@npm9912/v-map 0.1.0

package/dist/cjs/v-map.v-map-layer-osm.v-map-layergroup-BsXp3BoL.js

@@ -0,0 +1,582 @@
+'use strict';
+
+var index = require('./index-JSwBbvGA.js');
+var messages = require('./messages-D7h4m8Tx.js');
+var vMapLayerHelper = require('./v-map-layer-helper-iAzxAg9I.js');
+
+/** Exhaustiveness-Guard für Switch/Union */
+function assertNever(x, msg) {
+    throw new Error(msg ?? `Unbekannte Engine: ${String(x)}`);
+}
+/**
+ * Erzeugt eine konkrete Karten-Provider-Instanz abhängig vom gewählten Flavour.
+ *
+ * Unterstützt:
+ * - "ol"      → OpenLayers
+ * - "cesium"  → CesiumJS
+ * - "deck"    → Deck.gl
+ * - "leaflet" → Leaflet
+ */
+async function createProvider(engine) {
+    try {
+        switch (engine) {
+            case 'ol': {
+                const { OpenLayersProvider } = await Promise.resolve().then(function () { return require('./openlayers-provider-Dfeg6L4n.js'); });
+                return new OpenLayersProvider();
+            }
+            case 'cesium': {
+                const { CesiumProvider } = await Promise.resolve().then(function () { return require('./cesium-provider-BiFFyAl9.js'); });
+                return new CesiumProvider();
+            }
+            case 'deck': {
+                const { DeckProvider } = await Promise.resolve().then(function () { return require('./deck-provider-Ctq3Q8a1.js'); }).then(function (n) { return n.deckProvider; });
+                return new DeckProvider();
+            }
+            case 'leaflet': {
+                const { LeafletProvider } = await Promise.resolve().then(function () { return require('./leaflet-provider-DOqfs7g5.js'); });
+                return new LeafletProvider();
+            }
+            default: {
+                // Exhaustiveness: Falls Flavour erweitert wird, meckert TS hier
+                return assertNever(engine, `Unbekannte Engine: ${engine}`);
+            }
+        }
+    }
+    catch (e) {
+        messages.log(e);
+        throw e;
+    }
+}
+
+/* AUTO-GENERATED: DO NOT EDIT. Run "pnpm build" to regenerate. */
+const CESIUM_VERSION = '1.139.1';
+const OL_VERSION = '10.8.0';
+const LEAFLET_VERSION = '1.9.4';
+const IMPORT_MAP_JSON = "{\n  \"imports\": {\n    \"ol/\": \"https://esm.sh/ol@10.8.0/\",\n    \"ol\": \"https://esm.sh/ol@10.8.0\",\n    \"leaflet\": \"https://esm.sh/leaflet@1.9.4\",\n    \"deck\": \"https://esm.sh/deck@9.2.11\",\n    \"@loaders.gl/core\": \"https://esm.sh/@loaders.gl/core@4.3.4\",\n    \"@loaders.gl/3d-tiles\": \"https://esm.sh/@loaders.gl/3d-tiles@4.3.4\",\n    \"@loaders.gl/gis\": \"https://esm.sh/@loaders.gl/gis@4.3.4\",\n    \"@loaders.gl/gltf\": \"https://esm.sh/@loaders.gl/gltf@4.3.4\",\n    \"@loaders.gl/images\": \"https://esm.sh/@loaders.gl/images@4.3.4\",\n    \"@loaders.gl/loader-utils\": \"https://esm.sh/@loaders.gl/loader-utils@4.3.4\",\n    \"@loaders.gl/mvt\": \"https://esm.sh/@loaders.gl/mvt@4.3.4\",\n    \"@loaders.gl/schema\": \"https://esm.sh/@loaders.gl/schema@4.3.4\",\n    \"@loaders.gl/terrain\": \"https://esm.sh/@loaders.gl/terrain@4.3.4\",\n    \"@loaders.gl/textures\": \"https://esm.sh/@loaders.gl/textures@4.3.4\",\n    \"@loaders.gl/tiles\": \"https://esm.sh/@loaders.gl/tiles@4.3.4\",\n    \"@loaders.gl/wms\": \"https://esm.sh/@loaders.gl/wms@4.3.4\"\n  }\n}";
+
+function ensureImportMap({ allowOverride = true } = {}) {
+    if (allowOverride && document.querySelector('script[type="importmap"]'))
+        return;
+    if (!document.querySelector('script[type="importmap"][data-v-map]')) {
+        const s = document.createElement('script');
+        s.type = 'importmap';
+        s.dataset.vMap = 'true';
+        s.textContent = IMPORT_MAP_JSON;
+        document.head.appendChild(s);
+    }
+}
+
+const isBrowser = () => typeof window !== 'undefined' && typeof document !== 'undefined';
+const supportsAdoptedStyleSheets = () => isBrowser() &&
+    'adoptedStyleSheets' in document &&
+    typeof CSSStyleSheet.prototype.replaceSync === 'function';
+function onNextTick(fn) {
+    if (typeof requestAnimationFrame !== 'undefined')
+        requestAnimationFrame(fn);
+    else
+        setTimeout(fn, 0);
+}
+/** Beobachtet Größenänderungen des Targets. Nutzt ResizeObserver wenn vorhanden, sonst Fallback. */
+function watchElementResize(target, cb, mutationObserverInit) {
+    // Native ResizeObserver vorhanden?
+    if (typeof globalThis.ResizeObserver !== 'undefined') {
+        const ro = new globalThis.ResizeObserver(() => cb());
+        ro.observe(target);
+        return () => ro.disconnect();
+    }
+    // Fallback: Fenster-Resize + Mutations (Attribute-Änderungen, z.B. style.width/height)
+    const onWinResize = () => onNextTick(cb);
+    if (typeof window !== 'undefined') {
+        window.addEventListener('resize', onWinResize);
+    }
+    let mo;
+    if (typeof MutationObserver !== 'undefined') {
+        mo = new MutationObserver(() => onNextTick(cb));
+        if (mutationObserverInit) {
+            mo.observe(target, mutationObserverInit);
+        }
+        else {
+            mo.observe(target);
+        }
+    }
+    // Letzter Fallback: leichtes Polling (nur im Test sinnvoll)
+    const pollId = typeof window === 'undefined' ? undefined : setInterval(() => cb(), 250);
+    return () => {
+        if (typeof window !== 'undefined')
+            window.removeEventListener('resize', onWinResize);
+        mo?.disconnect();
+        if (pollId)
+            clearInterval(pollId);
+    };
+}
+
+const vMapCss = () => `:host{display:block}`;
+
+const NOOP_PROVIDER = {
+    async init() { },
+    async destroy() { },
+    async setOpacity() { },
+    async setVisible() { },
+    async setZIndex() { },
+    async addLayerToGroup() {
+        return null;
+    },
+    async updateLayer() { },
+    async removeLayer() { },
+    async setView() { },
+    async addBaseLayer() {
+        return null;
+    },
+    async setBaseLayer() { },
+    async ensureGroup() { },
+    async setGroupVisible() { },
+};
+const MSG_COMPONENT$2 = 'v-map - ';
+const VMap = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.mapProviderReady = index.createEvent(this, "mapProviderReady", 5);
+    }
+    get el() { return index.getElement(this); }
+    /**
+     * Zu verwendender Karten-Provider.
+     * Unterstützte Werte: "ol" | "leaflet" | "cesium" | "deck".
+     * @default "ol"
+     * @example
+     * <v-map flavour="leaflet"></v-map>
+     */
+    flavour = 'ol';
+    /**
+     * Mittelpunkt der Karte im **WGS84**-Koordinatensystem.
+     * Erwartet [lon, lat] (Längengrad, Breitengrad).
+     * @default [0, 0]
+     * @example
+     * <v-map center="[11.5761, 48.1371]" zoom="12"></v-map>
+     */
+    center = '0,0';
+    /**
+     * Anfangs-Zoomstufe. Skala abhängig vom Provider (typisch 0–20).
+     * @default 3
+     */
+    zoom = 2;
+    /** Falls true, injiziert v-map automatisch die Import-Map. */
+    useDefaultImportMap = true;
+    /**
+     * Aktiviert ein „CSS-Only“-Rendering (z. B. für einfache Tests/Layouts).
+     * Bei `true` werden keine Provider initialisiert.
+     * @default false
+     */
+    cssMode = 'cdn';
+    /**
+     * Wird ausgelöst, sobald der Karten-Provider initialisiert wurde und Layers entgegennimmt.
+     * `detail` enthält `{ provider, flavour }`.
+     * @event mapProviderReady
+     */
+    mapProviderReady;
+    // KEIN @State – keine Re-Renders nötig
+    mapProvider;
+    mapState = 'unavailable';
+    mapContainer;
+    unsubscribeResize;
+    unsubscribePointerMove = null;
+    async onFlavourChanged(oldValue, newValue) {
+        messages.log(MSG_COMPONENT$2 + 'onFlavourChanged');
+        if (oldValue !== newValue) {
+            this.reset();
+            // await this.createMap();
+        }
+    }
+    reset() {
+        this.unsubscribeResize?.();
+        this.unsubscribePointerMove?.();
+        this.unsubscribePointerMove = null;
+        const mapProvider = this.mapProvider;
+        this.mapProvider = null;
+        this.el.__vMapProvider = null;
+        const payLoad = {
+            mapProvider: NOOP_PROVIDER,
+        };
+        // this.mapProviderReady.emit(payLoad);
+        this.el.dispatchEvent(new CustomEvent(messages.VMapEvents.MapProviderWillShutdown, {
+            detail: payLoad, // deine Payload
+            bubbles: false, // blubbert nach oben
+            composed: false, // geht über Shadow-Grenzen
+            cancelable: true, // Parent kann preventDefault() aufrufen
+        }));
+        mapProvider?.destroy();
+        this.mapState = 'unavailable';
+    }
+    async createMap() {
+        this.mapContainer = this.ensureContainer();
+        if (this.mapState === 'creating') {
+            messages.log('Map already in creating state.');
+            return;
+        }
+        this.mapState = 'creating';
+        this.mapProvider = await createProvider(this.flavour);
+        const mapInitOpts = { zoom: this.zoom };
+        if (this.center) {
+            const centerLL = this.center.split(',').map(parseFloat);
+            const [centerLon, centerLat] = centerLL;
+            if (!Number.isFinite(centerLon) || !Number.isFinite(centerLat)) {
+                throw new Error(`<v-map>: Ungültiges center-Prop: "${this.center}" (erwartet "lon,lat")`);
+            }
+            mapInitOpts.center = centerLL;
+        }
+        const opts = {
+            target: this.mapContainer,
+            shadowRoot: this.el.shadowRoot,
+            mapInitOptions: mapInitOpts,
+            cssMode: this.cssMode,
+        };
+        await this.mapProvider.init(opts);
+        this.mapState = 'available';
+        this.el.__vMapProvider = this.mapProvider;
+        this.unsubscribeResize = watchElementResize(this.el, async () => {
+            await this.mapProvider?.setView(mapInitOpts.center, mapInitOpts.zoom);
+        });
+        const payLoad = {
+            mapProvider: this.mapProvider,
+        };
+        // this.mapProviderReady.emit(payLoad);
+        this.el.dispatchEvent(new CustomEvent(messages.VMapEvents.MapProviderReady, {
+            detail: payLoad, // deine Payload
+            bubbles: false, // blubbert nach oben
+            composed: false, // geht über Shadow-Grenzen
+            cancelable: true, // Parent kann preventDefault() aufrufen
+        }));
+        // Mouse-move → Geo-Koordinaten (provider-spezifisch)
+        if (this.mapProvider?.onPointerMove) {
+            this.unsubscribePointerMove = this.mapProvider.onPointerMove((coordinate, pixel) => {
+                this.el.dispatchEvent(new CustomEvent(messages.VMapEvents.MapMouseMove, {
+                    detail: { coordinate, pixel },
+                    bubbles: true,
+                    composed: true,
+                }));
+            });
+        }
+    }
+    async componentWillLoad() {
+        messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_WILL_LOAD);
+        if (this.useDefaultImportMap) {
+            messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_WILL_LOAD + ' - useDefaultImportMap');
+            ensureImportMap();
+        }
+    }
+    // async componentDidLoad() {
+    //   log(MSG_COMPONENT + MSG.COMPONENT_DID_LOAD);
+    //   //test
+    // }
+    async componentWillRender() {
+        messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_WILL_RENDER);
+    }
+    async componentDidRender() {
+        messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_DID_RENDER);
+        await this.createMap();
+        this.el.addEventListener(messages.VMapEvents.MapProviderReady, ((event) => {
+            messages.log(MSG_COMPONENT$2 + 'test - event: ', event);
+        }));
+    }
+    disconnectedCallback() {
+        messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_DISCONNECTED_CALLBACK);
+        this.reset();
+    }
+    /**
+     * Gibt zurück, ob der Karten-Provider initialisiert wurde und verwendet werden kann.
+     * @returns Promise mit `true`, sobald der Provider bereit ist, sonst `false`.
+     */
+    async isMapProviderReady() {
+        const isReady = this.mapProvider !== null &&
+            this.mapProvider !== undefined &&
+            this.mapProvider !== NOOP_PROVIDER;
+        if (!isReady) {
+            messages.log(MSG_COMPONENT$2 + 'Map provider not yet ready.');
+        }
+        return isReady;
+    }
+    /**
+     * Setzt Kartenzentrum und Zoom (optional animiert).
+     * @param center [lon, lat] in WGS84
+     * @param zoom   Zoomstufe
+     * @param options Zusätzliche Optionen (z. B. { animate: true, duration: 300 })
+     * @example
+     * await mapEl.setView([7.1, 50.7], 10, { animate: true, duration: 400 });
+     */
+    async setView(coordinates, zoom) {
+        if (!this.mapProvider || this.mapProvider == NOOP_PROVIDER)
+            throw new Error(MSG_COMPONENT$2 + 'Map-Provider noch nicht initialisiert.');
+        await Promise.resolve(this.mapProvider?.setView(coordinates, zoom));
+    }
+    ensureContainer() {
+        let el = this.el.shadowRoot.querySelector('#map');
+        if (!el) {
+            el = document.createElement('div');
+            el.id = 'map';
+            el.style.cssText =
+                'position:relative;width:100%;height:100%;display:block;';
+            this.el.shadowRoot.appendChild(el);
+        }
+        return el;
+    }
+    render() {
+        messages.log(MSG_COMPONENT$2 + messages.MESSAGES.COMPONENT_RENDER);
+        //return <div id="map-container"></div>;
+        return (index.h("div", { key: '41aca26c5cab5a3d7fef6169e9c4b8d27c7e65db' }, index.h("slot", { key: '4b04986c721a478cdfb900491e44106778c07df7' })));
+    }
+    static get watchers() { return {
+        "flavour": [{
+                "onFlavourChanged": 0
+            }]
+    }; }
+};
+VMap.style = vMapCss();
+
+const vMapLayerOsmCss = () => `:host{display:none;}`;
+
+const MSG_COMPONENT$1 = 'v-map-layer-osm - ';
+const VMapLayerOSM = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.ready = index.createEvent(this, "ready", 7);
+    }
+    get el() { return index.getElement(this); }
+    /** Current load state of the layer. */
+    loadState = 'idle';
+    visible = true;
+    /**
+     * Opazität der OSM-Kacheln (0–1).
+     * @default 1
+     */
+    opacity = 1.0;
+    /**
+     * Z-index for layer stacking order. Higher values render on top.
+     */
+    zIndex = 10;
+    /**
+     * Base URL for OpenStreetMap tile server. Defaults to the standard OSM tile server.
+     */
+    url = 'https://tile.openstreetmap.org';
+    /**
+     * Wird ausgelöst, wenn der OSM-Layer bereit ist.
+     * @event ready
+     */
+    ready;
+    didLoad = false;
+    hasLoadedOnce = false;
+    helper;
+    setLoadState(state) {
+        this.loadState = state;
+    }
+    /** Returns the last error detail, if any. */
+    async getError() {
+        return this.helper?.getError();
+    }
+    async onVisibleChanged() {
+        messages.log(MSG_COMPONENT$1 + 'onVisibleChanged');
+        await this.helper?.setVisible(this.visible);
+    }
+    async onOpacityChanged() {
+        messages.log(MSG_COMPONENT$1 + 'onOpacityChanged');
+        await this.helper?.setOpacity(this.opacity);
+    }
+    async onZIndexChanged() {
+        messages.log(MSG_COMPONENT$1 + 'onZIndexChanged');
+        await this.helper?.setZIndex(this.zIndex);
+    }
+    async onUrlChanged(oldValue, newValue) {
+        messages.log(MSG_COMPONENT$1 + 'onUrlChanged');
+        if (oldValue !== newValue) {
+            await this.helper?.updateLayer({
+                type: 'osm',
+                data: {
+                    url: this.url,
+                },
+            });
+        }
+        //    if (oldValue !== newValue) {
+        //      await this.helper.initLayer(() => this.createLayerConfig());
+        //    }
+    }
+    isReady() {
+        return this.didLoad;
+    }
+    /**
+     * Returns the internal layer ID used by the map provider.
+     */
+    async getLayerId() {
+        return this.helper?.getLayerId();
+    }
+    createLayerConfig() {
+        return {
+            type: 'osm',
+            url: this.url,
+            visible: this.visible,
+            zIndex: this.zIndex,
+            opacity: this.opacity,
+        };
+    }
+    async connectedCallback() {
+        messages.log(MSG_COMPONENT$1 + messages.MESSAGES.COMPONENT_CONNECTED_CALLBACK);
+        if (!this.hasLoadedOnce)
+            return;
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+    }
+    async componentWillLoad() {
+        messages.log(MSG_COMPONENT$1 + messages.MESSAGES.COMPONENT_WILL_LOAD);
+        this.helper = new vMapLayerHelper.VMapLayerHelper(this.el, this);
+    }
+    async componentDidLoad() {
+        messages.log(MSG_COMPONENT$1 + messages.MESSAGES.COMPONENT_DID_LOAD);
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+        this.hasLoadedOnce = true;
+        this.didLoad = true;
+        this.ready.emit();
+    }
+    async componentWillRender() {
+        messages.log(MSG_COMPONENT$1 + messages.MESSAGES.COMPONENT_WILL_RENDER);
+    }
+    async disconnectedCallback() {
+        messages.log(MSG_COMPONENT$1 + messages.MESSAGES.COMPONENT_DISCONNECTED_CALLBACK);
+        await this.helper?.dispose();
+    }
+    render() {
+        return;
+    }
+    static get watchers() { return {
+        "visible": [{
+                "onVisibleChanged": 0
+            }],
+        "opacity": [{
+                "onOpacityChanged": 0
+            }],
+        "zIndex": [{
+                "onZIndexChanged": 0
+            }],
+        "url": [{
+                "onUrlChanged": 0
+            }]
+    }; }
+};
+VMapLayerOSM.style = vMapLayerOsmCss();
+
+const vMapLayergroupCss = () => `:host{display:none;}`;
+
+const MSG_COMPONENT = 'v-map-layergroup - ';
+const VMapLayerGroup = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+    }
+    get el() { return index.getElement(this); }
+    /**
+     * Sichtbarkeit der gesamten Gruppe.
+     * @default true
+     */
+    visible = true;
+    /**
+     * Globale Opazität (0–1) für alle Kinder.
+     * @default 1
+     */
+    opacity = 1.0;
+    // /**
+    //  * Kennzeichnet diese Gruppe als Basis-Kartenebene (exklusiv sichtbar).
+    //  * @default false
+    //  */
+    // @Prop({ reflect: true }) basemap = false;
+    /**
+     * Base map identifier for this layer group. When set, layers in this group will be treated as base map layers.
+     */
+    basemapid = null;
+    // /**
+    //  * Eindeutige Gruppen-ID (z. B. für programmatisches Umschalten).
+    //  */
+    // @Prop({ reflect: true }) groupId: string = Math.random()
+    //   .toString(36)
+    //   .slice(2, 11);
+    mapProvider = null;
+    groupId = crypto.randomUUID();
+    async onVisibleChanged() {
+        messages.log(MSG_COMPONENT + 'onVisibleChanged');
+        if (this.mapProvider?.setGroupVisible) {
+            await this.mapProvider.setGroupVisible(this.groupId, this.visible);
+        }
+    }
+    async onBaseMapIdChanged() {
+        messages.log(MSG_COMPONENT + 'onBaseMapIdChanged');
+        if (this.mapProvider?.setBaseLayer) {
+            await this.mapProvider.setBaseLayer(this.groupId, this.basemapid);
+        }
+    }
+    async init(mapProvider) {
+        if (this.mapProvider != null)
+            return;
+        this.mapProvider = mapProvider;
+        if (this.mapProvider === null)
+            return;
+        if (this.mapProvider?.ensureGroup) {
+            await this.mapProvider.ensureGroup(this.groupId, this.visible, {
+                basemapid: this.basemapid,
+            });
+        }
+        await this.mapProvider?.setGroupVisible(this.groupId, this.visible);
+        await this.mapProvider?.setBaseLayer(this.groupId, this.basemapid);
+    }
+    async connectedCallback() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_CONNECTED_CALLBACK);
+        const mapElement = this.el.closest('v-map');
+        await customElements.whenDefined('v-map');
+        const vmap = mapElement;
+        const mapProviderAvailable = (await mapElement?.isMapProviderReady?.()) === true;
+        if (mapProviderAvailable) {
+            const mapProvider = mapElement?.__vMapProvider ?? null;
+            await this.init(mapProvider);
+        }
+        vmap?.addEventListener(messages.VMapEvents.MapProviderReady, (async (event) => {
+            messages.log(`${MSG_COMPONENT}map provider ready`);
+            const mapEvent = event.detail;
+            await this.init(mapEvent.mapProvider);
+        }));
+        vmap?.addEventListener(messages.VMapEvents.MapProviderWillShutdown, async (_event) => {
+            messages.log(`${MSG_COMPONENT}map provider shutting down`);
+            this.mapProvider = null;
+        });
+    }
+    async componentWillLoad() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_WILL_LOAD);
+    }
+    async componentDidLoad() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_DID_LOAD);
+    }
+    async componentWillRender() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_WILL_RENDER);
+    }
+    /**
+     * Returns the internal group identifier used by the map provider.
+     */
+    async getGroupId() {
+        return this.groupId;
+    }
+    render() {
+        return index.h("slot", { key: '584a5816d8f73071bf257e3f70a4c2baea2d2f56' });
+    }
+    static get watchers() { return {
+        "visible": [{
+                "onVisibleChanged": 0
+            }],
+        "basemapid": [{
+                "onBaseMapIdChanged": 0
+            }]
+    }; }
+};
+VMapLayerGroup.style = vMapLayergroupCss();
+
+exports.CESIUM_VERSION = CESIUM_VERSION;
+exports.LEAFLET_VERSION = LEAFLET_VERSION;
+exports.OL_VERSION = OL_VERSION;
+exports.VMap = VMap;
+exports.VMapLayerGroup = VMapLayerGroup;
+exports.VMapLayerOSM = VMapLayerOSM;
+exports.isBrowser = isBrowser;
+exports.supportsAdoptedStyleSheets = supportsAdoptedStyleSheets;
+exports.watchElementResize = watchElementResize;

