@signaltree/core 4.0.6 → 4.0.8

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

@@ -0,0 +1,293 @@
+import * as _angular_core from '@angular/core';
+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<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<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
+
+/**
+ * Sets up middleware for a SignalTree with an array of middleware functions.
+ * Replaces any existing middleware configuration.
+ *
+ * @param tree - The SignalTree to enhance with middleware
+ * @param middlewares - Array of middleware functions to apply
+ * @returns The enhanced SignalTree
+ */
+declare function withMiddleware<T>(middlewares?: Middleware<T>[]): (tree: SignalTree<T>) => SignalTree<T>;
+/**
+ * Creates a logging middleware that tracks all state changes.
+ *
+ * @param treeName - Name to display in console logs
+ * @returns Configured logging middleware
+ */
+declare function createLoggingMiddleware<T>(treeName: string): Middleware<T>;
+/**
+ * Creates a performance monitoring middleware.
+ *
+ * @returns Configured performance middleware
+ */
+declare function createPerformanceMiddleware<T>(): Middleware<T>;
+/**
+ * Creates a validation middleware that validates state after updates.
+ *
+ * @param validator - Function that validates state and returns error message or null
+ * @returns Configured validation middleware
+ */
+declare function createValidationMiddleware<T>(validator: (state: T) => string | null): Middleware<T>;
+/**
+ * Creates a persistence middleware that auto-saves state changes.
+ *
+ * @param config - Configuration for persistence behavior
+ * @returns Configured persistence middleware
+ */
+declare function createPersistenceMiddleware<T>(config: {
+    key: string;
+    storage?: Storage;
+    debounceMs?: number;
+    actions?: string[];
+}): Middleware<T>;
+
+/**
+ * Create an async operation that updates the tree via its batchUpdate method
+ * and sets simple name-scoped keys for pending/result/error.
+ */
+declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
+/**
+ * Standalone status tracking for async operations using Angular signals.
+ */
+declare function trackAsync<T>(operation: () => Promise<T>): {
+    pending: _angular_core.Signal<boolean>;
+    error: _angular_core.Signal<Error | null>;
+    result: _angular_core.Signal<T | null>;
+    execute: () => Promise<T>;
+};
+
+export { createAsyncOperation, createLoggingMiddleware, createPerformanceMiddleware, createPersistenceMiddleware, createValidationMiddleware, trackAsync, withMiddleware };

package/dist/enhancers/middleware/index.js

