headlamp 0.1.33 → 0.1.35

package/dist/jest/reporter.cjs

@@ -1,193 +0,0 @@
-/* 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,
-      // Consider suite-level errors as failures even when no individual assertions failed
-      status:
-        (tr && typeof tr.numFailingTests === 'number' && tr.numFailingTests > 0) ||
-        Boolean(tr.testExecError) ||
-        Boolean(tr.failureMessage)
-          ? '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);
-    // Recompute suite pass/fail counts to include suite-level errors/timeouts
-    const totalSuites = typeof agg.numTotalTestSuites === 'number' ? agg.numTotalTestSuites : 0;
-    const failedSuites = this.buf.testResults.filter(
-      (r) => r.status === 'failed' || r.testExecError || r.failureMessage,
-    ).length;
-    const passedSuites = Math.max(0, totalSuites - failedSuites);
-    const failedAssertions = typeof agg.numFailedTests === 'number' ? agg.numFailedTests : 0;
-    const suiteOnlyFailures = Math.max(0, failedSuites - failedAssertions);
-    const failedTestsInclSuiteErrors = failedAssertions + suiteOnlyFailures;
-
-    this.buf.aggregated = {
-      numTotalTestSuites: totalSuites,
-      numPassedTestSuites: passedSuites,
-      numFailedTestSuites: failedSuites,
-      numTotalTests: agg.numTotalTests,
-      numPassedTests: agg.numPassedTests,
-      numFailedTests: failedTestsInclSuiteErrors,
-      numPendingTests: agg.numPendingTests,
-      numTodoTests: agg.numTodoTests,
-      numTimedOutTests: testTimeouts.length,
-      numTimedOutTestSuites: fileTimeouts.length,
-      startTime: agg.startTime,
-      success:
-        Boolean(agg.success) &&
-        failedSuites === 0 &&
-        failedTestsInclSuiteErrors === 0 &&
-        fileTimeouts.length === 0,
-      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/dist/jest/setup.cjs

@@ -1,201 +0,0 @@
-/* eslint-disable global-require */
-/* eslint-disable @typescript-eslint/no-require-imports */
-/* eslint-disable import/no-dynamic-require */
-
-(function setupBridge() {
-  try {
-    const print = (payload) => {
-      try {
-        const line = `[JEST-BRIDGE-EVENT] ${JSON.stringify(payload)}`;
-        (process.stderr || process.stdout).write(`${line}\n`);
-      } catch {}
-    };
-
-    const toErr = (x) => {
-      try {
-        return x instanceof Error ? x : new Error(String(x));
-      } catch {
-        return new Error('unknown');
-      }
-    };
-
-    const getCtx = () => {
-      try {
-        const st =
-          global.expect && typeof global.expect.getState === 'function'
-            ? global.expect.getState()
-            : {};
-        return { testPath: st.testPath, currentTestName: st.currentTestName };
-      } catch {
-        return {};
-      }
-    };
-
-    // Capture console output during tests
-    try {
-      const g = global;
-      const levels = ['log', 'info', 'warn', 'error'];
-      const originals = {};
-      const maxEntries = 200;
-      const toText = (args) => {
-        try {
-          return args.map((v) => (typeof v === 'string' ? v : JSON.stringify(v))).join(' ');
-        } catch {
-          return args.map(String).join(' ');
-        }
-      };
-      if (!g.__JEST_CONSOLE_BUFFER__) g.__JEST_CONSOLE_BUFFER__ = [];
-      for (const lvl of levels) {
-        try {
-          originals[lvl] =
-            g.console[lvl] && g.console[lvl].bind ? g.console[lvl].bind(g.console) : g.console[lvl];
-          g.console[lvl] = (...args) => {
-            try {
-              const buf = Array.isArray(g.__JEST_CONSOLE_BUFFER__)
-                ? g.__JEST_CONSOLE_BUFFER__
-                : (g.__JEST_CONSOLE_BUFFER__ = []);
-              const msg = toText(args);
-              buf.push({ type: lvl, message: msg, ts: Date.now() });
-              if (buf.length > maxEntries) buf.splice(0, buf.length - maxEntries);
-              const ctx = getCtx();
-              print({ type: 'console', level: lvl, message: msg, ...ctx });
-            } catch {}
-            try {
-              return originals[lvl](...args);
-            } catch {
-              return undefined;
-            }
-          };
-        } catch {}
-      }
-    } catch {}
-
-    // Process-level error hooks
-    try {
-      const onRej = (reason) => {
-        const e = toErr(reason);
-        const c = getCtx();
-        print({
-          type: 'unhandledRejection',
-          name: e.name,
-          message: e.message,
-          stack: e.stack,
-          code: e.code ?? undefined,
-          ...c,
-        });
-      };
-      const onExc = (error) => {
-        const e = toErr(error);
-        const c = getCtx();
-        print({
-          type: 'uncaughtException',
-          name: e.name,
-          message: e.message,
-          stack: e.stack,
-          code: e.code ?? undefined,
-          ...c,
-        });
-      };
-      process.on('unhandledRejection', onRej);
-      process.on('uncaughtException', onExc);
-    } catch {}
-
-    // HTTP response patch
-    try {
-      const http = require('node:http');
-      const PATCH_FLAG = Symbol.for('jestBridgePatched');
-      const ORIGINAL_KEY = Symbol.for('jestBridgeOriginalEmit');
-      const originalEmit =
-        http &&
-        http.Server &&
-        http.Server.prototype &&
-        typeof http.Server.prototype.emit === 'function'
-          ? http.Server.prototype.emit
-          : null;
-      if (originalEmit && !http.Server.prototype.emit[PATCH_FLAG]) {
-        const MAX = 64 * 1024;
-        const asString = (x) => {
-          try {
-            if (typeof x === 'string') return x;
-            if (Buffer.isBuffer(x)) return x.toString('utf8');
-            return String(x);
-          } catch {
-            return '';
-          }
-        };
-        const patched = function (eventName, req, res) {
-          try {
-            if (
-              eventName === 'request' &&
-              req &&
-              res &&
-              typeof res.write === 'function' &&
-              typeof res.end === 'function'
-            ) {
-              const startAt = Date.now();
-              const chunks = [];
-              const write = res.write.bind(res);
-              const end = res.end.bind(res);
-              const method = req.method ? String(req.method) : undefined;
-              const url =
-                req.originalUrl || req.url ? String(req.originalUrl || req.url) : undefined;
-              res.write = function (chunk, enc, cb) {
-                try {
-                  const s = asString(chunk);
-                  if (s) chunks.push(s);
-                } catch {}
-                return write(chunk, enc, cb);
-              };
-              res.end = function (chunk, enc, cb) {
-                try {
-                  const s = asString(chunk);
-                  if (s) chunks.push(s);
-                } catch {}
-                try {
-                  const preview = chunks.join('').slice(0, MAX);
-                  const statusCode =
-                    typeof res.statusCode === 'number' ? res.statusCode : undefined;
-                  const ctx = getCtx();
-                  print({
-                    type: 'httpResponse',
-                    timestampMs: Date.now(),
-                    durationMs: Math.max(0, Date.now() - startAt),
-                    method,
-                    url,
-                    statusCode,
-                    bodyPreview: preview,
-                    ...ctx,
-                  });
-                } catch {}
-                return end(chunk, enc, cb);
-              };
-              try {
-                res.on('close', () => {
-                  try {
-                    const ended =
-                      typeof res.writableEnded === 'boolean' ? res.writableEnded : false;
-                    if (!ended) {
-                      const ctx = getCtx();
-                      print({
-                        type: 'httpAbort',
-                        timestampMs: Date.now(),
-                        durationMs: Math.max(0, Date.now() - startAt),
-                        method,
-                        url,
-                        ...ctx,
-                      });
-                    }
-                  } catch {}
-                });
-              } catch {}
-            }
-          } catch {}
-          return originalEmit.apply(this, arguments);
-        };
-        patched[PATCH_FLAG] = true;
-        patched[ORIGINAL_KEY] = originalEmit;
-        http.Server.prototype.emit = patched;
-      }
-    } catch {}
-  } catch {}
-})();

