headlamp 0.1.21 → 0.1.23

package/dist/jest/reporter.cjs

@@ -0,0 +1,173 @@
+/* eslint-disable global-require */
+/* eslint-disable @typescript-eslint/no-require-imports */
+/* eslint-disable import/no-dynamic-require */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const print = (payload) => {
+  try {
+    const line = `[JEST-BRIDGE-EVENT] ${JSON.stringify(payload)}`;
+    (process.stderr || process.stdout).write(`${line}\n`);
+  } catch {}
+};
+
+const isObject = (v) => typeof v === 'object' && v !== null;
+const sanitizeError = (err) => {
+  if (!isObject(err)) return err;
+  const out = {};
+  const name = err.name || (err.constructor && err.constructor.name) || undefined;
+  if (name) out.name = String(name);
+  if (typeof err.message === 'string') out.message = err.message;
+  if (typeof err.stack === 'string') out.stack = err.stack;
+  if (err.code !== undefined) out.code = err.code;
+  if (err.expected !== undefined) out.expected = err.expected;
+  if (err.received !== undefined) out.received = err.received;
+  if (err.matcherResult && isObject(err.matcherResult)) {
+    const mr = err.matcherResult;
+    let messageText;
+    try {
+      messageText =
+        typeof mr.message === 'function'
+          ? String(mr.message())
+          : typeof mr.message === 'string'
+            ? mr.message
+            : undefined;
+    } catch {}
+    out.matcherResult = {
+      matcherName: typeof mr.matcherName === 'string' ? mr.matcherName : undefined,
+      message: messageText,
+      stack: typeof mr.stack === 'string' ? mr.stack : undefined,
+      expected: mr.expected,
+      received: mr.received,
+      actual: mr.actual,
+      pass: typeof mr.pass === 'boolean' ? mr.pass : undefined,
+    };
+  }
+  if (err.cause) {
+    out.cause = sanitizeError(err.cause);
+  }
+  // Copy own enumerable props to preserve custom data
+  try {
+    for (const key of Object.keys(err)) {
+      if (!(key in out)) out[key] = err[key];
+    }
+  } catch {}
+  return out;
+};
+const sanitizeDetail = (d) => {
+  if (typeof d === 'string') return d;
+  if (!isObject(d)) return d;
+  // Common Jest detail shapes
+  const out = {};
+  if (d.message) out.message = d.message;
+  if (d.stack) out.stack = d.stack;
+  if (d.error) out.error = sanitizeError(d.error);
+  if (d.matcherResult) {
+    out.matcherResult = sanitizeError({ matcherResult: d.matcherResult }).matcherResult;
+  }
+  if (d.expected !== undefined) out.expected = d.expected;
+  if (d.received !== undefined) out.received = d.received;
+  // Copy the rest
+  try {
+    for (const key of Object.keys(d)) {
+      if (!(key in out)) out[key] = d[key];
+    }
+  } catch {}
+  return out;
+};
+
+class BridgeReporter {
+  constructor(globalConfig, options) {
+    this.out =
+      process.env.JEST_BRIDGE_OUT ||
+      (options && options.outFile) ||
+      path.join(process.cwd(), 'coverage', 'jest-run.json');
+    this.buf = { startTime: Date.now(), testResults: [], aggregated: null };
+  }
+
+  onRunStart() {
+    this.buf.startTime = Date.now();
+  }
+
+  onTestResult(_test, tr) {
+    const mapAssertion = (a) => ({
+      title: a.title,
+      fullName: a.fullName || [...(a.ancestorTitles || []), a.title].join(' '),
+      status: a.status,
+      timedOut: Boolean(
+        a.status === 'failed' &&
+          String(a.failureMessages || '')
+            .toLowerCase()
+            .includes('timed out'),
+      ),
+      duration: a.duration || 0,
+      location: a.location || null,
+      failureMessages: (a.failureMessages || []).map(String),
+      failureDetails: (a.failureDetails || []).map(sanitizeDetail),
+    });
+    this.buf.testResults.push({
+      testFilePath: tr.testFilePath,
+      status: tr.numFailingTests ? 'failed' : 'passed',
+      timedOut: Boolean(
+        (tr.testExecError &&
+          /timed out/i.test(
+            String(tr.testExecError && (tr.testExecError.message || tr.testExecError)),
+          )) ||
+          /timed out/i.test(String(tr.failureMessage || '')),
+      ),
+      failureMessage: tr.failureMessage || '',
+      failureDetails: (tr.failureDetails || []).map(sanitizeDetail),
+      testExecError: tr.testExecError ? sanitizeError(tr.testExecError) : null,
+      console: tr.console || null,
+      perfStats: tr.perfStats || {},
+      testResults: (tr.testResults || []).map(mapAssertion),
+    });
+    try {
+      print({
+        type: 'suiteComplete',
+        testPath: tr.testFilePath,
+        numPassingTests: tr.numPassingTests,
+        numFailingTests: tr.numFailingTests,
+      });
+    } catch {}
+  }
+
+  onRunComplete(_contexts, agg) {
+    // Compute timed out counts heuristically from test results & errors
+    const suiteTimedOut = (r) =>
+      Boolean(
+        (r.testExecError &&
+          /timed out/i.test(
+            String(r.testExecError && (r.testExecError.message || r.testExecError)),
+          )) ||
+          /timed out/i.test(String(r.failureMessage || '')),
+      );
+    const fileTimeouts = this.buf.testResults.filter(suiteTimedOut);
+    const testTimeouts = this.buf.testResults
+      .flatMap((r) => r.testResults || [])
+      .filter((a) => a && a.timedOut);
+    this.buf.aggregated = {
+      numTotalTestSuites: agg.numTotalTestSuites,
+      numPassedTestSuites: agg.numPassedTestSuites,
+      numFailedTestSuites: agg.numFailedTestSuites,
+      numTotalTests: agg.numTotalTests,
+      numPassedTests: agg.numPassedTests,
+      numFailedTests: agg.numFailedTests,
+      numPendingTests: agg.numPendingTests,
+      numTodoTests: agg.numTodoTests,
+      numTimedOutTests: testTimeouts.length,
+      numTimedOutTestSuites: fileTimeouts.length,
+      startTime: agg.startTime,
+      success: agg.success,
+      runTimeMs: agg.testResults.reduce(
+        (t, r) => t + Math.max(0, (r.perfStats?.end || 0) - (r.perfStats?.start || 0)),
+        0,
+      ),
+    };
+    fs.mkdirSync(path.dirname(this.out), { recursive: true });
+    fs.writeFileSync(this.out, JSON.stringify(this.buf), 'utf8');
+  }
+}
+
+module.exports = BridgeReporter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "headlamp",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Coverage-first, runner-agnostic test UX CLI for Jest",
   "type": "module",
   "main": "dist/index.js",
