@signaltree/core 5.1.1 → 5.1.3

package/dist/enhancers/time-travel/lib/time-travel.js

@@ -0,0 +1,193 @@
+import { deepClone } from '../../../deep-clone.js';
+import { deepEqual } from '../../../deep-equal.js';
+
+class TimeTravelManager {
+  tree;
+  config;
+  restoreStateFn;
+  history = [];
+  currentIndex = -1;
+  maxHistorySize;
+  includePayload;
+  actionNames;
+  constructor(tree, config = {}, restoreStateFn) {
+    this.tree = tree;
+    this.config = config;
+    this.restoreStateFn = restoreStateFn;
+    this.maxHistorySize = config.maxHistorySize ?? 50;
+    this.includePayload = config.includePayload ?? true;
+    this.actionNames = {
+      update: 'UPDATE',
+      set: 'SET',
+      batch: 'BATCH',
+      ...config.actionNames
+    };
+    this.addEntry('INIT', this.tree());
+  }
+  addEntry(action, state, payload) {
+    if (this.currentIndex < this.history.length - 1) {
+      this.history = this.history.slice(0, this.currentIndex + 1);
+    }
+    const entry = {
+      state: deepClone(state),
+      timestamp: Date.now(),
+      action: this.actionNames[action] || action,
+      ...(this.includePayload && payload !== undefined && {
+        payload
+      })
+    };
+    this.history.push(entry);
+    this.currentIndex = this.history.length - 1;
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+      this.currentIndex--;
+    }
+  }
+  undo() {
+    if (!this.canUndo()) {
+      return false;
+    }
+    this.currentIndex--;
+    const entry = this.history[this.currentIndex];
+    this.restoreState(entry.state);
+    return true;
+  }
+  redo() {
+    if (!this.canRedo()) {
+      return false;
+    }
+    this.currentIndex++;
+    const entry = this.history[this.currentIndex];
+    this.restoreState(entry.state);
+    return true;
+  }
+  getHistory() {
+    return this.history.map(entry => ({
+      ...entry,
+      state: deepClone(entry.state)
+    }));
+  }
+  resetHistory() {
+    const currentState = this.tree();
+    this.history = [];
+    this.currentIndex = -1;
+    this.addEntry('RESET', currentState);
+  }
+  jumpTo(index) {
+    if (index < 0 || index >= this.history.length) {
+      return false;
+    }
+    this.currentIndex = index;
+    const entry = this.history[index];
+    this.restoreState(entry.state);
+    return true;
+  }
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  canUndo() {
+    return this.currentIndex > 0;
+  }
+  canRedo() {
+    return this.currentIndex < this.history.length - 1;
+  }
+  restoreState(state) {
+    if (this.restoreStateFn) {
+      this.restoreStateFn(state);
+    } else {
+      this.tree(state);
+    }
+  }
+}
+function withTimeTravel(config = {}) {
+  return tree => {
+    const originalTreeCall = tree.bind(tree);
+    let isRestoring = false;
+    const timeTravelManager = new TimeTravelManager(tree, config, state => {
+      isRestoring = true;
+      try {
+        originalTreeCall(state);
+      } finally {
+        isRestoring = false;
+      }
+    });
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        if (isRestoring) {
+          if (args.length === 1) {
+            const arg = args[0];
+            if (typeof arg === 'function') {
+              return originalTreeCall(arg);
+            } else {
+              return originalTreeCall(arg);
+            }
+          }
+          return;
+        }
+        const beforeState = originalTreeCall();
+        let result;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            result = originalTreeCall(arg);
+          } else {
+            result = originalTreeCall(arg);
+          }
+        }
+        const afterState = originalTreeCall();
+        const statesEqual = deepEqual(beforeState, afterState);
+        if (!statesEqual) {
+          timeTravelManager.addEntry('update', afterState);
+        }
+        return result;
+      }
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    Object.assign(enhancedTree, tree);
+    if ('state' in tree) {
+      Object.defineProperty(enhancedTree, 'state', {
+        value: tree.state,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if ('$' in tree) {
+      Object.defineProperty(enhancedTree, '$', {
+        value: tree['$'],
+        enumerable: false,
+        configurable: true
+      });
+    }
+    enhancedTree.undo = () => {
+      timeTravelManager.undo();
+    };
+    enhancedTree.redo = () => {
+      timeTravelManager.redo();
+    };
+    enhancedTree.getHistory = () => timeTravelManager.getHistory();
+    enhancedTree.resetHistory = () => {
+      timeTravelManager.resetHistory();
+    };
+    enhancedTree.jumpTo = index => {
+      timeTravelManager.jumpTo(index);
+    };
+    enhancedTree.canUndo = () => timeTravelManager.canUndo();
+    enhancedTree.canRedo = () => timeTravelManager.canRedo();
+    enhancedTree.getCurrentIndex = () => timeTravelManager.getCurrentIndex();
+    return Object.assign(enhancedTree, {
+      __timeTravel: timeTravelManager
+    });
+  };
+}
+function enableTimeTravel(maxHistorySize) {
+  return withTimeTravel({
+    maxHistorySize
+  });
+}
+function getTimeTravel(tree) {
+  return tree.__timeTravel;
+}
+
+export { enableTimeTravel, getTimeTravel, withTimeTravel };

package/dist/index.js

@@ -0,0 +1,19 @@
+export { signalTree } from './lib/signal-tree.js';
+export { ENHANCER_META, entityMap } from './lib/types.js';
+export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
+export { getPathNotifier } from './lib/path-notifier.js';
+export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
+export { flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, withBatching, withHighPerformanceBatching } from './enhancers/batching/lib/batching.js';
+export { cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization } from './enhancers/memoization/lib/memoization.js';
+export { enableTimeTravel, getTimeTravel, withTimeTravel } from './enhancers/time-travel/lib/time-travel.js';
+export { enableEntities, withEntities, withHighPerformanceEntities } from './enhancers/entities/lib/entities.js';
+export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, withPersistence, withSerialization } from './enhancers/serialization/lib/serialization.js';
+export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools } from './enhancers/devtools/lib/devtools.js';
+export { createAsyncOperation, trackAsync } from './lib/async-helpers.js';
+export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
+export { computedEnhancer, createComputed } from './enhancers/computed/lib/computed.js';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants.js';
+export { deepEqual, deepEqual as equal } from './deep-equal.js';
+export { parsePath } from './parse-path.js';
+export { isBuiltInObject } from './is-built-in-object.js';

