aur-openlayers 19.6.4 → 19.6.6

package/README.md

@@ -1,63 +1,63 @@
-# Lib
-
-This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 19.2.0.
-
-## Code scaffolding
-
-Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
-
-```bash
-ng generate component component-name
-```
-
-For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
-
-```bash
-ng generate --help
-```
-
-## Building
-
-To build the library, run:
-
-```bash
-ng build lib
-```
-
-This command will compile your project, and the build artifacts will be placed in the `dist/` directory.
-
-### Publishing the Library
-
-Once the project is built, you can publish your library by following these steps:
-
-1. Navigate to the `dist` directory:
-   ```bash
-   cd dist/lib
-   ```
-
-2. Run the `npm publish` command to publish your library to the npm registry:
-   ```bash
-   npm publish
-   ```
-
-## Running unit tests
-
-To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:
-
-```bash
-ng test
-```
-
-## Running end-to-end tests
-
-For end-to-end (e2e) testing, run:
-
-```bash
-ng e2e
-```
-
-Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
-
-## Additional Resources
-
-For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.
+# Lib
+
+This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 19.2.0.
+
+## Code scaffolding
+
+Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
+
+```bash
+ng generate component component-name
+```
+
+For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
+
+```bash
+ng generate --help
+```
+
+## Building
+
+To build the library, run:
+
+```bash
+ng build lib
+```
+
+This command will compile your project, and the build artifacts will be placed in the `dist/` directory.
+
+### Publishing the Library
+
+Once the project is built, you can publish your library by following these steps:
+
+1. Navigate to the `dist` directory:
+   ```bash
+   cd dist/lib
+   ```
+
+2. Run the `npm publish` command to publish your library to the npm registry:
+   ```bash
+   npm publish
+   ```
+
+## Running unit tests
+
+To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:
+
+```bash
+ng test
+```
+
+## Running end-to-end tests
+
+For end-to-end (e2e) testing, run:
+
+```bash
+ng e2e
+```
+
+Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
+
+## Additional Resources
+
+For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/fesm2022/aur-openlayers.mjs

@@ -9,6 +9,9 @@ import Collection from 'ol/Collection';
 import DragPan from 'ol/interaction/DragPan';
 import Modify from 'ol/interaction/Modify';
 import * as Observable from 'ol/Observable';
+import { unByKey } from 'ol/Observable';
+import { LineString, MultiLineString, Point, Polygon } from 'ol/geom';
+import { toLonLat } from 'ol/proj';
 
 class LibService {
     constructor() { }
@@ -24,18 +27,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImpo
 
 class LibComponent {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.18", type: LibComponent, isStandalone: true, selector: "lib-lib", ngImport: i0, template: `
-    <p>
-      lib works!
-    </p>
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.18", type: LibComponent, isStandalone: true, selector: "lib-lib", ngImport: i0, template: `
+    <p>
+      lib works!
+    </p>
   `, isInline: true, styles: [""] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'lib-lib', imports: [], template: `
-    <p>
-      lib works!
-    </p>
+            args: [{ selector: 'lib-lib', imports: [], template: `
+    <p>
+      lib works!
+    </p>
   ` }]
         }] });
 
@@ -1585,7 +1588,7 @@ class StyleCache {
     }
 }
 
