@angular-helpers/openlayers 0.3.0 → 0.5.0

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

@@ -36,6 +36,22 @@ interface Style {
             width?: number;
         };
     };
+    /**
+     * Icon style for Point features. When set, renderers should produce an
+     * `ol/style/Icon` with the given source. Used by the military symbology
+     * helpers to embed `milsymbol`-generated SVGs as data URLs.
+     */
+    icon?: {
+        /** Image source — typically a `data:image/svg+xml;base64,...` URL */
+        src: string;
+        /** Pixel size `[width, height]` */
+        size?: [number, number];
+        /**
+         * Anchor in fractional coordinates `[x, y]` where `0..1` is the icon
+         * extent. `[0.5, 0.5]` centers the icon on the feature.
+         */
+        anchor?: [number, number];
+    };
     text?: {
         text?: string;
         font?: string;
@@ -83,6 +99,7 @@ declare class OlMapComponent {
     mapDblClick: _angular_core.OutputEmitterRef<MapClickEvent>;
     mapContainerRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
     private map?;
+    private resizeObserver?;
     constructor();
     private initMap;
     private destroyMap;
@@ -140,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;
@@ -198,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';
@@ -11,14 +11,21 @@ import { Feature as Feature$1 } from 'ol';
 type InteractionType = 'select' | 'draw' | 'modify' | 'dragAndDrop';
 interface InteractionConfig {
     active?: boolean;
+    /**
+     * If true, enabling this interaction will automatically disable other active exclusive interactions.
+     * Useful for mutually exclusive tools like Draw and Modify.
+     * @default true
+     */
+    exclusive?: boolean;
 }
 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;
@@ -32,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';
 }
@@ -77,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
@@ -138,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>;
 }
 
 /**
@@ -169,15 +181,18 @@ 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.
      * @param interaction - The interaction to add
      */
     addInteraction(interaction: ManagedInteraction): void;
@@ -221,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
@@ -237,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>;
 }
 
 /**
@@ -256,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>;
 }
 
 /**
@@ -276,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>;
 }
 
 /**
@@ -294,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>;
 }
 
 /**
@@ -307,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.
@@ -339,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 };