@signaltree/core 7.1.5 → 7.1.6

package/dist/lib/entity-signal.js

@@ -0,0 +1,544 @@
+import { signal, computed } from '@angular/core';
+
+function createEntitySignal(config, pathNotifier, basePath) {
+  const storage = new Map();
+  const allSignal = signal([]);
+  const countSignal = signal(0);
+  const idsSignal = signal([]);
+  const mapSignal = signal(new Map());
+  const nodeCache = new Map();
+  const selectId = config.selectId ?? (entity => entity['id']);
+  const tapHandlers = [];
+  const interceptHandlers = [];
+  function updateSignals() {
+    const entities = Array.from(storage.values());
+    const ids = Array.from(storage.keys());
+    const map = new Map(storage);
+    allSignal.set(entities);
+    countSignal.set(entities.length);
+    idsSignal.set(ids);
+    mapSignal.set(map);
+  }
+  function createEntityNode(id, entity) {
+    const node = () => storage.get(id);
+    for (const key of Object.keys(entity)) {
+      Object.defineProperty(node, key, {
+        get: () => {
+          const current = storage.get(id);
+          const value = current?.[key];
+          return () => value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return node;
+  }
+  function getOrCreateNode(id, entity) {
+    let node = nodeCache.get(id);
+    if (!node) {
+      node = createEntityNode(id, entity);
+      nodeCache.set(id, node);
+    }
+    return node;
+  }
+  const whereCache = new WeakMap();
+  const findCache = new WeakMap();
+  const api = {
+    byId(id) {
+      const entity = storage.get(id);
+      if (!entity) return undefined;
+      return getOrCreateNode(id, entity);
+    },
+    byIdOrFail(id) {
+      const node = api.byId(id);
+      if (!node) {
+        throw new Error(`Entity with id ${String(id)} not found`);
+      }
+      return node;
+    },
+    get all() {
+      return allSignal;
+    },
+    get count() {
+      return countSignal;
+    },
+    get ids() {
+      return idsSignal;
+    },
+    get map() {
+      return mapSignal;
+    },
+    has(id) {
+      return computed(() => mapSignal().has(id));
+    },
+    get isEmpty() {
+      return computed(() => countSignal() === 0);
+    },
+    where(predicate) {
+      const cached = whereCache.get(predicate);
+      if (cached) return cached;
+      const s = computed(() => allSignal().filter(predicate));
+      whereCache.set(predicate, s);
+      return s;
+    },
+    find(predicate) {
+      const cached = findCache.get(predicate);
+      if (cached) return cached;
+      const s = computed(() => allSignal().find(predicate));
+      findCache.set(predicate, s);
+      return s;
+    },
+    addOne(entity, opts) {
+      const id = opts?.selectId?.(entity) ?? selectId(entity);
+      if (storage.has(id)) {
+        throw new Error(`Entity with id ${String(id)} already exists`);
+      }
+      let transformedEntity = entity;
+      for (const handler of 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);
+      }
+      storage.set(id, transformedEntity);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, transformedEntity, undefined);
+      for (const handler of tapHandlers) {
+        handler.onAdd?.(transformedEntity, id);
+      }
+      return id;
+    },
+    addMany(entities, opts) {
+      const idsToAdd = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        if (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 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);
+        }
+        storage.set(id, transformedEntity);
+        nodeCache.delete(id);
+        addedEntities.push({
+          id,
+          entity: transformedEntity
+        });
+      }
+      updateSignals();
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
+      }
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onAdd?.(entity, id);
+        }
+      }
+      return idsToAdd;
+    },
+    updateOne(id, changes) {
+      const entity = 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 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
+      };
+      storage.set(id, finalUpdated);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
+      for (const handler of tapHandlers) {
+        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+      }
+    },
+    updateMany(ids, changes) {
+      if (ids.length === 0) return;
+      const updatedEntities = [];
+      for (const id of ids) {
+        const entity = 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 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
+        };
+        storage.set(id, finalUpdated);
+        nodeCache.delete(id);
+        updatedEntities.push({
+          id,
+          prev,
+          finalUpdated,
+          transformedChanges
+        });
+      }
+      updateSignals();
+      for (const {
+        id,
+        prev,
+        finalUpdated
+      } of updatedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
+      }
+      for (const {
+        id,
+        transformedChanges,
+        finalUpdated
+      } of updatedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onUpdate?.(id, transformedChanges, finalUpdated);
+        }
+      }
+    },
+    updateWhere(predicate, changes) {
+      const idsToUpdate = [];
+      for (const [id, entity] of storage) {
+        if (predicate(entity)) {
+          idsToUpdate.push(id);
+        }
+      }
+      if (idsToUpdate.length > 0) {
+        api.updateMany(idsToUpdate, changes);
+      }
+      return idsToUpdate.length;
+    },
+    removeOne(id) {
+      const entity = storage.get(id);
+      if (!entity) {
+        throw new Error(`Entity with id ${String(id)} not found`);
+      }
+      for (const handler of 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);
+      }
+      storage.delete(id);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, undefined, entity);
+      for (const handler of tapHandlers) {
+        handler.onRemove?.(id, entity);
+      }
+    },
+    removeMany(ids) {
+      if (ids.length === 0) return;
+      const entitiesToRemove = [];
+      for (const id of ids) {
+        const entity = storage.get(id);
+        if (!entity) {
+          throw new Error(`Entity with id ${String(id)} not found`);
+        }
+        for (const handler of 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) {
+        storage.delete(id);
+        nodeCache.delete(id);
+      }
+      updateSignals();
+      for (const {
+        id,
+        entity
+      } of entitiesToRemove) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, undefined, entity);
+      }
+      for (const {
+        id,
+        entity
+      } of entitiesToRemove) {
+        for (const handler of tapHandlers) {
+          handler.onRemove?.(id, entity);
+        }
+      }
+    },
+    removeWhere(predicate) {
+      const idsToRemove = [];
+      for (const [id, entity] of storage) {
+        if (predicate(entity)) {
+          idsToRemove.push(id);
+        }
+      }
+      if (idsToRemove.length > 0) {
+        api.removeMany(idsToRemove);
+      }
+      return idsToRemove.length;
+    },
+    upsertOne(entity, opts) {
+      const id = opts?.selectId?.(entity) ?? selectId(entity);
+      if (storage.has(id)) {
+        api.updateOne(id, entity);
+      } else {
+        api.addOne(entity, opts);
+      }
+      return id;
+    },
+    upsertMany(entities, opts) {
+      if (entities.length === 0) return [];
+      const toAdd = [];
+      const toUpdate = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        const existing = storage.get(id);
+        if (existing !== undefined) {
+          toUpdate.push({
+            entity,
+            id,
+            prev: existing
+          });
+        } else {
+          toAdd.push({
+            entity,
+            id
+          });
+        }
+      }
+      const addedEntities = [];
+      for (const {
+        entity,
+        id
+      } of toAdd) {
+        let transformedEntity = entity;
+        for (const handler of 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);
+        }
+        storage.set(id, transformedEntity);
+        nodeCache.delete(id);
+        addedEntities.push({
+          id,
+          entity: transformedEntity
+        });
+      }
+      const updatedEntities = [];
+      for (const {
+        entity,
+        id,
+        prev
+      } of toUpdate) {
+        let transformedChanges = entity;
+        for (const handler of 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
+        };
+        storage.set(id, finalUpdated);
+        nodeCache.delete(id);
+        updatedEntities.push({
+          id,
+          prev,
+          finalUpdated,
+          transformedChanges
+        });
+      }
+      updateSignals();
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
+      }
+      for (const {
+        id,
+        prev,
+        finalUpdated
+      } of updatedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
+      }
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onAdd?.(entity, id);
+        }
+      }
+      for (const {
+        id,
+        transformedChanges,
+        finalUpdated
+      } of updatedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onUpdate?.(id, transformedChanges, finalUpdated);
+        }
+      }
+      return [...toAdd.map(a => a.id), ...toUpdate.map(u => u.id)];
+    },
+    clear() {
+      storage.clear();
+      nodeCache.clear();
+      updateSignals();
+    },
+    removeAll() {
+      api.clear();
+    },
+    setAll(entities, opts) {
+      storage.clear();
+      nodeCache.clear();
+      const addedIds = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        let transformedEntity = entity;
+        for (const handler of 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);
+        }
+        storage.set(id, transformedEntity);
+        addedIds.push(id);
+      }
+      updateSignals();
+      for (let i = 0; i < addedIds.length; i++) {
+        const id = addedIds[i];
+        const entity = storage.get(id);
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
+      }
+      for (let i = 0; i < addedIds.length; i++) {
+        const id = addedIds[i];
+        const entity = storage.get(id);
+        if (entity) {
+          for (const handler of tapHandlers) {
+            handler.onAdd?.(entity, id);
+          }
+        }
+      }
+    },
+    tap(handlers) {
+      tapHandlers.push(handlers);
+      return () => {
+        const idx = tapHandlers.indexOf(handlers);
+        if (idx > -1) tapHandlers.splice(idx, 1);
+      };
+    },
+    intercept(handlers) {
+      interceptHandlers.push(handlers);
+      return () => {
+        const idx = interceptHandlers.indexOf(handlers);
+        if (idx > -1) interceptHandlers.splice(idx, 1);
+      };
+    }
+  };
+  return new Proxy(api, {
+    get: (target, prop) => {
+      if (typeof prop === 'string' && !isNaN(Number(prop))) {
+        return api.byId(Number(prop));
+      }
+      return target[prop];
+    }
+  });
+}
+
+export { createEntitySignal };

