@signaltree/core 4.0.15 → 4.1.0

package/dist/enhancers/middleware/lib/async-helpers.js

@@ -1,85 +1,77 @@
 import { signal } from '@angular/core';
-export 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) {
-                void e;
-            }
-        }
+
+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 {
-            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;
+          tree['$'][`${name}_RESULT`]?.set?.(result);
+          tree['$'][`${name}_PENDING`]?.set?.(false);
+        } catch (e) {
+          void e;
         }
-        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) {
-                    void e;
-                }
-            }
-            throw error;
+      }
+      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;
+    }
+  };
 }
-export 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);
-            }
-        },
-    };
+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/enhancers/middleware/lib/middleware.js

@@ -1,179 +1,136 @@
 const middlewareMap = new WeakMap();
-export function withMiddleware(middlewares = []) {
-    return (tree) => {
-        middlewareMap.set(tree, [...middlewares]);
-        const originalTreeCall = tree.bind(tree);
-        const enhancedTree = function (...args) {
-            if (args.length === 0) {
-                return originalTreeCall();
-            }
-            else {
-                const action = 'UPDATE';
-                const currentState = originalTreeCall();
-                const treeMiddlewares = middlewareMap.get(tree) || [];
-                let updateResult;
-                if (args.length === 1) {
-                    const arg = args[0];
-                    if (typeof arg === 'function') {
-                        updateResult = arg(currentState);
-                    }
-                    else {
-                        updateResult = arg;
-                    }
-                }
-                else {
-                    return;
-                }
-                for (const middleware of treeMiddlewares) {
-                    if (middleware.before &&
-                        !middleware.before(action, updateResult, currentState)) {
-                        return;
-                    }
-                }
-                const previousState = currentState;
-                if (args.length === 1) {
-                    const arg = args[0];
-                    if (typeof arg === 'function') {
-                        originalTreeCall(arg);
-                    }
-                    else {
-                        originalTreeCall(arg);
-                    }
-                }
-                const newState = originalTreeCall();
-                for (const middleware of treeMiddlewares) {
-                    if (middleware.after) {
-                        middleware.after(action, updateResult, previousState, newState);
-                    }
-                }
-            }
-        };
-        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,
-            });
+function withMiddleware(middlewares = []) {
+  return tree => {
+    middlewareMap.set(tree, [...middlewares]);
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        const action = 'UPDATE';
+        const currentState = originalTreeCall();
+        const treeMiddlewares = middlewareMap.get(tree) || [];
+        let updateResult;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            updateResult = arg(currentState);
+          } else {
+            updateResult = arg;
+          }
+        } else {
+          return;
         }
-        if ('$' in tree) {
-            Object.defineProperty(enhancedTree, '$', {
-                value: tree['$'],
-                enumerable: false,
-                configurable: true,
-            });
+        for (const middleware of treeMiddlewares) {
+          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
+            return;
+          }
         }
-        enhancedTree.addTap = (middleware) => {
-            const treeMiddlewares = middlewareMap.get(tree) || [];
-            const existingIndex = treeMiddlewares.findIndex((m) => m.id === middleware.id);
-            if (existingIndex >= 0) {
-                treeMiddlewares[existingIndex] = middleware;
-            }
-            else {
-                treeMiddlewares.push(middleware);
-            }
-            middlewareMap.set(tree, treeMiddlewares);
-        };
-        enhancedTree.removeTap = (id) => {
-            const treeMiddlewares = middlewareMap.get(tree) || [];
-            const filtered = treeMiddlewares.filter((m) => m.id !== id);
-            middlewareMap.set(tree, filtered);
-        };
-        const originalBatchUpdate = tree.batchUpdate;
-        if (originalBatchUpdate) {
-            enhancedTree.batchUpdate = (updater) => {
-                const action = 'BATCH_UPDATE';
-                const currentState = originalTreeCall();
-                const updateResult = updater(currentState);
-                const treeMiddlewares = middlewareMap.get(tree) || [];
-                for (const middleware of treeMiddlewares) {
-                    if (middleware.before &&
-                        !middleware.before(action, updateResult, currentState)) {
-                        return;
-                    }
-                }
-                const previousState = currentState;
-                originalBatchUpdate.call(tree, updater);
-                const newState = originalTreeCall();
-                for (const middleware of treeMiddlewares) {
-                    if (middleware.after) {
-                        middleware.after(action, updateResult, previousState, newState);
-                    }
-                }
-            };
+        const previousState = currentState;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            originalTreeCall(arg);
+          } else {
+            originalTreeCall(arg);
+          }
         }
-        const originalDestroy = tree.destroy;
-        enhancedTree.destroy = () => {
-            middlewareMap.delete(tree);
-            if (originalDestroy) {
-                originalDestroy.call(tree);
-            }
-        };
-        return enhancedTree;
+        const newState = originalTreeCall();
+        for (const middleware of treeMiddlewares) {
+          if (middleware.after) {
+            middleware.after(action, updateResult, previousState, newState);
+          }
+        }
+      }
     };
