aur-openlayers 0.0.3 → 1.0.1

package/fesm2022/aur-openlayers.mjs

@@ -39,6 +39,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImpo
   ` }]
         }] });
 
+/**
+ * Ошибка, выбрасываемая при нарушении уникальности id моделей слоя.
+ *
+ * Возникает при попытке:
+ * - добавить модель с уже существующим id;
+ * - передать в setModels массив с дублирующимися id.
+ */
+class DuplicateModelIdError extends Error {
+    id;
+    layerId;
+    name = 'DuplicateModelIdError';
+    constructor(
+    /** Дублирующийся id. */
+    id, 
+    /** Идентификатор слоя. */
+    layerId, message) {
+        super(message ?? `Model with id "${String(id)}" already exists on layer (${layerId}).`);
+        this.id = id;
+        this.layerId = layerId;
+    }
+}
+
 class FlushScheduler {
     defaultPolicy;
     queue = new Map();
@@ -314,6 +336,54 @@ class InteractionManager {
             if (this.activeTranslates.has(entry.descriptor.id)) {
                 continue;
             }
+            const modify = interactions?.modify;
+            if (modify && this.isEnabled(modify.enabled)) {
+                const { items: candidates } = this.hitTest({
+                    layerId: entry.descriptor.id,
+                    layer: entry.layer,
+                    api: entry.api,
+                    descriptor: entry.descriptor,
+                    event,
+                    hitTolerance: this.getHitTolerance(modify.hitTolerance),
+                });
+                if (candidates.length > 0) {
+                    const modifyEvent = this.createModifyEvent(event, 'modifystart', candidates);
+                    let target;
+                    if (modify.pickTarget) {
+                        target = modify.pickTarget({ candidates, ctx: this.ctx, event: modifyEvent });
+                    }
+                    else {
+                        target = candidates[0];
+                    }
+                    if (target) {
+                        const targetKey = entry.descriptor.feature.id(target.model);
+                        const resolved = this.resolveTarget(entry, targetKey);
+                        if (resolved) {
+                            const active = {
+                                targetKey,
+                                lastItem: resolved,
+                                moveThrottleMs: modify.moveThrottleMs ?? 0,
+                                modify,
+                            };
+                            this.activeModifies.set(entry.descriptor.id, active);
+                            this.lockDragPan();
+                            if (modify.state) {
+                                this.applyState([resolved], modify.state, true);
+                            }
+                            const handled = modify.onStart
+                                ? this.isHandled(modify.onStart({ item: resolved, ctx: this.ctx, event: modifyEvent }))
+                                : false;
+                            active.lastHandled = handled;
+                            if (handled && this.shouldStopPropagation(modify)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (this.activeModifies.has(entry.descriptor.id)) {
+                continue;
+            }
         }
         this.updateCursor(event);
     }
@@ -624,21 +694,27 @@ class InteractionManager {
         let needsPointerUp = false;
         this.schema.layers.forEach((descriptor) => {
             const state = this.enabledState.get(descriptor.id);
-            if (state?.hover) {
+            const interactions = descriptor.feature.interactions;
+            const maybeHover = this.isMaybeEnabled(interactions?.hover?.enabled);
+            const maybeClick = this.isMaybeEnabled(interactions?.click?.enabled);
+            const maybeSelect = this.isMaybeEnabled(interactions?.select?.enabled);
+            const maybeDoubleClick = this.isMaybeEnabled(interactions?.doubleClick?.enabled);
+            const maybeTranslate = this.isMaybeEnabled(interactions?.translate?.enabled);
+            const maybeModify = this.isMaybeEnabled(interactions?.modify?.enabled);
+            if (state?.hover || maybeHover) {
                 needsPointerMove = true;
             }
-            if (state?.click || state?.select) {
+            if (state?.click || state?.select || maybeClick || maybeSelect) {
                 needsSingleClick = true;
             }
-            if (state?.doubleClick) {
+            if (state?.doubleClick || maybeDoubleClick) {
                 needsDoubleClick = true;
             }
-            if (state?.translate || state?.modify) {
+            if (state?.translate || state?.modify || maybeTranslate || maybeModify) {
                 needsPointerDown = true;
                 needsPointerDrag = true;
                 needsPointerUp = true;
             }
-            const interactions = descriptor.feature.interactions;
             if (interactions && this.hasCursorInteraction(interactions)) {
                 needsPointerMove = true;
             }
@@ -759,7 +835,7 @@ class InteractionManager {
             interactions.translate,
             interactions.modify,
         ];
-        return candidates.some((interaction) => interaction?.cursor && this.isEnabled(interaction.enabled));
+        return candidates.some((interaction) => interaction?.cursor && this.isMaybeEnabled(interaction.enabled));
     }
     toggleListener(type, enabled, handler) {
         if (enabled) {
@@ -1255,6 +1331,15 @@ class InteractionManager {
         }
         return enabled;
     }
+    isMaybeEnabled(enabled) {
+        if (enabled === undefined) {
+            return true;
+        }
+        if (typeof enabled === 'function') {
+            return true;
+        }
+        return enabled;
+    }
     processHover(entry, hover, items, event) {
         const prev = this.hoverItems.get(entry.descriptor.id) ?? new Map();
         const next = this.itemsToMap(entry, items);
@@ -1279,7 +1364,13 @@ class InteractionManager {
         return handled;
     }
     processSelect(entry, select, items, event) {
-        if (items.length === 0) {
+        const selectedItems = select.pickTargets
+            ? select.pickTargets({ candidates: items, ctx: this.ctx, event })
+            : items;
+        if (!selectedItems || selectedItems.length === 0) {
+            if (select.pickTargets) {
+                return false;
+            }
             const prev = this.selectedItems.get(entry.descriptor.id);
             this.selectedItems.set(entry.descriptor.id, new Map());
             if (select.onClear) {
@@ -1295,9 +1386,9 @@ class InteractionManager {
             return false;
         }
         const prev = this.selectedItems.get(entry.descriptor.id) ?? new Map();
-        const next = this.itemsToMap(entry, items);
+        const next = this.itemsToMap(entry, selectedItems);
         const handled = select.onSelect
-            ? this.isHandled(select.onSelect({ items, ctx: this.ctx, event }))
+            ? this.isHandled(select.onSelect({ items: selectedItems, ctx: this.ctx, event }))
             : false;
         if (select.state) {
             const added = Array.from(next.entries())
@@ -1313,15 +1404,9 @@ class InteractionManager {
         return handled;
     }
     processClick(entry, click, items, event) {
-        if (items.length === 0) {
-            return false;
-        }
         return this.isHandled(click.onClick({ items, ctx: this.ctx, event }));
     }
     processDoubleClick(entry, doubleClick, items, event) {
-        if (items.length === 0) {
-            return false;
-        }
         return this.isHandled(doubleClick.onDoubleClick({ items, ctx: this.ctx, event }));
     }
     itemsToMap(entry, items) {
@@ -1587,16 +1672,24 @@ class VectorLayerBase {
     registry = new FeatureRegistry();
     scheduleInvalidate;
     ctx;
+    layerId;
     changeHandlers = new Set();
+    collectionHandlers = new Set();
+    models = [];
     constructor(options) {
         this.descriptor = options.descriptor.feature;
         this.layer = options.layer;
         this.source = options.source;
         this.ctx = options.ctx;
         this.scheduleInvalidate = options.scheduleInvalidate;
+        this.layerId = options.descriptor.id;
     }
     setModels(models) {
-        this.setModelsInternal(models);
+        this.assertUniqueIds(models);
+        this.applyModelsUpdate({
+            nextModels: models,
+            reason: 'set',
+        });
     }
     invalidate() {
         this.scheduleInvalidate();
@@ -1623,6 +1716,7 @@ class VectorLayerBase {
         }
         const reason = opts?.reason ?? 'mutate';
         this.registry.updateModel(id, next);
+        this.replaceModelSnapshot(id, next);
         this.syncFeatureFromModel(next);
         this.scheduleInvalidate();
         if (!opts?.silent) {
@@ -1642,6 +1736,7 @@ class VectorLayerBase {
                 return;
             }
             this.registry.updateModel(id, next);
+            this.replaceModelSnapshot(id, next);
             this.syncFeatureFromModel(next);
             changes.push({ prev, next, reason });
         });
@@ -1657,6 +1752,66 @@ class VectorLayerBase {
         this.changeHandlers.add(cb);
         return () => this.changeHandlers.delete(cb);
     }
+    onModelsCollectionChanged(cb) {
+        this.collectionHandlers.add(cb);
+        return () => this.collectionHandlers.delete(cb);
+    }
+    addModel(model) {
+        this.addModels([model]);
+    }
+    addModels(models) {
+        if (models.length === 0) {
+            return;
+        }
+        const existingIds = new Set(this.models.map((item) => this.descriptor.id(item)));
+        const batchIds = new Set();
+        for (const model of models) {
+            const id = this.descriptor.id(model);
+            if (existingIds.has(id) || batchIds.has(id)) {
+                this.throwDuplicateId(id);
+            }
+            batchIds.add(id);
+        }
+        this.applyModelsUpdate({
+            nextModels: [...this.models, ...models],
+            reason: 'add',
+            added: models,
+        });
+    }
+    removeModelsById(ids) {
+        if (ids.length === 0 || this.models.length === 0) {
+            return 0;
+        }
+        const idSet = new Set(ids);
+        const removed = [];
+        const nextModels = this.models.filter((model) => {
+            const id = this.descriptor.id(model);
+            if (idSet.has(id)) {
+                removed.push(model);
+                return false;
+            }
+            return true;
+        });
+        if (removed.length === 0) {
+            return 0;
+        }
+        this.applyModelsUpdate({
+            nextModels,
+            reason: 'remove',
+            removed,
+        });
+        return removed.length;
+    }
+    clear() {
+        if (this.models.length === 0) {
+            return;
+        }
+        this.applyModelsUpdate({
+            nextModels: [],
+            reason: 'clear',
+            removed: [...this.models],
+        });
+    }
     /** Fit view to all features on the layer. No-op if extent is empty. */
     centerOnAllModels(opts) {
         const current = this.getCenterOnAllModelsSource();
@@ -1720,19 +1875,10 @@ class VectorLayerBase {
         return this.registry.getFeature(id) != null;
     }
     getAllModels() {
-        const out = [];
-        this.registry.forEachId((id) => {
-            const model = this.registry.getModel(id);
-            if (model !== undefined) {
-                out.push(model);
-            }
-        });
-        return out;
+        return [...this.models];
     }
     getAllModelIds() {
-        const out = [];
-        this.registry.forEachId((id) => out.push(id));
-        return out;
+        return this.models.map((model) => this.descriptor.id(model));
     }
     setFeatureStates(ids, states) {
         const targetIds = Array.isArray(ids) ? ids : [ids];
@@ -1745,6 +1891,9 @@ class VectorLayerBase {
         });
         this.scheduleInvalidate();
     }
+    clearFeatureStates(ids) {
+        this.setFeatureStates(ids, []);
+    }
     setModelsInternal(models) {
         const nextIds = new Set();
         models.forEach((model) => {
@@ -1789,6 +1938,43 @@ class VectorLayerBase {
         }
         this.changeHandlers.forEach((handler) => handler(changes));
     }
+    emitCollectionChange(event) {
+        this.collectionHandlers.forEach((handler) => handler(event));
+    }
+    assertUniqueIds(models) {
+        const ids = new Set();
+        for (const model of models) {
+            const id = this.descriptor.id(model);
+            if (ids.has(id)) {
+                this.throwDuplicateId(id);
+            }
+            ids.add(id);
+        }
+    }
+    throwDuplicateId(id) {
+        throw new DuplicateModelIdError(id, this.layerId);
+    }
+    applyModelsUpdate(args) {
+        const prevSnapshot = [...this.models];
+        const internalNext = [...args.nextModels];
+        this.models = internalNext;
+        this.setModelsInternal(this.models);
+        const nextSnapshot = [...internalNext];
+        this.emitCollectionChange({
+            prev: prevSnapshot,
+            next: nextSnapshot,
+            reason: args.reason,
+            added: args.added ? [...args.added] : undefined,
+            removed: args.removed ? [...args.removed] : undefined,
+        });
+    }
+    replaceModelSnapshot(id, model) {
+        const index = this.models.findIndex((item) => this.descriptor.id(item) === id);
+        if (index === -1) {
+            return;
+        }
+        this.models[index] = model;
+    }
 }
 
 class ClusteredVectorLayer extends VectorLayerBase {
@@ -2120,5 +2306,5 @@ class LayerManager {
  * Generated bundle index. Do not edit.
  */
 
-export { LayerManager, LibComponent, LibService };
+export { DuplicateModelIdError, LayerManager, LibComponent, LibService };
 //# sourceMappingURL=aur-openlayers.mjs.map