@delta10/atlas-sdk 0.1.11 → 0.1.12

package/dist/components/Map.vue2.js

@@ -0,0 +1,522 @@
+import { defineComponent as he, ref as c, computed as h, onMounted as ke, openBlock as a, createElementBlock as F, createVNode as d, unref as s, withCtx as b, createBlock as f, normalizeStyle as Se, createCommentVNode as p, Fragment as W, renderList as H, mergeProps as _e, createElementVNode as g, normalizeClass as J, Transition as Q } from "vue";
+import { OlMap as Oe, OlProjectionRegister as Fe, OlView as Ie, OlFeature as Ce, OlOverlay as Me } from "vue3-openlayers/map";
+import { OlTileLayer as X, OlVectorLayer as Te } from "vue3-openlayers/layers";
+import { OlSourceTileWMS as ze, OlSourceWMTS as xe, OlSourceVector as Pe } from "vue3-openlayers/sources";
+import { OlGeomPoint as Be, OlGeomPolygon as je } from "vue3-openlayers/geometries";
+import { OlStyle as Ae } from "vue3-openlayers/styles";
+import { OlInteractionSelect as Ne, OlInteractionModify as Ve, OlInteractionSnap as Ze } from "vue3-openlayers/interactions";
+import { epsg28992 as A } from "../utils/projections.js";
+import { optionsFromCapabilities as Re } from "ol/source/WMTS";
+import Ge from "ol/format/WMTSCapabilities";
+import { Style as $, Fill as D, Stroke as U, Circle as We, Text as $e } from "ol/style";
+import { boundingExtent as De } from "ol/extent";
+import { unByKey as Ue } from "ol/Observable";
+import { Collection as Ke } from "ol";
+import "ol/geom";
+import Ye from "../assets/icons/map.svg.js";
+import qe from "../assets/icons/layers.svg.js";
+import He from "../assets/icons/plus.svg.js";
+import Je from "../assets/icons/minus.svg.js";
+import Qe from "./panels/BaseLayers.vue.js";
+import Xe from "./panels/Layers.vue.js";
+const Ee = { class: "map-container" }, et = { class: "bottom-left-panels" }, tt = {
+  key: 0,
+  class: "layers-control"
+}, ot = ["aria-expanded"], nt = { class: "bottom-right-panels" }, it = {
+  key: 0,
+  class: "base-layers-control"
+}, st = ["aria-expanded"], rt = { class: "zoom-panel" }, Ct = /* @__PURE__ */ he({
+  __name: "Map",
+  props: {
+    layers: { default: () => [] },
+    baseLayers: { default: () => [] },
+    toggleableLayers: { default: () => [] },
+    interactions: {},
+    zoom: { default: 10 },
+    center: { default: () => [12e4, 487e3] }
+  },
+  emits: ["featureSelected", "featureDeselected", "featureModified", "mapClicked", "modifyCancelled"],
+  setup(_, { expose: E, emit: ee }) {
+    const i = _, z = ee, x = c(), w = c(), N = c(), te = c({}), V = c({}), I = c(!1), C = c(!1), O = c(null), M = c(/* @__PURE__ */ new Set()), Z = c(!1), T = c(null), L = c(null), P = c(null), B = c(null), k = c(null), K = h(() => k.value), S = c(
+      new globalThis.Map()
+    ), Y = (e, o, t, n) => {
+      if (!e) return;
+      if (e instanceof $ || typeof e == "function")
+        return e;
+      const r = {}, l = (m) => {
+        if (Array.isArray(m)) {
+          const [y, ...u] = m;
+          switch (y) {
+            case "get":
+              return o?.getProperties()?.[u[0]] ?? null;
+            case "case":
+              for (let v = 0; v < u.length - 1; v += 2)
+                if (l(u[v]))
+                  return l(u[v + 1]);
+              return l(u[u.length - 1]);
+            case "==":
+              return l(u[0]) === l(u[1]);
+            case "coalesce":
+              for (const v of u) {
+                const G = l(v);
+                if (G != null) return G;
+              }
+              return null;
+            default:
+              return m;
+          }
+        }
+        return m;
+      };
+      if (e["fill-color"] && (r.fill = new D({ color: l(e["fill-color"]) })), (e["stroke-color"] || e["stroke-width"]) && (r.stroke = new U({
+        color: l(e["stroke-color"]) || "#3399CC",
+        width: l(e["stroke-width"]) || 1.25
+      })), e["circle-radius"] || e["circle-fill-color"] || e["circle-stroke-color"]) {
+        const m = l(e["circle-radius"]) || 5, y = l(e["circle-fill-color"]), u = l(e["circle-stroke-color"]) || "#3399CC", v = l(e["circle-stroke-width"]) || 1.25;
+        r.image = new We({
+          radius: m,
+          fill: y ? new D({ color: y }) : void 0,
+          stroke: new U({ color: u, width: v })
+        });
+      }
+      if (e["text-value"]) {
+        const m = l(e["text-value"]);
+        m && (r.text = new $e({
+          text: String(m),
+          fill: new D({ color: "#000" }),
+          stroke: new U({ color: "#fff", width: 2 })
+        }));
+      }
+      return new $(r);
+    }, oe = (e) => typeof e == "function" ? e : e instanceof $ ? (o, t, n) => [e] : (o, t, n) => {
+      const r = Y(e, o);
+      return r ? [r] : void 0;
+    }, ne = h(() => i.layers.map((e) => {
+      if (e.type === "wmts") {
+        const o = S.value.get(e.options.identifier);
+        return {
+          type: "wmts",
+          identifier: e.options.identifier,
+          options: o || null
+        };
+      } else return e.type === "wms" ? {
+        type: "wms",
+        identifier: e.options.identifier,
+        wmsUrl: e.options.url,
+        layerName: e.options.layer
+      } : {
+        type: "vector",
+        identifier: e.options.identifier,
+        options: e.options,
+        style: e.options.style,
+        styleFunction: e.options.styleFunction
+      };
+    })), j = h(() => {
+      if (!O.value || !i.baseLayers)
+        return null;
+      const e = i.baseLayers.find(
+        (o) => o.options.identifier === O.value
+      );
+      return !e || e.type === "wmts" && !S.value.get(e.options.identifier) ? null : e;
+    }), ie = h(() => j.value && S.value.get(j.value.options.identifier) || null), se = h(() => (i.toggleableLayers || []).filter(
+      (e) => M.value.has(e.options.identifier)
+    ).map((e) => e.type === "wms" ? {
+      type: "wms",
+      identifier: e.options.identifier,
+      wmsUrl: e.options.url,
+      layerName: e.options.layer
+    } : e.type === "wmts" ? {
+      type: "wmts",
+      identifier: e.options.identifier,
+      wmtsOptions: S.value.get(e.options.identifier)
+    } : e.type === "vector" ? {
+      type: "vector",
+      identifier: e.options.identifier,
+      options: e.options,
+      style: e.options.style,
+      styleFunction: e.options.styleFunction
+    } : {
+      ...e,
+      identifier: e.options.identifier
+    })), re = h(() => {
+      const e = [];
+      if (j.value) {
+        const n = j.value;
+        n.type === "wmts" ? e.push({
+          type: "wmts",
+          identifier: n.options.identifier,
+          wmtsOptions: ie.value,
+          zIndex: 0
+        }) : n.type === "wms" ? e.push({
+          type: "wms",
+          identifier: n.options.identifier,
+          wmsUrl: n.options.url,
+          layerName: n.options.layer,
+          zIndex: 0
+        }) : n.type === "vector" && e.push({
+          type: "vector",
+          identifier: n.options.identifier,
+          options: n.options,
+          style: n.options.style,
+          styleFunction: n.options.styleFunction,
+          zIndex: 0
+        });
+      }
+      const o = se.value.map((n, r) => ({
+        ...n,
+        zIndex: r + 10
+      })), t = ne.value.map((n, r) => ({
+        ...n,
+        zIndex: o.length + r + 20
+      }));
+      return [...e, ...o, ...t];
+    }), ae = () => {
+      I.value = !I.value;
+    }, le = () => {
+      C.value = !C.value;
+    }, ce = (e) => {
+      M.value.has(e) ? M.value.delete(e) : M.value.add(e);
+    }, ue = (e) => {
+      O.value = e;
+    }, fe = () => {
+      if (w.value?.view) {
+        const e = w.value.view, o = e.getZoom(), t = e.getMaxZoom();
+        typeof o == "number" && o < t && e.animate({ zoom: o + 1, duration: 250 });
+      }
+    }, de = () => {
+      if (w.value?.view) {
+        const e = w.value.view, o = e.getZoom(), t = e.getMinZoom();
+        typeof o == "number" && o > t && e.animate({ zoom: o - 1, duration: 250 });
+      }
+    }, R = async (e, o, t) => {
+      try {
+        const r = await (await fetch(e)).text(), l = new Ge().read(r), m = t ? [t, "image/jpeg", "image/png"] : ["image/png", "image/jpeg"];
+        let y = null;
+        for (const u of m)
+          try {
+            if (y = Re(l, {
+              layer: o,
+              matrixSet: "EPSG:28992",
+              projection: "EPSG:28992",
+              format: u,
+              crossOrigin: "anonymous",
+              style: "default"
+            }), y) break;
+          } catch (v) {
+            console.warn(`Format ${u} failed for layer ${o}:`, v);
+          }
+        return y && (y.style = "default"), y;
+      } catch (n) {
+        return console.error("Failed to fetch WMTS capabilities:", n), null;
+      }
+    }, pe = (e) => {
+      if (!e || e.length === 0 || !w.value?.view) return;
+      const o = [];
+      for (const t of e)
+        if (t.type === "Point")
+          o.push(t.coordinates);
+        else if (t.type === "Polygon") {
+          const n = t.coordinates;
+          for (const r of n)
+            for (const l of r)
+              o.push(l);
+        }
+      if (o.length > 0) {
+        const t = De(o);
+        w.value.view.fit(t, {
+          padding: [50, 50, 50, 50]
+        });
+      }
+    };
+    ke(async () => {
+      if (k.value = new Ke([]), !O.value && i.baseLayers && i.baseLayers.length > 0) {
+        const e = i.baseLayers[0];
+        e?.options.identifier && (O.value = e.options.identifier);
+      }
+      await new Promise((e) => setTimeout(e, 100)), x.value?.map && x.value.map.on("singleclick", (e) => {
+        z("mapClicked", {
+          coordinate: e.coordinate,
+          pixel: e.pixel
+        });
+      });
+      for (const e of i.layers.filter((o) => o.type === "wmts"))
+        if (e.options.url) {
+          const o = await R(
+            e.options.url,
+            e.options.identifier,
+            e.options.format
+          );
+          S.value.set(e.options.identifier, o);
+        }
+      if (i.baseLayers) {
+        for (const e of i.baseLayers.filter((o) => o.type === "wmts"))
+          if (e.options.url) {
+            const o = await R(
+              e.options.url,
+              e.options.identifier,
+              e.options.format
+            );
+            S.value.set(e.options.identifier, o);
+          }
+      }
+      if (i.toggleableLayers) {
+        for (const e of i.toggleableLayers.filter(
+          (o) => o.type === "wmts"
+        ))
+          if (e.options.url) {
+            const o = await R(
+              e.options.url,
+              e.options.identifier,
+              e.options.format
+            );
+            S.value.set(e.options.identifier, o);
+          }
+      }
+    });
+    const me = h(() => {
+      if (!i.interactions?.selectable?.layers || i.interactions.selectable.layers.length === 0)
+        return;
+      const e = i.interactions.selectable.layers;
+      return (o, t) => {
+        if (!t) return !1;
+        const n = t.get("name");
+        return e.includes(n);
+      };
+    }), ye = h(() => Y(i.interactions?.selectable?.style, void 0)), ve = (e) => {
+      k.value && (k.value.clear(), e.selected && e.selected.length > 0 && k.value.push(e.selected[0])), z("featureSelected", e);
+    }, ge = (e) => {
+      L.value = e;
+      const o = e.features.getArray()[0];
+      if (o) {
+        const t = o.getGeometry();
+        P.value = t.clone();
+        const n = t.getCoordinates();
+        T.value = n, Z.value = !0, B.value = t.on("change", () => {
+          const r = t.getCoordinates();
+          T.value = r;
+        });
+      }
+    }, be = (e) => {
+      L.value = e;
+    }, we = () => {
+      if (L.value) {
+        const e = L.value.features.getArray();
+        z("featureModified", { features: e }), k.value && k.value.clear(), N.value?.selectInteraction && N.value.selectInteraction.getFeatures().clear();
+      }
+      q();
+    }, Le = () => {
+      if (L.value && P.value) {
+        const e = L.value.features.getArray()[0];
+        e && e.setGeometry(P.value);
+        const o = L.value.features.getArray();
+        z("modifyCancelled", { features: o });
+      }
+      q();
+    }, q = () => {
+      Z.value = !1, T.value = null, L.value = null, P.value = null, B.value && (Ue(B.value), B.value = null);
+    };
+    return E({ map: x, view: w, fitToFeatures: pe }), (e, o) => (a(), F("div", Ee, [
+      d(s(Oe), {
+        ref_key: "mapRef",
+        ref: x,
+        style: { width: "100%", height: "100%" },
+        controls: []
+      }, {
+        default: b(() => [
+          d(s(Fe), {
+            projectionName: s(A).name,
+            projectionDef: s(A).def,
+            extent: s(A).extent
+          }, null, 8, ["projectionName", "projectionDef", "extent"]),
+          d(s(Ie), {
+            ref_key: "viewRef",
+            ref: w,
+            center: _.center,
+            zoom: _.zoom,
+            projection: s(A).name
+          }, null, 8, ["center", "zoom", "projection"]),
+          i.interactions?.selectable?.enabled ? (a(), f(s(Ne), {
+            key: 0,
+            ref_key: "selectInteractionRef",
+            ref: N,
+            multi: !1,
+            filter: me.value,
+            style: Se(ye.value),
+            onSelect: ve
+          }, null, 8, ["filter", "style"])) : p("", !0),
+          (a(!0), F(W, null, H(re.value, (t) => (a(), F(W, {
+            key: t.identifier
+          }, [
+            t.type === "wms" ? (a(), f(s(X), {
+              key: 0,
+              zIndex: t.zIndex
+            }, {
+              default: b(() => [
+                d(s(ze), {
+                  url: t.wmsUrl,
+                  layers: t.layerName || "",
+                  params: { LAYERS: t.layerName || "", TILED: !0 },
+                  serverType: "geoserver",
+                  crossOrigin: "anonymous"
+                }, null, 8, ["url", "layers", "params"])
+              ]),
+              _: 2
+            }, 1032, ["zIndex"])) : t.type === "wmts" && (t.wmtsOptions || t.options) ? (a(), f(s(X), {
+              key: 1,
+              zIndex: t.zIndex
+            }, {
+              default: b(() => [
+                d(s(xe), _e(
+                  { ref_for: !0 },
+                  t.wmtsOptions || t.options,
+                  { styles: "default" }
+                ), null, 16)
+              ]),
+              _: 2
+            }, 1032, ["zIndex"])) : t.type === "vector" ? (a(), f(s(Te), {
+              key: 2,
+              zIndex: t.zIndex,
+              properties: { name: t.identifier },
+              ref_for: !0,
+              ref: (n) => {
+                n && (te.value[t.identifier] = n);
+              }
+            }, {
+              default: b(() => [
+                t.styleFunction || t.options?.styleFunction || t.style || t.options?.style ? (a(), f(s(Ae), {
+                  key: 0,
+                  overrideStyleFunction: t.styleFunction || t.options?.styleFunction || oe(t.style || t.options?.style)
+                }, null, 8, ["overrideStyleFunction"])) : p("", !0),
+                d(s(Pe), {
+                  ref_for: !0,
+                  ref: (n) => {
+                    n && (V.value[t.identifier] = n);
+                  }
+                }, {
+                  default: b(() => [
+                    (a(!0), F(W, null, H(t.options?.features, (n, r) => (a(), f(s(Ce), {
+                      key: `${t.identifier}-${r}`,
+                      properties: n.properties || {}
+                    }, {
+                      default: b(() => [
+                        n.type === "Point" ? (a(), f(s(Be), {
+                          key: 0,
+                          coordinates: n.coordinates
+                        }, null, 8, ["coordinates"])) : p("", !0),
+                        n.type === "Polygon" ? (a(), f(s(je), {
+                          key: 1,
+                          coordinates: n.coordinates
+                        }, null, 8, ["coordinates"])) : p("", !0)
+                      ]),
+                      _: 2
+                    }, 1032, ["properties"]))), 128)),
+                    i.interactions?.modify?.enabled && i.interactions.modify.layer === t.identifier && K.value ? (a(), f(s(Ve), {
+                      key: 0,
+                      features: K.value,
+                      onModifystart: ge,
+                      onModifyend: be
+                    }, null, 8, ["features"])) : p("", !0),
+                    i.interactions?.snap?.enabled && i.interactions?.modify?.enabled && i.interactions?.modify?.layer === t.identifier && V.value[i.interactions.snap.targetLayer]?.source ? (a(), f(s(Ze), {
+                      key: `snap-${t.identifier}-${i.interactions?.snap?.enabled}-${i.interactions?.modify?.enabled}`,
+                      source: V.value[i.interactions.snap.targetLayer]?.source,
+                      pixelTolerance: i.interactions?.snap?.pixelTolerance || 8
+                    }, null, 8, ["source", "pixelTolerance"])) : p("", !0)
+                  ]),
+                  _: 2
+                }, 1536)
+              ]),
+              _: 2
+            }, 1032, ["zIndex", "properties"])) : p("", !0)
+          ], 64))), 128)),
+          Z.value && T.value ? (a(), f(s(Me), {
+            key: 1,
+            position: T.value,
+            positioning: "bottom-left",
+            offset: [10, -10],
+            stopEvent: !0
+          }, {
+            default: b(() => [
+              g("div", { class: "modify-overlay" }, [
+                g("button", {
+                  class: "modify-btn modify-btn-ok",
+                  onClick: we
+                }, " Bevestig "),
+                g("button", {
+                  class: "modify-btn modify-btn-cancel",
+                  onClick: Le
+                }, " Annuleer ")
+              ])
+            ]),
+            _: 1
+          }, 8, ["position"])) : p("", !0)
+        ]),
+        _: 1
+      }, 512),
+      g("div", et, [
+        _.toggleableLayers && _.toggleableLayers.length > 0 ? (a(), F("div", tt, [
+          g("button", {
+            class: J(["iconbutton", { isActive: C.value }]),
+            "aria-label": "Toon lagen",
+            "aria-expanded": C.value,
+            onClick: le
+          }, [
+            d(s(qe))
+          ], 10, ot),
+          d(Q, { name: "fade" }, {
+            default: b(() => [
+              C.value ? (a(), f(Xe, {
+                key: 0,
+                toggleableLayers: _.toggleableLayers || [],
+                visibleToggleableLayers: M.value,
+                onToggleLayer: ce
+              }, null, 8, ["toggleableLayers", "visibleToggleableLayers"])) : p("", !0)
+            ]),
+            _: 1
+          })
+        ])) : p("", !0)
+      ]),
+      g("div", nt, [
+        i.baseLayers && i.baseLayers.length > 0 ? (a(), F("div", it, [
+          g("button", {
+            class: J(["iconbutton", { isActive: I.value }]),
+            "aria-label": "Toon basislagen",
+            "aria-expanded": I.value,
+            onClick: ae
+          }, [
+            d(s(Ye))
+          ], 10, st),
+          d(Q, { name: "fade" }, {
+            default: b(() => [
+              I.value ? (a(), f(Qe, {
+                key: 0,
+                baseLayers: i.baseLayers,
+                selectedBaseLayerId: O.value,
+                onSelectBaseLayer: ue
+              }, null, 8, ["baseLayers", "selectedBaseLayerId"])) : p("", !0)
+            ]),
+            _: 1
+          })
+        ])) : p("", !0),
+        g("div", rt, [
+          g("button", {
+            class: "iconbutton",
+            "aria-label": "Zoom in",
+            onClick: fe
+          }, [
+            d(s(He))
+          ]),
+          g("button", {
+            class: "iconbutton",
+            "aria-label": "Zoom out",
+            onClick: de
+          }, [
+            d(s(Je))
+          ])
+        ])
+      ])
+    ]));
+  }
+});
+export {
+  Ct as default
+};

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export { default as Map } from './Map.vue';