package/scripts/build.mjs

@@ -1,123 +0,0 @@
-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');
-
-await rm(dist, { recursive: true, force: true });
-await mkdir(dist, { recursive: true });
-
-// Build ESM library output (index.js)
-await build({
-  entryPoints: [resolve(src, 'index.ts')],
-  outdir: dist,
-  format: 'esm',
-  platform: 'node',
-  target: ['node18'],
-  bundle: true,
-  sourcemap: true,
-  external: [
-    'fs',
-    'path',
-    'os',
-    'crypto',
-    'stream',
-    'util',
-    'events',
-    'assert',
-    'buffer',
-    'querystring',
-    'url',
-    'http',
-    'https',
-    'zlib',
-    'child_process',
-    'cluster',
-    'dgram',
-    'dns',
-    'domain',
-    'http2',
-    'net',
-    'perf_hooks',
-    'process',
-    'punycode',
-    'readline',
-    'repl',
-    'string_decoder',
-    'tls',
-    'tty',
-    'v8',
-    'vm',
-    'worker_threads',
-    // Keep Istanbul libs external to avoid bundling CJS that requires('fs')
-    // which breaks in ESM bundles on Node 20+ with dynamic require shim
-    'istanbul-lib-coverage',
-    'istanbul-lib-report',
-    'istanbul-reports',
-  ],
-});
-
-// Build CJS CLI output (cli.cjs) to support CJS-only deps and dynamic require
-await build({
-  entryPoints: [resolve(src, 'cli.ts')],
-  outfile: resolve(dist, 'cli.cjs'),
-  format: 'cjs',
-  platform: 'node',
-  target: ['node18'],
-  bundle: true,
-  sourcemap: true,
-  external: [
-    // keep Node core externals trivial
-    'fs',
-    'path',
-    'os',
-    'crypto',
-    'stream',
-    'util',
-    'events',
-    'assert',
-    'buffer',
-    'querystring',
-    'url',
-    'http',
-    'https',
-    'zlib',
-    'child_process',
-    'cluster',
-    'dgram',
-    'dns',
-    'domain',
-    'http2',
-    'net',
-    'perf_hooks',
-    'process',
-    'punycode',
-    'readline',
-    'repl',
-    'string_decoder',
-    'tls',
-    'tty',
-    'v8',
-    'vm',
-    'worker_threads',
-    // Externalize Istanbul + picomatch so their internal dynamic requires resolve correctly
-    'istanbul-lib-coverage',
-    'istanbul-lib-report',
-    'istanbul-reports',
-    'picomatch',
-  ],
-});
-
-// Create a Node shebang for the CLI
-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 (reporter/setup) 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 });

