@yappkit/front-module-map 0.1.8 → 0.2.0

package/lib/DeckGLOverlay.js

@@ -0,0 +1,76 @@
+import { defineComponent as e, inject as t, onUnmounted as n, toRefs as r, watch as i } from "vue";
+var a = class {
+	constructor({ unwatchFn: e, trackedIn: t = null }) {
+		this.overlay = null, this.watching = {
+			options: !1,
+			layers: !1
+		}, this.unwatchFn = e, this.trackedIn = t;
+	}
+	destroy() {
+		if (this.trackedIn) {
+			let e = this.trackedIn.indexOf(this);
+			e !== -1 && this.trackedIn.splice(e, 1), this.trackedIn = null;
+		}
+		for (let e of this.unwatchFn) e();
+		this.unwatchFn = [], this.overlay &&= (this._detach(), null);
+	}
+	watchOptions(e, t = {}) {
+		if (!this.overlay) throw Error("overlay should be set");
+		if (this.watching.options) {
+			console.warn(`No need to call ${this.constructor.name}.watchOptions(). options are already being watched`);
+			return;
+		}
+		this.watching.options = !0;
+		let n = i(e, () => {
+			this.overlay.setProps({ ...e.value });
+		}, {
+			immediate: !0,
+			deep: !0,
+			...t
+		});
+		this.unwatchFn.push(n);
+	}
+	watchLayers(e, t = {}) {
+		if (!this.overlay) throw Error("overlay should be set");
+		if (this.watching.layers) {
+			console.warn(`No need to call ${this.constructor.name}.watchLayers(). layers are already being watched`);
+			return;
+		}
+		this.watching.layers = !0;
+		let n = i(e, () => {
+			this.overlay.setProps({ layers: e.value });
+		}, {
+			immediate: !0,
+			...t
+		});
+		this.unwatchFn.push(n);
+	}
+}, o = (i) => e((e, { emit: a }) => {
+	let { options: o, layers: s } = r(e), c = t(i);
+	if (!c || !c.value) throw Error("map should exist");
+	let l = null, u = !1;
+	return c.value.setDeckGLOverlay(o.value).then((e) => {
+		if (u) {
+			e.destroy();
+			return;
+		}
+		l = e, e.watchOptions(o, o.value.watchOptionsOptions), e.watchLayers(s, o.value.watchLayersOptions), a("loaded", e);
+	}).catch((e) => {
+		u || a("error", e);
+	}), n(() => {
+		u = !0, l?.destroy();
+	}), () => {};
+}, {
+	props: {
+		options: {
+			type: Object,
+			default: () => ({})
+		},
+		layers: {
+			type: Array,
+			default: () => []
+		}
+	},
+	emits: ["loaded", "error"]
+});
+export { a as DeckGLOverlay, o as makeDeckGLOverlayComponent };

package/lib/providers/deckgl.js

