@signaltree/core 4.0.16 → 4.1.0

package/src/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/src/lib/utils.d.ts

@@ -0,0 +1,28 @@
+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 toWritableSignal<T>(node: NodeAccessor<T>, injector?: unknown): WritableSignal<T>;
+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;