package/scripts/postinstall.mjs

@@ -1,13 +0,0 @@
-import { chmod } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-const EXECUTABLE_MODE = 0o755;
-
-(async () => {
-  try {
-    const cli = resolve(new URL('.', import.meta.url).pathname, '..', 'dist', 'cli.cjs');
-    await chmod(cli, EXECUTABLE_MODE);
-  } catch {
-    // ignore (best-effort)
-  }
-})();

package/scripts/print-publish-log.mjs

@@ -1,29 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const rootDir = resolve(__dirname, '..');
-
-const pkgJsonPath = resolve(rootDir, 'package.json');
-const pkgRaw = await readFile(pkgJsonPath, 'utf8');
-const pkg = JSON.parse(pkgRaw);
-
-const date = new Date();
-// Detect the user's/system timezone; fall back to TZ env or UTC if unavailable
-const tz = Intl.DateTimeFormat().resolvedOptions().timeZone ?? process.env.TZ ?? 'UTC';
-// Friendly: "5:58 PM" (narrow no-break space before AM/PM to prevent wrapping)
-const ts = new Intl.DateTimeFormat('en-US', {
-  hour: 'numeric',
-  minute: '2-digit',
-  hour12: true,
-  timeZone: tz,
-  // If you want "CDT"/"CST", uncomment:
-  // timeZoneName: 'short',
-})
-  .format(date)
-  .replace(' AM', '\u202FAM')
-  .replace(' PM', '\u202FPM');
-
-// eslint-disable-next-line no-console
-console.log(`[${ts}] ${pkg.name}@${pkg.version} published in store.`);