@signaltree/core 4.0.13 → 4.0.15

package/dist/lib/types.d.ts

@@ -0,0 +1,164 @@
+import { Signal, WritableSignal } from '@angular/core';
+import type { SecurityValidatorConfig } from './security/security-validator';
+export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
+declare module '@angular/core' {
+    interface WritableSignal<T> {
+        (value: NotFn<T>): void;
+        (updater: (current: T) => T): void;
+    }
+}
+export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
+export 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;
+export type Unwrap<T> = T extends WritableSignal<infer U> ? U : T extends Signal<infer U> ? U : T extends BuiltInObject ? T : T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]: Unwrap<T[K]>;
+} : T;
+export interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
+export type CallableWritableSignal<T> = WritableSignal<T> & {
+    (value: NotFn<T>): void;
+    (updater: (current: T) => T): void;
+};
+export 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]>;
+};
+export type RemoveSignalMethods<T> = T extends infer U ? U : never;
+export interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+}
+export type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
+export type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
+    metadata?: EnhancerMeta;
+};
+export declare const ENHANCER_META: unique symbol;
+export type ChainResult<Start, E extends Array<EnhancerWithMeta<unknown, unknown>>> = E extends [infer H, ...infer R] ? H extends EnhancerWithMeta<SignalTree<unknown>, infer O> ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : H extends EnhancerWithMeta<infer I, infer O> ? Start extends I ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : unknown : unknown : Start;
+export 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;
+}
+export type SignalTree<T> = NodeAccessor<T> & {
+    state: TreeNode<T>;
+    $: TreeNode<T>;
+    with: WithMethod<T>;
+    destroy(): void;
+    dispose?(): void;
+    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[];
+    };
+    optimize(): void;
+    clearCache(): void;
+    invalidatePattern(pattern: string): number;
+    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;
+    addTap(middleware: Middleware<T>): void;
+    removeTap(id: string): void;
+    entities<E extends {
+        id: string | number;
+    }>(entityKey?: keyof T): EntityHelpers<E>;
+    asyncAction<TInput, TResult>(operation: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>): AsyncAction<TInput, TResult>;
+    undo(): void;
+    redo(): void;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo?: (index: number) => void;
+    canUndo?: () => boolean;
+    canRedo?: () => boolean;
+    getCurrentIndex?: () => number;
+    [key: string]: unknown;
+};
+export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+export interface TreeConfig {
+    batchUpdates?: boolean;
+    useMemoization?: boolean;
+    enableTimeTravel?: boolean;
+    useLazySignals?: boolean;
+    useShallowComparison?: boolean;
+    maxCacheSize?: number;
+    trackPerformance?: boolean;
+    treeName?: string;
+    enableDevTools?: boolean;
+    debugMode?: boolean;
+    useStructuralSharing?: boolean;
+    security?: SecurityValidatorConfig;
+}
+export interface Middleware<T> {
+    id: string;
+    before?: (action: string, payload: unknown, state: T) => boolean;
+    after?: (action: string, payload: unknown, state: T, newState: T) => void;
+}
+export interface PerformanceMetrics {
+    updates: number;
+    computations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageUpdateTime: number;
+}
+export 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;
+}
+export 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>;
+}
+export interface AsyncAction<TInput, TResult> {
+    execute(input: TInput): Promise<TResult>;
+    pending: Signal<boolean>;
+    error: Signal<Error | null>;
+    result: Signal<TResult | null>;
+}
+export interface TimeTravelEntry<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
+export declare function isSignalTree<T>(value: unknown): value is SignalTree<T>;

package/dist/lib/types.js

