@npm9912/v-map 0.1.0

package/dist/collection/types/styleconfig.js

@@ -0,0 +1,19 @@
+/**
+ * Default style configuration values
+ */
+export const DEFAULT_STYLE = {
+    // Fill styling
+    fillColor: 'rgba(0, 100, 255, 0.3)',
+    fillOpacity: 0.3,
+    // Stroke styling
+    strokeColor: 'rgba(0, 100, 255, 1)',
+    strokeWidth: 2,
+    strokeOpacity: 1,
+    // Point styling
+    pointRadius: 6,
+    pointColor: 'rgba(0, 100, 255, 1)',
+    pointOpacity: 1,
+    // Text styling
+    textColor: '#000000',
+    textSize: 12,
+};

package/dist/collection/types/styling.js

@@ -0,0 +1,13 @@
+function isArrayLike(val) {
+    return (val != null &&
+        typeof val.length === 'number' &&
+        (Array.isArray(val) || typeof val[0] !== 'undefined'));
+}
+export function isGeoStylerStyle(obj) {
+    // Schnell‑Abbruch, wenn kein Objekt vorliegt
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    const u = obj;
+    // Pflichtfelder prüfen
+    return typeof u.name === 'string' && isArrayLike(u.rules);
+}

package/dist/collection/types/styling.unit.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { isGeoStylerStyle } from "./styling";
+describe('isGeoStylerStyle', () => {
+    it('returns true for a style-like object with a name and rules array', () => {
+        expect(isGeoStylerStyle({
+            name: 'Style',
+            rules: [],
+        })).toBe(true);
+    });
+    it('returns true for array-like rules', () => {
+        expect(isGeoStylerStyle({
+            name: 'Style',
+            rules: { 0: { name: 'rule' }, length: 1 },
+        })).toBe(true);
+    });
+    it('returns false for null and non-objects', () => {
+        expect(isGeoStylerStyle(null)).toBe(false);
+        expect(isGeoStylerStyle('style')).toBe(false);
+        expect(isGeoStylerStyle(42)).toBe(false);
+    });
+    it('returns false when name is missing or not a string', () => {
+        expect(isGeoStylerStyle({ rules: [] })).toBe(false);
+        expect(isGeoStylerStyle({
+            name: 123,
+            rules: [],
+        })).toBe(false);
+    });
+    it('returns false when rules are missing or not array-like', () => {
+        expect(isGeoStylerStyle({
+            name: 'Style',
+        })).toBe(false);
+        expect(isGeoStylerStyle({
+            name: 'Style',
+            rules: {},
+        })).toBe(false);
+    });
+});

package/dist/collection/types/vmaplayer.js

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

package/dist/collection/utils/async-mutex.js

@@ -0,0 +1,28 @@
+// utils/async-mutex.ts
+export class AsyncMutex {
+    locked = false;
+    queue = [];
+    async runExclusive(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => this.queue.push(resolve));
+    }
+    release() {
+        const next = this.queue.shift();
+        if (next)
+            next();
+        else
+            this.locked = false;
+    }
+}

package/dist/collection/utils/diff.js