-}
-export function createLoggingMiddleware(treeName) {
-    return {
-        id: 'logging',
-        before: (action, payload, state) => {
-            console.group(`🏪 ${treeName}: ${action}`);
-            console.log('Previous state:', state);
-            console.log('Payload:', typeof payload === 'function' ? 'Function' : payload);
-            return true;
-        },
-        after: (action, payload, state, newState) => {
-            console.log('New state:', newState);
-            console.groupEnd();
-        },
+    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.addTap = middleware => {
+      const treeMiddlewares = middlewareMap.get(tree) || [];
+      const existingIndex = treeMiddlewares.findIndex(m => m.id === middleware.id);
+      if (existingIndex >= 0) {
+        treeMiddlewares[existingIndex] = middleware;
+      } else {
+        treeMiddlewares.push(middleware);
+      }
+      middlewareMap.set(tree, treeMiddlewares);
     };
-}
-export function createPerformanceMiddleware() {
-    return {
-        id: 'performance',
-        before: (action) => {
-            console.time(`Tree update: ${action}`);
-            return true;
-        },
-        after: (action) => {
-            console.timeEnd(`Tree update: ${action}`);
-        },
-    };
-}
-export function createValidationMiddleware(validator) {
-    return {
-        id: 'validation',
-        after: (action, payload, state, newState) => {
-            const error = validator(newState);
-            if (error) {
-                console.error(`Validation failed after ${action}:`, error);
-            }
-        },
+    enhancedTree.removeTap = id => {
+      const treeMiddlewares = middlewareMap.get(tree) || [];
+      const filtered = treeMiddlewares.filter(m => m.id !== id);
+      middlewareMap.set(tree, filtered);
     };
-}
-export function createPersistenceMiddleware(config) {
-    const { key, storage = localStorage, debounceMs = 1000, actions = ['UPDATE', 'BATCH_UPDATE'], } = config;
-    let timeoutId;
-    const debouncedSave = (state) => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
+    const originalBatchUpdate = tree.batchUpdate;
+    if (originalBatchUpdate) {
+      enhancedTree.batchUpdate = updater => {
+        const action = 'BATCH_UPDATE';
+        const currentState = originalTreeCall();
+        const updateResult = updater(currentState);
+        const treeMiddlewares = middlewareMap.get(tree) || [];
+        for (const middleware of treeMiddlewares) {
+          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
+            return;
+          }
         }
-        timeoutId = setTimeout(() => {
-            try {
-                storage.setItem(key, JSON.stringify(state));
-                console.log(`💾 State auto-saved to ${key}`);
-            }
-            catch (error) {
-                console.error('Failed to save state:', error);
-            }
-        }, debounceMs);
-    };
-    return {
-        id: 'persistence',
-        after: (action, payload, state, newState) => {
-            if (actions.includes(action)) {
-                debouncedSave(newState);
-            }
-        },
+        const previousState = currentState;
+        originalBatchUpdate.call(tree, updater);
+        const newState = originalTreeCall();
+        for (const middleware of treeMiddlewares) {
+          if (middleware.after) {
+            middleware.after(action, updateResult, previousState, newState);
+          }
+        }
+      };
+    }
+    const originalDestroy = tree.destroy;
+    enhancedTree.destroy = () => {
+      middlewareMap.delete(tree);
+      if (originalDestroy) {
+        originalDestroy.call(tree);
+      }
     };
+    return enhancedTree;
+  };
+}
+function createLoggingMiddleware(treeName) {
+  return {
+    id: 'logging',
+    before: (action, payload, state) => {
+      console.group(`🏪 ${treeName}: ${action}`);
+      console.log('Previous state:', state);
+      console.log('Payload:', typeof payload === 'function' ? 'Function' : payload);
+      return true;
+    },
+    after: (action, payload, state, newState) => {
+      console.log('New state:', newState);
+      console.groupEnd();
+    }
+  };
+}
+function createValidationMiddleware(validator) {
+  return {
+    id: 'validation',
+    after: (action, payload, state, newState) => {
+      const error = validator(newState);
+      if (error) {
+        console.error(`Validation failed after ${action}:`, error);
+      }
+    }
+  };
 }
+
+export { createLoggingMiddleware, createValidationMiddleware, withMiddleware };

package/dist/enhancers/presets/lib/presets.js