@@ -0,0 +1,339 @@
+import { signal } from '@angular/core';
+
+// Global middleware storage - using unknown for type safety
+const middlewareMap = new WeakMap();
+/**
+ * Sets up middleware for a SignalTree with an array of middleware functions.
+ * Replaces any existing middleware configuration.
+ *
+ * @param tree - The SignalTree to enhance with middleware
+ * @param middlewares - Array of middleware functions to apply
+ * @returns The enhanced SignalTree
+ */
+function withMiddleware(middlewares = []) {
+    return (tree) => {
+        // Initialize middleware array for this tree
+        middlewareMap.set(tree, [...middlewares]);
+        // Store the original callable tree function
+        const originalTreeCall = tree.bind(tree);
+        // Create enhanced tree function that includes middleware execution
+        const enhancedTree = function (...args) {
+            if (args.length === 0) {
+                // Get operation - call original directly (no middleware needed for reads)
+                return originalTreeCall();
+            }
+            else {
+                // Set or update operation - apply middleware
+                const action = 'UPDATE';
+                const currentState = originalTreeCall();
+                const treeMiddlewares = middlewareMap.get(tree) || [];
+                let updateResult;
+                if (args.length === 1) {
+                    const arg = args[0];
+                    if (typeof arg === 'function') {
+                        // Function updater
+                        updateResult = arg(currentState);
+                    }
+                    else {
+                        // Direct value
+                        updateResult = arg;
+                    }
+                }
+                else {
+                    return; // Invalid call
+                }
+                // Execute 'before' middleware hooks
+                for (const middleware of treeMiddlewares) {
+                    if (middleware.before &&
+                        !middleware.before(action, updateResult, currentState)) {
+                        // Middleware blocked the update
+                        return;
+                    }
+                }
+                // Capture state before update for 'after' hooks
+                const previousState = currentState;
+                // Execute the actual update using the original callable interface
+                if (args.length === 1) {
+                    const arg = args[0];
+                    if (typeof arg === 'function') {
+                        originalTreeCall(arg);
+                    }
+                    else {
+                        originalTreeCall(arg);
+                    }
+                }
+                // Get new state after update
+                const newState = originalTreeCall();
+                // Execute 'after' middleware hooks
+                for (const middleware of treeMiddlewares) {
+                    if (middleware.after) {
+                        middleware.after(action, updateResult, previousState, newState);
+                    }
+                }
+            }
+        };
+        // 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 addTap to work with the middleware system
+        enhancedTree.addTap = (middleware) => {
+            const treeMiddlewares = middlewareMap.get(tree) || [];
+            // Check if middleware with same ID already exists
+            const existingIndex = treeMiddlewares.findIndex((m) => m.id === middleware.id);
+            if (existingIndex >= 0) {
+                // Replace existing middleware
+                treeMiddlewares[existingIndex] = middleware;
+            }
+            else {
+                treeMiddlewares.push(middleware);
+            }
+            middlewareMap.set(tree, treeMiddlewares);
+        };
+        // Override removeTap method
+        enhancedTree.removeTap = (id) => {
+            const treeMiddlewares = middlewareMap.get(tree) || [];
+            const filtered = treeMiddlewares.filter((m) => m.id !== id);
+            middlewareMap.set(tree, filtered);
+        };
+        // Store original batchUpdate for enhancement
+        const originalBatchUpdate = tree.batchUpdate;
+        // Override batchUpdate to include middleware
+        if (originalBatchUpdate) {
+            enhancedTree.batchUpdate = (updater) => {
+                const action = 'BATCH_UPDATE';
+                const currentState = originalTreeCall();
+                const updateResult = updater(currentState);
+                const treeMiddlewares = middlewareMap.get(tree) || [];
+                // Execute 'before' middleware hooks
+                for (const middleware of treeMiddlewares) {
+                    if (middleware.before &&
+                        !middleware.before(action, updateResult, currentState)) {
+                        // Middleware blocked the update
+                        return;
+                    }
+                }
+                // Capture state before update for 'after' hooks
+                const previousState = currentState;
+                // Execute the actual batch update
+                originalBatchUpdate.call(tree, updater);
+                // Get new state after update
+                const newState = originalTreeCall();
+                // Execute 'after' middleware hooks
+                for (const middleware of treeMiddlewares) {
+                    if (middleware.after) {
+                        middleware.after(action, updateResult, previousState, newState);
+                    }
+                }
+            };
+        }
+        // Override destroy to cleanup middleware
+        const originalDestroy = tree.destroy;
+        enhancedTree.destroy = () => {
+            middlewareMap.delete(tree);
+            if (originalDestroy) {
+                originalDestroy.call(tree);
+            }
+        };
+        return enhancedTree;
+    };
+}
+/**
+ * Creates a logging middleware that tracks all state changes.
+ *
+ * @param treeName - Name to display in console logs
+ * @returns Configured logging middleware
+ */
+function createLoggingMiddleware(treeName) {
+    return {
+        id: 'logging',
+        before: (action, payload, state) => {
+            console.group(`🏪 ${treeName}: ${action}`);
+            console.log('Previous state:', state);
+            console.log('Payload:', typeof payload === 'function' ? 'Function' : payload);
+            return true;
+        },
+        after: (action, payload, state, newState) => {
+            console.log('New state:', newState);
+            console.groupEnd();
+        },
+    };
+}
+/**
+ * Creates a performance monitoring middleware.
+ *
+ * @returns Configured performance middleware
+ */
+function createPerformanceMiddleware() {
+    return {
+        id: 'performance',
+        before: (action) => {
+            console.time(`Tree update: ${action}`);
+            return true;
+        },
+        after: (action) => {
+            console.timeEnd(`Tree update: ${action}`);
+        },
+    };
+}
+/**
+ * Creates a validation middleware that validates state after updates.
+ *
+ * @param validator - Function that validates state and returns error message or null
+ * @returns Configured validation middleware
+ */
+function createValidationMiddleware(validator) {
+    return {
+        id: 'validation',
+        after: (action, payload, state, newState) => {
+            const error = validator(newState);
+            if (error) {
+                console.error(`Validation failed after ${action}:`, error);
+            }
+        },
+    };
+}
+/**
+ * Creates a persistence middleware that auto-saves state changes.
+ *
+ * @param config - Configuration for persistence behavior
+ * @returns Configured persistence middleware
+ */
+function createPersistenceMiddleware(config) {
+    const { key, storage = localStorage, debounceMs = 1000, actions = ['UPDATE', 'BATCH_UPDATE'], } = config;
+    let timeoutId;
+    const debouncedSave = (state) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            try {
+                storage.setItem(key, JSON.stringify(state));
+                console.log(`💾 State auto-saved to ${key}`);
+            }
+            catch (error) {
+                console.error('Failed to save state:', error);
+            }
+        }, debounceMs);
+    };
+    return {
+        id: 'persistence',
+        after: (action, payload, state, newState) => {
+            if (actions.includes(action)) {
+                debouncedSave(newState);
+            }
+        },
+    };
+}
+
+/**
+ * Create an async operation that updates the tree via its batchUpdate method
+ * and sets simple name-scoped keys for pending/result/error.
+ */
+function createAsyncOperation(name, operation) {
+    return async (tree) => {
+        // Trigger middleware-friendly batch update marking pending
+        if (typeof tree.batchUpdate === 'function') {
+            // batchUpdate expects a Partial<T>. We don't know T here, so create
+            // a minimal partial using unknown and cast to Partial<T> at the last step.
+            const pendingPatch = {
+                [`${name}_PENDING`]: true,
+            };
+            tree.batchUpdate(() => pendingPatch);
+        }
+        else if ('$' in tree) {
+            // Best-effort fallback: set via $ alias if available
+            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;
+        }
+    };
+}
+/**
+ * Standalone status tracking for async operations using Angular signals.
+ */
+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, createLoggingMiddleware, createPerformanceMiddleware, createPersistenceMiddleware, createValidationMiddleware, trackAsync, withMiddleware };
+//# sourceMappingURL=index.js.map

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

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

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