@@ -0,0 +1,142 @@
+const EPS = 1e-9;
+function toBoolString(v) {
+    if (v == null)
+        return undefined;
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    const s = String(v).toLowerCase();
+    if (s === 'true' || s === '1')
+        return 'true';
+    if (s === 'false' || s === '0')
+        return 'false';
+    return s;
+}
+function toNumOrUndef(v) {
+    if (v == null)
+        return undefined;
+    const n = typeof v === 'number' ? v : Number(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+/** stable JSON for objects (key-sorted) */
+function stableStringify(obj) {
+    if (obj == null)
+        return undefined;
+    if (typeof obj !== 'object')
+        return JSON.stringify(obj);
+    const keys = Object.keys(obj).sort();
+    const acc = {};
+    for (const k of keys)
+        acc[k] = obj[k];
+    return JSON.stringify(acc);
+}
+function eqNum(a, b) {
+    if (a == null && b == null)
+        return true;
+    if (a == null || b == null)
+        return false;
+    return Math.abs(a - b) <= EPS;
+}
+function eqStr(a, b) {
+    return (a ?? undefined) === (b ?? undefined);
+}
+/** Compare fields relevant for rendering; returns patch (only changed fields) */
+export function diffRelevantFields(a, b) {
+    const changes = {};
+    if (a.type !== b.type)
+        changes.type = { old: a.type, new: b.type };
+    const aVisible = toBoolString(a.visible);
+    const bVisible = toBoolString(b.visible);
+    if (!eqStr(aVisible, bVisible))
+        changes.visible = { old: aVisible, new: bVisible };
+    const aOpacity = toNumOrUndef(a.opacity);
+    const bOpacity = toNumOrUndef(b.opacity);
+    if (!eqNum(aOpacity, bOpacity))
+        changes.opacity = { old: aOpacity, new: bOpacity };
+    const aZ = toNumOrUndef(a.zIndex);
+    const bZ = toNumOrUndef(b.zIndex);
+    if (!eqNum(aZ, bZ))
+        changes.zIndex = { old: aZ, new: bZ };
+    if (!eqStr(a.url, b.url))
+        changes.url = { old: a.url, new: b.url };
+    if (!eqStr(a.layers, b.layers))
+        changes.layers = { old: a.layers, new: b.layers };
+    const aTiled = toBoolString(a.tiled);
+    const bTiled = toBoolString(b.tiled);
+    if (!eqStr(aTiled, bTiled))
+        changes.tiled = { old: aTiled, new: bTiled };
+    const aStyle = stableStringify(a.style);
+    const bStyle = stableStringify(b.style);
+    if (!eqStr(aStyle, bStyle))
+        changes.style = { old: a.style, new: b.style };
+    const aData = stableStringify(a.data);
+    const bData = stableStringify(b.data);
+    if (!eqStr(aData, bData))
+        changes.data = { old: a.data, new: b.data };
+    return changes;
+}
+/** Longest Common Subsequence for stable move detection (by IDs) */
+function lcs(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            dp[i][j] =
+                a[i] === b[j]
+                    ? dp[i + 1][j + 1] + 1
+                    : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const seq = [];
+    let i = 0, j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            seq.push(a[i]);
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1])
+            i++;
+        else
+            j++;
+    }
+    return seq;
+}
+/** Computes added/removed/updated/moved/unchanged */
+export function diffLayers(oldLayers, newLayers) {
+    const oldById = new Map(oldLayers.map(l => [l.id, l]));
+    const newById = new Map(newLayers.map(l => [l.id, l]));
+    const added = [];
+    const removed = [];
+    const updated = [];
+    const unchangedIds = [];
+    for (const newL of newLayers) {
+        const oldL = oldById.get(newL.id);
+        if (!oldL) {
+            added.push(newL);
+            continue;
+        }
+        const changes = diffRelevantFields(oldL, newL);
+        if (Object.keys(changes).length)
+            updated.push({ id: newL.id, changes });
+        else
+            unchangedIds.push(newL.id);
+    }
+    for (const oldL of oldLayers) {
+        if (!newById.has(oldL.id))
+            removed.push(oldL);
+    }
+    const oldIds = oldLayers.filter(l => newById.has(l.id)).map(l => l.id);
+    const newIds = newLayers.filter(l => oldById.has(l.id)).map(l => l.id);
+    const seq = lcs(oldIds, newIds);
+    const keep = new Set(seq);
+    const moved = [];
+    for (const id of newIds) {
+        if (!keep.has(id) && !added.find(a => a.id === id)) {
+            const from = oldIds.indexOf(id);
+            const to = newIds.indexOf(id);
+            if (from !== -1 && to !== -1)
+                moved.push({ id, from, to });
+        }
+    }
+    return { added, removed, updated, moved, unchangedIds };
+}