package/dist/components/panels/BaseLayers.vue.d.ts

@@ -0,0 +1,23 @@
+export interface LayerConfig {
+    type: "wmts" | "vector";
+    options: {
+        identifier: string;
+        title: string;
+        url?: string;
+        layer?: string;
+        matrixSet?: string;
+        format?: string;
+        projection?: string;
+    };
+}
+type __VLS_Props = {
+    baseLayers: LayerConfig[];
+    selectedBaseLayerId: string | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    selectBaseLayer: (layerId: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelectBaseLayer?: ((layerId: string | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/panels/BaseLayers.vue.js

@@ -0,0 +1,7 @@
+import a from "./BaseLayers.vue2.js";
+/* empty css                */
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const s = /* @__PURE__ */ o(a, [["__scopeId", "data-v-7a503b81"]]);
+export {
+  s as default
+};

package/dist/components/panels/BaseLayers.vue2.js

@@ -0,0 +1,50 @@
+import { defineComponent as u, computed as f, openBlock as o, createElementBlock as r, createElementVNode as t, Fragment as m, renderList as y, toDisplayString as L } from "vue";
+const _ = { class: "wrapper" }, B = ["id", "checked", "onClick"], k = ["for"], b = { class: "layer" }, h = ["checked"], I = /* @__PURE__ */ u({
+  __name: "BaseLayers",
+  props: {
+    baseLayers: {},
+    selectedBaseLayerId: {}
+  },
+  emits: ["selectBaseLayer"],
+  setup(a, { emit: c }) {
+    const i = a, l = c, p = f(() => i.selectedBaseLayerId === null), d = (n) => {
+      if (!n) {
+        l("selectBaseLayer", null);
+        return;
+      }
+      i.selectedBaseLayerId !== n.options.identifier && l("selectBaseLayer", n.options.identifier);
+    };
+    return (n, s) => (o(), r("div", _, [
+      t("ul", null, [
+        (o(!0), r(m, null, y(a.baseLayers, (e) => (o(), r("li", {
+          key: e.options.identifier,
+          class: "layer"
+        }, [
+          t("input", {
+            id: e.options.identifier,
+            type: "radio",
+            name: "baseLayer",
+            checked: i.selectedBaseLayerId === e.options.identifier,
+            onClick: () => d(e)
+          }, null, 8, B),
+          t("label", {
+            for: e.options.identifier
+          }, L(e.options.title), 9, k)
+        ]))), 128)),
+        t("li", b, [
+          t("input", {
+            id: "baseLayer_none",
+            type: "radio",
+            name: "baseLayer",
+            checked: p.value,
+            onClick: s[0] || (s[0] = () => d(null))
+          }, null, 8, h),
+          s[1] || (s[1] = t("label", { for: "baseLayer_none" }, "Geen", -1))
+        ])
+      ])
+    ]));
+  }
+});
+export {
+  I as default
+};

package/dist/components/panels/Layers.vue.d.ts

@@ -0,0 +1,23 @@
+export interface LayerConfig {
+    type: "wmts" | "vector" | "wms";
+    options: {
+        identifier: string;
+        title: string;
+        url?: string;
+        layer?: string;
+        matrixSet?: string;
+        format?: string;
+        projection?: string;
+    };
+}
+type __VLS_Props = {
+    toggleableLayers: LayerConfig[];
+    visibleToggleableLayers: Set<string>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggleLayer: (layerId: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleLayer?: ((layerId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/panels/Layers.vue.js

@@ -0,0 +1,7 @@
+import o from "./Layers.vue2.js";
+/* empty css            */
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ r(o, [["__scopeId", "data-v-16f7d1b3"]]);
+export {
+  f as default
+};

package/dist/components/panels/Layers.vue2.js

@@ -0,0 +1,35 @@
+import { defineComponent as c, openBlock as t, createElementBlock as o, Fragment as g, renderList as d, createElementVNode as s, toDisplayString as h, createCommentVNode as y } from "vue";
+const m = { class: "wrapper" }, p = { key: 0 }, _ = { class: "layer-control" }, u = ["checked", "onChange"], b = { class: "layer-title" }, v = /* @__PURE__ */ c({
+  __name: "Layers",
+  props: {
+    toggleableLayers: {},
+    visibleToggleableLayers: {}
+  },
+  emits: ["toggleLayer"],
+  setup(n, { emit: a }) {
+    const i = a, r = (l) => {
+      i("toggleLayer", l);
+    };
+    return (l, L) => (t(), o("div", m, [
+      n.toggleableLayers.length > 0 ? (t(), o("ul", p, [
+        (t(!0), o(g, null, d(n.toggleableLayers, (e) => (t(), o("li", {
+          key: "toggle-" + e.options.identifier,
+          class: "layer"
+        }, [
+          s("label", _, [
+            s("input", {
+              type: "checkbox",
+              checked: n.visibleToggleableLayers.has(e.options.identifier),
+              onChange: (k) => r(e.options.identifier),
+              class: "layer-checkbox"
+            }, null, 40, u),
+            s("span", b, h(e.options.title), 1)
+          ])
+        ]))), 128))
+      ])) : y("", !0)
+    ]));
+  }
+});
+export {
+  v as default
+};

package/dist/data/demo-data.d.ts

@@ -0,0 +1,15 @@
+export declare const pandenFeatures: {
+    type: "Polygon";
+    coordinates: number[][][];
+    properties: {
+        id: string;
+    };
+}[];
+export declare const meetboutenFeatures: {
+    type: "Point";
+    coordinates: number[];
+    properties: {
+        id: string;
+        geplaatst: boolean;
+    };
+}[];