@blzsky/variant 0.2.1 → 0.3.0-canary.1

package/dist/{run-C6VAQOVM.js → run-UOPS5FRU.js}

@@ -2,23 +2,24 @@ import {
   executeTarget,
   renderDryRunPlan,
   reportRunInsights
-} from "./chunk-FA64KWJ2.js";
-import "./chunk-43VLELTL.js";
-import "./chunk-QRPI6TJE.js";
+} from "./chunk-TPMHY4L6.js";
+import "./chunk-2UVLKBLV.js";
 import {
   createContext,
   toRunOptions
-} from "./chunk-ZH2PQUNL.js";
-import "./chunk-V5CTGXMM.js";
-import "./chunk-26DHEXGS.js";
-import "./chunk-YYGCSKIQ.js";
+} from "./chunk-EFCMBBBT.js";
+import "./chunk-H55GYSQ6.js";
 import "./chunk-GDSZFIHM.js";
-import "./chunk-7OPTWU6E.js";
+import "./chunk-MKUYZIXF.js";
+import "./chunk-IHXJ72XA.js";
+import "./chunk-V5CTGXMM.js";
 import "./chunk-3E5LBU3O.js";
-import "./chunk-6BXSZPHC.js";
 import "./chunk-6J4XDG44.js";
+import "./chunk-NOC53Z5Q.js";
+import "./chunk-YYGCSKIQ.js";
 import "./chunk-EISTWXDW.js";
