@npm9912/v-map 0.1.0

package/dist/collection/map-provider/provider-factory.js

@@ -0,0 +1,44 @@
+import { log } from "../utils/logger";
+/** 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
+ */
+export async function createProvider(engine) {
+    try {
+        switch (engine) {
+            case 'ol': {
+                const { OpenLayersProvider } = await import('./ol/openlayers-provider');
+                return new OpenLayersProvider();
+            }
+            case 'cesium': {
+                const { CesiumProvider } = await import('./cesium/cesium-provider');
+                return new CesiumProvider();
+            }
+            case 'deck': {
+                const { DeckProvider } = await import('./deck/deck-provider');
+                return new DeckProvider();
+            }
+            case 'leaflet': {
+                const { LeafletProvider } = await import('./leaflet/leaflet-provider');
+                return new LeafletProvider();
+            }
+            default: {
+                // Exhaustiveness: Falls Flavour erweitert wird, meckert TS hier
+                return assertNever(engine, `Unbekannte Engine: ${engine}`);
+            }
+        }
+    }
+    catch (e) {
+        log(e);
+        throw e;
+    }
+}

package/dist/collection/map-provider/provider-factory.unit.js

@@ -0,0 +1,66 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+const { logMock, OpenLayersProviderMock, CesiumProviderMock, DeckProviderMock, LeafletProviderMock, } = vi.hoisted(() => ({
+    logMock: vi.fn(),
+    OpenLayersProviderMock: vi.fn(),
+    CesiumProviderMock: vi.fn(),
+    DeckProviderMock: vi.fn(),
+    LeafletProviderMock: vi.fn(),
+}));
+vi.mock('../utils/logger', () => ({
+    log: logMock,
+}));
+vi.mock('./ol/openlayers-provider', () => ({
+    OpenLayersProvider: OpenLayersProviderMock,
+}));
+vi.mock('./cesium/cesium-provider', () => ({
+    CesiumProvider: CesiumProviderMock,
+}));
+vi.mock('./deck/deck-provider', () => ({
+    DeckProvider: DeckProviderMock,
+}));
+vi.mock('./leaflet/leaflet-provider', () => ({
+    LeafletProvider: LeafletProviderMock,
+}));
+async function loadFactory() {
+    vi.resetModules();
+    return import('./provider-factory');
+}
+describe('provider-factory unit', () => {
+    afterEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('creates the expected provider for each supported flavour', async () => {
+        OpenLayersProviderMock.mockImplementation(function OpenLayersProvider() {
+            return { engine: 'ol' };
+        });
+        CesiumProviderMock.mockImplementation(function CesiumProvider() {
+            return { engine: 'cesium' };
+        });
+        DeckProviderMock.mockImplementation(function DeckProvider() {
+            return { engine: 'deck' };
+        });
+        LeafletProviderMock.mockImplementation(function LeafletProvider() {
+            return { engine: 'leaflet' };
+        });
+        const { createProvider } = await loadFactory();
+        await expect(createProvider('ol')).resolves.toEqual({ engine: 'ol' });
+        await expect(createProvider('cesium')).resolves.toEqual({ engine: 'cesium' });
+        await expect(createProvider('deck')).resolves.toEqual({ engine: 'deck' });
+        await expect(createProvider('leaflet')).resolves.toEqual({ engine: 'leaflet' });
+    });
+    it('logs and rethrows provider creation errors', async () => {
+        const providerError = new Error('deck failed');
+        DeckProviderMock.mockImplementation(function DeckProvider() {
+            throw providerError;
+        });
+        const { createProvider } = await loadFactory();
+        await expect(createProvider('deck')).rejects.toThrow('deck failed');
+        expect(logMock).toHaveBeenCalledWith(providerError);
+    });
+    it('rejects unsupported flavours at runtime', async () => {
+        const { createProvider } = await loadFactory();
+        await expect(createProvider('unknown')).rejects.toThrow('Unbekannte Engine: unknown');
+        expect(logMock).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/collection/testing/browser-test-utils.js

@@ -0,0 +1,49 @@
+let bundlePromise;
+export function createTaggedElement(tagName) {
+    return document.createElement(tagName);
+}
+export async function loadVMapBundle() {
+    if (!bundlePromise) {
+        // Browser tests intentionally load the built Stencil bundle at runtime.
+        // `tsc --noEmit` runs before `dist` exists in CI, so this must stay a string import.
+        bundlePromise = Function('return import("/dist/v-map/v-map.esm.js")')().then(() => undefined);
+    }
+    await bundlePromise;
+}
+export async function waitFor(condition, timeoutMs = 3_000) {
+    const deadline = performance.now() + timeoutMs;
+    while (performance.now() < deadline) {
+        if (condition())
+            return;
+        await new Promise(resolve => requestAnimationFrame(() => resolve(undefined)));
+    }
+    throw new Error('Timed out while waiting for browser test condition');
+}
+export async function waitForHydration(element) {
+    await waitFor(() => element.classList.contains('hydrated'));
+}
+export function onceEvent(target, type, timeoutMs = 3_000) {
+    return new Promise((resolve, reject) => {
+        const timer = window.setTimeout(() => {
+            target.removeEventListener(type, onEvent);
+            reject(new Error(`Timed out while waiting for "${type}" event`));
+        }, timeoutMs);
+        const onEvent = (event) => {
+            window.clearTimeout(timer);
+            resolve(event);
+        };
+        target.addEventListener(type, onEvent, { once: true });
+    });
+}
+export function createLiveMap(flavour = 'leaflet') {
+    const map = createTaggedElement('v-map');
+    map.setAttribute('flavour', flavour);
+    map.setAttribute('center', '11.5761,48.1371');
+    map.setAttribute('zoom', '12');
+    map.setAttribute('css-mode', 'none');
+    map.style.display = 'block';
+    map.style.width = '300px';
+    map.style.height = '200px';
+    map.useDefaultImportMap = false;
+    return map;
+}

package/dist/collection/testing/e2e-testing.js

@@ -0,0 +1,122 @@
+export * from '@stencil/core/testing';
+import { newE2EPage as _newE2EPage } from "@stencil/core/testing";
+// Global list of additional errors to ignore
+const additionalIgnoredErrors = [];
+async function patchConsoleOnNewDocument(page) {
+    await page.evaluateOnNewDocument(() => {
+        const origError = console.error;
+        const origWarn = console.warn;
+        const origInfo = console.info;
+        const origLog = console.log;
+        const stringifyArg = (arg) => {
+            if (arg instanceof Error) {
+                return arg.stack || arg.message;
+            }
+            try {
+                if (typeof arg === 'string') {
+                    return arg;
+                }
+                return JSON.stringify(arg);
+            }
+            catch {
+                return String(arg);
+            }
+        };
+        console.error = (...args) => {
+            origError('[browser:error]', ...args.map(stringifyArg));
+        };
+        console.warn = (...args) => {
+            origWarn('[browser:warn]', ...args.map(stringifyArg));
+        };
+        console.info = (...args) => {
+            origInfo('[browser:info]', ...args.map(stringifyArg));
+        };
+        console.log = (...args) => {
+            origLog('[browser:log]', ...args.map(stringifyArg));
+        };
+        window.addEventListener('error', e => {
+            const err = e.error;
+            console.error('window.error:', err?.stack || e.message);
+        });
+        window.addEventListener('unhandledrejection', (e) => {
+            const r = e?.reason;
+            console.error('unhandledrejection:', (r && (r.stack || r.message)) || String(r));
+        });
+        try {
+            const seenDefines = new Set();
+            const seenMissing = new Set();
+            const origDefine = customElements.define.bind(customElements);
+            const origGet = customElements.get.bind(customElements);
+            customElements.define = (name, constructor, options) => {
+                seenDefines.add(name);
+                console.info(`[custom-elements#define] ${name}`);
+                return origDefine(name, constructor, options);
+            };
+            customElements.get = name => {
+                const ctor = origGet(name);
+                if (!ctor && !seenMissing.has(name)) {
+                    seenMissing.add(name);
+                    console.info(`[custom-elements#get-miss] ${name}`);
+                }
+                else if (ctor && !seenDefines.has(name)) {
+                    console.info(`[custom-elements#get-hit] ${name}`);
+                }
+                return ctor;
+            };
+        }
+        catch (err) {
+            console.warn('Failed to patch customElements logging', err);
+        }
+        document.addEventListener('readystatechange', () => {
+            console.info(`[document.readyState] ${document.readyState}`);
+        });
+        window.addEventListener('DOMContentLoaded', () => {
+            console.info('[lifecycle] DOMContentLoaded');
+        });
+        window.addEventListener('load', () => {
+            console.info('[lifecycle] load');
+        });
+    });
+}
+export const newE2EPage = (async (...args) => {
+    const page = await _newE2EPage(...args);
+    await patchConsoleOnNewDocument(page);
+    // Seitenbasierte Fehlerfalle
+    const { failOnConsole } = await import('./e2e-utils');
+    // Build the full ignore list by combining default and additional errors
+    const defaultIgnore = [
+        /useDefaultImportMap/i,
+        /Failed to resolve module specifier "child_process"/i,
+        /Failed to resolve module specifier "@loaders\.gl\//i,
+        /Blocked script execution in 'about:blank'/i,
+        /GPU stall due to ReadPixels/i,
+        /No map visible because the map container's width or height are 0/i,
+        /\[custom-elements#get-miss]/i,
+    ];
+    const additionalIgnore = additionalIgnoredErrors.map(pattern => new RegExp(pattern, 'i'));
+    failOnConsole(page, {
+        ignore: [...defaultIgnore, ...additionalIgnore],
+    });
+    // Netzwerkzugriffe für Debug-Zwecke protokollieren, um auffällige Requests (z. B. Google Maps) zu erkennen.
+    page.on('request', req => {
+        const url = req.url();
+        if (/^https:\/\/maps\.(googleapis|gstatic)\.com\//.test(url)) {
+            console.info(`[e2e] request ${url}`);
+        }
+    });
+    page.on('requestfailed', req => {
+        console.warn(`[e2e] request failed ${req.url()} :: ${req.failure()?.errorText}`);
+    });
+    return page;
+});
+/**
+ * Add an error pattern to the global ignore list for all E2E tests.
+ * This should be called before creating a new E2E page.
+ *
+ * @param errorPattern - String pattern to match against error messages (case-insensitive)
+ */
+newE2EPage.setIgnoreError = (errorPattern) => {
+    if (!additionalIgnoredErrors.includes(errorPattern)) {
+        additionalIgnoredErrors.push(errorPattern);
+    }
+};

package/dist/collection/testing/e2e-utils.js

@@ -0,0 +1,70 @@
+function anyToStringSafe(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    if (v && typeof v === 'object') {
+        const o = v;
+        if (typeof o.stack === 'string')
+            return o.stack;
+        if (typeof o.message === 'string')
+            return o.message;
+    }
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+export function failOnConsole(page, opts) {
+    const ignore = opts?.ignore ?? [];
+    page.on('console', async (msg) => {
+        // Hole Location, wenn verfügbar (Puppeteer hat location())
+        const loc = typeof msg.location === 'function'
+            ? msg.location()
+            : undefined;
+        // WICHTIG: JSHandles im Browser auswerten, um Error.stack zu bekommen
+        const argVals = await Promise.all(msg.args().map(a => a
+            .evaluate((v) => {
+            if (v instanceof Error)
+                return v.stack || v.message || String(v);
+            try {
+                return JSON.stringify(v);
+            }
+            catch {
+                return String(v);
+            }
+        })
+            .catch(() => undefined)));
+        const parts = [
+            msg.text(), // oft schon "Error: …"
+            ...argVals.map(anyToStringSafe), // sauber extrahiert
+            loc ? `${loc.url}:${loc.lineNumber}:${loc.columnNumber}` : '',
+        ].filter(Boolean);
+        const text = parts.join('\n');
+        const prefix = `[browser:${msg.type()}]`;
+        const line = `${prefix} ${text}\n`;
+        const shouldIgnore = ignore.some(rx => rx.test(text));
+        if (!shouldIgnore) {
+            if (msg.type() === 'error') {
+                process.stderr.write(line);
+            }
+            else if (msg.type() === 'warn') {
+                process.stdout.write(line);
+            }
+        }
+        if (msg.type() === 'error') {
+            if (shouldIgnore)
+                return;
+            throw new Error(`Console error in browser:\n${text}`);
+        }
+    });
+    page.on('pageerror', err => {
+        const text = anyToStringSafe(err);
+        console.error(`[browser:pageerror] ${text}`);
+        if (ignore.some(rx => rx.test(text)))
+            return;
+        throw new Error(`Unhandled page error:\n${text}`);
+    });
+}

package/dist/collection/testing/geotiff-test-server.js

@@ -0,0 +1,100 @@
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+function writeCorsHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', 'Range, Content-Type');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
+    res.setHeader('Access-Control-Expose-Headers', 'Accept-Ranges, Content-Length, Content-Range, Content-Type');
+}
+function parseRangeHeader(rangeHeader, size) {
+    const match = /^bytes=(\d+)-(\d+)?$/.exec(rangeHeader);
+    if (!match)
+        return null;
+    const start = Number.parseInt(match[1], 10);
+    const requestedEnd = match[2] !== undefined ? Number.parseInt(match[2], 10) : size - 1;
+    const end = Math.min(requestedEnd, size - 1);
+    if (Number.isNaN(start) || Number.isNaN(end) || start > end || start >= size) {
+        return null;
+    }
+    return { start, end };
+}
+function getPathname(req) {
+    return new URL(req.url ?? '/', 'http://127.0.0.1').pathname;
+}
+export async function startGeoTiffTestServer(fixturePath = path.resolve(process.cwd(), 'public/geotiff/cea.tif'), route = '/geotiff/cea.tif') {
+    const payload = readFileSync(fixturePath);
+    const server = createServer((req, res) => {
+        writeCorsHeaders(res);
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (getPathname(req) !== route) {
+            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Not found');
+            return;
+        }
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            res.writeHead(405, { Allow: 'GET, HEAD, OPTIONS' });
+            res.end();
+            return;
+        }
+        const baseHeaders = {
+            'Accept-Ranges': 'bytes',
+            'Content-Type': 'image/tiff',
+        };
+        const rangeHeader = req.headers.range;
+        if (!rangeHeader) {
+            res.writeHead(200, {
+                ...baseHeaders,
+                'Content-Length': String(payload.length),
+            });
+            if (req.method === 'HEAD') {
+                res.end();
+                return;
+            }
+            res.end(payload);
+            return;
+        }
+        const range = parseRangeHeader(rangeHeader, payload.length);
+        if (!range) {
+            res.writeHead(416, {
+                ...baseHeaders,
+                'Content-Range': `bytes */${payload.length}`,
+            });
+            res.end();
+            return;
+        }
+        const chunk = payload.subarray(range.start, range.end + 1);
+        res.writeHead(206, {
+            ...baseHeaders,
+            'Content-Length': String(chunk.length),
+            'Content-Range': `bytes ${range.start}-${range.end}/${payload.length}`,
+        });
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        res.end(chunk);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve());
+    });
+    const address = server.address();
+    const url = `http://127.0.0.1:${address.port}${route}`;
+    return {
+        url,
+        close: () => new Promise((resolve, reject) => {
+            server.close(err => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        }),
+    };
+}

package/dist/collection/testing/mocks/geostyler-lyrx-parser.js

@@ -0,0 +1,12 @@
+// src/testing/mocks/geostyler-lyrx-parser.ts
+export default class LyrxParser {
+    async readStyle(_content) {
+        return {
+            output: {
+                name: 'Mock LYRX Style',
+                layers: [],
+                _meta: { format: 'lyrx' },
+            },
+        };
+    }
+}

package/dist/collection/testing/mocks/geostyler-mapbox-parser.js

@@ -0,0 +1,12 @@
+// src/testing/mocks/geostyler-mapbox-parser.ts
+export default class MapboxParser {
+    async readStyle(_content) {
+        return {
+            output: {
+                name: 'Mock Mapbox Style',
+                layers: [],
+                _meta: { format: 'mapbox-gl' },
+            },
+        };
+    }
+}

package/dist/collection/testing/mocks/geostyler-qgis-parser.js

@@ -0,0 +1,12 @@
+// src/testing/mocks/geostyler-qgis-parser.ts
+export default class QGISParser {
+    async readStyle(_content) {
+        return {
+            output: {
+                name: 'Mock QGIS Style',
+                rules: [],
+                _meta: { format: 'qgis' },
+            },
+        };
+    }
+}

package/dist/collection/testing/mocks/geostyler-sld-parser.js

@@ -0,0 +1,13 @@
+// src/testing/mocks/geostyler-sld-parser.ts
+export default class SLDParser {
+    async readStyle(_content) {
+        return {
+            output: {
+                name: 'Mock SLD Style',
+                rules: [],
+                // Minimale geostyler-style-konforme Struktur
+                _meta: { format: 'sld' },
+            },
+        };
+    }
+}

package/dist/collection/testing/mocks/geostyler-style.js

@@ -0,0 +1,5 @@
+const mockStyle = {};
+export const Style = mockStyle;
+export default {
+    Style,
+};

package/dist/collection/testing/setupTests.browser.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/testing/setupTests.stencil.js

@@ -0,0 +1,20 @@
+import { vi } from "vitest";
+// Provide stub decorators so Stencil component source files can be imported.
+// The decorators are compile-time constructs; at runtime they are no-ops.
+const noop = () => (_target, _key) => { };
+const noopClass = (_opts) => (_target) => { };
+vi.mock('@stencil/core', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        Component: noopClass,
+        Prop: noop,
+        State: noop,
+        Element: noop,
+        Event: noop,
+        Watch: () => noop,
+        Method: noop,
+        Listen: () => noop,
+        Build: { isDev: true, isBrowser: false, isTesting: true },
+    };
+});

package/dist/collection/testing/setupTests.vitest.js

@@ -0,0 +1,59 @@
+import { vi } from "vitest";
+Object.defineProperty(document, 'createRange', {
+    value: () => ({
+        setStart: () => { },
+        setEnd: () => { },
+        commonAncestorContainer: document.body,
+        createContextualFragment: (html) => {
+            const t = document.createElement('template');
+            t.innerHTML = html;
+            return t.content;
+        },
+    }),
+});
+class RO {
+    observe() { }
+    unobserve() { }
+    disconnect() { }
+}
+global.ResizeObserver = RO;
+class MockMutationObserver {
+    observe() { }
+    disconnect() { }
+    takeRecords() {
+        return [];
+    }
+}
+if (typeof globalThis.MutationObserver === 'undefined') {
+    globalThis.MutationObserver = MockMutationObserver;
+}
+vi.mock('geostyler-sld-parser', () => import('./mocks/geostyler-sld-parser'));
+vi.mock('geostyler-mapbox-parser', () => import('./mocks/geostyler-mapbox-parser'));
+vi.mock('geostyler-qgis-parser', () => import('./mocks/geostyler-qgis-parser'));
+vi.mock('geostyler-lyrx-parser', () => import('./mocks/geostyler-lyrx-parser'));
+vi.mock('geostyler-style', () => import('./mocks/geostyler-style'));
+globalThis.global = globalThis;
+if (typeof window !== 'undefined') {
+    globalThis.Event = window.Event;
+    globalThis.CustomEvent = window.CustomEvent;
+}
+if (typeof HTMLCanvasElement !== 'undefined') {
+    Object.defineProperty(HTMLCanvasElement.prototype, 'getContext', {
+        configurable: true,
+        writable: true,
+        value: function getContext(_contextId) {
+            // jsdom logs noisy "Not implemented" errors for canvas. In spec tests we
+            // default to "no 2d context available" and let targeted tests override
+            // this when they need a working canvas mock.
+            return null;
+        },
+    });
+}
+// Catch known async leaks from test constructors that start fetch/timers
+const knownLeaks = /Google Maps session request failed|getBounds is not a function/;
+process.on('unhandledRejection', (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    if (knownLeaks.test(msg))
+        return;
+    throw reason;
+});

package/dist/collection/testing/stencil-testing-wrapper.js

@@ -0,0 +1,43 @@
+// Re-export alles aus dem Original
+export * from '@stencil/core/testing';
+import { newE2EPage as _newE2EPage } from "@stencil/core/testing";
+async function patchConsoleOnNewDocument(page) {
+    await page.evaluateOnNewDocument(() => {
+        const origError = console.error;
+        console.error = (...args) => {
+            const mapped = args.map(a => {
+                if (a instanceof Error)
+                    return a.stack || a.message;
+                try {
+                    return JSON.stringify(a);
+                }
+                catch {
+                    return String(a);
+                }
+            });
+            origError(...mapped);
+        };
+        window.addEventListener('error', e => {
+            const err = e.error;
+            console.error('window.error:', err?.stack || e.message);
+        });
+        window.addEventListener('unhandledrejection', (e) => {
+            const r = e?.reason;
+            console.error('unhandledrejection:', (r && (r.stack || r.message)) || String(r));
+        });
+    });
+}
+// unser Replacement für newE2EPage
+export const newE2EPage = (async (...args) => {
+    const page = await _newE2EPage(...args);
+    // 1) Browser: console.error patchen (Stack sichtbar machen)
+    await patchConsoleOnNewDocument(page);
+    // 2) Node-Seite: Console/Errors strikt überwachen (mit Whitelist)
+    const { failOnConsole } = await import('./e2e-utils');
+    const ignore = [
+        /useDefaultImportMap/i, // dein Dev-Log
+        ...(process.env.E2E_IGNORE?.split('|').map(s => new RegExp(s)) ?? []),
+    ];
+    failOnConsole(page, { ignore });
+    return page;
+});

package/dist/collection/testing/styleMock.js

@@ -0,0 +1 @@
+module.exports = {};

package/dist/collection/types/color.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/cssmode.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/flavour.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/layerconfig.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/lonlat.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/mapinitoptions.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/mapprovider.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/provideroptions.js

@@ -0,0 +1 @@
+export {};