reg-cli 0.18.16 → 0.19.0-rc0

package/dist/index.d.cts

@@ -0,0 +1,52 @@
+import EventEmitter from "node:events";
+
+//#region src/index.d.ts
+declare const dir: () => string;
+declare const run: (argv: string[]) => EventEmitter;
+type CompareInput = {
+  actualDir: string;
+  expectedDir: string;
+  diffDir: string;
+  report?: string;
+  junitReport?: string;
+  json?: string; /** Re-render HTML from an existing reg.json (classic `-F/--from`). */
+  from?: string;
+  /** "none" (default) | "client" — enable the report's browser-side
+   *  second-pass detector (classic `-X/--additionalDetection`). */
+  additionalDetection?: 'none' | 'client';
+  update?: boolean;
+  extendedErrors?: boolean;
+  /** Classic reg-cli's `-I/--ignoreChange` — governs the CLI's exit code
+   *  only. Accepted and silently dropped by `compare()` for drop-in
+   *  compat with reg-suit's `processor.ts:107`. */
+  ignoreChange?: boolean;
+  urlPrefix?: string;
+  matchingThreshold?: number;
+  threshold?: number;
+  thresholdRate?: number;
+  thresholdPixel?: number;
+  concurrency?: number;
+  enableAntialias?: boolean;
+  enableClientAdditionalDetection?: boolean;
+  /** Classic reg-cli's CLI-side x-img-diff extra detection pass. The
+   *  Wasm pipeline's diff already includes the equivalent classification,
+   *  so this is a no-op but accepted for drop-in compat with reg-suit's
+   *  `processor.ts:114`. */
+  enableCliAdditionalDetection?: boolean;
+};
+type CompareOutput = {
+  failedItems: string[];
+  newItems: string[];
+  deletedItems: string[];
+  passedItems: string[];
+  expectedItems: string[];
+  actualItems: string[];
+  diffItems: string[];
+  actualDir: string;
+  expectedDir: string;
+  diffDir: string;
+};
+declare const compare: (input: CompareInput) => EventEmitter;
+declare function writeRegJson(path: string, data: CompareOutput): Promise<void>;
+//#endregion
+export { CompareInput, CompareOutput, compare, dir, run, writeRegJson };

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+import EventEmitter from "node:events";
+
+//#region src/index.d.ts
+declare const dir: () => string;
+declare const run: (argv: string[]) => EventEmitter;
+type CompareInput = {
+  actualDir: string;
+  expectedDir: string;
+  diffDir: string;
+  report?: string;
+  junitReport?: string;
+  json?: string; /** Re-render HTML from an existing reg.json (classic `-F/--from`). */
+  from?: string;
+  /** "none" (default) | "client" — enable the report's browser-side
+   *  second-pass detector (classic `-X/--additionalDetection`). */
+  additionalDetection?: 'none' | 'client';
+  update?: boolean;
+  extendedErrors?: boolean;
+  /** Classic reg-cli's `-I/--ignoreChange` — governs the CLI's exit code
+   *  only. Accepted and silently dropped by `compare()` for drop-in
+   *  compat with reg-suit's `processor.ts:107`. */
+  ignoreChange?: boolean;
+  urlPrefix?: string;
+  matchingThreshold?: number;
+  threshold?: number;
+  thresholdRate?: number;
+  thresholdPixel?: number;
+  concurrency?: number;
+  enableAntialias?: boolean;
+  enableClientAdditionalDetection?: boolean;
+  /** Classic reg-cli's CLI-side x-img-diff extra detection pass. The
+   *  Wasm pipeline's diff already includes the equivalent classification,
+   *  so this is a no-op but accepted for drop-in compat with reg-suit's
+   *  `processor.ts:114`. */
+  enableCliAdditionalDetection?: boolean;
+};
+type CompareOutput = {
+  failedItems: string[];
+  newItems: string[];
+  deletedItems: string[];
+  passedItems: string[];
+  expectedItems: string[];
+  actualItems: string[];
+  diffItems: string[];
+  actualDir: string;
+  expectedDir: string;
+  diffDir: string;
+};
+declare const compare: (input: CompareInput) => EventEmitter;
+declare function writeRegJson(path: string, data: CompareOutput): Promise<void>;
+//#endregion
+export { CompareInput, CompareOutput, compare, dir, run, writeRegJson };

package/dist/index.mjs

