@signaltree/core 4.0.15 → 4.1.0

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

@@ -1,166 +1,164 @@
-export class SignalMemoryManager {
-    cache = new Map();
-    registry = null;
-    config;
-    stats = {
-        cleanedUpSignals: 0,
-        peakCachedSignals: 0,
-        manualDisposes: 0,
+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 ?? (() => {})
     };
-    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,
-            });
-        }
+    if (this.config.enableAutoCleanup && typeof FinalizationRegistry !== 'undefined') {
+      this.registry = new FinalizationRegistry(path => {
+        this.handleCleanup(path);
+      });
     }
-    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,
-            });
-        }
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Initialized', {
+        autoCleanup: this.config.enableAutoCleanup,
+        hasRegistry: !!this.registry
+      });
     }
-    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;
+  }
+  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);
     }
-    hasSignal(path) {
-        return this.cache.has(path);
+    const currentSize = this.cache.size;
+    if (currentSize > this.stats.peakCachedSignals) {
+      this.stats.peakCachedSignals = currentSize;
     }
-    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);
-        }
+    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);
-        if (this.config.debugMode) {
-            console.log(`[SignalMemoryManager] Removed signal: ${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);
         }
-        return true;
+      }
     }
-    handleCleanup(path) {
+    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);
-        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());
-        }
+        removed++;
+      }
     }
-    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');
-        }
+    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');
     }
+  }
 }
+
+export { SignalMemoryManager };

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

@@ -1,156 +1,156 @@
-export var ChangeType;
+var ChangeType;
 (function (ChangeType) {
-    ChangeType["ADD"] = "add";
-    ChangeType["UPDATE"] = "update";
-    ChangeType["DELETE"] = "delete";
-    ChangeType["REPLACE"] = "replace";
+  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,
+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
     };
-    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,
-        };
+    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;
     }
-    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],
-                    });
-                }
-            }
-        }
+    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;
     }
-    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);
+    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);
+      }
     }
-    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);
-            }
+    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]
+          });
         }
+      }
     }
-    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,
-                });
-            }
-        });
+  }
+  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) {
-            curr.forEach((value, index) => {
-                const str = this.stringify(value);
-                if (!updSet.has(str)) {
-                    changes.push({
-                        type: ChangeType.DELETE,
-                        path: [...path, index],
-                        oldValue: value,
-                    });
-                }
-            });
+          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);
+      }
     }
-    stringify(value) {
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return String(value);
+  }
+  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);
     }
+  }
 }
+
+export { ChangeType, DiffEngine };