@signaltree/core 3.0.2 → 3.1.0

package/src/lib/memory/memory-manager.js

@@ -0,0 +1,166 @@
+export class SignalMemoryManager {
+    cache = new Map();
+    registry = null;
+    config;
+    stats = {
+        cleanedUpSignals: 0,
+        peakCachedSignals: 0,
+        manualDisposes: 0,
+    };
+    constructor(config = {}) {
+        this.config = {
+            enableAutoCleanup: config.enableAutoCleanup ?? true,
+            debugMode: config.debugMode ?? false,
+            onCleanup: config.onCleanup ??
+                (() => {
+                }),
+        };
+        if (this.config.enableAutoCleanup &&
+            typeof FinalizationRegistry !== 'undefined') {
+            this.registry = new FinalizationRegistry((path) => {
+                this.handleCleanup(path);
+            });
+        }
+        if (this.config.debugMode) {
+            console.log('[SignalMemoryManager] Initialized', {
+                autoCleanup: this.config.enableAutoCleanup,
+                hasRegistry: !!this.registry,
+            });
+        }
+    }
+    cacheSignal(path, signal) {
+        const ref = new WeakRef(signal);
+        const entry = {
+            ref,
+            path,
+            cachedAt: Date.now(),
+        };
+        this.cache.set(path, entry);
+        if (this.registry) {
+            this.registry.register(signal, path, signal);
+        }
+        const currentSize = this.cache.size;
+        if (currentSize > this.stats.peakCachedSignals) {
+            this.stats.peakCachedSignals = currentSize;
+        }
+        if (this.config.debugMode) {
+            console.log(`[SignalMemoryManager] Cached signal: ${path}`, {
+                cacheSize: currentSize,
+                peak: this.stats.peakCachedSignals,
+            });
+        }
+    }
+    getSignal(path) {
+        const entry = this.cache.get(path);
+        if (!entry) {
+            return undefined;
+        }
+        const signal = entry.ref.deref();
+        if (!signal) {
+            this.cache.delete(path);
+            if (this.config.debugMode) {
+                console.log(`[SignalMemoryManager] Signal GC'd: ${path}`);
+            }
+            return undefined;
+        }
+        return signal;
+    }
+    hasSignal(path) {
+        return this.cache.has(path);
+    }
+    removeSignal(path) {
+        const entry = this.cache.get(path);
+        if (!entry) {
+            return false;
+        }
+        const signal = entry.ref.deref();
+        if (signal && this.registry) {
+            this.registry.unregister(signal);
+        }
+        this.cache.delete(path);
+        if (this.config.debugMode) {
+            console.log(`[SignalMemoryManager] Removed signal: ${path}`);
+        }
+        return true;
+    }
+    handleCleanup(path) {
+        this.cache.delete(path);
+        this.stats.cleanedUpSignals++;
+        const currentStats = this.getStats();
+        if (this.config.debugMode) {
+            console.log(`[SignalMemoryManager] Auto cleanup: ${path}`, currentStats);
+        }
+        this.config.onCleanup(path, currentStats);
+    }
+    getStats() {
+        let validSignals = 0;
+        for (const [path, entry] of this.cache.entries()) {
+            if (entry.ref.deref()) {
+                validSignals++;
+            }
+            else {
+                this.cache.delete(path);
+            }
+        }
+        const estimatedMemoryBytes = validSignals * 100;
+        return {
+            cachedSignals: validSignals,
+            cleanedUpSignals: this.stats.cleanedUpSignals,
+            peakCachedSignals: this.stats.peakCachedSignals,
+            manualDisposes: this.stats.manualDisposes,
+            estimatedMemoryBytes,
+        };
+    }
+    dispose() {
+        if (this.config.debugMode) {
+            console.log('[SignalMemoryManager] Disposing', {
+                cachedSignals: this.cache.size,
+            });
+        }
+        if (this.registry) {
+            for (const entry of this.cache.values()) {
+                const signal = entry.ref.deref();
+                if (signal) {
+                    this.registry.unregister(signal);
+                }
+            }
+        }
+        this.cache.clear();
+        this.stats.manualDisposes++;
+        if (this.config.debugMode) {
+            console.log('[SignalMemoryManager] Disposed', this.getStats());
+        }
+    }
+    getCachedPaths() {
+        const paths = [];
+        for (const [path, entry] of this.cache.entries()) {
+            if (entry.ref.deref()) {
+                paths.push(path);
+            }
+        }
+        return paths;
+    }
+    clearStale() {
+        let removed = 0;
+        for (const [path, entry] of this.cache.entries()) {
+            if (!entry.ref.deref()) {
+                this.cache.delete(path);
+                removed++;
+            }
+        }
+        if (this.config.debugMode && removed > 0) {
+            console.log(`[SignalMemoryManager] Cleared ${removed} stale entries`);
+        }
+        return removed;
+    }
+    resetStats() {
+        this.stats = {
+            cleanedUpSignals: 0,
+            peakCachedSignals: 0,
+            manualDisposes: 0,
+        };
+        if (this.config.debugMode) {
+            console.log('[SignalMemoryManager] Stats reset');
+        }
+    }
+}

