@npm9912/v-map 0.1.0

package/dist/types/map-provider/deck/DeckGLGeoTIFFTerrainLayer.d.ts

@@ -0,0 +1,82 @@
+import type { Layer, LayerProps } from '@deck.gl/core';
+import type { ColorMap as GeoStylerColorMap } from 'geostyler-style';
+import { type ColorMapName } from '../geotiff/utils/colormap-utils';
+export interface DeckGLGeoTIFFTerrainLayerProps extends LayerProps {
+    url?: string;
+    /**
+     * Quell-Projektion des GeoTIFF (z. B. \"EPSG:32632\" oder proj4-String)
+     */
+    projection?: string;
+    /**
+     * Erzwingt die Verwendung der projection-Prop, ignoriert GeoKeys
+     */
+    forceProjection?: boolean;
+    /**
+     * NoData-Wert für ungültige Höhendaten
+     */
+    noDataValue?: number;
+    /**
+     * Minimale Zoom-Stufe
+     */
+    minZoom?: number;
+    /**
+     * Maximale Zoom-Stufe
+     */
+    maxZoom?: number;
+    /**
+     * Tile-Größe in Pixeln (muss 2^n sein, z. B. 256 oder 512)
+     */
+    tileSize?: number;
+    /**
+     * Mesh-Fehlertoleranz in Metern für Martini-Triangulierung.
+     * Kleinere Werte = detaillierteres Mesh, aber höhere GPU-Last.
+     * Default: 4.0
+     */
+    meshMaxError?: number;
+    /**
+     * Wireframe-Modus: zeigt nur Mesh-Linien (terrain-Modus)
+     * Default: false
+     */
+    wireframe?: boolean;
+    /**
+     * Textur-URL (optional)
+     */
+    texture?: string;
+    /**
+     * Farbe für das Terrain-Mesh (terrain-Modus, wenn keine Textur)
+     * [r, g, b] mit Werten 0-255
+     */
+    color?: [number, number, number];
+    /**
+     * ColorMap für Höhendaten-Visualisierung (colormap-Modus)
+     */
+    colorMap?: ColorMapName | GeoStylerColorMap;
+    /**
+     * Wertebereich für ColorMap-Normalisierung [min, max]
+     */
+    valueRange?: [number, number];
+    /**
+     * Höhen-Überhöhung (terrain-Modus)
+     * Default: 1.0
+     */
+    elevationScale?: number;
+    /**
+     * Rendering-Modus:
+     * - 'terrain': 3D-Mesh via Martini-Algorithmus (Standard)
+     * - 'colormap': 2D-Kacheln mit Farbkarte (TileLayer + BitmapLayer)
+     */
+    renderMode?: 'terrain' | 'colormap';
+    /** Optional callback for tile load errors, wired by provider. */
+    onTileLoadError?: (err: Error) => void;
+}
+/**
+ * Factory-Funktion zum Erstellen eines DeckGLGeoTIFFTerrainLayer
+ *
+ * Rendert GeoTIFF-Höhendaten als 3D-Terrain-Mesh (Standard) oder als
+ * colormap-basierte 2D-Kacheln.
+ *
+ * Im terrain-Modus (Standard) wird der Martini-Algorithmus (@mapbox/martini)
+ * für adaptive RTIN-Mesh-Generierung verwendet. meshMaxError, wireframe und
+ * elevationScale sind in diesem Modus funktional.
+ */
+export declare function createDeckGLGeoTIFFTerrainLayer(props: DeckGLGeoTIFFTerrainLayerProps): Promise<Layer>;

package/dist/types/map-provider/deck/LayerGroupWithModel.d.ts

