@signaltree/core 4.0.7 → 4.0.8

package/dist/enhancers/time-travel/index.d.ts

@@ -0,0 +1,380 @@
+import { WritableSignal, Signal } from '@angular/core';
+
+/**
+ * SignalTree Core Types v2.0.2
+ * MIT License - Copyright (c) 2025 Jonathan D Borgia
+ */
+/**
+ * Helper type preventing ambiguity when a node itself stores a function value.
+ * In that case direct callable set(fn) would clash with the update(fn) signature.
+ * We exclude raw function values from the direct-set overload so users must use .set(fn)
+ * (after transform) instead of callable form, while updater form still works.
+ */
+type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
+/**
+ * Augment Angular's WritableSignal to support callable syntax for DX.
+ * This is purely TypeScript-level - the transform converts these calls to .set/.update
+ */
+declare module '@angular/core' {
+    interface WritableSignal<T> {
+        (value: NotFn<T>): void;
+        (updater: (current: T) => T): void;
+    }
+}
+/**
+ * Built-in object types that should be treated as primitive values
+ * (Keep this list in sync with runtime isBuiltInObject)
+ */
+type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | URL | URLSearchParams | FormData | Blob | File | Headers | Request | Response | AbortController | AbortSignal;
+/**
+ * Node accessor interface - unified API for get/set/update via function calls.
+ * Overloads:
+ *  (): T                     - getter
+ *  (value: NotFn<T>): void   - direct set (blocked when T is itself a function)
+ *  (updater: (T)=>T): void   - functional update
+ */
+interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+/**
+ * Signalified node with callable interface
+ */
+type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
+/**
+ * Deep signalification type - converts object properties to signals recursively
+ * - Leaves (primitives, arrays, functions, built-ins): Raw Angular WritableSignal<T>
+ * - Nested objects: NodeAccessor<T> (callable) + recursive TreeNode<T> properties
+ */
+type CallableWritableSignal<T> = WritableSignal<T> & {
+    (value: NotFn<T>): void;
+    (updater: (current: T) => T): void;
+};
+type TreeNode<T> = {
+    [K in keyof T]: T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends BuiltInObject ? CallableWritableSignal<T[K]> : T[K] extends (...args: unknown[]) => unknown ? CallableWritableSignal<T[K]> : AccessibleNode<T[K]> : CallableWritableSignal<T[K]>;
+};
+/** Enhancer metadata for optional auto-ordering */
+interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+}
+/** Enhancer function that may carry metadata */
+type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
+/** Enhancer with optional metadata attached */
+type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
+    metadata?: EnhancerMeta;
+};
+/**
+ * Simplified overload set for .with() method
+ * Reduced from 20+ complex overloads to basic patterns that TypeScript can infer.
+ * For complex enhancer chains, use applyEnhancer() helper or type assertions.
+ */
+interface WithMethod<T> {
+    (): SignalTree<T>;
+    <O>(enhancer: (input: SignalTree<T>) => O): O;
+    <O1, O2>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2): O2;
+    <O1, O2, O3>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3): O3;
+    <O>(enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
+    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
+    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+}
+/**
+ * Main SignalTree type with all methods
+ */
+type SignalTree<T> = NodeAccessor<T> & {
+    /** The reactive state object */
+    state: TreeNode<T>;
+    /** Shorthand alias for state */
+    $: TreeNode<T>;
+    /** Core methods */
+    with: WithMethod<T>;
+    destroy(): void;
+    /**
+     * Dispose of the signal tree and clean up memory resources.
+     * Only available when using lazy signals (useLazySignals: true).
+     *
+     * This method:
+     * - Clears the memory manager cache (releases WeakRef references)
+     * - Calls the cleanup function on the lazy proxy
+     * - Allows garbage collection of unused signals
+     *
+     * @example
+     * ```typescript
+     * const tree = signalTree({ users: largeUserList }, { useLazySignals: true });
+     * // ... use tree
+     * tree.dispose(); // Clean up when done
+     * ```
+     */
+    dispose?(): void;
+    /** Enhanced functionality */
+    effect(fn: (tree: T) => void): void;
+    subscribe(fn: (tree: T) => void): () => void;
+    batch(updater: (tree: T) => void): void;
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+    memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
+    memoizedUpdate(updater: (current: T) => Partial<T>, cacheKey?: string): void;
+    clearMemoCache(key?: string): void;
+    getCacheStats(): {
+        size: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        keys: string[];
+    };
+    /** Performance methods */
+    optimize(): void;
+    clearCache(): void;
+    invalidatePattern(pattern: string): number;
+    /**
+     * Optimized update using diff-based patching and batching.
+     * Only updates signals that actually changed, providing significant
+     * performance improvements for large trees and partial updates.
+     *
+     * @param updates - Partial updates to apply
+     * @param options - Update options (batching, equality, etc.)
+     * @returns Update result with performance metrics
+     *
+     * @example
+     * ```typescript
+     * const tree = signalTree({ users: largeUserList });
+     *
+     * // Only updates what changed
+     * const result = tree.updateOptimized({
+     *   users: { 0: { name: 'Updated' } }
+     * });
+     *
+     * console.log(result.changedPaths); // ['users.0.name']
+     * console.log(result.duration); // ~2ms
+     * ```
+     */
+    updateOptimized?(updates: Partial<T>, options?: {
+        batch?: boolean;
+        batchSize?: number;
+        maxDepth?: number;
+        ignoreArrayOrder?: boolean;
+        equalityFn?: (a: unknown, b: unknown) => boolean;
+    }): {
+        changed: boolean;
+        duration: number;
+        changedPaths: string[];
+        stats?: {
+            totalPaths: number;
+            optimizedPaths: number;
+            batchedUpdates: number;
+        };
+    };
+    getMetrics(): PerformanceMetrics;
+    /** Middleware */
+    addTap(middleware: Middleware<T>): void;
+    removeTap(id: string): void;
+    /** Entity helpers */
+    entities<E extends {
+        id: string | number;
+    }>(entityKey?: keyof T): EntityHelpers<E>;
+    /** Async actions */
+    asyncAction<TInput, TResult>(operation: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>): AsyncAction<TInput, TResult>;
+    /** Time travel */
+    undo(): void;
+    redo(): void;
+    getHistory(): TimeTravelEntry$1<T>[];
+    resetHistory(): void;
+    jumpTo?: (index: number) => void;
+    canUndo?: () => boolean;
+    canRedo?: () => boolean;
+    getCurrentIndex?: () => number;
+    /** Index signature for enhancer compatibility */
+    [key: string]: unknown;
+};
+interface Middleware<T> {
+    id: string;
+    before?: (action: string, payload: unknown, state: T) => boolean;
+    after?: (action: string, payload: unknown, state: T, newState: T) => void;
+}
+interface PerformanceMetrics {
+    updates: number;
+    computations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageUpdateTime: number;
+}
+interface EntityHelpers<E extends {
+    id: string | number;
+}> {
+    add(entity: E): void;
+    update(id: E['id'], updates: Partial<E>): void;
+    remove(id: E['id']): void;
+    upsert(entity: E): void;
+    selectById(id: E['id']): Signal<E | undefined>;
+    selectBy(predicate: (entity: E) => boolean): Signal<E[]>;
+    selectIds(): Signal<Array<string | number>>;
+    selectAll(): Signal<E[]>;
+    selectTotal(): Signal<number>;
+    clear(): void;
+}
+interface AsyncActionConfig<T, TResult> {
+    onStart?: (state: T) => Partial<T>;
+    onSuccess?: (result: TResult, state: T) => Partial<T>;
+    onError?: (error: Error, state: T) => Partial<T>;
+    onComplete?: (state: T) => Partial<T>;
+}
+interface AsyncAction<TInput, TResult> {
+    execute(input: TInput): Promise<TResult>;
+    pending: Signal<boolean>;
+    error: Signal<Error | null>;
+    result: Signal<TResult | null>;
+}
+interface TimeTravelEntry$1<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
+
+/**
+ * Entry in the time travel history
+ */
+interface TimeTravelEntry<T> {
+    state: T;
+    timestamp: number;
+    action: string;
+    payload?: unknown;
+}
+/**
+ * Time travel interface for state history management
+ */
+interface TimeTravelInterface<T> {
+    /**
+     * Navigate backward in history by one step
+     */
+    undo(): boolean;
+    /**
+     * Navigate forward in history by one step
+     */
+    redo(): boolean;
+    /**
+     * Get the complete history of state changes
+     */
+    getHistory(): TimeTravelEntry<T>[];
+    /**
+     * Reset the history, keeping only the current state
+     */
+    resetHistory(): void;
+    /**
+     * Jump to a specific point in history by index
+     */
+    jumpTo(index: number): boolean;
+    /**
+     * Get current position in history
+     */
+    getCurrentIndex(): number;
+    /**
+     * Check if undo is possible
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is possible
+     */
+    canRedo(): boolean;
+}
+/**
+ * Configuration options for time travel
+ */
+interface TimeTravelConfig {
+    /**
+     * Maximum number of history entries to keep
+     * @default 50
+     */
+    maxHistorySize?: number;
+    /**
+     * Whether to include payload information in history entries
+     * @default true
+     */
+    includePayload?: boolean;
+    /**
+     * Custom action names for different operations
+     */
+    actionNames?: {
+        update?: string;
+        set?: string;
+        batch?: string;
+        [key: string]: string | undefined;
+    };
+}
+/**
+ * Enhances a SignalTree with comprehensive time travel capabilities.
+ *
+ * Adds undo/redo functionality, state history management, and snapshot features.
+ * Automatically tracks state changes and provides methods to navigate through
+ * the application's state history with configurable limits and optimizations.
+ *
+ * @template T - The state object type
+ * @param config - Configuration options for time travel behavior
+ * @returns Function that enhances a SignalTree with time travel capabilities
+ *
+ * @example
+ * ```typescript
+ * // Basic time travel enhancement
+ * const store = signalTree({ count: 0, text: '' }).with(withTimeTravel());
+ *
+ * // Make some changes
+ * store.count.set(1);
+ * store.text.set('hello');
+ * store.count.set(2);
+ *
+ * // Access time travel interface
+ * const timeTravel = store.__timeTravel;
+ *
+ * // Navigate history
+ * console.log(timeTravel.canUndo()); // true
+ * timeTravel.undo(); // count: 1, text: 'hello'
+ * timeTravel.undo(); // count: 1, text: ''
+ * timeTravel.undo(); // count: 0, text: ''
+ *
+ * timeTravel.redo(); // count: 1, text: ''
+ * console.log(timeTravel.canRedo()); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Advanced configuration
+ * const store = signalTree({
+ *   document: { title: '', content: '' },
+ *   settings: { theme: 'light' }
+ * }).with(withTimeTravel({
+ *   maxHistorySize: 50,        // Limit memory usage
+ *   includePayload: true,      // Store action metadata
+ *   actionNames: {             // Custom action names
+ *     'update_title': 'Update Document Title',
+ *     'change_theme': 'Change Theme'
+ *   }
+ * }));
+ *
+ * // Named actions with metadata
+ * store.update(() => ({ document: { title: 'New Title' } }), 'update_title');
+ *
+ * // View detailed history
+ * const history = store.__timeTravel.getHistory();
+ * console.log(history[0].action); // 'Update Document Title'
+ * console.log(history[0].timestamp); // Date when change occurred
+ * ```
+ */
+declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+/**
+ * Convenience function to enable basic time travel
+ */
+declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+/**
+ * Get time travel interface from an enhanced tree
+ */
+declare function getTimeTravel<T>(tree: SignalTree<T> & {
+    __timeTravel?: TimeTravelInterface<T>;
+}): TimeTravelInterface<T> | undefined;
+
+export { enableTimeTravel, getTimeTravel, withTimeTravel };
+export type { TimeTravelConfig, TimeTravelEntry, TimeTravelInterface };

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

