@npm9912/v-map 0.1.0

package/dist/types/testing/browser-test-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function createTaggedElement<T extends HTMLElement>(tagName: string): T;
+export declare function loadVMapBundle(): Promise<void>;
+export declare function waitFor(condition: () => boolean, timeoutMs?: number): Promise<void>;
+export declare function waitForHydration(element: Element): Promise<void>;
+export declare function onceEvent<T extends Event>(target: EventTarget, type: string, timeoutMs?: number): Promise<T>;
+export declare function createLiveMap(flavour?: 'leaflet' | 'ol' | 'deck' | 'cesium'): HTMLVMapElement;

package/dist/types/testing/e2e-testing.d.ts

@@ -0,0 +1,5 @@
+export * from '@stencil/core/testing';
+import { newE2EPage as _newE2EPage } from '@stencil/core/testing';
+export declare const newE2EPage: typeof _newE2EPage & {
+    setIgnoreError: (errorPattern: string) => void;
+};

package/dist/types/testing/e2e-utils.d.ts

@@ -0,0 +1,4 @@
+import type { E2EPage } from '@stencil/core/testing';
+export declare function failOnConsole(page: E2EPage, opts?: {
+    ignore?: RegExp[];
+}): void;

package/dist/types/testing/geotiff-test-server.d.ts

@@ -0,0 +1,5 @@
+export interface GeoTiffTestServer {
+    close: () => Promise<void>;
+    url: string;
+}
+export declare function startGeoTiffTestServer(fixturePath?: string, route?: string): Promise<GeoTiffTestServer>;

package/dist/types/testing/mocks/geostyler-lyrx-parser.d.ts

@@ -0,0 +1,11 @@
+export default class LyrxParser {
+    readStyle(_content: string | object): Promise<{
+        output: {
+            name: string;
+            layers: any[];
+            _meta: {
+                format: string;
+            };
+        };
+    }>;
+}

package/dist/types/testing/mocks/geostyler-mapbox-parser.d.ts

@@ -0,0 +1,11 @@
+export default class MapboxParser {
+    readStyle(_content: string | object): Promise<{
+        output: {
+            name: string;
+            layers: any[];
+            _meta: {
+                format: string;
+            };
+        };
+    }>;
+}

package/dist/types/testing/mocks/geostyler-qgis-parser.d.ts

@@ -0,0 +1,11 @@
+export default class QGISParser {
+    readStyle(_content: string): Promise<{
+        output: {
+            name: string;
+            rules: any[];
+            _meta: {
+                format: string;
+            };
+        };
+    }>;
+}

package/dist/types/testing/mocks/geostyler-sld-parser.d.ts

@@ -0,0 +1,11 @@
+export default class SLDParser {
+    readStyle(_content: string): Promise<{
+        output: {
+            name: string;
+            rules: any[];
+            _meta: {
+                format: string;
+            };
+        };
+    }>;
+}

package/dist/types/testing/mocks/geostyler-style.d.ts

@@ -0,0 +1,5 @@
+export declare const Style: Record<string, unknown>;
+declare const _default: {
+    Style: Record<string, unknown>;
+};
+export default _default;

package/dist/types/testing/setupTests.browser.d.ts

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

package/dist/types/testing/setupTests.stencil.d.ts

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

package/dist/types/testing/setupTests.vitest.d.ts

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

package/dist/types/testing/stencil-testing-wrapper.d.ts

@@ -0,0 +1,3 @@
+export * from '@stencil/core/testing';
+import { newE2EPage as _newE2EPage } from '@stencil/core/testing';
+export declare const newE2EPage: typeof _newE2EPage;

package/dist/types/types/color.d.ts

@@ -0,0 +1 @@
+export type Color = string | [number, number, number, number?];

package/dist/types/types/cssmode.d.ts

@@ -0,0 +1 @@
+export type CssMode = 'inline-min' | 'cdn' | 'none' | 'bundle';

package/dist/types/types/flavour.d.ts

@@ -0,0 +1 @@
+export type Flavour = 'ol' | 'cesium' | 'leaflet' | 'deck';

package/dist/types/types/layerconfig.d.ts