package/dist/cjs/v-map_3.cjs.entry.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var vMap_vMapLayerOsm_vMapLayergroup_entry = require('./v-map.v-map-layer-osm.v-map-layergroup-BsXp3BoL.js');
+require('./index-JSwBbvGA.js');
+require('./messages-D7h4m8Tx.js');
+require('./v-map-layer-helper-iAzxAg9I.js');
+
+
+
+exports.v_map = vMap_vMapLayerOsm_vMapLayergroup_entry.VMap;
+exports.v_map_layer_osm = vMap_vMapLayerOsm_vMapLayergroup_entry.VMapLayerOSM;
+exports.v_map_layergroup = vMap_vMapLayerOsm_vMapLayergroup_entry.VMapLayerGroup;

package/dist/collection/collection-manifest.json

@@ -0,0 +1,30 @@
+{
+  "entries": [
+    "components/v-map-layer-scatterplot/v-map-layer-scatterplot.js",
+    "components/v-map/v-map.js",
+    "components/v-map-builder/v-map-builder.js",
+    "components/v-map-layer-geojson/v-map-layer-geojson.js",
+    "components/v-map-layer-geotiff/v-map-layer-geotiff.js",
+    "components/v-map-layer-google/v-map-layer-google.js",
+    "components/v-map-layer-osm/v-map-layer-osm.js",
+    "components/v-map-layer-terrain/v-map-layer-terrain.js",
+    "components/v-map-layer-terrain-geotiff/v-map-layer-terrain-geotiff.js",
+    "components/v-map-layer-tile3d/v-map-layer-tile3d.js",
+    "components/v-map-layer-wcs/v-map-layer-wcs.js",
+    "components/v-map-layer-wfs/v-map-layer-wfs.js",
+    "components/v-map-layer-wkt/v-map-layer-wkt.js",
+    "components/v-map-layer-wms/v-map-layer-wms.js",
+    "components/v-map-layer-xyz/v-map-layer-xyz.js",
+    "components/v-map-layercontrol/v-map-layercontrol.js",
+    "components/v-map-layergroup/v-map-layergroup.js",
+    "components/v-map-style/v-map-style.js"
+  ],
+  "mixins": [],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "4.43.3",
+    "typescriptVersion": "5.8.3"
+  },
+  "collections": [],
+  "bundles": []
+}

package/dist/collection/components/v-map/v-map.css

@@ -0,0 +1,3 @@
+:host {
+  display: block;
+}