@angular-helpers/openlayers 0.1.1 → 0.3.0

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

@@ -1,6 +1,12 @@
-import { Observable } from 'rxjs';
-import { Feature, OlFeature } from '@angular-helpers/openlayers/core';
+import * as rxjs from 'rxjs';
+import * as _angular_helpers_openlayers_interactions from '@angular-helpers/openlayers/interactions';
 import * as i0 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 {
@@ -9,27 +15,330 @@ interface InteractionConfig {
 interface SelectConfig extends InteractionConfig {
     layers?: string[];
     multi?: boolean;
+    hitTolerance?: number;
 }
 interface DrawConfig extends InteractionConfig {
     type: 'Point' | 'LineString' | 'Polygon' | 'Circle';
     source?: string;
     freehand?: boolean;
+    snapTolerance?: number;
+}
+interface ModifyConfig extends InteractionConfig {
+    source?: string;
+    snapTolerance?: number;
+}
+interface DragAndDropConfig extends InteractionConfig {
+    format?: 'GeoJSON' | 'KML' | 'GPX';
+    projection?: string;
 }
 interface SelectEvent {
     feature: Feature;
     selected: boolean;
 }
+interface DrawEndEvent {
+    feature: Feature;
+    type: string;
+}
+interface DrawStartEvent {
+    feature: Feature;
+}
+interface ModifyEvent {
+    features: Feature[];
+    type: 'modifystart' | 'modifyend';
+}
+interface InteractionState {
+    id: string;
+    type: InteractionType;
+    active: boolean;
+}
 
+/**
+ * Main service for managing OpenLayers map interactions.
+ * Orchestrates specialized interaction services and exposes unified API.
+ *
+ * @example
+ * ```typescript
+ * const interactionService = inject(OlInteractionService);
+ *
+ * // Enable select interaction
+ * interactionService.enableSelect('select-1', { layers: ['cities'], multi: true });
+ *
+ * // React to selection changes
+ * effect(() => {
+ *   const selected = interactionService.selectedFeatures();
+ *   console.log('Selected:', selected);
+ * });
+ * ```
+ */
 declare class OlInteractionService {
-    enableInteraction(type: InteractionType, config: unknown): unknown;
+    private mapService;
+    private stateService;
+    private zoneHelper;
+    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 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>;
+    /**
+     * Enable a select interaction on the map.
+     * @param id - Unique identifier for this interaction
+     * @param config - Selection configuration
+     * @returns Object with cleanup method
+     */
+    enableSelect(id: string, config?: SelectConfig): {
+        cleanup: () => void;
+    };
+    /**
+     * Enable a draw interaction on the map.
+     * @param id - Unique identifier for this interaction
+     * @param config - Draw configuration
+     * @returns Object with cleanup method and isActive signal
+     */
+    enableDraw(id: string, config: DrawConfig): {
+        cleanup: () => void;
+        isActive: () => boolean;
+    };
+    /**
+     * Enable a modify interaction on the map.
+     * @param id - Unique identifier for this interaction
+     * @param config - Modify configuration
+     * @returns Object with cleanup method
+     */
+    enableModify(id: string, config?: ModifyConfig): {
+        cleanup: () => void;
+    };
+    /**
+     * Disable and remove an interaction by id.
+     * @param id - The interaction identifier
+     */
     disableInteraction(id: string): void;
-    startDrawing(type: string, options?: DrawConfig): Observable<Feature>;
+    /**
+     * Disable all active interactions.
+     */
+    disableAll(): void;
+    /**
+     * Clear the current selection.
+     * Also clears the OL Select interaction's internal feature collection so the
+     * visual selection is removed from the map.
+     */
+    clearSelection(): void;
+    /**
+     * Check if an interaction is currently active.
+     * @param id - The interaction identifier
+     * @returns True if active, false otherwise
+     */
+    isActive(id: string): boolean;
+    /**
+     * Get current interaction state.
+     * @returns Array of interaction state summaries
+     */
+    getInteractionState(): _angular_helpers_openlayers_interactions.InteractionState[];
     static ɵfac: i0.ɵɵFactoryDeclaration<OlInteractionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OlInteractionService>;
 }
 
+/**
+ * Internal representation of a managed OpenLayers interaction.
+ * Tracks the interaction instance, its configuration, and cleanup function.
+ */
+interface ManagedInteraction {
+    /** Unique identifier for this interaction instance */
+    id: string;
+    /** Type of interaction (select, draw, modify, etc.) */
+    type: InteractionType;
+    /** The OpenLayers interaction instance */
+    olInteraction: Interaction;
+    /** Configuration used when creating the interaction */
+    config: InteractionConfig;
+    /** Function to clean up and remove the interaction from the map */
+    cleanup: () => void;
+}
+
+/**
+ * Service responsible for managing the reactive state of interactions.
+ * Provides signals for interaction state and observables for events.
+ */
+declare class InteractionStateService {
+    private interactions;
+    private selectedFeaturesInternal;
+    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[]>;
+    readonly drawStart$: rxjs.Observable<DrawStartEvent>;
+    readonly drawEnd$: rxjs.Observable<DrawEndEvent>;
+    readonly modify$: rxjs.Observable<ModifyEvent>;
+    /**
+     * Adds a managed interaction to the state.
+     * @param interaction - The interaction to add
+     */
+    addInteraction(interaction: ManagedInteraction): void;
+    /**
+     * Removes an interaction by id.
+     * @param id - The interaction identifier to remove
+     */
+    removeInteraction(id: string): void;
+    /**
+     * Gets all managed interactions.
+     * @returns Array of managed interactions
+     */
+    getInteractions(): ManagedInteraction[];
+    /**
+     * Finds an interaction by id.
+     * @param id - The interaction identifier
+     * @returns The managed interaction or undefined
+     */
+    findInteraction(id: string): ManagedInteraction | undefined;
+    /**
+     * Sets the currently selected features.
+     * @param features - Array of selected features
+     */
+    setSelectedFeatures(features: Feature[]): void;
+    /**
+     * Clears the current selection.
+     */
+    clearSelection(): void;
+    /**
+     * Emits a draw start event.
+     * @param event - The draw start event data
+     */
+    emitDrawStart(event: DrawStartEvent): void;
+    /**
+     * Emits a draw end event.
+     * @param event - The draw end event data
+     */
+    emitDrawEnd(event: DrawEndEvent): void;
+    /**
+     * Emits a modify event.
+     * @param event - The modify event data
+     */
+    emitModify(event: ModifyEvent): void;
+    /**
+     * Gets the current interaction state summary.
+     * @returns Array of interaction state objects
+     */
+    getInteractionState(): InteractionState[];
+    /**
+     * Checks if an interaction is currently active.
+     * @param id - The interaction identifier
+     * @returns True if the interaction exists and is active
+     */
+    isActive(id: string): boolean;
+    /**
+     * Clears all interactions from state.
+     * 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>;
+}
+
+/**
+ * Service responsible for creating and managing Select interactions.
+ */
+declare class SelectInteractionService {
+    private mapService;
+    private stateService;
+    private zoneHelper;
+    /**
+     * Creates and configures a Select interaction.
+     * @param id - Unique identifier for the interaction
+     * @param config - Select interaction configuration
+     * @param map - OpenLayers map instance
+     * @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>;
+}
+
+/**
+ * Service responsible for creating and managing Draw interactions.
+ */
+declare class DrawInteractionService {
+    private mapService;
+    private layerService;
+    private stateService;
+    private zoneHelper;
+    /**
+     * Creates and configures a Draw interaction.
+     * @param id - Unique identifier for the interaction
+     * @param config - Draw interaction configuration
+     * @param map - OpenLayers map instance
+     * @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>;
+}
+
+/**
+ * Service responsible for creating and managing Modify interactions.
+ */
+declare class ModifyInteractionService {
+    private layerService;
+    private stateService;
+    private zoneHelper;
+    /**
+     * Creates and configures a Modify interaction.
+     * @param id - Unique identifier for the interaction
+     * @param config - Modify interaction configuration
+     * @param map - OpenLayers map instance
+     */
+    createModifyInteraction(id: string, config: ModifyConfig, map: OLMap): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModifyInteractionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModifyInteractionService>;
+}
+
+/**
+ * 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;
+
+/**
+ * Provide the interactions feature with OlInteractionService and all specialized services.
+ * Note: ZoneHelper is inherited from core's provideOpenLayers.
+ * @returns OlFeature configuration for interactions
+ */
 declare function withInteractions(): OlFeature<'interactions'>;
+/**
+ * Alias for withInteractions().
+ * @returns OlFeature configuration for interactions
+ */
 declare function provideInteractions(): OlFeature<'interactions'>;
+/**
+ * Enable select interaction when providing the interactions feature.
+ * @param id Unique identifier for this interaction
+ * @param config Select interaction configuration
+ * @returns Provider function that enables select interaction
+ */
+declare function withSelectInteraction(id: string, config?: SelectConfig): Provider;
+/**
+ * Enable draw interaction when providing the interactions feature.
+ * @param id Unique identifier for this interaction
+ * @param config Draw interaction configuration
+ * @returns Provider function that enables draw interaction
+ */
+declare function withDrawInteraction(id: string, config: DrawConfig): Provider;
+/**
+ * Enable modify interaction when providing the interactions feature.
+ * @param id Unique identifier for this interaction
+ * @param config Modify interaction configuration
+ * @returns Provider function that enables modify interaction
+ */
+declare function withModifyInteraction(id: string, config?: ModifyConfig): Provider;
 
-export { OlInteractionService, provideInteractions, withInteractions };
-export type { DrawConfig, InteractionConfig, InteractionType, SelectConfig, SelectEvent };
+export { DrawInteractionService, InteractionStateService, ModifyInteractionService, OlInteractionService, SelectInteractionService, olFeatureToFeature, provideInteractions, withDrawInteraction, withInteractions, 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,23 +1,24 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy } from '@angular/core';
 import { Feature, Style, Layer, Extent, OlFeature } from '@angular-helpers/openlayers/core';
+import BaseLayer from 'ol/layer/Base';
 
-declare class OlVectorLayerComponent implements OnInit, OnDestroy {
+declare class OlVectorLayerComponent {
     private layerService;
+    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>;
     style: _angular_core.InputSignal<Style | ((feature: Feature) => Style)>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    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; }; }, {}, never, never, true, never>;
 }
 
-declare class OlTileLayerComponent implements OnInit, OnDestroy {
+declare class OlTileLayerComponent {
     private layerService;
+    private destroyRef;
     id: _angular_core.InputSignal<string>;
     source: _angular_core.InputSignal<"osm" | "xyz" | "wms">;
     url: _angular_core.InputSignal<string>;
@@ -26,13 +27,27 @@ declare class OlTileLayerComponent implements OnInit, OnDestroy {
     zIndex: _angular_core.InputSignal<number>;
     opacity: _angular_core.InputSignal<number>;
     visible: _angular_core.InputSignal<boolean>;
-    ngOnInit(): void;
-    private tryAddLayer;
-    ngOnDestroy(): void;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlTileLayerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlTileLayerComponent, "ol-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; }; "params": { "alias": "params"; "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 OlImageLayerComponent {
+    private layerService;
+    private destroyRef;
+    id: _angular_core.InputSignal<string>;
+    sourceType: _angular_core.InputSignal<"wms" | "static">;
+    url: _angular_core.InputSignal<string>;
+    params: _angular_core.InputSignal<Record<string, unknown>>;
+    imageExtent: _angular_core.InputSignal<[number, number, number, number]>;
+    zIndex: _angular_core.InputSignal<number>;
+    opacity: _angular_core.InputSignal<number>;
+    visible: _angular_core.InputSignal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlImageLayerComponent, never>;
+    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>;
+}
+
 interface LayerConfig extends Layer {
     type: 'vector' | 'tile' | 'image';
     extent?: Extent;
@@ -65,15 +80,51 @@ interface ImageSourceConfig {
     imageExtent?: Extent;
 }
 
+interface LayerInfo {
+    id: string;
+    type: 'vector' | 'tile' | 'image';
+    visible: boolean;
+    opacity: number;
+    zIndex: number;
+}
 declare class OlLayerService {
     private mapService;
     private layerCache;
+    private pendingConfigs;
+    private layerState;
+    readonly layers: _angular_core.Signal<LayerInfo[]>;
+    readonly visibleLayers: _angular_core.Signal<LayerInfo[]>;
+    readonly tileLayers: _angular_core.Signal<LayerInfo[]>;
+    readonly vectorLayers: _angular_core.Signal<LayerInfo[]>;
     addLayer(config: LayerConfig): {
         id: string;
     };
+    private flushPending;
+    private createLayer;
+    getLayer(id: string): BaseLayer | undefined;
+    hasLayer(id: string): boolean;
     removeLayer(id: string): void;
     setVisibility(id: string, visible: boolean): void;
+    toggleVisibility(id: string): boolean;
     setOpacity(id: string, opacity: number): void;
+    setZIndex(id: string, zIndex: number): void;
+    isVisible(id: string): boolean;
+    getOpacity(id: string): number;
+    getZIndex(id: string): number;
+    /**
+     * Clears all features from a vector layer's source.
+     * Does not remove the layer itself.
+     * @param id - Layer identifier
+     */
+    clearFeatures(id: string): void;
+    /**
+     * Updates the features of a vector layer.
+     * Syncs new features without clearing existing ones (preserves OL modifications).
+     * @param id - Layer identifier
+     * @param features - New features to sync
+     */
+    updateFeatures(id: string, features: VectorLayerConfig['features']): void;
+    private updateLayerState;
     private createVectorLayer;
     private createTileLayer;
     private createImageLayer;
@@ -84,5 +135,5 @@ declare class OlLayerService {
 declare function withLayers(): OlFeature<'layers'>;
 declare function provideLayers(): OlFeature<'layers'>;
 
-export { OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, provideLayers, withLayers };
-export type { ImageLayerConfig, ImageSourceConfig, LayerConfig, SourceConfig, TileLayerConfig, VectorLayerConfig };
+export { OlImageLayerComponent, OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, provideLayers, withLayers };
+export type { ImageLayerConfig, ImageSourceConfig, LayerConfig, LayerInfo, SourceConfig, TileLayerConfig, VectorLayerConfig };