@signaltree/core 6.0.0 → 6.0.1

package/dist/lib/utils.js

@@ -0,0 +1,299 @@
+import { isSignal, signal, runInInjectionContext, effect } from '@angular/core';
+import { isBuiltInObject } from '../is-built-in-object.js';
+
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('SignalTree:NodeAccessor');
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value.__isEntityMap === true);
+}
+function isNodeAccessor(value) {
+  return typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value;
+}
+function isAnySignal(value) {
+  return isSignal(value) || isNodeAccessor(value);
+}
+function toWritableSignal(node, injector) {
+  const sig = signal(node());
+  const originalSet = sig.set.bind(sig);
+  const runner = () => {
+    originalSet(node());
+  };
+  if (injector) {
+    runInInjectionContext(injector, () => effect(runner));
+  } else {
+    try {
+      effect(runner);
+    } catch {
+      console.warn('[SignalTree] toWritableSignal called without injection context; pass Injector for reactivity.');
+    }
+  }
+  sig.set = value => {
+    node(value);
+    originalSet(value);
+  };
+  sig.update = updater => {
+    sig.set(updater(sig()));
+  };
+  return sig;
+}
+function composeEnhancers(...enhancers) {
+  return tree => enhancers.reduce((t, e) => e(t), tree);
+}
+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 (value && typeof value === 'object' && typeof value.addOne === 'function' && typeof value.all === 'function') {
+        return value;
+      }
+      if (isEntityMapMarker(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;
+}
+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;
+}
+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 { applyState, composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isEntityMapMarker, isNodeAccessor, snapshotState, toWritableSignal, unwrap };

package/dist/lru-cache.js

@@ -0,0 +1,64 @@
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+      throw new Error('LRUCache maxSize must be a positive, finite number');
+    }
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+  get(key) {
+    if (!this.cache.has(key)) return undefined;
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  forEach(callback) {
+    this.cache.forEach((value, key) => callback(value, key));
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  resize(newSize) {
+    if (!Number.isFinite(newSize) || newSize <= 0) {
+      throw new Error('LRUCache newSize must be a positive, finite number');
+    }
+    this.maxSize = newSize;
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === undefined) break;
+      this.cache.delete(oldestKey);
+    }
+  }
+}
+
+export { LRUCache };

package/dist/parse-path.js

@@ -0,0 +1,13 @@
+import { DEFAULT_PATH_CACHE_SIZE } from './constants.js';
+import { LRUCache } from './lru-cache.js';
+
+const pathCache = new LRUCache(DEFAULT_PATH_CACHE_SIZE);
+function parsePath(path) {
+  const cached = pathCache.get(path);
+  if (cached) return cached;
+  const segments = path.split('.');
+  pathCache.set(path, segments);
+  return segments;
+}
+
+export { parsePath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "6.0.0",
+  "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,

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/batching.types.d.ts

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

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

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

package/src/enhancers/batching/test-setup.d.ts

@@ -0,0 +1,3 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';

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

@@ -0,0 +1,68 @@
+import { Signal } from '@angular/core';
+import type { ISignalTree, DevToolsConfig, DevToolsMethods } from '../../lib/types';
+export interface ModuleMetadata {
+    name: string;
+    methods: string[];
+    addedAt: Date;
+    lastActivity: Date;
+    operationCount: number;
+    averageExecutionTime: number;
+    errorCount: number;
+}
+export interface ModularPerformanceMetrics {
+    totalUpdates: number;
+    moduleUpdates: Record<string, number>;
+    modulePerformance: Record<string, number>;
+    compositionChain: string[];
+    signalGrowth: Record<string, number>;
+    memoryDelta: Record<string, number>;
+    moduleCacheStats: Record<string, {
+        hits: number;
+        misses: number;
+    }>;
+}
+export interface ModuleActivityTracker {
+    trackMethodCall: (module: string, method: string, duration: number) => void;
+    trackError: (module: string, error: Error, context?: string) => void;
+    getModuleActivity: (module: string) => ModuleMetadata | undefined;
+    getAllModules: () => ModuleMetadata[];
+}
+export interface CompositionLogger {
+    logComposition: (modules: string[], action: 'with' | 'enhance') => void;
+    logMethodExecution: (module: string, method: string, args: unknown[], result: unknown) => void;
+    logStateChange: (module: string, path: string, oldValue: unknown, newValue: unknown) => void;
+    logPerformanceWarning: (module: string, operation: string, duration: number, threshold: number) => void;
+    exportLogs: () => Array<{
+        timestamp: Date;
+        module: string;
+        type: 'composition' | 'method' | 'state' | 'performance';
+        data: unknown;
+    }>;
+}
+export interface ModularDevToolsInterface {
+    activityTracker: ModuleActivityTracker;
+    logger: CompositionLogger;
+    metrics: Signal<ModularPerformanceMetrics>;
+    trackComposition: (modules: string[]) => void;
+    startModuleProfiling: (module: string) => string;
+    endModuleProfiling: (profileId: string) => void;
+    connectDevTools: (treeName: string) => void;
+    exportDebugSession: () => {
+        metrics: ModularPerformanceMetrics;
+        modules: ModuleMetadata[];
+        logs: Array<unknown>;
+        compositionHistory: Array<{
+            timestamp: Date;
+            chain: string[];
+        }>;
+    };
+}
+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

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

package/src/enhancers/devtools/test-setup.d.ts

@@ -0,0 +1,3 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';

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

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

package/src/enhancers/entities/test-setup.d.ts

@@ -0,0 +1,3 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';

package/src/enhancers/index.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+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/memoization/test-setup.d.ts

@@ -0,0 +1,3 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';

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

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

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

@@ -0,0 +1,8 @@
+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 { createDevTree, createProdTree, createMinimalTree };

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

@@ -0,0 +1,14 @@
+export declare const TYPE_MARKERS: {
+    readonly DATE: "§d";
+    readonly REGEXP: "§r";
+    readonly MAP: "§m";
+    readonly SET: "§s";
+    readonly UNDEFINED: "§u";
+    readonly NAN: "§n";
+    readonly INFINITY: "§i";
+    readonly NEG_INFINITY: "§-i";
+    readonly BIGINT: "§b";
+    readonly SYMBOL: "§y";
+    readonly FUNCTION: "§f";
+    readonly CIRCULAR: "§c";
+};

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

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