@signaltree/core 4.0.1 → 4.0.2

package/dist/enhancers/serialization/types/packages/core/src/lib/constants.d.ts

@@ -1,50 +0,0 @@
-/**
- * SignalTree Constants
- * Centralized configuration values and messages
- */
-export declare const SIGNAL_TREE_CONSTANTS: {
-    /** Cache configuration */
-    readonly MAX_PATH_CACHE_SIZE: any;
-    /** Performance thresholds */
-    readonly LAZY_THRESHOLD: 50;
-    readonly ESTIMATE_MAX_DEPTH: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
-    /** Default values */
-    readonly DEFAULT_CACHE_SIZE: 100;
-    readonly DEFAULT_BATCH_SIZE: 10;
-};
-export 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 UPDATE_OPTIMIZED_NOT_AVAILABLE: "update optimized 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";
-}>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/enhancers/serialization/types/packages/core/src/lib/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/constants.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB;IAChC,0BAA0B;;IAG1B,6BAA6B;;;;;IAM7B,qBAAqB;;;CAGb,CAAC;AAuEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC"}

package/dist/enhancers/serialization/types/packages/core/src/lib/memory/memory-manager.d.ts

@@ -1,145 +0,0 @@
-/**
- * Memory Manager for SignalTree
- * Provides automatic cleanup and memory leak prevention for lazy-loaded signal trees
- * @packageDocumentation
- */
-import type { WritableSignal } from '@angular/core';
-/**
- * Memory statistics for monitoring
- */
-export interface MemoryStats {
-    /** Total number of signals currently cached */
-    cachedSignals: number;
-    /** Number of signals cleaned up by FinalizationRegistry */
-    cleanedUpSignals: number;
-    /** Peak number of cached signals */
-    peakCachedSignals: number;
-    /** Number of manual dispose calls */
-    manualDisposes: number;
-    /** Estimated memory usage in bytes (approximate) */
-    estimatedMemoryBytes: number;
-}
-/**
- * Configuration for MemoryManager
- */
-export interface MemoryManagerConfig {
-    /**
-     * Enable automatic cleanup via FinalizationRegistry
-     * @default true
-     */
-    enableAutoCleanup?: boolean;
-    /**
-     * Enable debug logging for memory operations
-     * @default false
-     */
-    debugMode?: boolean;
-    /**
-     * Callback when signals are cleaned up
-     */
-    onCleanup?: (path: string, stats: MemoryStats) => void;
-}
-/**
- * SignalMemoryManager
- *
- * Manages memory for lazy-loaded signal trees using WeakRef and FinalizationRegistry.
- * Provides automatic cleanup when signals are no longer referenced, preventing memory leaks.
- *
- * Features:
- * - WeakRef caches allow garbage collection when signals are unused
- * - FinalizationRegistry automatically cleans up after GC
- * - Stats API for memory profiling and monitoring
- * - Manual dispose() for explicit cleanup
- *
- * @example
- * ```ts
- * const manager = new SignalMemoryManager({
- *   enableAutoCleanup: true,
- *   onCleanup: (path, stats) => {
- *     console.log(`Cleaned up signal at ${path}`, stats);
- *   }
- * });
- *
- * // Cache a signal
- * manager.cacheSignal('user.name', nameSignal);
- *
- * // Get cached signal (returns undefined if GC'd)
- * const signal = manager.getSignal('user.name');
- *
- * // Get memory stats
- * const stats = manager.getStats();
- * console.log(`Memory: ${stats.estimatedMemoryBytes} bytes`);
- *
- * // Dispose all cached signals
- * manager.dispose();
- * ```
- */
-export declare class SignalMemoryManager {
-    private cache;
-    private registry;
-    private config;
-    private stats;
-    constructor(config?: MemoryManagerConfig);
-    /**
-     * Cache a signal with WeakRef for automatic garbage collection
-     *
-     * @param path - Dot-notation path to the signal
-     * @param signal - The signal to cache
-     */
-    cacheSignal<T>(path: string, signal: WritableSignal<T>): void;
-    /**
-     * Get a cached signal
-     * Returns undefined if the signal has been garbage collected
-     *
-     * @param path - Dot-notation path to the signal
-     * @returns The signal or undefined if GC'd
-     */
-    getSignal(path: string): WritableSignal<unknown> | undefined;
-    /**
-     * Check if a signal is cached (even if potentially GC'd)
-     *
-     * @param path - Dot-notation path to the signal
-     * @returns true if the path exists in cache
-     */
-    hasSignal(path: string): boolean;
-    /**
-     * Remove a signal from the cache
-     *
-     * @param path - Dot-notation path to the signal
-     * @returns true if the signal was removed
-     */
-    removeSignal(path: string): boolean;
-    /**
-     * Handle automatic cleanup from FinalizationRegistry
-     * @private
-     */
-    private handleCleanup;
-    /**
-     * Get current memory statistics
-     *
-     * @returns Current memory stats
-     */
-    getStats(): MemoryStats;
-    /**
-     * Dispose all cached signals and clean up resources
-     * Call this when destroying a SignalTree to prevent memory leaks
-     */
-    dispose(): void;
-    /**
-     * Get all cached signal paths (for debugging)
-     *
-     * @returns Array of cached signal paths
-     */
-    getCachedPaths(): string[];
-    /**
-     * Clear all stale entries (where signals have been GC'd)
-     * Useful for freeing up cache Map memory
-     *
-     * @returns Number of stale entries removed
-     */
-    clearStale(): number;
-    /**
-     * Reset all statistics
-     */
-    resetStats(): void;
-}
-//# sourceMappingURL=memory-manager.d.ts.map

