executable-stories-vitest 8.1.16 → 8.1.17

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { DocEntry, StepKeyword } from 'executable-stories-formatters';
 export { ColocatedStyle, DocEntry, DocPhase, FormatterOptions, NormalizedTicket, OutputFormat, OutputMode, OutputRule, STORY_META_KEY, StepKeyword, StepMode, StoryMeta, StoryStep } from 'executable-stories-formatters';
-export { StoryReporterOptions } from './reporter.cjs';
+export { StoryReporterOptions, StoryReporterProtocol, VitestContext, createStoryReporter } from './reporter.cjs';
 import 'vitest/node';
 
 /**
@@ -501,19 +501,21 @@ type Story = typeof story;
  * });
  * ```
  *
- * In vitest.config, import StoryReporter from "executable-stories-vitest/reporter":
+ * In vitest.config, use createStoryReporter factory from "executable-stories-vitest/reporter":
  *
  * @example
  * ```ts
  * import { defineConfig } from "vitest/config";
- * import { StoryReporter } from "executable-stories-vitest/reporter";
+ * import { createStoryReporter } from "executable-stories-vitest/reporter";
  *
  * export default defineConfig({
  *   test: {
- *     reporters: ["default", new StoryReporter()],
+ *     reporters: ["default", createStoryReporter()],
  *   },
  * });
  * ```
+ *
+ * The factory provides type-safe reporter creation with no type casts.
  */
 
 /** @internal Guard: throws if used. Import StoryReporter from "executable-stories-vitest/reporter" in vitest.config. */

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { DocEntry, StepKeyword } from 'executable-stories-formatters';
 export { ColocatedStyle, DocEntry, DocPhase, FormatterOptions, NormalizedTicket, OutputFormat, OutputMode, OutputRule, STORY_META_KEY, StepKeyword, StepMode, StoryMeta, StoryStep } from 'executable-stories-formatters';
-export { StoryReporterOptions } from './reporter.js';
+export { StoryReporterOptions, StoryReporterProtocol, VitestContext, createStoryReporter } from './reporter.js';
 import 'vitest/node';
 
 /**
@@ -501,19 +501,21 @@ type Story = typeof story;
  * });
  * ```
  *
- * In vitest.config, import StoryReporter from "executable-stories-vitest/reporter":
+ * In vitest.config, use createStoryReporter factory from "executable-stories-vitest/reporter":
  *
  * @example
  * ```ts
  * import { defineConfig } from "vitest/config";
- * import { StoryReporter } from "executable-stories-vitest/reporter";
+ * import { createStoryReporter } from "executable-stories-vitest/reporter";
  *
  * export default defineConfig({
  *   test: {
- *     reporters: ["default", new StoryReporter()],
+ *     reporters: ["default", createStoryReporter()],
  *   },
  * });
  * ```
+ *
+ * The factory provides type-safe reporter creation with no type casts.
  */
 
 /** @internal Guard: throws if used. Import StoryReporter from "executable-stories-vitest/reporter" in vitest.config. */

package/dist/index.js

