@signaltree/core 5.1.6 → 6.0.1

package/dist/lib/types.js

@@ -1,9 +1,9 @@
-const ENHANCER_META = Symbol('signaltree:enhancer:meta');
 function entityMap(config) {
   return {
     __isEntityMap: true,
     __entityMapConfig: config ?? {}
   };
 }
+const ENHANCER_META = Symbol('signaltree:enhancer:meta');
 
 export { ENHANCER_META, entityMap };

package/dist/lib/utils.js

@@ -1,7 +1,7 @@
 import { isSignal, signal, runInInjectionContext, effect } from '@angular/core';
 import { isBuiltInObject } from '../is-built-in-object.js';
 
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('SignalTree:NodeAccessor');
 function isEntityMapMarker(value) {
   return Boolean(value && typeof value === 'object' && value.__isEntityMap === true);
 }
@@ -257,5 +257,43 @@ function unwrap(node) {
   }
   return result;
 }
+function snapshotState(state) {
+  return unwrap(state);
+}
+function applyState(stateNode, snapshot) {
+  if (snapshot === null || snapshot === undefined) return;
+  if (typeof snapshot !== 'object') return;
+  for (const key of Object.keys(snapshot)) {
+    const val = snapshot[key];
+    const target = stateNode[key];
+    if (isNodeAccessor(target)) {
+      if (val && typeof val === 'object') {
+        try {
+          applyState(target, val);
+        } catch {
+          try {
+            target(val);
+          } catch {}
+        }
+      } else {
+        try {
+          target(val);
+        } catch {}
+      }
+    } else if (isSignal(target)) {
+      try {
+        target.set?.(val);
+      } catch {
+        try {
+          target(val);
+        } catch {}
+      }
+    } else {
+      try {
+        stateNode[key] = val;
+      } catch {}
+    }
+  }
+}
 
-export { composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isNodeAccessor, toWritableSignal, unwrap };
+export { applyState, composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isEntityMapMarker, isNodeAccessor, snapshotState, toWritableSignal, unwrap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "5.1.6",
+  "version": "6.0.1",
   "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,
@@ -23,11 +23,6 @@
       "import": "./dist/enhancers/batching/index.js",
       "default": "./dist/enhancers/batching/index.js"
     },
