@signaltree/enterprise 4.0.6 → 4.0.9

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

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

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

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

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