@signaltree/core 4.0.1 → 4.0.2

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

@@ -1,302 +0,0 @@
-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;
-}
-
-/**
- * Configuration for the computed enhancer
- */
-interface ComputedConfig {
-    /** Whether to enable lazy evaluation */
-    lazy?: boolean;
-    /** Whether to memoize computed values */
-    memoize?: boolean;
-}
-/**
- * Computed signal type for derived state
- */
-type ComputedSignal<T> = Signal<T>;
-/**
- * Extended SignalTree with computed signal capabilities
- */
-interface ComputedSignalTree<T extends Record<string, unknown>> extends SignalTree<T> {
-    /**
-     * Create a computed signal from the current tree state
-     * @param computeFn Function that computes the derived value
-     * @returns A computed signal that updates when dependencies change
-     */
-    computed<U>(computeFn: (tree: TreeNode<T>) => U): ComputedSignal<U>;
-}
-/**
- * Computed enhancer factory function
- * @param config Configuration options for computed signals
- * @returns Enhancer that adds computed signal functionality
- *
- * @example
- * ```typescript
- * import { signalTree } from '@signaltree/core';
- * import { computed } from '@signaltree/core/enhancers/computed';
- *
- * const state = signalTree(
- *   { count: 0, multiplier: 2 },
- *   { enhancers: [computed()] }
- * );
- *
- * // Create a computed signal
- * const doubled = state.computed(tree => tree.count() * tree.multiplier());
- *
- * console.log(doubled()); // 0
- * state.count.set(5);
- * console.log(doubled()); // 10
- * ```
- */
-declare function computedEnhancer(config?: ComputedConfig): EnhancerWithMeta<SignalTree<Record<string, unknown>>, ComputedSignalTree<Record<string, unknown>>>;
-/**
- * Utility function to create a computed signal from multiple dependencies
- * @param dependencies Array of signals to depend on
- * @param computeFn Function that computes the result
- * @returns Computed signal
- *
- * @example
- * ```typescript
- * import { signal } from '@angular/core';
- * import { createComputed } from '@signaltree/core/enhancers/computed';
- *
- * const a = signal(1);
- * const b = signal(2);
- * const sum = createComputed([a, b], () => a() + b());
- * ```
- */
-declare function createComputed<T>(dependencies: readonly Signal<unknown>[], computeFn: () => T): ComputedSignal<T>;
-
-export { computedEnhancer, createComputed };
-export type { ComputedConfig, ComputedSignal, ComputedSignalTree };

package/dist/enhancers/computed/index.js

@@ -1,165 +0,0 @@
-import { computed } from '@angular/core';
-import '@signaltree/shared';
-
-// Full developer-facing messages
-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',
-};
-// Compact production messages (very short numeric codes) to keep bundles minimal.
-// We map each key to a short numeric string like '0','1','2' to minimize bytes.
-const PROD_MESSAGES = (() => {
-    const out = {};
-    let i = 0;
-    for (const k of Object.keys(DEV_MESSAGES)) {
-        out[k] = String(i++);
-    }
-    return out;
-})();
-// Avoid referencing the bare `process` identifier to keep builds free of Node
-// type assumptions; use globalThis to check env when available.
-const _isProdByEnv = Boolean(typeof globalThis === 'object' &&
-    globalThis !== null &&
-    'process' in globalThis &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeof globalThis.process === 'object' &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    'env' in globalThis.process &&
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    globalThis.process.env.NODE_ENV === 'production');
-const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
-Object.freeze(_isDev
-    ? DEV_MESSAGES
-    : PROD_MESSAGES);
-
-/** Symbol key for enhancer metadata */
-const ENHANCER_META = Symbol('signaltree:enhancer:meta');
-
-/**
- * Helper to create an enhancer with metadata attached
- *
- * @param meta - Metadata describing the enhancer
- * @param enhancerFn - The enhancer function
- * @returns Enhancer function with metadata attached
- *
- * @example
- * ```typescript
- * const myEnhancer = createEnhancer(
- *   {
- *     name: 'myEnhancer',
- *     provides: ['feature1'],
- *     requires: ['feature2']
- *   },
- *   (tree) => {
- *     // Enhance the tree
- *     return { ...tree, feature1: true };
- *   }
- * );
- * ```
- */
-function createEnhancer(meta, enhancerFn) {
-    const fn = enhancerFn;
-    try {
-        fn.metadata = meta;
-        // Also attach under symbol for third-party compatibility
-        try {
-            fn[ENHANCER_META] = meta;
-        }
-        catch {
-            // Ignore if property can't be set
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return fn;
-}
-
-/**
- * Computed enhancer factory function
- * @param config Configuration options for computed signals
- * @returns Enhancer that adds computed signal functionality
- *
- * @example
- * ```typescript
- * import { signalTree } from '@signaltree/core';
- * import { computed } from '@signaltree/core/enhancers/computed';
- *
- * const state = signalTree(
- *   { count: 0, multiplier: 2 },
- *   { enhancers: [computed()] }
- * );
- *
- * // Create a computed signal
- * const doubled = state.computed(tree => tree.count() * tree.multiplier());
- *
- * console.log(doubled()); // 0
- * state.count.set(5);
- * console.log(doubled()); // 10
- * ```
- */
-function computedEnhancer(config = {}) {
-    return createEnhancer({
-        name: 'computed',
-        provides: ['computed'],
-        requires: [],
-    }, (tree) => {
-        const computedTree = tree;
-        // Add computed method to the tree
-        computedTree.computed = function (computeFn) {
-            return computed(() => computeFn(tree.state));
-        };
-        return computedTree;
-    });
-}
-/**
- * Utility function to create a computed signal from multiple dependencies
- * @param dependencies Array of signals to depend on
- * @param computeFn Function that computes the result
- * @returns Computed signal
- *
- * @example
- * ```typescript
- * import { signal } from '@angular/core';
- * import { createComputed } from '@signaltree/core/enhancers/computed';
- *
- * const a = signal(1);
- * const b = signal(2);
- * const sum = createComputed([a, b], () => a() + b());
- * ```
- */
-function createComputed(dependencies, computeFn) {
-    return computed(computeFn);
-}
-
-export { computedEnhancer, createComputed };
-//# sourceMappingURL=index.js.map

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

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

package/dist/enhancers/computed/types/packages/core/src/enhancers/batching/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lib/batching';
-//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/computed/types/packages/core/src/enhancers/batching/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/enhancers/computed/types/packages/core/src/enhancers/batching/jest.config.d.ts

@@ -1,16 +0,0 @@
-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/computed/types/packages/core/src/enhancers/batching/jest.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../../../../../../../src/enhancers/batching/jest.config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,wBAoBE"}