@signaltree/core 4.0.16 → 4.1.0

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.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.js

@@ -0,0 +1,19 @@
+export { signalTree } from './lib/signal-tree.js';
+export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
+export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
+export { ENHANCER_META } from './lib/types.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 { createLoggingMiddleware, createValidationMiddleware, withMiddleware } from './enhancers/middleware/lib/middleware.js';
+export { createAsyncOperation, trackAsync } from './enhancers/middleware/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/constants.js

@@ -0,0 +1,57 @@
+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',
+  ASYNC_ACTIONS_NOT_AVAILABLE: 'async actions 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/memory/memory-manager.js

@@ -0,0 +1,164 @@
+class SignalMemoryManager {
+  cache = new Map();
+  registry = null;
+  config;
+  stats = {
+    cleanedUpSignals: 0,
+    peakCachedSignals: 0,
+    manualDisposes: 0
+  };
+  constructor(config = {}) {
+    this.config = {
+      enableAutoCleanup: config.enableAutoCleanup ?? true,
+      debugMode: config.debugMode ?? false,
+      onCleanup: config.onCleanup ?? (() => {})
+    };
+    if (this.config.enableAutoCleanup && typeof FinalizationRegistry !== 'undefined') {
+      this.registry = new FinalizationRegistry(path => {
+        this.handleCleanup(path);
+      });
+    }
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Initialized', {
+        autoCleanup: this.config.enableAutoCleanup,
+        hasRegistry: !!this.registry
+      });
+    }
+  }
+  cacheSignal(path, signal) {
+    const ref = new WeakRef(signal);
+    const entry = {
+      ref,
+      path,
+      cachedAt: Date.now()
+    };
+    this.cache.set(path, entry);
+    if (this.registry) {
+      this.registry.register(signal, path, signal);
+    }
+    const currentSize = this.cache.size;
+    if (currentSize > this.stats.peakCachedSignals) {
+      this.stats.peakCachedSignals = currentSize;
+    }
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Cached signal: ${path}`, {
+        cacheSize: currentSize,
+        peak: this.stats.peakCachedSignals
+      });
+    }
+  }
+  getSignal(path) {
+    const entry = this.cache.get(path);
+    if (!entry) {
+      return undefined;
+    }
+    const signal = entry.ref.deref();
+    if (!signal) {
+      this.cache.delete(path);
+      if (this.config.debugMode) {
+        console.log(`[SignalMemoryManager] Signal GC'd: ${path}`);
+      }
+      return undefined;
+    }
+    return signal;
+  }
+  hasSignal(path) {
+    return this.cache.has(path);
+  }
+  removeSignal(path) {
+    const entry = this.cache.get(path);
+    if (!entry) {
+      return false;
+    }
+    const signal = entry.ref.deref();
+    if (signal && this.registry) {
+      this.registry.unregister(signal);
+    }
+    this.cache.delete(path);
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Removed signal: ${path}`);
+    }
+    return true;
+  }
+  handleCleanup(path) {
+    this.cache.delete(path);
+    this.stats.cleanedUpSignals++;
+    const currentStats = this.getStats();
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Auto cleanup: ${path}`, currentStats);
+    }
+    this.config.onCleanup(path, currentStats);
+  }
+  getStats() {
+    let validSignals = 0;
+    for (const [path, entry] of this.cache.entries()) {
+      if (entry.ref.deref()) {
+        validSignals++;
+      } else {
+        this.cache.delete(path);
+      }
+    }
+    const estimatedMemoryBytes = validSignals * 100;
+    return {
+      cachedSignals: validSignals,
+      cleanedUpSignals: this.stats.cleanedUpSignals,
+      peakCachedSignals: this.stats.peakCachedSignals,
+      manualDisposes: this.stats.manualDisposes,
+      estimatedMemoryBytes
+    };
+  }
+  dispose() {
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Disposing', {
+        cachedSignals: this.cache.size
+      });
+    }
+    if (this.registry) {
+      for (const entry of this.cache.values()) {
+        const signal = entry.ref.deref();
+        if (signal) {
+          this.registry.unregister(signal);
+        }
+      }
+    }
+    this.cache.clear();
+    this.stats.manualDisposes++;
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Disposed', this.getStats());
+    }
+  }
+  getCachedPaths() {
+    const paths = [];
+    for (const [path, entry] of this.cache.entries()) {
+      if (entry.ref.deref()) {
+        paths.push(path);
+      }
+    }
+    return paths;
+  }
+  clearStale() {
+    let removed = 0;
+    for (const [path, entry] of this.cache.entries()) {
+      if (!entry.ref.deref()) {
+        this.cache.delete(path);
+        removed++;
+      }
+    }
+    if (this.config.debugMode && removed > 0) {
+      console.log(`[SignalMemoryManager] Cleared ${removed} stale entries`);
+    }
+    return removed;
+  }
+  resetStats() {
+    this.stats = {
+      cleanedUpSignals: 0,
+      peakCachedSignals: 0,
+      manualDisposes: 0
+    };
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Stats reset');
+    }
+  }
+}
+
+export { SignalMemoryManager };

