@cn-map/gaode-react 0.0.0-stage → 0.0.1

package/dist/loca.js

@@ -0,0 +1,784 @@
+import { a as splitProps, c as useEventListeners, o as syncProperty, r as useMapInstance, s as useLazyInit } from "./context-ChPGCKoP.js";
+import { createContext, use, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { clone, eventsToProps, lostContextError } from "@cn-map/gaode-shared/utils";
+import { complete, loaded } from "@cn-map/gaode-shared/const";
+import { patchGeoBufferSource, patchGeoJSONSource, patchLocaLayer } from "@cn-map/gaode-shared/patch";
+// src/loca/loca/context.ts
+const EMPTY$1 = Symbol("No Loca");
+const LocaContext = createContext(EMPTY$1);
+/**
+* 获取 Loca 容器实例 hook
+*/
+function useLoca() {
+	const loca = use(LocaContext);
+	if (loca === EMPTY$1) throw lostContextError("`Loca.Container`");
+	return loca;
+}
+/**
+* 获取合并props的 Loca 容器实例
+*/
+function useLocaInstance(locaInProps) {
+	const locaInCtx = use(LocaContext);
+	return locaInProps ?? (locaInCtx === EMPTY$1 ? null : locaInCtx);
+}
+// src/loca/loca/loca.tsx
+const Container = ({ ref, map: _map, ...props }) => {
+	const map = useMapInstance(_map);
+	const [loca, setLoca] = useState(null);
+	useLayoutEffect(() => {
+		if (!map) return;
+		const container = new Loca.Container({ map });
+		setLoca(container);
+		return () => {
+			if (container.map) {
+				AMap.Event.clearListeners(container.map, "firstPaint");
+				container.destroy();
+			}
+			setLoca(null);
+		};
+	}, [map]);
+	useImperativeHandle(ref, () => loca, [loca]);
+	return /* @__PURE__ */ jsx(LocaContext, {
+		value: loca,
+		children: props.children
+	});
+};
+// src/loca/source/data-source/context.ts
+const EMPTY = Symbol("No DataSource");
+const DataSourceContext = createContext(EMPTY);
+/**
+* 获取 Loca 数据源实例 hook
+*/
+function useDataSource() {
+	const context = use(DataSourceContext);
+	if (context === EMPTY) throw lostContextError("`Loca.GeoBufferSource`/`Loca.GeoJSONSource`");
+	return context;
+}
+/**
+* 获取合并props的 Loca 数据源实例
+*/
+function useDataSourceInstance(dataSourceInProps) {
+	const dataSourceInCtx = use(DataSourceContext);
+	return dataSourceInProps ?? (dataSourceInCtx === EMPTY ? null : dataSourceInCtx);
+}
+// src/loca/source/data-source/data-source.ts
+function hasData(data) {
+	return data !== void 0;
+}
+function hasUrl(url) {
+	return typeof url === "string" && url.length > 0;
+}
+function reloadSource(source) {
+	for (const layer of source.layers) layer.ll?.destroy();
+	source.abort?.();
+	source.load();
+}
+function syncDataSourceAttributes(source, props, prevRef) {
+	const mode = hasData(props.data) ? "data" : hasUrl(props.url) ? "url" : "idle";
+	const activeValue = mode === "data" ? props.data : props.url;
+	if (hasData(props.data)) source.options.data = clone(props.data, true);
+	else delete source.options.data;
+	if (hasUrl(props.url)) {
+		source.options.url = props.url;
+		source.url = props.url;
+	} else {
+		delete source.options.url;
+		source.url = void 0;
+	}
+	if (mode === "idle") {
+		if (prevRef.current && prevRef.current.mode !== "idle") {
+			source.abort?.();
+			source.dataset = [];
+			for (const layer of source.layers) layer.receiveDataset?.(source.dataset);
+		}
+	} else if (!prevRef.current) {
+		if (source.status !== "loading" && source.dataset.length === 0) source.load();
+	} else if (prevRef.current.mode !== mode || prevRef.current.value !== activeValue) reloadSource(source);
+	else if (source.dataset.length === 0) {
+		if (source.status !== "loading") source.load();
+	}
+	prevRef.current = {
+		mode,
+		value: activeValue
+	};
+}
+function useDataSourceAttributes(source, props) {
+	const prevRef = useRef(void 0);
+	useLayoutEffect(() => {
+		syncDataSourceAttributes(source, props, prevRef);
+	}, [
+		props.data,
+		props.url,
+		source
+	]);
+}
+// src/loca/layer/layer/layer.ts
+const layerEvents = [complete, loaded];
+function useLayerAttributes(getLayer, props) {
+	patchLocaLayer();
+	const { opacity, zooms, zIndex, source, style, visible, duration, onShow, onHide } = props;
+	useLayoutEffect(() => {
+		getLayer()?.setOpacity(opacity);
+	}, [opacity]);
+	useLayoutEffect(() => {
+		getLayer()?.setZooms(clone(zooms));
+	}, [zooms]);
+	useLayoutEffect(() => {
+		getLayer()?.setzIndex(zIndex);
+	}, [zIndex]);
+	useLayoutEffect(() => {
+		const layer = getLayer();
+		if (source) layer?.setSource(source);
+		return () => {
+			layer?.source?.Mr(layer);
+		};
+	}, [source]);
+	useLayoutEffect(() => {
+		if (style !== void 0) getLayer()?.setStyle(clone(style));
+	}, [style]);
+	useLayoutEffect(() => {
+		const layer = getLayer();
+		if (visible !== void 0 && layer?.visible !== visible) {
+			if (visible) layer?.show(duration?.show, onShow);
+			else layer?.hide(duration?.hide, onHide);
+		}
+	}, [
+		visible,
+		duration,
+		onShow,
+		onHide
+	]);
+}
+// src/loca/layer/grid-layer/grid-layer.ts
+const GridLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const gridLayerRef = useRef(null);
+	const getGridLayer = useCallback(() => gridLayerRef.current, []);
+	useLayoutEffect(() => {
+		gridLayerRef.current = new Loca.GridLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = gridLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			gridLayerRef.current?.destroy();
+			gridLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getGridLayer, []);
+	useLayerAttributes(getGridLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getGridLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/heat-map-layer/heat-map-layer.ts
+const HeatMapLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const heatMapLayerRef = useRef(null);
+	const getHeatMapLayer = useCallback(() => heatMapLayerRef.current, []);
+	useLayoutEffect(() => {
+		heatMapLayerRef.current = new Loca.HeatMapLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = heatMapLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			heatMapLayerRef.current?.destroy();
+			heatMapLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getHeatMapLayer, []);
+	useLayerAttributes(getHeatMapLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getHeatMapLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/hexagon-layer/hexagon-layer.ts
+const HexagonLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const hexagonLayerRef = useRef(null);
+	const getHexagonLayer = useCallback(() => hexagonLayerRef.current, []);
+	useLayoutEffect(() => {
+		hexagonLayerRef.current = new Loca.HexagonLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = hexagonLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			hexagonLayerRef.current?.destroy();
+			hexagonLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getHexagonLayer, []);
+	useLayerAttributes(getHexagonLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getHexagonLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/icon-layer/icon-layer.ts
+const IconLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const iconLayerRef = useRef(null);
+	const getIconLayer = useCallback(() => iconLayerRef.current, []);
+	useLayoutEffect(() => {
+		iconLayerRef.current = new Loca.IconLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = iconLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			iconLayerRef.current?.destroy();
+			iconLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getIconLayer, []);
+	useLayerAttributes(getIconLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getIconLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/labels-layer/labels-layer.ts
+const LabelsLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const labelsLayerRef = useRef(null);
+	const getLabelsLayer = useCallback(() => labelsLayerRef.current, []);
+	useLayoutEffect(() => {
+		labelsLayerRef.current = new Loca.LabelsLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = labelsLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			labelsLayerRef.current?.destroy();
+			labelsLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getLabelsLayer, []);
+	const { allowCollision, collision, ...layerRestProps } = restProps;
+	useLayoutEffect(() => {
+		if (allowCollision !== void 0) getLabelsLayer()?.setAllowCollision(allowCollision);
+	}, [allowCollision]);
+	useLayoutEffect(() => {
+		if (collision !== void 0) getLabelsLayer()?.setCollision(collision);
+	}, [collision]);
+	useLayerAttributes(getLabelsLayer, {
+		...layerRestProps,
+		source
+	});
+	useEventListeners(getLabelsLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/laser-layer/laser-layer.ts
+const LaserLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const laserLayerRef = useRef(null);
+	const getLaserLayer = useCallback(() => laserLayerRef.current, []);
+	useLayoutEffect(() => {
+		laserLayerRef.current = new Loca.LaserLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = laserLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			laserLayerRef.current?.destroy();
+			laserLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getLaserLayer, []);
+	useLayerAttributes(getLaserLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getLaserLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/line-layer/line-layer.ts
+const LineLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const lineLayerRef = useRef(null);
+	const getLineLayer = useCallback(() => lineLayerRef.current, []);
+	useLayoutEffect(() => {
+		lineLayerRef.current = new Loca.LineLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = lineLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			lineLayerRef.current?.destroy();
+			lineLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getLineLayer, []);
+	useLayerAttributes(getLineLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getLineLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/link-layer/link-layer.ts
+const LinkLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const linkLayerRef = useRef(null);
+	const getLinkLayer = useCallback(() => linkLayerRef.current, []);
+	useLayoutEffect(() => {
+		linkLayerRef.current = new Loca.LinkLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = linkLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			linkLayerRef.current?.destroy();
+			linkLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getLinkLayer, []);
+	useLayerAttributes(getLinkLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getLinkLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/point-layer/point-layer.ts
+const PointLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const pointLayerRef = useRef(null);
+	const getPointLayer = useCallback(() => pointLayerRef.current, []);
+	useLayoutEffect(() => {
+		pointLayerRef.current = new Loca.PointLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = pointLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			pointLayerRef.current?.destroy();
+			pointLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getPointLayer, []);
+	useLayerAttributes(getPointLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getPointLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/polygon-layer/polygon-layer.ts
+const PolygonLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const polygonLayerRef = useRef(null);
+	const getPolygonLayer = useCallback(() => polygonLayerRef.current, []);
+	useLayoutEffect(() => {
+		polygonLayerRef.current = new Loca.PolygonLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = polygonLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			polygonLayerRef.current?.destroy();
+			polygonLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getPolygonLayer, []);
+	useLayerAttributes(getPolygonLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getPolygonLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/prism-layer/prism-layer.ts
+const PrismLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const prismLayerRef = useRef(null);
+	const getPrismLayer = useCallback(() => prismLayerRef.current, []);
+	useLayoutEffect(() => {
+		prismLayerRef.current = new Loca.PrismLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = prismLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			prismLayerRef.current?.destroy();
+			prismLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getPrismLayer, []);
+	useLayerAttributes(getPrismLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getPrismLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/pulse-line-layer/pulse-line-layer.ts
+const PulseLineLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const pulseLineLayerRef = useRef(null);
+	const getPulseLineLayer = useCallback(() => pulseLineLayerRef.current, []);
+	useLayoutEffect(() => {
+		pulseLineLayerRef.current = new Loca.PulseLineLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = pulseLineLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			pulseLineLayerRef.current?.destroy();
+			pulseLineLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getPulseLineLayer, []);
+	useLayerAttributes(getPulseLineLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getPulseLineLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/pulse-link-layer/pulse-link-layer.ts
+const PulseLinkLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const pulseLinkLayerRef = useRef(null);
+	const getPulseLinkLayer = useCallback(() => pulseLinkLayerRef.current, []);
+	useLayoutEffect(() => {
+		pulseLinkLayerRef.current = new Loca.PulseLinkLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = pulseLinkLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			pulseLinkLayerRef.current?.destroy();
+			pulseLinkLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getPulseLinkLayer, []);
+	useLayerAttributes(getPulseLinkLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getPulseLinkLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/scatter-layer/scatter-layer.ts
+const ScatterLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const scatterLayerRef = useRef(null);
+	const getScatterLayer = useCallback(() => scatterLayerRef.current, []);
+	useLayoutEffect(() => {
+		scatterLayerRef.current = new Loca.ScatterLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = scatterLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			scatterLayerRef.current?.destroy();
+			scatterLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getScatterLayer, []);
+	useLayerAttributes(getScatterLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getScatterLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/layer/z-marker-layer/z-marker-layer.ts
+const ZMarkerLayer = ({ ref, map, loca: _loca, source: _source, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const source = useDataSourceInstance(_source);
+	const [eventProps, restProps] = splitProps(props, eventsToProps(layerEvents));
+	const zMarkerLayerRef = useRef(null);
+	const getZMarkerLayer = useCallback(() => zMarkerLayerRef.current, []);
+	useLayoutEffect(() => {
+		zMarkerLayerRef.current = new Loca.ZMarkerLayer(restProps);
+	}, []);
+	useEffect(() => {
+		if (!loca) return;
+		const layer = zMarkerLayerRef.current;
+		loca.add(layer);
+		return () => {
+			loca.remove(layer);
+		};
+	}, [loca]);
+	useEffect(() => {
+		return () => {
+			zMarkerLayerRef.current?.destroy();
+			zMarkerLayerRef.current = null;
+		};
+	}, []);
+	useImperativeHandle(ref, getZMarkerLayer, []);
+	useLayerAttributes(getZMarkerLayer, {
+		...restProps,
+		source
+	});
+	useEventListeners(getZMarkerLayer, eventProps, layerEvents);
+	return null;
+};
+// src/loca/legend/legend.ts
+const Legend = ({ ref, loca: _loca, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const legend = useLazyInit(() => new Loca.Legend(props));
+	useLayoutEffect(() => {
+		if (!loca) return;
+		legend.addTo(loca);
+		return () => {
+			legend.remove();
+		};
+	}, [loca]);
+	useImperativeHandle(ref, () => legend, []);
+	const { style, title } = props;
+	useLayoutEffect(() => {
+		legend.setStyle({
+			style,
+			title
+		});
+	}, [style, title]);
+	return null;
+};
+// src/loca/light/ambient-light/ambient-light.ts
+const AmbientLight = ({ ref, loca: _loca, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const ambientLight = useLazyInit(() => new Loca.AmbientLight(props));
+	useLayoutEffect(() => {
+		if (!loca) return;
+		loca.addLight(ambientLight);
+		return () => {
+			loca.removeLight(ambientLight);
+		};
+	}, [loca]);
+	useImperativeHandle(ref, () => ambientLight, []);
+	const { color, intensity } = props;
+	useLayoutEffect(() => {
+		syncProperty(ambientLight, "color", color);
+	}, [color]);
+	useLayoutEffect(() => {
+		syncProperty(ambientLight, "intensity", intensity);
+	}, [intensity]);
+	return null;
+};
+// src/loca/light/directional-light/directional-light.ts
+const DirectionalLight = ({ ref, loca: _loca, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const directionalLight = useLazyInit(() => new Loca.DirectionalLight(props));
+	useLayoutEffect(() => {
+		if (!loca) return;
+		loca.addLight(directionalLight);
+		return () => {
+			loca.removeLight(directionalLight);
+		};
+	}, [loca]);
+	useImperativeHandle(ref, () => directionalLight, []);
+	const { color, intensity, target, position } = props;
+	useLayoutEffect(() => {
+		syncProperty(directionalLight, "color", color);
+	}, [color]);
+	useLayoutEffect(() => {
+		syncProperty(directionalLight, "intensity", intensity);
+	}, [intensity]);
+	useLayoutEffect(() => {
+		syncProperty(directionalLight, "target", target);
+	}, [target]);
+	useLayoutEffect(() => {
+		syncProperty(directionalLight, "position", position);
+	}, [position]);
+	return null;
+};
+// src/loca/light/point-light/point-light.ts
+const PointLight = ({ ref, loca: _loca, ...props }) => {
+	const loca = useLocaInstance(_loca);
+	const pointLight = useLazyInit(() => new Loca.PointLight(props));
+	useLayoutEffect(() => {
+		if (!loca) return;
+		loca.addLight(pointLight);
+		return () => {
+			loca.removeLight(pointLight);
+		};
+	}, [loca]);
+	useImperativeHandle(ref, () => pointLight, []);
+	const { color, intensity, distance, position } = props;
+	useLayoutEffect(() => {
+		syncProperty(pointLight, "color", color);
+	}, [color]);
+	useLayoutEffect(() => {
+		syncProperty(pointLight, "intensity", intensity);
+	}, [intensity]);
+	useLayoutEffect(() => {
+		syncProperty(pointLight, "distance", distance);
+	}, [distance]);
+	useLayoutEffect(() => {
+		syncProperty(pointLight, "position", position);
+	}, [position]);
+	return null;
+};
+// src/loca/source/geo-buffer-source/geo-buffer-source.tsx
+const GeoBufferSource = ({ ref, children, ...props }) => {
+	patchGeoBufferSource();
+	const { layer, ...restProps } = props;
+	const geoBufferSource = useLazyInit(() => new Loca.GeoBufferSource(restProps));
+	useLayoutEffect(() => {
+		if (!layer) return;
+		layer.setSource(geoBufferSource);
+		return () => {
+			geoBufferSource.Mr(layer);
+		};
+	}, [layer]);
+	useEffect(() => {
+		return () => {
+			geoBufferSource.abort();
+		};
+	}, []);
+	useImperativeHandle(ref, () => geoBufferSource, []);
+	useDataSourceAttributes(geoBufferSource, props);
+	return /* @__PURE__ */ jsx(DataSourceContext, {
+		value: geoBufferSource,
+		children
+	});
+};
+// src/loca/source/geo-json-source/geo-json-source.tsx
+const GeoJSONSource = ({ ref, children, ...props }) => {
+	patchGeoJSONSource();
+	const { layer, ...restProps } = props;
+	const geoJSONSource = useLazyInit(() => new Loca.GeoJSONSource(restProps));
+	useLayoutEffect(() => {
+		if (!layer) return;
+		layer.setSource(geoJSONSource);
+		return () => {
+			geoJSONSource.Mr(layer);
+		};
+	}, [layer]);
+	useEffect(() => {
+		return () => {
+			geoJSONSource.abort();
+		};
+	}, []);
+	useImperativeHandle(ref, () => geoJSONSource, []);
+	useDataSourceAttributes(geoJSONSource, props);
+	return /* @__PURE__ */ jsx(DataSourceContext, {
+		value: geoJSONSource,
+		children
+	});
+};
+export { AmbientLight, DirectionalLight, GeoBufferSource, GeoJSONSource, GridLayer, HeatMapLayer, HexagonLayer, IconLayer, LabelsLayer, LaserLayer, Legend, LineLayer, LinkLayer, Container as Loca, PointLayer, PointLight, PolygonLayer, PrismLayer, PulseLineLayer, PulseLinkLayer, ScatterLayer, ZMarkerLayer, useDataSource, useLoca };