@angular-helpers/openlayers 0.1.0

package/README.md

@@ -0,0 +1,156 @@
+# @angular-helpers/openlayers
+
+A modern Angular wrapper for OpenLayers with modular architecture, standalone components, and a hybrid template/programmatic API.
+
+## Features
+
+- **Standalone Components** - No NgModule boilerplate, use directly in your components
+- **Signals Integration** - Native Angular signals for reactive state management
+- **Modular Loading** - Import only what you need with AgGrid-style sub-entry points
+- **Dual API** - Template for UI, Inputs for data, Services for operations
+- **Tree-shaking** - Unused OpenLayers code is eliminated from your bundle
+- **TypeScript First** - Full type safety with strict mode support
+- **Military Features** - Ellipses, sectors, NATO symbology, and MGRS coordinates
+
+## Installation
+
+```bash
+npm install @angular-helpers/openlayers ol
+```
+
+## Quick Start
+
+### 1. Configure in your app
+
+```typescript
+// app.config.ts
+import { ApplicationConfig } from '@angular/core';
+import { provideOpenLayers } from '@angular-helpers/openlayers/core';
+import { withLayers } from '@angular-helpers/openlayers/layers';
+import { withControls } from '@angular-helpers/openlayers/controls';
+
+export const appConfig: ApplicationConfig = {
+  providers: [provideOpenLayers(withLayers(), withControls())],
+};
+```
+
+### 2. Use in your component
+
+```typescript
+// map.component.ts
+import { Component, inject, signal } from '@angular/core';
+import { OlMapComponent } from '@angular-helpers/openlayers/core';
+import { OlTileLayerComponent } from '@angular-helpers/openlayers/layers';
+import {
+  OlZoomControlComponent,
+  OlScaleLineControlComponent,
+} from '@angular-helpers/openlayers/controls';
+import { OlMapService } from '@angular-helpers/openlayers/core';
+
+@Component({
+  selector: 'app-map',
+  standalone: true,
+  imports: [
+    OlMapComponent,
+    OlTileLayerComponent,
+    OlZoomControlComponent,
+    OlScaleLineControlComponent,
+  ],
+  template: `
+    <ol-map
+      [center]="center()"
+      [zoom]="zoom()"
+      (viewChange)="onViewChange($event)"
+      (click)="onMapClick($event)"
+      style="display: block; height: 400px;"
+    >
+      <!-- Base Layer -->
+      <ol-tile-layer id="osm" source="osm"></ol-tile-layer>
+
+      <!-- Controls -->
+      <ol-zoom-control></ol-zoom-control>
+      <ol-scale-line-control unit="metric"></ol-scale-line-control>
+    </ol-map>
+
+    <p>Clicked: {{ lastClick()?.coordinate | json }}</p>
+  `,
+})
+export class MapComponent {
+  private mapService = inject(OlMapService);
+
+  center = signal<[number, number]>([2.2945, 48.8584]);
+  zoom = signal<number>(12);
+  lastClick = signal<{ coordinate: [number, number]; pixel: [number, number] } | null>(null);
+
+  onViewChange(state: { center: [number, number]; zoom: number }): void {
+    this.center.set(state.center);
+    this.zoom.set(state.zoom);
+  }
+
+  onMapClick(event: { coordinate: [number, number]; pixel: [number, number] }): void {
+    this.lastClick.set(event);
+  }
+
+  flyToEiffel() {
+    this.mapService.animateView({ center: [2.2945, 48.8584], zoom: 15, duration: 1000 });
+  }
+}
+```
+
+## Architecture
+
+### Data vs UI Separation
+
+| Use Case                             | Approach                    | Example                                                       |
+| ------------------------------------ | --------------------------- | ------------------------------------------------------------- |
+| **Data** (features, layers, coords)  | `@Input()`                  | `<ol-vector-layer [features]="data">`                         |
+| **UI** (buttons, popups, toolbars)   | Template/content projection | `<ol-custom-control><button>...</button></ol-custom-control>` |
+| **Operations** (animations, queries) | Service via `inject()`      | `this.ol.animateView({...})`                                  |
+
+### Sub-Entry Points
+
+Import only what you need:
+
+```typescript
+// Core only (~45KB gzipped)
+import { OlMapComponent, OlMapService } from '@angular-helpers/openlayers';
+
+// Add layers (~35KB additional)
+import { OlVectorLayerComponent, withLayers } from '@angular-helpers/openlayers/layers';
+
+// Add controls (~15KB additional)
+import { OlCustomControlComponent, withControls } from '@angular-helpers/openlayers/controls';
+
+// Add interactions (~40KB additional)
+import {
+  OlDrawInteractionComponent,
+  withInteractions,
+} from '@angular-helpers/openlayers/interactions';
+
+// Add military features (~10KB additional)
+import { OlEllipseFeatureComponent, withMilitary } from '@angular-helpers/openlayers/military';
+```
+
+## API Reference
+
+See the [documentation](https://gaspar1992.github.io/angular-helpers/docs/openlayers) for full API reference and examples.
+
+## Comparison with Other Libraries
+
+| Feature               | ngx-openlayers | ngx-ol-library | IGO2-lib | **This Library**         |
+| --------------------- | -------------- | -------------- | -------- | ------------------------ |
+| Angular 21+           | ❌             | ✅             | ❌       | ✅                       |
+| Standalone Components | ❌             | ✅             | ❌       | ✅                       |
+| Signals               | ❌             | ❌             | ❌       | ✅                       |
+| Modular Loading       | ❌             | Partial        | ❌       | ✅                       |
+| Programmatic API      | ❌             | ❌             | Partial  | ✅                       |
+| Military Features     | ❌             | ❌             | ❌       | ✅                       |
+| Bundle Size           | ~180KB         | ~200KB         | ~500KB   | **~145KB (all modules)** |
+
+## License
+
+MIT
+
+## Contributing
+
+See the main repository for contribution guidelines.

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

@@ -0,0 +1,224 @@
+import * as i0 from '@angular/core';
+import { inject, NgZone, input, ChangeDetectionStrategy, Component, Injectable } from '@angular/core';
+import { OlMapService } from '@angular-helpers/openlayers/core';
+import Zoom from 'ol/control/Zoom';
+import Attribution from 'ol/control/Attribution';
+import ScaleLine from 'ol/control/ScaleLine';
+import FullScreen from 'ol/control/FullScreen';
+
+// OlZoomControlComponent
+class OlZoomControlComponent {
+    mapService = inject(OlMapService);
+    ngZone = inject(NgZone);
+    delta = input(1, ...(ngDevMode ? [{ debugName: "delta" }] : /* istanbul ignore next */ []));
+    duration = input(250, ...(ngDevMode ? [{ debugName: "duration" }] : /* istanbul ignore next */ []));
+    control;
+    ngOnInit() {
+        this.tryAddControl();
+    }
+    tryAddControl(retryCount = 0) {
+        const map = this.mapService.getMap();
+        if (!map) {
+            if (retryCount < 10) {
+                setTimeout(() => this.tryAddControl(retryCount + 1), Math.min(50 * (retryCount + 1), 500));
+            }
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.control = new Zoom({
+                delta: this.delta(),
+                duration: this.duration(),
+            });
+            map.addControl(this.control);
+        });
+    }
+    ngOnDestroy() {
+        const map = this.mapService.getMap();
+        if (!this.control || !map)
+            return;
+        this.ngZone.runOutsideAngular(() => {
+            map.removeControl(this.control);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlZoomControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlZoomControlComponent, isStandalone: true, selector: "ol-zoom-control", inputs: { delta: { classPropertyName: "delta", publicName: "delta", isSignal: true, isRequired: false, transformFunction: null }, duration: { classPropertyName: "duration", publicName: "duration", 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: OlZoomControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-zoom-control',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { delta: [{ type: i0.Input, args: [{ isSignal: true, alias: "delta", required: false }] }], duration: [{ type: i0.Input, args: [{ isSignal: true, alias: "duration", required: false }] }] } });
+
+// OlAttributionControlComponent
+class OlAttributionControlComponent {
+    mapService = inject(OlMapService);
+    ngZone = inject(NgZone);
+    collapsible = input(true, ...(ngDevMode ? [{ debugName: "collapsible" }] : /* istanbul ignore next */ []));
+    collapsed = input(true, ...(ngDevMode ? [{ debugName: "collapsed" }] : /* istanbul ignore next */ []));
+    control;
+    ngOnInit() {
+        this.tryAddControl();
+    }
+    tryAddControl(retryCount = 0) {
+        const map = this.mapService.getMap();
+        if (!map) {
+            if (retryCount < 10) {
+                setTimeout(() => this.tryAddControl(retryCount + 1), Math.min(50 * (retryCount + 1), 500));
+            }
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.control = new Attribution({
+                collapsible: this.collapsible(),
+                collapsed: this.collapsed(),
+            });
+            map.addControl(this.control);
+        });
+    }
+    ngOnDestroy() {
+        const map = this.mapService.getMap();
+        if (!this.control || !map)
+            return;
+        this.ngZone.runOutsideAngular(() => {
+            map.removeControl(this.control);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlAttributionControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlAttributionControlComponent, isStandalone: true, selector: "ol-attribution-control", inputs: { collapsible: { classPropertyName: "collapsible", publicName: "collapsible", isSignal: true, isRequired: false, transformFunction: null }, collapsed: { classPropertyName: "collapsed", publicName: "collapsed", 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: OlAttributionControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-attribution-control',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { collapsible: [{ type: i0.Input, args: [{ isSignal: true, alias: "collapsible", required: false }] }], collapsed: [{ type: i0.Input, args: [{ isSignal: true, alias: "collapsed", required: false }] }] } });
+
+// OlScaleLineControlComponent
+class OlScaleLineControlComponent {
+    mapService = inject(OlMapService);
+    ngZone = inject(NgZone);
+    units = input('metric', ...(ngDevMode ? [{ debugName: "units" }] : /* istanbul ignore next */ []));
+    bar = input(false, ...(ngDevMode ? [{ debugName: "bar" }] : /* istanbul ignore next */ []));
+    steps = input(4, ...(ngDevMode ? [{ debugName: "steps" }] : /* istanbul ignore next */ []));
+    control;
+    ngOnInit() {
+        this.tryAddControl();
+    }
+    tryAddControl(retryCount = 0) {
+        const map = this.mapService.getMap();
+        if (!map) {
+            if (retryCount < 10) {
+                setTimeout(() => this.tryAddControl(retryCount + 1), Math.min(50 * (retryCount + 1), 500));
+            }
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.control = new ScaleLine({
+                units: this.units(),
+                bar: this.bar(),
+                steps: this.steps(),
+            });
+            map.addControl(this.control);
+        });
+    }
+    ngOnDestroy() {
+        const map = this.mapService.getMap();
+        if (!this.control || !map)
+            return;
+        this.ngZone.runOutsideAngular(() => {
+            map.removeControl(this.control);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlScaleLineControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlScaleLineControlComponent, isStandalone: true, selector: "ol-scale-line-control", inputs: { units: { classPropertyName: "units", publicName: "units", isSignal: true, isRequired: false, transformFunction: null }, bar: { classPropertyName: "bar", publicName: "bar", isSignal: true, isRequired: false, transformFunction: null }, steps: { classPropertyName: "steps", publicName: "steps", 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: OlScaleLineControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-scale-line-control',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { units: [{ type: i0.Input, args: [{ isSignal: true, alias: "units", required: false }] }], bar: [{ type: i0.Input, args: [{ isSignal: true, alias: "bar", required: false }] }], steps: [{ type: i0.Input, args: [{ isSignal: true, alias: "steps", required: false }] }] } });
+
+// OlFullscreenControlComponent
+class OlFullscreenControlComponent {
+    mapService = inject(OlMapService);
+    ngZone = inject(NgZone);
+    source = input(...(ngDevMode ? [undefined, { debugName: "source" }] : /* istanbul ignore next */ []));
+    label = input('⤢', ...(ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []));
+    labelActive = input('⤡', ...(ngDevMode ? [{ debugName: "labelActive" }] : /* istanbul ignore next */ []));
+    tipLabel = input('Toggle full-screen', ...(ngDevMode ? [{ debugName: "tipLabel" }] : /* istanbul ignore next */ []));
+    control;
+    ngOnInit() {
+        this.tryAddControl();
+    }
+    tryAddControl(retryCount = 0) {
+        const map = this.mapService.getMap();
+        if (!map) {
+            if (retryCount < 10) {
+                setTimeout(() => this.tryAddControl(retryCount + 1), Math.min(50 * (retryCount + 1), 500));
+            }
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.control = new FullScreen({
+                source: this.source(),
+                label: this.label(),
+                labelActive: this.labelActive(),
+                tipLabel: this.tipLabel(),
+            });
+            map.addControl(this.control);
+        });
+    }
+    ngOnDestroy() {
+        const map = this.mapService.getMap();
+        if (!this.control || !map)
+            return;
+        this.ngZone.runOutsideAngular(() => {
+            map.removeControl(this.control);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlFullscreenControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.4", type: OlFullscreenControlComponent, isStandalone: true, selector: "ol-fullscreen-control", inputs: { source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: false, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null }, labelActive: { classPropertyName: "labelActive", publicName: "labelActive", isSignal: true, isRequired: false, transformFunction: null }, tipLabel: { classPropertyName: "tipLabel", publicName: "tipLabel", 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: OlFullscreenControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ol-fullscreen-control',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: false }] }], label: [{ type: i0.Input, args: [{ isSignal: true, alias: "label", required: false }] }], labelActive: [{ type: i0.Input, args: [{ isSignal: true, alias: "labelActive", required: false }] }], tipLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "tipLabel", required: false }] }] } });
+
+// OlControlService
+class OlControlService {
+    addCustomControl(element, position) { }
+    removeCustomControl(element) { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlControlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlControlService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlControlService, decorators: [{
+            type: Injectable
+        }] });
+
+// Provider functions
+function withControls() {
+    return { kind: 'controls', providers: [OlControlService] };
+}
+function provideControls() {
+    return withControls();
+}
+
+// @angular-helpers/openlayers/controls
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlAttributionControlComponent, OlControlService, OlFullscreenControlComponent, OlScaleLineControlComponent, OlZoomControlComponent, provideControls, withControls };

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

@@ -0,0 +1,184 @@
+import * as i0 from '@angular/core';
+import { inject, NgZone, Injectable, input, output, viewChild, effect, ChangeDetectionStrategy, Component, makeEnvironmentProviders } from '@angular/core';
+import OLMap from 'ol/Map';
+import View from 'ol/View';
+import { fromLonLat, toLonLat } from 'ol/proj';
+
+// OlMapService
+class OlMapService {
+    ngZone = inject(NgZone);
+    map = null;
+    setMap(map) {
+        this.map = map;
+    }
+    getMap() {
+        return this.map;
+    }
+    getView() {
+        return this.map?.getView() ?? null;
+    }
+    setCenter(coordinate) {
+        const view = this.getView();
+        if (view)
+            this.ngZone.runOutsideAngular(() => view.setCenter(coordinate));
+    }
+    setZoom(level) {
+        const view = this.getView();
+        if (view)
+            this.ngZone.runOutsideAngular(() => view.setZoom(level));
+    }
+    fitExtent(extent, options) {
+        const view = this.getView();
+        if (view)
+            this.ngZone.runOutsideAngular(() => view.fit(extent, options));
+    }
+    animateView(options) {
+        const view = this.getView();
+        if (!view)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.ngZone.runOutsideAngular(() => {
+                view.animate({
+                    center: options.center,
+                    zoom: options.zoom,
+                    rotation: options.rotation,
+                    duration: options.duration ?? 250,
+                }, () => this.ngZone.run(() => resolve()));
+            });
+        });
+    }
+    getViewState() {
+        const view = this.getView();
+        if (!view)
+            return { center: [0, 0], zoom: 0, rotation: 0 };
+        return {
+            center: (view.getCenter() ?? [0, 0]),
+            zoom: view.getZoom() ?? 0,
+            rotation: view.getRotation() ?? 0,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMapService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMapService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMapService, decorators: [{
+            type: Injectable
+        }] });
+
+// OlMapComponent
+class OlMapComponent {
+    mapService = inject(OlMapService);
+    ngZone = inject(NgZone);
+    center = input([0, 0], ...(ngDevMode ? [{ debugName: "center" }] : /* istanbul ignore next */ []));
+    zoom = input(0, ...(ngDevMode ? [{ debugName: "zoom" }] : /* istanbul ignore next */ []));
+    rotation = input(0, ...(ngDevMode ? [{ debugName: "rotation" }] : /* istanbul ignore next */ []));
+    projection = input('EPSG:3857', ...(ngDevMode ? [{ debugName: "projection" }] : /* istanbul ignore next */ []));
+    viewChange = output();
+    mapClick = output();
+    mapDblClick = output();
+    mapContainerRef = viewChild.required('mapContainer');
+    map;
+    constructor() {
+        effect(() => {
+            const center = this.center();
+            if (this.map)
+                this.updateCenter(center);
+        });
+        effect(() => {
+            const zoom = this.zoom();
+            if (this.map)
+                this.updateZoom(zoom);
+        });
+        effect(() => {
+            const rotation = this.rotation();
+            if (this.map)
+                this.updateRotation(rotation);
+        });
+    }
+    ngAfterViewInit() {
+        this.initMap();
+    }
+    ngOnDestroy() {
+        this.destroyMap();
+    }
+    initMap() {
+        const container = this.mapContainerRef().nativeElement;
+        this.ngZone.runOutsideAngular(() => {
+            const view = new View({
+                center: fromLonLat(this.center(), this.projection()),
+                zoom: this.zoom(),
+                rotation: this.rotation(),
+                projection: this.projection(),
+            });
+            this.map = new OLMap({ target: container, view, layers: [] });
+            this.mapService.setMap(this.map);
+            view.on('change:center', () => this.ngZone.run(() => this.emitViewChange()));
+            view.on('change:resolution', () => this.ngZone.run(() => this.emitViewChange()));
+            this.map.on('click', (e) => this.ngZone.run(() => this.mapClick.emit({
+                coordinate: e.coordinate,
+                pixel: e.pixel,
+            })));
+            this.map.on('dblclick', (e) => this.ngZone.run(() => this.mapDblClick.emit({
+                coordinate: e.coordinate,
+                pixel: e.pixel,
+            })));
+        });
+        this.emitViewChange();
+    }
+    destroyMap() {
+        if (this.map) {
+            this.ngZone.runOutsideAngular(() => {
+                this.map.setTarget(undefined);
+                this.map.dispose();
+            });
+            this.map = undefined;
+            this.mapService.setMap(null);
+        }
+    }
+    updateCenter(center) {
+        if (this.map) {
+            const projectedCenter = fromLonLat(center, this.projection());
+            this.ngZone.runOutsideAngular(() => this.map.getView().setCenter(projectedCenter));
+        }
+    }
+    updateZoom(zoom) {
+        if (this.map)
+            this.ngZone.runOutsideAngular(() => this.map.getView().setZoom(zoom));
+    }
+    updateRotation(rotation) {
+        if (this.map)
+            this.ngZone.runOutsideAngular(() => this.map.getView().setRotation(rotation));
+    }
+    emitViewChange() {
+        const view = this.map?.getView();
+        if (view) {
+            const projectedCenter = view.getCenter() ?? [0, 0];
+            const lonLatCenter = toLonLat(projectedCenter, this.projection());
+            this.viewChange.emit({
+                center: lonLatCenter,
+                zoom: view.getZoom() ?? 0,
+                rotation: view.getRotation() ?? 0,
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMapComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "21.2.4", type: OlMapComponent, isStandalone: true, selector: "ol-map", inputs: { center: { classPropertyName: "center", publicName: "center", isSignal: true, isRequired: false, transformFunction: null }, zoom: { classPropertyName: "zoom", publicName: "zoom", isSignal: true, isRequired: false, transformFunction: null }, rotation: { classPropertyName: "rotation", publicName: "rotation", isSignal: true, isRequired: false, transformFunction: null }, projection: { classPropertyName: "projection", publicName: "projection", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { viewChange: "viewChange", mapClick: "mapClick", mapDblClick: "mapDblClick" }, viewQueries: [{ propertyName: "mapContainerRef", first: true, predicate: ["mapContainer"], descendants: true, isSignal: true }], ngImport: i0, template: `<div class="ol-map-container" #mapContainer></div>
+    <ng-content />`, isInline: true, styles: [":host{display:block;width:100%;height:100%;position:relative}.ol-map-container{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ol-map', template: `<div class="ol-map-container" #mapContainer></div>
+    <ng-content />`, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%;position:relative}.ol-map-container{width:100%;height:100%}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { center: [{ type: i0.Input, args: [{ isSignal: true, alias: "center", required: false }] }], zoom: [{ type: i0.Input, args: [{ isSignal: true, alias: "zoom", required: false }] }], rotation: [{ type: i0.Input, args: [{ isSignal: true, alias: "rotation", required: false }] }], projection: [{ type: i0.Input, args: [{ isSignal: true, alias: "projection", required: false }] }], viewChange: [{ type: i0.Output, args: ["viewChange"] }], mapClick: [{ type: i0.Output, args: ["mapClick"] }], mapDblClick: [{ type: i0.Output, args: ["mapDblClick"] }], mapContainerRef: [{ type: i0.ViewChild, args: ['mapContainer', { isSignal: true }] }] } });
+
+// Provider functions
+function provideOpenLayers(...features) {
+    return makeEnvironmentProviders([OlMapService, ...features.flatMap((f) => f.providers)]);
+}
+
+// @angular-helpers/openlayers/core
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlMapComponent, OlMapService, provideOpenLayers };

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

@@ -0,0 +1,34 @@
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+// OlInteractionService
+class OlInteractionService {
+    enableInteraction(type, config) {
+        return null;
+    }
+    disableInteraction(id) { }
+    startDrawing(type, options) {
+        return new Observable();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlInteractionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlInteractionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlInteractionService, decorators: [{
+            type: Injectable
+        }] });
+
+function withInteractions() {
+    return { kind: 'interactions', providers: [OlInteractionService] };
+}
+function provideInteractions() {
+    return withInteractions();
+}
+
+// @angular-helpers/openlayers/interactions
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OlInteractionService, provideInteractions, withInteractions };