package/dist/enhancers/serialization/types/packages/core/src/lib/memory/memory-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-manager.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/memory/memory-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,aAAa,EAAE,MAAM,CAAC;IAEtB,2DAA2D;IAC3D,gBAAgB,EAAE,MAAM,CAAC;IAEzB,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAE1B,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAC;IAEvB,oDAAoD;IACpD,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CACxD;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,QAAQ,CAA6C;IAC7D,OAAO,CAAC,MAAM,CAAgC;IAG9C,OAAO,CAAC,KAAK,CAIX;gBAEU,MAAM,GAAE,mBAAwB;IA6B5C;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI;IAgC7D;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,SAAS;IAwB5D;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIhC;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAsBnC;;;OAGG;IACH,OAAO,CAAC,aAAa;IAarB;;;;OAIG;IACH,QAAQ,IAAI,WAAW;IAyBvB;;;OAGG;IACH,OAAO,IAAI,IAAI;IA0Bf;;;;OAIG;IACH,cAAc,IAAI,MAAM,EAAE;IAa1B;;;;;OAKG;IACH,UAAU,IAAI,MAAM;IAiBpB;;OAEG;IACH,UAAU,IAAI,IAAI;CAWnB"}

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/diff-engine.d.ts

@@ -1,109 +0,0 @@
-/**
- * DiffEngine - Efficient change detection for tree updates
- * @packageDocumentation
- */
-import type { Path } from './path-index';
-/**
- * Type of change detected
- */
-export declare enum ChangeType {
-    ADD = "add",
-    UPDATE = "update",
-    DELETE = "delete",
-    REPLACE = "replace"
-}
-/**
- * A detected change
- */
-export interface Change {
-    /** Type of change */
-    type: ChangeType;
-    /** Path to the changed value */
-    path: Path;
-    /** New value */
-    value?: unknown;
-    /** Old value (for updates/deletes) */
-    oldValue?: unknown;
-}
-/**
- * Diff result
- */
-export interface Diff {
-    /** List of changes */
-    changes: Change[];
-    /** Whether any changes were detected */
-    hasChanges: boolean;
-}
-/**
- * Configuration for diff operation
- */
-export interface DiffOptions {
-    /** Maximum depth to traverse */
-    maxDepth?: number;
-    /** Whether to detect deletions */
-    detectDeletions?: boolean;
-    /** Whether to ignore array order */
-    ignoreArrayOrder?: boolean;
-    /** Custom equality function */
-    equalityFn?: (a: unknown, b: unknown) => boolean;
-    /** Optional key validator for security (e.g., to prevent prototype pollution) */
-    keyValidator?: (key: string) => boolean;
-}
-/**
- * DiffEngine
- *
- * Efficiently detects changes between two objects to minimize unnecessary updates.
- *
- * Features:
- * - Deep object comparison
- * - Circular reference detection
- * - Configurable equality checking
- * - Array diffing (ordered and unordered)
- * - Path tracking for precise updates
- *
- * @example
- * ```ts
- * const engine = new DiffEngine();
- *
- * const current = { user: { name: 'Alice', age: 30 } };
- * const updates = { user: { name: 'Alice', age: 31 } };
- *
- * const diff = engine.diff(current, updates);
- *
- * console.log(diff.changes);
- * // [{ type: 'update', path: ['user', 'age'], value: 31, oldValue: 30 }]
- * ```
- */
-export declare class DiffEngine {
-    private defaultOptions;
-    /**
-     * Diff two objects and return changes
-     *
-     * @param current - Current state
-     * @param updates - Updated state
-     * @param options - Diff options
-     * @returns Diff result with all changes
-     */
-    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
-    /**
-     * Traverse and compare objects recursively
-     */
-    private traverse;
-    /**
-     * Diff arrays
-     */
-    private diffArrays;
-    /**
-     * Diff arrays in order (index-based)
-     */
-    private diffArraysOrdered;
-    /**
-     * Diff arrays ignoring order (value-based)
-     */
-    private diffArraysUnordered;
-    /**
-     * Stringify value for set comparison
-     */
-    private stringify;
-}
-//# sourceMappingURL=diff-engine.d.ts.map

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/diff-engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"diff-engine.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/performance/diff-engine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC;;GAEG;AACH,oBAAY,UAAU;IACpB,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,qBAAqB;IACrB,IAAI,EAAE,UAAU,CAAC;IAEjB,gCAAgC;IAChC,IAAI,EAAE,IAAI,CAAC;IAEX,gBAAgB;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,sBAAsB;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,wCAAwC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,gCAAgC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,kCAAkC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,oCAAoC;IACpC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,+BAA+B;IAC/B,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAEjD,iFAAiF;IACjF,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AASD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,cAAc,CAMpB;IAEF;;;;;;;OAOG;IACH,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI;IAazE;;OAEG;IACH,OAAO,CAAC,QAAQ;IA4FhB;;OAEG;IACH,OAAO,CAAC,UAAU;IA2BlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4CzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;OAEG;IACH,OAAO,CAAC,SAAS;CAOlB"}

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/path-index.d.ts