@@ -27,17 +27,17 @@ function looksLikeFilePath(name) {
   return false;
 }
 function extractSuitePath(task) {
-  const path = [];
+  const path2 = [];
   const fileName = task.file?.name;
   let current = task.suite;
   while (current) {
     const name = current.name;
     if (name && name.trim() !== "" && name !== "<root>" && name !== fileName && !looksLikeFilePath(name)) {
-      path.unshift(name);
+      path2.unshift(name);
     }
     current = current.suite;
   }
-  return path.length > 0 ? path : void 0;
+  return path2.length > 0 ? path2 : void 0;
 }
 function normalizeTickets(ticket) {
   if (!ticket) return void 0;
@@ -479,9 +479,312 @@ var story = {
 // src/types.ts
 import { STORY_META_KEY } from "executable-stories-formatters";
 
+// src/reporter.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  ReportGenerator,
+  canonicalizeRun,
+  readGitSha,
+  readPackageVersion,
+  detectCI,
+  sendNotifications,
+  toCIInfo,
+  loadHistory,
+  updateHistory,
+  saveHistory
+} from "executable-stories-formatters";
+function normalizeCoveragePayload(coverage) {
+  if (!coverage || typeof coverage !== "object" || Array.isArray(coverage))
+    return void 0;
+  const raw = coverage;
+  const data = {};
+  for (const [filePath, file] of Object.entries(raw)) {
+    if (file && typeof file === "object" && "s" in file && "f" in file && "b" in file) {
+      data[filePath] = file;
+    }
+  }
+  if (Object.keys(data).length === 0) return void 0;
+  return data;
+}
+function summarizeCoverage(data) {
+  let statementsTotal = 0;
+  let statementsCovered = 0;
+  let functionsTotal = 0;
+  let functionsCovered = 0;
+  let branchesTotal = 0;
+  let branchesCovered = 0;
+  let linesTotal = 0;
+  let linesCovered = 0;
+  let hasLines = false;
+  for (const file of Object.values(data)) {
+    for (const count of Object.values(file.s)) {
+      statementsTotal += 1;
+      if (count > 0) statementsCovered += 1;
+    }
+    for (const count of Object.values(file.f)) {
+      functionsTotal += 1;
+      if (count > 0) functionsCovered += 1;
+    }
+    for (const counts of Object.values(file.b)) {
+      for (const count of counts) {
+        branchesTotal += 1;
+        if (count > 0) branchesCovered += 1;
+      }
+    }
+    if (file.l) {
+      hasLines = true;
+      for (const count of Object.values(file.l)) {
+        linesTotal += 1;
+        if (count > 0) linesCovered += 1;
+      }
+    }
+  }
+  if (statementsTotal === 0 && functionsTotal === 0 && branchesTotal === 0 && !hasLines) {
+    return void 0;
+  }
+  const metric = (covered, total) => ({
+    total,
+    covered,
+    pct: total === 0 ? 100 : Math.round(covered / total * 100)
+  });
+  const summary = {
+    statements: metric(statementsCovered, statementsTotal),
+    branches: metric(branchesCovered, branchesTotal),
+    functions: metric(functionsCovered, functionsTotal)
+  };
+  if (hasLines) {
+    summary.lines = metric(linesCovered, linesTotal);
+  }
+  return summary;
+}
+function toCoverageSummary(data) {
+  if (!data) return void 0;
+  return {
+    statementsPct: data.statements.pct,
+    branchesPct: data.branches.pct,
+    functionsPct: data.functions.pct,
+    linesPct: data.lines?.pct
+  };
+}
+function toRelativePosix(absolutePath, projectRoot) {
+  return path.relative(projectRoot, absolutePath).split(path.sep).join("/");
+}
+var StoryReporter = class {
+  options;
+  ctx;
+  startTime = 0;
+  packageVersion;
+  gitSha;
+  coverageByFile = {};
+  constructor(options = {}) {
+    this.options = options;
+  }
+  onInit(ctx) {
+    this.ctx = ctx;
+    this.startTime = Date.now();
+    const root = ctx.config?.root ?? process.cwd();
+    const includeMetadata = this.options.markdown?.includeMetadata ?? true;
+    if (includeMetadata) {
+      this.packageVersion = readPackageVersion(root);
+      this.gitSha = readGitSha(root);
+    }
+  }
+  onCoverage(coverage) {
+    const data = normalizeCoveragePayload(coverage);
+    if (data) {
+      this.coverageByFile = { ...this.coverageByFile, ...data };
+    }
+  }
+  async onTestRunEnd(testModules, _unhandledErrors, reason) {
+    if (reason === "interrupted") return;
+    const root = this.ctx?.config?.root ?? process.cwd();
+    const rawTestCases = this.collectTestCases(testModules, root);
+    const rawRun = {
+      testCases: rawTestCases,
+      startedAtMs: this.startTime,
+      finishedAtMs: Date.now(),
+      projectRoot: root,
+      packageVersion: this.packageVersion,
+      gitSha: this.gitSha,
+      ci: detectCI()
+    };
+    const rawRunPath = this.options.rawRunPath;
+    if (rawRunPath) {
+      try {
+        const absolutePath = path.isAbsolute(rawRunPath) ? rawRunPath : path.join(root, rawRunPath);
+        const dir = path.dirname(absolutePath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const payload = { schemaVersion: 1, ...rawRun };
+        fs.writeFileSync(absolutePath, JSON.stringify(payload, null, 2), "utf8");
+      } catch (err) {
+        console.error("Failed to write raw run JSON:", err);
+      }
+    }
+    const canonicalRun = canonicalizeRun(rawRun);
+    const coverageData = summarizeCoverage(this.coverageByFile);
+    if (coverageData) {
+      canonicalRun.coverage = toCoverageSummary(coverageData);
+    }
+    const generator = new ReportGenerator(this.options);
+    try {
+      const results = await generator.generate(canonicalRun);
+      const enableGithubSummary = this.options.enableGithubActionsSummary ?? true;
+      if (process.env.GITHUB_ACTIONS === "true" && enableGithubSummary) {
+        const markdownPaths = results.get("markdown") ?? [];
+        if (markdownPaths.length > 0) {
+          const firstPath = markdownPaths[0];
+          const content = fs.readFileSync(firstPath, "utf8");
+          await this.appendGithubSummary(content).catch(() => {
+          });
+        }
+      }
+    } catch (err) {
+      console.error("Failed to generate reports:", err);
+    }
+    try {
+      const histOpts = this.options.history;
+      if (histOpts?.filePath) {
+        const historyPath = path.isAbsolute(histOpts.filePath) ? histOpts.filePath : path.join(root, histOpts.filePath);
+        const store = loadHistory(
+          { filePath: historyPath },
+          {
+            readFile: (p) => {
+              try {
+                return fs.readFileSync(p, "utf8");
+              } catch {
+                return void 0;
+              }
+            },
+            logger: console
+          }
+        );
+        const updated = updateHistory({ store, run: canonicalRun, maxRuns: histOpts.maxRuns ?? 10 });
+        const dir = path.dirname(historyPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        saveHistory(
+          { filePath: historyPath, store: updated },
+          { writeFile: (p, c) => fs.writeFileSync(p, c, "utf8") }
+        );
+      }
+    } catch (err) {
+      console.error("Failed to update history:", err);
+    }
+    try {
+      if (this.options.notification) {
+        await sendNotifications(
+          { run: canonicalRun, notification: this.options.notification },
+          { fetch: globalThis.fetch, logger: console, toCIInfo }
+        );
+      }
+    } catch (err) {
+      console.error("Failed to send notifications:", err);
+    }
+  }
+  /**
+   * Collect test cases from Vitest test modules.
+   */
+  collectTestCases(testModules, root) {
+    const testCases = [];
+    for (const mod of testModules) {
+      const collection = mod.children;
+      if (!collection) continue;
+      const moduleId = mod.moduleId ?? mod.relativeModuleId ?? "";
+      const absoluteModuleId = path.isAbsolute(moduleId) ? moduleId : path.resolve(root, moduleId);
+      const sourceFile = toRelativePosix(absoluteModuleId, root);
+      for (const test of collection.allTests()) {
+        const meta = this.getStoryMeta(test);
+        if (!meta?.scenario || !Array.isArray(meta.steps)) continue;
+        const result = test.result?.();
+        const state = result?.state ?? "pending";
+        const durationMs = typeof result?.duration === "number" ? result.duration : 0;
+        let errorMessage;
+        let errorStack;
+        if (state === "failed" && result) {
+          const errors = result.errors;
+          if (errors?.length) {
+            const err = errors[0];
+            errorMessage = err.message;
+            errorStack = err.stack;
+          }
+        }
+        const statusMap = {
+          passed: "pass",
+          failed: "fail",
+          skipped: "skip",
+          pending: "pending",
+          todo: "pending"
+        };
+        const taskMeta = test.meta();
+        const scopedAttachments = taskMeta?.storyAttachments ?? [];
+        const attachments = scopedAttachments.map((a) => ({
+          name: a.name,
+          mediaType: a.mediaType,
+          path: a.path,
+          body: a.body,
+          encoding: a.encoding,
+          charset: a.charset,
+          fileName: a.fileName,
+          stepIndex: a.stepIndex,
+          stepId: a.stepId
+        }));
+        const stepEvents = meta.steps.filter((s) => s.durationMs !== void 0).map((s, i) => ({
+          index: i,
+          title: s.text,
+          durationMs: s.durationMs
+        }));
+        const otelSpans = taskMeta?.otelSpans;
+        if (Array.isArray(otelSpans) && otelSpans.length > 0) {
+          const valid = otelSpans.filter(
+            (s) => s != null && typeof s === "object" && typeof s.spanId === "string" && typeof s.name === "string"
+          );
+          if (valid.length > 0) {
+            meta.otelSpans = valid;
+          }
+        }
+        const retryCount = result?.retryCount ?? 0;
+        const configuredRetries = Math.max(
+          retryCount,
+          test.retries ?? test.options?.retry ?? 0
+        );
+        testCases.push({
+          title: meta.scenario,
+          titlePath: meta.suitePath ? [...meta.suitePath, meta.scenario] : [meta.scenario],
+          story: meta,
+          sourceFile,
+          sourceLine: Math.max(1, meta.sourceOrder ?? 1),
+          status: statusMap[state] ?? "unknown",
+          durationMs,
+          error: errorMessage ? { message: errorMessage, stack: errorStack } : void 0,
+          attachments: attachments.length > 0 ? attachments : void 0,
+          stepEvents: stepEvents.length > 0 ? stepEvents : void 0,
+          retry: retryCount,
+          retries: configuredRetries
+        });
+      }
+    }
+    return testCases;
+  }
+  getStoryMeta(test) {
+    const meta = test.meta();
+    return meta?.["story"];
+  }
+  async appendGithubSummary(reportText) {
+    try {
+      const { summary } = await import("@actions/core");
+      summary.addRaw(reportText);
+      await summary.write();
+    } catch {
+    }
+  }
+};
+function createStoryReporter(options) {
+  return new StoryReporter(options);
+}
+
 // src/index.ts
 var STORY_REPORTER_GUARD_MSG = 'Do not import StoryReporter from "executable-stories-vitest". In vitest.config, import it from "executable-stories-vitest/reporter".';
-var StoryReporter = class {
+var StoryReporter2 = class {
   static __isGuard = true;
   constructor() {
     throw new Error(STORY_REPORTER_GUARD_MSG);
@@ -489,7 +792,8 @@ var StoryReporter = class {
 };
 export {
   STORY_META_KEY,
-  StoryReporter,
+  StoryReporter2 as StoryReporter,
+  createStoryReporter,
   story
 };
 //# sourceMappingURL=index.js.map