@@ -1,111 +1,112 @@
-import { defineComponent as y, ref as d, toRefs as g, shallowRef as w, provide as l, computed as k, h as v, onMounted as L, onUnmounted as M, watch as h } from "vue";
-class D {
-  constructor() {
-    this.deckgl = null, this.map = null, this.watching = { options: !1, layers: !1 }, this.unwatchFn = [];
-  }
-  watchOptions(e, a = {}) {
-    if (!this.map)
-      throw new Error("map should be set");
-    if (this.watching.options) {
-      console.warn("No need to call DeckGLMap.watchOptions(). options are already being watched");
-      return;
-    }
-    this.watching.options = !0;
-    const t = h(e, () => {
-      this.map.setProps({ ...e.value });
-    }, {
-      immediate: !0,
-      deep: !0,
-      ...a
-    });
-    this.unwatchFn.push(t);
-  }
-  watchLayers(e, a = {}) {
-    if (!this.map)
-      throw new Error("map should be set");
-    if (this.watching.layers) {
-      console.warn("No need to call DeckGLMap.watchLayers(). layers are already being watched");
-      return;
-    }
-    this.watching.layers = !0;
-    const t = h(e, () => {
-      this.map.setProps({ layers: e.value });
-    }, {
-      immediate: !0,
-      ...a
-    });
-    this.unwatchFn.push(t);
-  }
-}
-class G {
-  constructor(e) {
-    this.deckgl = null;
-  }
-  get Map() {
-    return y(
-      (e, { emit: a, attrs: t, slots: c }) => {
-        const n = d(null), { options: o, layers: i } = g(e), r = w(null);
-        l("deckGLMap", r);
-        const u = w([]);
-        l("deckGLPrependLayers", u);
-        const f = k(() => [
-          ...u.value,
-          ...i.value
-        ]);
-        this.createMap(n, o.value).then((s) => {
-          r.value = s, s.watchOptions(o, o.value.watchOptionsOptions), s.watchLayers(f, o.value.watchLayersOptions), a("loaded", s);
-        });
-        const p = d([]);
-        return l("deckGLAppendVNodeFn", p), () => [v("div", { ...t, ref: n }, r.value ? c : []), p.value.map((s) => s())];
-      },
-      {
-        props: {
-          options: {
-            type: Object,
-            default: () => ({})
-          },
-          layers: {
-            type: Array,
-            default: () => []
-          }
-        },
-        emits: ["loaded"]
-      }
-    );
-  }
-  async loadDeckGL() {
-    if (!this.deckgl) {
-      const { Deck: e } = await import("deck.gl");
-      this.deckgl = { Deck: e };
-    }
-  }
-  async createMap(e, a = {}) {
-    const t = new D(), c = () => {
-      for (const n of t.unwatchFn)
-        n();
-      t.unwatchFn = [], t.map && (t.map.finalize(), t.map = null);
-    };
-    return new Promise((n, o) => {
-      L(async () => {
-        await this.loadDeckGL();
-        const i = () => {
-          if (!e.value)
-            throw new Error("Missing HTML element");
-          const r = h(e, () => {
-            e.value || (c(), r());
-          });
-          t.deckgl = this.deckgl, t.map = new this.deckgl.Deck({
-            parent: e.value,
-            ...a
-          }), n(t);
-        };
-        a.onMounted ? a.onMounted(i) : i();
-      }), M(() => {
-        c();
-      });
-    });
-  }
-}
-export {
-  G as default
+import { computed as e, defineComponent as t, h as n, onMounted as r, onUnmounted as i, provide as a, ref as o, shallowRef as s, toRefs as c, watch as l } from "vue";
+var u = class {
+	constructor() {
+		this.map = null, this.watching = {
+			options: !1,
+			layers: !1
+		}, this.unwatchFn = [];
+	}
+	watchOptions(e, t = {}) {
+		if (!this.map) throw Error("map should be set");
+		if (this.watching.options) {
+			console.warn("No need to call DeckGLMap.watchOptions(). options are already being watched");
+			return;
+		}
+		this.watching.options = !0;
+		let n = l(e, () => {
+			this.map.setProps({ ...e.value });
+		}, {
+			immediate: !0,
+			deep: !0,
+			...t
+		});
+		this.unwatchFn.push(n);
+	}
+	watchLayers(e, t = {}) {
+		if (!this.map) throw Error("map should be set");
+		if (this.watching.layers) {
+			console.warn("No need to call DeckGLMap.watchLayers(). layers are already being watched");
+			return;
+		}
+		this.watching.layers = !0;
+		let n = l(e, () => {
+			this.map.setProps({ layers: e.value });
+		}, {
+			immediate: !0,
+			...t
+		});
+		this.unwatchFn.push(n);
+	}
+}, d = class {
+	constructor() {
+		this.deckgl = null, this._MapComponent = null;
+	}
+	get Map() {
+		return this._MapComponent ??= t((t, { emit: r, attrs: i, slots: l }) => {
+			let u = o(null), { options: d, layers: f } = c(t), p = s(null);
+			a("deckGLMap", p);
+			let m = s([]);
+			a("deckGLPrependLayers", m);
+			let h = e(() => [...m.value, ...f.value]);
+			this.createMap(u, d.value).then((e) => {
+				p.value = e, e.watchOptions(d, d.value.watchOptionsOptions), e.watchLayers(h, d.value.watchLayersOptions), r("loaded", e);
+			}).catch((e) => {
+				e?.code !== "MAP_UNMOUNTED" && r("error", e);
+			});
+			let g = o([]);
+			return a("deckGLAppendVNodeFn", g), () => [n("div", {
+				...i,
+				ref: u
+			}, p.value ? l : []), g.value.map((e) => e())];
+		}, {
+			props: {
+				options: {
+					type: Object,
+					default: () => ({})
+				},
+				layers: {
+					type: Array,
+					default: () => []
+				}
+			},
+			emits: ["loaded", "error"]
+		}), this._MapComponent;
+	}
+	async loadDeckGL() {
+		if (!this.deckgl) {
+			let { Deck: e } = await import("@deck.gl/core");
+			this.deckgl = { Deck: e };
+		}
+	}
+	async createMap(e, t = {}) {
+		let n = new u(), a = () => {
+			for (let e of n.unwatchFn) e();
+			n.unwatchFn = [], n.map &&= (n.map.finalize(), null);
+		};
+		return new Promise((o, s) => {
+			r(() => {
+				let r = () => {
+					if (!e.value) {
+						let e = /* @__PURE__ */ Error("Missing HTML element");
+						throw s(e), e;
+					}
+					let r = l(e, () => {
+						e.value || (a(), r());
+					});
+					n.map = new this.deckgl.Deck({
+						parent: e.value,
+						...t
+					}), o(n);
+				};
+				(async () => {
+					await this.loadDeckGL(), t.onMounted ? t.onMounted(r) : r();
+				})().catch(s);
+			}), i(() => {
+				a();
+				let e = /* @__PURE__ */ Error("Map unmounted before load");
+				e.code = "MAP_UNMOUNTED", s(e);
+			});
+		});
+	}
 };
+export { d as default };