@@ -0,0 +1,55 @@
+import type { Layer } from '@deck.gl/core';
+import type { RenderableGroup } from './RenderableGroup';
+import type { LayerModel } from './LayerModel';
+export type SyncMode = 'force-model' | 'respect-deck';
+type LayerOverrides<L extends Layer> = Partial<L['props']> & {
+    opacity?: number;
+    visible?: boolean;
+    zIndex?: number;
+    data?: unknown;
+    url?: string;
+};
+export declare class LayerGroupWithModel<L extends Layer = Layer> implements RenderableGroup<L> {
+    readonly id: string;
+    private _visible;
+    private _syncMode;
+    private _models;
+    private _instances;
+    private _recreateOnNextEmit;
+    private _overrides;
+    private _dirty;
+    private _cachedLayers;
+    private _basemap;
+    constructor(opts: {
+        id: string;
+        visible?: boolean;
+        syncMode?: SyncMode;
+        models?: ReadonlyArray<LayerModel<L>>;
+        basemap?: string | null;
+    });
+    get visible(): boolean;
+    set visible(v: boolean);
+    get syncMode(): SyncMode;
+    set syncMode(m: SyncMode);
+    set basemap(b: string | null);
+    get basemap(): string | null;
+    isDirty(): boolean;
+    addModel(model: LayerModel<L>): void;
+    addModels(models: ReadonlyArray<LayerModel<L>>): void;
+    getModel(id: string): {
+        id: string;
+        elementId: string;
+        enabled: boolean;
+        make: () => L;
+        meta?: Record<string, unknown>;
+    };
+    removeModel(id: string): void;
+    clear(): void;
+    setModelEnabled(id: string, enabled: boolean): void;
+    replaceModel(model: LayerModel<L>): void;
+    setModelOverrides(id: string, overrides: LayerOverrides<L>): void;
+    clearModelOverrides(id: string): void;
+    getLayers(): readonly L[];
+    destroy(): void;
+}
+export {};

package/dist/types/map-provider/deck/LayerGroups.d.ts

@@ -0,0 +1,63 @@
+import type { Layer } from '@deck.gl/core';
+import type { Deck, DeckProps } from '@deck.gl/core';
+import type { RenderableGroup } from './RenderableGroup';
+/** Kompatibel zu deck.gl Deck.setProps */
+export interface DeckLike {
+    setProps(props: Partial<DeckProps<any>>): void;
+}
+export interface LayerGroupsProps<L extends Layer = Layer, G extends RenderableGroup<L> = RenderableGroup<L>> {
+    groups?: ReadonlyArray<G>;
+}
+export declare class LayerGroups<L extends Layer = Layer, G extends RenderableGroup<L> = RenderableGroup<L>> {
+    private _groups;
+    private _dirty;
+    private _cachedLayers;
+    private _deck;
+    constructor(props?: LayerGroupsProps<L, G>);
+    get size(): number;
+    get groups(): readonly G[];
+    getGroup(id: string): G | undefined;
+    hasGroup(id: string): boolean;
+    attachDeck(deck: Deck | DeckLike): void;
+    detachDeck(): void;
+    applyToDeck(options?: {
+        respectExternalChanges?: boolean;
+    }): void;
+    addGroup(group: G): void;
+    addGroups(groups: ReadonlyArray<G>): void;
+    removeGroup(id: string, opts?: {
+        destroy?: boolean;
+    }): void;
+    clear(opts?: {
+        destroy?: boolean;
+    }): void;
+    replaceGroup(group: G, keepPosition?: boolean): void;
+    moveGroup(id: string, toIndex: number): void;
+    setGroupVisible(id: string, visible: boolean, opts?: {
+        respectExternalChanges?: boolean;
+    }): boolean;
+    /**
+     * Entfernt einen Layer mit gegebener ID aus allen Gruppen, die
+     * klassische LayerGroup **unterstützen**. Bei modellbasierten Gruppen
+     * suchst du nach Model-ID und nutzt removeModel().
+     */
+    removeLayer(layerId: string, opts?: {
+        removeFromAll?: boolean;
+        respectExternalChanges?: boolean;
+    }): boolean;
+    /**
+     * Convenience: Für modellbasierte Gruppen – LayerModel enabled togglen.
+     * No-Op für klassische LayerGroup.
+     */
+    setModelEnabled(groupId: string, modelId: string, enabled: boolean, opts?: {
+        apply?: boolean;
+    }): void;
+    withUpdate(fn: (store: this) => void): void;
+    getLayers(options?: {
+        respectExternalChanges?: boolean;
+    }): readonly L[];
+    markDirty(): void;
+    destroy(opts?: {
+        destroyGroups?: boolean;
+    }): void;
+}

package/dist/types/map-provider/deck/LayerModel.d.ts

@@ -0,0 +1,8 @@
+import type { Layer } from '@deck.gl/core';
+export interface LayerModel<L extends Layer = Layer> {
+    id: string;
+    elementId: string;
+    enabled: boolean;
+    make: () => L;
+    meta?: Record<string, unknown>;
+}