@@ -0,0 +1,9 @@
+export const ENHANCER_META = Symbol('signaltree:enhancer:meta');
+export function isSignalTree(value) {
+    return (value !== null &&
+        typeof value === 'function' &&
+        'state' in value &&
+        '$' in value &&
+        'with' in value &&
+        'destroy' in value);
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,27 @@
+import { Signal, WritableSignal } from '@angular/core';
+import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
+export { deepEqual };
+export { deepEqual as equal };
+export { isBuiltInObject };
+export { parsePath };
+export interface MemoryManager {
+    getSignal(path: string): WritableSignal<unknown> | undefined;
+    cacheSignal(path: string, signal: WritableSignal<unknown>): void;
+    dispose(): void;
+}
+export interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+export type TreeNode<T> = {
+    [K in keyof T]: T[K] extends readonly unknown[] ? WritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends (...args: unknown[]) => unknown ? WritableSignal<T[K]> : NodeAccessor<T[K]> : WritableSignal<T[K]>;
+};
+export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
+export declare function isAnySignal(value: unknown): boolean;
+export declare function composeEnhancers<T>(...enhancers: Array<(tree: T) => T>): (tree: T) => T;
+export declare function createLazySignalTree<T extends object>(obj: T, equalityFn: (a: unknown, b: unknown) => boolean, basePath?: string, memoryManager?: MemoryManager): TreeNode<T>;
+export declare function unwrap<T>(node: TreeNode<T>): T;
+export declare function unwrap<T>(node: NodeAccessor<T> & TreeNode<T>): T;
+export declare function unwrap<T>(node: NodeAccessor<T>): T;
+export declare function unwrap<T>(node: unknown): T;

package/dist/lib/utils.js

@@ -0,0 +1,286 @@
+import { isSignal, signal } from '@angular/core';
+import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
+export { deepEqual };
+export { deepEqual as equal };
+export { isBuiltInObject };
+export { parsePath };
+export function isNodeAccessor(value) {
+    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
+}
+export function isAnySignal(value) {
+    return isSignal(value) || isNodeAccessor(value);
+}
+export function composeEnhancers(...enhancers) {
+    return (tree) => enhancers.reduce((t, e) => e(t), tree);
+}
+export function createLazySignalTree(obj, equalityFn, basePath = '', memoryManager) {
+    const signalCache = new Map();
+    const nestedProxies = new Map();
+    const nestedCleanups = new Map();
+    const cleanup = () => {
+        nestedCleanups.forEach((fn) => {
+            try {
+                fn();
+            }
+            catch (error) {
+                console.warn('Error during nested cleanup:', error);
+            }
+        });
+        nestedCleanups.clear();
+        signalCache.clear();
+        nestedProxies.clear();
+        if (memoryManager) {
+            memoryManager.dispose();
+        }
+    };
+    const proxy = new Proxy(obj, {
+        get(target, prop) {
+            if (prop === '__cleanup__')
+                return cleanup;
+            if (typeof prop === 'symbol') {
+                return target[prop];
+            }
+            if (prop === 'valueOf' || prop === 'toString') {
+                return target[prop];
+            }
+            const key = prop;
+            const path = basePath ? `${basePath}.${key}` : key;
+            if (!(key in target))
+                return undefined;
+            const value = target[key];
+            if (isSignal(value))
+                return value;
+            if (memoryManager) {
+                const cached = memoryManager.getSignal(path);
+                if (cached)
+                    return cached;
+            }
+            if (signalCache.has(path))
+                return signalCache.get(path);
+            if (nestedProxies.has(path))
+                return nestedProxies.get(path);
+            if (value &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                !isSignal(value) &&
+                !isBuiltInObject(value)) {
+                try {
+                    const nestedProxy = createLazySignalTree(value, equalityFn, path, memoryManager);
+                    nestedProxies.set(path, nestedProxy);
+                    const proxyWithCleanup = nestedProxy;
+                    if (typeof proxyWithCleanup.__cleanup__ === 'function') {
+                        nestedCleanups.set(path, proxyWithCleanup.__cleanup__);
+                    }
+                    return nestedProxy;
+                }
+                catch (error) {
+                    console.warn(`Failed to create lazy proxy for path "${path}":`, error);
+                    const fallbackSignal = signal(value, { equal: equalityFn });
+                    signalCache.set(path, fallbackSignal);
+                    if (memoryManager) {
+                        memoryManager.cacheSignal(path, fallbackSignal);
+                    }
+                    return fallbackSignal;
+                }
+            }
+            try {
+                const newSignal = signal(value, { equal: equalityFn });
+                signalCache.set(path, newSignal);
+                if (memoryManager) {
+                    memoryManager.cacheSignal(path, newSignal);
+                }
+                return newSignal;
+            }
+            catch (error) {
+                console.warn(`Failed to create signal for path "${path}":`, error);
+                return value;
+            }
+        },
+        set(target, prop, value) {
+            if (typeof prop === 'symbol') {
+                target[prop] = value;
+                return true;
+            }
+            const key = prop;
+            const path = basePath ? `${basePath}.${key}` : key;
+            try {
+                target[key] = value;
+                const cachedSignal = signalCache.get(path);
+                if (cachedSignal && 'set' in cachedSignal) {
+                    cachedSignal.set(value);
+                }
+                if (nestedProxies.has(path)) {
+                    const nestedCleanup = nestedCleanups.get(path);
+                    if (nestedCleanup) {
+                        nestedCleanup();
+                        nestedCleanups.delete(path);
+                    }
+                    nestedProxies.delete(path);
+                }
+                return true;
+            }
+            catch (error) {
+                console.warn(`Failed to set value for path "${path}":`, error);
+                return false;
+            }
+        },
+        has(target, prop) {
+            return prop in target;
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+    });
+    return proxy;
+}
+export function unwrap(node) {
+    if (node === null || node === undefined) {
+        return node;
+    }
+    if (isNodeAccessor(node)) {
+        const result = {};
+        for (const key in node) {
+            if (!Object.prototype.hasOwnProperty.call(node, key))
+                continue;
+            if (key === 'length' || key === 'prototype')
+                continue;
+            if (key === 'name') {
+                const value = node[key];
+                if (!isSignal(value) && !isNodeAccessor(value)) {
+                    continue;
+                }
+            }
+            const value = node[key];
+            if (isNodeAccessor(value)) {
+                result[key] = unwrap(value);
+            }
+            else if (isSignal(value)) {
+                const unwrappedValue = value();
+                if (typeof unwrappedValue === 'object' &&
+                    unwrappedValue !== null &&
+                    !Array.isArray(unwrappedValue) &&
+                    !isBuiltInObject(unwrappedValue)) {
+                    result[key] = unwrap(unwrappedValue);
+                }
+                else {
+                    result[key] = unwrappedValue;
+                }
+            }
+            else if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value) &&
+                !isBuiltInObject(value)) {
+                result[key] = unwrap(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    if (isSignal(node)) {
+        const value = node();
+        if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            return unwrap(value);
+        }
+        return value;
+    }
+    if (typeof node !== 'object') {
+        return node;
+    }
+    if (Array.isArray(node)) {
+        return node;
+    }
+    if (isBuiltInObject(node)) {
+        return node;
+    }
+    const result = {};
+    for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+            continue;
+        if (key === 'set' || key === 'update') {
+            const v = node[key];
+            if (typeof v === 'function')
+                continue;
+        }
+        const value = node[key];
+        if (isNodeAccessor(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[key] = unwrap(unwrappedValue);
+            }
+            else {
+                result[key] = unwrappedValue;
+            }
+        }
+        else if (isSignal(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[key] = unwrap(unwrappedValue);
+            }
+            else {
+                result[key] = unwrappedValue;
+            }
+        }
+        else if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            result[key] = unwrap(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    const symbols = Object.getOwnPropertySymbols(node);
+    for (const sym of symbols) {
+        const value = node[sym];
+        if (isNodeAccessor(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[sym] = unwrap(unwrappedValue);
+            }
+            else {
+                result[sym] = unwrappedValue;
+            }
+        }
+        else if (isSignal(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[sym] = unwrap(unwrappedValue);
+            }
+            else {
+                result[sym] = unwrappedValue;
+            }
+        }
+        else if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            result[sym] = unwrap(value);
+        }
+        else {
+            result[sym] = value;
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "4.0.13",
+  "version": "4.0.15",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,
@@ -56,13 +56,7 @@
   },
   "peerDependencies": {
     "@angular/core": "^20.3.0",
-    "jest-preset-angular": "*",
-    "@rollup/plugin-commonjs": "*",
-    "@rollup/plugin-node-resolve": "*",
-    "@rollup/plugin-typescript": "*",
-    "rollup": "*",
-    "rollup-plugin-dts": "*",
-    "tslib": "*"
+    "tslib": "^2.0.0"
   },
   "files": [
     "dist",