@@ -23,8 +23,8 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "release": "npm publish --access public",
-    "build:yalc": "npm run build && npx yalc publish && node ./scripts/print-publish-log.mjs",
-    "dev:yalc": "nodemon -w src -e ts,tsx,js,jsx -d 700ms -x \"npm run build:yalc\""
+    "build:yalc": "npm run build && npx yalc publish --push && node ./scripts/print-publish-log.mjs",
+    "dev:yalc": "nodemon -w src -w src/jest -e ts,tsx,js,jsx,cjs -d 300ms -x \"npm run build:yalc\""
   },
   "keywords": [
     "testing",

package/scripts/build.mjs

@@ -1,7 +1,9 @@
-import { build } from 'esbuild';
-import { rm, mkdir, writeFile, chmod } from 'node:fs/promises';
+import { rm, mkdir, writeFile, chmod, cp } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { build } from 'esbuild';
+
 const root = resolve(new URL('.', import.meta.url).pathname, '..');
 const src = resolve(root, 'src');
 const dist = resolve(root, 'dist');
@@ -115,3 +117,7 @@ const cliPath = resolve(dist, 'cli.cjs');
 const cliContent = await (await import('node:fs/promises')).readFile(cliPath, 'utf8');
 await writeFile(cliPath, `#!/usr/bin/env node\n${cliContent}`);
 await chmod(cliPath, 0o755);
+
+// Copy Jest runtime assets (env/reporter) to dist so Jest can require them by absolute path
+await mkdir(resolve(dist, 'jest'), { recursive: true });
+await cp(resolve(src, 'jest'), resolve(dist, 'jest'), { recursive: true });