@@ -0,0 +1,207 @@
+import type { StyleConfig } from './styleconfig';
+import type { Color } from './color';
+import type { Style, ColorMap as GeoStylerColorMap } from 'geostyler-style';
+export type googleMapType = 'roadmap' | 'satellite' | 'terrain' | 'hybrid';
+export type LayerConfig = {
+    type: 'geojson';
+    url?: string;
+    geojson?: string;
+    style?: StyleConfig;
+    geostylerStyle?: Style;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'osm';
+    groupId?: string;
+    groupVisible?: boolean;
+    url?: string;
+    opacity?: number;
+    zIndex?: number;
+    visible?: boolean;
+} | {
+    type: 'geotiff';
+    groupId?: string;
+    groupVisible?: boolean;
+    url?: string;
+    nodata?: number;
+    colorMap?: string | GeoStylerColorMap;
+    valueRange?: [number, number];
+    opacity?: number;
+    zIndex?: number;
+    visible?: boolean;
+} | {
+    type: 'xyz';
+    url: string;
+    attributions?: string | string[];
+    maxZoom?: number;
+    options?: Record<string, unknown>;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'arcgis';
+    url: string;
+    params?: Record<string, string | number | boolean>;
+    token?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    options?: Record<string, unknown>;
+    attributions?: string | string[];
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'google';
+    apiKey: string;
+    mapType?: googleMapType;
+    scale?: 'scaleFactor1x' | 'scaleFactor2x' | 'scaleFactor4x';
+    highDpi?: boolean;
+    opacity?: number;
+    visible?: boolean;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    maxZoom?: number;
+    styles?: Record<string, unknown>[] | string;
+    language?: string;
+    libraries?: string[];
+    region?: string;
+    layerTypes?: string[];
+    overlay?: boolean;
+    imageFormat?: string;
+    apiOptions?: string[];
+} | {
+    type: 'wms';
+    url: string;
+    layers: string;
+    extraParams?: Record<string, string>;
+    groupId?: string;
+    groupVisible?: boolean;
+    opacity?: number;
+    visible?: boolean;
+    zIndex?: number;
+    tileSize?: number;
+    version?: '1.1.1' | '1.3.0';
+    crs?: string;
+    format?: string;
+    transparent?: string;
+    styles?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    time?: string;
+} | {
+    type: 'scatterplot';
+    data?: unknown;
+    getFillColor?: Color;
+    getRadius?: number;
+    opacity?: number;
+    visible?: boolean;
+    getTooltip?: (info: Record<string, unknown>) => unknown;
+    onClick?: (info: Record<string, unknown>) => void;
+    onHover?: (info: Record<string, unknown>) => void;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+} | {
+    type: 'terrain';
+    elevationData: string;
+    texture?: string;
+    elevationDecoder?: {
+        r: number;
+        g: number;
+        b: number;
+        offset: number;
+    };
+    wireframe?: boolean;
+    color?: [number, number, number];
+    minZoom?: number;
+    maxZoom?: number;
+    meshMaxError?: number;
+    groupId?: string;
+    groupVisible?: boolean;
+    opacity?: number;
+    visible?: boolean;
+    zIndex?: number;
+} | {
+    type: 'wfs';
+    url: string;
+    typeName: string;
+    version?: string;
+    outputFormat?: string;
+    srsName?: string;
+    params?: Record<string, string | number | boolean>;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+    geostylerStyle?: Style;
+    style?: StyleConfig;
+} | {
+    type: 'wcs';
+    url: string;
+    coverageName: string;
+    format?: string;
+    version?: string;
+    projection?: string;
+    resolutions?: number[];
+    params?: Record<string, string | number | boolean>;
+    tileSize?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'wkt';
+    wkt?: string;
+    url?: string;
+    style?: StyleConfig;
+    geostylerStyle?: Style;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'tile3d';
+    url: string;
+    tilesetOptions?: Record<string, unknown>;
+    cesiumStyle?: Record<string, unknown>;
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+} | {
+    type: 'terrain-geotiff';
+    url: string;
+    projection?: string;
+    forceProjection?: boolean;
+    nodata?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    tileSize?: number;
+    meshMaxError?: number;
+    wireframe?: boolean;
+    texture?: string;
+    color?: [number, number, number];
+    colorMap?: string | GeoStylerColorMap;
+    valueRange?: [number, number];
+    elevationScale?: number;
+    renderMode?: 'terrain' | 'colormap';
+    groupId?: string;
+    groupVisible?: boolean;
+    zIndex?: number;
+    visible?: boolean;
+    opacity?: number;
+};