-const resolveMaybeFn = (value, args) => {
+const resolveMaybeFn$1 = (value, args) => {
     if (typeof value === 'function') {
         return value(...args);
     }
@@ -1620,7 +1623,7 @@ const createStyleFunction = (options) => {
             resolution,
             zoom: map?.getView().getZoom(),
         };
-        let opts = resolveMaybeFn(style.base, [model, view]);
+        let opts = resolveMaybeFn$1(style.base, [model, view]);
         if (style.states) {
             const featureStates = orderStates(getFeatureStates(feature), style.statePriority);
             featureStates.forEach((state) => {
@@ -1628,7 +1631,7 @@ const createStyleFunction = (options) => {
                 if (!patchFactory) {
                     return;
                 }
-                const patch = resolveMaybeFn(patchFactory, [model, view]);
+                const patch = resolveMaybeFn$1(patchFactory, [model, view]);
                 opts = applyPatch(opts, patch);
             });
         }
@@ -2292,6 +2295,360 @@ class PopupHost {
     }
 }
 
+const resolveMaybeFn = (value, args) => typeof value === 'function' ? value(...args) : value;
+/**
+ * Extracts flat coordinate arrays from a feature's geometry.
+ * Supports LineString and MultiLineString; returns empty array for others.
+ */
+function extractLineCoords$1(geometry) {
+    if (geometry instanceof LineString) {
+        return [geometry.getCoordinates()];
+    }
+    if (geometry instanceof MultiLineString) {
+        return geometry.getCoordinates();
+    }
+    return [];
+}
+/**
+ * Generate arrow points along a polyline at a given interval (meters in EPSG:3857).
+ */
+function generateArrowPoints(coords, intervalMeters, offsetRatio) {
+    if (coords.length < 2 || intervalMeters <= 0)
+        return [];
+    const arrows = [];
+    let accumulated = intervalMeters * offsetRatio;
+    for (let i = 0; i < coords.length - 1; i++) {
+        const ax = coords[i][0], ay = coords[i][1];
+        const bx = coords[i + 1][0], by = coords[i + 1][1];
+        const segLen = Math.hypot(bx - ax, by - ay);
+        const rotation = Math.atan2(bx - ax, by - ay);
+        while (accumulated <= segLen) {
+            const t = accumulated / segLen;
+            arrows.push({
+                coordinate: [ax + t * (bx - ax), ay + t * (by - ay)],
+                rotation,
+            });
+            accumulated += intervalMeters;
+        }
+        accumulated -= segLen;
+    }
+    return arrows;
+}
+class ArrowDecorationManager {
+    source = new VectorSource();
+    layer;
+    config;
+    map;
+    parentLayer;
+    parentApi;
+    moveEndKey;
+    unsubCollection;
+    unsubChanges;
+    rafId = null;
+    constructor(options) {
+        this.config = options.config;
+        this.map = options.map;
+        this.parentLayer = options.parentLayer;
+        this.parentApi = options.parentApi;
+        const parentZ = this.parentLayer.getZIndex() ?? 0;
+        this.layer = new VectorLayer({
+            source: this.source,
+            zIndex: parentZ + 2,
+        });
+        this.layer.set('id', `__decoration_arrows`);
+        this.map.addLayer(this.layer);
+        this.syncVisibility();
+        this.syncOpacity();
+        this.moveEndKey = this.map.on('moveend', () => this.scheduleUpdate());
+        this.unsubCollection = this.parentApi.onModelsCollectionChanged(() => this.scheduleUpdate());
+        this.unsubChanges = this.parentApi.onModelsChanged?.(() => this.scheduleUpdate());
+    }
+    scheduleUpdate() {
+        if (this.rafId !== null)
+            return;
+        this.rafId = requestAnimationFrame(() => {
+            this.rafId = null;
+            this.rebuild();
+        });
+    }
+    rebuild() {
+        this.syncVisibility();
+        this.syncOpacity();
+        if (!this.parentLayer.getVisible()) {
+            this.source.clear();
+            return;
+        }
+        const view = this.map.getView();
+        const resolution = view.getResolution() ?? 1;
+        const styleView = { resolution, zoom: view.getZoom() };
+        const interval = resolveMaybeFn(this.config.interval, [styleView]);
+        const offsetRatio = this.config.offsetRatio ?? 0.5;
+        const parentSource = this.parentLayer.getSource();
+        if (!parentSource) {
+            this.source.clear();
+            return;
+        }
+        const allArrows = [];
+        parentSource.getFeatures().forEach((feature) => {
+            const geom = feature.getGeometry();
+            if (!geom)
+                return;
+            const lines = extractLineCoords$1(geom);
+            for (const coords of lines) {
+                const arrows = generateArrowPoints(coords, interval, offsetRatio);
+                allArrows.push(...arrows);
+            }
+        });
+        const features = allArrows.map((arrow, i) => {
+            const f = new Feature({ geometry: new Point(arrow.coordinate) });
+            f.setId(`__arrow_${i}`);
+            const styleResult = this.config.style({ rotation: arrow.rotation, view: styleView });
+            f.setStyle(Array.isArray(styleResult) ? styleResult : [styleResult]);
+            return f;
+        });
+        this.source.clear();
+        if (features.length > 0) {
+            this.source.addFeatures(features);
+        }
+    }
+    syncVisibility() {
+        this.layer.setVisible(this.parentLayer.getVisible());
+    }
+    syncOpacity() {
+        this.layer.setOpacity(this.parentLayer.getOpacity());
+    }
+    dispose() {
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+        unByKey(this.moveEndKey);
+        this.unsubCollection();
+        this.unsubChanges?.();
+        this.map.removeLayer(this.layer);
+    }
+}
+
+/**
+ * Compute projected buffer distance for a segment by converting meters
+ * to EPSG:3857 units using the segment's average latitude.
+ */
+function projectedDistance(ax, ay, bx, by, meters) {
+    const midY = (ay + by) / 2;
+    const [, lat] = toLonLat([0, midY]);
+    const scale = Math.cos((lat * Math.PI) / 180);
+    return scale > 1e-10 ? meters / scale : meters;
+}
+/**
+ * Compute the unit normal of a segment (pointing left when walking from a→b).
+ */
+function segmentNormal(ax, ay, bx, by) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    const len = Math.hypot(dx, dy);
+    if (len === 0)
+        return [0, 0];
+    return [-dy / len, dx / len];
+}
+/**
+ * Generate a semicircle of points around a center, from startAngle to startAngle + PI.
+ */
+function semicircle(cx, cy, radius, startAngle, segments) {
+    const points = [];
+    for (let i = 0; i <= segments; i++) {
+        const angle = startAngle + (Math.PI * i) / segments;
+        points.push([cx + radius * Math.cos(angle), cy + radius * Math.sin(angle)]);
+    }
+    return points;
+}
+/**
+ * Generate a closed polygon ring representing a buffer around a polyline.
+ *
+ * @param coords Line vertices in EPSG:3857.
+ * @param distance Buffer width in meters (one side).
+ * @param cap End cap style: 'round' or 'flat'.
+ * @returns Closed ring (first == last point), or empty array if line is degenerate.
+ */
+function generateBufferPolygon(coords, distance, cap) {
+    if (coords.length < 2)
+        return [];
+    const n = coords.length;
+    const left = [];
+    const right = [];
+    // Compute per-vertex offset using averaged normals at joins
+    for (let i = 0; i < n; i++) {
+        let nx, ny, dist;
+        if (i === 0) {
+            // First vertex — use first segment's normal
+            dist = projectedDistance(coords[0][0], coords[0][1], coords[1][0], coords[1][1], distance);
+            [nx, ny] = segmentNormal(coords[0][0], coords[0][1], coords[1][0], coords[1][1]);
+        }
+        else if (i === n - 1) {
+            // Last vertex — use last segment's normal
+            dist = projectedDistance(coords[n - 2][0], coords[n - 2][1], coords[n - 1][0], coords[n - 1][1], distance);
+            [nx, ny] = segmentNormal(coords[n - 2][0], coords[n - 2][1], coords[n - 1][0], coords[n - 1][1]);
+        }
+        else {
+            // Interior vertex — average normals of adjacent segments
+            const dist1 = projectedDistance(coords[i - 1][0], coords[i - 1][1], coords[i][0], coords[i][1], distance);
+            const dist2 = projectedDistance(coords[i][0], coords[i][1], coords[i + 1][0], coords[i + 1][1], distance);
+            dist = (dist1 + dist2) / 2;
+            const [n1x, n1y] = segmentNormal(coords[i - 1][0], coords[i - 1][1], coords[i][0], coords[i][1]);
+            const [n2x, n2y] = segmentNormal(coords[i][0], coords[i][1], coords[i + 1][0], coords[i + 1][1]);
+            nx = n1x + n2x;
+            ny = n1y + n2y;
+            const len = Math.hypot(nx, ny);
+            if (len > 1e-10) {
+                nx /= len;
+                ny /= len;
+                // Miter length factor: 1 / cos(half-angle between segments)
+                const dot = n1x * nx + n1y * ny;
+                const miterScale = dot > 0.5 ? 1 / dot : 2; // Clamp miter at ratio 2 to prevent spikes
+                dist *= miterScale;
+            }
+            else {
+                [nx, ny] = segmentNormal(coords[i - 1][0], coords[i - 1][1], coords[i][0], coords[i][1]);
+            }
+        }
+        const x = coords[i][0];
+        const y = coords[i][1];
+        left.push([x + nx * dist, y + ny * dist]);
+        right.push([x - nx * dist, y - ny * dist]);
+    }
+    // Assemble the polygon ring: left forward → end cap → right backward → start cap → close
+    const ring = [];
+    // Left side (forward)
+    for (let i = 0; i < n; i++) {
+        ring.push(left[i]);
+    }
+    // End cap
+    if (cap === 'round') {
+        const [n2x, n2y] = segmentNormal(coords[n - 2][0], coords[n - 2][1], coords[n - 1][0], coords[n - 1][1]);
+        const endAngle = Math.atan2(-n2y, -n2x);
+        const dist = projectedDistance(coords[n - 2][0], coords[n - 2][1], coords[n - 1][0], coords[n - 1][1], distance);
+        ring.push(...semicircle(coords[n - 1][0], coords[n - 1][1], dist, endAngle, 8));
+    }
+    else {
+        ring.push(right[n - 1]);
+    }
+    // Right side (backward)
+    for (let i = n - 2; i >= 0; i--) {
+        ring.push(right[i]);
+    }
+    // Start cap
+    if (cap === 'round') {
+        const [n1x, n1y] = segmentNormal(coords[0][0], coords[0][1], coords[1][0], coords[1][1]);
+        const startAngle = Math.atan2(n1y, n1x);
+        const dist = projectedDistance(coords[0][0], coords[0][1], coords[1][0], coords[1][1], distance);
+        ring.push(...semicircle(coords[0][0], coords[0][1], dist, startAngle, 8));
+    }
+    // Close ring
+    ring.push(ring[0].slice());
+    return ring;
+}
+
+/**
+ * Extracts flat coordinate arrays from a feature's geometry.
+ * Supports LineString and MultiLineString; returns empty array for others.
+ */
+function extractLineCoords(geometry) {
+    if (geometry instanceof LineString) {
+        return [geometry.getCoordinates()];
+    }
+    if (geometry instanceof MultiLineString) {
+        return geometry.getCoordinates();
+    }
+    return [];
+}
+class BufferDecorationManager {
+    source = new VectorSource();
+    layer;
+    config;
+    map;
+    parentLayer;
+    parentApi;
+    moveEndKey;
+    unsubCollection;
+    unsubChanges;
+    rafId = null;
+    constructor(options) {
+        this.config = options.config;
+        this.map = options.map;
+        this.parentLayer = options.parentLayer;
+        this.parentApi = options.parentApi;
+        const parentZ = this.parentLayer.getZIndex() ?? 0;
+        this.layer = new VectorLayer({
+            source: this.source,
+            zIndex: parentZ,
+        });
+        this.layer.set('id', '__decoration_buffer');
+        this.map.addLayer(this.layer);
+        this.syncVisibility();
+        this.syncOpacity();
+        this.moveEndKey = this.map.on('moveend', () => this.scheduleUpdate());
+        this.unsubCollection = this.parentApi.onModelsCollectionChanged(() => this.scheduleUpdate());
+        this.unsubChanges = this.parentApi.onModelsChanged?.(() => this.scheduleUpdate());
+    }
+    scheduleUpdate() {
+        if (this.rafId !== null)
+            return;
+        this.rafId = requestAnimationFrame(() => {
+            this.rafId = null;
+            this.rebuild();
+        });
+    }
+    rebuild() {
+        this.syncVisibility();
+        this.syncOpacity();
+        if (!this.parentLayer.getVisible()) {
+            this.source.clear();
+            return;
+        }
+        const parentSource = this.parentLayer.getSource();
+        if (!parentSource) {
+            this.source.clear();
+            return;
+        }
+        const cap = this.config.cap ?? 'round';
+        const style = this.config.style;
+        const allFeatures = [];
+        parentSource.getFeatures().forEach((feature) => {
+            const geom = feature.getGeometry();
+            if (!geom)
+                return;
+            const lines = extractLineCoords(geom);
+            for (const coords of lines) {
+                const ring = generateBufferPolygon(coords, this.config.distance, cap);
+                if (ring.length === 0)
+                    continue;
+                const f = new Feature({ geometry: new Polygon([ring]) });
+                f.setStyle(Array.isArray(style) ? style : [style]);
+                allFeatures.push(f);
+            }
+        });
+        this.source.clear();
+        if (allFeatures.length > 0) {
+            this.source.addFeatures(allFeatures);
+        }
+    }
+    syncVisibility() {
+        this.layer.setVisible(this.parentLayer.getVisible());
+    }
+    syncOpacity() {
+        this.layer.setOpacity(this.parentLayer.getOpacity());
+    }
+    dispose() {
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+        unByKey(this.moveEndKey);
+        this.unsubCollection();
+        this.unsubChanges?.();
+        this.map.removeLayer(this.layer);
+    }
+}
+
 class LayerManager {
     map;
     layers = {};
@@ -2300,6 +2657,7 @@ class LayerManager {
     scheduler;
     popupHost;
     ctx;
+    decorationManagers = [];
     constructor(map, schema) {
         this.map = map;
         const popupHost = schema.options?.popupHost ? new PopupHost(schema.options.popupHost) : undefined;
@@ -2347,6 +2705,25 @@ class LayerManager {
             this.layers[descriptor.id] = layer;
             this.apis[descriptor.id] = api;
             this.map.addLayer(layer);
+            if (descriptor.feature.decorations?.buffer) {
+                const bufferManager = new BufferDecorationManager({
+                    map: this.map,
+                    parentLayer: layer,
+                    parentApi: api,
+                    config: descriptor.feature.decorations.buffer,
+                });
+                this.decorationManagers.push(bufferManager);
+                layer.setZIndex((descriptor.zIndex ?? 0) + 1);
+            }
+            if (descriptor.feature.decorations?.arrows) {
+                const decorationManager = new ArrowDecorationManager({
+                    map: this.map,
+                    parentLayer: layer,
+                    parentApi: api,
+                    config: descriptor.feature.decorations.arrows,
+                });
+                this.decorationManagers.push(decorationManager);
+            }
         });
         this.interactions = new InteractionManager({
             ctx,
@@ -2378,6 +2755,7 @@ class LayerManager {
         this.interactions.dispose();
         this.popupHost?.dispose();
         this.scheduler.dispose();
+        this.decorationManagers.forEach((dm) => dm.dispose());
         Object.values(this.layers).forEach((layer) => this.map.removeLayer(layer));
     }
 }