@npm9912/v-map 0.1.0

package/dist/types/map-provider/geotiff/utils/normalization-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Normalization utilities for raster data
+ * Handles conversion of different TypedArray types to normalized 0-255 range
+ */
+export type TypedArrayType = 'Uint8Array' | 'Uint16Array' | 'Int16Array' | 'Uint32Array' | 'Int32Array' | 'Float32Array' | 'Float64Array';
+/**
+ * Normalize a raw value to 0-255 range based on array type
+ * @param rawValue - The raw value from the raster
+ * @param arrayType - The TypedArray type name
+ * @returns Normalized value 0-255
+ */
+export declare function normalizeValue(rawValue: number, arrayType: TypedArrayType): number;
+/**
+ * Normalize a raw value to 0-1 range for colormap application
+ * @param rawValue - The raw value from the raster
+ * @param valueRange - Optional [min, max] range. If not provided, assumes normalized data.
+ * @returns Normalized value 0-1
+ */
+export declare function normalizeToColorMapRange(rawValue: number, valueRange?: [number, number]): number;
+/**
+ * Auto-detect value range from a Float32/Float64 array sample
+ * Useful when valueRange is not provided
+ * @param data - The raster data array
+ * @param sampleSize - Number of samples to analyze (default: 1000)
+ * @returns Detected [min, max] range
+ */
+export declare function autoDetectValueRange(data: Float32Array | Float64Array, sampleSize?: number): [number, number];
+/**
+ * Check if a TypedArray type represents floating point data
+ * @param arrayType - The TypedArray type name
+ * @returns True if Float32Array or Float64Array
+ */
+export declare function isFloatType(arrayType: TypedArrayType): boolean;
+/**
+ * Get the typical value range for a TypedArray type
+ * @param arrayType - The TypedArray type name
+ * @returns [min, max] range for the type
+ */
+export declare function getTypeRange(arrayType: TypedArrayType): [number, number];

package/dist/types/map-provider/geotiff/utils/sampling-utils.d.ts

@@ -0,0 +1,13 @@
+import { type TypedArrayType } from './normalization-utils';
+import { type ColorStop } from './colormap-utils';
+export type TypedArray = Uint8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+/**
+ * Nearest-Neighbor Sampling with window-based reading and multi-band support
+ * Returns [R, G, B, A] values (0-255)
+ */
+export declare function sampleNearest(x: number, y: number, rasterBands: TypedArray[], arrayType: TypedArrayType, width: number, height: number, offsetX: number, offsetY: number, colorStops?: ColorStop[]): [number, number, number, number] | null;
+/**
+ * Bilinear Interpolation with window-based reading and multi-band support
+ * Returns [R, G, B, A] values (0-255)
+ */
+export declare function sampleBilinear(x: number, y: number, rasterBands: TypedArray[], arrayType: TypedArrayType, width: number, height: number, offsetX: number, offsetY: number, colorStops?: ColorStop[]): [number, number, number, number] | null;

package/dist/types/map-provider/leaflet/GeoTIFFGridLayer.d.ts

@@ -0,0 +1,34 @@
+import * as L from 'leaflet';
+import type { Coords, DoneCallback } from 'leaflet';
+import { getColorStops } from '../geotiff/utils/colormap-utils';
+export interface GeoTIFFGridLayerOptions extends L.GridLayerOptions {
+    url: string;
+    colorMap?: Parameters<typeof getColorStops>[0];
+    valueRange?: [number, number];
+    nodata?: number;
+    resolution?: number;
+    resampleMethod?: 'near' | 'bilinear';
+    tileSize?: number;
+    opacity?: number;
+    zIndex?: number;
+    viewProjection?: string;
+}
+export declare class GeoTIFFGridLayer extends L.GridLayer {
+    private readonly geotiffOptions;
+    private tileProcessor;
+    private colorStops?;
+    private loadingPromise?;
+    private readonly defaultResolution;
+    private readonly defaultResample;
+    constructor(options: GeoTIFFGridLayerOptions);
+    onAdd(map: L.Map): this;
+    createTile(coords: Coords, done: DoneCallback): HTMLCanvasElement;
+    private ensureReady;
+    updateSource(options: Partial<GeoTIFFGridLayerOptions>): Promise<void>;
+    private initializeProcessor;
+    /**
+     * Set Leaflet bounds from GeoTIFF source bounds
+     * Restricts tile loading to the GeoTIFF coverage area
+     */
+    private setViewBounds;
+}

package/dist/types/map-provider/leaflet/WCSGridLayer.d.ts

