@signaltree/core 4.0.16 → 4.1.0

package/dist/enhancers/middleware/lib/middleware.js

@@ -0,0 +1,136 @@
+const middlewareMap = new WeakMap();
+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
+      });
+    }
+    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);
+    };
+    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 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

@@ -0,0 +1,88 @@
+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
+  }
+};
+function createPresetConfig(preset, overrides = {}) {
+  const baseConfig = TREE_PRESETS[preset];
+  return {
+    ...baseConfig,
+    ...overrides
+  };
+}
+function validatePreset(preset) {
+  if (!TREE_PRESETS[preset]) {
+    throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
+  }
+  return true;
+}
+function getAvailablePresets() {
+  return Object.keys(TREE_PRESETS);
+}
+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

@@ -0,0 +1,15 @@
+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 };