@signaltree/core 1.1.9 → 2.0.1

package/index.d.ts

@@ -1,54 +1,57 @@
 import { WritableSignal, Signal } from '@angular/core';
 
 type Primitive = string | number | boolean | null | undefined | bigint | symbol;
-type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | URL | URLSearchParams | FormData | Blob | File;
-type IsPrimitive<T> = T extends Primitive ? true : false;
-type IsBuiltInObject<T> = T extends BuiltInObject ? true : false;
-type IsSignal<T> = T extends Signal<unknown> ? true : false;
-type IsWritableSignal<T> = T extends WritableSignal<unknown> ? true : false;
+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;
+interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+type SignalifiedNode<T> = NodeAccessor<T> & DeepSignalify<T>;
 type DeepSignalify<T> = {
-    [K in keyof T]: T[K] extends (infer U)[] ? WritableSignal<U[]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends BuiltInObject ? WritableSignal<T[K]> : T[K] extends (...args: unknown[]) => unknown ? WritableSignal<T[K]> : DeepSignalify<T[K]> : WritableSignal<T[K]>;
-} & (() => T) & {
-    update(updaterOrPartial: ((current: T) => Partial<T>) | Partial<T>): void;
-    set(partial: Partial<T>): void;
-    batchUpdate(updater: (current: T) => Partial<T>): void;
-    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
-    clearMemoCache: (key?: string) => void;
-    getCacheStats: () => {
-        size?: number;
-        hitRate?: number;
-        totalHits?: number;
-        totalMisses?: number;
-        keys?: string[];
-    };
-    asyncAction: <TInput = void, TResult = void>(operation: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>) => AsyncAction<TInput, TResult>;
-    loadData: <TResult = void>(loader: () => Promise<TResult>, config?: AsyncActionConfig<T, TResult>) => AsyncAction<void, TResult>;
-    submitForm: <TInput = void, TResult = void>(submitter: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>) => AsyncAction<TInput, TResult>;
-    asCrud: <E extends {
-        id: string | number;
-    } = {
-        id: string | number;
-    }>(entityKey?: keyof T) => EntityHelpers<E>;
-    undo: () => boolean;
-    redo: () => boolean;
-    getHistory: () => TimeTravelEntry<T>[];
-    resetHistory: () => void;
-    jumpTo: (index: number) => boolean;
-    getCurrentIndex: () => number;
-    canUndo: () => boolean;
-    canRedo: () => boolean;
-    __devTools: unknown;
+    [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 BuiltInObject ? WritableSignal<T[K]> : T[K] extends (...args: unknown[]) => unknown ? WritableSignal<T[K]> : SignalifiedNode<T[K]> : WritableSignal<T[K]>;
 };
-type SignalTree<T> = {
+type RemoveSignalMethods<T> = T extends infer U ? U : never;
+interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+}
+type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
+type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
+    metadata?: EnhancerMeta;
+};
+declare const ENHANCER_META: unique symbol;
+type ChainResult<Start, E extends Array<EnhancerWithMeta<unknown, unknown>>> = E extends [infer H, ...infer R] ? H extends EnhancerWithMeta<SignalTree<any>, 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 : any : unknown : Start;
+interface WithMethod<T> {
+    (): SignalTree<T>;
+    <O1>(e1: (input: SignalTree<T>) => O1): O1;
+    <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;
+    <O1, O2, O3, O4>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3, e4: (input: O3) => O4): O4;
+    <O1>(e1: EnhancerWithMeta<SignalTree<T>, O1>): O1;
+    <O1>(e1: EnhancerWithMeta<SignalTree<any>, O1>): O1;
+    <O1>(e1: EnhancerWithMeta<SignalTree<T>, O1>): O1;
+    <O1>(e1: EnhancerWithMeta<SignalTree<any>, O1>, e2: EnhancerWithMeta<O1, unknown>): unknown;
+    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
+    <O1, O2>(e1: EnhancerWithMeta<SignalTree<any>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
+    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<any>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+    <O1, O2, O3, O4>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>, e4: EnhancerWithMeta<O3, O4>): O4;
+    <O1, O2, O3, O4>(e1: EnhancerWithMeta<SignalTree<any>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>, e4: EnhancerWithMeta<O3, O4>): O4;
+    <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;
+    <O1, O2, O3, O4>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>, e4: EnhancerWithMeta<O3, O4>): O4;
+}
+type SignalTree<T> = NodeAccessor<T> & {
     state: DeepSignalify<T>;
     $: DeepSignalify<T>;
+    with: WithMethod<T>;
+    destroy(): void;
     effect(fn: (tree: T) => void): void;
     subscribe(fn: (tree: T) => void): () => void;
-    destroy(): void;
-    pipe(): SignalTree<T>;
-    pipe<R1>(fn1: (tree: SignalTree<T>) => R1): R1;
-    pipe<R1, R2>(fn1: (tree: SignalTree<T>) => R1, fn2: (arg: R1) => R2): R2;
-    pipe<R1, R2, R3>(fn1: (tree: SignalTree<T>) => R1, fn2: (arg: R1) => R2, fn3: (arg: R2) => R3): R3;
+    batch(updater: (tree: T) => void): void;
+    batchUpdate(updater: (current: T) => Partial<T>): void;
     memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
     optimize(): void;
     clearCache(): void;
@@ -64,6 +67,7 @@ type SignalTree<T> = {
     redo(): void;
     getHistory(): TimeTravelEntry<T>[];
     resetHistory(): void;
+    [key: string]: unknown;
 };
 type TreePreset = 'basic' | 'performance' | 'development' | 'production';
 interface TreeConfig {
@@ -132,11 +136,63 @@ declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>,
 declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
 
 declare function equal<T>(a: T, b: T): boolean;
+declare const deepEqual: typeof equal;
 declare function terminalSignal<T>(value: T, customEqual?: (a: T, b: T) => boolean): WritableSignal<T>;
+declare function isBuiltInObject(v: unknown): boolean;
+declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
+declare function isAnySignal(value: unknown): boolean;
 declare function parsePath(path: string): string[];
+declare function composeEnhancers<T>(...enhancers: Array<(tree: T) => T>): (tree: T) => T;
 declare function createLazySignalTree<T extends object>(obj: T, equalityFn: (a: unknown, b: unknown) => boolean, basePath?: string): DeepSignalify<T>;
-declare const deepEqual: typeof equal;
-declare function shallowEqual<T>(a: T, b: T): boolean;
+declare function unwrap<T>(node: DeepSignalify<T>): T;
+declare function unwrap<T>(node: NodeAccessor<T> & DeepSignalify<T>): T;
+declare function unwrap<T>(node: NodeAccessor<T>): T;
+declare function unwrap<T>(node: unknown): T;
+
+declare function createEnhancer<I = unknown, O = unknown>(meta: EnhancerMeta, enhancerFn: (input: I) => O): EnhancerWithMeta<I, O>;
+declare function resolveEnhancerOrder(enhancers: EnhancerWithMeta<unknown, unknown>[], availableCapabilities?: Set<string>, debugMode?: boolean): EnhancerWithMeta<unknown, unknown>[];
+
+declare const SIGNAL_TREE_CONSTANTS: {
+    readonly MAX_PATH_CACHE_SIZE: 1000;
+    readonly LAZY_THRESHOLD: 50;
+    readonly ESTIMATE_MAX_DEPTH: 3;
+    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
+    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
+    readonly DEFAULT_CACHE_SIZE: 100;
+    readonly DEFAULT_BATCH_SIZE: 10;
+};
+declare const SIGNAL_TREE_MESSAGES: Readonly<{
+    readonly NULL_OR_UNDEFINED: "null/undefined";
+    readonly CIRCULAR_REF: "circular ref";
+    readonly UPDATER_INVALID: "updater invalid";
+    readonly LAZY_FALLBACK: "lazy fallback";
+    readonly SIGNAL_CREATION_FAILED: "signal creation failed";
+    readonly UPDATE_PATH_NOT_FOUND: "update path not found";
+    readonly UPDATE_FAILED: "update failed";
+    readonly ROLLBACK_FAILED: "rollback failed";
+    readonly CLEANUP_ERROR: "cleanup error";
+    readonly PRESET_UNKNOWN: "unknown preset";
+    readonly STRATEGY_SELECTION: "strategy select";
+    readonly TREE_DESTROYED: "destroyed";
+    readonly UPDATE_TRANSACTION: "update tx";
+    readonly BATCH_NOT_ENABLED: "batching disabled";
+    readonly MEMOIZE_NOT_ENABLED: "memoize disabled";
+    readonly MIDDLEWARE_NOT_AVAILABLE: "middleware missing";
+    readonly ENTITY_HELPERS_NOT_AVAILABLE: "entity helpers missing";
+    readonly ASYNC_ACTIONS_NOT_AVAILABLE: "async actions missing";
+    readonly TIME_TRAVEL_NOT_AVAILABLE: "time travel missing";
+    readonly OPTIMIZE_NOT_AVAILABLE: "optimize missing";
+    readonly CACHE_NOT_AVAILABLE: "cache missing";
+    readonly PERFORMANCE_NOT_ENABLED: "performance disabled";
+    readonly ENHANCER_ORDER_FAILED: "enhancer order failed";
+    readonly ENHANCER_CYCLE_DETECTED: "enhancer cycle";
+    readonly ENHANCER_REQUIREMENT_MISSING: "enhancer req missing";
+    readonly ENHANCER_PROVIDES_MISSING: "enhancer provides missing";
+    readonly ENHANCER_FAILED: "enhancer failed";
+    readonly ENHANCER_NOT_FUNCTION: "enhancer not function";
+    readonly EFFECT_NO_CONTEXT: "no angular context";
+    readonly SUBSCRIBE_NO_CONTEXT: "no angular context";
+}>;
 
-export { createLazySignalTree, deepEqual, equal, parsePath, shallowEqual, signalTree, terminalSignal };
-export type { AsyncAction, AsyncActionConfig, BuiltInObject, DeepSignalify, EntityHelpers, IsBuiltInObject, IsPrimitive, IsSignal, IsWritableSignal, Middleware, PerformanceMetrics, Primitive, SignalTree, TimeTravelEntry, TreeConfig, TreePreset };
+export { ENHANCER_META, SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, composeEnhancers, createEnhancer, createLazySignalTree, deepEqual, equal, isAnySignal, isBuiltInObject, isNodeAccessor, parsePath, resolveEnhancerOrder, signalTree, terminalSignal, unwrap };
+export type { AsyncAction, AsyncActionConfig, BuiltInObject, ChainResult, DeepSignalify, Enhancer, EnhancerMeta, EnhancerWithMeta, EntityHelpers, Middleware, PerformanceMetrics, Primitive, RemoveSignalMethods, SignalTree, TimeTravelEntry, TreeConfig, TreePreset, WithMethod };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "1.1.9",
+  "version": "2.0.1",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "peerDependencies": {
     "@angular/core": "^20.1.0"