@signaltree/core 4.0.12 → 4.0.15

package/dist/enhancers/memoization/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'memoization',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/memoization',
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': [
+            'jest-preset-angular',
+            {
+                tsconfig: '<rootDir>/tsconfig.spec.json',
+                stringifyContentPathRegex: '\\.(html|svg)$',
+            },
+        ],
+    },
+    transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+    snapshotSerializers: [
+        'jest-preset-angular/build/serializers/no-ng-attributes',
+        'jest-preset-angular/build/serializers/ng-snapshot',
+        'jest-preset-angular/build/serializers/html-comment',
+    ],
+};

package/dist/enhancers/memoization/lib/memoization.d.ts

@@ -0,0 +1,65 @@
+import type { SignalTree } from '../../../lib/types';
+export interface MemoizedSignalTree<T> extends SignalTree<T> {
+    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
+    clearMemoCache: (key?: string) => void;
+    getCacheStats: () => {
+        size: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        keys: string[];
+    };
+}
+export declare function cleanupMemoizationCache(): void;
+export interface MemoizationConfig {
+    enabled?: boolean;
+    maxCacheSize?: number;
+    ttl?: number;
+    equality?: 'deep' | 'shallow' | 'reference';
+    enableLRU?: boolean;
+}
+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 withSelectorMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withComputedMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withDeepStateMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withHighFrequencyMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withMemoization<T>(config?: MemoizationConfig): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function enableMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withHighPerformanceMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withLightweightMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withShallowMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function clearAllCaches(): void;
+export declare function getGlobalCacheStats(): {
+    treeCount: number;
+    totalSize: number;
+    totalHits: number;
+    averageCacheSize: number;
+};

package/dist/enhancers/memoization/lib/memoization.js

@@ -0,0 +1,391 @@
+import { deepEqual, LRUCache } from '@signaltree/shared';
+import { isNodeAccessor } from '../../../lib/utils';
+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();
+}
+export function cleanupMemoizationCache() {
+    resetMemoizationCaches();
+}
+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;
+    }
+}
+export 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;
+    };
+}
+export function memoizeShallow(fn, keyFn) {
+    return memoize(fn, keyFn, {
+        equality: 'shallow',
+        enableLRU: false,
+        ttl: undefined,
+        maxCacheSize: 100,
+    });
+}
+export function memoizeReference(fn, keyFn) {
+    return memoize(fn, keyFn, {
+        equality: 'reference',
+        enableLRU: false,
+        ttl: undefined,
+        maxCacheSize: 50,
+    });
+}
+export 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,
+    },
+};
+export function withSelectorMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.selector);
+}
+export function withComputedMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.computed);
+}
+export function withDeepStateMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.deepState);
+}
+export function withHighFrequencyMemoization() {
+    return withMemoization(MEMOIZATION_PRESETS.highFrequency);
+}
+export function withMemoization(config = {}) {
+    const { enabled = true, maxCacheSize = 1000, ttl, 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 = () => {
+            };
+            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);
+        };
+        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;
+                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);
+            };
+        }
+        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;
+    };
+}
+export function enableMemoization() {
+    return withMemoization({ enabled: true });
+}
+export function withHighPerformanceMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 10000,
+        ttl: 300000,
+        equality: 'shallow',
+        enableLRU: true,
+    });
+}
+export function withLightweightMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 100,
+        ttl: undefined,
+        equality: 'reference',
+        enableLRU: false,
+    });
+}
+export function withShallowMemoization() {
+    return withMemoization({
+        enabled: true,
+        maxCacheSize: 1000,
+        ttl: 60000,
+        equality: 'shallow',
+        enableLRU: true,
+    });
+}
+export function clearAllCaches() {
+    resetMemoizationCaches();
+}
+export 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,
+    };
+}

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

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

package/dist/enhancers/memoization/test-setup.js

@@ -0,0 +1,5 @@
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/zone';
+setupZoneTestEnv({
+    errorOnUnknownElements: true,
+    errorOnUnknownProperties: true,
+});

package/dist/enhancers/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/middleware';
+export * from './lib/async-helpers';

package/dist/enhancers/middleware/index.js

@@ -0,0 +1,2 @@
+export * from './lib/middleware';
+export * from './lib/async-helpers';

package/dist/enhancers/middleware/jest.config.d.ts

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

package/dist/enhancers/middleware/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'middleware',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/middleware',
+    transform: {
+        '^.+\\.(ts|mjs|js|html)$': [
+            'jest-preset-angular',
+            {
+                tsconfig: '<rootDir>/tsconfig.spec.json',
+                stringifyContentPathRegex: '\\.(html|svg)$',
+            },
+        ],
+    },
+    transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+    snapshotSerializers: [
+        'jest-preset-angular/build/serializers/no-ng-attributes',
+        'jest-preset-angular/build/serializers/ng-snapshot',
+        'jest-preset-angular/build/serializers/html-comment',
+    ],
+};

package/dist/enhancers/middleware/lib/async-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { SignalTree } from '../../../lib/types';
+export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
+export declare function trackAsync<T>(operation: () => Promise<T>): {
+    pending: import("@angular/core").Signal<boolean>;
+    error: import("@angular/core").Signal<Error | null>;
+    result: import("@angular/core").Signal<T | null>;
+    execute: () => Promise<T>;
+};

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

@@ -0,0 +1,85 @@
+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;
+            }
+        }
+        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) {
+                    void 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);
+            }
+        },
+    };
+}

package/dist/enhancers/middleware/lib/middleware.d.ts

@@ -0,0 +1,11 @@
+import type { Middleware, SignalTree } from '../../../lib/types';
+export declare function withMiddleware<T>(middlewares?: Middleware<T>[]): (tree: SignalTree<T>) => SignalTree<T>;
+export declare function createLoggingMiddleware<T>(treeName: string): Middleware<T>;
+export declare function createPerformanceMiddleware<T>(): Middleware<T>;
+export declare function createValidationMiddleware<T>(validator: (state: T) => string | null): Middleware<T>;
+export declare function createPersistenceMiddleware<T>(config: {
+    key: string;
+    storage?: Storage;
+    debounceMs?: number;
+    actions?: string[];
+}): Middleware<T>;