package/dist/types/map-provider/deck/RenderableGroup.d.ts

@@ -0,0 +1,20 @@
+import type { Layer } from '@deck.gl/core';
+/**
+ * Gemeinsames Interface, das sowohl von der klassischen LayerGroup als auch
+ * von der modellbasierten LayerGroupWithModel implementiert wird.
+ */
+export interface RenderableGroup<L extends Layer = Layer> {
+    readonly id: string;
+    visible: boolean;
+    /** true, wenn ein Rebuild der Ausgabe-Layer nötig ist */
+    isDirty(): boolean;
+    /**
+     * Liefert die Deck-Layer zur Darstellung.
+     * groups/LayerGroups reichen intern options weiter (falls benötigt).
+     */
+    getLayers(options?: {
+        respectExternalChanges?: boolean;
+    }): readonly L[];
+    /** Optionale Ressourcenfreigabe */
+    destroy?(): void;
+}

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

@@ -0,0 +1,92 @@
+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 { Deck } from '@deck.gl/core';
+import type { Layer } from '@deck.gl/core';
+export declare class DeckProvider implements MapProvider {
+    private deck;
+    private target;
+    private shadowRoot;
+    private injectedStyle;
+    private layerGroups;
+    private layerErrorCallbacks;
+    init(opts: ProviderOptions): Promise<void>;
+    /** Liefert (oder erzeugt) eine modellbasierte Gruppe */
+    private ensureModelGroup;
+    /** Erzeugt ein LayerModel aus einem LayerConfig + Factory */
+    private createLayerModel;
+    private buildXyzTileLayer;
+    private buildArcgisUrl;
+    private buildArcgisTileLayer;
+    private buildTerrainLayer;
+    private getModelUrl;
+    private normalizeElevationDecoder;
+    /**
+     * Convert a Geostyler style to Deck.gl style configuration
+     */
+    private createGeostylerDeckGLStyle;
+    /**
+     * Convert CSS color to Deck.gl RGBA array
+     */
+    private parseColor;
+    /**
+     * Apply opacity to color array
+     */
+    private applyOpacity;
+    /**
+     * Create Deck.gl style configuration from StyleConfig
+     */
+    private createDeckGLStyle;
+    private buildOsmLayer;
+    private buildGoogleTileLayer;
+    private getGoogleMapTypeId;
+    /**
+     * Load Google Maps JavaScript API
+     */
+    private loadGoogleMapsApi;
+    /**
+     * Add Google logo for compliance
+     */
+    private ensureGoogleLogo;
+    buildScatterPlot(layerConfig: Extract<LayerConfig, {
+        type: 'scatterplot';
+    }>, layerId: string): Promise<Layer>;
+    private createGeoJSONLayer;
+    private buildWmsTileLayer;
+    /**
+     * Build WCS (Web Coverage Service) TileLayer for deck.gl
+     * Supports WCS 2.0.1 (subset) and 1.x.x (BBOX) versions
+     */
+    private buildWcsTileLayer;
+    private createLayer;
+    addLayerToGroup(layerConfig: LayerConfig): Promise<string>;
+    addBaseLayer(layerConfig: LayerConfig, basemapid: string, layerElementId: string): Promise<string>;
+    setBaseLayer(groupId: string, layerElementId: string): Promise<void>;
+    ensureGroup(groupId: string, visible: boolean, _opts?: {
+        basemapid?: string;
+    }): Promise<void>;
+    private _ensureGroup;
+    updateLayer(layerId: string, update: LayerUpdate): Promise<void>;
+    onLayerError(layerId: string, callback: LayerErrorCallback): void;
+    offLayerError(layerId: string): void;
+    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>;
+    setView([lon, lat]: LonLat, zoom: number): Promise<void>;
+    private createWKTLayer;
+    private resolveWktToGeoJSON;
+    private resolveWktText;
+    private wktToGeoJSON;
+    private createGeoTIFFLayer;
+    private createGeoTIFFTerrainLayer;
+    onPointerMove(callback: (coordinate: [number, number] | null, pixel: [number, number]) => void): () => void;
+    destroy(): Promise<void>;
+    private createWFSLayer;
+    private fetchWFSFromUrl;
+    private appendParams;
+    getMap(): Deck<null>;
+}
+export default DeckProvider;

