@signaltree/core 5.1.6 → 6.0.1

package/dist/enhancers/time-travel/{lib/time-travel.js → time-travel.js}

@@ -1,5 +1,5 @@
-import { deepClone } from '../../../deep-clone.js';
-import { deepEqual } from '../../../deep-equal.js';
+import { snapshotState } from '../../lib/utils.js';
+import { deepClone, deepEqual } from './utils.js';
 
 class TimeTravelManager {
   tree;
@@ -28,8 +28,10 @@ class TimeTravelManager {
     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: deepClone(state),
+      state: cloned,
       timestamp: Date.now(),
       action: this.actionNames[action] || action,
       ...(this.includePayload && payload !== undefined && {
@@ -99,8 +101,33 @@ class TimeTravelManager {
     }
   }
 }
-function withTimeTravel(config = {}) {
+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 => {
@@ -137,8 +164,7 @@ function withTimeTravel(config = {}) {
           }
         }
         const afterState = originalTreeCall();
-        const statesEqual = deepEqual(beforeState, afterState);
-        if (!statesEqual) {
+        if (!deepEqual(beforeState, afterState)) {
           timeTravelManager.addEntry('update', afterState);
         }
         return result;
@@ -155,39 +181,51 @@ function withTimeTravel(config = {}) {
     }
     if ('$' in tree) {
       Object.defineProperty(enhancedTree, '$', {
-        value: tree['$'],
+        value: tree.$,
         enumerable: false,
         configurable: true
       });
     }
-    enhancedTree.undo = () => {
+    enhancedTree['undo'] = () => {
       timeTravelManager.undo();
     };
-    enhancedTree.redo = () => {
+    enhancedTree['redo'] = () => {
       timeTravelManager.redo();
     };
-    enhancedTree.getHistory = () => timeTravelManager.getHistory();
-    enhancedTree.resetHistory = () => {
+    enhancedTree['getHistory'] = () => timeTravelManager.getHistory();
+    enhancedTree['resetHistory'] = () => {
       timeTravelManager.resetHistory();
     };
-    enhancedTree.jumpTo = index => {
+    enhancedTree['jumpTo'] = index => {
       timeTravelManager.jumpTo(index);
     };
-    enhancedTree.canUndo = () => timeTravelManager.canUndo();
-    enhancedTree.canRedo = () => timeTravelManager.canRedo();
-    enhancedTree.getCurrentIndex = () => timeTravelManager.getCurrentIndex();
-    return Object.assign(enhancedTree, {
-      __timeTravel: timeTravelManager
-    });
+    enhancedTree['canUndo'] = () => timeTravelManager.canUndo();
+    enhancedTree['canRedo'] = () => timeTravelManager.canRedo();
+    enhancedTree['getCurrentIndex'] = () => timeTravelManager.getCurrentIndex();
+    enhancedTree['__timeTravel'] = timeTravelManager;
+    return enhancedTree;
   };
 }
-function enableTimeTravel(maxHistorySize) {
-  return withTimeTravel({
-    maxHistorySize
+function enableTimeTravel() {
+  return timeTravel({
+    enabled: true
   });
 }
-function getTimeTravel(tree) {
-  return tree.__timeTravel;
+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, getTimeTravel, withTimeTravel };
+export { enableTimeTravel, timeTravel, timeTravelHistory };

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

@@ -0,0 +1,11 @@
+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/index.js

@@ -4,16 +4,16 @@ export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, to
 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 { batching, 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, createDevTree, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
-export { computedEnhancer, createComputed } from './enhancers/computed/lib/computed.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/lib/async-helpers.js

@@ -2,11 +2,11 @@ import { signal } from '@angular/core';
 
 function createAsyncOperation(name, operation) {
   return async tree => {
-    if (typeof tree.batchUpdate === 'function') {
+    if (typeof tree['batchUpdate'] === 'function') {
       const pendingPatch = {
         [`${name}_PENDING`]: true
       };
-      tree.batchUpdate(() => pendingPatch);
+      tree['batchUpdate'](() => pendingPatch);
     } else if ('$' in tree) {
       try {
         tree['$'][`${name}_PENDING`]?.set?.(true);
@@ -15,12 +15,12 @@ function createAsyncOperation(name, operation) {
     }
     try {
       const result = await operation();
-      if (typeof tree.batchUpdate === 'function') {
+      if (typeof tree['batchUpdate'] === 'function') {
         const resultPatch = {
           [`${name}_RESULT`]: result,
           [`${name}_PENDING`]: false
         };
-        tree.batchUpdate(() => resultPatch);
+        tree['batchUpdate'](() => resultPatch);
       } else if ('$' in tree) {
         try {
           tree['$'][`${name}_RESULT`]?.set?.(result);
@@ -31,12 +31,12 @@ function createAsyncOperation(name, operation) {
       }
       return result;
     } catch (error) {
-      if (typeof tree.batchUpdate === 'function') {
+      if (typeof tree['batchUpdate'] === 'function') {
         const errorPatch = {
           [`${name}_ERROR`]: error,
           [`${name}_PENDING`]: false
         };
-        tree.batchUpdate(() => errorPatch);
+        tree['batchUpdate'](() => errorPatch);
       } else if ('$' in tree) {
         try {
           tree['$'][`${name}_ERROR`]?.set?.(error);

package/dist/lib/presets.js

@@ -0,0 +1,21 @@
+import { signalTree } from './signal-tree.js';
+import { effects } from '../enhancers/effects/effects.js';
+import { batching } from '../enhancers/batching/batching.js';
+import { memoization } from '../enhancers/memoization/memoization.js';
+import { entities } from '../enhancers/entities/entities.js';
+import { timeTravel } from '../enhancers/time-travel/time-travel.js';
+import { devTools } from '../enhancers/devtools/devtools.js';
+
+function createDevTree(initialState, config = {}) {
+  if (arguments.length === 0) {
+    const enhancer = tree => tree.with(effects()).with(batching()).with(memoization()).with(entities()).with(timeTravel()).with(devTools());
+    return {
+      enhancer
+    };
+  }
+  const base = signalTree(initialState, config);
+  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization)).with(entities()).with(timeTravel(config.timeTravel)).with(devTools(config.devTools));
+  return enhanced;
+}
+
+export { createDevTree };