@signaltree/core 4.0.13 → 4.0.15

package/dist/enhancers/time-travel/jest.config.js

@@ -0,0 +1,21 @@
+export default {
+    displayName: 'time-travel',
+    preset: '../../../jest.preset.js',
+    setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+    coverageDirectory: '../../../coverage/packages/core/enhancers/time-travel',
+    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/time-travel/lib/time-travel.d.ts

@@ -0,0 +1,36 @@
+import type { SignalTree } from '../../../lib/types';
+export interface TimeTravelEntry<T> {
+    state: T;
+    timestamp: number;
+    action: string;
+    payload?: unknown;
+}
+export interface TimeTravelInterface<T> {
+    undo(): boolean;
+    redo(): boolean;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo(index: number): boolean;
+    getCurrentIndex(): number;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}
+export interface TimeTravelConfig {
+    maxHistorySize?: number;
+    includePayload?: boolean;
+    actionNames?: {
+        update?: string;
+        set?: string;
+        batch?: string;
+        [key: string]: string | undefined;
+    };
+}
+export declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+export declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+export declare function getTimeTravel<T>(tree: SignalTree<T> & {
+    __timeTravel?: TimeTravelInterface<T>;
+}): TimeTravelInterface<T> | undefined;

package/dist/enhancers/time-travel/lib/time-travel.js

@@ -0,0 +1,192 @@
+import { deepClone, deepEqual } from './utils';
+class TimeTravelManager {
+    tree;
+    config;
+    restoreStateFn;
+    history = [];
+    currentIndex = -1;
+    maxHistorySize;
+    includePayload;
+    actionNames;
+    constructor(tree, config = {}, restoreStateFn) {
+        this.tree = tree;
+        this.config = config;
+        this.restoreStateFn = restoreStateFn;
+        this.maxHistorySize = config.maxHistorySize ?? 50;
+        this.includePayload = config.includePayload ?? true;
+        this.actionNames = {
+            update: 'UPDATE',
+            set: 'SET',
+            batch: 'BATCH',
+            ...config.actionNames,
+        };
+        this.addEntry('INIT', this.tree());
+    }
+    addEntry(action, state, payload) {
+        if (this.currentIndex < this.history.length - 1) {
+            this.history = this.history.slice(0, this.currentIndex + 1);
+        }
+        const entry = {
+            state: deepClone(state),
+            timestamp: Date.now(),
+            action: this.actionNames[action] || action,
+            ...(this.includePayload && payload !== undefined && { payload }),
+        };
+        this.history.push(entry);
+        this.currentIndex = this.history.length - 1;
+        if (this.history.length > this.maxHistorySize) {
+            this.history.shift();
+            this.currentIndex--;
+        }
+    }
+    undo() {
+        if (!this.canUndo()) {
+            return false;
+        }
+        this.currentIndex--;
+        const entry = this.history[this.currentIndex];
+        this.restoreState(entry.state);
+        return true;
+    }
+    redo() {
+        if (!this.canRedo()) {
+            return false;
+        }
+        this.currentIndex++;
+        const entry = this.history[this.currentIndex];
+        this.restoreState(entry.state);
+        return true;
+    }
+    getHistory() {
+        return this.history.map((entry) => ({
+            ...entry,
+            state: deepClone(entry.state),
+        }));
+    }
+    resetHistory() {
+        const currentState = this.tree();
+        this.history = [];
+        this.currentIndex = -1;
+        this.addEntry('RESET', currentState);
+    }
+    jumpTo(index) {
+        if (index < 0 || index >= this.history.length) {
+            return false;
+        }
+        this.currentIndex = index;
+        const entry = this.history[index];
+        this.restoreState(entry.state);
+        return true;
+    }
+    getCurrentIndex() {
+        return this.currentIndex;
+    }
+    canUndo() {
+        return this.currentIndex > 0;
+    }
+    canRedo() {
+        return this.currentIndex < this.history.length - 1;
+    }
+    restoreState(state) {
+        if (this.restoreStateFn) {
+            this.restoreStateFn(state);
+        }
+        else {
+            this.tree(state);
+        }
+    }
+}
+export function withTimeTravel(config = {}) {
+    return (tree) => {
+        const originalTreeCall = tree.bind(tree);
+        let isRestoring = false;
+        const timeTravelManager = new TimeTravelManager(tree, config, (state) => {
+            isRestoring = true;
+            try {
+                originalTreeCall(state);
+            }
+            finally {
+                isRestoring = false;
+            }
+        });
+        const enhancedTree = function (...args) {
+            if (args.length === 0) {
+                return originalTreeCall();
+            }
+            else {
+                if (isRestoring) {
+                    if (args.length === 1) {
+                        const arg = args[0];
+                        if (typeof arg === 'function') {
+                            return originalTreeCall(arg);
+                        }
+                        else {
+                            return originalTreeCall(arg);
+                        }
+                    }
+                    return;
+                }
+                const beforeState = originalTreeCall();
+                let result;
+                if (args.length === 1) {
+                    const arg = args[0];
+                    if (typeof arg === 'function') {
+                        result = originalTreeCall(arg);
+                    }
+                    else {
+                        result = originalTreeCall(arg);
+                    }
+                }
+                const afterState = originalTreeCall();
+                const statesEqual = deepEqual(beforeState, afterState);
+                if (!statesEqual) {
+                    timeTravelManager.addEntry('update', afterState);
+                }
+                return result;
+            }
+        };
+        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.undo = () => {
+            timeTravelManager.undo();
+        };
+        enhancedTree.redo = () => {
+            timeTravelManager.redo();
+        };
+        enhancedTree.getHistory = () => timeTravelManager.getHistory();
+        enhancedTree.resetHistory =
+            () => {
+                timeTravelManager.resetHistory();
+            };
+        enhancedTree.jumpTo = (index) => {
+            timeTravelManager.jumpTo(index);
+        };
+        enhancedTree.canUndo = () => timeTravelManager.canUndo();
+        enhancedTree.canRedo = () => timeTravelManager.canRedo();
+        enhancedTree.getCurrentIndex =
+            () => timeTravelManager.getCurrentIndex();
+        return Object.assign(enhancedTree, {
+            __timeTravel: timeTravelManager,
+        });
+    };
+}
+export function enableTimeTravel(maxHistorySize) {
+    return withTimeTravel({ maxHistorySize });
+}
+export function getTimeTravel(tree) {
+    return tree.__timeTravel;
+}

package/dist/enhancers/time-travel/lib/utils.d.ts

@@ -0,0 +1 @@
+export { deepClone, deepEqual } from '@signaltree/shared';

package/dist/enhancers/time-travel/lib/utils.js

@@ -0,0 +1 @@
+export { deepClone, deepEqual } from '@signaltree/shared';

package/dist/enhancers/time-travel/test-setup.d.ts

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

package/dist/enhancers/time-travel/test-setup.js

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

package/dist/enhancers/types.d.ts

@@ -0,0 +1,105 @@
+export interface BatchingConfig {
+    maxBatchSize?: number;
+    debounceMs?: number;
+    flushOnMicrotask?: boolean;
+}
+export interface BatchUpdate<T = unknown> {
+    path: string[];
+    value: T;
+    timestamp: number;
+}
+export interface ComputedSignal<T> {
+    (): T;
+    readonly value: T;
+}
+export interface ComputedConfig {
+    lazy?: boolean;
+    memoize?: boolean;
+}
+export interface MiddlewareConfig {
+    beforeUpdate?: (path: string[], value: unknown) => void | boolean;
+    afterUpdate?: (path: string[], value: unknown, previousValue: unknown) => void;
+    beforeRead?: (path: string[]) => void;
+    afterRead?: (path: string[], value: unknown) => void;
+}
+export interface MiddlewareContext {
+    path: string[];
+    value: unknown;
+    previousValue?: unknown;
+    operation: 'read' | 'write';
+}
+export interface MemoizationConfig {
+    maxSize?: number;
+    ttl?: number;
+    strategy?: 'lru' | 'fifo' | 'lfu';
+}
+export interface MemoizedFunction<T extends (...args: never[]) => unknown> {
+    (...args: Parameters<T>): ReturnType<T>;
+    clear(): void;
+    stats(): {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+}
+export interface TimeTravelConfig {
+    maxHistorySize?: number;
+    enableCompression?: boolean;
+}
+export interface TimeTravelState {
+    canUndo: boolean;
+    canRedo: boolean;
+    historySize: number;
+    currentIndex: number;
+}
+export interface DevToolsConfig {
+    name?: string;
+    enabled?: boolean;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+export interface DevToolsAction {
+    type: string;
+    payload?: unknown;
+    timestamp: number;
+    source: string;
+}
+export interface PresetConfig {
+    name: string;
+    enhancers: unknown[];
+    config?: Record<string, unknown>;
+}
+export interface EntityConfig {
+    idField?: string;
+    indexes?: string[];
+    relations?: Record<string, string>;
+}
+export interface EntityCollection<T = unknown> {
+    add(entity: T): void;
+    remove(id: string | number): boolean;
+    update(id: string | number, updates: Partial<T>): boolean;
+    get(id: string | number): T | undefined;
+    find(predicate: (entity: T) => boolean): T | undefined;
+    filter(predicate: (entity: T) => boolean): T[];
+    count(): number;
+}
+export interface AsyncConfig {
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export interface AsyncAction<T = unknown> {
+    execute(): Promise<T>;
+    cancel(): void;
+    status: 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
+}
+export interface SerializationConfig {
+    includeComputed?: boolean;
+    includeMeta?: boolean;
+    customSerializers?: Record<string, (value: unknown) => unknown>;
+}
+export interface SerializedState {
+    version: string;
+    timestamp: number;
+    data: unknown;
+    meta?: Record<string, unknown>;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { signalTree } from './lib/signal-tree';
+export type { SignalTree, TreeNode, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, Middleware, PerformanceMetrics, EntityHelpers, AsyncActionConfig, AsyncAction, TimeTravelEntry, } from './lib/types';
+export { equal, deepEqual, isNodeAccessor, isAnySignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
+export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
+export { ENHANCER_META } from './lib/types';
+export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
+export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
+export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
+export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
+export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
+export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
+export { withMiddleware, createLoggingMiddleware, createValidationMiddleware, } from './enhancers/middleware/lib/middleware';
+export { createAsyncOperation, trackAsync, } from './enhancers/middleware/lib/async-helpers';
+export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
+export { computedEnhancer, createComputed, type ComputedConfig, type ComputedSignal, type ComputedSignalTree, } from './enhancers/computed/lib/computed';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';

package/dist/index.js

@@ -0,0 +1,16 @@
+export { signalTree } from './lib/signal-tree';
+export { equal, deepEqual, isNodeAccessor, isAnySignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
+export { SecurityValidator, SecurityPresets, } from './lib/security/security-validator';
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
+export { ENHANCER_META } from './lib/types';
+export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
+export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
+export { withTimeTravel, enableTimeTravel, getTimeTravel, } from './enhancers/time-travel/lib/time-travel';
+export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
+export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
+export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
+export { withMiddleware, createLoggingMiddleware, createValidationMiddleware, } from './enhancers/middleware/lib/middleware';
+export { createAsyncOperation, trackAsync, } from './enhancers/middleware/lib/async-helpers';
+export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
+export { computedEnhancer, createComputed, } from './enhancers/computed/lib/computed';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';

package/dist/lib/constants.d.ts

@@ -0,0 +1,42 @@
+export declare const SIGNAL_TREE_CONSTANTS: {
+    readonly MAX_PATH_CACHE_SIZE: 1000;
+    readonly LAZY_THRESHOLD: 50;
+    readonly ESTIMATE_MAX_DEPTH: 3;
+    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
+    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
+    readonly DEFAULT_CACHE_SIZE: 100;
+    readonly DEFAULT_BATCH_SIZE: 10;
+};
+export declare const SIGNAL_TREE_MESSAGES: Readonly<{
+    readonly NULL_OR_UNDEFINED: "null/undefined";
+    readonly CIRCULAR_REF: "circular ref";
+    readonly UPDATER_INVALID: "updater invalid";
+    readonly LAZY_FALLBACK: "lazy fallback";
+    readonly SIGNAL_CREATION_FAILED: "signal creation failed";
+    readonly UPDATE_PATH_NOT_FOUND: "update path not found";
+    readonly UPDATE_FAILED: "update failed";
+    readonly ROLLBACK_FAILED: "rollback failed";
+    readonly CLEANUP_ERROR: "cleanup error";
+    readonly PRESET_UNKNOWN: "unknown preset";
+    readonly STRATEGY_SELECTION: "strategy select";
+    readonly TREE_DESTROYED: "destroyed";
+    readonly UPDATE_TRANSACTION: "update tx";
+    readonly BATCH_NOT_ENABLED: "batching disabled";
+    readonly MEMOIZE_NOT_ENABLED: "memoize disabled";
+    readonly MIDDLEWARE_NOT_AVAILABLE: "middleware missing";
+    readonly ENTITY_HELPERS_NOT_AVAILABLE: "entity helpers missing";
+    readonly ASYNC_ACTIONS_NOT_AVAILABLE: "async actions missing";
+    readonly TIME_TRAVEL_NOT_AVAILABLE: "time travel missing";
+    readonly OPTIMIZE_NOT_AVAILABLE: "optimize missing";
+    readonly UPDATE_OPTIMIZED_NOT_AVAILABLE: "update optimized missing";
+    readonly CACHE_NOT_AVAILABLE: "cache missing";
+    readonly PERFORMANCE_NOT_ENABLED: "performance disabled";
+    readonly ENHANCER_ORDER_FAILED: "enhancer order failed";
+    readonly ENHANCER_CYCLE_DETECTED: "enhancer cycle";
+    readonly ENHANCER_REQUIREMENT_MISSING: "enhancer req missing";
+    readonly ENHANCER_PROVIDES_MISSING: "enhancer provides missing";
+    readonly ENHANCER_FAILED: "enhancer failed";
+    readonly ENHANCER_NOT_FUNCTION: "enhancer not function";
+    readonly EFFECT_NO_CONTEXT: "no angular context";
+    readonly SUBSCRIBE_NO_CONTEXT: "no angular context";
+}>;

package/dist/lib/constants.js

@@ -0,0 +1,61 @@
+import { DEFAULT_PATH_CACHE_SIZE } from '@signaltree/shared';
+export const SIGNAL_TREE_CONSTANTS = {
+    MAX_PATH_CACHE_SIZE: DEFAULT_PATH_CACHE_SIZE,
+    LAZY_THRESHOLD: 50,
+    ESTIMATE_MAX_DEPTH: 3,
+    ESTIMATE_SAMPLE_SIZE_ARRAY: 3,
+    ESTIMATE_SAMPLE_SIZE_OBJECT: 5,
+    DEFAULT_CACHE_SIZE: 100,
+    DEFAULT_BATCH_SIZE: 10,
+};
+const DEV_MESSAGES = {
+    NULL_OR_UNDEFINED: 'null/undefined',
+    CIRCULAR_REF: 'circular ref',
+    UPDATER_INVALID: 'updater invalid',
+    LAZY_FALLBACK: 'lazy fallback',
+    SIGNAL_CREATION_FAILED: 'signal creation failed',
+    UPDATE_PATH_NOT_FOUND: 'update path not found',
+    UPDATE_FAILED: 'update failed',
+    ROLLBACK_FAILED: 'rollback failed',
+    CLEANUP_ERROR: 'cleanup error',
+    PRESET_UNKNOWN: 'unknown preset',
+    STRATEGY_SELECTION: 'strategy select',
+    TREE_DESTROYED: 'destroyed',
+    UPDATE_TRANSACTION: 'update tx',
+    BATCH_NOT_ENABLED: 'batching disabled',
+    MEMOIZE_NOT_ENABLED: 'memoize disabled',
+    MIDDLEWARE_NOT_AVAILABLE: 'middleware missing',
+    ENTITY_HELPERS_NOT_AVAILABLE: 'entity helpers missing',
+    ASYNC_ACTIONS_NOT_AVAILABLE: 'async actions missing',
+    TIME_TRAVEL_NOT_AVAILABLE: 'time travel missing',
+    OPTIMIZE_NOT_AVAILABLE: 'optimize missing',
+    UPDATE_OPTIMIZED_NOT_AVAILABLE: 'update optimized missing',
+    CACHE_NOT_AVAILABLE: 'cache missing',
+    PERFORMANCE_NOT_ENABLED: 'performance disabled',
+    ENHANCER_ORDER_FAILED: 'enhancer order failed',
+    ENHANCER_CYCLE_DETECTED: 'enhancer cycle',
+    ENHANCER_REQUIREMENT_MISSING: 'enhancer req missing',
+    ENHANCER_PROVIDES_MISSING: 'enhancer provides missing',
+    ENHANCER_FAILED: 'enhancer failed',
+    ENHANCER_NOT_FUNCTION: 'enhancer not function',
+    EFFECT_NO_CONTEXT: 'no angular context',
+    SUBSCRIBE_NO_CONTEXT: 'no angular context',
+};
+const PROD_MESSAGES = (() => {
+    const out = {};
+    let i = 0;
+    for (const k of Object.keys(DEV_MESSAGES)) {
+        out[k] = String(i++);
+    }
+    return out;
+})();
+const _isProdByEnv = Boolean(typeof globalThis === 'object' &&
+    globalThis !== null &&
+    'process' in globalThis &&
+    typeof globalThis.process === 'object' &&
+    'env' in globalThis.process &&
+    globalThis.process.env.NODE_ENV === 'production');
+const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
+export const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev
+    ? DEV_MESSAGES
+    : PROD_MESSAGES);

package/dist/lib/memory/memory-manager.d.ts

@@ -0,0 +1,30 @@
+import type { WritableSignal } from '@angular/core';
+export interface MemoryStats {
+    cachedSignals: number;
+    cleanedUpSignals: number;
+    peakCachedSignals: number;
+    manualDisposes: number;
+    estimatedMemoryBytes: number;
+}
+export interface MemoryManagerConfig {
+    enableAutoCleanup?: boolean;
+    debugMode?: boolean;
+    onCleanup?: (path: string, stats: MemoryStats) => void;
+}
+export declare class SignalMemoryManager {
+    private cache;
+    private registry;
+    private config;
+    private stats;
+    constructor(config?: MemoryManagerConfig);
+    cacheSignal<T>(path: string, signal: WritableSignal<T>): void;
+    getSignal(path: string): WritableSignal<unknown> | undefined;
+    hasSignal(path: string): boolean;
+    removeSignal(path: string): boolean;
+    private handleCleanup;
+    getStats(): MemoryStats;
+    dispose(): void;
+    getCachedPaths(): string[];
+    clearStale(): number;
+    resetStats(): void;
+}