@signaltree/core 8.0.2 → 9.0.1

package/dist/enhancers/memoization/memoization.js

@@ -1,420 +0,0 @@
-import { computed } from '@angular/core';
-import { isNodeAccessor } from '../../lib/utils.js';
-import { deepEqual } from '../../shared/lib/deep-equal.js';
-import { LRUCache } from '../../shared/lib/lru-cache.js';
-
-function isDevMode() {
-  if (typeof __DEV__ !== 'undefined') {
-    return __DEV__;
-  }
-  return false;
-}
-const MAX_CACHE_SIZE = 1000;
-const DEFAULT_TTL = 5 * 60 * 1000;
-const memoizationCache = new Map();
-function createMemoCacheStore(maxSize, enableLRU) {
-  if (enableLRU) {
-    const cache = new LRUCache(maxSize);
-    const shadow = new Map();
-    const pruneShadow = () => {
-      while (shadow.size > cache.size()) {
-        const oldestKey = shadow.keys().next().value;
-        if (oldestKey === undefined) {
-          break;
-        }
-        shadow.delete(oldestKey);
-      }
-    };
-    return {
-      get: key => {
-        const value = cache.get(key);
-        if (value !== undefined) {
-          shadow.set(key, value);
-        } else if (shadow.has(key)) {
-          shadow.delete(key);
-        }
-        return value;
-      },
-      set: (key, value) => {
-        cache.set(key, value);
-        shadow.set(key, value);
-        pruneShadow();
-      },
-      delete: key => {
-        cache.delete(key);
-        shadow.delete(key);
-      },
-      clear: () => {
-        cache.clear();
-        shadow.clear();
-      },
-      size: () => shadow.size,
-      forEach: callback => {
-        shadow.forEach((value, key) => callback(value, key));
-      },
-      keys: () => shadow.keys()
-    };
-  }
-  const store = new Map();
-  return {
-    get: key => store.get(key),
-    set: (key, value) => {
-      store.set(key, value);
-    },
-    delete: key => store.delete(key),
-    clear: () => store.clear(),
-    size: () => store.size,
-    forEach: callback => {
-      store.forEach((value, key) => callback(value, key));
-    },
-    keys: () => store.keys()
-  };
-}
-function getCleanupInterval(tree) {
-  return tree._memoCleanupInterval;
-}
-function setCleanupInterval(tree, interval) {
-  if (interval === undefined) {
-    delete tree._memoCleanupInterval;
-    return;
-  }
-  tree._memoCleanupInterval = interval;
-}
-function clearCleanupInterval(tree) {
-  const interval = getCleanupInterval(tree);
-  if (!interval) {
-    return;
-  }
-  try {
-    clearInterval(interval);
-  } catch {}
-  setCleanupInterval(tree);
-}
-function resetMemoizationCaches() {
-  memoizationCache.forEach((cache, tree) => {
-    cache.clear();
-    clearCleanupInterval(tree);
-  });
-  memoizationCache.clear();
-}
-function shallowEqual(a, b) {
-  if (a === b) return true;
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === 'object' && typeof b === 'object') {
-    const objA = a;
-    const objB = b;
-    let countA = 0;
-    for (const key in objA) {
-      if (!Object.prototype.hasOwnProperty.call(objA, key)) continue;
-      countA++;
-      if (!(key in objB) || objA[key] !== objB[key]) return false;
-    }
-    let countB = 0;
-    for (const key in objB) {
-      if (Object.prototype.hasOwnProperty.call(objB, key)) countB++;
-    }
-    return countA === countB;
-  }
-  return false;
-}
-function generateCacheKey(fn, args) {
-  try {
-    return `${fn.name || 'anonymous'}_${JSON.stringify(args)}`;
-  } catch {
-    return `${fn.name || 'anonymous'}_${args.length}`;
-  }
-}
-function getEqualityFn(strategy) {
-  switch (strategy) {
-    case 'shallow':
-      return shallowEqual;
-    case 'reference':
-      return (a, b) => a === b;
-    case 'deep':
-    default:
-      return deepEqual;
-  }
-}
-function memoize(fn, keyFn, config = {}) {
-  const maxSize = config.maxCacheSize ?? MAX_CACHE_SIZE;
-  const ttl = config.ttl ?? DEFAULT_TTL;
-  const equality = getEqualityFn(config.equality ?? 'shallow');
-  const enableLRU = config.enableLRU ?? false;
-  const cache = createMemoCacheStore(maxSize, enableLRU);
-  const cleanExpiredEntries = () => {
-    if (!ttl) return;
-    const now = Date.now();
-    cache.forEach((entry, key) => {
-      if (entry.timestamp && now - entry.timestamp > ttl) {
-        cache.delete(key);
-      }
-    });
-  };
-  return (...args) => {
-    if (ttl && Math.random() < 0.01) {
-      cleanExpiredEntries();
-    }
-    const key = keyFn ? keyFn(...args) : generateCacheKey(fn, args);
-    const cached = cache.get(key);
-    if (cached && (keyFn || equality(cached.deps, args))) {
-      if (enableLRU) {
-        cached.hitCount += 1;
-      }
-      return cached.value;
-    }
-    const result = fn(...args);
-    cache.set(key, {
-      value: result,
-      deps: args,
-      timestamp: Date.now(),
-      hitCount: 1
-    });
-    return result;
-  };
-}
-function memoizeShallow(fn, keyFn) {
-  return memoize(fn, keyFn, {
-    equality: 'shallow',
-    enableLRU: false,
-    ttl: undefined,
-    maxCacheSize: 100
-  });
-}
-function memoizeReference(fn, keyFn) {
-  return memoize(fn, keyFn, {
-    equality: 'reference',
-    enableLRU: false,
-    ttl: undefined,
-    maxCacheSize: 50
-  });
-}
-const MEMOIZATION_PRESETS = {
-  selector: {
-    equality: 'reference',
-    maxCacheSize: 10,
-    enableLRU: false,
-    ttl: undefined
-  },
-  computed: {
-    equality: 'shallow',
-    maxCacheSize: 100,
-    enableLRU: false,
-    ttl: undefined
-  },
-  deepState: {
-    equality: 'deep',
-    maxCacheSize: 1000,
-    enableLRU: true,
-    ttl: 5 * 60 * 1000
-  },
-  highFrequency: {
-    equality: 'reference',
-    maxCacheSize: 5,
-    enableLRU: false,
-    ttl: undefined
-  }
-};
-function selectorMemoization() {
-  return memoization(MEMOIZATION_PRESETS.selector);
-}
-function computedMemoization() {
-  return memoization(MEMOIZATION_PRESETS.computed);
-}
-function deepStateMemoization() {
-  return memoization(MEMOIZATION_PRESETS.deepState);
-}
-function highFrequencyMemoization() {
-  return memoization(MEMOIZATION_PRESETS.highFrequency);
-}
-Object.assign((config = {}) => memoization(config), {
-  selector: selectorMemoization,
-  computed: computedMemoization,
-  deep: deepStateMemoization,
-  fast: highFrequencyMemoization
-});
-function memoization(config = {}) {
-  const {
-    enabled = true,
-    maxCacheSize = 1000,
-    ttl,
-    equality = 'deep',
-    enableLRU = true
-  } = config;
-  const enhancer = tree => {
-    const originalTreeCall = tree.bind(tree);
-    const applyUpdateResult = result => {
-      Object.entries(result).forEach(([propKey, value]) => {
-        const property = tree.state[propKey];
-        if (property && 'set' in property) {
-          property.set(value);
-        } else if (isNodeAccessor(property)) {
-          property(value);
-        }
-      });
-    };
-    if (!enabled) {
-      const memoTree = tree;
-      memoTree.memoize = (fn, _cacheKey) => {
-        return computed(() => fn(originalTreeCall()));
-      };
-      memoTree.memoizedUpdate = updater => {
-        const currentState = originalTreeCall();
-        const result = updater(currentState);
-        applyUpdateResult(result);
-      };
-      memoTree.clearMemoCache = () => {};
-      memoTree.clearCache = memoTree.clearMemoCache;
-      memoTree.getCacheStats = () => ({
-        size: 0,
-        hitRate: 0,
-        totalHits: 0,
-        totalMisses: 0,
-        keys: []
-      });
-      return memoTree;
-    }
-    const cache = createMemoCacheStore(maxCacheSize, enableLRU);
-    memoizationCache.set(tree, cache);
-    const equalityFn = getEqualityFn(equality);
-    tree.memoizedUpdate = (updater, cacheKey) => {
-      const currentState = originalTreeCall();
-      const key = cacheKey || generateCacheKey(updater, [currentState]);
-      const cached = cache.get(key);
-      if (cached && equalityFn(cached.deps, [currentState])) {
-        const cachedUpdate = cached.value;
-        applyUpdateResult(cachedUpdate);
-        return;
-      }
-      const result = updater(currentState);
-      cache.set(key, {
-        value: result,
-        deps: [currentState],
-        timestamp: Date.now(),
-        hitCount: 1
-      });
-      applyUpdateResult(result);
-    };
-    const memoizeResultCache = createMemoCacheStore(MAX_CACHE_SIZE, true);
-    tree.memoize = (fn, cacheKey) => {
-      return computed(() => {
-        const currentState = originalTreeCall();
-        const key = cacheKey || generateCacheKey(fn, [currentState]);
-        const cached = memoizeResultCache.get(key);
-        if (cached && equalityFn(cached.deps, [currentState])) {
-          return cached.value;
-        }
-        if (isDevMode() && tree.__devHooks?.onRecompute) {
-          try {
-            tree.__devHooks.onRecompute(key, 1);
-          } catch {}
-        }
-        const result = fn(currentState);
-        memoizeResultCache.set(key, {
-          value: result,
-          deps: [currentState],
-          timestamp: Date.now(),
-          hitCount: 1
-        });
-        return result;
-      });
-    };
-    tree.clearMemoCache = key => {
-      if (key) {
-        cache.delete(key);
-      } else {
-        cache.clear();
-      }
-    };
-    tree.clearCache = tree.clearMemoCache;
-    tree.getCacheStats = () => {
-      let totalHits = 0;
-      let totalMisses = 0;
-      cache.forEach(entry => {
-        totalHits += entry.hitCount || 0;
-        totalMisses += Math.floor((entry.hitCount || 0) / 2);
-      });
-      const hitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
-      return {
-        size: cache.size(),
-        hitRate,
-        totalHits,
-        totalMisses,
-        keys: Array.from(cache.keys())
-      };
-    };
-    const maybeInterval = getCleanupInterval(tree);
-    if (maybeInterval) {
-      const origClear = tree.clearMemoCache.bind(tree);
-      tree.clearMemoCache = key => {
-        origClear(key);
-        clearCleanupInterval(tree);
-      };
-    }
-    tree.clearCache = tree.clearMemoCache;
-    if (ttl) {
-      const cleanup = () => {
-        const now = Date.now();
-        cache.forEach((entry, key) => {
-          if (entry.timestamp && now - entry.timestamp > ttl) {
-            cache.delete(key);
-          }
-        });
-      };
-      const intervalId = setInterval(cleanup, ttl);
-      setCleanupInterval(tree, intervalId);
-    }
-    return tree;
-  };
-  return enhancer;
-}
-function highPerformanceMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 10000,
-    ttl: 300000,
-    equality: 'shallow',
-    enableLRU: true
-  });
-}
-function lightweightMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 100,
-    ttl: undefined,
-    equality: 'reference',
-    enableLRU: false
-  });
-}
-function shallowMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 1000,
-    ttl: 60000,
-    equality: 'shallow',
-    enableLRU: true
-  });
-}
-function clearAllCaches() {
-  resetMemoizationCaches();
-}
-function getGlobalCacheStats() {
-  let totalSize = 0;
-  let totalHits = 0;
-  let treeCount = 0;
-  memoizationCache.forEach(cache => {
-    treeCount++;
-    totalSize += cache.size();
-    cache.forEach(entry => {
-      totalHits += entry.hitCount || 0;
-    });
-  });
-  return {
-    treeCount,
-    totalSize,
-    totalHits,
-    averageCacheSize: treeCount > 0 ? totalSize / treeCount : 0
-  };
-}
-
-export { MEMOIZATION_PRESETS, clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization };

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

