@delta10/atlas-sdk 0.2.0 → 0.2.2

package/dist/components/Map.vue2.js

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