package/dist/is-built-in-object.js

@@ -0,0 +1,23 @@
+function isBuiltInObject(value) {
+  if (value === null || value === undefined) return false;
+  if (value instanceof Date || value instanceof RegExp || typeof value === 'function' || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet || value instanceof ArrayBuffer || value instanceof DataView || value instanceof Error || value instanceof Promise) {
+    return true;
+  }
+  if (value instanceof Int8Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int16Array || value instanceof Uint16Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof BigInt64Array || value instanceof BigUint64Array) {
+    return true;
+  }
+  if (typeof window !== 'undefined') {
+    if (value instanceof URL || value instanceof URLSearchParams || value instanceof FormData || value instanceof Blob || typeof File !== 'undefined' && value instanceof File || typeof FileList !== 'undefined' && value instanceof FileList || typeof Headers !== 'undefined' && value instanceof Headers || typeof Request !== 'undefined' && value instanceof Request || typeof Response !== 'undefined' && value instanceof Response || typeof AbortController !== 'undefined' && value instanceof AbortController || typeof AbortSignal !== 'undefined' && value instanceof AbortSignal) {
+      return true;
+    }
+  }
+  try {
+    const NodeBuffer = globalThis === null || globalThis === void 0 ? void 0 : globalThis.Buffer;
+    if (NodeBuffer && value instanceof NodeBuffer) {
+      return true;
+    }
+  } catch (_a) {}
+  return false;
+}
+
+export { isBuiltInObject };

package/dist/lib/async-helpers.js

@@ -0,0 +1,77 @@
+import { signal } from '@angular/core';
+
+function createAsyncOperation(name, operation) {
+  return async tree => {
+    if (typeof tree.batchUpdate === 'function') {
+      const pendingPatch = {
+        [`${name}_PENDING`]: true
+      };
+      tree.batchUpdate(() => pendingPatch);
+    } else if ('$' in tree) {
+      try {
+        tree['$'][`${name}_PENDING`]?.set?.(true);
+      } catch (e) {
+      }
+    }
+    try {
+      const result = await operation();
+      if (typeof tree.batchUpdate === 'function') {
+        const resultPatch = {
+          [`${name}_RESULT`]: result,
+          [`${name}_PENDING`]: false
+        };
+        tree.batchUpdate(() => resultPatch);
+      } else if ('$' in tree) {
+        try {
+          tree['$'][`${name}_RESULT`]?.set?.(result);
+          tree['$'][`${name}_PENDING`]?.set?.(false);
+        } catch (e) {
+          void e;
+        }
+      }
+      return result;
+    } catch (error) {
+      if (typeof tree.batchUpdate === 'function') {
+        const errorPatch = {
+          [`${name}_ERROR`]: error,
+          [`${name}_PENDING`]: false
+        };
+        tree.batchUpdate(() => errorPatch);
+      } else if ('$' in tree) {
+        try {
+          tree['$'][`${name}_ERROR`]?.set?.(error);
+          tree['$'][`${name}_PENDING`]?.set?.(false);
+        } catch (e) {
+        }
+      }
+      throw error;
+    }
+  };
+}
+function trackAsync(operation) {
+  const pending = signal(false);
+  const error = signal(null);
+  const result = signal(null);
+  return {
+    pending: pending.asReadonly(),
+    error: error.asReadonly(),
+    result: result.asReadonly(),
+    execute: async () => {
+      pending.set(true);
+      error.set(null);
+      try {
+        const res = await operation();
+        result.set(res);
+        return res;
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        error.set(err);
+        throw err;
+      } finally {
+        pending.set(false);
+      }
+    }
+  };
+}
+
+export { createAsyncOperation, trackAsync };

