@signaltree/core 3.1.0 → 4.0.1

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

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

@@ -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/lib/performance/diff-engine.js

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

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

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

@@ -1,32 +0,0 @@
-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;
-}