@@ -1,77 +1,88 @@
-import { composeEnhancers } from '../../../lib/utils';
-import { withBatching, withHighPerformanceBatching } from '../../batching/lib/batching';
-import { withDevTools } from '../../devtools/lib/devtools';
-import { withHighPerformanceMemoization, withMemoization } from '../../memoization/lib/memoization';
-import { withMiddleware } from '../../middleware/lib/middleware';
-import { withTimeTravel } from '../../time-travel/lib/time-travel';
-export const TREE_PRESETS = {
-    basic: {
-        batchUpdates: false,
-        useMemoization: false,
-        trackPerformance: false,
-        enableTimeTravel: false,
-        enableDevTools: false,
-        debugMode: false,
-    },
-    performance: {
-        batchUpdates: true,
-        useMemoization: true,
-        trackPerformance: false,
-        enableTimeTravel: false,
-        enableDevTools: false,
-        debugMode: false,
-        useShallowComparison: true,
-        maxCacheSize: 200,
-    },
-    development: {
-        batchUpdates: true,
-        useMemoization: true,
-        trackPerformance: true,
-        enableTimeTravel: true,
-        enableDevTools: true,
-        debugMode: true,
-        maxCacheSize: 100,
-    },
-    production: {
-        batchUpdates: true,
-        useMemoization: true,
-        trackPerformance: false,
-        enableTimeTravel: false,
-        enableDevTools: false,
-        debugMode: false,
-        useShallowComparison: true,
-        maxCacheSize: 200,
-    },
+import { composeEnhancers } from '../../../lib/utils.js';
+import { withHighPerformanceBatching, withBatching } from '../../batching/lib/batching.js';
+import { withDevTools } from '../../devtools/lib/devtools.js';
+import { withHighPerformanceMemoization, withMemoization } from '../../memoization/lib/memoization.js';
+import { withMiddleware } from '../../middleware/lib/middleware.js';
+import { withTimeTravel } from '../../time-travel/lib/time-travel.js';
+
+const TREE_PRESETS = {
+  basic: {
+    batchUpdates: false,
+    useMemoization: false,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false
+  },
+  performance: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false,
+    useShallowComparison: true,
+    maxCacheSize: 200
+  },
+  development: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: true,
+    enableTimeTravel: true,
+    enableDevTools: true,
+    debugMode: true,
+    maxCacheSize: 100
+  },
+  production: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false,
+    useShallowComparison: true,
+    maxCacheSize: 200
+  }
 };
-export function createPresetConfig(preset, overrides = {}) {
-    const baseConfig = TREE_PRESETS[preset];
-    return {
-        ...baseConfig,
-        ...overrides,
-    };
-}
-export function validatePreset(preset) {
-    if (!TREE_PRESETS[preset]) {
-        throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
-    }
-    return true;
+function createPresetConfig(preset, overrides = {}) {
+  const baseConfig = TREE_PRESETS[preset];
+  return {
+    ...baseConfig,
+    ...overrides
+  };
 }
-export function getAvailablePresets() {
-    return Object.keys(TREE_PRESETS);
+function validatePreset(preset) {
+  if (!TREE_PRESETS[preset]) {
+    throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
+  }
+  return true;
 }
-export function combinePresets(presets, overrides = {}) {
-    let combined = {};
-    for (const preset of presets) {
-        validatePreset(preset);
-        combined = { ...combined, ...TREE_PRESETS[preset] };
-    }
-    return { ...combined, ...overrides };
+function getAvailablePresets() {
+  return Object.keys(TREE_PRESETS);
 }
-export function createDevTree(overrides = {}) {
-    const config = createPresetConfig('development', overrides);
-    const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withMiddleware(), withTimeTravel(), withDevTools({ treeName: config.treeName ?? 'SignalTree Dev' }));
-    return {
-        config,
-        enhancer: composed,
+function combinePresets(presets, overrides = {}) {
+  let combined = {};
+  for (const preset of presets) {
+    validatePreset(preset);
+    combined = {
+      ...combined,
+      ...TREE_PRESETS[preset]
     };
+  }
+  return {
+    ...combined,
+    ...overrides
+  };
+}
+function createDevTree(overrides = {}) {
+  const config = createPresetConfig('development', overrides);
+  const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withMiddleware(), withTimeTravel(), withDevTools({
+    treeName: config.treeName ?? 'SignalTree Dev'
+  }));
+  return {
+    config,
+    enhancer: composed
+  };
 }
+
+export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset };

package/dist/enhancers/serialization/constants.js

@@ -1,14 +1,15 @@
-export const TYPE_MARKERS = {
-    DATE: '§d',
-    REGEXP: '§r',
-    MAP: '§m',
-    SET: '§s',
-    UNDEFINED: '§u',
-    NAN: '§n',
-    INFINITY: '§i',
-    NEG_INFINITY: '§-i',
-    BIGINT: '§b',
-    SYMBOL: '§y',
-    FUNCTION: '§f',
-    CIRCULAR: '§c',
+const TYPE_MARKERS = {
+  DATE: '§d',
+  REGEXP: '§r',
+  MAP: '§m',
+  SET: '§s',
+  UNDEFINED: '§u',
+  NAN: '§n',
+  INFINITY: '§i',
+  NEG_INFINITY: '§-i',
+  BIGINT: '§b',
+  SYMBOL: '§y',
+  CIRCULAR: '§c'
 };
+
+export { TYPE_MARKERS };