@signaltree/enterprise 4.0.9 → 4.0.13

package/src/lib/path-index.spec.ts

@@ -1,290 +0,0 @@
-import { signal } from '@angular/core';
-
-import { PathIndex } from './path-index';
-
-import type { WritableSignal } from "@angular/core";
-
-describe("PathIndex", () => {
-  let index: PathIndex;
-
-  beforeEach(() => {
-    index = new PathIndex();
-  });
-
-  describe("set and get", () => {
-    it("should store and retrieve values by path", () => {
-      const testSignal = signal(42);
-      index.set(["user", "age"], testSignal);
-
-      const retrieved = index.get(["user", "age"]);
-      expect(retrieved).toBe(testSignal);
-      expect(retrieved?.()).toBe(42);
-    });
-
-    it("should handle nested paths", () => {
-      const nameSignal = signal("Alice");
-      const ageSignal = signal(30);
-      const citySignal = signal("NYC");
-
-      index.set(["user", "profile", "name"], nameSignal);
-      index.set(["user", "profile", "age"], ageSignal);
-      index.set(["user", "address", "city"], citySignal);
-
-      expect(index.get(["user", "profile", "name"])).toBe(nameSignal);
-      expect(index.get(["user", "profile", "age"])).toBe(ageSignal);
-      expect(index.get(["user", "address", "city"])).toBe(citySignal);
-    });
-
-    it("should handle array indices", () => {
-      const sig = signal("item");
-      index.set(["items", 0, "name"], sig);
-
-      const retrieved = index.get(["items", 0, "name"]);
-      expect(retrieved).toBe(sig);
-    });
-
-    it("should return null for non-existent paths", () => {
-      expect(index.get(["nonexistent", "path"])).toBeNull();
-    });
-
-    it("should handle empty paths", () => {
-      const sig = signal("root");
-      index.set([], sig);
-
-      expect(index.get([])).toBe(sig);
-    });
-  });
-
-  describe("has", () => {
-    it("should return true for existing paths", () => {
-      const sig = signal(1);
-      index.set(["test"], sig);
-
-      expect(index.has(["test"])).toBe(true);
-    });
-
-    it("should return false for non-existent paths", () => {
-      expect(index.has(["nonexistent"])).toBe(false);
-    });
-  });
-
-  describe("getByPrefix", () => {
-    beforeEach(() => {
-      index.set(["user", "name"], signal("Alice"));
-      index.set(["user", "age"], signal(30));
-      index.set(["user", "profile", "bio"], signal("Dev"));
-      index.set(["config", "theme"], signal("dark"));
-    });
-
-    it("should get all values matching a prefix", () => {
-      const userValues = index.getByPrefix(["user"]);
-
-      expect(userValues.size).toBe(3);
-      expect(userValues.get("name")?.()).toBe("Alice");
-      expect(userValues.get("age")?.()).toBe(30);
-      expect(userValues.get("profile.bio")?.()).toBe("Dev");
-    });
-
-    it("should return empty map for non-existent prefix", () => {
-      const values = index.getByPrefix(["nonexistent"]);
-      expect(values.size).toBe(0);
-    });
-
-    it("should handle nested prefixes", () => {
-      const profileValues = index.getByPrefix(["user", "profile"]);
-
-      expect(profileValues.size).toBe(1);
-      expect(profileValues.get("bio")?.()).toBe("Dev");
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete a value and return true", () => {
-      const sig = signal(1);
-      index.set(["test"], sig);
-
-      expect(index.delete(["test"])).toBe(true);
-      expect(index.has(["test"])).toBe(false);
-    });
-
-    it("should return false for non-existent paths", () => {
-      expect(index.delete(["nonexistent"])).toBe(false);
-    });
-
-    it("should clean up empty nodes", () => {
-      index.set(["user", "name"], signal("Alice"));
-      index.set(["user", "age"], signal(30));
-
-      index.delete(["user", "name"]);
-
-      // Age should still be accessible
-      expect(index.has(["user", "age"])).toBe(true);
-    });
-  });
-
-  describe("clear", () => {
-    it("should remove all entries", () => {
-      index.set(["a"], signal(1));
-      index.set(["b"], signal(2));
-      index.set(["c"], signal(3));
-
-      index.clear();
-
-      expect(index.has(["a"])).toBe(false);
-      expect(index.has(["b"])).toBe(false);
-      expect(index.has(["c"])).toBe(false);
-    });
-  });
-
-  describe("getStats", () => {
-    it("should track hits and misses", () => {
-      const sig = signal(1);
-      index.set(["test"], sig);
-
-      // Trigger a hit
-      index.get(["test"]);
-
-      // Trigger a miss
-      index.get(["nonexistent"]);
-
-      const stats = index.getStats();
-      expect(stats.hits).toBeGreaterThan(0);
-      expect(stats.misses).toBeGreaterThan(0);
-      expect(stats.hitRate).toBeGreaterThan(0);
-    });
-
-    it("should track sets", () => {
-      index.set(["a"], signal(1));
-      index.set(["b"], signal(2));
-
-      const stats = index.getStats();
-      expect(stats.sets).toBe(2);
-    });
-  });
-
-  describe("buildFromTree", () => {
-    it("should index signals from a tree structure", () => {
-      const tree = {
-        user: {
-          name: signal("Alice"),
-          age: signal(30),
-          profile: {
-            bio: signal("Developer"),
-          },
-        },
-        config: signal("dark"),
-      };
-
-      index.buildFromTree(tree);
-
-      expect(index.has(["user", "name"])).toBe(true);
-      expect(index.has(["user", "age"])).toBe(true);
-      expect(index.has(["user", "profile", "bio"])).toBe(true);
-      expect(index.has(["config"])).toBe(true);
-
-      expect(index.get(["user", "name"])?.()).toBe("Alice");
-      expect(index.get(["config"])?.()).toBe("dark");
-    });
-
-    it("should handle nested objects without signals", () => {
-      const tree = {
-        data: {
-          nested: {
-            value: signal(42),
-          },
-        },
-      };
-
-      index.buildFromTree(tree);
-
-      expect(index.has(["data", "nested", "value"])).toBe(true);
-    });
-
-    it("should skip non-signal leaves", () => {
-      const tree = {
-        signal: signal(1),
-        notSignal: "plain value",
-      };
-
-      index.buildFromTree(tree);
-
-      expect(index.has(["signal"])).toBe(true);
-      expect(index.has(["notSignal"])).toBe(false);
-    });
-  });
-
-  describe("WeakRef behavior", () => {
-    it("should allow garbage collection of signals", () => {
-      const sig: WritableSignal<number> = signal(42);
-      index.set(["test"], sig);
-
-      // Signal should be retrievable
-      expect(index.get(["test"])).toBe(sig);
-
-      // Note: We can't actually trigger GC in tests, but the WeakRef
-      // allows it to happen in production
-    });
-
-    it("should clean up stale references on access", () => {
-      const sig: WritableSignal<number> = signal(42);
-      index.set(["test"], sig);
-
-      const stats1 = index.getStats();
-      const initialSets = stats1.sets;
-
-      // Access should maintain cache
-      index.get(["test"]);
-
-      const stats2 = index.getStats();
-      expect(stats2.sets).toBe(initialSets);
-    });
-  });
-
-  describe("performance", () => {
-    it("should handle large numbers of paths efficiently", () => {
-      const start = performance.now();
-
-      // Index 1000 signals
-      for (let i = 0; i < 1000; i++) {
-        index.set(["items", i], signal(i));
-      }
-
-      const indexTime = performance.now() - start;
-
-      // Retrieval should be fast
-      const retrieveStart = performance.now();
-      for (let i = 0; i < 1000; i++) {
-        index.get(["items", i]);
-      }
-      const retrieveTime = performance.now() - retrieveStart;
-
-      // Both operations should be reasonably fast
-      expect(indexTime).toBeLessThan(100); // Indexing 1000 items < 100ms
-      expect(retrieveTime).toBeLessThan(50); // Retrieving 1000 items < 50ms
-    });
-
-    it("should have O(k) lookup time regardless of total size", () => {
-      // Add 100 signals
-      for (let i = 0; i < 100; i++) {
-        index.set(["items", i], signal(i));
-      }
-
-      const time100 = performance.now();
-      index.get(["items", 50]);
-      const duration100 = performance.now() - time100;
-
-      // Add 900 more signals (10x more data)
-      for (let i = 100; i < 1000; i++) {
-        index.set(["items", i], signal(i));
-      }
-
-      const time1000 = performance.now();
-      index.get(["items", 50]);
-      const duration1000 = performance.now() - time1000;
-
-      // Lookup time should not increase significantly with more data
-      // (allowing for some variance in measurement)
-      expect(duration1000).toBeLessThan(duration100 * 3);
-    });
-  });
-});