package/dist/lib/internals/batch-scope.js

@@ -0,0 +1,8 @@
+function batchScope(fn) {
+  try {
+    fn();
+  } finally {
+  }
+}
+
+export { batchScope };

package/dist/lib/internals/derived-types.js

@@ -0,0 +1,6 @@
+function derivedFrom() {
+  return fn => fn;
+}
+const externalDerived = derivedFrom;
+
+export { derivedFrom, externalDerived };

package/dist/lib/internals/materialize-markers.js

@@ -0,0 +1,72 @@
+import { isSignal } from '@angular/core';
+import { getPathNotifier } from '../path-notifier.js';
+import { isNodeAccessor } from '../utils.js';
+
+const MARKER_PROCESSORS = [];
+function isRegisteredMarker(value) {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+  if (Object.getOwnPropertySymbols(value).length === 0) {
+    return false;
+  }
+  for (const processor of MARKER_PROCESSORS) {
+    if (processor.check(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function registerMarkerProcessor(check, create) {
+  const alreadyRegistered = MARKER_PROCESSORS.some(p => p.check === check);
+  if (alreadyRegistered) {
+    return;
+  }
+  MARKER_PROCESSORS.push({
+    check,
+    create: create
+  });
+}
+function materializeMarkers(node, notifier, path = []) {
+  if (node == null) return;
+  if (typeof node !== 'object' && typeof node !== 'function') return;
+  if (isSignal(node)) return;
+  const isAccessor = typeof node === 'function' && isNodeAccessor(node);
+  if (typeof node === 'function' && !isAccessor) return;
+  const getNotifier = () => {
+    if (!notifier) {
+      notifier = getPathNotifier();
+    }
+    return notifier;
+  };
+  const keys = Object.keys(node);
+  for (const key of keys) {
+    const value = node[key];
+    const currentPath = [...path, key];
+    const pathString = currentPath.join('.');
+    let processed = false;
+    for (const processor of MARKER_PROCESSORS) {
+      if (processor.check(value)) {
+        try {
+          const materialized = processor.create(value, getNotifier(), pathString);
+          node[key] = materialized;
+          processed = true;
+        } catch (err) {
+          if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            console.error(`SignalTree: Failed to materialize marker at "${pathString}"`, err);
+          }
+        }
+        break;
+      }
+    }
+    if (!processed && value != null) {
+      if (isNodeAccessor(value)) {
+        materializeMarkers(value, notifier, currentPath);
+      } else if (typeof value === 'object' && !Array.isArray(value) && !isSignal(value)) {
+        materializeMarkers(value, notifier, currentPath);
+      }
+    }
+  }
+}
+
+export { isRegisteredMarker, materializeMarkers, registerMarkerProcessor };

package/dist/lib/internals/merge-derived.js

@@ -0,0 +1,59 @@
+import { computed, isSignal } from '@angular/core';
+import { isDerivedMarker } from '../markers/derived.js';
+
+function isSignalLike(value) {
+  return isSignal(value);
+}
+function ensurePathAndGetTarget($, path) {
+  if (!path) return $;
+  const parts = path.split('.');
+  let current = $;
+  for (const part of parts) {
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  return current;
+}
+function mergeDerivedState($, derivedDef, path = '') {
+  if (!derivedDef || typeof derivedDef !== 'object') {
+    return;
+  }
+  for (const [key, value] of Object.entries(derivedDef)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (isDerivedMarker(value)) {
+      const target = ensurePathAndGetTarget($, path);
+      if (key in target && isSignalLike(target[key])) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+          console.warn(`SignalTree: Derived "${currentPath}" overwrites source signal. ` + `Consider using a different key to avoid confusion.`);
+        }
+      }
+      target[key] = computed(value.factory);
+    } else if (isSignalLike(value)) {
+      const target = ensurePathAndGetTarget($, path);
+      if (key in target && isSignalLike(target[key])) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+          console.warn(`SignalTree: Derived signal "${currentPath}" overwrites source signal. ` + `Consider using a different key to avoid confusion.`);
+        }
+      }
+      target[key] = value;
+    } else if (typeof value === 'object' && value !== null) {
+      const target = ensurePathAndGetTarget($, path);
+      if (!(key in target)) {
+        target[key] = {};
+      } else if (isSignalLike(target[key])) {
+        throw new Error(`SignalTree: Cannot merge derived object into "${currentPath}" ` + `because source is a signal. Either make source an object or use a different key.`);
+      }
+      mergeDerivedState($, value, currentPath);
+    }
+  }
+}
+function applyDerivedFactories($, factories) {
+  for (const factory of factories) {
+    const derivedDef = factory($);
+    mergeDerivedState($, derivedDef);
+  }
+}
+
+export { applyDerivedFactories, mergeDerivedState };

package/dist/lib/markers/derived.js

@@ -0,0 +1,6 @@
+const DERIVED_MARKER = Symbol.for('signaltree:derived');
+function isDerivedMarker(value) {
+  return value !== null && typeof value === 'object' && DERIVED_MARKER in value && value[DERIVED_MARKER] === true;
+}
+
+export { isDerivedMarker };