@signaltree/core 5.1.6 → 6.0.1

package/dist/lib/performance/path-index.js

@@ -1,156 +0,0 @@
-import { isSignal } from '@angular/core';
-
-class TrieNode {
-  value = null;
-  children = new Map();
-}
-class PathIndex {
-  root = new TrieNode();
-  pathCache = new Map();
-  stats = {
-    hits: 0,
-    misses: 0,
-    sets: 0,
-    cleanups: 0
-  };
-  set(path, signal) {
-    const pathStr = this.pathToString(path);
-    const ref = new WeakRef(signal);
-    let node = this.root;
-    for (const segment of path) {
-      const key = String(segment);
-      if (!node.children.has(key)) {
-        node.children.set(key, new TrieNode());
-      }
-      const nextNode = node.children.get(key);
-      if (!nextNode) {
-        throw new Error(`Failed to get node for key: ${key}`);
-      }
-      node = nextNode;
-    }
-    node.value = ref;
-    this.pathCache.set(pathStr, ref);
-    this.stats.sets++;
-  }
-  get(path) {
-    const pathStr = this.pathToString(path);
-    const cached = this.pathCache.get(pathStr);
-    if (cached) {
-      const value = cached.deref();
-      if (value) {
-        this.stats.hits++;
-        return value;
-      }
-      this.pathCache.delete(pathStr);
-      this.stats.cleanups++;
-    }
-    let node = this.root;
-    for (const segment of path) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        this.stats.misses++;
-        return null;
-      }
-    }
-    if (node.value) {
-      const value = node.value.deref();
-      if (value) {
-        this.pathCache.set(pathStr, node.value);
-        this.stats.hits++;
-        return value;
-      }
-      node.value = null;
-      this.stats.cleanups++;
-    }
-    this.stats.misses++;
-    return null;
-  }
-  has(path) {
-    return this.get(path) !== null;
-  }
-  getByPrefix(prefix) {
-    const results = new Map();
-    let node = this.root;
-    for (const segment of prefix) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return results;
-      }
-    }
-    this.collectDescendants(node, [], results);
-    return results;
-  }
-  delete(path) {
-    const pathStr = this.pathToString(path);
-    this.pathCache.delete(pathStr);
-    let node = this.root;
-    const nodes = [node];
-    for (const segment of path) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return false;
-      }
-      nodes.push(node);
-    }
-    const hadValue = node.value !== null;
-    node.value = null;
-    for (let i = nodes.length - 1; i > 0; i--) {
-      const current = nodes[i];
-      if (current.value === null && current.children.size === 0) {
-        const parent = nodes[i - 1];
-        const segment = path[i - 1];
-        parent.children.delete(String(segment));
-      } else {
-        break;
-      }
-    }
-    return hadValue;
-  }
-  clear() {
-    this.root = new TrieNode();
-    this.pathCache.clear();
-  }
-  getStats() {
-    const total = this.stats.hits + this.stats.misses;
-    const hitRate = total > 0 ? this.stats.hits / total : 0;
-    return {
-      ...this.stats,
-      hitRate,
-      cacheSize: this.pathCache.size
-    };
-  }
-  buildFromTree(tree, path = []) {
-    if (!tree) {
-      return;
-    }
-    if (isSignal(tree)) {
-      this.set(path, tree);
-      return;
-    }
-    if (typeof tree !== 'object') {
-      return;
-    }
-    for (const [key, value] of Object.entries(tree)) {
-      this.buildFromTree(value, [...path, key]);
-    }
-  }
-  pathToString(path) {
-    return path.join('.');
-  }
-  collectDescendants(node, currentPath, results) {
-    if (node.value) {
-      const value = node.value.deref();
-      if (value) {
-        results.set(this.pathToString(currentPath), value);
-      }
-    }
-    for (const [key, child] of node.children) {
-      this.collectDescendants(child, [...currentPath, key], results);
-    }
-  }
-}
-
-export { PathIndex };

package/dist/lib/performance/update-engine.js

