@epicat/toon-reporter 0.0.1 → 0.0.3

package/README.md

@@ -42,11 +42,11 @@ passing: 42
 ```
 passing: 40
 failing[2]:
-- at: src/utils.test.ts:15:12
-  expected: "7"
-  got: "6"
-- at: src/api.test.ts:42:8
-  error: TypeError: Cannot read property 'id' of undefined
+  - at: src/utils.test.ts:15:12
+    expected: "7"
+    got: "6"
+  - at: src/api.test.ts:42:8
+    error: TypeError: Cannot read property 'id' of undefined
 ```
 
 ### With parameterized test failures
@@ -56,10 +56,10 @@ Uses TOON tabular format for uniform parameter arrays:
 ```
 passing: 6
 failing[2]:
-- at: math.test.ts:16:17
-  parameters[2]{expected,got}:
-    "1","2"
-    "4","2"
+  - at: math.test.ts:16:17
+    parameters[2]{expected,got}:
+      "1","2"
+      "4","2"
 ```
 
 ### With todo/skipped tests
@@ -82,16 +82,19 @@ skipped[2]{at,name}:
 - **Gray**: `skipped` tests
 - **Cyan**: `todo` tests
 
-Colors are automatically disabled when:
-- `NO_COLOR` environment variable is set
-- `CI` environment variable is set
+Colors are enabled when:
+- `COLOR` environment variable is set, OR
+- `color: true` option is passed
+
+Colors are always disabled when:
+- `CI` environment variable is set (hard disable)
 - Output is written to a file
 
 ## Options
 
 ### `color`
 
-Enable/disable colored output (default: `false`).
+Enable/disable colored output.
 
 ```ts
 // vitest.config.ts
@@ -105,6 +108,12 @@ export default defineConfig({
 })
 ```
 
+Or via environment variable:
+
+```bash
+COLOR=1 npx vitest run --reporter=@epicat/toon-reporter
+```
+
 ### `outputFile`
 
 Write report to a file instead of stdout.

package/dist/index.d.mts

@@ -0,0 +1,27 @@
+import { SerializedError } from "@vitest/utils";
+import { Reporter, TestRunEndReason, Vitest } from "vitest/node";
+
+//#region src/toon-reporter.d.ts
+interface ToonReporterOptions {
+  outputFile?: string;
+  color?: boolean;
+  /** @internal Used for testing to capture output */
+  _captureOutput?: (output: string) => void;
+}
+declare class ToonReporter implements Reporter {
+  start: number;
+  ctx: Vitest;
+  options: ToonReporterOptions;
+  private useColor;
+  constructor(options?: ToonReporterOptions);
+  onInit(ctx: Vitest): void;
+  private formatLocation;
+  private parseErrorLocation;
+  private parseExpectedGot;
+  private formatErrorMessage;
+  onTestRunEnd(testModules: ReadonlyArray<any>, _unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): Promise<void>;
+  private colorize;
+  writeReport(report: string): Promise<void>;
+}
+//#endregion
+export { ToonReporter, ToonReporter as default, type ToonReporterOptions };

package/dist/index.mjs