package/dist/lib/performance/diff-engine.js

@@ -0,0 +1,156 @@
+var ChangeType;
+(function (ChangeType) {
+  ChangeType["ADD"] = "add";
+  ChangeType["UPDATE"] = "update";
+  ChangeType["DELETE"] = "delete";
+  ChangeType["REPLACE"] = "replace";
+})(ChangeType || (ChangeType = {}));
+class DiffEngine {
+  defaultOptions = {
+    maxDepth: 100,
+    detectDeletions: false,
+    ignoreArrayOrder: false,
+    equalityFn: (a, b) => a === b,
+    keyValidator: undefined
+  };
+  diff(current, updates, options = {}) {
+    const opts = {
+      ...this.defaultOptions,
+      ...options
+    };
+    const changes = [];
+    const visited = new WeakSet();
+    this.traverse(current, updates, [], changes, visited, opts, 0);
+    return {
+      changes,
+      hasChanges: changes.length > 0
+    };
+  }
+  traverse(curr, upd, path, changes, visited, opts, depth) {
+    if (depth > opts.maxDepth) {
+      return;
+    }
+    if (typeof upd !== 'object' || upd === null) {
+      if (!opts.equalityFn(curr, upd)) {
+        changes.push({
+          type: curr === undefined ? ChangeType.ADD : ChangeType.UPDATE,
+          path: [...path],
+          value: upd,
+          oldValue: curr
+        });
+      }
+      return;
+    }
+    if (visited.has(upd)) {
+      return;
+    }
+    visited.add(upd);
+    if (Array.isArray(upd)) {
+      this.diffArrays(curr, upd, path, changes, visited, opts, depth);
+      return;
+    }
+    if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
+      changes.push({
+        type: ChangeType.REPLACE,
+        path: [...path],
+        value: upd,
+        oldValue: curr
+      });
+      return;
+    }
+    const currObj = curr;
+    const updObj = upd;
+    for (const key in updObj) {
+      if (Object.prototype.hasOwnProperty.call(updObj, key)) {
+        if (opts.keyValidator && !opts.keyValidator(key)) {
+          continue;
+        }
+        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1);
+      }
+    }
+    if (opts.detectDeletions) {
+      for (const key in currObj) {
+        if (Object.prototype.hasOwnProperty.call(currObj, key) && !(key in updObj)) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, key],
+            oldValue: currObj[key]
+          });
+        }
+      }
+    }
+  }
+  diffArrays(curr, upd, path, changes, visited, opts, depth) {
+    if (!Array.isArray(curr)) {
+      changes.push({
+        type: ChangeType.REPLACE,
+        path: [...path],
+        value: upd,
+        oldValue: curr
+      });
+      return;
+    }
+    if (opts.ignoreArrayOrder) {
+      this.diffArraysUnordered(curr, upd, path, changes, opts);
+    } else {
+      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth);
+    }
+  }
+  diffArraysOrdered(curr, upd, path, changes, visited, opts, depth) {
+    const maxLength = Math.max(curr.length, upd.length);
+    for (let i = 0; i < maxLength; i++) {
+      if (i >= upd.length) {
+        if (opts.detectDeletions) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, i],
+            oldValue: curr[i]
+          });
+        }
+      } else if (i >= curr.length) {
+        changes.push({
+          type: ChangeType.ADD,
+          path: [...path, i],
+          value: upd[i]
+        });
+      } else {
+        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1);
+      }
+    }
+  }
+  diffArraysUnordered(curr, upd, path, changes, opts) {
+    const currSet = new Set(curr.map(v => this.stringify(v)));
+    const updSet = new Set(upd.map(v => this.stringify(v)));
+    upd.forEach((value, index) => {
+      const str = this.stringify(value);
+      if (!currSet.has(str)) {
+        changes.push({
+          type: ChangeType.ADD,
+          path: [...path, index],
+          value
+        });
+      }
+    });
+    if (opts.detectDeletions) {
+      curr.forEach((value, index) => {
+        const str = this.stringify(value);
+        if (!updSet.has(str)) {
+          changes.push({
+            type: ChangeType.DELETE,
+            path: [...path, index],
+            oldValue: value
+          });
+        }
+      });
+    }
+  }
+  stringify(value) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+}
+
+export { ChangeType, DiffEngine };