aur-openlayers 0.0.2 → 1.0.0

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;
             }
@@ -728,7 +804,7 @@ class InteractionManager {
                     return;
                 }
                 const id = entry.descriptor.feature.id(item.model);
-                entry.api.mutate(id, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, geometry), 'modify');
+                entry.api.mutate(id, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, geometry), { reason: 'modify' });
             });
         });
         if (modify.onEnd) {
@@ -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) {
@@ -993,7 +1069,7 @@ class InteractionManager {
         }
         const translated = geometry.clone();
         translated.translate(delta[0], delta[1]);
-        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, translated), 'translate'));
+        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, translated), { reason: 'translate' }));
         if (translate.onChange) {
             const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translating', [resolved]);
             active.lastHandled = this.isHandled(translate.onChange({ item: resolved, ctx: this.ctx, event: translateEvent }));
@@ -1015,7 +1091,7 @@ class InteractionManager {
             return;
         }
         const nextGeometry = geometry.clone();
-        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, nextGeometry), 'modify'));
+        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, nextGeometry), { reason: 'modify' }));
         if (modify.onChange) {
             const modifyEvent = this.createModifyEvent(event, 'modifying', [resolved]);
             active.lastHandled = this.isHandled(modify.onChange({ item: resolved, ctx: this.ctx, event: modifyEvent }));
@@ -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);
@@ -1313,15 +1398,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 +1666,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();
@@ -1612,7 +1699,7 @@ class VectorLayerBase {
     getModelByFeature(feature) {
         return this.registry.getModelByFeature(feature);
     }
-    mutate(id, update, reason = 'mutate') {
+    mutate(id, update, opts) {
         const prev = this.registry.getModel(id);
         if (!prev) {
             return;
@@ -1621,13 +1708,18 @@ class VectorLayerBase {
         if (next === prev) {
             return;
         }
+        const reason = opts?.reason ?? 'mutate';
         this.registry.updateModel(id, next);
+        this.replaceModelSnapshot(id, next);
         this.syncFeatureFromModel(next);
         this.scheduleInvalidate();
-        this.emitModelChanges([{ prev, next, reason }]);
+        if (!opts?.silent) {
+            this.emitModelChanges([{ prev, next, reason }]);
+        }
     }
-    mutateMany(ids, update, reason = 'mutate') {
+    mutateMany(ids, update, opts) {
         const changes = [];
+        const reason = opts?.reason ?? 'mutate';
         ids.forEach((id) => {
             const prev = this.registry.getModel(id);
             if (!prev) {
@@ -1638,6 +1730,7 @@ class VectorLayerBase {
                 return;
             }
             this.registry.updateModel(id, next);
+            this.replaceModelSnapshot(id, next);
             this.syncFeatureFromModel(next);
             changes.push({ prev, next, reason });
         });
@@ -1645,12 +1738,74 @@ class VectorLayerBase {
             return;
         }
         this.scheduleInvalidate();
-        this.emitModelChanges(changes);
+        if (!opts?.silent) {
+            this.emitModelChanges(changes);
+        }
     }
     onModelsChanged(cb) {
         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();
@@ -1714,19 +1869,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];
@@ -1783,6 +1929,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 {
@@ -2114,5 +2297,5 @@ class LayerManager {
  * Generated bundle index. Do not edit.
  */
 
-export { LayerManager, LibComponent, LibService };
+export { DuplicateModelIdError, LayerManager, LibComponent, LibService };
 //# sourceMappingURL=aur-openlayers.mjs.map