package/dist/types/map-provider/geotiff/geotiff-source.d.ts

@@ -0,0 +1,30 @@
+import type { GeoTIFF, GeoTIFFImage } from 'geotiff';
+import type proj4Type from 'proj4';
+export interface GeoTIFFSourceOptions {
+    projection?: string;
+    forceProjection?: boolean;
+    nodata?: number;
+}
+export interface GeoTIFFLoaderDeps {
+    geotiff: typeof import('geotiff');
+    proj4: typeof proj4Type;
+    geokeysToProj4: typeof import('geotiff-geokeys-to-proj4');
+}
+export interface GeoTIFFSource {
+    tiff: GeoTIFF;
+    baseImage: GeoTIFFImage;
+    overviewImages: GeoTIFFImage[];
+    width: number;
+    height: number;
+    samplesPerPixel: number;
+    fromProjection: string;
+    sourceBounds: [number, number, number, number];
+    sourceRef: [number, number];
+    resolution: number;
+    proj4: typeof proj4Type;
+    noDataValue?: number;
+    wgs84Bounds: [number, number, number, number];
+    transformToWgs84: (coord: [number, number]) => [number, number];
+}
+export declare function loadGeoTIFFSource(url: string, options: GeoTIFFSourceOptions, deps: GeoTIFFLoaderDeps): Promise<GeoTIFFSource>;
+export declare function getGeoTIFFSource(url: string, projection: string, forceProjection: boolean, nodata: number): Promise<GeoTIFFSource>;

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

@@ -0,0 +1,28 @@
+import { ITriangle } from './Triangle';
+export type AffineTransform = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+};
+export type Point2D = {
+    x: number;
+    y: number;
+};
+export type Triangle2D = {
+    a: Point2D;
+    b: Point2D;
+    c: Point2D;
+    triangle: ITriangle;
+    transform: AffineTransform | null;
+};
+export declare class AABB2D {
+    min: Point2D;
+    max: Point2D;
+    constructor(min: Point2D, max: Point2D);
+    contains(point: Point2D): boolean;
+    static fromTriangle(triangle: Triangle2D): AABB2D;
+    static union(a: AABB2D, b: AABB2D): AABB2D;
+}

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

@@ -0,0 +1,36 @@
+import { AABB2D, Point2D, Triangle2D } from './AABB2D';
+import { ITriangle } from './Triangle';
+export declare class BVHNode2D {
+    bbox: AABB2D;
+    triangles: Triangle2D[];
+    left: BVHNode2D | null;
+    right: BVHNode2D | null;
+    constructor(bbox: AABB2D, triangles?: Triangle2D[], left?: BVHNode2D | null, right?: BVHNode2D | null);
+    static build(triangles: Triangle2D[], depth?: number, maxDepth?: number): BVHNode2D;
+    /**
+     * Finds the triangle containing the given point.
+     * @param point The point to test.
+     * @returns The containing triangle or `null`.
+     */
+    findContainingTriangle(point: Point2D): Triangle2D | null;
+    static punktInDreieck2D(p: Point2D, triangle: Triangle2D): boolean;
+    static toTriangle2D(triangle: ITriangle): Triangle2D;
+    /**
+     * Returns a string representation of the BVH tree structure
+     * @param indent - Internal parameter for recursive formatting
+     * @returns Formatted string showing tree structure
+     */
+    toString(indent?: string): string;
+    /**
+     * Get statistics about the BVH tree
+     * @returns Object with tree statistics
+     */
+    getStats(): {
+        depth: number;
+        nodeCount: number;
+        leafCount: number;
+        triangleCount: number;
+        minTrianglesPerLeaf: number;
+        maxTrianglesPerLeaf: number;
+    };
+}

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