@@ -1,120 +0,0 @@
-/**
- * PathIndex - Fast signal lookup using Trie data structure
- * @packageDocumentation
- */
-import type { WritableSignal } from '@angular/core';
-/**
- * Path segment (string or number for array indices)
- */
-export type PathSegment = string | number;
-/**
- * Path as array of segments
- */
-export type Path = PathSegment[];
-/**
- * PathIndex
- *
- * Fast signal lookup using a Trie (prefix tree) data structure.
- * Provides O(k) lookup time where k is the path length, regardless of total signals.
- *
- * Features:
- * - Trie-based indexing for O(k) lookup
- * - WeakRef caching for memory efficiency
- * - Automatic cleanup of stale references
- * - Prefix matching for batch operations
- * - Path normalization
- *
- * @example
- * ```ts
- * const index = new PathIndex();
- *
- * // Index signals
- * index.set(['user', 'name'], nameSignal);
- * index.set(['user', 'email'], emailSignal);
- *
- * // Fast lookup
- * const signal = index.get(['user', 'name']);
- *
- * // Prefix matching
- * const userSignals = index.getByPrefix(['user']);
- * // Returns: { name: nameSignal, email: emailSignal }
- *
- * // Check if path exists
- * if (index.has(['user', 'name'])) {
- *   // ...
- * }
- * ```
- */
-export declare class PathIndex<T extends object = WritableSignal<any>> {
-    private root;
-    private pathCache;
-    private stats;
-    /**
-     * Set a value at the given path
-     *
-     * @param path - Path segments
-     * @param value - Value to store
-     */
-    set(path: Path, signal: T): void;
-    /**
-     * Get value at the given path
-     *
-     * @param path - Path segments
-     * @returns Value if found and not GC'd, null otherwise
-     */
-    get(path: Path): T | null;
-    /**
-     * Check if path exists in index
-     *
-     * @param path - Path segments
-     * @returns True if path exists and value is not GC'd
-     */
-    has(path: Path): boolean;
-    /**
-     * Get all values matching a prefix
-     *
-     * @param prefix - Path prefix
-     * @returns Map of relative paths to values
-     */
-    getByPrefix(prefix: Path): Map<string, T>;
-    /**
-     * Delete value at path
-     *
-     * @param path - Path segments
-     * @returns True if deleted, false if not found
-     */
-    delete(path: Path): boolean;
-    /**
-     * Clear all entries
-     */
-    clear(): void;
-    /**
-     * Get statistics
-     *
-     * @returns Index statistics
-     */
-    getStats(): {
-        hits: number;
-        misses: number;
-        sets: number;
-        cleanups: number;
-        hitRate: number;
-        cacheSize: number;
-    };
-    /**
-     * Build index from a tree structure
-     *
-     * @param tree - Tree object to index
-     * @param path - Current path (for recursion)
-     */
-    buildFromTree(tree: unknown, path?: Path): void;
-    /**
-     * Convert path to string for caching
-     */
-    private pathToString;
-    /**
-     * Collect all descendant values recursively
-     */
-    private collectDescendants;
-}
-//# sourceMappingURL=path-index.d.ts.map

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/path-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-index.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/performance/path-index.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,WAAW,EAAE,CAAC;AAUjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,qBAAa,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC;IAC3D,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,KAAK,CAKX;IAEF;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI;IAyBhC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,GAAG,IAAI;IA4CzB;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAIxB;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,IAAI,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;IAmBzC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAsC3B;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;OAIG;IACH,QAAQ,IAAI;QACV,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB;IAWD;;;;;OAKG;IACH,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,GAAE,IAAS,GAAG,IAAI;IAsBnD;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAkB3B"}

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/update-engine.d.ts

