@angular-helpers/openlayers 0.4.0 → 0.5.0

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

@@ -1,78 +1,8 @@
-import { Coordinate, Feature, OlFeature } from '@angular-helpers/openlayers/core';
 import * as i0 from '@angular/core';
+import { Coordinate, EllipseConfig, Feature, SectorConfig, DonutConfig, OlFeature } from '@angular-helpers/openlayers/core';
+import { Style } from 'ol/style';
+import { Feature as Feature$1 } from 'ol';
 
-/**
- * Configuration for an ellipse polygon centered at `center`.
- * Coordinates are emitted in EPSG:4326 (lon/lat) using a local tangent-plane
- * approximation; accuracy degrades for radii > ~100 km or near the poles.
- */
-interface EllipseConfig {
-    /** Ellipse center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Semi-major axis in meters. Must be > 0. */
-    semiMajor: number;
-    /** Semi-minor axis in meters. Must be > 0. */
-    semiMinor: number;
-    /**
-     * Rotation in radians, counter-clockwise from East. Default: 0
-     * (semi-major axis points East).
-     */
-    rotation?: number;
-    /**
-     * Number of vertices used to approximate the ellipse. Default: 64.
-     * Minimum: 8.
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
-/**
- * Configuration for a circular sector (pie-slice) polygon.
- * Same projection caveats as `EllipseConfig`.
- */
-interface SectorConfig {
-    /** Sector apex / center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Sector radius in meters. Must be > 0. */
-    radius: number;
-    /** Start angle in radians (0 = East, CCW positive). */
-    startAngle: number;
-    /**
-     * End angle in radians. Must satisfy `startAngle < endAngle <= startAngle + 2π`.
-     */
-    endAngle: number;
-    /**
-     * Number of vertices along the arc. Default: 32. Minimum: 4. The output
-     * polygon has `segments + 3` vertices (apex + arc + apex closer).
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
-/**
- * Configuration for a donut (annular ring) polygon — a disk with a
- * concentric circular hole. Useful for range rings, exclusion zones,
- * and similar GIS military primitives.
- *
- * The output `Feature<Polygon>` has TWO rings: an outer ring (CCW) and
- * an inner ring (CW per the GeoJSON right-hand rule), so renderers that
- * follow the spec fill only the band between the radii.
- */
-interface DonutConfig {
-    /** Donut center as `[lon, lat]` in EPSG:4326. */
-    center: Coordinate;
-    /** Outer radius in meters. Must be > `innerRadius`. */
-    outerRadius: number;
-    /** Inner radius in meters. Must be > 0 and < `outerRadius`. */
-    innerRadius: number;
-    /**
-     * Number of vertices per ring. Default: 64. Minimum: 8. Both rings use
-     * the same segment count.
-     */
-    segments?: number;
-    /** Custom feature properties to attach to the output feature. */
-    properties?: Record<string, unknown>;
-}
 /**
  * Subset of `milsymbol`'s `SymbolOptions` exposed by this package.
  * `sidc` is the only required field; everything else is optional and
@@ -124,13 +54,20 @@ interface MilSymbolStyleResult {
  * 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.
  */
 declare class OlMilitaryService {
     private idCounter;
-    private mlLoader;
-    private msModule;
+    private geometryService;
+    /**
+     * Resource managing the lazy-loading of the milsymbol library.
+     * Angular resource provides native signals for value, loading state, and errors.
+     */
+    private readonly msResource;
+    /** Signal indicating if the milsymbol library is currently being loaded. */
+    readonly isLoading: i0.Signal<boolean>;
+    constructor();
     /**
      * Build a `Feature<Polygon>` approximating an ellipse centered at
      * `config.center`. See {@link EllipseConfig} for parameter semantics.
@@ -142,46 +79,99 @@ declare class OlMilitaryService {
      */
     createSector(config: SectorConfig): Feature;
     /**
-     * Build a `Feature<Polygon>` for a donut (annular ring). The output has
-     * two rings: an outer ring wound counter-clockwise and an inner ring
-     * wound clockwise so the GeoJSON right-hand rule renders the hole.
+     * Build a `Feature<Polygon>` for a donut (annular ring).
      */
     createDonut(config: DonutConfig): Feature;
     /**
-     * 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(): Promise<void>;
     /**
      * Build a MIL-STD-2525 symbol feature asynchronously.
-     * Lazy-loads `milsymbol` on the first call.
+     * Waits for the milsymbol resource to resolve.
      */
     createMilSymbol(config: MilSymbolConfig): Promise<Feature>;
     /**
      * 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: MilSymbolConfig): Feature;
-    /**
-     * 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).
-     */
-    private offsetMetersToLonLat;
     private nextId;
     private buildSymbolFeature;
     private symbolToStyleResult;
     private encodeBase64Utf8;
+    /**
+     * Generates a canvas and anchor for a MIL-STD-2525 symbol.
+     * Requires milsymbol to be loaded (synchronous).
+     */
+    createUnitStyle(sidc: string, selected?: boolean, size?: number): {
+        image: {
+            img: HTMLCanvasElement;
+            size: [number, number];
+            anchor: [number, number];
+        };
+        zIndex: number;
+    } | null;
     private assertSidc;
     private assertBrowser;
     static ɵfac: i0.ɵɵFactoryDeclaration<OlMilitaryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OlMilitaryService>;
 }
 
+/**
+ * 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`.
+ */
+declare class OlTacticalGraphicsService {
+    private idCounter;
+    private militaryService;
+    /**
+     * Creates a LineString feature representing a battle front.
+     */
+    createFrontLine(coordinates: Coordinate[], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a LineString feature representing an attack arrow.
+     */
+    createAttackArrow(coordinates: Coordinate[], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a Polygon feature representing a control zone.
+     */
+    createControlZone(coordinates: Coordinate[][], direction?: 'friendly' | 'hostile'): Feature;
+    /**
+     * Creates a Point feature representing a military unit.
+     * @param sidc - Symbol Identification Code (MIL-STD-2525 / APP-6)
+     */
+    createUnit(coordinate: Coordinate, sidc: string, name: string): Feature;
+    private nextId;
+    /**
+     * Style for Troop Units using milsymbol.
+     * NOTE: Requires milsymbol to be pre-loaded via OlMilitaryService.
+     */
+    createUnitStyle(sidc: string, selected?: boolean): Style | null;
+    /**
+     * Style for Battle Fronts (Complex LineString with teeth).
+     */
+    createFrontLineStyle(color: string, direction?: 'friendly' | 'hostile'): (feature: Feature$1, resolution: number) => Style[];
+    /**
+     * Style for Troop Movements (Arrows).
+     */
+    createAttackArrowStyle(color: string): (feature: Feature$1) => Style[];
+    /**
+     * Style for Control Zones (Polygons).
+     */
+    createZoneStyle(color: string, opacity?: number): Style;
+    private hexToRgba;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OlTacticalGraphicsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OlTacticalGraphicsService>;
+}
+
 declare function withMilitary(): OlFeature<'military'>;
 declare function provideMilitary(): OlFeature<'military'>;
 
-export { OlMilitaryService, provideMilitary, withMilitary };
-export type { DonutConfig, EllipseConfig, MilSymbolConfig, MilSymbolStyleResult, SectorConfig };
+export { OlMilitaryService, OlTacticalGraphicsService, provideMilitary, withMilitary };
+export type { MilSymbolConfig, MilSymbolStyleResult };