@@ -0,0 +1,289 @@
+import { deepClone, deepEqual } from '@signaltree/shared';
+
+/**
+ * Internal time travel state management
+ */
+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,
+        };
+        // Add initial state to history
+        this.addEntry('INIT', this.tree());
+    }
+    /**
+     * Add a new entry to the history
+     */
+    addEntry(action, state, payload) {
+        // If we're not at the end of history, remove everything after current position
+        if (this.currentIndex < this.history.length - 1) {
+            this.history = this.history.slice(0, this.currentIndex + 1);
+        }
+        // Create new entry
+        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;
+        // Enforce max history size
+        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;
+    }
+    /**
+     * Restore state without triggering time travel middleware
+     */
+    restoreState(state) {
+        if (this.restoreStateFn) {
+            this.restoreStateFn(state);
+        }
+        else {
+            // Fallback if no restoration function provided
+            this.tree(state);
+        }
+    }
+}
+/**
+ * Enhances a SignalTree with comprehensive time travel capabilities.
+ *
+ * Adds undo/redo functionality, state history management, and snapshot features.
+ * Automatically tracks state changes and provides methods to navigate through
+ * the application's state history with configurable limits and optimizations.
+ *
+ * @template T - The state object type
+ * @param config - Configuration options for time travel behavior
+ * @returns Function that enhances a SignalTree with time travel capabilities
+ *
+ * @example
+ * ```typescript
+ * // Basic time travel enhancement
+ * const store = signalTree({ count: 0, text: '' }).with(withTimeTravel());
+ *
+ * // Make some changes
+ * store.count.set(1);
+ * store.text.set('hello');
+ * store.count.set(2);
+ *
+ * // Access time travel interface
+ * const timeTravel = store.__timeTravel;
+ *
+ * // Navigate history
+ * console.log(timeTravel.canUndo()); // true
+ * timeTravel.undo(); // count: 1, text: 'hello'
+ * timeTravel.undo(); // count: 1, text: ''
+ * timeTravel.undo(); // count: 0, text: ''
+ *
+ * timeTravel.redo(); // count: 1, text: ''
+ * console.log(timeTravel.canRedo()); // true
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Advanced configuration
+ * const store = signalTree({
+ *   document: { title: '', content: '' },
+ *   settings: { theme: 'light' }
+ * }).with(withTimeTravel({
+ *   maxHistorySize: 50,        // Limit memory usage
+ *   includePayload: true,      // Store action metadata
+ *   actionNames: {             // Custom action names
+ *     'update_title': 'Update Document Title',
+ *     'change_theme': 'Change Theme'
+ *   }
+ * }));
+ *
+ * // Named actions with metadata
+ * store.update(() => ({ document: { title: 'New Title' } }), 'update_title');
+ *
+ * // View detailed history
+ * const history = store.__timeTravel.getHistory();
+ * console.log(history[0].action); // 'Update Document Title'
+ * console.log(history[0].timestamp); // Date when change occurred
+ * ```
+ */
+function withTimeTravel(config = {}) {
+    return (tree) => {
+        // Store the original callable tree function
+        const originalTreeCall = tree.bind(tree);
+        // Flag to prevent time travel during restoration
+        let isRestoring = false;
+        // Create time travel manager with restoration function
+        const timeTravelManager = new TimeTravelManager(tree, config, (state) => {
+            isRestoring = true;
+            try {
+                originalTreeCall(state);
+            }
+            finally {
+                isRestoring = false;
+            }
+        });
+        // Create enhanced tree function that includes time travel tracking
+        const enhancedTree = function (...args) {
+            if (args.length === 0) {
+                // Get operation - call original directly
+                return originalTreeCall();
+            }
+            else {
+                // Set or update operation - track for time travel
+                if (isRestoring) {
+                    // During restoration, just call original update
+                    if (args.length === 1) {
+                        const arg = args[0];
+                        if (typeof arg === 'function') {
+                            return originalTreeCall(arg);
+                        }
+                        else {
+                            return originalTreeCall(arg);
+                        }
+                    }
+                    return;
+                }
+                const beforeState = originalTreeCall();
+                // Execute the actual update using the original callable interface
+                let result;
+                if (args.length === 1) {
+                    const arg = args[0];
+                    if (typeof arg === 'function') {
+                        result = originalTreeCall(arg);
+                    }
+                    else {
+                        result = originalTreeCall(arg);
+                    }
+                }
+                const afterState = originalTreeCall();
+                // Only add to history if state actually changed
+                const statesEqual = deepEqual(beforeState, afterState);
+                if (!statesEqual) {
+                    timeTravelManager.addEntry('update', afterState);
+                }
+                return result;
+            }
+        };
+        // Copy all properties and methods from original tree
+        Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+        Object.assign(enhancedTree, tree);
+        // Ensure state and $ properties are preserved
+        if ('state' in tree) {
+            Object.defineProperty(enhancedTree, 'state', {
+                value: tree.state,
+                enumerable: false,
+                configurable: true,
+            });
+        }
+        // Ensure $ alias is preserved
+        if ('$' in tree) {
+            Object.defineProperty(enhancedTree, '$', {
+                value: tree['$'],
+                enumerable: false,
+                configurable: true,
+            });
+        }
+        // Override DX-friendly methods to forward to the time travel manager
+        // These shadow the core stubs when the enhancer is applied
+        enhancedTree.undo = () => {
+            timeTravelManager.undo();
+        };
+        enhancedTree.redo = () => {
+            timeTravelManager.redo();
+        };
+        enhancedTree.getHistory = () => timeTravelManager.getHistory();
+        enhancedTree.resetHistory =
+            () => {
+                timeTravelManager.resetHistory();
+            };
+        // Additional helpers exposed directly on the tree for better DX
+        enhancedTree.jumpTo = (index) => {
+            timeTravelManager.jumpTo(index);
+        };
+        enhancedTree.canUndo = () => timeTravelManager.canUndo();
+        enhancedTree.canRedo = () => timeTravelManager.canRedo();
+        enhancedTree.getCurrentIndex =
+            () => timeTravelManager.getCurrentIndex();
+        return Object.assign(enhancedTree, {
+            __timeTravel: timeTravelManager,
+        });
+    };
+}
+/**
+ * Convenience function to enable basic time travel
+ */
+function enableTimeTravel(maxHistorySize) {
+    return withTimeTravel({ maxHistorySize });
+}
+/**
+ * Get time travel interface from an enhanced tree
+ */
+function getTimeTravel(tree) {
+    return tree.__timeTravel;
+}
+
+export { enableTimeTravel, getTimeTravel, withTimeTravel };
+//# sourceMappingURL=index.js.map

package/dist/enhancers/time-travel/index.js.map

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

package/dist/enhancers/time-travel/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/time-travel/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"}