@signaltree/core 4.0.7 → 4.0.8

package/dist/enhancers/memoization/index.js

@@ -0,0 +1,570 @@
+import { deepEqual, LRUCache } from '@signaltree/shared';
+import '@angular/core';
+
+/** Symbol to mark callable signals - using global symbol to match across files */
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
+/**
+ * Checks if a value is a node accessor created by makeNodeAccessor
+ */
+function isNodeAccessor(value) {
+    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
+}
+
+// Global memoization cache with size limits and TTL
+const MAX_CACHE_SIZE = 1000;
+const DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes
+// Use Map for global cache management (we keep iteration for diagnostics).
+// Note: we avoid starting any global timers at module import to prevent
+// background timer leaks in long-running processes; cleanup is performed
+// opportunistically inside hot paths (probabilistic) or via explicit APIs.
+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 {
+        /* best-effort cleanup */
+    }
+    setCleanupInterval(tree);
+}
+function resetMemoizationCaches() {
+    memoizationCache.forEach((cache, tree) => {
+        cache.clear();
+        clearCleanupInterval(tree);
+    });
+    memoizationCache.clear();
+}
+/**
+ * Cleanup the cache interval on app shutdown
+ */
+function cleanupMemoizationCache() {
+    resetMemoizationCaches();
+}
+/**
+ * Shallow equality check for dependency comparison
+ * Much faster than deep equality for objects with primitive values
+ * Optimized: Uses for...in instead of Object.keys() to avoid array allocations
+ */
+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;
+        // Count properties in objA and check equality
+        let countA = 0;
+        for (const key in objA) {
+            if (!Object.prototype.hasOwnProperty.call(objA, key))
+                continue;
+            countA++;
+            // Early exit if key missing or value different
+            if (!(key in objB) || objA[key] !== objB[key])
+                return false;
+        }
+        // Count properties in objB to ensure same number
+        let countB = 0;
+        for (const key in objB) {
+            if (Object.prototype.hasOwnProperty.call(objB, key))
+                countB++;
+        }
+        return countA === countB;
+    }
+    return false;
+}
+/**
+ * Generate cache key for memoization
+ */
+function generateCacheKey(fn, args) {
+    try {
+        return `${fn.name || 'anonymous'}_${JSON.stringify(args)}`;
+    }
+    catch {
+        // Fallback for cyclic or non-serializable args
+        return `${fn.name || 'anonymous'}_${args.length}`;
+    }
+}
+/**
+ * Get equality function based on strategy
+ */
+function getEqualityFn(strategy) {
+    switch (strategy) {
+        case 'shallow':
+            return shallowEqual;
+        case 'reference':
+            return (a, b) => a === b;
+        case 'deep':
+        default:
+            return deepEqual;
+    }
+}
+/**
+ * Memoization function that caches expensive computations with enhanced cache management
+ */
+function memoize(fn, keyFn, config = {}) {
+    const maxSize = config.maxCacheSize ?? MAX_CACHE_SIZE;
+    const ttl = config.ttl ?? DEFAULT_TTL;
+    // Use shallow equality by default to avoid expensive deep comparisons
+    const equality = getEqualityFn(config.equality ?? 'shallow');
+    // Disable LRU by default to avoid hidden CPU overhead
+    const enableLRU = config.enableLRU ?? false;
+    const cache = createMemoCacheStore(maxSize, enableLRU);
+    const cleanExpiredEntries = () => {
+        if (!ttl)
+            return; // Skip if TTL is disabled
+        const now = Date.now();
+        cache.forEach((entry, key) => {
+            if (entry.timestamp && now - entry.timestamp > ttl) {
+                cache.delete(key);
+            }
+        });
+    };
+    return (...args) => {
+        // Probabilistic cleanup to avoid paying cleanup cost on every hot call.
+        // Runs ~1% of the time when TTL is enabled.
+        if (ttl && Math.random() < 0.01) {
+            cleanExpiredEntries();
+        }
+        const key = keyFn
+            ? keyFn(...args)
+            : generateCacheKey(fn, args);
+        const cached = cache.get(key);
+        // If using custom key function, trust the key; otherwise check equality
+        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;
+    };
+}
+/**
+ * High-performance memoization function optimized for speed
+ * Uses shallow equality and minimal cache management overhead
+ */
+function memoizeShallow(fn, keyFn) {
+    return memoize(fn, keyFn, {
+        equality: 'shallow',
+        enableLRU: false,
+        ttl: undefined,
+        maxCacheSize: 100,
+    });
+}
+/**
+ * Lightweight memoization function with reference equality only
+ * Maximum performance for scenarios where exact reference matches are sufficient
+ */
+function memoizeReference(fn, keyFn) {
+    return memoize(fn, keyFn, {
+        equality: 'reference',
+        enableLRU: false,
+        ttl: undefined,
+        maxCacheSize: 50,
+    });
+}
+/**
+ * Preset memoization configurations optimized for common use cases
+ * These presets are the same ones used in SignalTree's benchmarks
+ */
+const MEMOIZATION_PRESETS = {
+    /**
+     * Optimized for selectors and frequently-accessed computed values
+     * - Fast reference-only equality checks (~0.3μs)
+     * - Small cache (10 entries) for minimal overhead
+     * - No LRU management (eliminates bookkeeping cost)
+     * - Best for: Selectors, derived values, stable references
+     */
+    selector: {
+        equality: 'reference',
+        maxCacheSize: 10,
+        enableLRU: false,
+        ttl: undefined,
+    },
+    /**
+     * Balanced configuration for general computed values
+     * - Shallow equality checks (~5-15μs) for object comparisons
+     * - Medium cache (100 entries) for reasonable coverage
+     * - No LRU (good performance/memory balance)
+     * - Best for: General computations, objects with primitives
+     */
+    computed: {
+        equality: 'shallow',
+        maxCacheSize: 100,
+        enableLRU: false,
+        ttl: undefined,
+    },
+    /**
+     * Thorough configuration for complex nested state
+     * - Deep equality checks (~50-200μs) for nested objects
+     * - Large cache (1000 entries) for complex scenarios
+     * - LRU enabled for intelligent cache management
+     * - 5-minute TTL to prevent stale data
+     * - Best for: Complex nested objects, thorough comparisons needed
+     */
+    deepState: {
+        equality: 'deep',
+        maxCacheSize: 1000,
+        enableLRU: true,
+        ttl: 5 * 60 * 1000,
+    },
+    /**
+     * Minimal overhead for high-frequency operations
+     * - Reference-only equality (fastest possible)
+     * - Tiny cache (5 entries) for minimal memory
+     * - No bells and whistles
+     * - Best for: Hot paths, microseconds matter, immutable data
+     */
+    highFrequency: {
+        equality: 'reference',
+        maxCacheSize: 5,
+        enableLRU: false,
+        ttl: undefined,
+    },
+};
+/**
+ * Convenience function: Memoization optimized for selectors
+ * Uses reference equality and small cache for maximum performance
+ *
+ * @example
+ * ```typescript
+ * const tree = signalTree(state).with(withSelectorMemoization());
+ * const activeUsers = computed(() =>
+ *   tree.state.users().filter(u => u.active)
+ * );
+ * ```
+ */
+function withSelectorMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.selector);
+}
+/**
+ * Convenience function: Memoization optimized for computed values
+ * Uses shallow equality for balanced performance
+ *
+ * @example
+ * ```typescript
+ * const tree = signalTree(state).with(withComputedMemoization());
+ * const metrics = computed(() =>
+ *   calculateExpensiveMetrics(tree.state.data())
+ * );
+ * ```
+ */
+function withComputedMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.computed);
+}
+/**
+ * Convenience function: Memoization for complex nested state
+ * Uses deep equality and LRU management
+ *
+ * @example
+ * ```typescript
+ * const tree = signalTree(state).with(withDeepStateMemoization());
+ * // Handles complex nested object comparisons
+ * ```
+ */
+function withDeepStateMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.deepState);
+}
+/**
+ * Convenience function: Minimal memoization for hot paths
+ * Maximum performance with minimal overhead
+ *
+ * @example
+ * ```typescript
+ * const tree = signalTree(state).with(withHighFrequencyMemoization());
+ * // For operations called thousands of times per second
+ * ```
+ */
+function withHighFrequencyMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.highFrequency);
+}
+/**
+ * Enhances a SignalTree with memoization capabilities
+ * Uses unconstrained recursive typing - no limitations on T
+ */
+function withMemoization(config = {}) {
+    const { enabled = true, maxCacheSize = 1000, ttl, 
+    // Default behavior: deep equality and LRU enabled to preserve
+    // memoization semantics expected by existing consumers/tests.
+    equality = 'deep', enableLRU = true, } = config;
+    return (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.memoizedUpdate = (updater) => {
+                const currentState = originalTreeCall();
+                const result = updater(currentState);
+                applyUpdateResult(result);
+            };
+            memoTree.clearMemoCache = () => {
+                /* no-op when memoization disabled */
+            };
+            memoTree.getCacheStats = () => ({
+                size: 0,
+                hitRate: 0,
+                totalHits: 0,
+                totalMisses: 0,
+                keys: [],
+            });
+            return memoTree;
+        }
+        // Initialize cache for this tree
+        const cache = createMemoCacheStore(maxCacheSize, enableLRU);
+        memoizationCache.set(tree, cache);
+        const equalityFn = getEqualityFn(equality);
+        // Add memoized update method
+        tree.memoizedUpdate = (updater, cacheKey) => {
+            const currentState = originalTreeCall();
+            // Determine cache key: prefer explicit keyFn-like behavior if not provided
+            const key = cacheKey ||
+                generateCacheKey(updater, [
+                    currentState,
+                ]);
+            // Check cache
+            const cached = cache.get(key);
+            if (cached && equalityFn(cached.deps, [currentState])) {
+                // Apply cached result - use callable interface to set the partial update
+                const cachedUpdate = cached.value;
+                applyUpdateResult(cachedUpdate);
+                return;
+            }
+            // Compute new result
+            const result = updater(currentState);
+            // Cache the result
+            cache.set(key, {
+                value: result,
+                deps: [currentState],
+                timestamp: Date.now(),
+                hitCount: 1,
+            });
+            // Apply update using callable interface
+            applyUpdateResult(result);
+        };
+        // Add cache management methods
+        tree.clearMemoCache = (key) => {
+            if (key) {
+                cache.delete(key);
+            }
+            else {
+                cache.clear();
+            }
+        };
+        tree.getCacheStats = () => {
+            let totalHits = 0;
+            let totalMisses = 0;
+            cache.forEach((entry) => {
+                totalHits += entry.hitCount || 0;
+                // For simplicity, we'll estimate misses as half of hits
+                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()),
+            };
+        };
+        // If we created a periodic cleanup for this tree, ensure callers can clear it
+        const maybeInterval = getCleanupInterval(tree);
+        if (maybeInterval) {
+            // When the tree cache is cleared, also clear the interval
+            const origClear = tree.clearMemoCache.bind(tree);
+            tree.clearMemoCache = (key) => {
+                origClear(key);
+                clearCleanupInterval(tree);
+            };
+        }
+        // Intentionally do NOT attach memoization helpers to `tree.$` to preserve
+        // the "callable-only nodes" invariant for serialization safety.
+        // Clean up expired entries if TTL is set
+        if (ttl) {
+            const cleanup = () => {
+                const now = Date.now();
+                cache.forEach((entry, key) => {
+                    if (entry.timestamp && now - entry.timestamp > ttl) {
+                        cache.delete(key);
+                    }
+                });
+            };
+            // Run cleanup periodically
+            const intervalId = setInterval(cleanup, ttl);
+            // Store interval ID for cleanup (handle Node.js vs browser differences)
+            setCleanupInterval(tree, intervalId);
+        }
+        return tree;
+    };
+}
+/**
+ * Convenience function to enable memoization with default settings
+ * Uses unconstrained recursive typing - no limitations on T
+ */
+function enableMemoization() {
+    return withMemoization({ enabled: true });
+}
+/**
+ * High-performance memoization with aggressive caching
+ * Uses unconstrained recursive typing - no limitations on T
+ */
+function withHighPerformanceMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 10000,
+        ttl: 300000, // 5 minutes
+        equality: 'shallow', // Faster than deep equality
+        enableLRU: true,
+    });
+}
+/**
+ * Lightweight memoization optimized for performance-critical scenarios
+ * Disables expensive cache management features for maximum speed
+ */
+function withLightweightMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 100, // Smaller cache to reduce management overhead
+        ttl: undefined, // No TTL to avoid timestamp checks
+        equality: 'reference', // Fastest equality check
+        enableLRU: false, // No LRU to avoid hit count tracking
+    });
+}
+/**
+ * Shallow equality memoization for objects with primitive values
+ * Good balance between performance and correctness
+ */
+function withShallowMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 1000,
+        ttl: 60000, // 1 minute
+        equality: 'shallow',
+        enableLRU: true,
+    });
+}
+/**
+ * Clear all memoization caches
+ */
+function clearAllCaches() {
+    resetMemoizationCaches();
+}
+/**
+ * Get global cache statistics
+ */
+function getGlobalCacheStats() {
+    // Note: We keep a Map keyed by tree objects to allow listing and diagnostics
+    // (WeakMap would prevent traversal). This function summarizes those diagnostics.
+    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, cleanupMemoizationCache, clearAllCaches, enableMemoization, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization };
+//# sourceMappingURL=index.js.map

package/dist/enhancers/memoization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../packages/core/src/lib/utils.ts","../../../../../../../packages/core/src/enhancers/memoization/lib/memoization.ts"],"sourcesContent":[null,null],"names":[],"mappings":"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"}

package/dist/enhancers/memoization/types/packages/core/src/enhancers/batching/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/batching';
+//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/memoization/types/packages/core/src/enhancers/batching/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/enhancers/memoization/types/packages/core/src/enhancers/batching/jest.config.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    displayName: string;
+    preset: string;
+    setupFilesAfterEnv: string[];
+    coverageDirectory: string;
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': (string | {
+            tsconfig: string;
+            stringifyContentPathRegex: string;
+        })[];
+    };
+    transformIgnorePatterns: string[];
+    snapshotSerializers: string[];
+};
+export default _default;
+//# sourceMappingURL=jest.config.d.ts.map

package/dist/enhancers/memoization/types/packages/core/src/enhancers/batching/jest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/jest.config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wBAoBE"}