@signaltree/core 5.1.0 → 5.1.1

package/dist/lib/utils.js

@@ -1,254 +0,0 @@
-import { isSignal, signal, runInInjectionContext, effect } from '@angular/core';
-import { isBuiltInObject } from '../is-built-in-object.js';
-
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
-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 (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;
-}
-
-export { composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isNodeAccessor, toWritableSignal, unwrap };

package/dist/lru-cache.js

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

@@ -1,13 +0,0 @@
-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/src/enhancers/batching/index.d.ts

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

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

@@ -1,16 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-interface BatchingConfig {
-    enabled?: boolean;
-    maxBatchSize?: number;
-    autoFlushDelay?: number;
-    batchTimeoutMs?: number;
-}
-interface BatchingSignalTree<T> extends SignalTree<T> {
-    batchUpdate(updater: (current: T) => Partial<T>): void;
-}
-export declare function withBatching<T>(config?: BatchingConfig): (tree: SignalTree<T>) => BatchingSignalTree<T>;
-export declare function withHighPerformanceBatching<T>(): (tree: SignalTree<T>) => BatchingSignalTree<T>;
-export declare function flushBatchedUpdates(): void;
-export declare function hasPendingUpdates(): boolean;
-export declare function getBatchQueueSize(): number;
-export {};

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

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

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

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

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

@@ -1,12 +0,0 @@
-import { Signal } from '@angular/core';
-import type { TreeNode, SignalTree } from '../../../lib/types';
-export interface ComputedConfig {
-    lazy?: boolean;
-    memoize?: boolean;
-}
-export type ComputedSignal<T> = Signal<T>;
-export interface ComputedSignalTree<T extends Record<string, unknown>> extends SignalTree<T> {
-    computed<U>(computeFn: (tree: TreeNode<T>) => U): ComputedSignal<U>;
-}
-export declare function computedEnhancer(_config?: ComputedConfig): import("../../../lib/types").EnhancerWithMeta<SignalTree<Record<string, unknown>>, ComputedSignalTree<Record<string, unknown>>>;
-export declare function createComputed<T>(dependencies: readonly Signal<unknown>[], computeFn: () => T): ComputedSignal<T>;

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

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

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

@@ -1,77 +0,0 @@
-import { Signal } from '@angular/core';
-import type { SignalTree } 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<_T = unknown> {
-    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 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>;
-};

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

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

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

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

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

@@ -1,20 +0,0 @@
-import type { EntitySignal, SignalTree, EntityAwareTreeNode } from '../../../lib/types';
-interface EntitiesEnhancerConfig {
-    enabled?: boolean;
-}
-export declare function withEntities(config?: EntitiesEnhancerConfig): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
-};
-export {};

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

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

package/src/enhancers/index.d.ts

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

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

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

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

@@ -1,65 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-export interface MemoizedSignalTree<T> extends SignalTree<T> {
-    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
-    clearMemoCache: (key?: string) => void;
-    getCacheStats: () => {
-        size: number;
-        hitRate: number;
-        totalHits: number;
-        totalMisses: number;
-        keys: string[];
-    };
-}
-export declare function cleanupMemoizationCache(): void;
-export interface MemoizationConfig {
-    enabled?: boolean;
-    maxCacheSize?: number;
-    ttl?: number;
-    equality?: 'deep' | 'shallow' | 'reference';
-    enableLRU?: boolean;
-}
-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 withSelectorMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withComputedMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withDeepStateMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withHighFrequencyMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withMemoization<T>(config?: MemoizationConfig): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function enableMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withHighPerformanceMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withLightweightMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function withShallowMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-export declare function clearAllCaches(): void;
-export declare function getGlobalCacheStats(): {
-    treeCount: number;
-    totalSize: number;
-    totalHits: number;
-    averageCacheSize: number;
-};

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

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

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

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

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

@@ -1,11 +0,0 @@
-import type { TreeConfig } from '../../../lib/types';
-export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
-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>;
-};

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

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

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

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

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

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

@@ -1,59 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-import type { EnhancerWithMeta } from '../../../lib/types';
-export interface SerializationConfig {
-    includeMetadata?: boolean;
-    replacer?: (key: string, value: unknown) => unknown;
-    reviver?: (key: string, value: unknown) => unknown;
-    preserveTypes?: boolean;
-    maxDepth?: number;
-    handleCircular?: boolean;
-}
-export interface SerializedState<T = unknown> {
-    data: T;
-    metadata?: {
-        timestamp: number;
-        version: string;
-        appVersion?: string;
-        types?: Record<string, string>;
-        circularRefs?: Array<{
-            path: string;
-            targetPath: string;
-        }>;
-        nodeMap?: Record<string, 'b' | 'r'>;
-    };
-}
-export interface SerializableSignalTree<T> extends SignalTree<T> {
-    $: any;
-    serialize(config?: SerializationConfig): string;
-    deserialize(json: string, config?: SerializationConfig): void;
-    toJSON(): T;
-    fromJSON(data: T, metadata?: SerializedState<T>['metadata']): void;
-    snapshot(): SerializedState<T>;
-    restore(snapshot: SerializedState<T>): 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 interface StorageAdapter {
-    getItem(key: string): string | null | Promise<string | null>;
-    setItem(key: string, value: string): void | Promise<void>;
-    removeItem(key: string): void | Promise<void>;
-}
-export interface PersistenceConfig extends SerializationConfig {
-    key: string;
-    storage?: StorageAdapter;
-    autoSave?: boolean;
-    debounceMs?: number;
-    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 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;