aur-openlayers 19.6.5 → 19.6.9

package/fesm2022/aur-openlayers.mjs

@@ -10,7 +10,8 @@ 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 } from 'ol/geom';
+import { LineString, MultiLineString, Point, Polygon } from 'ol/geom';
+import { toLonLat } from 'ol/proj';
 
 class LibService {
     constructor() { }
@@ -2299,7 +2300,7 @@ const resolveMaybeFn = (value, args) => typeof value === 'function' ? value(...a
  * Extracts flat coordinate arrays from a feature's geometry.
  * Supports LineString and MultiLineString; returns empty array for others.
  */
-function extractLineCoords(geometry) {
+function extractLineCoords$1(geometry) {
     if (geometry instanceof LineString) {
         return [geometry.getCoordinates()];
     }
@@ -2341,6 +2342,7 @@ class ArrowDecorationManager {
     parentLayer;
     parentApi;
     moveEndKey;
+    visibilityKey;
     unsubCollection;
     unsubChanges;
     rafId = null;
@@ -2352,12 +2354,13 @@ class ArrowDecorationManager {
         const parentZ = this.parentLayer.getZIndex() ?? 0;
         this.layer = new VectorLayer({
             source: this.source,
-            zIndex: parentZ + 1,
+            zIndex: parentZ + 2,
         });
         this.layer.set('id', `__decoration_arrows`);
         this.map.addLayer(this.layer);
         this.syncVisibility();
         this.syncOpacity();
+        this.visibilityKey = this.parentLayer.on('change:visible', () => this.syncVisibility());
         this.moveEndKey = this.map.on('moveend', () => this.scheduleUpdate());
         this.unsubCollection = this.parentApi.onModelsCollectionChanged(() => this.scheduleUpdate());
         this.unsubChanges = this.parentApi.onModelsChanged?.(() => this.scheduleUpdate());
@@ -2392,7 +2395,7 @@ class ArrowDecorationManager {
             const geom = feature.getGeometry();
             if (!geom)
                 return;
-            const lines = extractLineCoords(geom);
+            const lines = extractLineCoords$1(geom);
             for (const coords of lines) {
                 const arrows = generateArrowPoints(coords, interval, offsetRatio);
                 allArrows.push(...arrows);
@@ -2422,6 +2425,230 @@ class ArrowDecorationManager {
             this.rafId = null;
         }
         unByKey(this.moveEndKey);
+        unByKey(this.visibilityKey);
+        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;
+    visibilityKey;
+    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.visibilityKey = this.parentLayer.on('change:visible', () => this.syncVisibility());
+        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);
+        unByKey(this.visibilityKey);
         this.unsubCollection();
         this.unsubChanges?.();
         this.map.removeLayer(this.layer);
@@ -2484,6 +2711,16 @@ 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,