-import "./chunk-VYWPQKMS.js";
+import "./chunk-OON6O4S5.js";
+import "./chunk-C3NZIFW6.js";
 
 // src/cli/commands/run.ts
 async function registerRunAction(taskName, opts = {}) {

package/dist/stryker-host.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/stryker-host.js

@@ -0,0 +1,135 @@
+import {
+  EXCLUDED_MUTATORS
+} from "./chunk-WTXWEEI2.js";
+
+// src/adapters/mutation/stryker-host.ts
+import { readFile } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { Stryker } from "@stryker-mutator/core";
+
+// src/adapters/mutation/tsconfig.ts
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+async function canRewriteTsconfig(load) {
+  try {
+    const module = await load();
+    const api = module?.default ?? module;
+    return typeof api?.["parseConfigFileTextToJson"] === "function";
+  } catch {
+    return false;
+  }
+}
+function loadTypescriptAsStryker() {
+  const core = createRequire(import.meta.url).resolve("@stryker-mutator/core");
+  const typescript = createRequire(core).resolve("typescript");
+  return import(pathToFileURL(typescript).href);
+}
+async function tsconfigLeavesPackage(root, read) {
+  const { ts } = await import("ts-morph");
+  const visited = /* @__PURE__ */ new Set();
+  const inside = (file) => {
+    const relative = path.relative(root, file);
+    return !relative.startsWith("..") && !path.isAbsolute(relative);
+  };
+  const visit = async (file) => {
+    if (visited.has(file)) return false;
+    visited.add(file);
+    const text = await read(file);
+    if (text === null) return false;
+    const config = ts.parseConfigFileTextToJson(file, text).config;
+    const extended = Array.isArray(config?.extends) ? config.extends : [config?.extends];
+    for (const target of extended) {
+      if (typeof target !== "string" || !target.startsWith(".")) continue;
+      const resolved = path.resolve(path.dirname(file), target);
+      if (!inside(resolved)) return true;
+      if (await visit(resolved.endsWith(".json") ? resolved : `${resolved}.json`)) {
+        return true;
+      }
+    }
+    const references = Array.isArray(config?.references) ? config.references : [];
+    return references.some(
+      (reference) => typeof reference?.path === "string" && !inside(
+        path.resolve(
+          path.dirname(file),
+          reference.path
+        )
+      )
+    );
+  };
+  return visit(path.join(root, "tsconfig.json"));
+}
+
+// src/adapters/mutation/stryker-host.ts
+function logLevel(value) {
+  return value;
+}
+function send(message) {
+  process.send?.(message);
+}
+process.on("disconnect", () => {
+  if (process.platform === "win32") process.exit(1);
+  try {
+    process.kill(-process.pid, "SIGKILL");
+  } catch {
+    process.exit(1);
+  }
+});
+process.once("message", (request) => {
+  void run(request);
+});
+async function run(request) {
+  const vitestRunner = createRequire2(import.meta.url).resolve(
+    "@stryker-mutator/vitest-runner"
+  );
+  const rewriteTsconfig = await canRewriteTsconfig(loadTypescriptAsStryker);
+  if (!rewriteTsconfig && await tsconfigLeavesPackage(
+    process.cwd(),
+    (file) => readFile(file, "utf8").catch(() => null)
+  ).catch(() => false)) {
+    send({
+      kind: "note",
+      text: "the tsconfig here points outside this package (a relative `extends` or `references`). This TypeScript has no JavaScript API (TypeScript 7 does not), so that path was not adjusted for the copy the tests ran in."
+    });
+  }
+  try {
+    await new Stryker({
+      ...!rewriteTsconfig && {
+        tsconfigFile: `${request.tempDirName}.no-tsconfig.json`
+      },
+      configFile: request.configFile,
+      // Stryker's Vitest runner, made to count a test file that fails to
+      // load: see stryker-plugins.ts.
+      testRunner: "variant-vitest",
+      vitest: {
+        // The whole configured suite in the baseline, so each mutant's
+        // tests come from measured coverage, not from Vitest's guess at
+        // which tests relate to the file.
+        related: false,
+        ...request.vitestConfig !== void 0 && {
+          configFile: request.vitestConfig
+        }
+      },
+      mutate: request.mutate,
+      mutator: { excludedMutations: EXCLUDED_MUTATORS },
+      plugins: [vitestRunner],
+      appendPlugins: [request.plugins],
+      reporters: ["variant"],
+      tempDirName: request.tempDirName,
+      cleanTempDir: "always",
+      ignorePatterns: ["/.variant"],
+      fileLogLevel: logLevel("off"),
+      // Stryker names the failing baseline tests only in its log.
+      logLevel: logLevel("error"),
+      incremental: false,
+      thresholds: { high: 80, low: 60, break: null },
+      dryRunTimeoutMinutes: request.baselineTimeoutMinutes
+    }).runMutationTest();
+    send({ kind: "finished" });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    send(
+      /failed tests in the initial test run/i.test(message) ? { kind: "baseline-failed" } : { kind: "error", message }
+    );
+  }
+}

package/dist/stryker-plugins.d.ts

@@ -0,0 +1,33 @@
+import * as _stryker_mutator_api_plugin from '@stryker-mutator/api/plugin';
+import { PluginKind } from '@stryker-mutator/api/plugin';
+import { TestRunner, FailedTestResult, SkippedTestResult, DryRunResult } from '@stryker-mutator/api/test-runner';
+
+/**
+ * Stryker's setup records each file's coverage on `meta.mutantCoverage`, as
+ * whatever the instrumented code collected: nothing at all when no mutated
+ * code ran. With every file empty its runner returns no coverage, which
+ * Stryker reads as "coverage analysis off": every mutant then ran against
+ * every test, and code no test imports read as undetected (found on pyra).
+ *
+ * The key is set even when empty, so a file that has it shows the setup ran
+ * and found nothing: that is coverage, of nothing. A file without it says
+ * nothing either way.
+ */
+declare function measuredNothing(runner: TestRunner): boolean;
+/**
+ * Tests Vitest skipped (`skip`, `skipIf`, `todo`). They have no result, and
+ * Stryker's runner keeps only tests with one, so without these the report
+ * could not say that any were skipped.
+ */
+declare function skippedTests(runner: TestRunner): SkippedTestResult[];
+/**
+ * Files Vitest could not run at all: an import that fails, a `beforeAll` at
+ * the top of the file that throws. Their errors sit on the file, not on a
+ * test, which is where Stryker's runner looks.
+ */
+declare function filesThatDidNotLoad(runner: TestRunner): FailedTestResult[];
+/** The baseline as Vitest saw it: files that did not load fail it, and skipped tests are counted. */
+declare function withLoadFailures(result: DryRunResult, runner: TestRunner): DryRunResult;
+declare const strykerPlugins: (_stryker_mutator_api_plugin.FactoryPlugin<PluginKind.TestRunner, ["$injector"]> | _stryker_mutator_api_plugin.ClassPlugin<PluginKind.Reporter, []>)[];
+
+export { filesThatDidNotLoad, measuredNothing, skippedTests, strykerPlugins, withLoadFailures };

package/dist/stryker-plugins.js

@@ -0,0 +1,142 @@
+import {
+  LOAD_FAILURE_SUFFIX
+} from "./chunk-WTXWEEI2.js";
+
+// src/adapters/mutation/stryker-plugins.ts
+import {
+  commonTokens,
+  declareClassPlugin,
+  declareFactoryPlugin,
+  PluginKind,
+  tokens
+} from "@stryker-mutator/api/plugin";
+import { DryRunStatus, TestStatus } from "@stryker-mutator/api/test-runner";
+import { strykerPlugins as vitestPlugins } from "@stryker-mutator/vitest-runner";
+function send(message) {
+  process.send?.(message);
+}
+var VariantReporter = class {
+  onDryRunCompleted(event) {
+    const result = event.result;
+    send({
+      kind: "baseline",
+      tests: (result.status === "complete" ? result.tests : []).map((test) => ({
+        id: test.id,
+        name: test.name,
+        ...test.fileName !== void 0 && { fileName: test.fileName },
+        ...test.status === TestStatus.Skipped && { skipped: true }
+      }))
+    });
+  }
+  onMutationTestingPlanReady(event) {
+    send({
+      kind: "plan",
+      mutants: event.mutantPlans.map(({ mutant }) => ({
+        id: mutant.id,
+        fileName: mutant.fileName,
+        mutatorName: mutant.mutatorName,
+        replacement: mutant.replacement,
+        location: mutant.location,
+        ...mutant.coveredBy !== void 0 && { coveredBy: mutant.coveredBy },
+        ...mutant.static !== void 0 && { static: mutant.static }
+      }))
+    });
+  }
+  onMutantTested(result) {
+    send({
+      kind: "tested",
+      mutant: {
+        id: result.id,
+        status: result.status,
+        ...result.statusReason !== void 0 && {
+          statusReason: result.statusReason
+        },
+        ...result.killedBy !== void 0 && {
+          killedBy: [...result.killedBy]
+        },
+        ...result.testsCompleted !== void 0 && {
+          testsCompleted: result.testsCompleted
+        }
+      }
+    });
+  }
+};
+function measuredNothing(runner) {
+  const files = runner.ctx?.state?.getFiles?.() ?? [];
+  return files.some(
+    (file) => file.meta !== void 0 && Object.hasOwn(file.meta, "mutantCoverage")
+  );
+}
+function skippedTests(runner) {
+  const files = runner.ctx?.state?.getFiles?.() ?? [];
+  const out = [];
+  const walk = (task, file) => {
+    if (task.type === "test") {
+      if (task.result === void 0 && (task.mode === "skip" || task.mode === "todo")) {
+        out.push({
+          id: task.id ?? `${file.name ?? ""}#${task.name ?? ""}`,
+          name: task.name ?? "a skipped test",
+          status: TestStatus.Skipped,
+          timeSpentMs: 0,
+          ...file.filepath !== void 0 && { fileName: file.filepath }
+        });
+      }
+      return;
+    }
+    for (const child of task.tasks ?? []) walk(child, file);
+  };
+  for (const file of files) walk(file, file);
+  return out;
+}
+function filesThatDidNotLoad(runner) {
+  const files = runner.ctx?.state?.getFiles?.() ?? [];
+  return files.filter((file) => (file.result?.errors?.length ?? 0) > 0).map((file) => {
+    const name = file.name ?? file.filepath ?? "a test file";
+    return {
+      id: `${name}#variant-load`,
+      name: `${name}${LOAD_FAILURE_SUFFIX}`,
+      status: TestStatus.Failed,
+      failureMessage: file.result?.errors?.[0]?.message?.split("\n")[0] ?? "the file failed to load",
+      timeSpentMs: 0,
+      ...file.filepath !== void 0 && { fileName: file.filepath }
+    };
+  });
+}
+function withLoadFailures(result, runner) {
+  if (result.status !== DryRunStatus.Complete) return result;
+  const added = [...filesThatDidNotLoad(runner), ...skippedTests(runner)];
+  const coverage = result.mutantCoverage === void 0 && measuredNothing(runner) ? { mutantCoverage: { static: {}, perTest: {} } } : {};
+  return added.length === 0 && Object.keys(coverage).length === 0 ? result : { ...result, ...coverage, tests: [...result.tests, ...added] };
+}
+var vitest = vitestPlugins.find(
+  (plugin) => plugin.kind === PluginKind.TestRunner && plugin.name === "vitest"
+);
+function createVitestRunner(injector) {
+  if (vitest === void 0 || !("factory" in vitest)) {
+    throw new Error("@stryker-mutator/vitest-runner has no Vitest runner");
+  }
+  const runner = injector.injectFunction(vitest.factory);
+  return {
+    capabilities: () => runner.capabilities(),
+    init: async () => runner.init?.(),
+    dryRun: async (options) => withLoadFailures(await runner.dryRun(options), runner),
+    mutantRun: (options) => runner.mutantRun(options),
+    dispose: async () => runner.dispose?.()
+  };
+}
+createVitestRunner.inject = tokens(commonTokens.injector);
+var strykerPlugins = [
+  declareClassPlugin(PluginKind.Reporter, "variant", VariantReporter),
+  declareFactoryPlugin(
+    PluginKind.TestRunner,
+    "variant-vitest",
+    createVitestRunner
+  )
+];
+export {
+  filesThatDidNotLoad,
+  measuredNothing,
+  skippedTests,
+  strykerPlugins,
+  withLoadFailures
+};

package/dist/{symbol-graph-E5GXKDFZ.js → symbol-graph-GYOI4GU4.js}

@@ -7,9 +7,9 @@ import {
   loadSymbolGraph,
   saveSymbolGraph,
   updateSymbolGraph
-} from "./chunk-TCISS2AS.js";
-import "./chunk-RC23JQKI.js";
-import "./chunk-VYWPQKMS.js";
+} from "./chunk-XXMD4NC5.js";
+import "./chunk-WULBOSG5.js";
+import "./chunk-C3NZIFW6.js";
 export {
   SYMBOL_GRAPH_VERSION,
   buildSymbolGraph,

package/dist/{tsconfig-paths-E3UEDGXZ.js → tsconfig-paths-SV3PULCW.js}

@@ -1,9 +1,11 @@
 import {
+  aliasesInScope,
   matchPathAlias,
   readPathAliases,
   toPathAliases
-} from "./chunk-KSHWC2XN.js";
+} from "./chunk-X3VVGTEV.js";
 export {
+  aliasesInScope,
   matchPathAlias,
   readPathAliases,
   toPathAliases