package/dist/collection/utils/diff.unit.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { diffLayers, diffRelevantFields, } from "./diff";
+function baseLayer(overrides = {}) {
+    return {
+        id: 'layer-1',
+        type: 'wms',
+        visible: true,
+        opacity: 1,
+        zIndex: 10,
+        url: 'https://example.com/wms',
+        layers: 'base',
+        tiled: 'false',
+        style: { color: 'red', width: 2 },
+        data: { key: 'value' },
+        ...overrides,
+    };
+}
+describe('diff unit', () => {
+    it('treats normalized visible, opacity, zIndex and object order as unchanged', () => {
+        const before = baseLayer({
+            visible: true,
+            opacity: '1',
+            zIndex: '10',
+            style: { width: 2, color: 'red' },
+        });
+        const after = baseLayer({
+            visible: '1',
+            opacity: 1,
+            zIndex: 10,
+            style: { color: 'red', width: 2 },
+        });
+        expect(diffRelevantFields(before, after)).toEqual({});
+    });
+    it('returns added, removed, updated and moved layers separately', () => {
+        const oldLayers = [
+            baseLayer({ id: 'a', type: 'osm' }),
+            baseLayer({ id: 'b', opacity: 0.7 }),
+            baseLayer({ id: 'c', type: 'xyz' }),
+        ];
+        const newLayers = [
+            baseLayer({ id: 'b', opacity: 0.9 }),
+            baseLayer({ id: 'a', type: 'osm' }),
+            baseLayer({ id: 'd', type: 'geojson' }),
+        ];
+        const result = diffLayers(oldLayers, newLayers);
+        expect(result.added).toEqual([baseLayer({ id: 'd', type: 'geojson' })]);
+        expect(result.removed).toEqual([baseLayer({ id: 'c', type: 'xyz' })]);
+        expect(result.updated).toEqual([
+            {
+                id: 'b',
+                changes: {
+                    opacity: { old: 0.7, new: 0.9 },
+                },
+            },
+        ]);
+        expect(result.moved).toEqual([{ id: 'a', from: 0, to: 1 }]);
+        expect(result.unchangedIds).toEqual(['a']);
+    });
+});

package/dist/collection/utils/dom-env.js

@@ -0,0 +1,43 @@
+export const isBrowser = () => typeof window !== 'undefined' && typeof document !== 'undefined';
+export 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. */
+export 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);
+    };
+}

package/dist/collection/utils/dom-env.unit.js

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { isBrowser, supportsAdoptedStyleSheets, watchElementResize, } from "./dom-env";
+describe('dom-env unit', () => {
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+    it('returns false when window and document are unavailable', () => {
+        vi.stubGlobal('window', undefined);
+        vi.stubGlobal('document', undefined);
+        expect(isBrowser()).toBe(false);
+    });
+    it('detects adoptedStyleSheets support from the relevant globals', () => {
+        class FakeSheet {
+        }
+        Object.defineProperty(FakeSheet.prototype, 'replaceSync', {
+            configurable: true,
+            value: () => undefined,
+        });
+        vi.stubGlobal('window', {});
+        vi.stubGlobal('document', { adoptedStyleSheets: [] });
+        vi.stubGlobal('CSSStyleSheet', FakeSheet);
+        expect(supportsAdoptedStyleSheets()).toBe(true);
+    });
+    it('uses ResizeObserver when available and disconnects on unsubscribe', () => {
+        const observe = vi.fn();
+        const disconnect = vi.fn();
+        const callbacks = [];
+        class MockResizeObserver {
+            constructor(cb) {
+                callbacks.push(cb);
+            }
+            observe = observe;
+            disconnect = disconnect;
+        }
+        vi.stubGlobal('ResizeObserver', MockResizeObserver);
+        const cb = vi.fn();
+        const target = {};
+        const unsubscribe = watchElementResize(target, cb);
+        callbacks[0]();
+        expect(observe).toHaveBeenCalledWith(target);
+        expect(cb).toHaveBeenCalledTimes(1);
+        unsubscribe();
+        expect(disconnect).toHaveBeenCalledTimes(1);
+    });
+    it('falls back to window resize, MutationObserver and polling when ResizeObserver is unavailable', () => {
+        const addEventListener = vi.fn();
+        const removeEventListener = vi.fn();
+        let resizeHandler;
+        addEventListener.mockImplementation((type, handler) => {
+            if (type === 'resize')
+                resizeHandler = handler;
+        });
+        const rafCallbacks = [];
+        const requestAnimationFrame = vi.fn((cb) => {
+            rafCallbacks.push(cb);
+            return 1;
+        });
+        const setIntervalSpy = vi.fn(() => 123);
+        const clearIntervalSpy = vi.fn();
+        const observe = vi.fn();
+        const disconnect = vi.fn();
+        const mutationCallbacks = [];
+        class MockMutationObserver {
+            constructor(cb) {
+                mutationCallbacks.push(cb);
+            }
+            observe = observe;
+            disconnect = disconnect;
+        }
+        vi.stubGlobal('ResizeObserver', undefined);
+        vi.stubGlobal('window', { addEventListener, removeEventListener });
+        vi.stubGlobal('requestAnimationFrame', requestAnimationFrame);
+        vi.stubGlobal('setInterval', setIntervalSpy);
+        vi.stubGlobal('clearInterval', clearIntervalSpy);
+        vi.stubGlobal('MutationObserver', MockMutationObserver);
+        const cb = vi.fn();
+        const target = {};
+        const mutationObserverInit = { attributes: true };
+        const unsubscribe = watchElementResize(target, cb, mutationObserverInit);
+        resizeHandler?.();
+        mutationCallbacks[0]();
+        rafCallbacks.forEach((fn) => fn());
+        expect(observe).toHaveBeenCalledWith(target, mutationObserverInit);
+        expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 250);
+        expect(cb).toHaveBeenCalledTimes(2);
+        unsubscribe();
+        expect(removeEventListener).toHaveBeenCalledWith('resize', resizeHandler);
+        expect(disconnect).toHaveBeenCalledTimes(1);
+        expect(clearIntervalSpy).toHaveBeenCalledWith(123);
+    });
+});

