@npm9912/v-map 0.1.0

package/dist/collection/layer/v-map-layer-helper.js

@@ -0,0 +1,281 @@
+import { VMapEvents } from "../utils/events";
+import { log, warn } from "../utils/logger";
+export class VMapLayerHelper {
+    el;
+    static RUNTIME_ERROR_DEBOUNCE_MS = 5000;
+    layerId = null;
+    mapProvider = null;
+    _error;
+    host;
+    initContext;
+    listenersBound = false;
+    recreateInFlight = false;
+    lastRuntimeErrorTime = 0;
+    constructor(el, host) {
+        this.el = el;
+        this.host = host;
+    }
+    // ── Error / State management ──────────────────────────────────────
+    startLoading() {
+        // Keep the last error visible during retry until success or new error
+        this.host?.setLoadState('loading');
+    }
+    markReady() {
+        this.clearError();
+        this.host?.setLoadState('ready');
+    }
+    markUpdated() {
+        // Semantically separate success path for updates, currently identical to markReady()
+        this.markReady();
+    }
+    setError(detail) {
+        this._error = detail;
+        this.host?.setLoadState('error');
+        this.el.dispatchEvent(new CustomEvent(VMapEvents.Error, {
+            detail,
+            bubbles: true,
+            composed: true,
+        }));
+        warn(`${this.el.nodeName.toLowerCase()} - ${detail.message}`);
+    }
+    setRuntimeError(detail) {
+        const now = Date.now();
+        if (now - this.lastRuntimeErrorTime < VMapLayerHelper.RUNTIME_ERROR_DEBOUNCE_MS) {
+            return;
+        }
+        this.lastRuntimeErrorTime = now;
+        this.setError(detail);
+    }
+    clearError() {
+        this._error = undefined;
+        this.lastRuntimeErrorTime = 0;
+    }
+    getError() {
+        return this._error;
+    }
+    // ── Layer operations ──────────────────────────────────────────────
+    async addLayer(basemapid, groupId, groupVisible, layerConfig, layerElementId) {
+        if (!this.mapProvider) {
+            warn('Map provider not available.');
+            return null;
+        }
+        if (basemapid) {
+            return await this.mapProvider?.addBaseLayer({
+                ...layerConfig,
+                groupId: groupId,
+                groupVisible: groupVisible,
+            }, basemapid, layerElementId);
+        }
+        return await this.mapProvider?.addLayerToGroup({
+            ...layerConfig,
+            groupId: groupId,
+            groupVisible: groupVisible,
+        });
+    }
+    async addToMapInternal(group, vmap, createLayerConfig, elementId) {
+        if (this.layerId) {
+            this.unregisterLayerError();
+            await this.mapProvider?.removeLayer(this.layerId);
+            this.layerId = null;
+        }
+        const isMapProviderAvailable = (await vmap.isMapProviderReady?.()) === true;
+        if (isMapProviderAvailable) {
+            log(`${this.el.nodeName.toLowerCase()} - layer is being added`);
+            this.mapProvider = vmap.__vMapProvider ?? null;
+            const groupId = await group.getGroupId();
+            const groupVisible = await group.visible;
+            if (this.layerId === null && this.mapProvider) {
+                try {
+                    this.layerId = await this.addLayer(group.basemapid, groupId, groupVisible, createLayerConfig(), elementId);
+                    if (this.layerId) {
+                        this.registerLayerError();
+                        this.markReady();
+                    }
+                    else {
+                        this.setError({
+                            type: 'provider',
+                            message: 'Layer could not be added: provider returned no layer ID',
+                        });
+                    }
+                }
+                catch (e) {
+                    this.setError({
+                        type: 'provider',
+                        message: `Layer could not be added: ${e instanceof Error ? e.message : String(e)}`,
+                        cause: e,
+                    });
+                }
+            }
+        }
+    }
+    // ── Event binding ─────────────────────────────────────────────────
+    bindMapEventsOnce() {
+        if (this.listenersBound || !this.initContext)
+            return;
+        const { vmap } = this.initContext;
+        vmap.addEventListener(VMapEvents.MapProviderReady, this.onMapProviderReady);
+        vmap.addEventListener(VMapEvents.MapProviderWillShutdown, this.onMapProviderWillShutdown);
+        this.listenersBound = true;
+    }
+    onMapProviderReady = async (event) => {
+        log(`${this.el.nodeName.toLowerCase()} - layer add deferred`);
+        const mapEvent = event.detail;
+        this.mapProvider = mapEvent.mapProvider;
+        if (!this.layerId && this.initContext) {
+            this.startLoading();
+            const { group, vmap, createLayerConfig, elementId } = this.initContext;
+            await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+        }
+    };
+    onMapProviderWillShutdown = async (_event) => {
+        log(`${this.el.nodeName.toLowerCase()} - map provider shutting down`);
+        this.mapProvider = null;
+        this.layerId = null;
+        this.clearError();
+        this.host?.setLoadState('idle');
+    };
+    // ── Mutators ──────────────────────────────────────────────────────
+    async setVisible(visible) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setVisible(this.layerId, visible);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setVisible failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async setOpacity(opacity) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setOpacity(this.layerId, opacity);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setOpacity failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async setZIndex(zIndex) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setZIndex(this.layerId, zIndex);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setZIndex failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async updateLayer(update) {
+        if (!this.layerId || !this.mapProvider) {
+            await this.recreateLayer();
+            return;
+        }
+        try {
+            await this.mapProvider.updateLayer(this.layerId, update);
+            this.markUpdated();
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `updateLayer failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────
+    async recreateLayer() {
+        if (!this.initContext || this.recreateInFlight)
+            return;
+        this.recreateInFlight = true;
+        this.startLoading();
+        const { group, vmap, createLayerConfig, elementId } = this.initContext;
+        try {
+            await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+        }
+        finally {
+            this.recreateInFlight = false;
+        }
+    }
+    async initLayer(createLayerConfig, elementId) {
+        const group = this.el.closest('v-map-layergroup');
+        if (!group) {
+            warn(`${this.el.nodeName.toLowerCase()} is not inside a v-map-layergroup`);
+            return;
+        }
+        const vmap = await this.getVMap();
+        if (!vmap) {
+            warn(`No parent v-map component found for ${this.el.nodeName.toLowerCase()}`);
+            return;
+        }
+        this.initContext = { group, vmap, createLayerConfig, elementId };
+        this.bindMapEventsOnce();
+        await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+    }
+    async dispose() {
+        if (this.initContext && this.listenersBound) {
+            const { vmap } = this.initContext;
+            vmap.removeEventListener(VMapEvents.MapProviderReady, this.onMapProviderReady);
+            vmap.removeEventListener(VMapEvents.MapProviderWillShutdown, this.onMapProviderWillShutdown);
+        }
+        // listenersBound = false enables re-binding on a later connectedCallback()/initLayer()
+        this.listenersBound = false;
+        await this.removeLayer();
+        this.clearError();
+        this.host?.setLoadState('idle');
+    }
+    // ── Accessors ─────────────────────────────────────────────────────
+    getMapProvider() {
+        return this.mapProvider;
+    }
+    getLayerId() {
+        return this.layerId;
+    }
+    async removeLayer() {
+        this.unregisterLayerError();
+        await this.mapProvider?.removeLayer(this.layerId);
+        this.layerId = null;
+    }
+    registerLayerError() {
+        if (this.layerId && this.mapProvider?.onLayerError) {
+            this.mapProvider.onLayerError(this.layerId, (err) => {
+                this.setRuntimeError({
+                    type: err.type,
+                    message: err.message,
+                    cause: err.cause,
+                });
+            });
+        }
+    }
+    unregisterLayerError() {
+        if (this.layerId && this.mapProvider?.offLayerError) {
+            this.mapProvider.offLayerError(this.layerId);
+        }
+    }
+    async getVMap() {
+        log(`${this.el.nodeName.toLowerCase()} - getVMap`);
+        const mapElement = this.el.closest('v-map');
+        if (!mapElement) {
+            log(`${this.el.nodeName.toLowerCase()} - getVMap - v-map not found.`);
+            return null;
+        }
+        await customElements.whenDefined('v-map');
+        const vmap = mapElement;
+        log(`${this.el.nodeName.toLowerCase()} - getVMap - assigned.`);
+        return vmap;
+    }
+}

package/dist/collection/layer/v-map-layer-helper.unit.js

@@ -0,0 +1,234 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+vi.mock('../utils/logger', () => ({
+    log: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+}));
+vi.mock('../utils/events', () => ({
+    VMapEvents: {
+        Ready: 'ready',
+        Error: 'vmap-error',
+        MapProviderReady: 'map-provider-ready',
+        MapProviderWillShutdown: 'map-provider-will-shutdown',
+        MapMouseMove: 'map-mousemove',
+    },
+}));
+import { VMapLayerHelper } from "./v-map-layer-helper";
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+function createMockMapProvider(overrides = {}) {
+    return {
+        addBaseLayer: vi.fn().mockResolvedValue('base-layer-id'),
+        addLayerToGroup: vi.fn().mockResolvedValue('group-layer-id'),
+        removeLayer: vi.fn().mockResolvedValue(undefined),
+        setVisible: vi.fn().mockResolvedValue(undefined),
+        setOpacity: vi.fn().mockResolvedValue(undefined),
+        setZIndex: vi.fn().mockResolvedValue(undefined),
+        updateLayer: vi.fn().mockResolvedValue(undefined),
+        onLayerError: vi.fn(),
+        offLayerError: vi.fn(),
+        ...overrides,
+    };
+}
+function asHelperInternals(value) {
+    return value;
+}
+function createMockVMap(provider) {
+    return {
+        __vMapProvider: provider,
+        isMapProviderReady: vi.fn().mockResolvedValue(true),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+    };
+}
+function createMockGroup(groupId = 'test-group-id') {
+    return {
+        getGroupId: vi.fn().mockResolvedValue(groupId),
+        visible: true,
+        basemapid: '',
+    };
+}
+function createMockElement() {
+    return {
+        nodeName: 'V-MAP-LAYER-XYZ',
+        closest: vi.fn(() => null),
+        dispatchEvent: vi.fn(),
+    };
+}
+function createMockHost() {
+    return {
+        states: [],
+        setLoadState(state) {
+            this.states.push(state);
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Tests                                                              */
+/* ------------------------------------------------------------------ */
+describe('VMapLayerHelper – runtime error propagation', () => {
+    let helper;
+    let mockEl;
+    let mockProvider;
+    let mockHost;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.clearAllMocks();
+        mockProvider = createMockMapProvider();
+        mockEl = createMockElement();
+        mockHost = createMockHost();
+        helper = new VMapLayerHelper(mockEl, mockHost);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    /* ================================================================ */
+    /*  setRuntimeError – leading-edge throttle                          */
+    /* ================================================================ */
+    describe('setRuntimeError', () => {
+        it('fires immediately on first call', () => {
+            const detail = { type: 'network', message: 'Tile load error' };
+            helper.setRuntimeError(detail);
+            expect(helper.getError()).toEqual(detail);
+            expect(mockHost.states).toContain('error');
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(1);
+        });
+        it('suppresses repeated calls within the 5s window', () => {
+            const detail1 = { type: 'network', message: 'Error 1' };
+            const detail2 = { type: 'network', message: 'Error 2' };
+            helper.setRuntimeError(detail1);
+            expect(helper.getError()).toEqual(detail1);
+            // Advance less than 5s
+            vi.advanceTimersByTime(3000);
+            helper.setRuntimeError(detail2);
+            // Error should still be the first one – second was suppressed
+            expect(helper.getError()).toEqual(detail1);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(1);
+        });
+        it('fires again after the 5s window expires', () => {
+            const detail1 = { type: 'network', message: 'Error 1' };
+            const detail2 = { type: 'network', message: 'Error 2' };
+            helper.setRuntimeError(detail1);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(1);
+            // Advance past the 5s debounce window
+            vi.advanceTimersByTime(5001);
+            helper.setRuntimeError(detail2);
+            expect(helper.getError()).toEqual(detail2);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(2);
+        });
+        it('suppresses at exactly 5s but fires at 5001ms', () => {
+            const detail1 = { type: 'network', message: 'Error 1' };
+            const detail2 = { type: 'network', message: 'Error 2' };
+            const detail3 = { type: 'network', message: 'Error 3' };
+            helper.setRuntimeError(detail1);
+            // At exactly 4999ms – still suppressed
+            vi.advanceTimersByTime(4999);
+            helper.setRuntimeError(detail2);
+            expect(helper.getError()).toEqual(detail1);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(1);
+            // At 5001ms from the first call
+            vi.advanceTimersByTime(2);
+            helper.setRuntimeError(detail3);
+            expect(helper.getError()).toEqual(detail3);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(2);
+        });
+    });
+    /* ================================================================ */
+    /*  clearError resets the debounce timer                             */
+    /* ================================================================ */
+    describe('clearError resets debounce timer', () => {
+        it('allows immediate fire after clearError', () => {
+            const detail1 = { type: 'network', message: 'Error 1' };
+            const detail2 = { type: 'network', message: 'Error 2' };
+            helper.setRuntimeError(detail1);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(1);
+            // Only 1s in – normally would be suppressed
+            vi.advanceTimersByTime(1000);
+            helper.clearError();
+            // Should fire immediately after clearError, even within the 5s window
+            helper.setRuntimeError(detail2);
+            expect(helper.getError()).toEqual(detail2);
+            expect(mockEl.dispatchEvent).toHaveBeenCalledTimes(2);
+        });
+        it('clearError removes the stored error', () => {
+            helper.setRuntimeError({ type: 'network', message: 'err' });
+            expect(helper.getError()).toBeDefined();
+            helper.clearError();
+            expect(helper.getError()).toBeUndefined();
+        });
+    });
+    /* ================================================================ */
+    /*  registerLayerError / unregisterLayerError                        */
+    /* ================================================================ */
+    describe('registerLayerError', () => {
+        it('calls mapProvider.onLayerError after addLayer succeeds', async () => {
+            const testHelper = asHelperInternals(helper);
+            const mockVMap = createMockVMap(mockProvider);
+            const mockGroup = createMockGroup();
+            await testHelper.addToMapInternal(mockGroup, mockVMap, () => ({ type: 'osm' }));
+            expect(mockProvider.onLayerError).toHaveBeenCalledWith('group-layer-id', expect.any(Function));
+        });
+        it('onLayerError callback delegates to setRuntimeError', async () => {
+            let capturedCallback;
+            mockProvider.onLayerError.mockImplementation((_id, cb) => {
+                capturedCallback = cb;
+            });
+            const testHelper = asHelperInternals(helper);
+            const mockVMap = createMockVMap(mockProvider);
+            const mockGroup = createMockGroup();
+            await testHelper.addToMapInternal(mockGroup, mockVMap, () => ({ type: 'osm' }));
+            // Simulate a layer error from the provider
+            capturedCallback({ type: 'network', message: 'Tile load error' });
+            expect(helper.getError()).toEqual({
+                type: 'network',
+                message: 'Tile load error',
+            });
+            expect(mockHost.states).toContain('error');
+        });
+        it('does not call onLayerError if provider lacks the method', async () => {
+            const testHelper = asHelperInternals(helper);
+            const providerWithoutError = createMockMapProvider();
+            delete providerWithoutError.onLayerError;
+            delete providerWithoutError.offLayerError;
+            const mockVMap = createMockVMap(providerWithoutError);
+            const mockGroup = createMockGroup('g1');
+            // Should not throw
+            await testHelper.addToMapInternal(mockGroup, mockVMap, () => ({ type: 'osm' }));
+            expect(helper.getLayerId()).toBe('group-layer-id');
+        });
+    });
+    describe('unregisterLayerError', () => {
+        it('calls mapProvider.offLayerError on removeLayer', async () => {
+            const testHelper = asHelperInternals(helper);
+            testHelper.mapProvider = mockProvider;
+            testHelper.layerId = 'layer-1';
+            await helper.removeLayer();
+            expect(mockProvider.offLayerError).toHaveBeenCalledWith('layer-1');
+            expect(helper.getLayerId()).toBeNull();
+        });
+        it('calls offLayerError before removing old layer in addToMapInternal', async () => {
+            const testHelper = asHelperInternals(helper);
+            testHelper.layerId = 'old-layer';
+            testHelper.mapProvider = mockProvider;
+            const mockVMap = createMockVMap(mockProvider);
+            const mockGroup = createMockGroup('g1');
+            await testHelper.addToMapInternal(mockGroup, mockVMap, () => ({ type: 'osm' }));
+            // offLayerError should have been called for the old layer
+            expect(mockProvider.offLayerError).toHaveBeenCalledWith('old-layer');
+            // And onLayerError for the new layer
+            expect(mockProvider.onLayerError).toHaveBeenCalledWith('group-layer-id', expect.any(Function));
+        });
+        it('does not throw if provider lacks offLayerError', async () => {
+            const testHelper = asHelperInternals(helper);
+            const providerWithoutOff = createMockMapProvider();
+            delete providerWithoutOff.offLayerError;
+            testHelper.mapProvider = providerWithoutOff;
+            testHelper.layerId = 'layer-1';
+            // Should not throw
+            await helper.removeLayer();
+            expect(helper.getLayerId()).toBeNull();
+        });
+    });
+});

package/dist/collection/lib/cesium-loader.js

@@ -0,0 +1,58 @@
+import { CESIUM_VERSION } from "./versions.gen";
+import { AsyncMutex } from "../utils/async-mutex";
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(msg);
+}
+const sameMM = (exp, act) => exp.match(/^\d+\.\d+/)?.[0] === act.match(/^\d+\.\d+/)?.[0];
+const loadCesiumMutex = new AsyncMutex();
+export async function loadCesium(version = CESIUM_VERSION) {
+    const v = version.replace(/^[^\d]*/, '');
+    const base = `https://cdn.jsdelivr.net/npm/cesium@${v}/Build/Cesium`;
+    const url = `${base}/Cesium.js`;
+    await loadCesiumMutex.runExclusive(async () => {
+        if (!globalThis.Cesium) {
+            await new Promise((resolve, reject) => {
+                const id = 'cesium-cdn-script';
+                if (document.getElementById(id))
+                    return resolve();
+                const s = document.createElement('script');
+                s.id = id;
+                s.async = true;
+                s.src = url;
+                s.addEventListener('load', () => resolve(), { once: true });
+                s.addEventListener('error', () => reject(new Error(`Laden fehlgeschlagen: ${url}`)), { once: true });
+                document.head.appendChild(s);
+            });
+        }
+    });
+    const Cesium = globalThis.Cesium;
+    assert(Cesium, 'globalThis.Cesium nicht verfügbar.');
+    const actual = Cesium.VERSION; // z.B. "1.133"
+    assert(sameMM(String(version), actual), // Major.Minor muss passen
+    `Cesium-Version abweichend: erwartet ~${version}, geladen ${actual}`);
+    globalThis.CESIUM_BASE_URL = base;
+    return Cesium;
+}
+export async function injectWidgetsCss(shadowRoot) {
+    const v = CESIUM_VERSION.replace(/^[^\d]*/, '');
+    const base = `https://cdn.jsdelivr.net/npm/cesium@${v}/Build/Cesium`;
+    const cssUrl = `${base}/Widgets/widgets.css`;
+    const cssText = await (await fetch(cssUrl)).text();
+    const absolutized = cssText.replace(/url\((?!['"]?data:)(['"]?)([^'")]+)\1\)/g, (_m, _q, rel) => `url(${base}/Widgets/${rel.replace(/^\.?\//, '')})`);
+    if (!shadowRoot)
+        return;
+    if ('adoptedStyleSheets' in Document.prototype) {
+        const sheet = new CSSStyleSheet();
+        await sheet.replace(absolutized);
+        shadowRoot.adoptedStyleSheets = [
+            ...(shadowRoot.adoptedStyleSheets ?? []),
+            sheet,
+        ];
+    }
+    else {
+        const style = document.createElement('style');
+        style.textContent = absolutized;
+        shadowRoot.appendChild(style);
+    }
+}

package/dist/collection/lib/ensure-importmap.js

@@ -0,0 +1,12 @@
+import { IMPORT_MAP_JSON } from "./versions.gen";
+export 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);
+    }
+}