@@ -0,0 +1,38 @@
+import * as L from 'leaflet';
+export interface WCSGridLayerOptions extends L.GridLayerOptions {
+    url: string;
+    coverageName: string;
+    version?: string;
+    format?: string;
+    projection?: string;
+    params?: Record<string, string | number | boolean>;
+}
+/**
+ * Custom Leaflet GridLayer for WCS (Web Coverage Service) support
+ *
+ * Supports:
+ * - WCS 2.0.1 with subset parameters
+ * - WCS 1.x.x with BBOX parameters (backward compatibility)
+ * - GeoTIFF FLOAT32 format
+ * - Dynamic BBOX-based requests
+ */
+export declare class WCSGridLayer extends L.GridLayer {
+    private wcsOptions;
+    constructor(options: WCSGridLayerOptions);
+    /**
+     * Build WCS GetCoverage URL for a given tile
+     */
+    private buildWCSUrl;
+    /**
+     * Create tile element (required by GridLayer)
+     */
+    createTile(coords: L.Coords, done: L.DoneCallback): HTMLElement;
+    /**
+     * Update WCS options and redraw
+     */
+    updateOptions(newOptions: Partial<WCSGridLayerOptions>): void;
+}
+/**
+ * Factory function to create a WCS GridLayer
+ */
+export declare function createWCSGridLayer(options: WCSGridLayerOptions): WCSGridLayer;

package/dist/types/map-provider/leaflet/google-map-tiles-layer.d.ts

@@ -0,0 +1,73 @@
+import * as L from 'leaflet';
+type ScaleFactor = 'scaleFactor1x' | 'scaleFactor2x' | 'scaleFactor4x';
+interface GoogleMapTilesOptions {
+    apiKey: string;
+    mapType?: string;
+    language?: string;
+    region?: string;
+    imageFormat?: string;
+    scale?: ScaleFactor;
+    highDpi?: boolean;
+    layerTypes?: string[];
+    overlay?: boolean;
+    styles?: Record<string, unknown>[];
+    apiOptions?: string[];
+    maxZoom?: number;
+    minZoom?: number;
+    minNativeZoom?: number;
+    maxNativeZoom?: number;
+    opacity?: number;
+    tileSize?: unknown;
+    attribution?: unknown;
+    bounds?: unknown;
+    updateWhenIdle?: boolean;
+    updateWhenZooming?: boolean;
+    updateInterval?: number;
+    className?: string;
+    keepBuffer?: number;
+    noWrap?: boolean;
+    pane?: string;
+    zIndex?: number;
+    zoomOffset?: number;
+    errorTileUrl?: string;
+    subdomains?: unknown;
+    tms?: boolean;
+    detectRetina?: boolean;
+    reuseTiles?: boolean;
+    [key: string]: unknown;
+}
+export declare class GoogleMapTilesLayer extends L.GridLayer {
+    private readonly apiKey;
+    private readonly highDpi;
+    private readonly sessionRequest;
+    private readonly scaleFactor;
+    private sessionToken?;
+    private sessionPromise?;
+    private sessionRefreshId?;
+    private previousViewport?;
+    private currentAttribution?;
+    private mapInstance?;
+    private readonly onMoveEnd;
+    constructor(options: GoogleMapTilesOptions);
+    onAdd(map: L.Map): this;
+    onRemove(map: L.Map): this;
+    createTile(coords: L.Coords, done: L.DoneCallback): HTMLElement;
+    private ensureSession;
+    private startSessionFetch;
+    private fetchAndApplySession;
+    private scheduleSessionRefresh;
+    private clearSessionRefresh;
+    private updateAttribution;
+    private applyAttribution;
+    private removeCurrentAttribution;
+    private applyTileSize;
+    private parseExpiry;
+    private buildTileUrl;
+    private mapScaleToFactor;
+    private factorToScale;
+    private applyInitialGridOptions;
+    private setGridOptions;
+    private resolveTileSize;
+    private redrawLayer;
+}
+export {};

package/dist/types/map-provider/leaflet/leaflet-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { CssMode } from '../../types/cssmode';
+import * as L from 'leaflet';
+export declare function removeInjectedCss(shadowRoot: ShadowRoot, injectedStyle: HTMLStyleElement): void;
+export declare function ensureLeafletCss(mode: CssMode, root?: ShadowRoot): HTMLStyleElement | null;
+/** Fügt ein kleines Google-Logo als Leaflet-Control hinzu (Branding-Sicherheit) */
+export declare function ensureGoogleLogo(map: L.Map, markAdded: () => void): void;

package/dist/types/map-provider/leaflet/leaflet-provider.d.ts

