@mandujs/core 0.53.3 → 0.54.0

package/src/bundler/plugins/__tests__/react-compiler-config.test.ts

@@ -1,83 +1,83 @@
-/**
- * `resolveReactCompilerConfig` — #240 Phase 2 auto-detect tests.
- *
- * The probe only fires when `enabled` is undefined. Explicit `true` /
- * `false` veto the probe so user intent always wins.
- *
- * Cache lifetime is per-process; we reset it between cases so a probe
- * from one fixture doesn't leak to the next.
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import {
-  resolveReactCompilerConfig,
-  _resetReactCompilerConfigCache,
-} from "../react-compiler-config";
-
-async function makeRoot(prefix: string): Promise<string> {
-  return fs.mkdtemp(path.join(os.tmpdir(), `mandu-rc-${prefix}-`));
-}
-
-beforeEach(() => {
-  _resetReactCompilerConfigCache();
-});
-
-describe("resolveReactCompilerConfig", () => {
-  it("explicit enabled:true honours the user even when peers are missing", async () => {
-    const root = await makeRoot("explicit-on");
-    const result = resolveReactCompilerConfig({ enabled: true }, root);
-    expect(result.enabled).toBe(true);
-    expect(result.autoDetected).toBe(false);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("explicit enabled:false vetos the probe", async () => {
-    const root = await makeRoot("explicit-off");
-    const result = resolveReactCompilerConfig({ enabled: false }, root);
-    expect(result.enabled).toBe(false);
-    expect(result.autoDetected).toBe(false);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("undefined enabled + missing peers → disabled silently", async () => {
-    const root = await makeRoot("auto-no-peers");
-    // Empty rootDir — no node_modules, no package.json, no peer deps.
-    const result = resolveReactCompilerConfig(undefined, root);
-    expect(result.enabled).toBe(false);
-    expect(result.autoDetected).toBe(false);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("forwards compilerConfig regardless of enabled state", async () => {
-    const root = await makeRoot("compiler-config");
-    const cfg = { compilationMode: "annotation" };
-    const result = resolveReactCompilerConfig(
-      { enabled: true, compilerConfig: cfg },
-      root,
-    );
-    expect(result.compilerConfig).toBe(cfg);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("caches by (rootDir, explicit-enabled) — second call hits cache", async () => {
-    const root = await makeRoot("cache");
-    const a = resolveReactCompilerConfig(undefined, root);
-    const b = resolveReactCompilerConfig(undefined, root);
-    // Same identity — cache hit returns the stored object.
-    expect(a).toBe(b);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("treats explicit-true vs auto as separate cache keys", async () => {
-    const root = await makeRoot("cache-key");
-    const auto = resolveReactCompilerConfig(undefined, root);
-    const explicit = resolveReactCompilerConfig({ enabled: true }, root);
-    expect(auto).not.toBe(explicit);
-    expect(auto.enabled).toBe(false);
-    expect(explicit.enabled).toBe(true);
-    await fs.rm(root, { recursive: true, force: true });
-  });
-});
+/**
+ * `resolveReactCompilerConfig` — #240 Phase 2 auto-detect tests.
+ *
+ * The probe only fires when `enabled` is undefined. Explicit `true` /
+ * `false` veto the probe so user intent always wins.
+ *
+ * Cache lifetime is per-process; we reset it between cases so a probe
+ * from one fixture doesn't leak to the next.
+ */
+import { describe, it, expect, beforeEach } from "bun:test";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  resolveReactCompilerConfig,
+  _resetReactCompilerConfigCache,
+} from "../react-compiler-config";
+
+async function makeRoot(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), `mandu-rc-${prefix}-`));
+}
+
+beforeEach(() => {
+  _resetReactCompilerConfigCache();
+});
+
+describe("resolveReactCompilerConfig", () => {
+  it("explicit enabled:true honours the user even when peers are missing", async () => {
+    const root = await makeRoot("explicit-on");
+    const result = resolveReactCompilerConfig({ enabled: true }, root);
+    expect(result.enabled).toBe(true);
+    expect(result.autoDetected).toBe(false);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("explicit enabled:false vetos the probe", async () => {
+    const root = await makeRoot("explicit-off");
+    const result = resolveReactCompilerConfig({ enabled: false }, root);
+    expect(result.enabled).toBe(false);
+    expect(result.autoDetected).toBe(false);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("undefined enabled + missing peers → disabled silently", async () => {
+    const root = await makeRoot("auto-no-peers");
+    // Empty rootDir — no node_modules, no package.json, no peer deps.
+    const result = resolveReactCompilerConfig(undefined, root);
+    expect(result.enabled).toBe(false);
+    expect(result.autoDetected).toBe(false);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("forwards compilerConfig regardless of enabled state", async () => {
+    const root = await makeRoot("compiler-config");
+    const cfg = { compilationMode: "annotation" };
+    const result = resolveReactCompilerConfig(
+      { enabled: true, compilerConfig: cfg },
+      root,
+    );
+    expect(result.compilerConfig).toBe(cfg);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("caches by (rootDir, explicit-enabled) — second call hits cache", async () => {
+    const root = await makeRoot("cache");
+    const a = resolveReactCompilerConfig(undefined, root);
+    const b = resolveReactCompilerConfig(undefined, root);
+    // Same identity — cache hit returns the stored object.
+    expect(a).toBe(b);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("treats explicit-true vs auto as separate cache keys", async () => {
+    const root = await makeRoot("cache-key");
+    const auto = resolveReactCompilerConfig(undefined, root);
+    const explicit = resolveReactCompilerConfig({ enabled: true }, root);
+    expect(auto).not.toBe(explicit);
+    expect(auto.enabled).toBe(false);
+    expect(explicit.enabled).toBe(true);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+});

package/src/bundler/plugins/__tests__/react-compiler-lint.test.ts

@@ -1,110 +1,110 @@
-import { describe, expect, test } from "bun:test";
-import path from "node:path";
-import {
-  runReactCompilerLint,
-  formatCompilerReport,
-  type ReactCompilerDiagnostic,
-} from "../react-compiler-lint";
-
-describe("runReactCompilerLint", () => {
-  test("returns empty result with no targets without invoking ESLint", async () => {
-    const result = await runReactCompilerLint({
-      projectRoot: process.cwd(),
-      targetFiles: [],
-    });
-    expect(result.diagnostics).toEqual([]);
-    expect(result.skipped).toBe(false);
-  });
-
-  test("degrades gracefully when ESLint peer dep is missing", async () => {
-    // In a clean Mandu checkout `eslint` and
-    // `eslint-plugin-react-compiler` are not installed. The runner
-    // must report `skipped: true` + empty diagnostics + a skipReason.
-    const result = await runReactCompilerLint({
-      projectRoot: process.cwd(),
-      targetFiles: [path.resolve(__filename)],
-    });
-    // If ESLint happens to be installed in this env, diagnostics is
-    // either empty (this file has no bailouts) or the runner ran
-    // successfully. Either shape is valid — the contract we care
-    // about is "no throw + typed result."
-    expect(Array.isArray(result.diagnostics)).toBe(true);
-    expect(typeof result.skipped).toBe("boolean");
-    if (result.skipped) {
-      expect(typeof result.skipReason).toBe("string");
-    }
-  });
-});
-
-describe("formatCompilerReport", () => {
-  test("returns the no-bailouts sentinel for empty input", () => {
-    expect(formatCompilerReport([])).toContain("no bailouts detected");
-  });
-
-  test("summarises bailouts with file counts + bullet list", () => {
-    const diagnostics: ReactCompilerDiagnostic[] = [
-      {
-        file: "/app/todos/todo.island.tsx",
-        line: 42,
-        column: 5,
-        message: "Cannot memoize: ref escape in closure.",
-        ruleId: "react-compiler/react-compiler",
-        severity: "warning",
-      },
-      {
-        file: "/app/todos/todo.island.tsx",
-        line: 87,
-        column: 3,
-        message: "Cannot memoize: conditional hook call.",
-        ruleId: "react-compiler/react-compiler",
-        severity: "warning",
-      },
-      {
-        file: "/app/dashboard/chart.client.tsx",
-        line: 14,
-        column: 9,
-        message: "Cannot memoize: mutation of a shared value.",
-        ruleId: "react-compiler/react-compiler",
-        severity: "warning",
-      },
-    ];
-    const out = formatCompilerReport(diagnostics);
-    expect(out).toContain("3 bailout(s) in 2 file(s)");
-    expect(out).toContain("todo.island.tsx:42:5");
-    expect(out).toContain("chart.client.tsx:14:9");
-    expect(out).toContain("https://react.dev");
-  });
-
-  test("truncates past the limit with a '... N more' tail", () => {
-    const diagnostics: ReactCompilerDiagnostic[] = Array.from(
-      { length: 30 },
-      (_, i) => ({
-        file: `/app/x/c${i}.island.tsx`,
-        line: i + 1,
-        column: 1,
-        message: "bailout",
-        ruleId: "react-compiler/react-compiler",
-        severity: "warning" as const,
-      }),
-    );
-    const out = formatCompilerReport(diagnostics, { limit: 5 });
-    expect(out).toContain("30 bailout(s)");
-    expect(out).toContain("… and 25 more");
-  });
-
-  test("uses relative paths when projectRoot is provided", () => {
-    const diagnostic: ReactCompilerDiagnostic = {
-      file: path.resolve("/project/app/todo.island.tsx"),
-      line: 1,
-      column: 1,
-      message: "bailout",
-      ruleId: "react-compiler/react-compiler",
-      severity: "warning",
-    };
-    const out = formatCompilerReport([diagnostic], {
-      projectRoot: path.resolve("/project"),
-    });
-    expect(out).toContain(path.join("app", "todo.island.tsx"));
-    expect(out).not.toContain(path.resolve("/project/app"));
-  });
-});
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import {
+  runReactCompilerLint,
+  formatCompilerReport,
+  type ReactCompilerDiagnostic,
+} from "../react-compiler-lint";
+
+describe("runReactCompilerLint", () => {
+  test("returns empty result with no targets without invoking ESLint", async () => {
+    const result = await runReactCompilerLint({
+      projectRoot: process.cwd(),
+      targetFiles: [],
+    });
+    expect(result.diagnostics).toEqual([]);
+    expect(result.skipped).toBe(false);
+  });
+
+  test("degrades gracefully when ESLint peer dep is missing", async () => {
+    // In a clean Mandu checkout `eslint` and
+    // `eslint-plugin-react-compiler` are not installed. The runner
+    // must report `skipped: true` + empty diagnostics + a skipReason.
+    const result = await runReactCompilerLint({
+      projectRoot: process.cwd(),
+      targetFiles: [path.resolve(__filename)],
+    });
+    // If ESLint happens to be installed in this env, diagnostics is
+    // either empty (this file has no bailouts) or the runner ran
+    // successfully. Either shape is valid — the contract we care
+    // about is "no throw + typed result."
+    expect(Array.isArray(result.diagnostics)).toBe(true);
+    expect(typeof result.skipped).toBe("boolean");
+    if (result.skipped) {
+      expect(typeof result.skipReason).toBe("string");
+    }
+  });
+});
+
+describe("formatCompilerReport", () => {
+  test("returns the no-bailouts sentinel for empty input", () => {
+    expect(formatCompilerReport([])).toContain("no bailouts detected");
+  });
+
+  test("summarises bailouts with file counts + bullet list", () => {
+    const diagnostics: ReactCompilerDiagnostic[] = [
+      {
+        file: "/app/todos/todo.island.tsx",
+        line: 42,
+        column: 5,
+        message: "Cannot memoize: ref escape in closure.",
+        ruleId: "react-compiler/react-compiler",
+        severity: "warning",
+      },
+      {
+        file: "/app/todos/todo.island.tsx",
+        line: 87,
+        column: 3,
+        message: "Cannot memoize: conditional hook call.",
+        ruleId: "react-compiler/react-compiler",
+        severity: "warning",
+      },
+      {
+        file: "/app/dashboard/chart.client.tsx",
+        line: 14,
+        column: 9,
+        message: "Cannot memoize: mutation of a shared value.",
+        ruleId: "react-compiler/react-compiler",
+        severity: "warning",
+      },
+    ];
+    const out = formatCompilerReport(diagnostics);
+    expect(out).toContain("3 bailout(s) in 2 file(s)");
+    expect(out).toContain("todo.island.tsx:42:5");
+    expect(out).toContain("chart.client.tsx:14:9");
+    expect(out).toContain("https://react.dev");
+  });
+
+  test("truncates past the limit with a '... N more' tail", () => {
+    const diagnostics: ReactCompilerDiagnostic[] = Array.from(
+      { length: 30 },
+      (_, i) => ({
+        file: `/app/x/c${i}.island.tsx`,
+        line: i + 1,
+        column: 1,
+        message: "bailout",
+        ruleId: "react-compiler/react-compiler",
+        severity: "warning" as const,
+      }),
+    );
+    const out = formatCompilerReport(diagnostics, { limit: 5 });
+    expect(out).toContain("30 bailout(s)");
+    expect(out).toContain("… and 25 more");
+  });
+
+  test("uses relative paths when projectRoot is provided", () => {
+    const diagnostic: ReactCompilerDiagnostic = {
+      file: path.resolve("/project/app/todo.island.tsx"),
+      line: 1,
+      column: 1,
+      message: "bailout",
+      ruleId: "react-compiler/react-compiler",
+      severity: "warning",
+    };
+    const out = formatCompilerReport([diagnostic], {
+      projectRoot: path.resolve("/project"),
+    });
+    expect(out).toContain(path.join("app", "todo.island.tsx"));
+    expect(out).not.toContain(path.resolve("/project/app"));
+  });
+});