@@ -0,0 +1,206 @@
+import { a as processWorkerSpans, d as resolveExtention, i as processRustTraceData, l as isCJS, n as initTracing, o as shutdownTracing, r as isTracingEnabled, s as startRootSpan, t as endRootSpan } from "./tracing-7HO8hac9.mjs";
+import EventEmitter from "node:events";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join } from "node:path";
+//#region src/index.ts
+const dir = () => {
+	return isCJS ? __dirname : dirname(fileURLToPath(import.meta.url));
+};
+const mainSpans = [];
+const recordMainSpan = (name, start_ms, attributes) => {
+	if (!isTracingEnabled()) return;
+	mainSpans.push({
+		name,
+		start_ms,
+		end_ms: Date.now(),
+		attributes,
+		worker_label: "main"
+	});
+};
+const run = (argv) => {
+	const emitter = new EventEmitter();
+	setImmediate(() => emitter.emit("start"));
+	runInternal(argv, emitter);
+	return emitter;
+};
+const runInternal = async (argv, emitter) => {
+	const run_start_ms = Date.now();
+	const t_init = Date.now();
+	if (isTracingEnabled()) {
+		await initTracing();
+		recordMainSpan("main.init_tracing", t_init);
+	}
+	const traceContext = isTracingEnabled() ? startRootSpan("reg-cli") : null;
+	const t_new_entry = Date.now();
+	const worker = new Worker(join(dir(), `./entry.${resolveExtention()}`), { workerData: { argv } });
+	recordMainSpan("main.new_entry_worker", t_new_entry);
+	let nextTid = 1;
+	const workers = [worker];
+	const threadWorkerSpans = [];
+	const spawn = (startArg, threadId, memory) => {
+		const t_new_worker = Date.now();
+		const worker = new Worker(join(dir(), `./worker.${resolveExtention()}`), { workerData: { argv } });
+		const tid = nextTid++;
+		recordMainSpan("main.new_thread_worker", t_new_worker, { tid });
+		workers.push(worker);
+		worker.on("message", (msg) => {
+			const { cmd } = msg;
+			if (cmd === "loaded") {
+				if (typeof worker.unref === "function") worker.unref();
+			} else if (cmd === "thread-spawn") spawn(msg.startArg, msg.threadId, msg.memory);
+			else if (cmd === "worker-spans") {
+				if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
+			} else if (cmd === "compare-event") {
+				if (msg.event) emitter.emit("compare", msg.event);
+			}
+		});
+		worker.on("error", (e) => {
+			workers.forEach((w) => w.terminate());
+			emitter.emit("error", e);
+		});
+		if (threadId) {
+			Atomics.store(threadId, 0, tid);
+			Atomics.notify(threadId, 0);
+		}
+		worker.postMessage({
+			startArg,
+			tid,
+			memory
+		});
+		return tid;
+	};
+	worker.on("message", async ({ cmd, startArg, threadId, memory, data, traceData, workerSpans, event }) => {
+		if (cmd === "compare-event") {
+			if (event) emitter.emit("compare", event);
+			return;
+		}
+		if (cmd === "complete") {
+			const t_post_complete = Date.now();
+			if (isTracingEnabled()) {
+				if (Array.isArray(workerSpans)) processWorkerSpans(workerSpans, "entry");
+				if (threadWorkerSpans.length) processWorkerSpans(threadWorkerSpans, "thread");
+				if (traceData) processRustTraceData(traceData);
+				recordMainSpan("main.process_trace_and_spans", t_post_complete);
+				mainSpans.push({
+					name: "main.run_total",
+					start_ms: run_start_ms,
+					end_ms: Date.now(),
+					worker_label: "main"
+				});
+				processWorkerSpans(mainSpans, "main");
+				endRootSpan(true);
+				await shutdownTracing();
+			}
+			workers.forEach((w) => w.terminate());
+			emitter.emit("complete", data);
+			return;
+		}
+		if (cmd === "loaded") {
+			if (typeof worker.unref === "function") worker.unref();
+			return;
+		}
+		if (cmd === "thread-spawn") spawn(startArg, threadId, memory);
+	});
+	worker.on("error", (err) => {
+		if (traceContext) endRootSpan(false);
+		workers.forEach((w) => w.terminate());
+		emitter.emit("error", err);
+	});
+};
+/** Flags that `compare()` handles itself in JS; they are NOT forwarded to
+*  the Wasm binary. `extendedErrors` WAS here but now also feeds the
+*  Rust-side junit generator, so it's forwarded below via KEY_REMAP.
+*
+*  `ignoreChange` and `enableCliAdditionalDetection` are stripped because
+*  reg-suit unconditionally passes them (see
+*  reg-viz/reg-suit `packages/reg-suit-core/src/processor.ts` `compare({…})`)
+*  and the Rust clap layer doesn't recognise them — forwarding would abort
+*  the binary with "unexpected argument". Semantically both are no-ops at
+*  the library-event layer:
+*    - `ignoreChange` only governs classic reg-cli's process exit code;
+*      the EventEmitter surface never needed it.
+*    - `enableCliAdditionalDetection` was classic's flag for running an
+*      extra CLI-side x-img-diff pass; the Wasm port's diff pipeline
+*      already produces the final pass/fail classification, so toggling
+*      it changes nothing. (The *client*-side variant is handled via
+*      `additionalDetection: 'client'` / the legacy
+*      `enableClientAdditionalDetection: true` alias further down.) */
+const CLI_ONLY_KEYS = new Set([
+	"update",
+	"ignoreChange",
+	"enableCliAdditionalDetection"
+]);
+/** Library option names that must be forwarded to the Wasm binary under a
+*  different flag name (Rust uses `--junit`, callers pass `junitReport`). */
+const KEY_REMAP = { junitReport: "junit" };
+const compare = (input) => {
+	const { actualDir, expectedDir, diffDir, threshold, update, ...rest } = input;
+	if (rest.diffFormat == null) rest.diffFormat = "png";
+	if (rest.json == null) rest.json = "./reg.json";
+	if (threshold != null && rest.thresholdRate == null) rest.thresholdRate = threshold;
+	const restAny = rest;
+	if (restAny.enableClientAdditionalDetection && restAny.additionalDetection == null) restAny.additionalDetection = "client";
+	delete restAny.enableClientAdditionalDetection;
+	for (const k of CLI_ONLY_KEYS) delete rest[k];
+	const inner = run([
+		"--",
+		actualDir,
+		expectedDir,
+		diffDir,
+		...Object.entries(rest).flatMap(([k, v]) => {
+			if (v == null || v === "") return [];
+			return [`--${KEY_REMAP[k] ?? k}`, String(v)];
+		})
+	]);
+	const outer = new EventEmitter();
+	inner.on("start", () => outer.emit("start"));
+	inner.on("compare", (p) => outer.emit("compare", p));
+	inner.on("error", (e) => outer.emit("error", e));
+	inner.on("complete", async (data) => {
+		try {
+			if (restAny.additionalDetection === "client" && typeof input.report === "string") {
+				const { writeXimgdiffAssets } = await import("./ximgdiff-DzkRRnkW.mjs").then((n) => n.n);
+				await writeXimgdiffAssets({
+					reportPath: input.report,
+					urlPrefix: typeof input.urlPrefix === "string" ? input.urlPrefix : "",
+					distDir: dir()
+				});
+			}
+			if (update) {
+				await updateExpected(actualDir, expectedDir, {
+					newItems: data.newItems ?? [],
+					failedItems: data.failedItems ?? [],
+					deletedItems: data.deletedItems ?? []
+				});
+				outer.emit("update");
+			}
+		} catch (e) {
+			outer.emit("error", e);
+			return;
+		}
+		outer.emit("complete", data);
+	});
+	return outer;
+};
+async function writeRegJson(path, data) {
+	const { writeFile, mkdir } = await import("node:fs/promises");
+	const { dirname } = await import("node:path");
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+async function updateExpected(actualDir, expectedDir, items) {
+	const { mkdir, copyFile, rm } = await import("node:fs/promises");
+	const { dirname, join } = await import("node:path");
+	const toRemove = [...items.deletedItems, ...items.failedItems];
+	for (const img of toRemove) await rm(join(expectedDir, img), { force: true });
+	const toCopy = [...items.newItems, ...items.failedItems];
+	for (const img of toCopy) {
+		const src = join(actualDir, img);
+		const dst = join(expectedDir, img);
+		await mkdir(dirname(dst), { recursive: true });
+		await copyFile(src, dst);
+	}
+}
+//#endregion
+export { compare, dir, run, writeRegJson };

package/dist/progress-BB7D-xke.mjs

@@ -0,0 +1,28 @@
+//#region src/progress.ts
+const MARKER = "__REG_CLI_EVT__	";
+/**
+* Build a WASI `printErr` hook that forwards progress events to `onEvent`
+* and everything else to `fallback` (defaults to `console.error`).
+*
+* `@tybys/wasm-util`'s `StandardOutput.write` already buffers until a
+* newline and invokes the callback with one stripped line per call (see
+* `node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js` line
+* ~749-779). So we can treat each invocation as a single complete line.
+*/
+const createPrintErrHook = (onEvent, fallback = (s) => console.error(s)) => {
+	return (line) => {
+		if (line.startsWith(MARKER)) {
+			const json = line.slice(16);
+			try {
+				const ev = JSON.parse(json);
+				if (ev && typeof ev.type === "string" && typeof ev.path === "string") {
+					onEvent(ev);
+					return;
+				}
+			} catch {}
+		}
+		fallback(line);
+	};
+};
+//#endregion
+export { createPrintErrHook as t };

package/dist/progress-UOiKHaTY.cjs

@@ -0,0 +1,33 @@
+//#region src/progress.ts
+const MARKER = "__REG_CLI_EVT__	";
+/**
+* Build a WASI `printErr` hook that forwards progress events to `onEvent`
+* and everything else to `fallback` (defaults to `console.error`).
+*
+* `@tybys/wasm-util`'s `StandardOutput.write` already buffers until a
+* newline and invokes the callback with one stripped line per call (see
+* `node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js` line
+* ~749-779). So we can treat each invocation as a single complete line.
+*/
+const createPrintErrHook = (onEvent, fallback = (s) => console.error(s)) => {
+	return (line) => {
+		if (line.startsWith(MARKER)) {
+			const json = line.slice(16);
+			try {
+				const ev = JSON.parse(json);
+				if (ev && typeof ev.type === "string" && typeof ev.path === "string") {
+					onEvent(ev);
+					return;
+				}
+			} catch {}
+		}
+		fallback(line);
+	};
+};
+//#endregion
+Object.defineProperty(exports, "createPrintErrHook", {
+	enumerable: true,
+	get: function() {
+		return createPrintErrHook;
+	}
+});

package/dist/rolldown-runtime-D_mwlA32.cjs

@@ -0,0 +1,43 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});