@signaltree/core 3.0.2 → 4.0.1

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

@@ -0,0 +1,272 @@
+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;
+}
+
+/**
+ * Entity configuration options
+ */
+interface EntityConfig {
+    enabled?: boolean;
+    trackChanges?: boolean;
+    validateIds?: boolean;
+}
+/**
+ * Enhances a SignalTree with entity management capabilities
+ * Works with SignalTree's TreeNode type structure
+ *
+ * The key insight: The state is already deeply signalified, so array properties
+ * like `users: User[]` become `users: WritableSignal<User[]>` in tree.state
+ */
+declare function withEntities(config?: EntityConfig): <T>(tree: SignalTree<T>) => SignalTree<T> & {
+    entities<E extends {
+        id: string | number;
+    }>(entityKey: keyof T): EntityHelpers<E>;
+};
+/**
+ * Convenience function to enable entities with default config
+ */
+declare function enableEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
+    entities<E extends {
+        id: string | number;
+    }>(entityKey: keyof T): EntityHelpers<E>;
+};
+/**
+ * High-performance entity management configuration
+ */
+declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
+    entities<E extends {
+        id: string | number;
+    }>(entityKey: keyof T): EntityHelpers<E>;
+};
+
+export { enableEntities, withEntities, withHighPerformanceEntities };

package/dist/enhancers/entities/index.js

@@ -0,0 +1,164 @@
+import { isSignal, computed } from '@angular/core';
+import '@signaltree/shared';
+
+/** Symbol to mark callable signals - using global symbol to match across files */
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
+/**
+ * Checks if a value is a node accessor created by makeNodeAccessor
+ */
+function isNodeAccessor(value) {
+    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
+}
+/**
+ * Checks if a value is either an Angular signal or a callable signal
+ * This is useful for packages that need to work with both types
+ */
+function isAnySignal(value) {
+    return isSignal(value) || isNodeAccessor(value);
+}
+
+/**
+ * Creates entity helpers for a specific entity collection
+ * This properly handles the SignalTree's TreeNode type structure
+ *
+ * CRITICAL: In SignalTree, arrays become WritableSignal<Array>
+ * So `users: User[]` in the original state becomes `users: WritableSignal<User[]>` in tree.state
+ */
+function createEntityHelpers(tree, entityKey) {
+    // Get the signal from the deeply signalified state
+    // The state property is of type TreeNode<T>
+    const getEntitySignal = () => {
+        // Access the state property - it's already a signal due to TreeNode
+        // We need to use type assertion here because TypeScript can't track the deep signalification
+        const stateProperty = tree.state[entityKey];
+        // Check if it exists
+        if (!stateProperty) {
+            throw new Error(`Entity key '${String(entityKey)}' does not exist in the state`);
+        }
+        // Due to TreeNode, if the original was an array, it's now WritableSignal<Array>
+        if (!isAnySignal(stateProperty)) {
+            throw new Error(`Entity key '${String(entityKey)}' is not a signal. This should not happen with SignalTree.`);
+        }
+        // Cast to WritableSignal and verify it contains an array
+        const signal = stateProperty;
+        const value = signal();
+        if (!Array.isArray(value)) {
+            throw new Error(`Entity key '${String(entityKey)}' does not contain an array. Current type: ${typeof value}`);
+        }
+        return signal;
+    };
+    // Helper function to set values on both WritableSignal and callable signals
+    const setSignalValue = (signal, value) => {
+        if (isNodeAccessor(signal)) {
+            // Callable signal - use function call
+            signal(value);
+        }
+        else {
+            // WritableSignal - use .set() method
+            signal.set(value);
+        }
+    };
+    return {
+        add: (entity) => {
+            const entitySignal = getEntitySignal();
+            const currentEntities = entitySignal();
+            // Check for duplicate
+            if (currentEntities.some((e) => e.id === entity.id)) {
+                throw new Error(`Entity with id '${entity.id}' already exists`);
+            }
+            setSignalValue(entitySignal, [...currentEntities, entity]);
+        },
+        update: (id, updates) => {
+            const entitySignal = getEntitySignal();
+            const currentEntities = entitySignal();
+            const updatedEntities = currentEntities.map((entity) => entity.id === id ? { ...entity, ...updates } : entity);
+            setSignalValue(entitySignal, updatedEntities);
+        },
+        remove: (id) => {
+            const entitySignal = getEntitySignal();
+            const currentEntities = entitySignal();
+            const filteredEntities = currentEntities.filter((entity) => entity.id !== id);
+            setSignalValue(entitySignal, filteredEntities);
+        },
+        upsert: (entity) => {
+            const entitySignal = getEntitySignal();
+            const currentEntities = entitySignal();
+            const index = currentEntities.findIndex((e) => e.id === entity.id);
+            if (index >= 0) {
+                // Update existing
+                const updatedEntities = [...currentEntities];
+                updatedEntities[index] = entity;
+                setSignalValue(entitySignal, updatedEntities);
+            }
+            else {
+                // Add new
+                setSignalValue(entitySignal, [...currentEntities, entity]);
+            }
+        },
+        selectById: (id) => {
+            const entitySignal = getEntitySignal();
+            return computed(() => entitySignal().find((entity) => entity.id === id));
+        },
+        selectBy: (predicate) => {
+            const entitySignal = getEntitySignal();
+            return computed(() => entitySignal().filter(predicate));
+        },
+        selectIds: () => {
+            const entitySignal = getEntitySignal();
+            return computed(() => entitySignal().map((entity) => entity.id));
+        },
+        selectAll: () => {
+            const entitySignal = getEntitySignal();
+            return entitySignal;
+        },
+        selectTotal: () => {
+            const entitySignal = getEntitySignal();
+            return computed(() => entitySignal().length);
+        },
+        clear: () => {
+            const entitySignal = getEntitySignal();
+            setSignalValue(entitySignal, []);
+        },
+    };
+}
+/**
+ * Enhances a SignalTree with entity management capabilities
+ * Works with SignalTree's TreeNode type structure
+ *
+ * The key insight: The state is already deeply signalified, so array properties
+ * like `users: User[]` become `users: WritableSignal<User[]>` in tree.state
+ */
+function withEntities(config = {}) {
+    const { enabled = true } = config;
+    return function enhanceWithEntities(tree) {
+        if (!enabled) {
+            // When disabled, return the original tree object unchanged
+            // Cast is safe here because we're not actually adding the method
+            return tree;
+        }
+        // Type-safe enhancement that adds entities method using Object.assign
+        // This approach preserves the generic method signature better than direct property assignment
+        const enhancedTree = Object.assign(tree, {
+            entities(entityKey) {
+                return createEntityHelpers(tree, entityKey);
+            },
+        });
+        return enhancedTree;
+    };
+}
+/**
+ * Convenience function to enable entities with default config
+ */
+function enableEntities() {
+    return withEntities({ enabled: true });
+}
+/**
+ * High-performance entity management configuration
+ */
+function withHighPerformanceEntities() {
+    return withEntities({
+        enabled: true});
+}
+
+export { enableEntities, withEntities, withHighPerformanceEntities };
+//# sourceMappingURL=index.js.map

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

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

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