@signaltree/core 3.1.0 → 4.0.1

package/dist/enhancers/presets/types/packages/core/src/enhancers/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * SignalTree Enhancers Types
+ * Type definitions for all enhancers
+ *
+ * @packageDocumentation
+ */
+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 MiddlewareConfig {
+    beforeUpdate?: (path: string[], value: unknown) => void | boolean;
+    afterUpdate?: (path: string[], value: unknown, previousValue: unknown) => void;
+    beforeRead?: (path: string[]) => void;
+    afterRead?: (path: string[], value: unknown) => void;
+}
+export interface MiddlewareContext {
+    path: string[];
+    value: unknown;
+    previousValue?: unknown;
+    operation: 'read' | 'write';
+}
+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 EntityCollection<T = unknown> {
+    add(entity: T): void;
+    remove(id: string | number): boolean;
+    update(id: string | number, updates: Partial<T>): boolean;
+    get(id: string | number): T | undefined;
+    find(predicate: (entity: T) => boolean): T | undefined;
+    filter(predicate: (entity: T) => boolean): T[];
+    count(): number;
+}
+export interface AsyncConfig {
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export interface AsyncAction<T = unknown> {
+    execute(): Promise<T>;
+    cancel(): void;
+    status: 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
+}
+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>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/enhancers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/enhancers/types.ts"],"names":[],"mappings":"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"}

package/dist/enhancers/presets/types/packages/core/src/index.d.ts

@@ -0,0 +1,119 @@
+/**
+ * SignalTree v1.1.6
+ * A reactive state management library for Angular
+ *
+ * Provides reactive state management with deep signal trees, enhancer system,
+ * and performance optimizations including lazy loading and batch updates.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Main factory function to create a SignalTree
+ * @see {@link signalTree}
+ */
+export { signalTree } from './lib/signal-tree';
+export type { SignalTree, TreeNode, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, Middleware, PerformanceMetrics, EntityHelpers, AsyncActionConfig, AsyncAction, TimeTravelEntry, } from './lib/types';
+export { equal, deepEqual, isNodeAccessor, isAnySignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
+/**
+ * Security utilities for preventing common vulnerabilities
+ * @see {@link SecurityValidator} for validation and sanitization
+ * @see {@link SecurityPresets} for common security configurations
+ */
+export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
+/**
+ * Enhancer creation and composition utilities
+ * @see {@link createEnhancer} for creating enhancers with metadata
+ * @see {@link resolveEnhancerOrder} for dependency resolution
+ */
+export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
+/**
+ * Enhancer metadata symbol for third-party compatibility
+ */
+export { ENHANCER_META } from './lib/types';
+/**
+ * Batching enhancer for high-performance state updates
+ * @see {@link withBatching} for intelligent batching capabilities
+ */
+export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
+/**
+ * Memoization enhancer for performance optimization
+ * @see {@link withMemoization} for intelligent memoization capabilities
+ */
+export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
+/**
+ * Time travel enhancer for debugging and undo/redo functionality
+ * @see {@link withTimeTravel} for time travel capabilities
+ */
+export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
+/**
+ * Entities enhancer for normalized collection helpers
+ * @see {@link withEntities}
+ */
+export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
+/**
+ * Serialization enhancer for state persistence and restoration
+ * @see {@link withSerialization} for serialization capabilities
+ */
+export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
+/**
+ * Preset configurations for common use cases
+ * @see {@link createPresetConfig} for preset configuration
+ */
+export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
+/**
+ * Configuration constants and error messages
+ * Exposed for library extensions and debugging
+ * @see {@link SIGNAL_TREE_CONSTANTS} for configuration values
+ * @see {@link SIGNAL_TREE_MESSAGES} for error/warning messages
+ */
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';
+/**
+ * SignalTree Core API Summary:
+ *
+ * **Main Factory:**
+ * - `signalTree(state, config?)` - Create a reactive signal tree
+ *
+ * **Core Types:**
+ * - `SignalTree<T>` - Main interface for signal trees
+ * - `TreeNode<T>` - Type transformation for nested signals
+ * - `TreeConfig` - Configuration options
+ *
+ * **Utilities:**
+ * - `equal()` / `deepEqual()` - Comparison functions
+ *
+ * **Enhancer System:**
+ * - `createEnhancer()` - Create enhancers with metadata
+ * - `composeEnhancers()` - Combine multiple enhancers
+ *
+ * **Advanced:**
+ * - `createLazySignalTree()` - For performance optimizations
+ * - Constants and messages for extensions
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { signalTree } from '@signaltree/core';
+ *
+ * const state = signalTree({ count: 0, user: { name: 'John' } });
+ *
+ * // Access signals
+ * console.log(state.count()); // 0
+ * console.log(state.user.name()); // 'John'
+ *
+ * // Update values
+ * state.count.set(5);
+ * state.user.name.set('Jane');
+ * ```
+ *
+ * @example With Enhancers
+ * ```typescript
+ * import { signalTree, createEnhancer } from '@signaltree/core';
+ *
+ * const logger = createEnhancer(
+ *   { name: 'logger', provides: ['logging'] },
+ *   (tree) => ({ ...tree, log: () => console.log(tree) })
+ * );
+ *
+ * const state = signalTree({ count: 0 }, { enhancers: [logger] });
+ * ```
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/enhancers/presets/types/packages/core/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAM/C,YAAY,EAEV,UAAU,EACV,QAAQ,EACR,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,KAAK,EAGL,UAAU,EACV,UAAU,EAGV,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,UAAU,EAGV,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,eAAe,GAChB,MAAM,aAAa,CAAC;AAMrB,OAAO,EAEL,KAAK,EACL,SAAS,EAGT,cAAc,EACd,WAAW,EAGX,SAAS,EACT,gBAAgB,EAChB,eAAe,EAGf,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAMrB;;;;GAIG;AACH,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,mCAAmC,CAAC;AAQ3C;;;;GAIG;AACH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAM5C;;;GAGG;AACH,OAAO,EACL,YAAY,EACZ,2BAA2B,EAC3B,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,mCAAmC,CAAC;AAE3C;;;GAGG;AACH,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,sBAAsB,EACtB,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,cAAc,EACd,mBAAmB,GACpB,MAAM,yCAAyC,CAAC;AAEjD;;;GAGG;AACH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,KAAK,mBAAmB,GACzB,MAAM,yCAAyC,CAAC;AAEjD;;;GAGG;AACH,OAAO,EACL,YAAY,EACZ,cAAc,EACd,2BAA2B,GAC5B,MAAM,mCAAmC,CAAC;AAE3C;;;GAGG;AACH,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,6CAA6C,CAAC;AAErD;;;GAGG;AACH,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,aAAa,GACd,MAAM,iCAAiC,CAAC;AAMzC;;;;;GAKG;AACH,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAM9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG"}

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

@@ -0,0 +1,50 @@
+/**
+ * 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/presets/types/packages/core/src/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"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/presets/types/packages/core/src/lib/memory/memory-manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 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/presets/types/packages/core/src/lib/memory/memory-manager.d.ts.map

@@ -0,0 +1 @@
+{"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/presets/types/packages/core/src/lib/performance/diff-engine.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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/presets/types/packages/core/src/lib/performance/diff-engine.d.ts.map

@@ -0,0 +1 @@
+{"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/presets/types/packages/core/src/lib/performance/path-index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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