@angular-helpers/openlayers 0.1.0

package/fesm2022/angular-helpers-openlayers-layers.mjs

@@ -0,0 +1,215 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, input, ChangeDetectionStrategy, Component } from '@angular/core';
+import VectorLayer from 'ol/layer/Vector';
+import TileLayer from 'ol/layer/Tile';
+import ImageLayer from 'ol/layer/Image';
+import VectorSource from 'ol/source/Vector';
+import OSM from 'ol/source/OSM';
+import XYZ from 'ol/source/XYZ';
+import TileWMS from 'ol/source/TileWMS';
+import ImageWMS from 'ol/source/ImageWMS';
+import { OlMapService } from '@angular-helpers/openlayers/core';
+
+// OlLayerService
+class OlLayerService {
+    mapService = inject(OlMapService);
+    layerCache = new Map();
+    addLayer(config) {
+        // If layer already exists, return it (idempotent for retries)
+        if (this.layerCache.has(config.id)) {
+            return { id: config.id };
+        }
+        const map = this.mapService.getMap();
+        if (!map) {
+            // Map not ready yet - caller should retry
+            return { id: config.id };
+        }
+        switch (config.type) {
+            case 'vector':
+                return this.createVectorLayer(config, map);
+            case 'tile':
+                return this.createTileLayer(config, map);
+            case 'image':
+                return this.createImageLayer(config, map);
+            default:
+                return { id: config.id };
+        }
+    }
+    removeLayer(id) {
+        const map = this.mapService.getMap();
+        const layer = this.layerCache.get(id);
+        if (map && layer) {
+            map.removeLayer(layer);
+            this.layerCache.delete(id);
+        }
+    }
+    setVisibility(id, visible) {
+        this.layerCache.get(id)?.setVisible(visible);
+    }
+    setOpacity(id, opacity) {
+        this.layerCache.get(id)?.setOpacity(opacity);
+    }
+    createVectorLayer(config, map) {
+        const layer = new VectorLayer({
+            source: new VectorSource(),
+            visible: config.visible ?? true,
+            opacity: config.opacity ?? 1,
+            zIndex: config.zIndex,
+        });
+        layer.set('id', config.id);
+        map.addLayer(layer);
+        this.layerCache.set(config.id, layer);
+        return { id: config.id };
+    }
+    createTileLayer(config, map) {
+        let source;
+        switch (config.source.type) {
+            case 'osm':
+                source = new OSM({ attributions: config.source.attributions });
+                break;
+            case 'xyz':
+                source = new XYZ({ url: config.source.url, attributions: config.source.attributions });
+                break;
+            case 'wms':
+                source = new TileWMS({
+                    url: config.source.url,
+                    params: config.source.params,
+                    attributions: config.source.attributions,
+                });
+                break;
+            default:
+                source = new OSM();
+        }
+        const layer = new TileLayer({
+            source,
+            visible: config.visible ?? true,
+            opacity: config.opacity ?? 1,
+            zIndex: config.zIndex,
+        });
+        layer.set('id', config.id);
+        map.addLayer(layer);
+        this.layerCache.set(config.id, layer);
+        return { id: config.id };
+    }
+    createImageLayer(config, map) {
+        const source = new ImageWMS({ url: config.source.url, params: config.source.params });
+        const layer = new ImageLayer({
+            source,
+            visible: config.visible ?? true,
+            opacity: config.opacity ?? 1,
+            zIndex: config.zIndex,
+        });
+        layer.set('id', config.id);
+        map.addLayer(layer);
+        this.layerCache.set(config.id, layer);
+        return { id: config.id };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlLayerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlLayerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlLayerService, decorators: [{
+            type: Injectable
+        }] });
+
+// OlVectorLayerComponent
+class OlVectorLayerComponent {
+    layerService = inject(OlLayerService);
+    id = input.required(...(ngDevMode ? [{ debugName: "id" }] : /* istanbul ignore next */ []));
+    features = input([], ...(ngDevMode ? [{ debugName: "features" }] : /* istanbul ignore next */ []));
+    zIndex = input(0, ...(ngDevMode ? [{ debugName: "zIndex" }] : /* istanbul ignore next */ []));
+    opacity = input(1, ...(ngDevMode ? [{ debugName: "opacity" }] : /* istanbul ignore next */ []));
+    visible = input(true, ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
+    style = input(...(ngDevMode ? [undefined, { debugName: "style" }] : /* istanbul ignore next */ []));
+    ngOnInit() {
+        this.layerService.addLayer({
+            id: this.id(),
+            type: 'vector',
+            features: this.features(),
+            zIndex: this.zIndex(),
+            opacity: this.opacity(),
+            visible: this.visible(),
+            style: this.style(),
+        });
+    }
+    ngOnDestroy() {
+        this.layerService.removeLayer(this.id());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlVectorLayerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlVectorLayerComponent, isStandalone: true, selector: "ol-vector-layer", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: true, transformFunction: null }, features: { classPropertyName: "features", publicName: "features", isSignal: true, isRequired: false, transformFunction: null }, zIndex: { classPropertyName: "zIndex", publicName: "zIndex", isSignal: true, isRequired: false, transformFunction: null }, opacity: { classPropertyName: "opacity", publicName: "opacity", isSignal: true, isRequired: false, transformFunction: null }, visible: { classPropertyName: "visible", publicName: "visible", isSignal: true, isRequired: false, transformFunction: null }, style: { classPropertyName: "style", publicName: "style", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlVectorLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-vector-layer',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { id: [{ type: i0.Input, args: [{ isSignal: true, alias: "id", required: true }] }], features: [{ type: i0.Input, args: [{ isSignal: true, alias: "features", required: false }] }], zIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "zIndex", required: false }] }], opacity: [{ type: i0.Input, args: [{ isSignal: true, alias: "opacity", required: false }] }], visible: [{ type: i0.Input, args: [{ isSignal: true, alias: "visible", required: false }] }], style: [{ type: i0.Input, args: [{ isSignal: true, alias: "style", required: false }] }] } });
+
+// OlTileLayerComponent
+class OlTileLayerComponent {
+    layerService = inject(OlLayerService);
+    id = input.required(...(ngDevMode ? [{ debugName: "id" }] : /* istanbul ignore next */ []));
+    source = input.required(...(ngDevMode ? [{ debugName: "source" }] : /* istanbul ignore next */ []));
+    url = input(...(ngDevMode ? [undefined, { debugName: "url" }] : /* istanbul ignore next */ []));
+    attributions = input(...(ngDevMode ? [undefined, { debugName: "attributions" }] : /* istanbul ignore next */ []));
+    params = input(...(ngDevMode ? [undefined, { debugName: "params" }] : /* istanbul ignore next */ []));
+    zIndex = input(0, ...(ngDevMode ? [{ debugName: "zIndex" }] : /* istanbul ignore next */ []));
+    opacity = input(1, ...(ngDevMode ? [{ debugName: "opacity" }] : /* istanbul ignore next */ []));
+    visible = input(true, ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
+    ngOnInit() {
+        // Retry adding layer if map is not ready yet
+        this.tryAddLayer();
+    }
+    tryAddLayer(retryCount = 0) {
+        const result = this.layerService.addLayer({
+            id: this.id(),
+            type: 'tile',
+            source: {
+                type: this.source(),
+                url: this.url(),
+                attributions: this.attributions(),
+                params: this.params(),
+            },
+            zIndex: this.zIndex(),
+            opacity: this.opacity(),
+            visible: this.visible(),
+        });
+        // If layer wasn't added (map not ready), retry with exponential backoff
+        if (retryCount < 10) {
+            setTimeout(() => {
+                // Check if layer was actually added by trying again
+                this.tryAddLayer(retryCount + 1);
+            }, Math.min(50 * (retryCount + 1), 500));
+        }
+    }
+    ngOnDestroy() {
+        this.layerService.removeLayer(this.id());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlTileLayerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlTileLayerComponent, isStandalone: true, selector: "ol-tile-layer", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: true, transformFunction: null }, source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: true, transformFunction: null }, url: { classPropertyName: "url", publicName: "url", isSignal: true, isRequired: false, transformFunction: null }, attributions: { classPropertyName: "attributions", publicName: "attributions", isSignal: true, isRequired: false, transformFunction: null }, params: { classPropertyName: "params", publicName: "params", isSignal: true, isRequired: false, transformFunction: null }, zIndex: { classPropertyName: "zIndex", publicName: "zIndex", isSignal: true, isRequired: false, transformFunction: null }, opacity: { classPropertyName: "opacity", publicName: "opacity", isSignal: true, isRequired: false, transformFunction: null }, visible: { classPropertyName: "visible", publicName: "visible", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlTileLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-tile-layer',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { id: [{ type: i0.Input, args: [{ isSignal: true, alias: "id", required: true }] }], source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: true }] }], url: [{ type: i0.Input, args: [{ isSignal: true, alias: "url", required: false }] }], attributions: [{ type: i0.Input, args: [{ isSignal: true, alias: "attributions", required: false }] }], params: [{ type: i0.Input, args: [{ isSignal: true, alias: "params", required: false }] }], zIndex: [{ type: i0.Input, args: [{ isSignal: true, alias: "zIndex", required: false }] }], opacity: [{ type: i0.Input, args: [{ isSignal: true, alias: "opacity", required: false }] }], visible: [{ type: i0.Input, args: [{ isSignal: true, alias: "visible", required: false }] }] } });
+
+// Provider functions
+function withLayers() {
+    return { kind: 'layers', providers: [OlLayerService] };
+}
+function provideLayers() {
+    return withLayers();
+}
+
+// @angular-helpers/openlayers/layers
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlLayerService, OlTileLayerComponent, OlVectorLayerComponent, provideLayers, withLayers };

package/fesm2022/angular-helpers-openlayers-military.mjs

@@ -0,0 +1,38 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+
+// OlMilitaryService
+class OlMilitaryService {
+    createEllipse(config) {
+        return { id: 'ellipse-1', geometry: { type: 'Polygon', coordinates: [] } };
+    }
+    createSector(config) {
+        return { id: 'sector-1', geometry: { type: 'Polygon', coordinates: [] } };
+    }
+    addMilSymbol(config) {
+        return {
+            id: `symbol-${config.sidc}`,
+            geometry: { type: 'Point', coordinates: config.position },
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMilitaryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMilitaryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMilitaryService, decorators: [{
+            type: Injectable
+        }] });
+
+function withMilitary() {
+    return { kind: 'military', providers: [OlMilitaryService] };
+}
+function provideMilitary() {
+    return withMilitary();
+}
+
+// @angular-helpers/openlayers/military
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlMilitaryService, provideMilitary, withMilitary };

package/fesm2022/angular-helpers-openlayers-overlays.mjs

@@ -0,0 +1,31 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+
+// OlPopupService
+class OlPopupService {
+    showPopup(options) {
+        return 'popup-id';
+    }
+    hidePopup(id) { }
+    hideAllPopups() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupService, decorators: [{
+            type: Injectable
+        }] });
+
+function withOverlays() {
+    return { kind: 'overlays', providers: [OlPopupService] };
+}
+function provideOverlays() {
+    return withOverlays();
+}
+
+// @angular-helpers/openlayers/overlays
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlPopupService, provideOverlays, withOverlays };

package/fesm2022/angular-helpers-openlayers.mjs

@@ -0,0 +1,3 @@
+/**
+ * Generated bundle index. Do not edit.
+ */

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@angular-helpers/openlayers",
+  "version": "0.1.0",
+  "description": "Modern Angular wrapper for OpenLayers with modular architecture, standalone components, and hybrid template/programmatic API",
+  "homepage": "https://gaspar1992.github.io/angular-helpers/docs/openlayers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gaspar1992/angular-helpers"
+  },
+  "bugs": {
+    "url": "https://github.com/Gaspar1992/angular-helpers/issues"
+  },
+  "keywords": [
+    "angular",
+    "openlayers",
+    "ol",
+    "mapping",
+    "gis",
+    "cartography",
+    "standalone",
+    "signals",
+    "modular",
+    "military",
+    "milsymbol"
+  ],
+  "author": "",
+  "license": "MIT",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/core": "^21.0.0",
+    "@angular/common": "^21.0.0",
+    "ol": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ol": {
+      "optional": false
+    }
+  },
+  "module": "fesm2022/angular-helpers-openlayers.mjs",
+  "typings": "types/angular-helpers-openlayers.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/angular-helpers-openlayers.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers.mjs"
+    },
+    "./controls": {
+      "types": "./types/angular-helpers-openlayers-controls.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-controls.mjs"
+    },
+    "./core": {
+      "types": "./types/angular-helpers-openlayers-core.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-core.mjs"
+    },
+    "./interactions": {
+      "types": "./types/angular-helpers-openlayers-interactions.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-interactions.mjs"
+    },
+    "./layers": {
+      "types": "./types/angular-helpers-openlayers-layers.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-layers.mjs"
+    },
+    "./military": {
+      "types": "./types/angular-helpers-openlayers-military.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-military.mjs"
+    },
+    "./overlays": {
+      "types": "./types/angular-helpers-openlayers-overlays.d.ts",
+      "default": "./fesm2022/angular-helpers-openlayers-overlays.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

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

@@ -0,0 +1,77 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import { OlFeature } from '@angular-helpers/openlayers/core';
+
+declare class OlZoomControlComponent implements OnInit, OnDestroy {
+    private mapService;
+    private ngZone;
+    delta: _angular_core.InputSignal<number>;
+    duration: _angular_core.InputSignal<number>;
+    private control?;
+    ngOnInit(): void;
+    private tryAddControl;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlZoomControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlZoomControlComponent, "ol-zoom-control", never, { "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OlAttributionControlComponent implements OnInit, OnDestroy {
+    private mapService;
+    private ngZone;
+    collapsible: _angular_core.InputSignal<boolean>;
+    collapsed: _angular_core.InputSignal<boolean>;
+    private control?;
+    ngOnInit(): void;
+    private tryAddControl;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlAttributionControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlAttributionControlComponent, "ol-attribution-control", never, { "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OlScaleLineControlComponent implements OnInit, OnDestroy {
+    private mapService;
+    private ngZone;
+    units: _angular_core.InputSignal<"metric" | "imperial" | "nautical" | "us">;
+    bar: _angular_core.InputSignal<boolean>;
+    steps: _angular_core.InputSignal<number>;
+    private control?;
+    ngOnInit(): void;
+    private tryAddControl;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlScaleLineControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlScaleLineControlComponent, "ol-scale-line-control", never, { "units": { "alias": "units"; "required": false; "isSignal": true; }; "bar": { "alias": "bar"; "required": false; "isSignal": true; }; "steps": { "alias": "steps"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class OlFullscreenControlComponent implements OnInit, OnDestroy {
+    private mapService;
+    private ngZone;
+    source: _angular_core.InputSignal<HTMLElement>;
+    label: _angular_core.InputSignal<string>;
+    labelActive: _angular_core.InputSignal<string>;
+    tipLabel: _angular_core.InputSignal<string>;
+    private control?;
+    ngOnInit(): void;
+    private tryAddControl;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlFullscreenControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlFullscreenControlComponent, "ol-fullscreen-control", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelActive": { "alias": "labelActive"; "required": false; "isSignal": true; }; "tipLabel": { "alias": "tipLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ControlPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
+interface ControlConfig {
+    position?: ControlPosition;
+    className?: string;
+}
+
+declare class OlControlService {
+    addCustomControl(element: HTMLElement, position: ControlPosition): void;
+    removeCustomControl(element: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlControlService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlControlService>;
+}
+
+declare function withControls(): OlFeature<'controls'>;
+declare function provideControls(): OlFeature<'controls'>;
+
+export { OlAttributionControlComponent, OlControlService, OlFullscreenControlComponent, OlScaleLineControlComponent, OlZoomControlComponent, provideControls, withControls };
+export type { ControlConfig, ControlPosition };

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

@@ -0,0 +1,144 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, Provider, EnvironmentProviders } from '@angular/core';
+import OLMap from 'ol/Map';
+import { View } from 'ol';
+
+type Coordinate = [number, number];
+type Extent = [number, number, number, number];
+type Pixel = [number, number];
+type FeatureId = string;
+interface Feature {
+    id: FeatureId;
+    geometry: Geometry;
+    properties?: Record<string, unknown>;
+    style?: Style;
+}
+type GeometryType = 'Point' | 'LineString' | 'Polygon' | 'Circle' | 'Ellipse' | 'Sector';
+interface Geometry {
+    type: GeometryType;
+    coordinates: Coordinate | Coordinate[] | Coordinate[][];
+}
+interface Style {
+    fill?: {
+        color?: string;
+    };
+    stroke?: {
+        color?: string;
+        width?: number;
+    };
+    image?: {
+        radius?: number;
+        fill?: {
+            color?: string;
+        };
+        stroke?: {
+            color?: string;
+            width?: number;
+        };
+    };
+    text?: {
+        text?: string;
+        font?: string;
+        fill?: {
+            color?: string;
+        };
+        stroke?: {
+            color?: string;
+            width?: number;
+        };
+    };
+}
+interface Layer {
+    id: string;
+    visible?: boolean;
+    opacity?: number;
+    zIndex?: number;
+}
+interface ViewState {
+    center: Coordinate;
+    zoom: number;
+    rotation?: number;
+}
+type ProjectionCode = 'EPSG:4326' | 'EPSG:3857' | string;
+interface MapConfig {
+    target?: string | HTMLElement;
+    view?: Partial<ViewState>;
+    projection?: ProjectionCode;
+}
+
+interface MapClickEvent {
+    coordinate: Coordinate;
+    pixel: Pixel;
+}
+declare class OlMapComponent implements AfterViewInit, OnDestroy {
+    private mapService;
+    private ngZone;
+    center: _angular_core.InputSignal<Coordinate>;
+    zoom: _angular_core.InputSignal<number>;
+    rotation: _angular_core.InputSignal<number>;
+    projection: _angular_core.InputSignal<string>;
+    viewChange: _angular_core.OutputEmitterRef<ViewState>;
+    mapClick: _angular_core.OutputEmitterRef<MapClickEvent>;
+    mapDblClick: _angular_core.OutputEmitterRef<MapClickEvent>;
+    mapContainerRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    private map?;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initMap;
+    private destroyMap;
+    private updateCenter;
+    private updateZoom;
+    private updateRotation;
+    private emitViewChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlMapComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlMapComponent, "ol-map", never, { "center": { "alias": "center"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; "projection": { "alias": "projection"; "required": false; "isSignal": true; }; }, { "viewChange": "viewChange"; "mapClick": "mapClick"; "mapDblClick": "mapDblClick"; }, never, ["*"], true, never>;
+}
+
+interface AnimationOptions {
+    center?: Coordinate;
+    zoom?: number;
+    rotation?: number;
+    duration?: number;
+}
+interface FitOptions {
+    padding?: [number, number, number, number];
+    maxZoom?: number;
+    duration?: number;
+}
+interface MapViewOptions {
+    center?: Coordinate;
+    zoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    rotation?: number;
+    projection?: string;
+}
+declare class OlMapService {
+    private ngZone;
+    private map;
+    setMap(map: OLMap): void;
+    getMap(): OLMap | null;
+    getView(): View | null;
+    setCenter(coordinate: Coordinate): void;
+    setZoom(level: number): void;
+    fitExtent(extent: Extent, options?: FitOptions): void;
+    animateView(options: AnimationOptions): Promise<void>;
+    getViewState(): {
+        center: Coordinate;
+        zoom: number;
+        rotation: number;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlMapService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OlMapService>;
+}
+
+type OlFeatureKind = 'layers' | 'controls' | 'interactions' | 'overlays' | 'military';
+interface OlFeature<Kind extends OlFeatureKind> {
+    kind: Kind;
+    providers: Provider[];
+}
+declare function provideOpenLayers(...features: OlFeature<OlFeatureKind>[]): EnvironmentProviders;
+
+export { OlMapComponent, OlMapService, provideOpenLayers };
+export type { AnimationOptions, Coordinate, Extent, Feature, FitOptions, Geometry, GeometryType, Layer, MapClickEvent, MapConfig, MapViewOptions, OlFeature, OlFeatureKind, Pixel, ProjectionCode, Style, ViewState };

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

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+import { Feature, OlFeature } from '@angular-helpers/openlayers/core';
+import * as i0 from '@angular/core';
+
+type InteractionType = 'select' | 'draw' | 'modify' | 'dragAndDrop';
+interface InteractionConfig {
+    active?: boolean;
+}
+interface SelectConfig extends InteractionConfig {
+    layers?: string[];
+    multi?: boolean;
+}
+interface DrawConfig extends InteractionConfig {
+    type: 'Point' | 'LineString' | 'Polygon' | 'Circle';
+    source?: string;
+    freehand?: boolean;
+}
+interface SelectEvent {
+    feature: Feature;
+    selected: boolean;
+}
+
+declare class OlInteractionService {
+    enableInteraction(type: InteractionType, config: unknown): unknown;
+    disableInteraction(id: string): void;
+    startDrawing(type: string, options?: DrawConfig): Observable<Feature>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OlInteractionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OlInteractionService>;
+}
+
+declare function withInteractions(): OlFeature<'interactions'>;
+declare function provideInteractions(): OlFeature<'interactions'>;
+
+export { OlInteractionService, provideInteractions, withInteractions };
+export type { DrawConfig, InteractionConfig, InteractionType, SelectConfig, SelectEvent };