package/src/lib/performance/diff-engine.d.ts

@@ -0,0 +1,33 @@
+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/lib/performance/diff-engine.js

@@ -0,0 +1,156 @@
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType["ADD"] = "add";
+    ChangeType["UPDATE"] = "update";
+    ChangeType["DELETE"] = "delete";
+    ChangeType["REPLACE"] = "replace";
+})(ChangeType || (ChangeType = {}));
+export class DiffEngine {
+    defaultOptions = {
+        maxDepth: 100,
+        detectDeletions: false,
+        ignoreArrayOrder: false,
+        equalityFn: (a, b) => a === b,
+        keyValidator: undefined,
+    };
+    diff(current, updates, options = {}) {
+        const opts = { ...this.defaultOptions, ...options };
+        const changes = [];
+        const visited = new WeakSet();
+        this.traverse(current, updates, [], changes, visited, opts, 0);
+        return {
+            changes,
+            hasChanges: changes.length > 0,
+        };
+    }
+    traverse(curr, upd, path, changes, visited, opts, depth) {
+        if (depth > opts.maxDepth) {
+            return;
+        }
+        if (typeof upd !== 'object' || upd === null) {
+            if (!opts.equalityFn(curr, upd)) {
+                changes.push({
+                    type: curr === undefined ? ChangeType.ADD : ChangeType.UPDATE,
+                    path: [...path],
+                    value: upd,
+                    oldValue: curr,
+                });
+            }
+            return;
+        }
+        if (visited.has(upd)) {
+            return;
+        }
+        visited.add(upd);
+        if (Array.isArray(upd)) {
+            this.diffArrays(curr, upd, path, changes, visited, opts, depth);
+            return;
+        }
+        if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
+            changes.push({
+                type: ChangeType.REPLACE,
+                path: [...path],
+                value: upd,
+                oldValue: curr,
+            });
+            return;
+        }
+        const currObj = curr;
+        const updObj = upd;
+        for (const key in updObj) {
+            if (Object.prototype.hasOwnProperty.call(updObj, key)) {
+                if (opts.keyValidator && !opts.keyValidator(key)) {
+                    continue;
+                }
+                this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1);
+            }
+        }
+        if (opts.detectDeletions) {
+            for (const key in currObj) {
+                if (Object.prototype.hasOwnProperty.call(currObj, key) &&
+                    !(key in updObj)) {
+                    changes.push({
+                        type: ChangeType.DELETE,
+                        path: [...path, key],
+                        oldValue: currObj[key],
+                    });
+                }
+            }
+        }
+    }
+    diffArrays(curr, upd, path, changes, visited, opts, depth) {
+        if (!Array.isArray(curr)) {
+            changes.push({
+                type: ChangeType.REPLACE,
+                path: [...path],
+                value: upd,
+                oldValue: curr,
+            });
+            return;
+        }
+        if (opts.ignoreArrayOrder) {
+            this.diffArraysUnordered(curr, upd, path, changes, opts);
+        }
+        else {
+            this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth);
+        }
+    }
+    diffArraysOrdered(curr, upd, path, changes, visited, opts, depth) {
+        const maxLength = Math.max(curr.length, upd.length);
+        for (let i = 0; i < maxLength; i++) {
+            if (i >= upd.length) {
+                if (opts.detectDeletions) {
+                    changes.push({
+                        type: ChangeType.DELETE,
+                        path: [...path, i],
+                        oldValue: curr[i],
+                    });
+                }
+            }
+            else if (i >= curr.length) {
+                changes.push({
+                    type: ChangeType.ADD,
+                    path: [...path, i],
+                    value: upd[i],
+                });
+            }
+            else {
+                this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1);
+            }
+        }
+    }
+    diffArraysUnordered(curr, upd, path, changes, opts) {
+        const currSet = new Set(curr.map((v) => this.stringify(v)));
+        const updSet = new Set(upd.map((v) => this.stringify(v)));
+        upd.forEach((value, index) => {
+            const str = this.stringify(value);
+            if (!currSet.has(str)) {
+                changes.push({
+                    type: ChangeType.ADD,
+                    path: [...path, index],
+                    value,
+                });
+            }
+        });
+        if (opts.detectDeletions) {
+            curr.forEach((value, index) => {
+                const str = this.stringify(value);
+                if (!updSet.has(str)) {
+                    changes.push({
+                        type: ChangeType.DELETE,
+                        path: [...path, index],
+                        oldValue: value,
+                    });
+                }
+            });
+        }
+    }
+    stringify(value) {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+}