package/dist/collection/lib/ensure-importmap.unit.js

@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { IMPORT_MAP_JSON } from "./versions.gen";
+import { ensureImportMap } from "./ensure-importmap";
+function stubDocument(options) {
+    const appended = [];
+    const fakeDocument = {
+        querySelector: (selector) => {
+            if (selector === 'script[type="importmap"]' &&
+                options?.hasAnyImportMap) {
+                return {};
+            }
+            if (selector === 'script[type="importmap"][data-v-map]' &&
+                options?.hasVMapImportMap) {
+                return {};
+            }
+            return null;
+        },
+        createElement: (_tagName) => ({
+            type: '',
+            dataset: {},
+            textContent: null,
+        }),
+        head: {
+            appendChild: (node) => {
+                appended.push(node);
+                return node;
+            },
+        },
+    };
+    vi.stubGlobal('document', fakeDocument);
+    return appended;
+}
+describe('ensureImportMap unit', () => {
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('appends a v-map importmap when none exists', () => {
+        const appended = stubDocument();
+        ensureImportMap();
+        expect(appended).toHaveLength(1);
+        expect(appended[0]).toEqual({
+            type: 'importmap',
+            dataset: { vMap: 'true' },
+            textContent: IMPORT_MAP_JSON,
+        });
+    });
+    it('skips injection when another importmap exists and override is allowed', () => {
+        const appended = stubDocument({ hasAnyImportMap: true });
+        ensureImportMap();
+        expect(appended).toHaveLength(0);
+    });
+    it('does not append a duplicate v-map importmap', () => {
+        const appended = stubDocument({ hasVMapImportMap: true });
+        ensureImportMap({ allowOverride: false });
+        expect(appended).toHaveLength(0);
+    });
+});

package/dist/collection/lib/versions.gen.js

@@ -0,0 +1,6 @@
+/* AUTO-GENERATED: DO NOT EDIT. Run "pnpm build" to regenerate. */
+export const CESIUM_VERSION = '1.139.1';
+export const OL_VERSION = '10.8.0';
+export const LEAFLET_VERSION = '1.9.4';
+export const DECK_VERSION = '9.2.11';
+export 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}";

package/dist/collection/lib/vstyle.js

@@ -0,0 +1,8 @@
+export const VSTYLE_DEFAULT = {
+    rules: [
+        { polygon: { fill: 'rgba(0,120,255,0.15)', stroke: { color: '#0971fe', width: 1 } } },
+        { line: { color: '#0971fe', width: ['interpolate', 'linear', ['zoom'], 4, 1, 10, 3] } },
+        { point: { radius: ['interpolate', 'linear', ['zoom'], 4, 3, 10, 6], fill: '#0971fe', stroke: { color: '#fff', width: 1 } } },
+        { label: { text: ['get', 'name'], color: '#111', size: ['interpolate', 'linear', ['zoom'], 4, 11, 10, 14], halo: { color: '#fff', width: 2 } } },
+    ]
+};