package/dist/lib/constants.js

@@ -0,0 +1,56 @@
+import { DEFAULT_PATH_CACHE_SIZE } from '../constants.js';
+
+const SIGNAL_TREE_CONSTANTS = {
+  MAX_PATH_CACHE_SIZE: DEFAULT_PATH_CACHE_SIZE,
+  LAZY_THRESHOLD: 50,
+  ESTIMATE_MAX_DEPTH: 3,
+  ESTIMATE_SAMPLE_SIZE_ARRAY: 3,
+  ESTIMATE_SAMPLE_SIZE_OBJECT: 5,
+  DEFAULT_CACHE_SIZE: 100,
+  DEFAULT_BATCH_SIZE: 10
+};
+const DEV_MESSAGES = {
+  NULL_OR_UNDEFINED: 'null/undefined',
+  CIRCULAR_REF: 'circular ref',
+  UPDATER_INVALID: 'updater invalid',
+  LAZY_FALLBACK: 'lazy fallback',
+  SIGNAL_CREATION_FAILED: 'signal creation failed',
+  UPDATE_PATH_NOT_FOUND: 'update path not found',
+  UPDATE_FAILED: 'update failed',
+  ROLLBACK_FAILED: 'rollback failed',
+  CLEANUP_ERROR: 'cleanup error',
+  PRESET_UNKNOWN: 'unknown preset',
+  STRATEGY_SELECTION: 'strategy select',
+  TREE_DESTROYED: 'destroyed',
+  UPDATE_TRANSACTION: 'update tx',
+  BATCH_NOT_ENABLED: 'batching disabled',
+  MEMOIZE_NOT_ENABLED: 'memoize disabled',
+  MIDDLEWARE_NOT_AVAILABLE: 'middleware missing',
+  ENTITY_HELPERS_NOT_AVAILABLE: 'entity helpers missing',
+  TIME_TRAVEL_NOT_AVAILABLE: 'time travel missing',
+  OPTIMIZE_NOT_AVAILABLE: 'optimize missing',
+  UPDATE_OPTIMIZED_NOT_AVAILABLE: 'update optimized missing',
+  CACHE_NOT_AVAILABLE: 'cache missing',
+  PERFORMANCE_NOT_ENABLED: 'performance disabled',
+  ENHANCER_ORDER_FAILED: 'enhancer order failed',
+  ENHANCER_CYCLE_DETECTED: 'enhancer cycle',
+  ENHANCER_REQUIREMENT_MISSING: 'enhancer req missing',
+  ENHANCER_PROVIDES_MISSING: 'enhancer provides missing',
+  ENHANCER_FAILED: 'enhancer failed',
+  ENHANCER_NOT_FUNCTION: 'enhancer not function',
+  EFFECT_NO_CONTEXT: 'no angular context',
+  SUBSCRIBE_NO_CONTEXT: 'no angular context'
+};
+const PROD_MESSAGES = (() => {
+  const out = {};
+  let i = 0;
+  for (const k of Object.keys(DEV_MESSAGES)) {
+    out[k] = String(i++);
+  }
+  return out;
+})();
+const _isProdByEnv = Boolean(typeof globalThis === 'object' && globalThis !== null && 'process' in globalThis && typeof globalThis.process === 'object' && 'env' in globalThis.process && globalThis.process.env.NODE_ENV === 'production');
+const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
+const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev ? DEV_MESSAGES : PROD_MESSAGES);
+
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES };

package/dist/lib/entity-signal.js

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