@signaltree/core 7.1.3 → 7.1.4

package/dist/lib/entity-signal.js

@@ -1,544 +0,0 @@
-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

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

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

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

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

@@ -1,72 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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 };