@angular-helpers/openlayers 0.4.0 → 0.5.0

package/types/angular-helpers-openlayers-core.d.ts

@@ -157,7 +157,11 @@ declare class OlMapService {
     private zoneHelper;
     private map;
     private readyCallbacks;
-    setMap(map: OLMap): void;
+    private _resolution;
+    /** Signal that emits the current map resolution in meters per pixel */
+    readonly resolution: _angular_core.Signal<number>;
+    setMap(map: OLMap | null): void;
+    setResolution(resolution: number): void;
     getMap(): OLMap | null;
     onReady(callback: (map: OLMap) => void): void;
     getView(): View | null;
@@ -215,12 +219,130 @@ declare class OlZoneHelper {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlZoneHelper>;
 }
 
-type OlFeatureKind = 'layers' | 'controls' | 'interactions' | 'overlays' | 'military';
+/**
+ * Configuration for an ellipse polygon centered at `center`.
+ * Coordinates are emitted in EPSG:4326 (lon/lat) using a local tangent-plane
+ * approximation; accuracy degrades for radii > ~100 km or near the poles.
+ */
+interface EllipseConfig {
+    /** Ellipse center as `[lon, lat]` in EPSG:4326. */
+    center: Coordinate;
+    /** Semi-major axis in meters. Must be > 0. */
+    semiMajor: number;
+    /** Semi-minor axis in meters. Must be > 0. */
+    semiMinor: number;
+    /**
+     * Rotation in radians, counter-clockwise from East. Default: 0
+     * (semi-major axis points East).
+     */
+    rotation?: number;
+    /**
+     * Number of vertices used to approximate the ellipse. Default: 64.
+     * Minimum: 8.
+     */
+    segments?: number;
+    /** Custom feature properties to attach to the output feature. */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Configuration for a circular sector (pie-slice) polygon.
+ * Same projection caveats as `EllipseConfig`.
+ */
+interface SectorConfig {
+    /** Sector apex / center as `[lon, lat]` in EPSG:4326. */
+    center: Coordinate;
+    /** Sector radius in meters. Must be > 0. */
+    radius: number;
+    /** Start angle in radians (0 = East, CCW positive). */
+    startAngle: number;
+    /**
+     * End angle in radians. Must satisfy `startAngle < endAngle <= startAngle + 2π`.
+     */
+    endAngle: number;
+    /**
+     * Number of vertices along the arc. Default: 32. Minimum: 4. The output
+     * polygon has `segments + 3` vertices (apex + arc + apex closer).
+     */
+    segments?: number;
+    /** Custom feature properties to attach to the output feature. */
+    properties?: Record<string, unknown>;
+}
+/**
+ * Configuration for a donut (annular ring) polygon — a disk with a
+ * concentric circular hole.
+ *
+ * The output `Feature<Polygon>` has TWO rings: an outer ring (CCW) and
+ * an inner ring (CW per the GeoJSON right-hand rule), so renderers that
+ * follow the spec fill only the band between the radii.
+ */
+interface DonutConfig {
+    /** Donut center as `[lon, lat]` in EPSG:4326. */
+    center: Coordinate;
+    /** Outer radius in meters. Must be > `innerRadius`. */
+    outerRadius: number;
+    /** Inner radius in meters. Must be > 0 and < `outerRadius`. */
+    innerRadius: number;
+    /**
+     * Number of vertices per ring. Default: 64. Minimum: 8. Both rings use
+     * the same segment count.
+     */
+    segments?: number;
+    /** Custom feature properties to attach to the output feature. */
+    properties?: Record<string, unknown>;
+}
+
+/**
+ * Service exposing general purpose geometry helpers for creating
+ * approximated polygons (ellipses, sectors, donuts) from metric parameters.
+ */
+declare class OlGeometryService {
+    private idCounter;
+    /**
+     * Build a `Feature<Polygon>` approximating an ellipse centered at
+     * `config.center`. See {@link EllipseConfig} for parameter semantics.
+     */
+    createEllipse(config: EllipseConfig): Feature;
+    /**
+     * Build a `Feature<Polygon>` for a circular sector (pie slice).
+     * See {@link SectorConfig} for parameter semantics.
+     */
+    createSector(config: SectorConfig): Feature;
+    /**
+     * Build a `Feature<Polygon>` for a donut (annular ring). The output has
+     * two rings: an outer ring wound counter-clockwise and an inner ring
+     * wound clockwise so the GeoJSON right-hand rule renders the hole.
+     */
+    createDonut(config: DonutConfig): Feature;
+    /**
+     * Project an `(dx, dy)` meter offset from `center` to lon/lat using true
+     * geodesic math (Vincenty's formulae) via ol/sphere.
+     */
+    offsetMetersToLonLat(center: Coordinate, dx: number, dy: number): Coordinate;
+    private nextId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlGeometryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlGeometryService>;
+}
+
+type OlFeatureKind = 'layers' | 'controls' | 'interactions' | 'overlays' | 'military' | 'projections';
 interface OlFeature<Kind extends OlFeatureKind> {
     kind: Kind;
     providers: Provider[];
 }
 declare function provideOpenLayers(...features: OlFeature<OlFeatureKind>[]): EnvironmentProviders;
 
-export { OlMapComponent, OlMapService, OlZoneHelper, provideOpenLayers };
-export type { AnimationOptions, Coordinate, Extent, Feature, FitOptions, Geometry, GeometryType, Layer, MapClickEvent, MapConfig, MapViewOptions, OlFeature, OlFeatureKind, Pixel, ProjectionCode, Style, ViewState };
+interface Proj4Definition {
+    code: string;
+    def: string;
+    extent?: [number, number, number, number];
+}
+/**
+ * Registers custom projections using proj4.
+ *
+ * @param proj4 - The proj4 instance (must be passed to avoid strong dependency on proj4 package)
+ * @param definitions - Array of projection definitions
+ * @returns OlFeature for projections
+ */
+declare function withProjections(proj4: any, definitions: Proj4Definition[]): OlFeature<'projections'>;
+
+export { OlGeometryService, OlMapComponent, OlMapService, OlZoneHelper, provideOpenLayers, withProjections };
+export type { AnimationOptions, Coordinate, DonutConfig, EllipseConfig, Extent, Feature, FitOptions, Geometry, GeometryType, Layer, MapClickEvent, MapConfig, MapViewOptions, OlFeature, OlFeatureKind, Pixel, Proj4Definition, ProjectionCode, SectorConfig, Style, ViewState };

package/types/angular-helpers-openlayers-interactions.d.ts

@@ -1,6 +1,6 @@
 import * as rxjs from 'rxjs';
 import * as _angular_helpers_openlayers_interactions from '@angular-helpers/openlayers/interactions';
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { Provider } from '@angular/core';
 import * as _angular_helpers_openlayers_core from '@angular-helpers/openlayers/core';
 import { Feature, OlFeature } from '@angular-helpers/openlayers/core';
@@ -22,9 +22,10 @@ interface SelectConfig extends InteractionConfig {
     layers?: string[];
     multi?: boolean;
     hitTolerance?: number;
+    condition?: 'click' | 'pointerMove';
 }
 interface DrawConfig extends InteractionConfig {
-    type: 'Point' | 'LineString' | 'Polygon' | 'Circle';
+    type: 'Point' | 'LineString' | 'Polygon' | 'Circle' | 'Ellipse' | 'Donut';
     source?: string;
     freehand?: boolean;
     snapTolerance?: number;
@@ -38,17 +39,21 @@ interface DragAndDropConfig extends InteractionConfig {
     projection?: string;
 }
 interface SelectEvent {
-    feature: Feature;
-    selected: boolean;
+    interactionId: string;
+    selected: Feature[];
+    deselected: Feature[];
 }
 interface DrawEndEvent {
+    interactionId: string;
     feature: Feature;
     type: string;
 }
 interface DrawStartEvent {
+    interactionId: string;
     feature: Feature;
 }
 interface ModifyEvent {
+    interactionId: string;
     features: Feature[];
     type: 'modifystart' | 'modifyend';
 }
@@ -83,13 +88,14 @@ declare class OlInteractionService {
     private selectService;
     private drawService;
     private modifyService;
-    readonly selectedFeatures: i0.Signal<_angular_helpers_openlayers_core.Feature[]>;
-    readonly selectionCount: i0.Signal<number>;
-    readonly hasSelection: i0.Signal<boolean>;
-    readonly activeInteractions: i0.Signal<_angular_helpers_openlayers_interactions.ManagedInteraction[]>;
+    readonly selectedFeatures: _angular_core.Signal<_angular_helpers_openlayers_core.Feature[]>;
+    readonly selectionCount: _angular_core.Signal<number>;
+    readonly hasSelection: _angular_core.Signal<boolean>;
+    readonly activeInteractions: _angular_core.Signal<_angular_helpers_openlayers_interactions.ManagedInteraction[]>;
     readonly drawStart$: rxjs.Observable<_angular_helpers_openlayers_interactions.DrawStartEvent>;
     readonly drawEnd$: rxjs.Observable<_angular_helpers_openlayers_interactions.DrawEndEvent>;
     readonly modify$: rxjs.Observable<_angular_helpers_openlayers_interactions.ModifyEvent>;
+    readonly select$: rxjs.Observable<_angular_helpers_openlayers_interactions.SelectEvent>;
     /**
      * Enable a select interaction on the map.
      * @param id - Unique identifier for this interaction
@@ -144,8 +150,8 @@ declare class OlInteractionService {
      * @returns Array of interaction state summaries
      */
     getInteractionState(): _angular_helpers_openlayers_interactions.InteractionState[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<OlInteractionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OlInteractionService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlInteractionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlInteractionService>;
 }
 
 /**
@@ -175,13 +181,15 @@ declare class InteractionStateService {
     private drawStartSubject;
     private drawEndSubject;
     private modifySubject;
-    readonly selectedFeatures: i0.Signal<Feature[]>;
-    readonly selectionCount: i0.Signal<number>;
-    readonly hasSelection: i0.Signal<boolean>;
-    readonly activeInteractions: i0.Signal<ManagedInteraction[]>;
+    private selectSubject;
+    readonly selectedFeatures: _angular_core.Signal<Feature[]>;
+    readonly selectionCount: _angular_core.Signal<number>;
+    readonly hasSelection: _angular_core.Signal<boolean>;
+    readonly activeInteractions: _angular_core.Signal<ManagedInteraction[]>;
     readonly drawStart$: rxjs.Observable<DrawStartEvent>;
     readonly drawEnd$: rxjs.Observable<DrawEndEvent>;
     readonly modify$: rxjs.Observable<ModifyEvent>;
+    readonly select$: rxjs.Observable<SelectEvent>;
     /**
      * Adds a managed interaction to the state.
      * If the interaction is marked as exclusive, it disables other exclusive interactions.
@@ -228,6 +236,11 @@ declare class InteractionStateService {
      * @param event - The modify event data
      */
     emitModify(event: ModifyEvent): void;
+    /**
+     * Emits a select event.
+     * @param event - The select event data
+     */
+    emitSelect(event: SelectEvent): void;
     /**
      * Gets the current interaction state summary.
      * @returns Array of interaction state objects
@@ -244,8 +257,8 @@ declare class InteractionStateService {
      * Note: This only clears the state tracking, not the actual OL interactions.
      */
     clearAll(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionStateService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionStateService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InteractionStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InteractionStateService>;
 }
 
 /**
@@ -263,8 +276,8 @@ declare class SelectInteractionService {
      * @returns Promise that resolves when the interaction is created
      */
     createSelectInteraction(id: string, config: SelectConfig, map: OLMap): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SelectInteractionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SelectInteractionService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectInteractionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SelectInteractionService>;
 }
 
 /**
@@ -283,8 +296,8 @@ declare class DrawInteractionService {
      * @returns True if the interaction was created successfully
      */
     createDrawInteraction(id: string, config: DrawConfig, map: OLMap): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DrawInteractionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DrawInteractionService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawInteractionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DrawInteractionService>;
 }
 
 /**
@@ -301,8 +314,30 @@ declare class ModifyInteractionService {
      * @param map - OpenLayers map instance
      */
     createModifyInteraction(id: string, config: ModifyConfig, map: OLMap): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyInteractionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ModifyInteractionService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModifyInteractionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ModifyInteractionService>;
+}
+
+declare class MeasurementInteractionService {
+    private mapService;
+    private zoneHelper;
+    private draw?;
+    private source;
+    private vectorLayer?;
+    private map?;
+    private sketch;
+    private measureTooltipElement;
+    private measureTooltip;
+    private listener;
+    private isMeasuring;
+    startMeasuring(type: 'LineString' | 'Polygon'): void;
+    stopMeasuring(): void;
+    isActive(): boolean;
+    private createMeasureTooltip;
+    private formatLength;
+    private formatArea;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MeasurementInteractionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MeasurementInteractionService>;
 }
 
 /**
@@ -314,6 +349,63 @@ declare class ModifyInteractionService {
  */
 declare function olFeatureToFeature(olFeature: Feature$1): Feature;
 
+/**
+ * Declarative component to configure an OpenLayers Draw Interaction.
+ */
+declare class OlDrawInteractionComponent {
+    private interactionService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    type: _angular_core.InputSignal<"Point" | "LineString" | "Polygon" | "Circle">;
+    source: _angular_core.InputSignal<string>;
+    freehand: _angular_core.InputSignal<boolean>;
+    snapTolerance: _angular_core.InputSignal<number>;
+    active: _angular_core.InputSignal<boolean>;
+    private drawStartFiltered$;
+    private drawEndFiltered$;
+    drawStart: _angular_core.OutputRef<_angular_helpers_openlayers_interactions.DrawStartEvent>;
+    drawEnd: _angular_core.OutputRef<_angular_helpers_openlayers_interactions.DrawEndEvent>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlDrawInteractionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlDrawInteractionComponent, "ol-draw-interaction", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "freehand": { "alias": "freehand"; "required": false; "isSignal": true; }; "snapTolerance": { "alias": "snapTolerance"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "drawStart": "drawStart"; "drawEnd": "drawEnd"; }, never, never, true, never>;
+}
+
+/**
+ * Declarative component to configure an OpenLayers Modify Interaction.
+ */
+declare class OlModifyInteractionComponent {
+    private interactionService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    source: _angular_core.InputSignal<string>;
+    snapTolerance: _angular_core.InputSignal<number>;
+    active: _angular_core.InputSignal<boolean>;
+    private modifyFiltered$;
+    modifyEvent: _angular_core.OutputRef<_angular_helpers_openlayers_interactions.ModifyEvent>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlModifyInteractionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlModifyInteractionComponent, "ol-modify-interaction", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "snapTolerance": { "alias": "snapTolerance"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "modifyEvent": "modifyEvent"; }, never, never, true, never>;
+}
+
+/**
+ * Declarative component to configure an OpenLayers Select Interaction.
+ */
+declare class OlSelectInteractionComponent {
+    private interactionService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    layers: _angular_core.InputSignal<string[]>;
+    multi: _angular_core.InputSignal<boolean>;
+    hitTolerance: _angular_core.InputSignal<number>;
+    condition: _angular_core.InputSignal<"click" | "pointerMove">;
+    active: _angular_core.InputSignal<boolean>;
+    private selectFiltered$;
+    selectEvent: _angular_core.OutputRef<_angular_helpers_openlayers_interactions.SelectEvent>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlSelectInteractionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlSelectInteractionComponent, "ol-select-interaction", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "layers": { "alias": "layers"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "hitTolerance": { "alias": "hitTolerance"; "required": false; "isSignal": true; }; "condition": { "alias": "condition"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; }, { "selectEvent": "selectEvent"; }, never, never, true, never>;
+}
+
 /**
  * Provide the interactions feature with OlInteractionService and all specialized services.
  * Note: ZoneHelper is inherited from core's provideOpenLayers.
@@ -346,6 +438,11 @@ declare function withDrawInteraction(id: string, config: DrawConfig): Provider;
  * @returns Provider function that enables modify interaction
  */
 declare function withModifyInteraction(id: string, config?: ModifyConfig): Provider;
+/**
+ * Enable measurement interaction when providing the interactions feature.
+ * @returns Provider function that enables measurement interaction
+ */
+declare function withMeasurementInteraction(): Provider;
 
-export { DrawInteractionService, InteractionStateService, ModifyInteractionService, OlInteractionService, SelectInteractionService, olFeatureToFeature, provideInteractions, withDrawInteraction, withInteractions, withModifyInteraction, withSelectInteraction };
+export { DrawInteractionService, InteractionStateService, MeasurementInteractionService, ModifyInteractionService, OlDrawInteractionComponent, OlInteractionService, OlModifyInteractionComponent, OlSelectInteractionComponent, SelectInteractionService, olFeatureToFeature, provideInteractions, withDrawInteraction, withInteractions, withMeasurementInteraction, withModifyInteraction, withSelectInteraction };
 export type { DragAndDropConfig, DrawConfig, DrawEndEvent, DrawStartEvent, InteractionConfig, InteractionState, InteractionType, ManagedInteraction, ModifyConfig, ModifyEvent, SelectConfig, SelectEvent };

package/types/angular-helpers-openlayers-layers.d.ts

@@ -1,9 +1,11 @@
 import * as _angular_core from '@angular/core';
 import { Layer, Extent, Feature, Style, OlFeature } from '@angular-helpers/openlayers/core';
+import { FlatStyleLike } from 'ol/style/flat';
+import { Style as Style$1 } from 'ol/layer/WebGLTile';
 import BaseLayer from 'ol/layer/Base';
 
 interface LayerConfig extends Layer {
-    type: 'vector' | 'tile' | 'image';
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
     extent?: Extent;
     minResolution?: number;
     maxResolution?: number;
@@ -23,9 +25,18 @@ interface ClusterConfig {
 interface VectorLayerConfig extends LayerConfig {
     type: 'vector';
     features?: Feature[];
+    url?: string;
+    format?: 'geojson' | 'topojson' | 'kml';
     style?: Style | ((feature: Feature) => Style);
     cluster?: ClusterConfig;
 }
+interface HeatmapLayerConfig extends LayerConfig {
+    type: 'heatmap';
+    features?: Feature[];
+    weight?: string | ((feature: Feature) => number);
+    blur?: number;
+    radius?: number;
+}
 interface TileLayerConfig extends LayerConfig {
     type: 'tile';
     source: SourceConfig;
@@ -46,20 +57,33 @@ interface ImageSourceConfig {
     params?: Record<string, unknown>;
     imageExtent?: Extent;
 }
+type AnyLayerConfig = VectorLayerConfig | TileLayerConfig | ImageLayerConfig | HeatmapLayerConfig;
+
+declare class OlClusterComponent {
+    distance: _angular_core.InputSignal<number>;
+    minDistance: _angular_core.InputSignal<number>;
+    showCount: _angular_core.InputSignal<boolean>;
+    featureStyle: _angular_core.InputSignal<Style>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlClusterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlClusterComponent, "ol-cluster", never, { "distance": { "alias": "distance"; "required": false; "isSignal": true; }; "minDistance": { "alias": "minDistance"; "required": false; "isSignal": true; }; "showCount": { "alias": "showCount"; "required": false; "isSignal": true; }; "featureStyle": { "alias": "featureStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
 declare class OlVectorLayerComponent {
     private layerService;
     private destroyRef;
     id: _angular_core.InputSignal<string>;
     features: _angular_core.InputSignal<Feature[]>;
+    url: _angular_core.InputSignal<string>;
+    format: _angular_core.InputSignal<"geojson" | "topojson" | "kml">;
     zIndex: _angular_core.InputSignal<number>;
     opacity: _angular_core.InputSignal<number>;
     visible: _angular_core.InputSignal<boolean>;
-    style: _angular_core.InputSignal<Style | ((feature: Feature) => Style)>;
+    style: _angular_core.InputSignal<any>;
     cluster: _angular_core.InputSignal<ClusterConfig>;
+    clusterComponent: _angular_core.Signal<OlClusterComponent>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlVectorLayerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlVectorLayerComponent, "ol-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlVectorLayerComponent, "ol-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "cluster": { "alias": "cluster"; "required": false; "isSignal": true; }; }, {}, ["clusterComponent"], never, true, never>;
 }
 
 declare class OlTileLayerComponent {
@@ -94,9 +118,124 @@ declare class OlImageLayerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlImageLayerComponent, "ol-image-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "sourceType": { "alias": "sourceType"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": true; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "imageExtent": { "alias": "imageExtent"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+declare class OlHeatmapLayerComponent {
+    private layerService;
+    private mapService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    features: _angular_core.InputSignal<Feature[]>;
+    zIndex: _angular_core.InputSignal<number>;
+    opacity: _angular_core.InputSignal<number>;
+    visible: _angular_core.InputSignal<boolean>;
+    blur: _angular_core.InputSignal<number>;
+    radius: _angular_core.InputSignal<number>;
+    /** Unit for radius and blur: 'pixels' (default) or 'meters' */
+    radiusUnit: _angular_core.InputSignal<"pixels" | "meters">;
+    weight: _angular_core.InputSignal<string | ((feature: Feature) => number)>;
+    /** Computed radius in pixels based on current resolution if unit is 'meters' */
+    private scaledRadius;
+    /** Computed blur in pixels based on current resolution if unit is 'meters' */
+    private scaledBlur;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlHeatmapLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlHeatmapLayerComponent, "ol-heatmap-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "radiusUnit": { "alias": "radiusUnit"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * GPU-accelerated vector layer for rendering large datasets.
+ *
+ * Important: Uses WebGL 2 for rendering. Styles must be provided as
+ * `FlatStyleLike` objects (not `ol/style/Style` instances).
+ * Hit detection is disabled by default for performance.
+ *
+ * @usageNotes
+ * ```html
+ * <ol-webgl-vector-layer
+ *   id="big-dataset"
+ *   [features]="largeDataset()"
+ *   [flatStyle]="{
+ *     'circle-radius': 6,
+ *     'circle-fill-color': ['match', ['get', 'type'], 'alert', 'red', 'blue'],
+ *     'stroke-color': '#333',
+ *     'stroke-width': 1
+ *   }"
+ *   [disableHitDetection]="true">
+ * </ol-webgl-vector-layer>
+ * ```
+ */
+declare class OlWebGLVectorLayerComponent {
+    private mapService;
+    private destroyRef;
+    /** Unique layer identifier */
+    id: _angular_core.InputSignal<string>;
+    /** Features to render */
+    features: _angular_core.InputSignal<Feature[]>;
+    /** WebGL flat style (required — no default provided) */
+    flatStyle: _angular_core.InputSignal<FlatStyleLike>;
+    /** Z-index for layer ordering */
+    zIndex: _angular_core.InputSignal<number>;
+    /** Opacity (0–1) */
+    opacity: _angular_core.InputSignal<number>;
+    /** Layer visibility */
+    visible: _angular_core.InputSignal<boolean>;
+    /** Disable hit detection for better performance (default: true) */
+    disableHitDetection: _angular_core.InputSignal<boolean>;
+    /** Style variables for dynamic expressions (e.g. `['var', 'threshold']`) */
+    variables: _angular_core.InputSignal<Record<string, string | number | boolean | number[]>>;
+    private layer;
+    private vectorSource;
+    constructor();
+    private syncFeatures;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLVectorLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLVectorLayerComponent, "ol-webgl-vector-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; "flatStyle": { "alias": "flatStyle"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "disableHitDetection": { "alias": "disableHitDetection"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * GPU-accelerated tile layer with color/brightness/contrast expressions.
+ *
+ * Supports the same tile sources as `ol-tile-layer` but renders via WebGL,
+ * enabling GPU-powered color manipulation (brightness, contrast, saturation, gamma).
+ *
+ * @usageNotes
+ * ```html
+ * <ol-webgl-tile-layer
+ *   id="satellite-webgl"
+ *   source="xyz"
+ *   [url]="'https://server.arcgisonline.com/.../{z}/{y}/{x}'"
+ *   [tileStyle]="{ brightness: 0.1, contrast: 0.2 }">
+ * </ol-webgl-tile-layer>
+ * ```
+ */
+declare class OlWebGLTileLayerComponent {
+    private mapService;
+    private destroyRef;
+    /** Unique layer identifier */
+    id: _angular_core.InputSignal<string>;
+    /** Tile source type */
+    source: _angular_core.InputSignal<"osm" | "xyz" | "mvt">;
+    /** Tile URL template (required for 'xyz' and 'mvt') */
+    url: _angular_core.InputSignal<string>;
+    /** Attribution text */
+    attributions: _angular_core.InputSignal<string | string[]>;
+    /** WebGL tile style (raster expressions) or flat style (MVT) */
+    tileStyle: _angular_core.InputSignal<FlatStyleLike | Style$1>;
+    /** Z-index for layer ordering */
+    zIndex: _angular_core.InputSignal<number>;
+    /** Opacity (0–1) */
+    opacity: _angular_core.InputSignal<number>;
+    /** Layer visibility */
+    visible: _angular_core.InputSignal<boolean>;
+    /** Preload low-res tiles up to this many zoom levels */
+    preload: _angular_core.InputSignal<number>;
+    private layer;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlWebGLTileLayerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlWebGLTileLayerComponent, "ol-webgl-tile-layer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "attributions": { "alias": "attributions"; "required": false; "isSignal": true; }; "tileStyle": { "alias": "tileStyle"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "preload": { "alias": "preload"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 interface LayerInfo {
     id: string;
-    type: 'vector' | 'tile' | 'image';
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
     visible: boolean;
     opacity: number;
     zIndex: number;
@@ -110,7 +249,7 @@ declare class OlLayerService {
     readonly visibleLayers: _angular_core.Signal<LayerInfo[]>;
     readonly tileLayers: _angular_core.Signal<LayerInfo[]>;
     readonly vectorLayers: _angular_core.Signal<LayerInfo[]>;
-    addLayer(config: LayerConfig): {
+    addLayer(config: AnyLayerConfig): {
         id: string;
     };
     private flushPending;
@@ -122,6 +261,11 @@ declare class OlLayerService {
     toggleVisibility(id: string): boolean;
     setOpacity(id: string, opacity: number): void;
     setZIndex(id: string, zIndex: number): void;
+    setHeatmapProperties(id: string, props: {
+        blur?: number;
+        radius?: number;
+        weight?: string | ((feature: any) => number);
+    }): void;
     isVisible(id: string): boolean;
     getOpacity(id: string): number;
     getZIndex(id: string): number;
@@ -140,6 +284,7 @@ declare class OlLayerService {
     updateFeatures(id: string, features: VectorLayerConfig['features']): void;
     private updateLayerState;
     private createVectorLayer;
+    private createHeatmapLayer;
     private createTileLayer;
     private createImageLayer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlLayerService, never>;
@@ -149,5 +294,5 @@ declare class OlLayerService {
 declare function withLayers(): OlFeature<'layers'>;
 declare function provideLayers(): OlFeature<'layers'>;
 
-export { OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, provideLayers, withLayers };
-export type { ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };
+export { OlClusterComponent, OlHeatmapLayerComponent, OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, OlWebGLTileLayerComponent, OlWebGLVectorLayerComponent, provideLayers, withLayers };
+export type { HeatmapLayerConfig, ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };