aur-openlayers 19.6.4 → 19.6.5

package/fesm2022/aur-openlayers.mjs

@@ -9,6 +9,8 @@ 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 } from 'ol/geom';
 
 class LibService {
     constructor() { }
@@ -1585,7 +1587,7 @@ class StyleCache {
     }
 }
 
-const resolveMaybeFn = (value, args) => {
+const resolveMaybeFn$1 = (value, args) => {
     if (typeof value === 'function') {
         return value(...args);
     }
@@ -1620,7 +1622,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 +1630,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 +2294,140 @@ 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(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 + 1,
+        });
+        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(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);
+    }
+}
+
 class LayerManager {
     map;
     layers = {};
@@ -2300,6 +2436,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 +2484,15 @@ class LayerManager {
             this.layers[descriptor.id] = layer;
             this.apis[descriptor.id] = api;
             this.map.addLayer(layer);
+            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 +2524,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));
     }
 }