@angular-helpers/openlayers 0.4.0 → 0.5.0

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

@@ -1,201 +1,102 @@
 import * as i0 from '@angular/core';
-import { Injectable } from '@angular/core';
+import { inject, resource, Injectable } from '@angular/core';
+import { OlGeometryService } from '@angular-helpers/openlayers/core';
+import { Style, Icon, Stroke, RegularShape, Fill } from 'ol/style';
+import { LineString, Point } from 'ol/geom';
 
-// @angular-helpers/openlayers/military — service implementation
-/**
- * Meters per degree of latitude on a spherical Earth approximation.
- * Used by the local tangent-plane projection in the geometry helpers.
- */
-const METERS_PER_DEGREE_LAT = 111_320;
 /**
  * Service exposing geometry helpers and MIL-STD-2525 symbology rendering.
  *
  * - `createEllipse`, `createSector`, `createDonut` are **pure math** and
- *   have no runtime dependencies beyond the bundled types.
- * - `createMilSymbol` uses the milsymbol library via dynamic ESM import.
+ *   delegate to {@link OlGeometryService} in core.
+ * - `createMilSymbol` uses the milsymbol library via Angular resource loading.
  */
 class OlMilitaryService {
     idCounter = 0;
-    mlLoader = null;
-    msModule = null;
+    geometryService = inject(OlGeometryService);
+    /**
+     * Resource managing the lazy-loading of the milsymbol library.
+     * Angular resource provides native signals for value, loading state, and errors.
+     */
+    msResource = resource({ ...(ngDevMode ? { debugName: "msResource" } : /* istanbul ignore next */ {}), loader: () => import('milsymbol') });
+    /** Signal indicating if the milsymbol library is currently being loaded. */
+    isLoading = this.msResource.isLoading;
+    constructor() { }
     // ---------------------------------------------------------------------------
-    // Geometry helpers (pure math, no deps)
+    // Geometry helpers (delegated to core)
     // ---------------------------------------------------------------------------
     /**
      * Build a `Feature<Polygon>` approximating an ellipse centered at
      * `config.center`. See {@link EllipseConfig} for parameter semantics.
      */
     createEllipse(config) {
-        const { center, semiMajor, semiMinor, rotation = 0, segments = 64, properties } = config;
-        if (semiMajor <= 0 || semiMinor <= 0) {
-            throw new RangeError('semiMajor and semiMinor must be positive');
-        }
-        if (segments < 8) {
-            throw new RangeError('segments must be >= 8');
-        }
-        const cosR = Math.cos(rotation);
-        const sinR = Math.sin(rotation);
-        const ring = [];
-        for (let i = 0; i < segments; i++) {
-            const theta = (i / segments) * Math.PI * 2;
-            // Ellipse in local axis-aligned frame, then rotated by `rotation`.
-            const ax = Math.cos(theta) * semiMajor;
-            const ay = Math.sin(theta) * semiMinor;
-            const dx = ax * cosR - ay * sinR;
-            const dy = ax * sinR + ay * cosR;
-            ring.push(this.offsetMetersToLonLat(center, dx, dy));
-        }
-        ring.push(ring[0]); // close the ring
-        return {
-            id: this.nextId('ellipse'),
-            geometry: { type: 'Polygon', coordinates: [ring] },
-            properties,
-        };
+        return this.geometryService.createEllipse(config);
     }
     /**
      * Build a `Feature<Polygon>` for a circular sector (pie slice).
      * See {@link SectorConfig} for parameter semantics.
      */
     createSector(config) {
-        const { center, radius, startAngle, endAngle, segments = 32, properties } = config;
-        if (radius <= 0) {
-            throw new RangeError('radius must be positive');
-        }
-        if (endAngle <= startAngle) {
-            throw new RangeError('endAngle must be greater than startAngle');
-        }
-        if (endAngle - startAngle > Math.PI * 2) {
-            throw new RangeError('sector cannot exceed full circle');
-        }
-        if (segments < 4) {
-            throw new RangeError('segments must be >= 4');
-        }
-        const ring = [center];
-        const span = endAngle - startAngle;
-        for (let i = 0; i <= segments; i++) {
-            const theta = startAngle + (i / segments) * span;
-            const dx = Math.cos(theta) * radius;
-            const dy = Math.sin(theta) * radius;
-            ring.push(this.offsetMetersToLonLat(center, dx, dy));
-        }
-        ring.push(center); // close back to apex
-        return {
-            id: this.nextId('sector'),
-            geometry: { type: 'Polygon', coordinates: [ring] },
-            properties,
-        };
+        return this.geometryService.createSector(config);
     }
     /**
-     * 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.
+     * Build a `Feature<Polygon>` for a donut (annular ring).
      */
     createDonut(config) {
-        const { center, outerRadius, innerRadius, segments = 64, properties } = config;
-        if (outerRadius <= 0 || innerRadius <= 0) {
-            throw new RangeError('radii must be positive');
-        }
-        if (outerRadius <= innerRadius) {
-            throw new RangeError('outerRadius must be greater than innerRadius');
-        }
-        if (segments < 8) {
-            throw new RangeError('segments must be >= 8');
-        }
-        const outer = [];
-        const inner = [];
-        for (let i = 0; i < segments; i++) {
-            const theta = (i / segments) * Math.PI * 2;
-            const cosT = Math.cos(theta);
-            const sinT = Math.sin(theta);
-            // Outer ring: CCW (theta increasing)
-            outer.push(this.offsetMetersToLonLat(center, cosT * outerRadius, sinT * outerRadius));
-            // Inner ring: CW — sample the SAME thetas but we'll reverse the
-            // accumulator below so the ring is traversed in the opposite sense.
-            inner.push(this.offsetMetersToLonLat(center, cosT * innerRadius, sinT * innerRadius));
-        }
-        inner.reverse();
-        outer.push(outer[0]);
-        inner.push(inner[0]);
-        return {
-            id: this.nextId('donut'),
-            geometry: { type: 'Polygon', coordinates: [outer, inner] },
-            properties,
-        };
+        return this.geometryService.createDonut(config);
     }
     // ---------------------------------------------------------------------------
     // MIL-STD-2525 symbology (lazy `milsymbol` load)
     // ---------------------------------------------------------------------------
     /**
-     * Pre-load the optional `milsymbol` peer dependency so subsequent calls
-     * to `createMilSymbol` / `createMilSymbolSync` resolve immediately.
-     * Idempotent — multiple calls share the same promise.
+     * Pre-load the optional `milsymbol` peer dependency.
+     * Since resource() starts loading immediately, this simply returns a promise
+     * that resolves when the resource is ready.
      */
-    preloadMilsymbol() {
+    async preloadMilsymbol() {
         this.assertBrowser();
-        if (!this.mlLoader) {
-            this.mlLoader = import('milsymbol').then((m) => {
-                this.msModule = m;
-                return m;
-            });
-        }
-        return this.mlLoader.then(() => {
-            // Void return for the public API
-        });
+        // We can just await the dynamic import again; the browser/bundler will
+        // return the same module instantly if already loaded by the resource.
+        await import('milsymbol');
     }
     /**
      * Build a MIL-STD-2525 symbol feature asynchronously.
-     * Lazy-loads `milsymbol` on the first call.
+     * Waits for the milsymbol resource to resolve.
      */
     async createMilSymbol(config) {
         this.assertBrowser();
         this.assertSidc(config.sidc);
-        if (!this.msModule) {
-            await this.preloadMilsymbol();
-        }
-        return this.buildSymbolFeature(config);
+        // Dynamic import ensures we have the module reference even if called
+        // before the resource signal has propagated.
+        const msModule = await import('milsymbol');
+        return this.buildSymbolFeature(config, msModule);
     }
     /**
      * Build a MIL-STD-2525 symbol feature synchronously.
-     * Throws if `milsymbol` has not been preloaded via `preloadMilsymbol()`
-     * or a previous `createMilSymbol()` call.
+     * Throws if `milsymbol` resource is not ready.
      */
     createMilSymbolSync(config) {
         this.assertBrowser();
         this.assertSidc(config.sidc);
-        if (!this.msModule) {
+        const msModule = this.msResource.value();
+        if (!msModule) {
             throw new Error('milsymbol is not loaded yet. Call preloadMilsymbol() or use the async createMilSymbol().');
         }
-        return this.buildSymbolFeature(config);
+        return this.buildSymbolFeature(config, msModule);
     }
     // ---------------------------------------------------------------------------
     // Internals
     // ---------------------------------------------------------------------------
-    /**
-     * Project an `(dx, dy)` meter offset from `center` to lon/lat using a
-     * local tangent-plane (equirectangular) approximation. Acceptable for
-     * the radii typical in military symbology (<100 km from center).
-     */
-    offsetMetersToLonLat(center, dx, dy) {
-        const [lon, lat] = center;
-        const latRad = (lat * Math.PI) / 180;
-        const dLat = dy / METERS_PER_DEGREE_LAT;
-        const dLon = dx / (METERS_PER_DEGREE_LAT * Math.cos(latRad));
-        return [lon + dLon, lat + dLat];
-    }
     nextId(kind) {
         return `${kind}-${++this.idCounter}`;
     }
-    buildSymbolFeature(config) {
+    buildSymbolFeature(config, msModule) {
         const { sidc, position, properties, quantity, ...rest } = config;
-        // `milsymbol` types `quantity` as a string, but a number is the
-        // ergonomic shape; coerce here.
         const milOptions = {
             ...rest,
             ...(quantity !== undefined ? { quantity: String(quantity) } : {}),
         };
-        // We asserted this.msModule exists before calling this
-        const ms = this.msModule;
-        // default import might be wrapped depending on bundler
+        const ms = msModule;
         const SymbolClass = ms.default?.Symbol || ms.Symbol;
         const symbol = new SymbolClass(sidc, milOptions);
         const style = this.symbolToStyleResult(symbol);
@@ -218,10 +119,33 @@ class OlMilitaryService {
         };
     }
     encodeBase64Utf8(input) {
-        // `btoa` only handles Latin-1; this round-trip preserves non-ASCII
-        // characters (e.g. unit designators with accents).
         return btoa(unescape(encodeURIComponent(input)));
     }
+    /**
+     * Generates a canvas and anchor for a MIL-STD-2525 symbol.
+     * Requires milsymbol to be loaded (synchronous).
+     */
+    createUnitStyle(sidc, selected = false, size = 30) {
+        const msModule = this.msResource.value();
+        if (!msModule)
+            return null;
+        const ms = msModule;
+        const SymbolClass = ms.default?.Symbol || ms.Symbol;
+        const symbol = new SymbolClass(sidc, {
+            size,
+            strokeWidth: selected ? 6 : 4,
+        });
+        const canvas = symbol.asCanvas();
+        const anchor = symbol.getAnchor();
+        return {
+            image: {
+                img: canvas,
+                size: [canvas.width, canvas.height],
+                anchor: [anchor.x / canvas.width, anchor.y / canvas.height],
+            },
+            zIndex: selected ? 100 : 10,
+        };
+    }
     assertSidc(sidc) {
         if (typeof sidc !== 'string' || sidc.length < 10) {
             throw new TypeError('sidc must be a non-empty MIL-STD-2525 SIDC string');
@@ -232,15 +156,191 @@ class OlMilitaryService {
             throw new Error('createMilSymbol requires a browser environment');
         }
     }
-    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 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlMilitaryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlMilitaryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlMilitaryService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+// Tactical Graphics Service — investigation and prototype for military line drawing
+/**
+ * Service providing styles and geometry generators for military tactical graphics
+ * such as battle fronts, axes of attack, and boundaries.
+ *
+ * NOTE: For point symbols (units), it delegates to {@link OlMilitaryService}
+ * for lazy-loading `milsymbol`.
+ */
+class OlTacticalGraphicsService {
+    idCounter = 0;
+    militaryService = inject(OlMilitaryService);
+    /**
+     * Creates a LineString feature representing a battle front.
+     */
+    createFrontLine(coordinates, direction = 'friendly') {
+        return {
+            id: this.nextId('front-line'),
+            geometry: { type: 'LineString', coordinates },
+            properties: { tacticalType: 'front-line', direction },
+        };
+    }
+    /**
+     * Creates a LineString feature representing an attack arrow.
+     */
+    createAttackArrow(coordinates, direction = 'friendly') {
+        return {
+            id: this.nextId('attack-arrow'),
+            geometry: { type: 'LineString', coordinates },
+            properties: { tacticalType: 'attack-arrow', direction },
+        };
+    }
+    /**
+     * Creates a Polygon feature representing a control zone.
+     */
+    createControlZone(coordinates, direction = 'friendly') {
+        return {
+            id: this.nextId('control-zone'),
+            geometry: { type: 'Polygon', coordinates },
+            properties: { tacticalType: 'control-zone', direction },
+        };
+    }
+    /**
+     * Creates a Point feature representing a military unit.
+     * @param sidc - Symbol Identification Code (MIL-STD-2525 / APP-6)
+     */
+    createUnit(coordinate, sidc, name) {
+        return {
+            id: this.nextId('unit'),
+            geometry: { type: 'Point', coordinates: coordinate },
+            properties: { tacticalType: 'unit', sidc, name },
+        };
+    }
+    nextId(kind) {
+        return `${kind}-${++this.idCounter}`;
+    }
+    /**
+     * Style for Troop Units using milsymbol.
+     * NOTE: Requires milsymbol to be pre-loaded via OlMilitaryService.
+     */
+    createUnitStyle(sidc, selected = false) {
+        // We delegate the style calculation to militaryService which handles the lazy-load state.
+        const styleProperties = this.militaryService.createUnitStyle(sidc, selected);
+        if (!styleProperties)
+            return null;
+        return new Style({
+            image: new Icon({
+                img: styleProperties.image.img,
+                size: styleProperties.image.size,
+                anchor: styleProperties.image.anchor,
+            }),
+            zIndex: styleProperties.zIndex,
+        });
+    }
+    /**
+     * Style for Battle Fronts (Complex LineString with teeth).
+     */
+    createFrontLineStyle(color, direction = 'friendly') {
+        return (feature, resolution) => {
+            const geometry = feature.getGeometry();
+            if (!(geometry instanceof LineString))
+                return [];
+            const styles = [
+                new Style({
+                    stroke: new Stroke({
+                        color,
+                        width: 3,
+                        lineDash: direction === 'hostile' ? [10, 10] : undefined,
+                    }),
+                }),
+            ];
+            const coords = geometry.getCoordinates();
+            const stride = 40 * resolution; // Spacing between markers
+            let distSoFar = 0;
+            for (let i = 0; i < coords.length - 1; i++) {
+                const p1 = coords[i];
+                const p2 = coords[i + 1];
+                const dx = p2[0] - p1[0];
+                const dy = p2[1] - p1[1];
+                const len = Math.sqrt(dx * dx + dy * dy);
+                const angle = Math.atan2(dy, dx);
+                while (distSoFar < len) {
+                    const ratio = distSoFar / len;
+                    const pos = [p1[0] + dx * ratio, p1[1] + dy * ratio];
+                    // Add "teeth" or spikes along the line
+                    styles.push(new Style({
+                        geometry: new Point(pos),
+                        image: new RegularShape({
+                            fill: new Fill({ color }),
+                            points: direction === 'friendly' ? 20 : 3, // Semicircle vs Triangle
+                            radius: 6,
+                            rotation: -angle + (direction === 'friendly' ? 0 : Math.PI / 2),
+                            angle: direction === 'friendly' ? angle + Math.PI / 2 : 0,
+                        }),
+                    }));
+                    distSoFar += stride;
+                }
+                distSoFar -= len;
+            }
+            return styles;
+        };
+    }
+    /**
+     * Style for Troop Movements (Arrows).
+     */
+    createAttackArrowStyle(color) {
+        return (feature) => {
+            const geometry = feature.getGeometry();
+            if (!(geometry instanceof LineString))
+                return [];
+            const coords = geometry.getCoordinates();
+            if (coords.length < 2)
+                return [];
+            const last = coords[coords.length - 1];
+            const prev = coords[coords.length - 2];
+            const angle = Math.atan2(last[1] - prev[1], last[0] - prev[0]);
+            return [
+                new Style({
+                    stroke: new Stroke({ color, width: 4, lineDash: [8, 4] }),
+                }),
+                new Style({
+                    geometry: new Point(last),
+                    image: new RegularShape({
+                        fill: new Fill({ color }),
+                        points: 3,
+                        radius: 14,
+                        rotation: -angle + Math.PI / 2,
+                    }),
+                }),
+            ];
+        };
+    }
+    /**
+     * Style for Control Zones (Polygons).
+     */
+    createZoneStyle(color, opacity = 0.2) {
+        return new Style({
+            fill: new Fill({ color: this.hexToRgba(color, opacity) }),
+            stroke: new Stroke({ color, width: 2 }),
+        });
+    }
+    hexToRgba(hex, alpha) {
+        const r = parseInt(hex.slice(1, 3), 16);
+        const g = parseInt(hex.slice(3, 5), 16);
+        const b = parseInt(hex.slice(5, 7), 16);
+        return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlTacticalGraphicsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlTacticalGraphicsService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlMilitaryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlTacticalGraphicsService, decorators: [{
             type: Injectable
         }] });
 
 function withMilitary() {
-    return { kind: 'military', providers: [OlMilitaryService] };
+    return {
+        kind: 'military',
+        providers: [OlMilitaryService, OlTacticalGraphicsService],
+    };
 }
 function provideMilitary() {
     return withMilitary();
@@ -252,4 +352,4 @@ function provideMilitary() {
  * Generated bundle index. Do not edit.
  */
 
-export { OlMilitaryService, provideMilitary, withMilitary };
+export { OlMilitaryService, OlTacticalGraphicsService, provideMilitary, withMilitary };

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

@@ -107,8 +107,8 @@ class OlPopupComponent {
         this.overlay = null;
         this.currentMap = null;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.4", type: OlPopupComponent, isStandalone: true, selector: "ol-popup", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, offset: { classPropertyName: "offset", publicName: "offset", isSignal: true, isRequired: false, transformFunction: null }, positioning: { classPropertyName: "positioning", publicName: "positioning", isSignal: true, isRequired: false, transformFunction: null }, autoPan: { classPropertyName: "autoPan", publicName: "autoPan", isSignal: true, isRequired: false, transformFunction: null }, closeButton: { classPropertyName: "closeButton", publicName: "closeButton", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { closed: "closed" }, host: { attributes: { "role": "dialog" } }, ngImport: i0, template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlPopupComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.13", type: OlPopupComponent, isStandalone: true, selector: "ol-popup", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, offset: { classPropertyName: "offset", publicName: "offset", isSignal: true, isRequired: false, transformFunction: null }, positioning: { classPropertyName: "positioning", publicName: "positioning", isSignal: true, isRequired: false, transformFunction: null }, autoPan: { classPropertyName: "autoPan", publicName: "autoPan", isSignal: true, isRequired: false, transformFunction: null }, closeButton: { classPropertyName: "closeButton", publicName: "closeButton", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { closed: "closed" }, host: { attributes: { "role": "dialog" } }, ngImport: i0, template: `
     @if (closeButton()) {
       <button type="button" class="ol-popup-close" aria-label="Close" (click)="onCloseClick()">
         ×
@@ -117,7 +117,7 @@ class OlPopupComponent {
     <ng-content />
   `, isInline: true, styles: [":host{display:block;position:relative}.ol-popup-close{position:absolute;top:4px;right:4px;width:20px;height:20px;padding:0;border:none;background:transparent;font-size:16px;line-height:1;cursor:pointer;color:inherit}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlPopupComponent, decorators: [{
             type: Component,
             args: [{ selector: 'ol-popup', changeDetection: ChangeDetectionStrategy.OnPush, template: `
     @if (closeButton()) {
@@ -232,10 +232,10 @@ class OlTooltipDirective {
         this.listener = null;
         this.currentMap = null;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.4", type: OlTooltipDirective, isStandalone: true, selector: "[olTooltip]", inputs: { olTooltip: { classPropertyName: "olTooltip", publicName: "olTooltip", isSignal: true, isRequired: true, transformFunction: null }, olTooltipLayer: { classPropertyName: "olTooltipLayer", publicName: "olTooltipLayer", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.13", type: OlTooltipDirective, isStandalone: true, selector: "[olTooltip]", inputs: { olTooltip: { classPropertyName: "olTooltip", publicName: "olTooltip", isSignal: true, isRequired: true, transformFunction: null }, olTooltipLayer: { classPropertyName: "olTooltipLayer", publicName: "olTooltipLayer", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlTooltipDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlTooltipDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[olTooltip]',
@@ -410,10 +410,10 @@ class OlPopupService {
             this.popups.set(id, { id, overlay, componentRef: ref, dispose });
         });
     }
-    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 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlPopupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlPopupService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: OlPopupService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.13", ngImport: i0, type: OlPopupService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 // -----------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-helpers/openlayers",
-  "version": "0.4.0",
+  "version": "0.5.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": {
@@ -82,4 +82,4 @@
   "dependencies": {
     "tslib": "^2.3.0"
   }
-}
+}

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, OnInit, ElementRef } from '@angular/core';
 import OLMap from 'ol/Map';
 import { OlFeature } from '@angular-helpers/openlayers/core';
 
@@ -87,7 +87,7 @@ interface LayerSwitcherItem {
     /** Display name for the layer */
     name: string;
     /** Type of the layer */
-    type: 'vector' | 'tile' | 'image';
+    type: 'vector' | 'tile' | 'image' | 'heatmap';
     /** Whether the layer is currently visible */
     visible: boolean;
     /** Opacity of the layer (0-1) */
@@ -114,7 +114,7 @@ type LayerSwitcherPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-
  * </ol-layer-switcher>
  * ```
  */
-declare class OlLayerSwitcherComponent {
+declare class OlLayerSwitcherComponent implements OnInit {
     position: _angular_core.InputSignal<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
     layers: _angular_core.InputSignal<LayerSwitcherItem[]>;
     collapsible: _angular_core.InputSignal<boolean>;
@@ -129,6 +129,7 @@ declare class OlLayerSwitcherComponent {
         opacity: number;
     }>;
     protected isCollapsed: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
     toggleCollapsed(): void;
     toggleLayer(id: string): void;
     setOpacity(id: string, event: Event): void;
@@ -197,6 +198,25 @@ interface ControlConfig {
     className?: string;
 }
 
+declare class OlGeolocationControlComponent {
+    private mapService;
+    private zoneHelper;
+    private destroyRef;
+    position: _angular_core.InputSignal<ControlPosition>;
+    trackingChange: _angular_core.OutputEmitterRef<boolean>;
+    controlElement: ElementRef<HTMLElement>;
+    protected tracking: _angular_core.WritableSignal<boolean>;
+    private control?;
+    private geolocation?;
+    private positionFeature?;
+    private accuracyFeature?;
+    private layer?;
+    constructor();
+    toggleTracking(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OlGeolocationControlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OlGeolocationControlComponent, "ol-geolocation-control", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "trackingChange": "trackingChange"; }, never, never, true, never>;
+}
+
 declare class OlControlService {
     addCustomControl(element: HTMLElement, position: ControlPosition): void;
     removeCustomControl(element: HTMLElement): void;
@@ -211,5 +231,5 @@ declare class OlControlService {
 declare function withControls(): OlFeature<'controls'>;
 declare function provideControls(): OlFeature<'controls'>;
 
-export { OlAttributionControlComponent, OlBasemapSwitcherComponent, OlControlService, OlFullscreenControlComponent, OlLayerSwitcherComponent, OlRotateControlComponent, OlScaleLineControlComponent, OlZoomControlComponent, ROTATE_CONTROL_MAP_SERVICE, provideControls, withControls };
+export { OlAttributionControlComponent, OlBasemapSwitcherComponent, OlControlService, OlFullscreenControlComponent, OlGeolocationControlComponent, OlLayerSwitcherComponent, OlRotateControlComponent, OlScaleLineControlComponent, OlZoomControlComponent, ROTATE_CONTROL_MAP_SERVICE, provideControls, withControls };
 export type { BasemapConfig, BasemapSwitcherPosition, ControlConfig, ControlPosition, LayerSwitcherItem, LayerSwitcherPosition, RotateControlMapService };