package/src/lib/performance/path-index.d.ts

@@ -0,0 +1,25 @@
+import type { WritableSignal } from '@angular/core';
+export type PathSegment = string | number;
+export type Path = PathSegment[];
+export declare class PathIndex<T extends object = WritableSignal<any>> {
+    private root;
+    private pathCache;
+    private stats;
+    set(path: Path, signal: T): void;
+    get(path: Path): T | null;
+    has(path: Path): boolean;
+    getByPrefix(prefix: Path): Map<string, T>;
+    delete(path: Path): boolean;
+    clear(): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        sets: number;
+        cleanups: number;
+        hitRate: number;
+        cacheSize: number;
+    };
+    buildFromTree(tree: unknown, path?: Path): void;
+    private pathToString;
+    private collectDescendants;
+}

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

@@ -0,0 +1,154 @@
+import { isSignal } from '@angular/core';
+class TrieNode {
+    value = null;
+    children = new Map();
+}
+export 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);
+        }
+    }
+}

package/src/lib/performance/update-engine.d.ts

@@ -0,0 +1,32 @@
+import { PathIndex } from './path-index';
+import type { DiffOptions } from './diff-engine';
+export interface UpdateOptions extends DiffOptions {
+    batch?: boolean;
+    batchSize?: number;
+}
+export interface UpdateResult {
+    changed: boolean;
+    duration: number;
+    changedPaths: string[];
+    stats?: {
+        totalPaths: number;
+        optimizedPaths: number;
+        batchedUpdates: number;
+    };
+}
+export declare class OptimizedUpdateEngine {
+    private pathIndex;
+    private diffEngine;
+    constructor(tree: unknown);
+    update(tree: unknown, updates: unknown, options?: UpdateOptions): UpdateResult;
+    rebuildIndex(tree: unknown): void;
+    getIndexStats(): ReturnType<PathIndex['getStats']>;
+    private createPatches;
+    private createPatch;
+    private calculatePriority;
+    private sortPatches;
+    private applyPatches;
+    private batchApplyPatches;
+    private applyPatch;
+    private isEqual;
+}