package/dist/types/types/lonlat.d.ts

@@ -0,0 +1 @@
+export type LonLat = [number, number];

package/dist/types/types/mapinitoptions.d.ts

@@ -0,0 +1,4 @@
+export type MapInitOptions = {
+    center?: [number, number];
+    zoom?: number;
+};

package/dist/types/types/mapprovider.d.ts

@@ -0,0 +1,46 @@
+import type { ProviderOptions } from './provideroptions';
+import type { LayerConfig } from './layerconfig';
+import type { LonLat } from './lonlat';
+export type LayerUpdate = {
+    [K in LayerConfig['type']]: {
+        type: K;
+        data: Partial<Extract<LayerConfig, {
+            type: K;
+        }>>;
+    };
+}[LayerConfig['type']] | {
+    type: 'tile3d-style';
+    data: {
+        style?: Record<string, unknown>;
+    };
+};
+export type LayerErrorCallback = (error: {
+    type: 'network';
+    message: string;
+    cause?: unknown;
+}) => void;
+export interface MapProvider {
+    init(options: ProviderOptions): Promise<void>;
+    destroy(): Promise<void>;
+    setOpacity(layerId: string, opacity: number): Promise<void>;
+    setVisible(layerId: string, visible: boolean): Promise<void>;
+    setZIndex(layerId: string, zIndex: number): Promise<void>;
+    /** Layer hinzufügen; Rückgabe bewusst async, weil Erzeugung/Importe asynchron sind */
+    addLayerToGroup(layer: LayerConfig): Promise<string>;
+    updateLayer(layerId: string, update: LayerUpdate): Promise<void>;
+    removeLayer(layerId: string): Promise<void>;
+    addBaseLayer?(layerConfig: LayerConfig, basemapid: string, layerElementId: string): Promise<string>;
+    setBaseLayer?(groupId: string, layerElementId: string): Promise<void>;
+    /** View/Camera setzen; in OL/Cesium meist async (Animations/Promises), daher Promise<void> */
+    setView(center: LonLat, zoom: number): Promise<void>;
+    ensureGroup(groupId: string, visible: boolean, opts?: {
+        basemapid?: string;
+    }): Promise<void>;
+    setGroupVisible?(groupId: string, visible: boolean): Promise<void>;
+    /** Register a callback for runtime layer errors (tile load, feature fetch, etc.). */
+    onLayerError?(layerId: string, callback: LayerErrorCallback): void;
+    /** Unregister the runtime error callback and detach native listeners for a layer. */
+    offLayerError?(layerId: string): void;
+    /** Register a callback for pointer-move with geo-coordinates. Returns unsubscribe function. */
+    onPointerMove?(callback: (coordinate: [number, number] | null, pixel: [number, number]) => void): () => void;
+}

package/dist/types/types/provideroptions.d.ts

@@ -0,0 +1,8 @@
+import type { MapInitOptions } from './mapinitoptions';
+import type { CssMode } from './cssmode';
+export type ProviderOptions = {
+    target: HTMLDivElement;
+    shadowRoot?: ShadowRoot;
+    mapInitOptions?: MapInitOptions;
+    cssMode?: CssMode;
+};

package/dist/types/types/styleconfig.d.ts

@@ -0,0 +1,27 @@
+export interface StyleConfig {
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeDashArray?: number[];
+    pointRadius?: number;
+    pointColor?: string;
+    pointOpacity?: number;
+    iconUrl?: string;
+    iconSize?: [number, number];
+    iconAnchor?: [number, number];
+    textProperty?: string;
+    textColor?: string;
+    textSize?: number;
+    textHaloColor?: string;
+    textHaloWidth?: number;
+    textOffset?: [number, number];
+    zOffset?: number;
+    extrudeHeight?: number;
+    styleFunction?: (feature: unknown) => Partial<StyleConfig>;
+}
+/**
+ * Default style configuration values
+ */
+export declare const DEFAULT_STYLE: Readonly<Required<Omit<StyleConfig, 'iconUrl' | 'iconSize' | 'iconAnchor' | 'textProperty' | 'textHaloColor' | 'textHaloWidth' | 'textOffset' | 'zOffset' | 'extrudeHeight' | 'styleFunction' | 'strokeDashArray'>>>;

package/dist/types/types/styling.d.ts

