@signaltree/core 6.2.2 → 6.2.3

package/dist/lib/entity-signal.js

@@ -101,11 +101,55 @@ class EntitySignalImpl {
     return id;
   }
   addMany(entities, opts) {
-    const ids = [];
+    const idsToAdd = [];
     for (const entity of entities) {
-      ids.push(this.addOne(entity, opts));
+      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+      if (this.storage.has(id)) {
+        throw new Error(`Entity with id ${String(id)} already exists`);
+      }
+      idsToAdd.push(id);
+    }
+    const addedEntities = [];
+    for (let i = 0; i < entities.length; i++) {
+      const entity = entities[i];
+      const id = idsToAdd[i];
+      let transformedEntity = entity;
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: value => {
+            transformedEntity = value;
+          },
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onAdd?.(entity, ctx);
+      }
+      this.storage.set(id, transformedEntity);
+      this.nodeCache.delete(id);
+      addedEntities.push({
+        id,
+        entity: transformedEntity
+      });
     }
-    return ids;
+    this.updateSignals();
+    for (const {
+      id,
+      entity
+    } of addedEntities) {
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
+    }
+    for (const {
+      id,
+      entity
+    } of addedEntities) {
+      for (const handler of this.tapHandlers) {
+        handler.onAdd?.(entity, id);
+      }
+    }
+    return idsToAdd;
   }
   updateOne(id, changes) {
     const entity = this.storage.get(id);
@@ -140,19 +184,70 @@ class EntitySignalImpl {
     }
   }
   updateMany(ids, changes) {
+    if (ids.length === 0) return;
+    const updatedEntities = [];
     for (const id of ids) {
-      this.updateOne(id, changes);
+      const entity = this.storage.get(id);
+      if (!entity) {
+        throw new Error(`Entity with id ${String(id)} not found`);
+      }
+      const prev = entity;
+      let transformedChanges = changes;
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: value => {
+            transformedChanges = value;
+          },
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onUpdate?.(id, changes, ctx);
+      }
+      const finalUpdated = {
+        ...entity,
+        ...transformedChanges
+      };
+      this.storage.set(id, finalUpdated);
+      this.nodeCache.delete(id);
+      updatedEntities.push({
+        id,
+        prev,
+        finalUpdated,
+        transformedChanges
+      });
+    }
+    this.updateSignals();
+    for (const {
+      id,
+      prev,
+      finalUpdated
+    } of updatedEntities) {
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
+    }
+    for (const {
+      id,
+      transformedChanges,
+      finalUpdated
+    } of updatedEntities) {
+      for (const handler of this.tapHandlers) {
+        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+      }
     }
   }
   updateWhere(predicate, changes) {
-    let count = 0;
+    const idsToUpdate = [];
     for (const [id, entity] of this.storage) {
       if (predicate(entity)) {
-        this.updateOne(id, changes);
-        count++;
+        idsToUpdate.push(id);
       }
     }
-    return count;
+    if (idsToUpdate.length > 0) {
+      this.updateMany(idsToUpdate, changes);
+    }
+    return idsToUpdate.length;
   }
   removeOne(id) {
     const entity = this.storage.get(id);
@@ -179,8 +274,49 @@ class EntitySignalImpl {
     }
   }
   removeMany(ids) {
+    if (ids.length === 0) return;
+    const entitiesToRemove = [];
     for (const id of ids) {
-      this.removeOne(id);
+      const entity = this.storage.get(id);
+      if (!entity) {
+        throw new Error(`Entity with id ${String(id)} not found`);
+      }
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: () => {},
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onRemove?.(id, entity, ctx);
+      }
+      entitiesToRemove.push({
+        id,
+        entity
+      });
+    }
+    for (const {
+      id
+    } of entitiesToRemove) {
+      this.storage.delete(id);
+      this.nodeCache.delete(id);
+    }
+    this.updateSignals();
+    for (const {
+      id,
+      entity
+    } of entitiesToRemove) {
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
+    }
+    for (const {
+      id,
+      entity
+    } of entitiesToRemove) {
+      for (const handler of this.tapHandlers) {
+        handler.onRemove?.(id, entity);
+      }
     }
   }
   removeWhere(predicate) {
@@ -190,12 +326,10 @@ class EntitySignalImpl {
         idsToRemove.push(id);
       }
     }