@@ -0,0 +1,73 @@
+import type { MapProvider, LayerUpdate, LayerErrorCallback } from '../../types/mapprovider';
+import type { ProviderOptions } from '../../types/provideroptions';
+import type { LayerConfig } from '../../types/layerconfig';
+import type { LonLat } from '../../types/lonlat';
+import * as L from 'leaflet';
+export declare class LeafletProvider implements MapProvider {
+    private map?;
+    private layers;
+    private baseLayers;
+    private hiddenLayerGroups;
+    private googleLogoAdded;
+    private unsubscribeResize;
+    private shadowRoot;
+    private injectedStyle;
+    private layerErrorCallbacks;
+    private layerErrorCleanups;
+    init(options: ProviderOptions): Promise<void>;
+    updateLayer(layerId: string, update: LayerUpdate): Promise<void>;
+    addLayerToGroup(layerConfig: LayerConfig): Promise<string>;
+    addBaseLayer(layerConfig: LayerConfig, basemapid: string, layerElementId: string): Promise<string>;
+    setBaseLayer(groupId: string, layerElementId: string): Promise<void>;
+    private getLayerId;
+    private normalizeAttribution;
+    private _getLayerById;
+    private createLayer;
+    private updateGeoJSONLayer;
+    private createGeoJSONLayer;
+    private createXYZLayer;
+    private updateOSMLayer;
+    private createOSMLayer;
+    private createWMSLayer;
+    private buildArcGISUrl;
+    private createArcGISLayer;
+    private updateArcGISLayer;
+    private createGoogleLayer;
+    private tryParseStyles;
+    destroy(): Promise<void>;
+    setView([lon, lat]: LonLat, zoom: number): Promise<void>;
+    onLayerError(layerId: string, callback: LayerErrorCallback): void;
+    offLayerError(layerId: string): void;
+    removeLayer(layerId: string): Promise<void>;
+    setZIndex(layerId: string, zIndex: number): Promise<void>;
+    setOpacity(layerId: string, opacity: number): Promise<void>;
+    private setOpacityByLayer;
+    setVisible(layerId: string, visible: boolean): Promise<void>;
+    private setVisibleByLayer;
+    private setLayerOpacity;
+    ensureGroup(groupId: string, visible: boolean, _opts?: {
+        basemapid?: string;
+    }): Promise<void>;
+    private _ensureGroup;
+    private _getLayerGroupById;
+    setGroupVisible(groupId: string, visible: boolean): Promise<void>;
+    private updateWKTLayer;
+    private createWKTLayer;
+    private wktToGeoJSON;
+    private createGeoTIFFLayer;
+    private updateGeoTIFFLayer;
+    private createWCSLayer;
+    private updateWCSLayer;
+    /**
+     * Convert a Geostyler style to Leaflet GeoJSON options
+     */
+    private createGeostylerLeafletOptions;
+    private createLeafletStyle;
+    private createLeafletPoint;
+    private bindLeafletPopup;
+    private createWFSLayer;
+    private updateWFSLayer;
+    private fetchWFSFromUrl;
+    private appendParams;
+    getMap(): L.Map;
+}

package/dist/types/map-provider/ol/CustomGeoTiff.d.ts

@@ -0,0 +1,14 @@
+import type { Options as GeoTIFFOptions } from 'ol/source/GeoTIFF';
+import GeoTIFF from 'ol/source/GeoTIFF';
+import type { GeoKeys, ProjectionParameters } from 'geotiff-geokeys-to-proj4';
+import type { Projection } from 'ol/proj';
+type GeoKeysLike = Partial<GeoKeys>;
+export interface CustomGeoTiffInstance extends GeoTIFF {
+    getGeoKeys(): Promise<GeoKeysLike | null>;
+    getProjectionParameters(): Promise<ProjectionParameters | null>;
+    getProj4String(): Promise<string | null>;
+    registerProjectionIfNeeded(): Promise<Projection | null>;
+}
+export type CustomGeoTiffConstructor = new () => CustomGeoTiffInstance;
+export declare function createCustomGeoTiff(options: GeoTIFFOptions): Promise<CustomGeoTiffConstructor>;
+export {};

package/dist/types/map-provider/ol/openlayers-helper.d.ts

@@ -0,0 +1,2 @@
+/** CSS in ShadowRoot injizieren – ohne '?inline', kompatibel zu Stencil/Rollup */
+export declare function injectOlCss(shadowRoot?: ShadowRoot): Promise<void>;

package/dist/types/map-provider/ol/openlayers-provider.d.ts

