aur-openlayers 1.0.2 → 1.0.4

package/fesm2022/aur-openlayers.mjs

@@ -150,6 +150,15 @@ class FlushScheduler {
     shouldUpgradePolicy(current, next) {
         return current === 'microtask' && next === 'raf';
     }
+    dispose() {
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+        this.scheduledToken++;
+        this.queue.clear();
+        this.pendingPolicy = null;
+    }
 }
 
 const createMapContext = (map, layers, popupHost, scheduler = new FlushScheduler()) => {
@@ -312,22 +321,21 @@ class InteractionManager {
                             const active = {
                                 targetKey,
                                 startCoordinate: event.coordinate,
+                                startPixel: event.pixel,
                                 lastCoordinate: event.coordinate,
                                 lastItem: resolved,
                                 moveThrottleMs: translate.moveThrottleMs ?? 0,
+                                startThresholdPx: Math.max(0, translate.startThresholdPx ?? 1),
+                                started: false,
                                 translate,
                             };
                             this.activeTranslates.set(entry.descriptor.id, active);
                             this.lockDragPan();
-                            if (translate.state) {
-                                this.applyState([resolved], translate.state, true);
-                            }
-                            const handled = translate.onStart
-                                ? this.isHandled(translate.onStart({ item: resolved, ctx: this.ctx, event: translateEvent }))
-                                : false;
-                            active.lastHandled = handled;
-                            if (handled && this.shouldStopPropagation(translate)) {
-                                break;
+                            if (active.startThresholdPx <= 0) {
+                                this.startTranslate(entry, active, resolved, event);
+                                if (active.lastHandled && this.shouldStopPropagation(translate)) {
+                                    break;
+                                }
                             }
                         }
                     }
@@ -476,7 +484,7 @@ class InteractionManager {
                     this.applyTranslateMove(entry, active, pending);
                 }
                 const resolved = this.resolveTarget(entry, active.targetKey);
-                if (resolved && translate.onEnd) {
+                if (active.started && resolved && translate.onEnd) {
                     const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translateend', [resolved]);
                     active.lastHandled = this.isHandled(translate.onEnd({ item: resolved, ctx: this.ctx, event: translateEvent }));
                 }
@@ -1050,6 +1058,19 @@ class InteractionManager {
         }
         return { descriptor, layer, api, index };
     }
+    startTranslate(entry, active, resolved, event) {
+        if (active.started) {
+            return;
+        }
+        active.started = true;
+        if (active.translate.state) {
+            this.applyState([resolved], active.translate.state, true);
+        }
+        const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translatestart', [resolved]);
+        active.lastHandled = active.translate.onStart
+            ? this.isHandled(active.translate.onStart({ item: resolved, ctx: this.ctx, event: translateEvent }))
+            : false;
+    }
     applyTranslateMove(entry, active, event) {
         const translate = active.translate;
         const resolved = this.resolveTarget(entry, active.targetKey);
@@ -1062,6 +1083,17 @@ class InteractionManager {
             nextCoordinate[0] - active.lastCoordinate[0],
             nextCoordinate[1] - active.lastCoordinate[1],
         ];
+        if (!active.started) {
+            const currentPixel = event.pixel;
+            const offsetX = currentPixel[0] - active.startPixel[0];
+            const offsetY = currentPixel[1] - active.startPixel[1];
+            const distance = Math.hypot(offsetX, offsetY);
+            if (distance < active.startThresholdPx) {
+                active.lastHandled = false;
+                return;
+            }
+            this.startTranslate(entry, active, resolved, event);
+        }
         active.lastCoordinate = nextCoordinate;
         active.lastItem = resolved;
         const geometry = resolved.feature.getGeometry();
@@ -1075,7 +1107,7 @@ class InteractionManager {
             const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translating', [resolved]);
             active.lastHandled = this.isHandled(translate.onChange({ item: resolved, ctx: this.ctx, event: translateEvent }));
         }
-        else {
+        else if (!translate.onStart) {
             active.lastHandled = false;
         }
     }
@@ -1311,7 +1343,7 @@ class InteractionManager {
             if (aZ !== bZ) {
                 return bZ - aZ;
             }
-            return a.index - b.index;
+            return b.index - a.index;
         });
     }
     getHitTolerance(hitTolerance) {
@@ -1504,6 +1536,16 @@ class InteractionManager {
     shouldStopClusterPropagation() {
         return true;
     }
+    dispose() {
+        this.listenerKeys.forEach((key) => Observable.unByKey(key));
+        this.listenerKeys.clear();
+        Array.from(this.nativeModifies.keys()).forEach((id) => this.teardownNativeModify(id));
+        this.hoverItems.clear();
+        this.selectedItems.clear();
+        this.activeTranslates.clear();
+        this.activeModifies.clear();
+        this.enabledState.clear();
+    }
 }
 
 class StyleCache {
@@ -1995,7 +2037,7 @@ class ClusteredVectorLayer extends VectorLayerBase {
         this.layer.setSource(this.clusteringEnabled ? this.clusterSource : this.source);
     }
     setModels(models) {
-        this.setModelsInternal(models);
+        super.setModels(models);
         this.scheduleInvalidate();
     }
     setClusteringEnabled(enabled) {
@@ -2224,11 +2266,15 @@ class LayerManager {
     layers = {};
     apis = {};
     interactions;
+    scheduler;
+    popupHost;
     ctx;
     constructor(map, schema) {
         this.map = map;
         const popupHost = schema.options?.popupHost ? new PopupHost(schema.options.popupHost) : undefined;
         const scheduler = new FlushScheduler(schema.options?.scheduler?.policy ?? 'microtask');
+        this.scheduler = scheduler;
+        this.popupHost = popupHost;
         const ctx = createMapContext(this.map, this.apis, popupHost, scheduler);
         this.ctx = ctx;
         schema.layers.forEach((descriptor) => {
@@ -2297,6 +2343,12 @@ class LayerManager {
     refreshEnabled() {
         this.interactions.refreshEnabled();
     }
+    dispose() {
+        this.interactions.dispose();
+        this.popupHost?.dispose();
+        this.scheduler.dispose();
+        Object.values(this.layers).forEach((layer) => this.map.removeLayer(layer));
+    }
 }
 
 /*