@@ -0,0 +1,116 @@
+import type { GeoTIFFImage } from 'geotiff';
+import { Triangulation } from './Triangulation';
+import { type ColorStop } from './colormap-utils';
+import { GeoTIFFSource } from '../geotiff-source';
+/**
+ * Configuration for the GeoTIFF Tile Processor
+ */
+export interface GeoTIFFTileProcessorConfig {
+    transformViewToSourceMapFn: (coord: [number, number]) => [number, number];
+    transformSourceMapToViewFn: (coord: [number, number]) => [number, number];
+    sourceBounds: [number, number, number, number];
+    sourceRef: [number, number];
+    resolution: number;
+    imageWidth: number;
+    imageHeight: number;
+    fromProjection: string;
+    toProjection: string;
+    baseImage: GeoTIFFImage;
+    overviewImages: GeoTIFFImage[];
+    noDataValue?: number;
+    worldSize?: number;
+}
+/**
+ * Parameters for tile data generation
+ */
+export interface TileDataParams {
+    x: number;
+    y: number;
+    z: number;
+    tileSize: number;
+    resolution: number;
+    resampleMethod: 'near' | 'bilinear';
+    colorStops?: ColorStop[];
+}
+/**
+ * Processes GeoTIFF tiles with triangulation-based reprojection
+ *
+ * This class encapsulates the tile rendering logic using triangulation
+ * for efficient reprojection from arbitrary source projections to Web Mercator.
+ */
+export declare class GeoTIFFTileProcessor {
+    private config;
+    private worldSize;
+    private globalTriangulation?;
+    constructor(config: GeoTIFFTileProcessorConfig);
+    /**
+     * Create global triangulation for the entire GeoTIFF image
+     * This is called once to avoid recreating triangulation for every tile
+     */
+    createGlobalTriangulation(): void;
+    /**
+     * Get the global triangulation (may be undefined if not created yet)
+     */
+    getGlobalTriangulation(): Triangulation | undefined;
+    /**
+     * Normalize terrain samples so mesh generation does not create spikes
+     * for nodata or otherwise invalid height values.
+     */
+    private sanitizeElevationValue;
+    /**
+     * Calculate tile size in meters for a given zoom level
+     */
+    private getTileSizeInMeter;
+    /**
+     * Convert tile coordinates to View projection bounds
+     * For Web Mercator (deck.gl/Leaflet/Cesium): returns bounds in meters
+     * Note: This assumes Web Mercator tiling scheme. Override for other projections.
+     */
+    private getTileBounds;
+    /**
+     * Select best overview image based on zoom level
+     */
+    private selectOverviewImage;
+    /**
+     * Calculate source bounds for a tile after transformation
+     * @param viewBounds - Tile bounds in View projection
+     */
+    private calculateTileSourceBounds;
+    /**
+     * Calculate pixel window for reading from GeoTIFF
+     */
+    private calculateReadWindow;
+    /**
+     * Load and convert raster data from GeoTIFF image
+     */
+    private loadAndConvertRasterData;
+    /**
+     * Render tile pixels using triangulation-based reprojection
+     */
+    private renderTilePixels;
+    /**
+     * Check if tile intersects with GeoTIFF source bounds
+     * @param viewBounds - Tile bounds in View projection (e.g., Web Mercator for deck.gl/Leaflet/Cesium)
+     */
+    private tileIntersectsSource;
+    /**
+     * Generate tile data with triangulation-based reprojection
+     *
+     * This is the main method that orchestrates the entire tile rendering process.
+     */
+    getTileData(params: TileDataParams): Promise<Uint8ClampedArray | null>;
+    /**
+     * Get raw elevation values for a tile as Float32Array.
+     *
+     * Returns a (tileSize+1) × (tileSize+1) float array suitable for Martini
+     * terrain mesh generation. Border pixels are backfilled for Martini compatibility.
+     * Band 0 of the GeoTIFF is used as the elevation source.
+     */
+    getElevationData(params: {
+        x: number;
+        y: number;
+        z: number;
+        tileSize: number;
+    }): Promise<Float32Array | null>;
+}
+export declare function getTileProcessorConfig(tiffSource: GeoTIFFSource, viewProjection: string): Promise<GeoTIFFTileProcessorConfig>;

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

@@ -0,0 +1,5 @@
+export type Triangle = [[number, number], [number, number], [number, number]];
+export interface ITriangle {
+    source: Triangle;
+    target: Triangle;
+}

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

