@delta10/atlas-sdk 0.2.0 → 0.2.1

package/dist/components/Map.vue2.js

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