package/dist/collection/utils/events.js

@@ -0,0 +1,8 @@
+// events.ts
+export const VMapEvents = {
+    Ready: 'ready',
+    Error: 'vmap-error',
+    MapProviderReady: 'map-provider-ready',
+    MapProviderWillShutdown: 'map-provider-will-shutdown',
+    MapMouseMove: 'map-mousemove',
+};

package/dist/collection/utils/logger.js

@@ -0,0 +1,183 @@
+import { Build } from "@stencil/core";
+/** Stencil-nativ: prod = !Build.isDev */
+export const isProd = !Build.isDev;
+// ---- Exposure-Gate (macht Konsole-APIs auch in Prod verfügbar, wenn explizit aktiviert) ----
+const EXPOSE_KEY = '@pt9912/v-map:exposeConsoleAPI';
+const urlHasDebugFlag = (() => {
+    try {
+        return (typeof location !== 'undefined' &&
+            new URLSearchParams(location.search).has('vmapDebug'));
+    }
+    catch {
+        return false;
+    }
+})();
+const exposureEnabled = !isProd ||
+    urlHasDebugFlag ||
+    (typeof localStorage !== 'undefined' &&
+        localStorage.getItem(EXPOSE_KEY) === '1');
+/* ------------------------- Storage-Helfer -------------------------- */
+const LS_KEY = '@pt9912/v-map:logLevel';
+function getLocalStorage() {
+    try {
+        if (typeof window !== 'undefined' && 'localStorage' in window) {
+            return window.localStorage;
+        }
+    }
+    catch {
+        /* no-op (Privacy/Storage blocked o. Ä.) */
+    }
+    return null;
+}
+function readPersistedLevel() {
+    const ls = getLocalStorage();
+    if (!ls)
+        return null;
+    const raw = ls.getItem(LS_KEY);
+    if (!raw)
+        return null;
+    if (raw === 'none' ||
+        raw === 'error' ||
+        raw === 'warn' ||
+        raw === 'info' ||
+        raw === 'debug') {
+        return raw;
+    }
+    return null;
+}
+function writePersistedLevel(level) {
+    const ls = getLocalStorage();
+    if (!ls)
+        return;
+    try {
+        ls.setItem(LS_KEY, level);
+    }
+    catch {
+        /* no-op */
+    }
+}
+/* ---------- 1️⃣ Runtime-Konfiguration (Log-Level, Transport) ---------- */
+/** Standard-Default: prod -> bis warn, dev -> bis debug */
+const DEFAULT_LEVEL = isProd ? 'warn' : 'debug';
+/** Initiales Level: persisted > default */
+let currentLevel = readPersistedLevel() ?? DEFAULT_LEVEL;
+/** Standard-Transport: schreibt in die native Browser-Console. */
+class ConsoleTransport {
+    log(level, args, ns) {
+        const prefix = ns ? `[${ns}]` : undefined;
+        const enhancedArgs = [...args];
+        if (level === 'debug' || level === 'warn' || level === 'error') {
+            const showTrace = level === 'debug' || level === 'warn' || level === 'error';
+            const stackTrace = showTrace
+                ? new Error().stack?.split('\n')[4]?.trim()
+                : null;
+            if (stackTrace) {
+                enhancedArgs.push(`${stackTrace}`);
+            }
+        }
+        switch (level) {
+            case 'debug':
+            case 'info':
+                if (prefix)
+                    console.log(prefix, ...enhancedArgs);
+                else
+                    console.log(...enhancedArgs);
+                break;
+            case 'warn':
+                if (prefix)
+                    console.warn(prefix, ...enhancedArgs);
+                else
+                    console.warn(...enhancedArgs);
+                break;
+            case 'error':
+                if (prefix)
+                    console.error(prefix, ...enhancedArgs);
+                else
+                    console.error(...enhancedArgs);
+                break;
+            // 'none' wird nicht geroutet
+        }
+    }
+}
+let transport = new ConsoleTransport();
+/**
+ * Ändert das globale Log-Level zur Laufzeit und persistiert es.
+ * Praktisch für Tests, Feature-Flags und DevTools.
+ */
+export function setLogLevel(level) {
+    currentLevel = level;
+    writePersistedLevel(level);
+}
+/** Aktuelles Log-Level abfragen (z. B. in DevTools) */
+export function getLogLevel() {
+    return currentLevel;
+}
+/**
+ * Ersetzt den aktiven Transport (z. B. für Remote-Logging).
+ */
+export function setTransport(t) {
+    transport = t;
+}
+/* ---------------------- 2️⃣ Hilfsfunktionen ---------------------- */
+/** Prüft, ob ein gegebener Level laut aktueller Konfiguration ausgegeben werden darf. */
+function shouldLog(level) {
+    const order = {
+        none: 0,
+        error: 1,
+        warn: 2,
+        info: 3,
+        debug: 4,
+    };
+    return order[level] <= order[currentLevel];
+}
+/** Kern-Logger – wird von den öffentlichen Methoden genutzt. */
+function _log(level, args, namespace) {
+    if (!shouldLog(level))
+        return;
+    transport.log(level, args, namespace);
+}
+/* ---------------------- 3️⃣ Öffentliche API ---------------------- */
+/**
+ * Erzeugt eine Logger-Instanz mit Namespace-Präfix.
+ * Ideal für Komponenten: `const log = createLogger('MyComponent');`
+ */
+export function createLogger(namespace) {
+    return {
+        debug: (...args) => _log('debug', args, namespace),
+        info: (...args) => _log('info', args, namespace),
+        warn: (...args) => _log('warn', args, namespace),
+        error: (...args) => _log('error', args, namespace),
+    };
+}
+/* ----------- 4️⃣ Convenience-Wrapper für globale Nutzung ------------ */
+export const log = (...args) => _log('debug', args);
+export const info = (...args) => _log('info', args);
+export const warn = (...args) => _log('warn', args);
+export const error = (...args) => _log('error', args);
+if (exposureEnabled && typeof globalThis !== 'undefined') {
+    const g = globalThis;
+    g.setLogLevel = setLogLevel;
+    g.getLogLevel = getLogLevel;
+    g.log = (...args) => log(...args);
+    g.info = (...args) => info(...args);
+    g.warn = (...args) => warn(...args);
+    g.error = (...args) => error(...args);
+}
+//devtools
+//http://localhost:6006/?path=/docs/...&vmapDebug
+/*
+localStorage.setItem('@pt9912/v-map:exposeConsoleAPI', '1');
+localStorage.getItem('@pt9912/v-map:exposeConsoleAPI');
+location.reload();
+*/
+/*
+const LOG_LEVEL='debug'
+const KEY = '@pt9912/v-map:logLevel';
+for (let i = 0; i < top.frames.length; i++) {
+  try { top.frames[i].localStorage.setItem(KEY, LOG_LEVEL); } catch {}
+}
+try { window.localStorage.setItem(KEY, LOG_LEVEL); } catch {}
+top.location.reload();
+*/
+//getLogLevel()
+//setLogLevel('info')