@signaltree/core 6.2.0 → 6.2.1

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

@@ -1,231 +0,0 @@
-import { snapshotState } from '../../lib/utils.js';
-import { deepClone, deepEqual } from './utils.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 plain = snapshotState(this.tree.state);
-    const cloned = typeof structuredClone !== 'undefined' ? structuredClone(plain) : JSON.parse(JSON.stringify(plain));
-    const entry = {
-      state: cloned,
-      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 timeTravel(config = {}) {
-  const {
-    enabled = true
-  } = config;
-  return tree => {
-    if (!enabled) {
-      const noopMethods = {
-        undo() {},
-        redo() {},
-        canUndo() {
-          return false;
-        },
-        canRedo() {
-          return false;
-        },
-        getHistory() {
-          return [];
-        },
-        resetHistory() {},
-        jumpTo(_index) {
-        },
-        getCurrentIndex() {
-          return -1;
-        }
-      };
-      return Object.assign(tree, noopMethods);
-    }
-    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();
-        if (!deepEqual(beforeState, afterState)) {
-          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();
-    enhancedTree['__timeTravel'] = timeTravelManager;
-    return enhancedTree;
-  };
-}
-function enableTimeTravel() {
-  return timeTravel({
-    enabled: true
-  });
-}
-function timeTravelHistory(maxHistorySize) {
-  return timeTravel({
-    maxHistorySize
-  });
-}
-Object.assign((config = {}) => timeTravel(config), {
-  minimal: () => timeTravel({
-    maxHistorySize: 20,
-    includePayload: false
-  }),
-  debug: () => timeTravel({
-    maxHistorySize: 200,
-    includePayload: true
-  }),
-  history: timeTravelHistory
-});
-
-export { enableTimeTravel, timeTravel, timeTravelHistory };

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

@@ -1,11 +0,0 @@
-function deepClone(obj) {
-  if (typeof structuredClone === 'function') {
-    return structuredClone(obj);
-  }
-  return JSON.parse(JSON.stringify(obj));
-}
-function deepEqual(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-export { deepClone, deepEqual };

package/dist/enhancers/utils/copy-tree-properties.js

@@ -1,20 +0,0 @@
-function copyTreeProperties(source, target) {
-  const skipKeys = new Set(['state', '$']);
-  for (const key of Object.getOwnPropertyNames(source)) {
-    if (skipKeys.has(key)) continue;
-    if (Object.prototype.hasOwnProperty.call(target, key)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(source, key);
-    if (!descriptor) continue;
-    if (descriptor.configurable === false) continue;
-    Object.defineProperty(target, key, descriptor);
-  }
-  for (const sym of Object.getOwnPropertySymbols(source)) {
-    if (Object.prototype.hasOwnProperty.call(target, sym)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(source, sym);
-    if (!descriptor) continue;
-    if (descriptor.configurable === false) continue;
-    Object.defineProperty(target, sym, descriptor);
-  }
-}
-
-export { copyTreeProperties };

package/dist/index.js

@@ -1,20 +0,0 @@
-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 { createEditSession } from './lib/edit-session.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 { batching, batchingWithConfig, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching } from './enhancers/batching/batching.js';
-export { clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization } from './enhancers/memoization/memoization.js';
-export { enableTimeTravel, timeTravel } from './enhancers/time-travel/time-travel.js';
-export { enableEntities, entities, highPerformanceEntities } from './enhancers/entities/entities.js';
-export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, persistence, serialization } from './enhancers/serialization/serialization.js';
-export { devTools, enableDevTools, fullDevTools, productionDevTools } from './enhancers/devtools/devtools.js';
-export { createAsyncOperation, trackAsync } from './lib/async-helpers.js';
-export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.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';
-export { createDevTree } from './lib/presets.js';

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

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

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

@@ -1,56 +0,0 @@
-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/edit-session.js

@@ -1,84 +0,0 @@
-import { signal } from '@angular/core';
-import { deepEqual } from '../deep-equal.js';
-
-function clone(value) {
-  try {
-    return globalThis.structuredClone ? globalThis.structuredClone(value) : JSON.parse(JSON.stringify(value));
-  } catch {
-    return JSON.parse(JSON.stringify(value));
-  }
-}
-function createEditSession(initial) {
-  const original = signal(clone(initial));
-  const present = signal(clone(initial));
-  const pastCount = signal(0);
-  const futureCount = signal(0);
-  let past = [];
-  let future = [];
-  function updateCounts() {
-    pastCount.set(past.length);
-    futureCount.set(future.length);
-  }
-  const canUndo = () => pastCount() > 0;
-  const canRedo = () => futureCount() > 0;
-  const isDirty = () => !deepEqual(original(), present());
-  function setOriginal(value) {
-    const v = clone(value);
-    original.set(v);
-    present.set(clone(v));
-    past = [];
-    future = [];
-    updateCounts();
-  }
-  function applyChanges(valueOrUpdater) {
-    const current = present();
-    const next = typeof valueOrUpdater === 'function' ? valueOrUpdater(clone(current)) : valueOrUpdater;
-    if (deepEqual(current, next)) return;
-    past.push(clone(current));
-    present.set(clone(next));
-    future = [];
-    updateCounts();
-  }
-  function undo() {
-    if (past.length === 0) return;
-    const prev = past.pop();
-    future.push(clone(present()));
-    present.set(clone(prev));
-    updateCounts();
-  }
-  function redo() {
-    if (future.length === 0) return;
-    const next = future.pop();
-    past.push(clone(present()));
-    present.set(clone(next));
-    updateCounts();
-  }
-  function reset() {
-    present.set(clone(original()));
-    past = [];
-    future = [];
-    updateCounts();
-  }
-  function getHistory() {
-    return {
-      past: past.map(p => clone(p)),
-      present: clone(present()),
-      future: future.map(f => clone(f))
-    };
-  }
-  return {
-    original,
-    modified: present,
-    canUndo,
-    canRedo,
-    isDirty,
-    setOriginal,
-    applyChanges,
-    undo,
-    redo,
-    reset,
-    getHistory
-  };
-}
-
-export { createEditSession, createEditSession as default };