@@ -1,188 +0,0 @@
-import { isSignal } from '@angular/core';
-import { DiffEngine, ChangeType } from './diff-engine.js';
-import { PathIndex } from './path-index.js';
-
-class OptimizedUpdateEngine {
-  pathIndex;
-  diffEngine;
-  constructor(tree) {
-    this.pathIndex = new PathIndex();
-    this.diffEngine = new DiffEngine();
-    this.pathIndex.buildFromTree(tree);
-  }
-  update(tree, updates, options = {}) {
-    const startTime = performance.now();
-    const diffOptions = {};
-    if (options.maxDepth !== undefined) diffOptions.maxDepth = options.maxDepth;
-    if (options.ignoreArrayOrder !== undefined) diffOptions.ignoreArrayOrder = options.ignoreArrayOrder;
-    if (options.equalityFn !== undefined) diffOptions.equalityFn = options.equalityFn;
-    const diff = this.diffEngine.diff(tree, updates, diffOptions);
-    if (diff.changes.length === 0) {
-      return {
-        changed: false,
-        duration: performance.now() - startTime,
-        changedPaths: []
-      };
-    }
-    const patches = this.createPatches(diff.changes);
-    const sortedPatches = this.sortPatches(patches);
-    const result = options.batch ? this.batchApplyPatches(tree, sortedPatches, options.batchSize) : this.applyPatches(tree, sortedPatches);
-    const duration = performance.now() - startTime;
-    return {
-      changed: true,
-      duration,
-      changedPaths: result.appliedPaths,
-      stats: {
-        totalPaths: diff.changes.length,
-        optimizedPaths: patches.length,
-        batchedUpdates: result.batchCount
-      }
-    };
-  }
-  rebuildIndex(tree) {
-    this.pathIndex.clear();
-    this.pathIndex.buildFromTree(tree);
-  }
-  getIndexStats() {
-    return this.pathIndex.getStats();
-  }
-  createPatches(changes) {
-    const patches = [];
-    const processedPaths = new Set();
-    for (const change of changes) {
-      const pathStr = change.path.join('.');
-      let skipPath = false;
-      for (const processed of processedPaths) {
-        if (pathStr.startsWith(processed + '.')) {
-          skipPath = true;
-          break;
-        }
-      }
-      if (skipPath) {
-        continue;
-      }
-      const patch = this.createPatch(change);
-      patches.push(patch);
-      processedPaths.add(pathStr);
-      if (change.type === ChangeType.REPLACE && typeof change.value === 'object') {
-        processedPaths.add(pathStr);
-      }
-    }
-    return patches;
-  }
-  createPatch(change) {
-    return {
-      type: change.type,
-      path: change.path,
-      value: change.value,
-      oldValue: change.oldValue,
-      priority: this.calculatePriority(change),
-      signal: this.pathIndex.get(change.path)
-    };
-  }
-  calculatePriority(change) {
-    let priority = 0;
-    priority += (10 - change.path.length) * 10;
-    if (change.path.some(p => typeof p === 'number')) {
-      priority -= 20;
-    }
-    if (change.type === ChangeType.REPLACE) {
-      priority += 30;
-    }
-    return priority;
-  }
-  sortPatches(patches) {
-    return patches.sort((a, b) => {
-      if (a.priority !== b.priority) {
-        return b.priority - a.priority;
-      }
-      return a.path.length - b.path.length;
-    });
-  }
-  applyPatches(tree, patches) {
-    const appliedPaths = [];
-    let updateCount = 0;
-    for (const patch of patches) {
-      if (this.applyPatch(patch, tree)) {
-        appliedPaths.push(patch.path.join('.'));
-        updateCount++;
-      }
-    }
-    return {
-      appliedPaths,
-      updateCount,
-      batchCount: 1
-    };
-  }
-  batchApplyPatches(tree, patches, batchSize = 50) {
-    const batches = [];
-    for (let i = 0; i < patches.length; i += batchSize) {
-      batches.push(patches.slice(i, i + batchSize));
-    }
-    const appliedPaths = [];
-    let updateCount = 0;
-    for (const currentBatch of batches) {
-      for (const patch of currentBatch) {
-        if (this.applyPatch(patch, tree)) {
-          appliedPaths.push(patch.path.join('.'));
-          updateCount++;
-        }
-      }
-    }
-    return {
-      appliedPaths,
-      updateCount,
-      batchCount: batches.length
-    };
-  }
-  applyPatch(patch, tree) {
-    try {
-      if (patch.signal && isSignal(patch.signal) && 'set' in patch.signal) {
-        const currentValue = patch.signal();
-        if (this.isEqual(currentValue, patch.value)) {
-          return false;
-        }
-        patch.signal.set(patch.value);
-        if (patch.type === ChangeType.ADD && patch.value !== undefined) {
-          this.pathIndex.set(patch.path, patch.signal);
-        }
-        return true;
-      }
-      let current = tree;
-      for (let i = 0; i < patch.path.length - 1; i++) {
-        const key = patch.path[i];
-        current = current[key];
-        if (!current || typeof current !== 'object') {
-          return false;
-        }
-      }
-      const lastKey = patch.path[patch.path.length - 1];
-      if (this.isEqual(current[lastKey], patch.value)) {
-        return false;
-      }
-      current[lastKey] = patch.value;
-      return true;
-    } catch (error) {
-      console.error(`Failed to apply patch at ${patch.path.join('.')}:`, error);
-      return false;
-    }
-  }
-  isEqual(a, b) {
-    if (a === b) {
-      return true;
-    }
-    if (typeof a !== typeof b) {
-      return false;
-    }
-    if (typeof a !== 'object' || a === null || b === null) {
-      return false;
-    }
-    try {
-      return JSON.stringify(a) === JSON.stringify(b);
-    } catch {
-      return false;
-    }
-  }
-}
-
-export { OptimizedUpdateEngine };

package/src/async-helpers.d.ts

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

package/src/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/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/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/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/diff-engine.d.ts

@@ -1,33 +0,0 @@
-import type { Path } from './path-index';
-export declare enum ChangeType {
-    ADD = "add",
-    UPDATE = "update",
-    DELETE = "delete",
-    REPLACE = "replace"
-}
-export interface Change {
-    type: ChangeType;
-    path: Path;
-    value?: unknown;
-    oldValue?: unknown;
-}
-export interface Diff {
-    changes: Change[];
-    hasChanges: boolean;
-}
-export interface DiffOptions {
-    maxDepth?: number;
-    detectDeletions?: boolean;
-    ignoreArrayOrder?: boolean;
-    equalityFn?: (a: unknown, b: unknown) => boolean;
-    keyValidator?: (key: string) => boolean;
-}
-export declare class DiffEngine {
-    private defaultOptions;
-    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
-    private traverse;
-    private diffArrays;
-    private diffArraysOrdered;
-    private diffArraysUnordered;
-    private stringify;
-}

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/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/entities/lib/entities.d.ts

@@ -1,17 +0,0 @@
-import type { 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>;
-};
-export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-};
-export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
-    state: EntityAwareTreeNode<T>;
-    $: EntityAwareTreeNode<T>;
-};
-export {};

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/presets/test-setup.d.ts

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