-    "./enhancers/computed": {
-      "types": "./src/enhancers/computed/index.d.ts",
-      "import": "./dist/enhancers/computed/index.js",
-      "default": "./dist/enhancers/computed/index.js"
-    },
     "./enhancers/middleware": {
       "types": "./src/enhancers/middleware/index.d.ts",
       "import": "./dist/enhancers/middleware/index.js",

package/src/enhancers/batching/batching.d.ts

@@ -0,0 +1,11 @@
+import type { ISignalTree, Enhancer, BatchingConfig } from '../../lib/types';
+export type BatchingMethods<T> = import('../../lib/types').BatchingMethods<T>;
+export declare function batchingWithConfig<T>(config?: BatchingConfig): Enhancer<BatchingMethods<T>>;
+export declare function batching(config?: BatchingConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & BatchingMethods<any>;
+export declare function highPerformanceBatching<T>(): Enhancer<import("../../lib/types").BatchingMethods<T>>;
+export declare function flushBatchedUpdates(): void;
+export declare function hasPendingUpdates(): boolean;
+export declare function getBatchQueueSize(): number;
+export declare const withBatching: ((config?: BatchingConfig) => Enhancer<import("../../lib/types").BatchingMethods<unknown>>) & {
+    highPerformance: typeof highPerformanceBatching;
+};

package/src/enhancers/batching/index.d.ts

@@ -1 +1 @@
-export * from './lib/batching';
+export * from './batching';

package/src/enhancers/devtools/{lib/devtools.d.ts → devtools.d.ts}

@@ -1,5 +1,5 @@
 import { Signal } from '@angular/core';
-import type { SignalTree } from '../../../lib/types';
+import type { ISignalTree, DevToolsConfig, DevToolsMethods } from '../../lib/types';
 export interface ModuleMetadata {
     name: string;
     methods: string[];
@@ -39,7 +39,7 @@ export interface CompositionLogger {
         data: unknown;
     }>;
 }
-export interface ModularDevToolsInterface<_T = unknown> {
+export interface ModularDevToolsInterface {
     activityTracker: ModuleActivityTracker;
     logger: CompositionLogger;
     metrics: Signal<ModularPerformanceMetrics>;
@@ -57,21 +57,12 @@ export interface ModularDevToolsInterface<_T = unknown> {
         }>;
     };
 }
-export declare function withDevTools<T>(config?: {
-    enabled?: boolean;
-    treeName?: string;
-    enableBrowserDevTools?: boolean;
-    enableLogging?: boolean;
-    performanceThreshold?: number;
-}): (tree: SignalTree<T>) => SignalTree<T> & {
-    __devTools: ModularDevToolsInterface<T>;
-};
-export declare function enableDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
-    __devTools: ModularDevToolsInterface<T>;
-};
-export declare function withFullDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
-    __devTools: ModularDevToolsInterface<T>;
-};
-export declare function withProductionDevTools<T>(): (tree: SignalTree<T>) => SignalTree<T> & {
-    __devTools: ModularDevToolsInterface<T>;
+export declare function devTools(config?: DevToolsConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
+export declare function enableDevTools(treeName?: string): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
+export declare function fullDevTools(treeName?: string): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
+export declare function productionDevTools(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & DevToolsMethods;
+export declare const withDevTools: typeof devTools & {
+    production: typeof productionDevTools;
+    full: typeof fullDevTools;
+    enable: typeof enableDevTools;
 };

package/src/enhancers/devtools/devtools.types.d.ts

@@ -0,0 +1 @@
+export {};

package/src/enhancers/devtools/index.d.ts

@@ -1 +1 @@
-export * from './lib/devtools';
+export * from './devtools';

package/src/enhancers/effects/effects.d.ts

@@ -0,0 +1,9 @@
+import type { ISignalTree, EffectsMethods } from '../../lib/types';
+export interface EffectsConfig {
+    enabled?: boolean;
+}
+export declare function effects(config?: EffectsConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>;
+export declare function enableEffects(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>;
+export declare const withEffects: ((config?: EffectsConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any>) & {
+    enable: typeof enableEffects;
+};

package/src/enhancers/effects/effects.types.d.ts

@@ -0,0 +1 @@
+export {};

package/src/enhancers/effects/index.d.ts

@@ -0,0 +1 @@
+export * from './effects';

package/src/enhancers/entities/entities.d.ts

@@ -0,0 +1,11 @@
+import type { ISignalTree, EntitiesEnabled } from '../../lib/types';
+export interface EntitiesEnhancerConfig {
+    enabled?: boolean;
+}
+export declare function entities(config?: EntitiesEnhancerConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
+export declare function enableEntities(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
+export declare function highPerformanceEntities(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EntitiesEnabled;
+export declare const withEntities: typeof entities & {
+    highPerformance: typeof highPerformanceEntities;
+    enable: typeof enableEntities;
+};

package/src/enhancers/entities/entities.types.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1 @@
-export * from './lib/entities';
+export * from './entities';

package/src/enhancers/index.d.ts

@@ -1,3 +1,3 @@
-import type { EnhancerMeta, EnhancerWithMeta } from '../lib/types';
-export declare function createEnhancer<I = unknown, O = unknown>(meta: EnhancerMeta, enhancerFn: (input: I) => O): EnhancerWithMeta<I, O>;
-export declare function resolveEnhancerOrder(enhancers: EnhancerWithMeta<unknown, unknown>[], availableCapabilities?: Set<string>, debugMode?: boolean): EnhancerWithMeta<unknown, unknown>[];
+import type { EnhancerMeta, EnhancerWithMeta, Enhancer } from '../lib/types';
+export declare function createEnhancer<TAdded = unknown>(meta: EnhancerMeta, enhancerFn: Enhancer<TAdded>): EnhancerWithMeta<TAdded>;
+export declare function resolveEnhancerOrder(enhancers: EnhancerWithMeta<unknown>[], availableCapabilities?: Set<string>, debugMode?: boolean): EnhancerWithMeta<unknown>[];

package/src/enhancers/memoization/index.d.ts

@@ -1 +1 @@
-export * from './lib/memoization';
+export * from './memoization';

package/src/enhancers/memoization/memoization.d.ts

@@ -0,0 +1,54 @@
+import type { ISignalTree } from '../../lib/types';
+export declare function cleanupMemoizationCache(): void;
+import type { MemoizationConfig, MemoizationMethods } from '../../lib/types';
+export declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
+export declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
+export declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
+export declare const MEMOIZATION_PRESETS: {
+    readonly selector: {
+        readonly equality: "reference";
+        readonly maxCacheSize: 10;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+    readonly computed: {
+        readonly equality: "shallow";
+        readonly maxCacheSize: 100;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+    readonly deepState: {
+        readonly equality: "deep";
+        readonly maxCacheSize: 1000;
+        readonly enableLRU: true;
+        readonly ttl: number;
+    };
+    readonly highFrequency: {
+        readonly equality: "reference";
+        readonly maxCacheSize: 5;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+};
+export declare function selectorMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
+export declare function computedMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
+export declare function deepStateMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
+export declare function highFrequencyMemoization(): <S>(tree: ISignalTree<S>) => ISignalTree<S> & MemoizationMethods<S>;
+export declare const withMemoization: ((config?: MemoizationConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>) & {
+    selector: typeof selectorMemoization;
+    computed: typeof computedMemoization;
+    deep: typeof deepStateMemoization;
+    fast: typeof highFrequencyMemoization;
+};
+export declare function memoization(config?: MemoizationConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function enableMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function highPerformanceMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function lightweightMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function shallowMemoization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & MemoizationMethods<any>;
+export declare function clearAllCaches(): void;
+export declare function getGlobalCacheStats(): {
+    treeCount: number;
+    totalSize: number;
+    totalHits: number;
+    averageCacheSize: number;
+};

package/src/enhancers/memoization/memoization.types.d.ts

@@ -0,0 +1 @@
+export {};

package/src/enhancers/presets/lib/presets.d.ts

@@ -1,11 +1,8 @@
-import type { TreeConfig } from '../../../lib/types';
-export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+import { createDevTree, createMinimalTree, createProdTree } from '../../../lib/presets';
+import type { TreeConfig, TreePreset } from '../../../lib/types';
 export declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
 export declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
 export declare function validatePreset(preset: TreePreset): boolean;
 export declare function getAvailablePresets(): TreePreset[];
 export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
-export declare function createDevTree(overrides?: Partial<TreeConfig>): {
-    readonly config: TreeConfig;
-    readonly enhancer: (tree: import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>) => import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>;
-};
+export { createDevTree, createProdTree, createMinimalTree };

package/src/enhancers/serialization/index.d.ts

@@ -1,2 +1,2 @@
-export * from './lib/serialization';
+export * from './serialization';
 export * from './constants';

package/src/{serialization.d.ts → enhancers/serialization/serialization.d.ts}

@@ -1,5 +1,4 @@
-import type { SignalTree } from '../../../lib/types';
-import type { EnhancerWithMeta } from '../../../lib/types';
+import { ISignalTree } from '../../lib/types';
 export interface SerializationConfig {
     includeMetadata?: boolean;
     replacer?: (key: string, value: unknown) => unknown;
@@ -22,7 +21,7 @@ export interface SerializedState<T = unknown> {
         nodeMap?: Record<string, 'b' | 'r'>;
     };
 }
-export interface SerializableSignalTree<T> extends SignalTree<T> {
+export interface SerializableSignalTree<T> extends ISignalTree<T> {
     $: any;
     serialize(config?: SerializationConfig): string;
     deserialize(json: string, config?: SerializationConfig): void;
@@ -31,14 +30,23 @@ export interface SerializableSignalTree<T> extends SignalTree<T> {
     snapshot(): SerializedState<T>;
     restore(snapshot: SerializedState<T>): void;
 }
+export interface SerializationMethods {
+    serialize(config?: SerializationConfig): string;
+    deserialize(json: string, config?: SerializationConfig): void;
+    toJSON(): unknown;
+    fromJSON(data: unknown, metadata?: SerializedState<unknown>['metadata']): void;
+    snapshot(): SerializedState<unknown>;
+    restore(snapshot: SerializedState<unknown>): void;
+}
 export interface PersistenceMethods {
     save(): Promise<void>;
     load(): Promise<void>;
     clear(): Promise<void>;
     __flushAutoSave?: () => Promise<void>;
 }
-export declare function withSerialization<T extends Record<string, unknown> = Record<string, unknown>>(defaultConfig?: SerializationConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
-export declare function enableSerialization<T extends Record<string, unknown> = Record<string, unknown>>(): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
+export declare function serialization(defaultConfig?: SerializationConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
+export declare const withSerialization: (defaultConfig?: SerializationConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
+export declare function enableSerialization(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods;
 export interface StorageAdapter {
     getItem(key: string): string | null | Promise<string | null>;
     setItem(key: string, value: string): void | Promise<void>;
@@ -52,8 +60,9 @@ export interface PersistenceConfig extends SerializationConfig {
     autoLoad?: boolean;
     skipCache?: boolean;
 }
-export declare function withPersistence<T extends Record<string, unknown> = Record<string, unknown>>(config: PersistenceConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T> & PersistenceMethods>;
+export declare function persistence(config: PersistenceConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods & PersistenceMethods;
+export declare const withPersistence: (cfg: PersistenceConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & SerializationMethods & PersistenceMethods;
 export declare function createStorageAdapter(getItem: (key: string) => string | null | Promise<string | null>, setItem: (key: string, value: string) => void | Promise<void>, removeItem: (key: string) => void | Promise<void>): StorageAdapter;
 export declare function createIndexedDBAdapter(dbName?: string, storeName?: string): StorageAdapter;
-export declare function applySerialization<T extends Record<string, unknown>>(tree: SignalTree<T>): SerializableSignalTree<T>;
-export declare function applyPersistence<T extends Record<string, unknown>>(tree: SignalTree<T>, cfg: PersistenceConfig): SerializableSignalTree<T> & PersistenceMethods;
+export declare function applySerialization<T extends Record<string, unknown>>(tree: ISignalTree<T>): ISignalTree<T> & SerializationMethods;
+export declare function applyPersistence<T extends Record<string, unknown>>(tree: ISignalTree<T>, cfg: PersistenceConfig): ISignalTree<T> & SerializationMethods & PersistenceMethods;

package/src/enhancers/test-helpers/types-equals.d.ts

@@ -0,0 +1,2 @@
+export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+export type Assert<T extends true> = T;

package/src/enhancers/time-travel/index.d.ts

@@ -1 +1 @@
-export * from './lib/time-travel';
+export * from './time-travel';

package/src/enhancers/time-travel/time-travel.d.ts

@@ -0,0 +1,10 @@
+import type { ISignalTree, TimeTravelMethods, TimeTravelConfig, TimeTravelEntry } from '../../lib/types';
+export type { TimeTravelConfig, TimeTravelEntry };
+export declare function timeTravel(config?: TimeTravelConfig): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+export declare function enableTimeTravel(): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+export declare function timeTravelHistory(maxHistorySize: number): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+export declare const withTimeTravel: ((config?: TimeTravelConfig) => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods) & {
+    minimal: () => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+    debug: () => <Tree extends ISignalTree<any>>(tree: Tree) => Tree & TimeTravelMethods;
+    history: typeof timeTravelHistory;
+};

package/src/enhancers/time-travel/time-travel.types.d.ts

@@ -0,0 +1 @@
+export {};

package/src/enhancers/time-travel/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function deepClone<T>(obj: T): T;
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/src/enhancers/types.d.ts

@@ -1,74 +1 @@
-export interface BatchingConfig {
-    maxBatchSize?: number;
-    debounceMs?: number;
-    flushOnMicrotask?: boolean;
-}
-export interface BatchUpdate<T = unknown> {
-    path: string[];
-    value: T;
-    timestamp: number;
-}
-export interface ComputedSignal<T> {
-    (): T;
-    readonly value: T;
-}
-export interface ComputedConfig {
-    lazy?: boolean;
-    memoize?: boolean;
-}
-export interface MemoizationConfig {
-    maxSize?: number;
-    ttl?: number;
-    strategy?: 'lru' | 'fifo' | 'lfu';
-}
-export interface MemoizedFunction<T extends (...args: never[]) => unknown> {
-    (...args: Parameters<T>): ReturnType<T>;
-    clear(): void;
-    stats(): {
-        hits: number;
-        misses: number;
-        size: number;
-    };
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    enableCompression?: boolean;
-}
-export interface TimeTravelState {
-    canUndo: boolean;
-    canRedo: boolean;
-    historySize: number;
-    currentIndex: number;
-}
-export interface DevToolsConfig {
-    name?: string;
-    enabled?: boolean;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
-}
-export interface DevToolsAction {
-    type: string;
-    payload?: unknown;
-    timestamp: number;
-    source: string;
-}
-export interface PresetConfig {
-    name: string;
-    enhancers: unknown[];
-    config?: Record<string, unknown>;
-}
-export interface EntityConfig {
-    idField?: string;
-    indexes?: string[];
-    relations?: Record<string, string>;
-}
-export interface SerializationConfig {
-    includeComputed?: boolean;
-    includeMeta?: boolean;
-    customSerializers?: Record<string, (value: unknown) => unknown>;
-}
-export interface SerializedState {
-    version: string;
-    timestamp: number;
-    data: unknown;
-    meta?: Record<string, unknown>;
-}
+export { BatchingMethods, BatchingConfig, MemoizationMethods, MemoizationConfig, TimeTravelMethods, TimeTravelConfig, EffectsMethods, DevToolsMethods, DevToolsConfig, EntitiesEnabled, Enhancer, EnhancerWithMeta, EnhancerMeta, } from '../lib/types';

package/src/enhancers/typing/helpers-types.d.ts

@@ -0,0 +1,2 @@
+export type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+export type Assert<T extends true> = T;

package/src/index.d.ts

@@ -1,18 +1,17 @@
 export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, EntityHelpers, TimeTravelEntry, } from './lib/types';
+export type { ISignalTree, SignalTree, SignalTreeBase, FullSignalTree, ProdSignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, } from './lib/types';
 export { entityMap } from './lib/types';
 export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
 export { getPathNotifier } from './lib/path-notifier';
 export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
 export { ENHANCER_META } from './lib/types';
-export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
-export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
-export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
-export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
-export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
-export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
+export { batching, highPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/batching';
+export { memoization, selectorMemoization, computedMemoization, deepStateMemoization, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, shallowMemoization, memoize, memoizeShallow, memoizeReference, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/memoization';
+export { timeTravel, enableTimeTravel, } from './enhancers/time-travel/time-travel';
+export { entities, enableEntities, highPerformanceEntities, } from './enhancers/entities/entities';
+export { serialization, enableSerialization, persistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/serialization';
+export { devTools, enableDevTools, fullDevTools, productionDevTools, } from './enhancers/devtools/devtools';
 export { createAsyncOperation, trackAsync } from './lib/async-helpers';
 export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { computedEnhancer, createComputed, type ComputedConfig, type ComputedSignal, type ComputedSignalTree, } from './enhancers/computed/lib/computed';
 export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';

package/src/lib/async-helpers.d.ts

@@ -1,5 +1,5 @@
-import type { SignalTree } from './types';
-export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
+import type { ISignalTree } from './types';
+export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: ISignalTree<T>) => Promise<TResult>;
 export declare function trackAsync<T>(operation: () => Promise<T>): {
     pending: import("@angular/core").Signal<boolean>;
     error: import("@angular/core").Signal<Error | null>;

package/src/lib/dev-proxy.d.ts

@@ -0,0 +1,3 @@
+import type { ISignalTree } from './types';
+export declare function wrapWithDevProxy<T>(tree: ISignalTree<T>): ISignalTree<T>;
+export declare function shouldUseDevProxy(): boolean;

package/src/lib/presets.d.ts

@@ -0,0 +1,34 @@
+import type { ISignalTree, TreeConfig, BatchingConfig, MemoizationConfig, TimeTravelConfig, DevToolsConfig, BatchingMethods, MemoizationMethods, TimeTravelMethods, DevToolsMethods, EffectsMethods, EntitiesEnabled } from './types';
+export interface DevTreeConfig extends TreeConfig {
+    effects?: Record<string, never>;
+    batching?: BatchingConfig;
+    memoization?: MemoizationConfig;
+    timeTravel?: TimeTravelConfig;
+    devTools?: DevToolsConfig;
+    entities?: Record<string, never>;
+}
+export interface ProdTreeConfig extends TreeConfig {
+    effects?: Record<string, never>;
+    batching?: BatchingConfig;
+    memoization?: MemoizationConfig;
+    entities?: Record<string, never>;
+}
+export interface MinimalTreeConfig extends TreeConfig {
+    effects?: Record<string, never>;
+}
+export type FullSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled & TimeTravelMethods & DevToolsMethods;
+export type ProdSignalTree<T> = ISignalTree<T> & EffectsMethods<T> & BatchingMethods & MemoizationMethods<T> & EntitiesEnabled;
+export type MinimalSignalTree<T> = ISignalTree<T> & EffectsMethods<T>;
+export declare function createDevTree<T extends object>(initialState: T, config?: DevTreeConfig): FullSignalTree<T>;
+export declare function createDevTree(): {
+    enhancer: <Tree extends ISignalTree<any>>(tree: Tree) => Tree & EffectsMethods<any> & BatchingMethods & MemoizationMethods<any> & EntitiesEnabled & TimeTravelMethods & DevToolsMethods;
+};
+export declare function createProdTree<T extends object>(initialState: T, config?: ProdTreeConfig): ProdSignalTree<T>;
+export declare function createMinimalTree<T extends object>(initialState: T, config?: MinimalTreeConfig): MinimalSignalTree<T>;
+export declare const devTree: typeof createDevTree;
+export declare const prodTree: typeof createProdTree;
+export declare const minimalTree: typeof createMinimalTree;
+export declare function buildTree<T extends object>(initialState: T, config?: TreeConfig): {
+    add<R>(enhancer: (t: ISignalTree<T>) => R): any;
+    done(): ISignalTree<T>;
+};

package/src/lib/signal-tree.d.ts

@@ -1,8 +1,3 @@
-import type { SignalTree, TreeConfig, TreePreset, EnhancerWithMeta, NodeAccessor } from './types';
+import type { TreeConfig, NodeAccessor, ISignalTree } from './types';
 export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
-export declare function signalTree<T>(obj: T): SignalTree<T>;
-export declare function signalTree<T>(obj: T, preset: TreePreset): SignalTree<T>;
-export declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
-export declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset): SignalTree<Required<T>>;
-export declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
-export declare function applyEnhancer<T, O>(tree: SignalTree<T>, enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
+export declare function signalTree<T extends object>(initialState: T, config?: TreeConfig): ISignalTree<T>;