@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/chunks/index.C5r1PdPD.js

@@ -0,0 +1,231 @@
+import fs from 'node:fs';
+import { getTasks, getFullName, getTests } from '../@vitest/runner/utils.js';
+import * as pathe from '../vendor/pathe.mjs';
+import c from '../vendor/tinyrainbow.mjs';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.M8mOzt4Y.js';
+import { stripVTControlCharacters } from 'node:util';
+import { notNullish } from '../@vitest/utils/helpers.js';
+
+function createBenchmarkJsonReport(files) {
+  const report = { files: [] };
+  for (const file of files) {
+    const groups = [];
+    for (const task of getTasks(file)) if (task?.type === "suite") {
+      const benchmarks = [];
+      for (const t of task.tasks) {
+        const benchmark = t.meta.benchmark && t.result?.benchmark;
+        if (benchmark) benchmarks.push({
+          id: t.id,
+          ...benchmark,
+          samples: []
+        });
+      }
+      if (benchmarks.length) groups.push({
+        fullName: getFullName(task, " > "),
+        benchmarks
+      });
+    }
+    report.files.push({
+      filepath: file.filepath,
+      groups
+    });
+  }
+  return report;
+}
+function flattenFormattedBenchmarkReport(report) {
+  const flat = {};
+  for (const file of report.files) for (const group of file.groups) for (const t of group.benchmarks) flat[t.id] = t;
+  return flat;
+}
+
+const outputMap = /* @__PURE__ */ new WeakMap();
+function formatNumber(number) {
+  const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
+  return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
+}
+const tableHead = [
+  "name",
+  "hz",
+  "min",
+  "max",
+  "mean",
+  "p75",
+  "p99",
+  "p995",
+  "p999",
+  "rme",
+  "samples"
+];
+function renderBenchmarkItems(result) {
+  return [
+    result.name,
+    formatNumber(result.hz || 0),
+    formatNumber(result.min || 0),
+    formatNumber(result.max || 0),
+    formatNumber(result.mean || 0),
+    formatNumber(result.p75 || 0),
+    formatNumber(result.p99 || 0),
+    formatNumber(result.p995 || 0),
+    formatNumber(result.p999 || 0),
+    `±${(result.rme || 0).toFixed(2)}%`,
+    (result.sampleCount || 0).toString()
+  ];
+}
+function computeColumnWidths(results) {
+  const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
+  return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
+}
+function padRow(row, widths) {
+  return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
+}
+function renderTableHead(widths) {
+  return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
+}
+function renderBenchmark(result, widths) {
+  const padded = padRow(renderBenchmarkItems(result), widths);
+  return [
+    padded[0],
+    c.blue(padded[1]),
+    c.cyan(padded[2]),
+    c.cyan(padded[3]),
+    c.cyan(padded[4]),
+    c.cyan(padded[5]),
+    c.cyan(padded[6]),
+    c.cyan(padded[7]),
+    c.cyan(padded[8]),
+    c.dim(padded[9]),
+    c.dim(padded[10])
+  ].join("  ");
+}
+function renderTable(options) {
+  const output = [];
+  const benchMap = {};
+  for (const task of options.tasks) if (task.meta.benchmark && task.result?.benchmark) benchMap[task.id] = {
+    current: task.result.benchmark,
+    baseline: options.compare?.[task.id]
+  };
+  const benchCount = Object.entries(benchMap).length;
+  const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
+  let idx = 0;
+  const padding = "  ".repeat(1 );
+  for (const task of options.tasks) {
+    const duration = task.result?.duration;
+    const bench = benchMap[task.id];
+    let prefix = "";
+    if (idx === 0 && task.meta?.benchmark) prefix += `${renderTableHead(columnWidths)}\n${padding}`;
+    prefix += ` ${getStateSymbol(task)} `;
+    let suffix = "";
+    if (task.type === "suite") suffix += c.dim(` (${getTests(task).length})`);
+    if (task.mode === "skip" || task.mode === "todo") suffix += c.dim(c.gray(" [skipped]"));
+    if (duration != null) {
+      const color = duration > options.slowTestThreshold ? c.yellow : c.green;
+      suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
+    }
+    if (options.showHeap && task.result?.heap != null) suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
+    if (bench) {
+      let body = renderBenchmark(bench.current, columnWidths);
+      if (options.compare && bench.baseline) {
+        if (bench.current.hz) {
+          const diff = bench.current.hz / bench.baseline.hz;
+          const diffFixed = diff.toFixed(2);
+          if (diffFixed === "1.0.0") body += c.gray(`  [${diffFixed}x]`);
+          if (diff > 1) body += c.blue(`  [${diffFixed}x] ⇑`);
+          else body += c.red(`  [${diffFixed}x] ⇓`);
+        }
+        output.push(padding + prefix + body + suffix);
+        const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
+        output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
+      } else {
+        if (bench.current.rank === 1 && benchCount > 1) body += c.bold(c.green("   fastest"));
+        if (bench.current.rank === benchCount && benchCount > 2) body += c.bold(c.gray("   slowest"));
+        output.push(padding + prefix + body + suffix);
+      }
+    } else output.push(padding + prefix + task.name + suffix);
+    if (task.result?.state !== "pass" && outputMap.get(task) != null) {
+      let data = outputMap.get(task);
+      if (typeof data === "string") {
+        data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
+        if (data === "") data = void 0;
+      }
+      if (data != null) {
+        const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
+        output.push(c.gray(truncateString(out, options.columns)));
+      }
+    }
+    idx++;
+  }
+  return output.filter(Boolean).join("\n");
+}
+
+class BenchmarkReporter extends DefaultReporter {
+  compare;
+  async onInit(ctx) {
+    super.onInit(ctx);
+    if (this.ctx.config.benchmark?.compare) {
+      const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
+      try {
+        this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
+      } catch (e) {
+        this.error(`Failed to read '${compareFile}'`, e);
+      }
+    }
+  }
+  onTaskUpdate(packs) {
+    for (const pack of packs) {
+      const task = this.ctx.state.idMap.get(pack[0]);
+      if (task?.type === "suite" && task.result?.state !== "run") task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
+        bench.result.benchmark.rank = Number(idx) + 1;
+      });
+    }
+  }
+  onTestSuiteResult(testSuite) {
+    super.onTestSuiteResult(testSuite);
+    this.printSuiteTable(testSuite);
+  }
+  printTestModule(testModule) {
+    this.printSuiteTable(testModule);
+  }
+  printSuiteTable(testTask) {
+    const state = testTask.state();
+    if (state === "pending" || state === "queued") return;
+    const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
+    const duration = testTask.task.result?.duration || 0;
+    if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
+      let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, separator)}`;
+      if (duration != null && duration > this.ctx.config.slowTestThreshold) title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+      this.log(title);
+      this.log(renderTable({
+        tasks: benches,
+        level: 1,
+        columns: this.ctx.logger.getColumns(),
+        compare: this.compare,
+        showHeap: this.ctx.config.logHeapUsage,
+        slowTestThreshold: this.ctx.config.slowTestThreshold
+      }));
+    }
+  }
+  async onTestRunEnd(testModules, unhandledErrors, reason) {
+    super.onTestRunEnd(testModules, unhandledErrors, reason);
+    // write output for future comparison
+    let outputFile = this.ctx.config.benchmark?.outputJson;
+    if (outputFile) {
+      outputFile = pathe.resolve(this.ctx.config.root, outputFile);
+      const outputDirectory = pathe.dirname(outputFile);
+      if (!fs.existsSync(outputDirectory)) await fs.promises.mkdir(outputDirectory, { recursive: true });
+      const output = createBenchmarkJsonReport(testModules.map((t) => t.task.file));
+      await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
+      this.log(`Benchmark report written to ${outputFile}`);
+    }
+  }
+}
+
+class VerboseBenchmarkReporter extends BenchmarkReporter {
+  verbose = true;
+}
+
+const BenchmarkReportsMap = {
+  default: BenchmarkReporter,
+  verbose: VerboseBenchmarkReporter
+};
+
+export { BenchmarkReporter as B, VerboseBenchmarkReporter as V, BenchmarkReportsMap as a };

package/dist/chunks/index.Chj8NDwU.js

@@ -0,0 +1,206 @@
+//#region src/messages.ts
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+
+//#endregion
+//#region src/utils.ts
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  return {
+    promise: new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    }),
+    resolve,
+    reject
+  };
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--) id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+//#endregion
+//#region src/main.ts
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+  const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+  let $closed = false;
+  const _rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promiseInit;
+  let rpc;
+  async function _call(method, args, event, optional) {
+    if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+    const req = {
+      m: method,
+      a: args,
+      t: TYPE_REQUEST
+    };
+    if (optional) req.o = true;
+    const send = async (_req) => post(serialize(_req));
+    if (event) {
+      await send(req);
+      return;
+    }
+    if (_promiseInit) try {
+      await _promiseInit;
+    } finally {
+      _promiseInit = void 0;
+    }
+    let { promise, resolve, reject } = createPromiseWithResolvers();
+    const id = nanoid();
+    req.i = id;
+    let timeoutId;
+    async function handler(newReq = req) {
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          try {
+            if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+          } catch (e) {
+            reject(e);
+          }
+          _rpcPromiseMap.delete(id);
+        }, timeout);
+        if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+      }
+      _rpcPromiseMap.set(id, {
+        resolve,
+        reject,
+        timeoutId,
+        method
+      });
+      await send(newReq);
+      return promise;
+    }
+    try {
+      if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+      else await handler();
+    } catch (e) {
+      if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+      return;
+    } finally {
+      clearTimeout(timeoutId);
+      _rpcPromiseMap.delete(id);
+    }
+    return promise;
+  }
+  const builtinMethods = {
+    $call: (method, ...args) => _call(method, args, false),
+    $callOptional: (method, ...args) => _call(method, args, false, true),
+    $callEvent: (method, ...args) => _call(method, args, true),
+    $callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+    $rejectPendingCalls,
+    get $closed() {
+      return $closed;
+    },
+    get $meta() {
+      return options.meta;
+    },
+    $close,
+    $functions
+  };
+  if (proxify) rpc = new Proxy({}, { get(_, method) {
+    if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+    if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+    const sendEvent = (...args) => _call(method, args, true);
+    if (eventNames.includes(method)) {
+      sendEvent.asEvent = sendEvent;
+      return sendEvent;
+    }
+    const sendCall = (...args) => _call(method, args, false);
+    sendCall.asEvent = sendEvent;
+    return sendCall;
+  } });
+  else rpc = builtinMethods;
+  function $close(customError) {
+    $closed = true;
+    _rpcPromiseMap.forEach(({ reject, method }) => {
+      const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+      if (customError) {
+        customError.cause ??= error;
+        return reject(customError);
+      }
+      reject(error);
+    });
+    _rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  function $rejectPendingCalls(handler) {
+    const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+      if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+      return handler({
+        method,
+        reject
+      });
+    });
+    _rpcPromiseMap.clear();
+    return handlerResults;
+  }
+  async function onMessage(data, ...extra) {
+    let msg;
+    try {
+      msg = deserialize(data);
+    } catch (e) {
+      if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+      return;
+    }
+    if (msg.t === TYPE_REQUEST) {
+      const { m: method, a: args, o: optional } = msg;
+      let result, error;
+      let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+      if (optional) fn ||= () => void 0;
+      if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+      else try {
+        result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+      } catch (e) {
+        error = e;
+      }
+      if (msg.i) {
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+        }
+        if (!error) try {
+          await post(serialize({
+            t: TYPE_RESPONSE,
+            i: msg.i,
+            r: result
+          }), ...extra);
+          return;
+        } catch (e) {
+          error = e;
+          if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+        }
+        try {
+          await post(serialize({
+            t: TYPE_RESPONSE,
+            i: msg.i,
+            e: error
+          }), ...extra);
+        } catch (e) {
+          if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+        }
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = _rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error) promise.reject(error);
+        else promise.resolve(result);
+      }
+      _rpcPromiseMap.delete(ack);
+    }
+  }
+  _promiseInit = on(onMessage);
+  return rpc;
+}
+
+export { createBirpc as c };