@@ -0,0 +1,161 @@
+import { existsSync, promises } from "node:fs";
+import { dirname, relative, resolve } from "pathe";
+import { encode } from "@toon-format/toon";
+
+//#region node_modules/.pnpm/@vitest+utils@4.0.15/node_modules/@vitest/utils/dist/helpers.js
+function toArray(array) {
+	if (array === null || array === void 0) array = [];
+	if (Array.isArray(array)) return array;
+	return [array];
+}
+
+//#endregion
+//#region node_modules/.pnpm/@vitest+runner@4.0.15/node_modules/@vitest/runner/dist/chunk-tasks.js
+function isTestCase(s) {
+	return s.type === "test";
+}
+function getTests(suite) {
+	const tests = [];
+	const arraySuites = toArray(suite);
+	for (const s of arraySuites) if (isTestCase(s)) tests.push(s);
+	else for (const task of s.tasks) if (isTestCase(task)) tests.push(task);
+	else {
+		const taskTests = getTests(task);
+		for (const test of taskTests) tests.push(test);
+	}
+	return tests;
+}
+
+//#endregion
+//#region src/toon-reporter.ts
+function getOutputFile(config, reporter) {
+	if (!config?.outputFile) return;
+	if (typeof config.outputFile === "string") return config.outputFile;
+	return config.outputFile[reporter];
+}
+const colors = {
+	green: (s) => `\x1b[32m${s}\x1b[0m`,
+	red: (s) => `\x1b[31m${s}\x1b[0m`,
+	yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+	gray: (s) => `\x1b[90m${s}\x1b[0m`,
+	cyan: (s) => `\x1b[36m${s}\x1b[0m`
+};
+function shouldUseColor(option) {
+	if (process.env.CI) return false;
+	if (option !== void 0) return option;
+	return !!process.env.COLOR;
+}
+var ToonReporter = class {
+	constructor(options = {}) {
+		this.start = 0;
+		this.options = options;
+		this.useColor = shouldUseColor(options.color);
+	}
+	onInit(ctx) {
+		this.ctx = ctx;
+		this.start = Date.now();
+	}
+	formatLocation(relPath, line, column) {
+		return line ? `${relPath}:${line}:${column || 0}` : relPath;
+	}
+	parseErrorLocation(error, rootDir) {
+		const stack = error?.stack || "";
+		for (const line of stack.split("\n")) {
+			const match = line.match(/at\s+(?:.*?\s+\()?([^)\s]+):(\d+):(\d+)\)?/);
+			if (match) {
+				const [, filePath, lineNum, col] = match;
+				if (filePath.includes("node_modules") || filePath.startsWith("file:")) continue;
+				return {
+					relPath: relative(rootDir, filePath.startsWith(rootDir) ? filePath : resolve(rootDir, filePath)),
+					line: parseInt(lineNum, 10),
+					column: parseInt(col, 10)
+				};
+			}
+		}
+		return null;
+	}
+	parseExpectedGot(error) {
+		const match = (error?.message || "").match(/expected\s+(.+?)\s+to\s+(?:be|equal|deeply equal)\s+(.+?)(?:\s*\/\/|$)/i);
+		if (match) return {
+			expected: match[2].trim(),
+			got: match[1].trim()
+		};
+		if (error?.expected !== void 0 && error?.actual !== void 0) return {
+			expected: String(error.expected),
+			got: String(error.actual)
+		};
+		return {};
+	}
+	formatErrorMessage(error) {
+		let message = error.message || String(error);
+		if (message.startsWith("Test timed out")) message = message.split("\n")[0];
+		const name = error.name;
+		if (name && name !== "Error" && !message.startsWith(name)) message = `${name}: ${message}`;
+		return message;
+	}
+	async onTestRunEnd(testModules, _unhandledErrors, _reason) {
+		const tests = getTests(testModules.map((m) => m.task));
+		const rootDir = this.ctx.config.root;
+		const failedTests = tests.filter((t) => t.result?.state === "fail");
+		const passedCount = tests.filter((t) => t.result?.state === "pass").length;
+		const skippedTests = tests.filter((t) => t.mode === "skip");
+		const todoTests = tests.filter((t) => t.mode === "todo");
+		const grouped = /* @__PURE__ */ new Map();
+		const failures = [];
+		for (const t of failedTests) {
+			const error = t.result?.errors?.[0];
+			const loc = this.parseErrorLocation(error, rootDir);
+			const { expected, got } = this.parseExpectedGot(error);
+			const relPath = loc?.relPath || relative(rootDir, t.file.filepath);
+			const at = this.formatLocation(relPath, loc?.line || t.location?.line, loc?.column || t.location?.column);
+			if (t.each) {
+				if (!grouped.has(at)) grouped.set(at, []);
+				grouped.get(at).push(expected !== void 0 && got !== void 0 ? {
+					expected,
+					got
+				} : { error: this.formatErrorMessage(error) });
+			} else {
+				const failure = { at };
+				if (expected !== void 0 && got !== void 0) {
+					failure.expected = expected;
+					failure.got = got;
+				} else if (error) failure.error = this.formatErrorMessage(error);
+				failures.push(failure);
+			}
+		}
+		for (const [at, params] of grouped) failures.push({
+			at,
+			parameters: params
+		});
+		const mapToSkipped = (t) => ({
+			at: this.formatLocation(relative(rootDir, t.file.filepath), t.location?.line, t.location?.column),
+			name: t.name
+		});
+		const report = { passing: passedCount };
+		if (failures.length > 0) report.failing = failures;
+		if (todoTests.length > 0) report.todo = todoTests.map(mapToSkipped);
+		if (skippedTests.length > 0) report.skipped = skippedTests.map(mapToSkipped);
+		await this.writeReport(encode(report));
+	}
+	colorize(report) {
+		if (!this.useColor) return report;
+		return report.replace(/^(passing:)/m, colors.green("$1")).replace(/^(failing\[.*?\]:)/m, colors.red("$1")).replace(/^(todo\[.*?\]:)/m, colors.cyan("$1")).replace(/^(skipped\[.*?\]:)/m, colors.gray("$1")).replace(/(\S+\.test\.\w+:\d+:\d+)/g, colors.yellow("$1"));
+	}
+	async writeReport(report) {
+		if (this.options._captureOutput) {
+			this.options._captureOutput(report);
+			return;
+		}
+		const outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "toon");
+		if (outputFile) {
+			const reportFile = resolve(this.ctx.config.root, outputFile);
+			const outputDirectory = dirname(reportFile);
+			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
+			await promises.writeFile(reportFile, report, "utf-8");
+			this.ctx.logger.log(`TOON report written to ${reportFile}`);
+		} else this.ctx.logger.log(this.colorize(report));
+	}
+};
+
+//#endregion
+export { ToonReporter, ToonReporter as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicat/toon-reporter",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A minimal Vitest reporter optimized for LLM consumption",
   "repository": {
     "type": "git",
@@ -18,30 +18,26 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "test": "vitest run",
-    "test:watch": "vitest"
+  "peerDependencies": {
+    "vitest": ">=2.0.0"
+  },
+  "dependencies": {
+    "@toon-format/toon": "^2.0.1",
+    "pathe": "^2.0.3"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
-    "@types/istanbul-lib-coverage": "^2.0.6",
     "@types/node": "^24.10.1",
     "@vitest/runner": "4.0.15",
-    "@vitest/snapshot": "4.0.15",
     "@vitest/utils": "4.0.15",
-    "execa": "^9.6.1",
-    "gpt-tokenizer": "^3.4.0",
-    "istanbul-lib-coverage": "^3.2.2",
-    "pathe": "^2.0.3",
     "tsdown": "^0.16.4",
     "typescript": "^5.9.3",
-    "vite": "^7.2.6",
     "vitest": "4.0.15"
   },
-  "packageManager": "pnpm@10.22.0+sha512.bf049efe995b28f527fd2b41ae0474ce29186f7edcb3bf545087bd61fbbebb2bf75362d1307fda09c2d288e1e499787ac12d4fcb617a974718a6051f2eee741c",
-  "dependencies": {
-    "@toon-format/toon": "^2.0.1"
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}