@@ -0,0 +1,80 @@
+import Map from 'ol/Map';
+import type { MapProvider, LayerUpdate, LayerErrorCallback } from '../../types/mapprovider';
+import type { ProviderOptions } from '../../types/provideroptions';
+import type { LayerConfig } from '../../types/layerconfig';
+import type { LonLat } from '../../types/lonlat';
+export declare class OpenLayersProvider implements MapProvider {
+    private map;
+    private layers;
+    private baseLayers;
+    private googleLogoAdded;
+    private projection;
+    private layerErrorCallbacks;
+    private layerErrorCleanups;
+    init(options: ProviderOptions): Promise<void>;
+    destroy(): Promise<void>;
+    updateLayer(layerId: string, update: LayerUpdate): Promise<void>;
+    ensureGroup(groupId: string, visible: boolean, _opts?: {
+        basemapid?: string;
+    }): Promise<void>;
+    private _ensureGroup;
+    setBaseLayer(groupId: string, layerElementId: string): Promise<void>;
+    addBaseLayer(layerConfig: LayerConfig, basemapid: string, layerElementId: string): Promise<string>;
+    addLayerToGroup(layerConfig: LayerConfig): Promise<string>;
+    private createLayer;
+    private updateWMSLayer;
+    private updateOSMLayer;
+    private updateGeoJSONLayer;
+    private updateWFSLayer;
+    private updateWCSLayer;
+    private updateArcGISLayer;
+    private createEnhancedStyleFunction;
+    private createGeoJSONLayer;
+    private createWFSSpource;
+    private createWFSLayer;
+    /**
+     * Convert a GeoStyler style to an OpenLayers style function.
+     *
+     * TODO: Replace this hand-rolled conversion (~200 lines) with
+     * geostyler-openlayers-parser's writeStyle(). The official parser
+     * covers more symbolizer types, handles filters, and stays in sync
+     * with the GeoStyler spec. See:
+     * https://github.com/geostyler/geostyler-openlayers-parser
+     */
+    private createGeostylerStyleFunction;
+    private createXYZLayer;
+    private createGoogleLayer;
+    private createOSMLayer;
+    private createWMSLayer;
+    onLayerError(layerId: string, callback: LayerErrorCallback): void;
+    offLayerError(layerId: string): void;
+    private attachSourceErrorListeners;
+    setView(center: LonLat, zoom: number): Promise<void>;
+    private _forEachLayer;
+    private _getLayerById;
+    private _getLayerGroupById;
+    removeLayer(layerId: string): Promise<void>;
+    setOpacity(layerId: string, opacity: number): Promise<void>;
+    setZIndex(layerId: string, zIndex: number): Promise<void>;
+    setVisible(layerId: string, visible: boolean): Promise<void>;
+    setGroupVisible(groupId: string, visible: boolean): Promise<void>;
+    private updateWKTLayer;
+    private createWKTLayer;
+    private createGeoTIFFLayer;
+    private createWCSLayer;
+    private getWFSGetFeatureUrl;
+    /**
+     * Erstellt eine WCS GetCoverage URL mit dynamischem BBOX für WCS 2.0.1 und 1.x.x
+     */
+    private getWCSGetCoverageUrl;
+    private mergeLayerConfig;
+    private appendParams;
+    /**
+     * Erstellt eine WCS Image Source mit dynamischem BBOX-basierten Loading
+     * Unterstützt WCS 2.0.1 und 1.x.x mit GeoTIFF FLOAT32
+     */
+    private createWcsSource;
+    private createArcGISLayer;
+    private updateGeoTIFFLayer;
+    getMap(): Map;
+}

package/dist/types/map-provider/provider-factory.d.ts

@@ -0,0 +1,12 @@
+import type { MapProvider } from '../types/mapprovider';
+import type { Flavour } from '../types/flavour';
+/**
+ * Erzeugt eine konkrete Karten-Provider-Instanz abhängig vom gewählten Flavour.
+ *
+ * Unterstützt:
+ * - "ol"      → OpenLayers
+ * - "cesium"  → CesiumJS
+ * - "deck"    → Deck.gl
+ * - "leaflet" → Leaflet
+ */
+export declare function createProvider(engine: Flavour): Promise<MapProvider>;

package/dist/types/map-provider/provider-factory.unit.d.ts

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

package/dist/types/namespaces.d.ts

@@ -0,0 +1,3 @@
+// types/namespaces.d.ts
+export type CesiumNS = typeof import('cesium');
+export type OlNS = typeof import('ol'); // OL hat eigene TS-Types

package/dist/types/ol-augment.d.ts

@@ -0,0 +1,3 @@
+declare module 'ol' {
+  export const VERSION: string; // viele Bundles exportieren das
+}

package/dist/types/ol-override.d.ts

@@ -0,0 +1,7 @@
+// Override für OpenLayers PaletteTexture TypeScript-Problem
+declare module 'ol/webgl/PaletteTexture' {
+  export interface PaletteTexture {
+    name: string;
+    data: Uint8Array; // Fix: Remove generic parameter
+  }
+}

package/dist/types/ol.d.ts

@@ -0,0 +1,10 @@
+// Local OpenLayers type fixes
+declare module 'ol/webgl/PaletteTexture' {
+  export interface PaletteTexture {
+    name: string;
+    data: Uint8Array; // Fixed: removed generic parameter
+  }
+}
+
+// Re-export everything else from the original ol types
+export * from 'ol';