@cn-map/gaode-vue 0.0.0 → 0.0.1

package/dist/loca.js

@@ -0,0 +1,1288 @@
+import { a as toDefinedRaw, i as shallowReactiveOmit, o as use_event_listeners_default, r as useMapInstance } from "./context-BEyZOuBr.js";
+import { computed, defineComponent, inject, onUnmounted, provide, renderSlot, shallowRef, toRaw, watch, watchEffect } from "vue";
+import { clone, 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 AMap_Symbol_Loca = Symbol("Loca");
+/**
+* 设置Loca实例Context
+* @param {ShallowRef<Nullable<Loca.Container>>} loca - Loca实例ref
+*/
+function setLocaContext(loca) {
+	provide(AMap_Symbol_Loca, loca);
+}
+/**
+* 获取Loca实例
+* @returns {ShallowRef<Nullable<Loca.Container>>} - Loca实例ref
+*/
+function useLoca() {
+	const context = inject(AMap_Symbol_Loca);
+	if (!context) throw lostContextError("`Loca.Container`");
+	return context;
+}
+/**
+* 获取Loca实例
+* @returns {ComputedRef<Nullable<Loca.Container>>} - Loca实例ref
+*/
+function useLocaInstance(props) {
+	const loca = inject(AMap_Symbol_Loca, shallowRef(null));
+	return computed(() => props.loca ?? loca.value);
+}
+// src/loca/loca/loca.vue
+var loca_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.Container",
+	inheritAttrs: false,
+	__name: "loca",
+	props: { map: {} },
+	setup(__props, { expose: __expose }) {
+		const map = useMapInstance(__props);
+		const loca = shallowRef(null);
+		setLocaContext(loca);
+		watchEffect((onCleanup) => {
+			if (!map.value) return;
+			loca.value = new Loca.Container({ map: map.value });
+			onCleanup(() => {
+				if (loca.value?.map) {
+					AMap.Event.clearListeners(loca.value?.map, "firstPaint");
+					loca.value?.destroy();
+				}
+				loca.value = null;
+			});
+		});
+		__expose({ instance: loca });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+// src/loca/source/data-source/context.ts
+const AMap_Symbol_DataSource = Symbol("DataSource");
+/**
+* 设置数据源实例Context
+* @param {ShallowRef<Nullable<Loca.GeoBufferSource | Loca.GeoJSONSource>>} dataSource - 数据源实例ref
+*/
+function setDataSourceContext(dataSource) {
+	provide(AMap_Symbol_DataSource, dataSource);
+}
+/**
+* 获取数据源实例
+* @returns {ShallowRef<Nullable<Loca.GeoBufferSource | Loca.GeoJSONSource>>} - 数据源实例ref
+*/
+function useDataSource() {
+	const context = inject(AMap_Symbol_DataSource);
+	if (!context) throw lostContextError("`Loca.GeoBufferSource`/`Loca.GeoJSONSource`");
+	return context;
+}
+/**
+* 获取数据源实例
+* @returns {ComputedRef<Nullable<Loca.GeoBufferSource | Loca.GeoJSONSource>>} - 数据源实例ref
+*/
+function useDataSourceInstance(props) {
+	const source = inject(AMap_Symbol_DataSource, shallowRef(null));
+	return computed(() => props.source ?? source.value);
+}
+// src/loca/source/data-source/data-source.ts
+function toSnapshot(data, url) {
+	if (hasData(data)) return {
+		mode: "data",
+		value: toRaw(data)
+	};
+	if (hasUrl(url)) return {
+		mode: "url",
+		value: url
+	};
+	return {
+		mode: "idle",
+		value: void 0
+	};
+}
+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 useDataSourceAttributes(source, props) {
+	watch(() => [props.data, props.url], ([data, url], oldValue) => {
+		const currentSource = source.value;
+		const prev = oldValue ? toSnapshot(oldValue[0], oldValue[1]) : void 0;
+		const next = toSnapshot(data, url);
+		if (next.mode === "data") currentSource.options.data = clone(toRaw(next.value), true);
+		else delete currentSource.options.data;
+		if (next.mode === "url") {
+			currentSource.options.url = next.value;
+			currentSource.url = next.value;
+		} else {
+			delete currentSource.options.url;
+			currentSource.url = void 0;
+		}
+		if (next.mode === "idle") {
+			if (prev && prev?.mode !== "idle") {
+				currentSource.abort?.();
+				currentSource.dataset = [];
+				for (const layer of currentSource.layers) layer.receiveDataset?.(currentSource.dataset);
+			}
+		} else if (!prev) {
+			if (currentSource.status !== "loading" && currentSource.dataset.length === 0) currentSource.load();
+		} else if (prev.mode !== next.mode || prev.value !== next.value) reloadSource(currentSource);
+	}, { immediate: true });
+}
+// src/loca/layer/layer/layer.ts
+const layerEvents = [complete, loaded];
+function useLayerAttributes(layer, props, emits) {
+	patchLocaLayer();
+	const source = useDataSourceInstance(props);
+	watch(() => props.opacity, (val) => {
+		layer.value.setOpacity(val);
+	});
+	watch(() => props.zooms, (val) => {
+		layer.value.setZooms(clone(toRaw(val)));
+	});
+	watch(() => props.zIndex, (val) => {
+		layer.value.setzIndex(val);
+	});
+	watch(source, (val, _, onCleanup) => {
+		if (val) layer.value.setSource(val);
+		onCleanup(() => {
+			layer.value.source?.Mr(layer.value);
+		});
+	}, { immediate: true });
+	watch(() => props.style, (val) => {
+		if (val !== void 0) layer.value.setStyle(clone(toRaw(val)));
+	}, { immediate: true });
+	watch(() => props.visible, (val) => {
+		if (val !== void 0) {
+			if (val) layer.value.show(props.duration?.show, () => emits("show"));
+			else layer.value.hide(props.duration?.hide, () => emits("hide"));
+		}
+	}, { immediate: true });
+}
+// src/loca/layer/grid-layer/grid-layer.vue
+var grid_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.GridLayer",
+	inheritAttrs: false,
+	__name: "grid-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		acceptLight: {
+			type: Boolean,
+			default: void 0
+		},
+		cullface: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		hasSide: {
+			type: Boolean,
+			default: void 0
+		},
+		shininess: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const gridLayer = shallowRef(new Loca.GridLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(gridLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(gridLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(gridLayer.value);
+			});
+		});
+		use_event_listeners_default(gridLayer, emits, layerEvents);
+		onUnmounted(() => {
+			gridLayer.value?.destroy();
+		});
+		__expose({ instance: gridLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/heat-map-layer/heat-map-layer.vue
+var heat_map_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.HeatMapLayer",
+	inheritAttrs: false,
+	__name: "heat-map-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const heatMapLayer = shallowRef(new Loca.HeatMapLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(heatMapLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(heatMapLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(heatMapLayer.value);
+			});
+		});
+		use_event_listeners_default(heatMapLayer, emits, layerEvents);
+		onUnmounted(() => {
+			heatMapLayer.value?.destroy();
+		});
+		__expose({ instance: heatMapLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/hexagon-layer/hexagon-layer.vue
+var hexagon_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.HexagonLayer",
+	inheritAttrs: false,
+	__name: "hexagon-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		acceptLight: {
+			type: Boolean,
+			default: void 0
+		},
+		cullface: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		hasBottom: {
+			type: Boolean,
+			default: void 0
+		},
+		hasSide: {
+			type: Boolean,
+			default: void 0
+		},
+		shininess: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const hexagonLayer = shallowRef(new Loca.HexagonLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(hexagonLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(hexagonLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(hexagonLayer.value);
+			});
+		});
+		use_event_listeners_default(hexagonLayer, emits, layerEvents);
+		onUnmounted(() => {
+			hexagonLayer.value?.destroy();
+		});
+		__expose({ instance: hexagonLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/icon-layer/icon-layer.vue
+var icon_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.IconLayer",
+	inheritAttrs: false,
+	__name: "icon-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const iconLayer = shallowRef(new Loca.IconLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(iconLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(iconLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(iconLayer.value);
+			});
+		});
+		use_event_listeners_default(iconLayer, emits, layerEvents);
+		onUnmounted(() => {
+			iconLayer.value?.destroy();
+		});
+		__expose({ instance: iconLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/labels-layer/labels-layer.vue
+var labels_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.LabelsLayer",
+	inheritAttrs: false,
+	__name: "labels-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {},
+		allowCollision: {
+			type: Boolean,
+			default: void 0
+		},
+		collision: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const labelsLayer = shallowRef(new Loca.LabelsLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(labelsLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(labelsLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(labelsLayer.value);
+			});
+		});
+		watch(() => props.allowCollision, (val) => {
+			if (val !== void 0) labelsLayer.value.setAllowCollision(val);
+		});
+		watch(() => props.collision, (val) => {
+			if (val !== void 0) labelsLayer.value.setCollision(val);
+		});
+		use_event_listeners_default(labelsLayer, emits, layerEvents);
+		onUnmounted(() => {
+			labelsLayer.value?.destroy();
+		});
+		__expose({ instance: labelsLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/laser-layer/laser-layer.vue
+var laser_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.LaserLayer",
+	inheritAttrs: false,
+	__name: "laser-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const laserLayer = shallowRef(new Loca.LaserLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(laserLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(laserLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(laserLayer.value);
+			});
+		});
+		use_event_listeners_default(laserLayer, emits, layerEvents);
+		onUnmounted(() => {
+			laserLayer.value?.destroy();
+		});
+		__expose({ instance: laserLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/line-layer/line-layer.vue
+var line_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.LineLayer",
+	inheritAttrs: false,
+	__name: "line-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const lineLayer = shallowRef(new Loca.LineLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(lineLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(lineLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(lineLayer.value);
+			});
+		});
+		use_event_listeners_default(lineLayer, emits, layerEvents);
+		onUnmounted(() => {
+			lineLayer.value?.destroy();
+		});
+		__expose({ instance: lineLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/link-layer/link-layer.vue
+var link_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.LinkLayer",
+	inheritAttrs: false,
+	__name: "link-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const linkLayer = shallowRef(new Loca.LinkLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(linkLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(linkLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(linkLayer.value);
+			});
+		});
+		use_event_listeners_default(linkLayer, emits, layerEvents);
+		onUnmounted(() => {
+			linkLayer.value?.destroy();
+		});
+		__expose({ instance: linkLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/point-layer/point-layer.vue
+var point_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PointLayer",
+	inheritAttrs: false,
+	__name: "point-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		blend: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const pointLayer = shallowRef(new Loca.PointLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(pointLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(pointLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(pointLayer.value);
+			});
+		});
+		use_event_listeners_default(pointLayer, emits, layerEvents);
+		onUnmounted(() => {
+			pointLayer.value?.destroy();
+		});
+		__expose({ instance: pointLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/polygon-layer/polygon-layer.vue
+var polygon_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PolygonLayer",
+	inheritAttrs: false,
+	__name: "polygon-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		acceptLight: {
+			type: Boolean,
+			default: void 0
+		},
+		blockHide: {
+			type: Boolean,
+			default: void 0
+		},
+		cullface: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		hasBottom: {
+			type: Boolean,
+			default: void 0
+		},
+		hasSide: {
+			type: Boolean,
+			default: void 0
+		},
+		shininess: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const polygonLayer = shallowRef(new Loca.PolygonLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(polygonLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(polygonLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(polygonLayer.value);
+			});
+		});
+		use_event_listeners_default(polygonLayer, emits, layerEvents);
+		onUnmounted(() => {
+			polygonLayer.value?.destroy();
+		});
+		__expose({ instance: polygonLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/prism-layer/prism-layer.vue
+var prism_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PrismLayer",
+	inheritAttrs: false,
+	__name: "prism-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		acceptLight: {
+			type: Boolean,
+			default: void 0
+		},
+		cullface: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		hasSide: {
+			type: Boolean,
+			default: void 0
+		},
+		shininess: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const prismLayer = shallowRef(new Loca.PrismLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(prismLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(prismLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(prismLayer.value);
+			});
+		});
+		use_event_listeners_default(prismLayer, emits, layerEvents);
+		onUnmounted(() => {
+			prismLayer.value?.destroy();
+		});
+		__expose({ instance: prismLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/pulse-line-layer/pulse-line-layer.vue
+var pulse_line_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PulseLineLayer",
+	inheritAttrs: false,
+	__name: "pulse-line-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const pulseLineLayer = shallowRef(new Loca.PulseLineLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(pulseLineLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(pulseLineLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(pulseLineLayer.value);
+			});
+		});
+		use_event_listeners_default(pulseLineLayer, emits, layerEvents);
+		onUnmounted(() => {
+			pulseLineLayer.value?.destroy();
+		});
+		__expose({ instance: pulseLineLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/pulse-link-layer/pulse-link-layer.vue
+var pulse_link_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PulseLinkLayer",
+	inheritAttrs: false,
+	__name: "pulse-link-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const pulseLinkLayer = shallowRef(new Loca.PulseLinkLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(pulseLinkLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(pulseLinkLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(pulseLinkLayer.value);
+			});
+		});
+		use_event_listeners_default(pulseLinkLayer, emits, layerEvents);
+		onUnmounted(() => {
+			pulseLinkLayer.value?.destroy();
+		});
+		__expose({ instance: pulseLinkLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/scatter-layer/scatter-layer.vue
+var scatter_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.ScatterLayer",
+	inheritAttrs: false,
+	__name: "scatter-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const scatterLayer = shallowRef(new Loca.ScatterLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(scatterLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(scatterLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(scatterLayer.value);
+			});
+		});
+		use_event_listeners_default(scatterLayer, emits, layerEvents);
+		onUnmounted(() => {
+			scatterLayer.value?.destroy();
+		});
+		__expose({ instance: scatterLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/layer/z-marker-layer/z-marker-layer.vue
+var z_marker_layer_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.ZMarkerLayer",
+	inheritAttrs: false,
+	__name: "z-marker-layer",
+	props: {
+		source: {},
+		duration: {},
+		style: {},
+		depth: {
+			type: Boolean,
+			default: void 0
+		},
+		loca: {},
+		labelsLayerOptions: {},
+		map: {},
+		opacity: {},
+		preHandle: {
+			type: Boolean,
+			default: void 0
+		},
+		visible: {
+			type: Boolean,
+			default: void 0
+		},
+		zIndex: {},
+		zooms: {}
+	},
+	emits: [
+		"complete",
+		"loaded",
+		"show",
+		"hide"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "map", "loca");
+		const zMarkerLayer = shallowRef(new Loca.ZMarkerLayer(toDefinedRaw(restProps)));
+		useLayerAttributes(zMarkerLayer, props, emits);
+		watchEffect((onCleanup) => {
+			loca.value?.add(zMarkerLayer.value);
+			onCleanup(() => {
+				loca.value?.remove(zMarkerLayer.value);
+			});
+		});
+		use_event_listeners_default(zMarkerLayer, emits, layerEvents);
+		onUnmounted(() => {
+			zMarkerLayer.value?.destroy();
+		});
+		__expose({ instance: zMarkerLayer });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/legend/legend.vue
+var legend_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.Legend",
+	inheritAttrs: false,
+	__name: "legend",
+	props: {
+		dataMap: {},
+		loca: {},
+		style: {},
+		title: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "loca");
+		const legend = shallowRef(new Loca.Legend(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			if (!loca.value) return;
+			legend.value.addTo(loca.value);
+			onCleanup(() => {
+				legend.value.remove();
+			});
+		});
+		watch([() => props.style, () => props.title], ([style, title]) => {
+			legend.value.setStyle({
+				style: toRaw(style),
+				title: toRaw(title)
+			});
+		});
+		__expose({ instance: legend });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/light/ambient-light/ambient-light.vue
+var ambient_light_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.AmbientLight",
+	inheritAttrs: false,
+	__name: "ambient-light",
+	props: {
+		loca: {},
+		color: {},
+		intensity: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "loca");
+		const ambientLight = shallowRef(new Loca.AmbientLight(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			loca.value?.addLight(ambientLight.value);
+			onCleanup(() => {
+				loca.value?.removeLight(ambientLight.value);
+			});
+		});
+		watch(() => props.color, (val) => {
+			ambientLight.value.color = val;
+		});
+		watch(() => props.intensity, (val) => {
+			ambientLight.value.intensity = val;
+		});
+		__expose({ instance: ambientLight });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/light/directional-light/directional-light.vue
+var directional_light_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.DirectionalLight",
+	inheritAttrs: false,
+	__name: "directional-light",
+	props: {
+		loca: {},
+		color: {},
+		intensity: {},
+		target: {},
+		position: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "loca");
+		const directionalLight = shallowRef(new Loca.DirectionalLight(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			loca.value?.addLight(directionalLight.value);
+			onCleanup(() => {
+				loca.value?.removeLight(directionalLight.value);
+			});
+		});
+		watch(() => props.color, (val) => {
+			directionalLight.value.color = val;
+		});
+		watch(() => props.intensity, (val) => {
+			directionalLight.value.intensity = val;
+		});
+		watch(() => props.target, (val) => {
+			directionalLight.value.target = val;
+		});
+		watch(() => props.position, (val) => {
+			directionalLight.value.position = val;
+		});
+		__expose({ instance: directionalLight });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/light/point-light/point-light.vue
+var point_light_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.PointLight",
+	inheritAttrs: false,
+	__name: "point-light",
+	props: {
+		loca: {},
+		color: {},
+		intensity: {},
+		distance: {},
+		position: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const loca = useLocaInstance(props);
+		const restProps = shallowReactiveOmit(props, "loca");
+		const pointLight = shallowRef(new Loca.PointLight(toDefinedRaw(restProps)));
+		watchEffect((onCleanup) => {
+			loca.value?.addLight(pointLight.value);
+			onCleanup(() => {
+				loca.value?.removeLight(pointLight.value);
+			});
+		});
+		watch(() => props.color, (val) => {
+			pointLight.value.color = val;
+		});
+		watch(() => props.intensity, (val) => {
+			pointLight.value.intensity = val;
+		});
+		watch(() => props.distance, (val) => {
+			pointLight.value.distance = val;
+		});
+		watch(() => props.position, (val) => {
+			pointLight.value.position = val;
+		});
+		__expose({ instance: pointLight });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+// src/loca/source/geo-buffer-source/geo-buffer-source.vue
+var geo_buffer_source_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.GeoBufferSource",
+	inheritAttrs: false,
+	__name: "geo-buffer-source",
+	props: {
+		layer: {},
+		data: {},
+		url: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		patchGeoBufferSource();
+		const restProps = shallowReactiveOmit(props, "layer");
+		const geoBufferSource = shallowRef(new Loca.GeoBufferSource(toDefinedRaw(restProps)));
+		setDataSourceContext(geoBufferSource);
+		watchEffect((onCleanup) => {
+			if (!props.layer) return;
+			props.layer.setSource(geoBufferSource.value);
+			onCleanup(() => {
+				if (!props.layer) return;
+				geoBufferSource.value.Mr(props.layer);
+			});
+		});
+		useDataSourceAttributes(geoBufferSource, restProps);
+		onUnmounted(() => {
+			geoBufferSource.value.abort();
+			geoBufferSource.value.destroy();
+		});
+		__expose({ instance: geoBufferSource });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+// src/loca/source/geo-json-source/geo-json-source.vue
+var geo_json_source_default = /* @__PURE__ */ defineComponent({
+	name: "Loca.GeoJSONSource",
+	inheritAttrs: false,
+	__name: "geo-json-source",
+	props: {
+		layer: {},
+		data: {},
+		url: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		patchGeoJSONSource();
+		const restProps = shallowReactiveOmit(props, "layer");
+		const geoJSONSource = shallowRef(new Loca.GeoJSONSource(toDefinedRaw(restProps)));
+		setDataSourceContext(geoJSONSource);
+		watchEffect((onCleanup) => {
+			if (!props.layer) return;
+			props.layer.setSource(geoJSONSource.value);
+			onCleanup(() => {
+				if (!props.layer) return;
+				geoJSONSource.value.Mr(props.layer);
+			});
+		});
+		useDataSourceAttributes(geoJSONSource, restProps);
+		onUnmounted(() => {
+			geoJSONSource.value.abort();
+			geoJSONSource.value.destroy();
+		});
+		__expose({ instance: geoJSONSource });
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+export { ambient_light_default as AmbientLight, directional_light_default as DirectionalLight, geo_buffer_source_default as GeoBufferSource, geo_json_source_default as GeoJSONSource, grid_layer_default as GridLayer, heat_map_layer_default as HeatMapLayer, hexagon_layer_default as HexagonLayer, icon_layer_default as IconLayer, labels_layer_default as LabelsLayer, laser_layer_default as LaserLayer, legend_default as Legend, line_layer_default as LineLayer, link_layer_default as LinkLayer, loca_default as Loca, point_layer_default as PointLayer, point_light_default as PointLight, polygon_layer_default as PolygonLayer, prism_layer_default as PrismLayer, pulse_line_layer_default as PulseLineLayer, pulse_link_layer_default as PulseLinkLayer, scatter_layer_default as ScatterLayer, z_marker_layer_default as ZMarkerLayer, useDataSource, useLoca };