@@ -0,0 +1,24 @@
+import { Style } from 'geostyler-style';
+export type Cesium3DTileStyle = Record<string, unknown>;
+export type StyleFormat = 'sld' | 'mapbox-gl' | 'qgis' | 'lyrx' | 'cesium-3d-tiles' | 'geostyler';
+export type ResolvedStyle = Style | Cesium3DTileStyle;
+export interface StyleApplyOptions {
+    /**
+     * Layer IDs to apply the style to.
+     */
+    layerIds?: string[];
+    /**
+     * Whether to replace existing styles or merge with them.
+     * @default 'replace'
+     */
+    mode?: 'replace' | 'merge';
+    /**
+     * Optional priority for style application.
+     */
+    priority?: number;
+}
+export type StyleEvent = {
+    style?: ResolvedStyle;
+    layerIds?: string[];
+};
+export declare function isGeoStylerStyle(obj: unknown): obj is Style;

package/dist/types/types/styling.unit.d.ts

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

package/dist/types/types/vmaplayer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gemeinsame API für alle Map‑Layer‑Components.
+ */
+export interface VMapLayer {
+    /** Sichtbarkeit des Layers */
+    visible: boolean;
+    opacity: number;
+    zIndex: number;
+    isReady?(): boolean;
+}

package/dist/types/utils/async-mutex.d.ts

@@ -0,0 +1,7 @@
+export declare class AsyncMutex {
+    private locked;
+    private queue;
+    runExclusive<T>(fn: () => Promise<T> | T): Promise<T>;
+    private acquire;
+    private release;
+}

package/dist/types/utils/diff.d.ts

