@effected/cli 0.10.0 → 0.12.0

package/ui/testing/fakeStreams.js

@@ -0,0 +1,79 @@
+import { PassThrough, Writable } from "node:stream";
+
+//#region src/ui/testing/fakeStreams.ts
+const capture = (columns, rows, both, onWrite) => {
+	const chunks = [];
+	const stream = new Writable({ write(chunk, _encoding, callback) {
+		const text = chunk.toString();
+		chunks.push(text);
+		both.push(text);
+		onWrite?.(text);
+		callback();
+	} });
+	Object.assign(stream, {
+		isTTY: true,
+		columns,
+		rows
+	});
+	return {
+		stream,
+		text: () => chunks.join("")
+	};
+};
+/**
+* Make in-memory stdin, stdout and stderr that satisfy Ink's stream contract: TTYs with a size, a recorded
+* `setRawMode`, `ref` and `unref`, and captured writes.
+*
+* @remarks
+* The third file licensed to touch Node, testing only: Ink's stream
+* contract is Node's, so the fakes are `node:stream` streams rather than a hand-rolled emitter that would have to
+* reproduce `readable`, `read()`, `setEncoding` and the write-callback barrier Ink waits on at unmount.
+*
+* @internal
+*/
+const makeFakeStreams = (options = {}) => {
+	const columns = options.columns ?? 80;
+	const rows = options.rows ?? 24;
+	const rawModes = [];
+	const stdin = new PassThrough();
+	Object.assign(stdin, {
+		isTTY: true,
+		setRawMode: (mode) => {
+			rawModes.push(mode);
+			return stdin;
+		},
+		ref: () => stdin,
+		unref: () => stdin
+	});
+	const both = [];
+	const stdout = capture(columns, rows, both, options.onStdoutWrite);
+	const stderr = capture(columns, rows, both);
+	return {
+		streams: {
+			stdin,
+			stdout: stdout.stream,
+			stderr: stderr.stream
+		},
+		rawModes,
+		stdout: stdout.text,
+		stderr: stderr.text,
+		written: () => both.join(""),
+		input: (data) => {
+			stdin.write(data);
+		},
+		resize: (nextColumns, nextRows) => {
+			Object.assign(stdout.stream, {
+				columns: nextColumns,
+				rows: nextRows
+			});
+			Object.assign(stderr.stream, {
+				columns: nextColumns,
+				rows: nextRows
+			});
+			stdout.stream.emit("resize");
+		}
+	};
+};
+
+//#endregion
+export { makeFakeStreams };

package/ui/testing/terminalModel.js

@@ -0,0 +1,59 @@
+//#region src/ui/testing/terminalModel.ts
+const ESC = String.fromCharCode(27);
+/**
+* A small terminal model for the production render path: what a terminal shows after `written`, as its non-empty
+* lines.
+*
+* @remarks
+* It applies printable text, line feeds, the erase and cursor moves Ink's log-update writes (erase line, cursor up,
+* cursor to column one), and the clears of Ink's clear-terminal frame: `ESC[2J` blanks the visible screen, `ESC[3J`
+* drops the scrollback above it, `ESC[H` homes the cursor to the screen's top left. The visible screen is the last
+* `rows` lines; with `rows` unknown, the whole buffer counts as the screen, so a clear takes everything. Every other
+* escape is ignored. It does not wrap a line wider than the terminal. Shared by `CliUiTest.live`'s transcript and the
+* kit's own production-path tests.
+*
+* @param written - every byte written to the terminal
+* @param rows - the terminal's height, which decides how much of the buffer a clear takes as the screen
+*
+* @internal
+*/
+const screenAfter = (written, rows) => {
+	const lines = [""];
+	let row = 0;
+	let column = 0;
+	const screenTop = () => rows === void 0 ? 0 : Math.max(0, lines.length - rows);
+	const sequence = new RegExp(`${ESC}\\[([0-9;?]*)([A-Za-z])|${ESC}\\][^\\u0007]*\\u0007|([\\s\\S])`, "g");
+	for (const match of written.matchAll(sequence)) {
+		const [, params, command, character] = match;
+		if (character !== void 0) {
+			if (character === "\n") {
+				row++;
+				column = 0;
+				while (lines.length <= row) lines.push("");
+			} else if (character === "\r") column = 0;
+			else if (character >= " ") {
+				const line = lines[row] ?? "";
+				lines[row] = `${line.slice(0, column).padEnd(column)}${character}${line.slice(column + 1)}`;
+				column++;
+			}
+		} else if (command === "K") lines[row] = "";
+		else if (command === "A") row = Math.max(0, row - Number(params === "" ? 1 : params));
+		else if (command === "G") column = 0;
+		else if (command === "J" && params === "2") for (let index = screenTop(); index < lines.length; index++) lines[index] = "";
+		else if (command === "J" && params === "3") {
+			const top = screenTop();
+			lines.splice(0, top);
+			row = Math.max(0, row - top);
+			if (lines.length === 0) lines.push("");
+		} else if (command === "H") {
+			const [line, col] = params === "" ? [1, 1] : params.split(";").map((part) => Number(part === "" ? 1 : part));
+			row = screenTop() + (line ?? 1) - 1;
+			column = (col ?? 1) - 1;
+			while (lines.length <= row) lines.push("");
+		}
+	}
+	return lines.map((line) => line.trimEnd()).filter((line) => line !== "");
+};
+
+//#endregion
+export { screenAfter };

package/ui-testing-serializer.d.ts

@@ -0,0 +1,14 @@
+//#region src/ui-testing-serializer.d.ts
+/**
+ * `CliUiTest.serializer`: it claims a string carrying escapes or token markup and prints it as token markup with each
+ * line's trailing spaces trimmed. See `CliUiTest.serializer` for what it claims.
+ *
+ * @public
+ */
+declare const serializer: {
+  readonly test: (value: unknown) => boolean;
+  readonly serialize: (value: unknown) => string;
+};
+//#endregion
+export { serializer as default };
+//# sourceMappingURL=ui-testing-serializer.d.ts.map

package/ui-testing-serializer.js

@@ -0,0 +1,33 @@
+import { CliUiTest } from "./ui/testing/CliUiTest.js";
+
+//#region src/ui-testing-serializer.ts
+/**
+* `CliUiTest.serializer` as a module's default export, for Vitest's `snapshotSerializers` config.
+*
+* @remarks
+* Vitest's `test.snapshotSerializers` takes module paths whose default export is a serializer, so registering this
+* one needs no `expect.addSnapshotSerializer` call and no shim file of your own:
+*
+* ```ts
+* // vitest.config.ts
+* import { defineConfig } from "vitest/config"
+*
+* export default defineConfig({
+*   test: { snapshotSerializers: ["@effected/cli/ui/testing/serializer"] },
+* })
+* ```
+*
+* A separate entrypoint so a program's runtime import graph never loads test code.
+*
+* @packageDocumentation
+*/
+/**
+* `CliUiTest.serializer`: it claims a string carrying escapes or token markup and prints it as token markup with each
+* line's trailing spaces trimmed. See `CliUiTest.serializer` for what it claims.
+*
+* @public
+*/
+const serializer = CliUiTest.serializer;
+
+//#endregion
+export { serializer as default };