Allow Evaluator.invalidate() to accept rest arguments (#492)

Author: jantimon

.changeset/curvy-terms-turn.md

@@ -0,0 +1,3 @@
+---
+---
+

packages/next-yak/isolated-source-eval/README.md

@@ -12,10 +12,10 @@ const evaluator = await createEvaluator();
 const result = await evaluator.evaluate("/absolute/path/to/theme.ts");
 
 if (result.ok) {
-  result.value;        // { default: ..., namedExport: ... }
+  result.value; // { default: ..., namedExport: ... }
   result.dependencies; // ["/absolute/path/to/theme.ts", "/absolute/path/to/tokens.ts"]
 } else {
-  result.error;        // { message: string, stack: string }
+  result.error; // { message: string, stack: string }
 }
 ```
 
@@ -127,15 +127,16 @@ type EvaluateResult =
 
 Concurrent calls are queued and executed one at a time to keep dependency tracking accurate.
 
-### `evaluator.invalidate(absolutePath)`
+### `evaluator.invalidate(...absolutePaths)`
 
-Clears cached results for every entry point that transitively depends on the given file, then swaps workers to ensure a clean module cache. If an evaluation is in-flight, it's transparently retried on the fresh worker.
+Clears cached results for every entry point that transitively depends on the given file(s), then swaps workers to ensure a clean module cache. If an evaluation is in-flight, it's transparently retried on the fresh worker. Accepts one or more paths.
 
 ```ts
 evaluator.invalidate("/project/src/tokens.ts");
+evaluator.invalidate("/project/src/a.ts", "/project/src/b.ts");
 ```
 
-Silent no-op if the path isn't in any tracked dependency set.
+Silent no-op if no paths are provided or none are in any tracked dependency set.
 
 ### `evaluator.invalidateAll()`
 

packages/next-yak/isolated-source-eval/__tests__/evaluator.test.ts

@@ -316,6 +316,68 @@ describe("invalidation", () => {
     const result2 = await evaluator.evaluate(fixture("simple-theme.ts"));
     expect(result1).not.toBe(result2); // Different reference
   });
+
+  it("invalidate with no args is a no-op", async () => {
+    evaluator = await createEvaluator();
+    const result1 = await evaluator.evaluate(fixture("simple-theme.ts"));
+
+    evaluator.invalidate();
+
+    const result2 = await evaluator.evaluate(fixture("simple-theme.ts"));
+    expect(result1).toBe(result2); // Same reference — cache untouched
+  });
+
+  it("invalidate with multiple args clears only affected entry points", async () => {
+    evaluator = await createEvaluator();
+
+    // Evaluate two unrelated modules
+    const themeResult = await evaluator.evaluate(
+      fixture("transitive-theme.ts"),
+    );
+    const simpleResult = await evaluator.evaluate(fixture("simple-theme.ts"));
+
+    // Invalidate tokens.ts — only transitive-theme.ts depends on it
+    evaluator.invalidate(fixture("tokens.ts"));
+
+    const themeResult2 = await evaluator.evaluate(
+      fixture("transitive-theme.ts"),
+    );
+    const simpleResult2 = await evaluator.evaluate(fixture("simple-theme.ts"));
+
+    expect(themeResult2).not.toBe(themeResult); // Re-evaluated
+    expect(simpleResult2).toBe(simpleResult); // Cache survived
+  });
+
+  it("invalidate with multiple args handles shared dependents", async () => {
+    evaluator = await createEvaluator();
+
+    // Both depend on tokens.ts
+    await evaluator.evaluate(fixture("transitive-theme.ts"));
+    await evaluator.evaluate(fixture("alt-theme.ts"));
+
+    expect(evaluator.getDependentsOf(fixture("tokens.ts"))).toHaveLength(2);
+
+    // Batch invalidate
+    evaluator.invalidate(fixture("tokens.ts"));
+    expect(evaluator.getDependentsOf(fixture("tokens.ts"))).toEqual([]);
+
+    // Both re-evaluate correctly
+    const r1 = await evaluator.evaluate(fixture("transitive-theme.ts"));
+    const r2 = await evaluator.evaluate(fixture("alt-theme.ts"));
+    expect(r1.ok).toBe(true);
+    expect(r2.ok).toBe(true);
+    expect(evaluator.getDependentsOf(fixture("tokens.ts"))).toHaveLength(2);
+  });
+
+  it("invalidate with untracked files is a no-op", async () => {
+    evaluator = await createEvaluator();
+    const result1 = await evaluator.evaluate(fixture("simple-theme.ts"));
+
+    evaluator.invalidate("/some/untracked/file.ts");
+
+    const result2 = await evaluator.evaluate(fixture("simple-theme.ts"));
+    expect(result1).toBe(result2); // Cache untouched
+  });
 });
 
 describe("getDependentsOf", () => {

packages/next-yak/isolated-source-eval/evaluator.ts

@@ -11,8 +11,8 @@ export type EvaluateResult =
 export interface Evaluator {
   /** Evaluate a module and return its exports plus the full transitive dependency list. */
   evaluate(absolutePath: string): Promise<EvaluateResult>;
-  /** Clear cached results for every entry point that transitively depends on the given file. */
-  invalidate(absolutePath: string): void;
+  /** Clear cached results for every entry point that transitively depends on the given file(s). */
+  invalidate(...absolutePaths: string[]): void;
   /** Clear the entire result cache and swap workers. */
   invalidateAll(): void;
   /** Return entry point paths that would be affected by invalidate(absolutePath). */
@@ -406,23 +406,35 @@ export async function createEvaluator(): Promise<Evaluator> {
     return promise;
   }
 
-  function invalidate(absolutePath: string): void {
-    // Always track the invalidation so that in-flight evaluations whose
-    // dependency graph isn't populated yet (cold start) can detect staleness
-    // when they complete in handleResult().
-    invalidatedDuringEval.add(absolutePath);
+  function invalidate(...absolutePaths: string[]): void {
+    if (absolutePaths.length === 0) return;
 
-    const entryPoints = reverseDeps.get(absolutePath);
-    if (!entryPoints || entryPoints.size === 0) return;
+    // Track all invalidations for cold-start detection (in-flight evaluations
+    // whose dependency graph isn't populated yet).
+    for (const path of absolutePaths) {
+      invalidatedDuringEval.add(path);
+    }
+
+    // Collect all affected entry points across all changed files.
+    const allEntryPoints = new Set<string>();
+    for (const path of absolutePaths) {
+      const entryPoints = reverseDeps.get(path);
+      if (entryPoints) {
+        for (const entry of entryPoints) {
+          allEntryPoints.add(entry);
+        }
+      }
+    }
+
+    // If no cached entry points are affected, return early. The cold-start
+    // set (invalidatedDuringEval) will catch in-flight evaluations.
+    if (allEntryPoints.size === 0) return;
 
-    for (const entry of entryPoints) {
+    // Clear caches and clean dependency graphs for all affected entry points.
+    for (const entry of allEntryPoints) {
       resultCache.delete(entry);
       inflight.delete(entry);
 
-      // Clean up the dependency graph for invalidated entry points.
-      // Since we're about to swap workers and re-evaluate, the old graph
-      // entries are stale. Cleaning them here prevents phantom reverse
-      // entries from accumulating for removed dependencies.
       const deps = forwardDeps.get(entry);
       if (deps) {
         for (const dep of deps) {