@@ -1,27 +0,0 @@
-const TREE_PRESETS = {};
-function createPresetConfig(preset, overrides = {}) {
-  return {
-    ...overrides
-  };
-}
-function validatePreset(preset) {
-  return typeof preset === 'string';
-}
-function getAvailablePresets() {
-  return Object.keys(TREE_PRESETS);
-}
-function combinePresets(presets, overrides = {}) {
-  let combined = {};
-  for (const p of presets) {
-    combined = {
-      ...combined,
-      ...TREE_PRESETS[p]
-    };
-  }
-  return {
-    ...combined,
-    ...overrides
-  };
-}
-
-export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset };

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/presets.js

@@ -1,20 +0,0 @@
-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 { 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(timeTravel()).with(devTools());
-    return {
-      enhancer
-    };
-  }
-  const base = signalTree(initialState, config);
-  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization)).with(timeTravel(config.timeTravel)).with(devTools(config.devTools));
-  return enhanced;
-}
-
-export { createDevTree };

package/src/enhancers/memoization/index.d.ts

@@ -1 +0,0 @@
-export * from './memoization';

package/src/enhancers/memoization/memoization.d.ts

@@ -1,54 +0,0 @@
-import type { ISignalTree } from '../../lib/types';
-export declare function cleanupMemoizationCache(): void;
-import type { MemoizationConfig, MemoizationMethods } from '../../lib/types';
-export declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
-export declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-export declare const MEMOIZATION_PRESETS: {
-    readonly selector: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 10;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly computed: {
-        readonly equality: "shallow";
-        readonly maxCacheSize: 100;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-    readonly deepState: {
-        readonly equality: "deep";
-        readonly maxCacheSize: 1000;
-        readonly enableLRU: true;
-        readonly ttl: number;
-    };
-    readonly highFrequency: {
-        readonly equality: "reference";
-        readonly maxCacheSize: 5;
-        readonly enableLRU: false;
-        readonly ttl: undefined;
-    };
-};
-export declare function selectorMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function computedMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function deepStateMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function highFrequencyMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare const withMemoization: ((config?: MemoizationConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>) & {
-    selector: typeof selectorMemoization;
-    computed: typeof computedMemoization;
-    deep: typeof deepStateMemoization;
-    fast: typeof highFrequencyMemoization;
-};
-export declare function memoization(config?: MemoizationConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function enableMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function highPerformanceMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function lightweightMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function shallowMemoization(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & MemoizationMethods<T>;
-export declare function clearAllCaches(): void;
-export declare function getGlobalCacheStats(): {
-    treeCount: number;
-    totalSize: number;
-    totalHits: number;
-    averageCacheSize: number;
-};

package/src/enhancers/memoization/memoization.types.d.ts

@@ -1 +0,0 @@
-export {};

package/src/enhancers/memoization/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';

package/src/enhancers/presets/index.d.ts

@@ -1 +0,0 @@
-export * from './lib/presets';

package/src/enhancers/presets/lib/presets.d.ts

@@ -1,8 +0,0 @@
-import { createDevTree, createMinimalTree, createProdTree } from '../../../lib/presets';
-import type { TreeConfig, TreePreset } from '../../../lib/types';
-export declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
-export declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
-export declare function validatePreset(preset: TreePreset): boolean;
-export declare function getAvailablePresets(): TreePreset[];
-export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
-export { createDevTree, createProdTree, createMinimalTree };

package/src/lib/presets.d.ts

@@ -1,34 +0,0 @@
-import type { ISignalTree, TreeConfig, BatchingConfig, MemoizationConfig, TimeTravelConfig, DevToolsConfig, BatchingMethods, MemoizationMethods, TimeTravelMethods, DevToolsMethods, EffectsMethods, EntitiesEnabled } from './types';
-export interface DevTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-    batching?: BatchingConfig;
-    memoization?: MemoizationConfig;
-    timeTravel?: TimeTravelConfig;
-    devTools?: DevToolsConfig;
-    entities?: Record<string, never>;
-}
-export interface ProdTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-    batching?: BatchingConfig;
-    memoization?: MemoizationConfig;
-    entities?: Record<string, never>;
-}
-export interface MinimalTreeConfig extends TreeConfig {
-    effects?: Record<string, never>;
-}
-export type FullSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods & DevToolsMethods;
-export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled;
-export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
-export declare function createDevTree<T extends object>(initialState: T, config?: DevTreeConfig): FullSignalTree<T>;
-export declare function createDevTree(): {
-    enhancer: <T>(tree: ISignalTree<T>) => ISignalTree<T> & EffectsMethods<T> & BatchingMethods<T> & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods<T> & DevToolsMethods;
-};
-export declare function createProdTree<T extends object>(initialState: T, config?: ProdTreeConfig): ProdSignalTree<T>;
-export declare function createMinimalTree<T extends object>(initialState: T, config?: MinimalTreeConfig): MinimalSignalTree<T>;
-export declare const devTree: typeof createDevTree;
-export declare const prodTree: typeof createProdTree;
-export declare const minimalTree: typeof createMinimalTree;
-export declare function buildTree<T extends object>(initialState: T, config?: TreeConfig): {
-    add<R>(enhancer: (t: ISignalTree<T>) => R): any;
-    done(): ISignalTree<T>;
-};