@@ -1,116 +0,0 @@
-import { PathIndex } from './path-index';
-import type { DiffOptions } from './diff-engine';
-/**
- * OptimizedUpdateEngine - High-performance tree updates
- * @packageDocumentation
- */
-/**
- * Update options
- */
-export interface UpdateOptions extends DiffOptions {
-    /** Whether to batch updates */
-    batch?: boolean;
-    /** Batch size for chunked updates */
-    batchSize?: number;
-}
-/**
- * Update result
- */
-export interface UpdateResult {
-    /** Whether any changes were made */
-    changed: boolean;
-    /** Update duration in milliseconds */
-    duration: number;
-    /** List of changed paths */
-    changedPaths: string[];
-    /** Update statistics */
-    stats?: {
-        totalPaths: number;
-        optimizedPaths: number;
-        batchedUpdates: number;
-    };
-}
-/**
- * OptimizedUpdateEngine
- *
- * High-performance update engine using path indexing and diffing to minimize
- * unnecessary signal updates.
- *
- * Features:
- * - Diff-based updates (only update what changed)
- * - Path indexing for O(k) lookups
- * - Automatic batching for large updates
- * - Priority-based patch ordering
- * - Skip unchanged values
- *
- * @example
- * ```ts
- * const tree = signalTree(data, { useLazySignals: true });
- * const engine = new OptimizedUpdateEngine(tree);
- *
- * // Optimized update - only changes what's different
- * const result = engine.update({
- *   user: { name: 'Alice' } // Only updates if name changed
- * });
- *
- * console.log(result.changedPaths); // ['user.name']
- * console.log(result.duration); // ~2ms
- * ```
- */
-export declare class OptimizedUpdateEngine {
-    private pathIndex;
-    private diffEngine;
-    constructor(tree: unknown);
-    /**
-     * Update tree with optimizations
-     *
-     * @param tree - Current tree state
-     * @param updates - Updates to apply
-     * @param options - Update options
-     * @returns Update result
-     */
-    update(tree: unknown, updates: unknown, options?: UpdateOptions): UpdateResult;
-    /**
-     * Rebuild path index from current tree state
-     *
-     * @param tree - Current tree
-     */
-    rebuildIndex(tree: unknown): void;
-    /**
-     * Get path index statistics
-     */
-    getIndexStats(): ReturnType<PathIndex['getStats']>;
-    /**
-     * Creates optimized patches from diff changes
-     */
-    private createPatches;
-    /**
-     * Creates a single patch from a change
-     */
-    private createPatch;
-    /**
-     * Calculates update priority for optimal ordering
-     */
-    private calculatePriority;
-    /**
-     * Sorts patches for optimal application
-     */
-    private sortPatches;
-    /**
-     * Applies patches directly (no batching)
-     */
-    private applyPatches;
-    /**
-     * Applies patches with batching for better performance
-     */
-    private batchApplyPatches;
-    /**
-     * Applies a single patch to the tree object
-     */
-    private applyPatch;
-    /**
-     * Check equality
-     */
-    private isEqual;
-}
-//# sourceMappingURL=update-engine.d.ts.map

package/dist/enhancers/serialization/types/packages/core/src/lib/performance/update-engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update-engine.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/performance/update-engine.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,KAAK,EAAU,WAAW,EAAE,MAAM,eAAe,CAAC;AAEzD;;;GAGG;AACH;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,+BAA+B;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,OAAO,EAAE,OAAO,CAAC;IAEjB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,wBAAwB;IACxB,KAAK,CAAC,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;gBAEnB,IAAI,EAAE,OAAO;IAQzB;;;;;;;OAOG;IACH,MAAM,CACJ,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,aAAkB,GAC1B,YAAY;IA+Cf;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAKjC;;OAEG;IACH,aAAa,IAAI,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAIlD;;OAEG;IACH,OAAO,CAAC,aAAa;IAuCrB;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAYnB;;OAEG;IACH,OAAO,CAAC,YAAY;IAkBpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA+BzB;;OAEG;IACH,OAAO,CAAC,UAAU;IA6ClB;;OAEG;IACH,OAAO,CAAC,OAAO;CAmBhB"}