@jterrazz/test 16.1.1 → 17.0.0

package/dist/shared-in-place.js

@@ -0,0 +1,172 @@
+import { i as safeRealpath } from "./shared-resolve.js";
+import { t as isRecord } from "./shared-json-shape.js";
+import { n as refusal } from "./shared-refusal.js";
+import { r as closingOf, t as argumentSpans } from "./shared-source-scan.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region src/chain/paths/caller.ts
+const TEST_FILE = /\.test\.[cm]?[jt]s$/u;
+const FRAME_LOCATION = /^at (?:.*? \((?<wrapped>[^()]+)\)|(?:async )?(?<bare>[^()\s]+))$/u;
+const POSITION = /^(?<file>.+):(?<line>\d+):(?<column>\d+)$/u;
+function stackFrames(stack) {
+	const frames = [];
+	for (const text of stack.split("\n")) {
+		const groups = FRAME_LOCATION.exec(text.trim())?.groups;
+		const position = POSITION.exec(groups?.wrapped ?? groups?.bare ?? "")?.groups;
+		if (position?.file === void 0 || position.file.startsWith("node:")) continue;
+		const file = position.file.startsWith("file:") ? fileURLToPath(position.file) : position.file;
+		frames.push({
+			column: Number(position.column),
+			file,
+			line: Number(position.line)
+		});
+	}
+	return frames;
+}
+function callerFrames() {
+	const { stack } = /* @__PURE__ */ new Error("@jterrazz/test: reading the call site");
+	return stackFrames(stack ?? "").filter(({ file }) => file !== import.meta.filename);
+}
+const SOURCE_LOCATION = join("chain", "paths");
+const FRAMEWORK_DIR = safeRealpath(import.meta.dirname);
+/** From a build, `dist/` plus the `src/` its source maps point back to: a mapped frame is still the framework's. */
+function frameworkTreesOf(frameworkDir) {
+	return frameworkDir.endsWith(`${sep}${SOURCE_LOCATION}`) ? [resolve(frameworkDir, "../..")] : [frameworkDir, resolve(frameworkDir, "..", "src")];
+}
+const FRAMEWORK_TREES = frameworkTreesOf(FRAMEWORK_DIR);
+function isStrictlyInside(directory, path) {
+	const rest = relative(directory, path);
+	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
+}
+/** By identity, never by substring: a consumer's own `src/chain/` is not this package's. */
+function isFrameworkFrame(filePath, frameworkTrees = FRAMEWORK_TREES) {
+	if (TEST_FILE.test(filePath)) return false;
+	const real = safeRealpath(filePath);
+	return frameworkTrees.some((tree) => isStrictlyInside(safeRealpath(tree), real));
+}
+/** Must be called before the first `await`: async resumption drops the caller's frames. */
+function getCallerDir() {
+	const caller = callerFrames().find(({ file }) => !file.includes("node_modules") && !isFrameworkFrame(file));
+	return caller === void 0 ? process.cwd() : dirname(caller.file);
+}
+//#endregion
+//#region src/expectations/in-place/formatter.ts
+const FORMATTER = join("node_modules", ".bin", "oxfmt");
+function formatterOf(file) {
+	for (let directory = dirname(file);; directory = dirname(directory)) {
+		const binary = join(directory, FORMATTER);
+		if (existsSync(binary)) return binary;
+		if (dirname(directory) === directory) return;
+	}
+}
+function formatRewritten(files) {
+	for (const file of files) {
+		const binary = formatterOf(file);
+		if (binary !== void 0) {
+			const project = dirname(dirname(dirname(binary)));
+			spawnSync(binary, [file], {
+				cwd: project,
+				stdio: "ignore"
+			});
+		}
+	}
+}
+//#endregion
+//#region src/expectations/in-place/in-place.ts
+const TO_MATCH = /\btoMatch\s*\(/gu;
+const LITERAL = /^(?:['"`{[]|-?\d|(?:null|true|false|undefined)$)/u;
+function callSiteOf(stack) {
+	return stackFrames(stack).find(({ file }) => !file.includes(`${sep}node_modules${sep}`) && !isFrameworkFrame(file));
+}
+function lineStartOf(source, line) {
+	let offset = 0;
+	for (let current = 1; current < line; current += 1) offset = source.indexOf("\n", offset) + 1;
+	return offset;
+}
+/** The call a frame points at, by its name or its parenthesis, among the calls of its line; its value's span, trimmed. */
+function locateArgument(source, site) {
+	const lineStart = lineStartOf(source, site.line);
+	const position = lineStart + site.column - 1;
+	TO_MATCH.lastIndex = lineStart;
+	for (const found of source.matchAll(TO_MATCH)) {
+		if (found.index + 7 < position) continue;
+		const open = found.index + found[0].length - 1;
+		const [span = {
+			end: open + 1,
+			start: open + 1
+		}] = argumentSpans(source, open + 1, closingOf(source, open));
+		const line = source.slice(source.lastIndexOf("\n", found.index) + 1);
+		return {
+			...span,
+			indent: line.slice(0, line.length - line.trimStart().length)
+		};
+	}
+}
+const LEDGERS = /* @__PURE__ */ new Map();
+const isPending = (value) => isRecord(value) && typeof value.file === "string" && typeof value.source === "string";
+let pendingFolder = null;
+/** Read at each write: the folder is the project's, and one worker may serve several. */
+function deferRewritesTo(folder) {
+	pendingFolder = folder;
+}
+function save(file, source, folder) {
+	if (folder === void 0) {
+		writeFileSync(file, source);
+		return;
+	}
+	mkdirSync(folder, { recursive: true });
+	const name = createHash("sha256").update(file).digest("hex");
+	const pending = {
+		file,
+		source
+	};
+	writeFileSync(join(folder, `${name}.json`), JSON.stringify(pending));
+}
+function writePendingRewrites(folder) {
+	if (!existsSync(folder)) return;
+	const written = [];
+	for (const name of readdirSync(folder).filter((entry) => entry.endsWith(".json"))) {
+		const pending = JSON.parse(readFileSync(join(folder, name), "utf8"));
+		if (isPending(pending)) {
+			writeFileSync(pending.file, pending.source);
+			written.push(pending.file);
+		}
+	}
+	rmSync(folder, { recursive: true });
+	formatRewritten(written);
+}
+function writeInPlace(site, render, folder = pendingFolder?.()) {
+	const ledger = LEDGERS.get(site.file) ?? {
+		edits: /* @__PURE__ */ new Map(),
+		original: readFileSync(site.file, "utf8")
+	};
+	LEDGERS.set(site.file, ledger);
+	const span = locateArgument(ledger.original, site);
+	if (span === void 0) throw new Error(refusal({
+		fix: "call `.toMatch(` on the expect() written at that line, not through an alias",
+		found: `update mode: no toMatch( stands at ${site.file}:${site.line}:${site.column}, so the value in place cannot be written`,
+		read: "docs/reference/tokens.md#a-value-written-in-place-is-rewritten-in-the-test",
+		why: "A value written in place is rewritten where its `toMatch(` stands."
+	}));
+	const written = ledger.original.slice(span.start, span.end);
+	if (written !== "" && !LITERAL.test(written)) throw new Error(refusal({
+		fix: "write the expectation as a literal in `toMatch(`, or record it by hand: a table's rows are recorded one by one, never from the last row",
+		found: `update mode: toMatch(${written}) at ${site.file}:${site.line}:${site.column} holds a name or a call, not a literal`,
+		read: "docs/reference/tokens.md#a-value-written-in-place-is-rewritten-in-the-test",
+		why: "Update mode rewrites the literal a `toMatch(` holds; a variable stands for values the rewrite would replace by the last one it saw."
+	}));
+	ledger.edits.set(span.start, {
+		end: span.end,
+		text: render(span.indent)
+	});
+	let source = ledger.original;
+	for (const [start, edit] of [...ledger.edits].toSorted(([a], [b]) => b - a)) source = source.slice(0, start) + edit.text + source.slice(edit.end);
+	save(site.file, source, folder);
+}
+//#endregion
+export { callerFrames as a, writePendingRewrites as i, deferRewritesTo as n, getCallerDir as o, writeInPlace as r, callSiteOf as t };
+
+//# sourceMappingURL=shared-in-place.js.map