package/src/lib/path-index.ts

@@ -1,320 +0,0 @@
-import { isSignal } from '@angular/core';
-
-/**
- * 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[];
-
-/**
- * Node in the Trie structure
- */
-class TrieNode<T> {
-  value: T | null = null;
-  children = new Map<string, TrieNode<T>>();
-}
-
-/**
- * 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'])) {
- *   // ...
- * }
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class PathIndex<T extends object = WritableSignal<any>> {
-  private root = new TrieNode<WeakRef<T>>();
-  private pathCache = new Map<string, WeakRef<T>>();
-  private stats = {
-    hits: 0,
-    misses: 0,
-    sets: 0,
-    cleanups: 0,
-  };
-
-  /**
-   * Set a value at the given path
-   *
-   * @param path - Path segments
-   * @param value - Value to store
-   */
-  set(path: Path, signal: T): void {
-    const pathStr = this.pathToString(path);
-    const ref = new WeakRef(signal);
-
-    // Update trie
-    let node = this.root;
-    for (const segment of path) {
-      const key = String(segment);
-      if (!node.children.has(key)) {
-        node.children.set(key, new TrieNode<WeakRef<T>>());
-      }
-      const nextNode = node.children.get(key);
-      if (!nextNode) {
-        throw new Error(`Failed to get node for key: ${key}`);
-      }
-      node = nextNode;
-    }
-    node.value = ref;
-
-    // Update cache for fast string lookups
-    this.pathCache.set(pathStr, ref);
-
-    this.stats.sets++;
-  }
-
-  /**
-   * 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 {
-    const pathStr = this.pathToString(path);
-
-    // Try cache first
-    const cached = this.pathCache.get(pathStr);
-    if (cached) {
-      const value = cached.deref();
-      if (value) {
-        this.stats.hits++;
-        return value;
-      }
-      // Clean up dead reference
-      this.pathCache.delete(pathStr);
-      this.stats.cleanups++;
-    }
-
-    // Try trie
-    let node: TrieNode<WeakRef<T>> | undefined = 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) {
-        // Re-cache for next time
-        this.pathCache.set(pathStr, node.value);
-        this.stats.hits++;
-        return value;
-      }
-      // Clean up dead reference
-      node.value = null;
-      this.stats.cleanups++;
-    }
-
-    this.stats.misses++;
-    return 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 {
-    return this.get(path) !== null;
-  }
-
-  /**
-   * Get all values matching a prefix
-   *
-   * @param prefix - Path prefix
-   * @returns Map of relative paths to values
-   */
-  getByPrefix(prefix: Path): Map<string, T> {
-    const results = new Map<string, T>();
-
-    // Find the node at prefix
-    let node: TrieNode<WeakRef<T>> | undefined = this.root;
-    for (const segment of prefix) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return results; // Empty map
-      }
-    }
-
-    // Collect all descendants
-    this.collectDescendants(node, [], results);
-
-    return results;
-  }
-
-  /**
-   * Delete value at path
-   *
-   * @param path - Path segments
-   * @returns True if deleted, false if not found
-   */
-  delete(path: Path): boolean {
-    const pathStr = this.pathToString(path);
-
-    // Remove from cache
-    this.pathCache.delete(pathStr);
-
-    // Remove from trie
-    let node: TrieNode<WeakRef<T>> | undefined = this.root;
-    const nodes: TrieNode<WeakRef<T>>[] = [node];
-
-    for (const segment of path) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return false;
-      }
-      nodes.push(node);
-    }
-
-    // Clear value
-    const hadValue = node.value !== null;
-    node.value = null;
-
-    // Clean up empty nodes (from leaf to root)
-    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; // Stop if node has value or children
-      }
-    }
-
-    return hadValue;
-  }
-
-  /**
-   * Clear all entries
-   */
-  clear(): void {
-    this.root = new TrieNode<WeakRef<T>>();
-    this.pathCache.clear();
-  }
-
-  /**
-   * Get statistics
-   *
-   * @returns Index statistics
-   */
-  getStats(): {
-    hits: number;
-    misses: number;
-    sets: number;
-    cleanups: number;
-    hitRate: number;
-    cacheSize: number;
-  } {
-    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,
-    };
-  }
-
-  /**
-   * Build index from a tree structure
-   *
-   * @param tree - Tree object to index
-   * @param path - Current path (for recursion)
-   */
-  buildFromTree(tree: unknown, path: Path = []): void {
-    if (!tree) {
-      return;
-    }
-
-    // Check if it's a signal using Angular's isSignal
-    if (isSignal(tree)) {
-      this.set(path, tree as T);
-      return;
-    }
-
-    // Only continue if it's an object (not a signal or primitive)
-    if (typeof tree !== 'object') {
-      return;
-    }
-
-    // Recursively index children
-    for (const [key, value] of Object.entries(tree)) {
-      this.buildFromTree(value, [...path, key]);
-    }
-  }
-
-  /**
-   * Convert path to string for caching
-   */
-  private pathToString(path: Path): string {
-    return path.join('.');
-  }
-
-  /**
-   * Collect all descendant values recursively
-   */
-  private collectDescendants(
-    node: TrieNode<WeakRef<T>>,
-    currentPath: PathSegment[],
-    results: Map<string, T>
-  ): void {
-    // Add current node's value if it exists
-    if (node.value) {
-      const value = node.value.deref();
-      if (value) {
-        results.set(this.pathToString(currentPath), value);
-      }
-    }
-
-    // Recursively collect children
-    for (const [key, child] of node.children) {
-      this.collectDescendants(child, [...currentPath, key], results);
-    }
-  }
-}

package/src/lib/scheduler.ts

@@ -1,16 +0,0 @@
-export type Task = () => void;
-
-const q: Task[] = [];
-
-export function postTask(t: Task) {
-  q.push(t);
-  if (q.length === 1) flush();
-}
-
-async function flush() {
-  while (q.length) {
-    const t = q.shift()!;
-    try { t(); } catch (e) { console.error('[EnterpriseScheduler]', e); }
-    await Promise.resolve();
-  }
-}

package/src/lib/thread-pools.ts

@@ -1,11 +0,0 @@
-export interface WorkerPool {
-  run<T>(fn: (...args: any[]) => T, ...args: any[]): Promise<T>;
-}
-
-export function createMockPool(): WorkerPool {
-  return {
-    async run(fn, ...args) {
-      return fn(...args);
-    }
-  };
-}