@@ -0,0 +1,64 @@
+export type LayerType = 'osm' | 'wms' | 'wms-tiled' | 'geojson' | 'xyz' | 'terrain' | 'wfs' | 'wcs' | 'google' | 'geotiff' | 'tile3d' | 'scatterplot' | 'wkt' | 'custom';
+export interface LayerGroup {
+    groupTitle: string;
+    basemapid: string;
+    visible?: boolean | string;
+    layers: NormalizedLayer[];
+}
+export interface NormalizedStyle {
+    /** internal identifier to keep track between updates */
+    key: string;
+    format: string;
+    src?: string;
+    content?: string;
+    layerTargets?: string;
+    autoApply?: boolean;
+    id?: string;
+}
+export interface MapConfig {
+    flavour: string;
+    id: string;
+    zoom: number;
+    center: string;
+    style: string;
+    styles: NormalizedStyle[];
+    layerGroups: LayerGroup[];
+}
+export interface BuilderConfig {
+    map: MapConfig;
+}
+export interface NormalizedLayer {
+    id: string;
+    type: LayerType;
+    visible?: boolean | string;
+    opacity?: number | string;
+    zIndex?: number | string;
+    url?: string;
+    layers?: string;
+    tiled?: string;
+    data?: unknown;
+    style?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type LayerPatch = {
+    id: string;
+    changes: Partial<Record<'type' | 'visible' | 'opacity' | 'zIndex' | 'url' | 'layers' | 'tiled' | 'style' | 'data', {
+        old: unknown;
+        new: unknown;
+    }>>;
+};
+export type LayersDiff = {
+    added: NormalizedLayer[];
+    removed: NormalizedLayer[];
+    updated: LayerPatch[];
+    moved: Array<{
+        id: string;
+        from: number;
+        to: number;
+    }>;
+    unchangedIds: string[];
+};
+/** Compare fields relevant for rendering; returns patch (only changed fields) */
+export declare function diffRelevantFields(a: NormalizedLayer, b: NormalizedLayer): LayerPatch['changes'];
+/** Computes added/removed/updated/moved/unchanged */
+export declare function diffLayers(oldLayers: NormalizedLayer[], newLayers: NormalizedLayer[]): LayersDiff;

package/dist/types/utils/diff.unit.d.ts

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

package/dist/types/utils/dom-env.d.ts

@@ -0,0 +1,5 @@
+export declare const isBrowser: () => boolean;
+export declare const supportsAdoptedStyleSheets: () => boolean;
+export type Unsubscribe = () => void;
+/** Beobachtet Größenänderungen des Targets. Nutzt ResizeObserver wenn vorhanden, sonst Fallback. */
+export declare function watchElementResize(target: HTMLElement, cb: () => void, mutationObserverInit?: MutationObserverInit): Unsubscribe;

package/dist/types/utils/dom-env.unit.d.ts

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

package/dist/types/utils/events.d.ts

@@ -0,0 +1,29 @@
+import type { MapProvider } from '../types/mapprovider';
+export declare const VMapEvents: {
+    readonly Ready: "ready";
+    readonly Error: "vmap-error";
+    readonly MapProviderReady: "map-provider-ready";
+    readonly MapProviderWillShutdown: "map-provider-will-shutdown";
+    readonly MapMouseMove: "map-mousemove";
+};
+export interface VMapErrorDetail {
+    /** Error category */
+    type: 'network' | 'validation' | 'parse' | 'provider';
+    /** Human-readable error message */
+    message: string;
+    /** Affected prop/attribute (if applicable) */
+    attribute?: string;
+    /** Original thrown value (if available) */
+    cause?: unknown;
+}
+export type VMapEventMap = {
+    [VMapEvents.Ready]: void;
+    [VMapEvents.Error]: VMapErrorDetail;
+};
+export interface MapProviderDetail {
+    mapProvider: MapProvider;
+}
+export interface MapMouseMoveDetail {
+    coordinate: [number, number] | null;
+    pixel: [number, number];
+}

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,47 @@
+type LogLevel = 'none' | 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Transport-Interface – definiert, wohin ein Log geschrieben wird.
+ * Du kannst z. B. einen HTTP-Transport für Remote-Logging implementieren.
+ */
+export interface LogTransport {
+    /** Log-Methode, die vom Logger intern aufgerufen wird. */
+    log(level: LogLevel, args: readonly unknown[], namespace?: string): void;
+}
+/** Stencil-nativ: prod = !Build.isDev */
+export declare const isProd: boolean;
+/**
+ * Ändert das globale Log-Level zur Laufzeit und persistiert es.
+ * Praktisch für Tests, Feature-Flags und DevTools.
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/** Aktuelles Log-Level abfragen (z. B. in DevTools) */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Ersetzt den aktiven Transport (z. B. für Remote-Logging).
+ */
+export declare function setTransport(t: LogTransport): void;
+/**
+ * Erzeugt eine Logger-Instanz mit Namespace-Präfix.
+ * Ideal für Komponenten: `const log = createLogger('MyComponent');`
+ */
+export declare function createLogger(namespace: string): {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export declare const log: (...args: unknown[]) => void;
+export declare const info: (...args: unknown[]) => void;
+export declare const warn: (...args: unknown[]) => void;
+export declare const error: (...args: unknown[]) => void;
+declare global {
+    interface Window {
+        setLogLevel?: (level: LogLevel) => void;
+        getLogLevel?: () => LogLevel;
+        log?: (...args: unknown[]) => void;
+        info?: (...args: unknown[]) => void;
+        warn?: (...args: unknown[]) => void;
+        error?: (...args: unknown[]) => void;
+    }
+}
+export {};

package/dist/types/utils/logger.unit.d.ts

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

package/dist/types/utils/messages.d.ts

@@ -0,0 +1,12 @@
+export declare const MESSAGES: {
+    COMPONENT_CONNECTED_CALLBACK: string;
+    COMPONENT_WILL_LOAD: string;
+    COMPONENT_WILL_UPDATE: string;
+    COMPONENT_WILL_RENDER: string;
+    COMPONENT_RENDER: string;
+    COMPONENT_DID_RENDER: string;
+    COMPONENT_DID_LOAD: string;
+    COMPONENT_DID_UPDATE: string;
+    COMPONENT_DISCONNECTED_CALLBACK: string;
+};
+export default MESSAGES;

package/dist/types/utils/spatial-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function mercatorFromLonLat([lon, lat]: [number, number]): [
+    number,
+    number
+];
+export declare function formatBbox(west: number, south: number, east: number, north: number, version: '1.1.1' | '1.3.0', crs: string): string;
+export declare function buildQuery(params: Record<string, string | number | boolean | undefined>): string;

package/dist/types/utils/spatial-utils.unit.d.ts

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

package/dist/types/versions.d.ts

@@ -0,0 +1,7 @@
+// types/versions.d.ts  (TS kennt die Konstante & macht strenge Prüfung)
+declare const CESIUM_VERSION:
+  | `${number}.${number}.${number}`
+  | `${number}.${number}`;
+declare const OL_VERSION:
+  | `${number}.${number}.${number}`
+  | `${number}.${number}`;