@angular-helpers/openlayers 0.4.0 → 0.5.1

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, Provider, EnvironmentProviders } from '@angular/core';
+import { ElementRef, Signal, Resource, Provider, EnvironmentProviders } from '@angular/core';
 import OLMap from 'ol/Map';
-import { View } from 'ol';
+import { View, Feature as Feature$1 } from 'ol';
 
 type Coordinate = [number, number];
 type Extent = [number, number, number, number];
@@ -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,199 @@ 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>;
+}
+
+/**
+ * Service for orchestrating time-series animations in OpenLayers.
+ * Exposes a reactive currentTime signal that updates outside the Angular zone
+ * via requestAnimationFrame, ensuring 60FPS WebGL animations without triggering
+ * global change detection.
+ */
+declare class OlTimeService {
+    private zoneHelper;
+    private timeSignal;
+    private playingSignal;
+    private speedSignal;
+    private animationFrameId;
+    private lastTick;
+    readonly currentTime: _angular_core.Signal<number>;
+    readonly isPlaying: _angular_core.Signal<boolean>;
+    readonly speed: _angular_core.Signal<number>;
+    /**
+     * Sets the current time manually.
+     * @param time Epoch timestamp in milliseconds
+     */
+    setTime(time: number): void;
+    /**
+     * Sets the playback speed multiplier.
+     * @param speed Multiplier (e.g. 1 = real time, 60 = 1 minute per second)
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Starts the time animation loop.
+     */
+    play(): void;
+    /**
+     * Pauses the time animation loop.
+     */
+    pause(): void;
+    /**
+     * Stops the animation and resets to a specific time.
+     */
+    stop(resetTime?: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlTimeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlTimeService>;
+}
+
+interface VectorResourceOptions {
+    /** Optional custom fetch options */
+    fetchOptions?: RequestInit;
+}
+/**
+ * Creates an Angular resource for fetching and decoding GeoJSON into OpenLayers Features.
+ * Must be called in an injection context.
+ *
+ * @param url The URL signal or string to fetch data from
+ * @param options Additional vector resource options
+ * @returns An Angular Resource containing an array of parsed Features
+ */
+declare function createVectorResource(url: Signal<string | undefined>, options?: VectorResourceOptions): Resource<Feature[]>;
+
+/**
+ * Converts an OpenLayers feature to the internal Feature format.
+ * Handles coordinate extraction and geometry type mapping.
+ *
+ * @param olFeature - The OpenLayers feature to convert
+ * @returns The converted Feature with normalized structure
+ */
+declare function olFeatureToFeature(olFeature: Feature$1): Feature;
+/**
+ * Converts an internal Feature to an OpenLayers feature.
+ */
+declare function featureToOlFeature(feature: Feature): Feature$1;
+
+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, OlTimeService, OlZoneHelper, createVectorResource, featureToOlFeature, olFeatureToFeature, provideOpenLayers, withProjections };
+export type { AnimationOptions, Coordinate, DonutConfig, EllipseConfig, Extent, Feature, FitOptions, Geometry, GeometryType, Layer, MapClickEvent, MapConfig, MapViewOptions, OlFeature, OlFeatureKind, Pixel, Proj4Definition, ProjectionCode, SectorConfig, Style, VectorResourceOptions, ViewState };

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

@@ -1,12 +1,10 @@
 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';
 import Interaction from 'ol/interaction/Interaction';
 import OLMap from 'ol/Map';
-import { Feature as Feature$1 } from 'ol';
 
 type InteractionType = 'select' | 'draw' | 'modify' | 'dragAndDrop';
 interface InteractionConfig {
@@ -22,9 +20,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 +37,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 +86,15 @@ 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<Feature[]>;
+    readonly hoveredFeature: _angular_core.Signal<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 +149,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>;
 }
 
 /**
@@ -172,16 +177,20 @@ interface ManagedInteraction {
 declare class InteractionStateService {
     private interactions;
     private selectedFeaturesInternal;
+    private hoveredFeatureInternal;
     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 hoveredFeature: _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.
@@ -213,6 +222,11 @@ declare class InteractionStateService {
      * Clears the current selection.
      */
     clearSelection(): void;
+    /**
+     * Sets the currently hovered feature.
+     * @param feature - The hovered feature or null
+     */
+    setHoveredFeature(feature: Feature | null): void;
     /**
      * Emits a draw start event.
      * @param event - The draw start event data
@@ -228,6 +242,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 +263,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 +282,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 +302,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,18 +320,88 @@ 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>;
 }
 
 /**
- * Converts an OpenLayers feature to the internal Feature format.
- * Handles coordinate extraction and geometry type mapping.
- *
- * @param olFeature - The OpenLayers feature to convert
- * @returns The converted Feature with normalized structure
+ * Declarative component to configure an OpenLayers Draw Interaction.
  */
-declare function olFeatureToFeature(olFeature: Feature$1): Feature;
+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.
@@ -346,6 +435,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, provideInteractions, withDrawInteraction, withInteractions, withMeasurementInteraction, withModifyInteraction, withSelectInteraction };
 export type { DragAndDropConfig, DrawConfig, DrawEndEvent, DrawStartEvent, InteractionConfig, InteractionState, InteractionType, ManagedInteraction, ModifyConfig, ModifyEvent, SelectConfig, SelectEvent };