-    let count = 0;
-    for (const id of idsToRemove) {
-      this.removeOne(id);
-      count++;
+    if (idsToRemove.length > 0) {
+      this.removeMany(idsToRemove);
     }
-    return count;
+    return idsToRemove.length;
   }
   upsertOne(entity, opts) {
     const id = opts?.selectId?.(entity) ?? this.selectId(entity);
@@ -207,7 +341,115 @@ class EntitySignalImpl {
     return id;
   }
   upsertMany(entities, opts) {
-    return entities.map(e => this.upsertOne(e, opts));
+    if (entities.length === 0) return [];
+    const toAdd = [];
+    const toUpdate = [];
+    for (const entity of entities) {
+      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+      if (this.storage.has(id)) {
+        toUpdate.push({
+          entity,
+          id,
+          prev: this.storage.get(id)
+        });
+      } else {
+        toAdd.push({
+          entity,
+          id
+        });
+      }
+    }
+    const addedEntities = [];
+    for (const {
+      entity,
+      id
+    } of toAdd) {
+      let transformedEntity = entity;
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: value => {
+            transformedEntity = value;
+          },
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onAdd?.(entity, ctx);
+      }
+      this.storage.set(id, transformedEntity);
+      this.nodeCache.delete(id);
+      addedEntities.push({
+        id,
+        entity: transformedEntity
+      });
+    }
+    const updatedEntities = [];
+    for (const {
+      entity,
+      id,
+      prev
+    } of toUpdate) {
+      let transformedChanges = entity;
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: value => {
+            transformedChanges = value;
+          },
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onUpdate?.(id, entity, ctx);
+      }
+      const finalUpdated = {
+        ...prev,
+        ...transformedChanges
+      };
+      this.storage.set(id, finalUpdated);
+      this.nodeCache.delete(id);
+      updatedEntities.push({
+        id,
+        prev,
+        finalUpdated,
+        transformedChanges
+      });
+    }
+    this.updateSignals();
+    for (const {
+      id,
+      entity
+    } of addedEntities) {
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
+    }
+    for (const {
+      id,
+      prev,
+      finalUpdated
+    } of updatedEntities) {
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
+    }
+    for (const {
+      id,
+      entity
+    } of addedEntities) {
+      for (const handler of this.tapHandlers) {
+        handler.onAdd?.(entity, id);
+      }
+    }
+    for (const {
+      id,
+      transformedChanges,
+      finalUpdated
+    } of updatedEntities) {
+      for (const handler of this.tapHandlers) {
+        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+      }
+    }
+    return [...toAdd.map(a => a.id), ...toUpdate.map(u => u.id)];
   }
   clear() {
     this.storage.clear();
@@ -218,8 +460,41 @@ class EntitySignalImpl {
     this.clear();
   }
   setAll(entities, opts) {
-    this.clear();
-    this.addMany(entities, opts);
+    this.storage.clear();
+    this.nodeCache.clear();
+    const addedIds = [];
+    for (const entity of entities) {
+      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+      let transformedEntity = entity;
+      for (const handler of this.interceptHandlers) {
+        const ctx = {
+          block: reason => {
+            throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+          },
+          transform: value => {
+            transformedEntity = value;
+          },
+          blocked: false,
+          blockReason: undefined
+        };
+        handler.onAdd?.(entity, ctx);
+      }
+      this.storage.set(id, transformedEntity);
+      addedIds.push(id);
+    }
+    this.updateSignals();
+    for (let i = 0; i < addedIds.length; i++) {
+      const id = addedIds[i];
+      const entity = this.storage.get(id);
+      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
+    }
+    for (let i = 0; i < addedIds.length; i++) {
+      const id = addedIds[i];
+      const entity = this.storage.get(id);
+      for (const handler of this.tapHandlers) {
+        handler.onAdd?.(entity, id);
+      }
+    }
   }
   tap(handlers) {
     this.tapHandlers.push(handlers);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "6.2.2",
+  "version": "6.2.3",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,