@@ -0,0 +1,94 @@
+/**
+ * Triangulation for raster reprojection
+ *
+ * Based on OpenLayers' triangulation approach for efficient raster reprojection.
+ * Instead of transforming every pixel, we:
+ * 1. Divide the target extent into triangles
+ * 2. Transform only triangle vertices with proj4
+ * 3. Use affine transformation to map pixels within each triangle
+ *
+ * This reduces proj4 calls from ~65,536 per tile to ~50-200 per tile.
+ */
+import { ITriangle } from './Triangle';
+import { AffineTransform } from './AABB2D';
+interface TransformFunction {
+    (coord: [number, number]): [number, number];
+}
+export type TriResult = {
+    tri: ITriangle;
+    transform: AffineTransform | null;
+};
+export type Bounds = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export declare function calculateBounds(sourceRef: [number, number], resolution: number, targetExtent: [number, number, number, number], transformFn: TransformFunction, step?: number): {
+    source: Bounds;
+    target: Bounds;
+};
+/**
+ * Class for triangulation of the given target extent
+ * Used for determining source data and the reprojection itself
+ */
+export declare class Triangulation {
+    private triangles_;
+    private transformFn_;
+    private errorThresholdSquared_;
+    private bvh_;
+    private bounds;
+    /**
+     * @param transformFn - Function that transforms [x, y] from target to source projection
+     * @param targetExtent - [west, south, east, north] in target projection
+     * @param errorThreshold - Maximum allowed error in pixels (default: 0.5)
+     */
+    constructor(transformFn: TransformFunction, targetExtent: [number, number, number, number], errorThreshold?: number, sourceRef?: [number, number], resolution?: number, step?: number);
+    getBounds(): Bounds;
+    /**
+     * Recursively subdivide a quadrilateral if needed
+     */
+    private addQuad_;
+    /**
+     * Add a single triangle
+     */
+    private addTriangle_;
+    /**
+     * Calculate squared error between two points
+     */
+    private getSquaredError_;
+    /**
+     * Get all triangles
+     */
+    getTriangles(): ITriangle[];
+    /**
+     * Calculate the bounding extent of all source coordinates
+     */
+    calculateSourceExtent(): [number, number, number, number] | null;
+    buildBVH(): void;
+    findSourceTriangleForTargetPoint(point: [number, number], extraTri?: TriResult): TriResult | null;
+    /**
+     * Calculate affine transformation matrix for a triangle
+     * Maps from target triangle to source triangle
+     */
+    calculateAffineTransform(triangle: ITriangle): {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    /**
+     * Apply affine transformation to a point
+     */
+    applyAffineTransform(x: number, y: number, transform: {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    }): [number, number];
+}
+export {};

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

@@ -0,0 +1,47 @@
+/**
+ * ColorMap utilities for GeoTIFF visualization
+ * Extracted for testability
+ */
+import type { ColorMap as GeoStylerColorMap } from 'geostyler-style';
+export interface ColorStop {
+    value: number;
+    color: [number, number, number];
+}
+export type ColorMapName = 'grayscale' | 'viridis' | 'terrain' | 'turbo' | 'rainbow';
+/**
+ * Predefined color maps
+ */
+export declare const PREDEFINED_COLORMAPS: Record<ColorMapName, ColorStop[]>;
+/**
+ * Parse a hex color string to RGB array
+ * @param hexColor - Hex color string (e.g., "#FF0000" or "#F00")
+ * @returns RGB array [r, g, b] with values 0-255
+ */
+export declare function parseHexColor(hexColor: string): [number, number, number];
+/**
+ * Convert GeoStyler ColorMap to internal ColorStop array
+ * @param geoStylerColorMap - GeoStyler ColorMap object
+ * @param valueRange - Optional value range [min, max] for normalization
+ * @returns Object with ColorStop array and computed range
+ */
+export declare function convertGeoStylerColorMap(geoStylerColorMap: GeoStylerColorMap, valueRange?: [number, number]): {
+    stops: ColorStop[];
+    computedRange?: [number, number];
+};
+/**
+ * Apply colormap to a normalized value using interpolation
+ * @param normalizedValue - Value between 0 and 1
+ * @param colorStops - Array of color stops (must be sorted by value)
+ * @returns RGB color [r, g, b]
+ */
+export declare function applyColorMap(normalizedValue: number, colorStops: ColorStop[]): [number, number, number];
+/**
+ * Get ColorStop array from ColorMapName or GeoStyler ColorMap
+ * @param colorMap - Predefined name or GeoStyler ColorMap
+ * @param valueRange - Optional value range for GeoStyler ColorMap
+ * @returns ColorStop array and computed range (if applicable)
+ */
+export declare function getColorStops(colorMap: ColorMapName | GeoStylerColorMap, valueRange?: [number, number]): {
+    stops: ColorStop[];
+    computedRange?: [number, number];
+};