@devdogsuga/backstage 0.1.0

package/dist/commands-Bk7IbhPD.js

@@ -0,0 +1,220 @@
+import { p as isNonInteractive } from "./telemetry-Bjoz29Hl.js";
+import { i as qrParseOptions, n as QR_FLAGS, o as isDryRun, t as QR_EXTRA_FLAGS } from "./options-BTjOf5KP.js";
+import { a as explainError, o as unwrap, t as UsageError } from "./ui-CdKo8mLw.js";
+import { t as DONE } from "./dispatch-D048O65I.js";
+import { dirname, extname, relative, resolve } from "node:path";
+import { log, text } from "@clack/prompts";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import { homedir } from "node:os";
+import { renderQr } from "@devdogsuga/brand/render";
+import { QR_LOGO_PRESETS, qrRequestSchema, qrVersionIssue, resolveQrRequest } from "@devdogsuga/brand/qr";
+//#region src/qr/commands.ts
+/**
+* `pnpm backstage qr <text> [options]`
+*
+* The QR generator from `/console/qr`, on the command line, with every option
+* the page has: content, size and margin, ink colour, background, a two-colour
+* gradient, module shape, error-correction level, QR version, a centre logo
+* (a brand preset, or an image file with size, padding and crop) and every
+* output format at once. The page stays, deprecated; new options are
+* CLI-only.
+*
+* Both read one request schema from `@devdogsuga/brand/qr`, so what a request
+* means cannot differ between them. The scannability warning is the page's
+* too: `qrVersionIssue`.
+*
+* No credentials, no checkout.
+*/
+const MIME = {
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif",
+	".avif": "image/avif"
+};
+function expandHome(path) {
+	return path === "~" || path.startsWith("~/") ? resolve(homedir(), path.slice(2)) : path;
+}
+function number(flag, value) {
+	if (value === void 0) return void 0;
+	const parsed = Number(value);
+	if (value.trim() === "" || Number.isNaN(parsed)) throw new UsageError(`--${flag} takes a number, not "${value}".`);
+	return parsed;
+}
+/** An empty flag value counts as absent. */
+function nonBlank(value) {
+	return value === void 0 || value === "" ? void 0 : value;
+}
+function list(value) {
+	return value.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function parseCrop(value) {
+	const parts = list(value).map(Number);
+	const [x, y, width, height] = parts;
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0) || !width || !height) throw new UsageError(`--${QR_EXTRA_FLAGS.logoCrop.name} takes four whole numbers: x,y,width,height (source pixels).`);
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+/**
+* Reads the command line into a request the shared schema accepts.
+*
+* Throws {@link UsageError} for anything it can name: a bad number, a logo
+* that is neither a preset nor a file, or a value the schema refuses (reported
+* against the flag that carries it).
+*/
+/** The parsed flags by name: all string-valued, bar `--dry-run`. */
+function flagValues(values) {
+	return values;
+}
+function readArgs(argv) {
+	try {
+		return parseArgs({
+			args: [...argv],
+			options: {
+				...qrParseOptions(),
+				"dry-run": { type: "boolean" }
+			},
+			allowPositionals: true
+		});
+	} catch (err) {
+		throw new UsageError(err instanceof Error ? err.message : String(err));
+	}
+}
+/** The text on the command line, if it carries any. */
+function textGiven(argv) {
+	const { values, positionals } = readArgs(argv);
+	return positionals[0] ?? flagValues(values)[QR_FLAGS.text.name];
+}
+function parseQrArgs(argv, cwd, asked) {
+	const parsed = readArgs(argv);
+	const { positionals } = parsed;
+	const values = flagValues(parsed.values);
+	const get = (flag) => values[flag.name];
+	if (positionals.length > 1) throw new UsageError(`Give the text to encode as one argument (quote it); got ${positionals.length}.`);
+	const text = positionals[0] ?? get(QR_FLAGS.text) ?? asked;
+	const gradient = get(QR_FLAGS.gradient);
+	const gradientColours = gradient === void 0 ? void 0 : list(gradient);
+	if (gradientColours && gradientColours.length !== 2) throw new UsageError("--gradient takes two colours: from,to.");
+	const logo = get(QR_FLAGS.logo);
+	const isPreset = logo !== void 0 && logo in QR_LOGO_PRESETS;
+	const logoPath = logo !== void 0 && !isPreset && logo !== "none" ? resolve(cwd, expandHome(logo)) : void 0;
+	const cropValue = get(QR_EXTRA_FLAGS.logoCrop);
+	if (cropValue !== void 0 && !logoPath) throw new UsageError("--logo-crop crops a logo file; pass --logo <file>.");
+	const background = get(QR_FLAGS.background);
+	const formats = get(QR_FLAGS.formats);
+	const request = {
+		text: text ?? "",
+		theme: get(QR_FLAGS.theme),
+		size: number("size", get(QR_FLAGS.size)),
+		margin: number("margin", get(QR_FLAGS.margin)),
+		color: get(QR_FLAGS.color),
+		background: background === "transparent" || background === "none" ? "" : background,
+		gradient: gradientColours,
+		shape: get(QR_FLAGS.shape),
+		logo: logoPath ? "none" : logo,
+		logoSize: number("logo-size", get(QR_FLAGS.logoSize)),
+		logoPadding: number("logo-padding", get(QR_FLAGS.logoPadding)),
+		errorLevel: get(QR_FLAGS.errorLevel),
+		version: number("qr-version", get(QR_FLAGS.version)),
+		formats: formats === void 0 ? void 0 : list(formats)
+	};
+	const defined = Object.fromEntries(Object.entries(request).filter(([, value]) => value !== void 0));
+	const checked = qrRequestSchema.safeParse(defined);
+	if (!checked.success) {
+		const names = new Map(Object.entries(QR_FLAGS).map(([key, flag]) => [key, flag.name]));
+		throw new UsageError(checked.error.issues.map((issue) => {
+			const key = String(issue.path[0] ?? "");
+			const flag = names.get(key);
+			return key === "text" || !flag ? issue.message : `--${flag}: ${issue.message}`;
+		}).join("\n"));
+	}
+	return {
+		request: defined,
+		logoFile: logoPath ? {
+			path: logoPath,
+			crop: cropValue === void 0 ? void 0 : parseCrop(cropValue)
+		} : void 0,
+		out: resolve(cwd, expandHome(nonBlank(get(QR_EXTRA_FLAGS.out)) ?? ".")),
+		name: nonBlank(get(QR_EXTRA_FLAGS.name)) ?? "qr",
+		dryRun: parsed.values["dry-run"] === true || isDryRun()
+	};
+}
+/**
+* The logo file as a data URI, cropped first when asked.
+*
+* Cropped with sharp rather than by the renderer's own `logoCrop`, because the
+* schema takes that from a preset only; the result is the same square of
+* pixels either way.
+*/
+async function logoHref({ path, crop }) {
+	const mime = MIME[extname(path).toLowerCase()];
+	if (!mime) throw new UsageError(`Cannot use ${path} as a logo: expected ${Object.keys(MIME).join(", ")}.`);
+	let bytes;
+	try {
+		bytes = await readFile(path);
+	} catch {
+		throw new UsageError(`--logo is neither a preset (${Object.keys(QR_LOGO_PRESETS).join(", ")}, none) nor a readable file: ${path}`);
+	}
+	if (!crop) return `data:${mime};base64,${bytes.toString("base64")}`;
+	const { default: sharp } = await import("sharp");
+	const image = sharp(bytes);
+	const { width = 0, height = 0 } = await image.metadata();
+	if (crop.x + crop.width > width || crop.y + crop.height > height) throw new UsageError(`--logo-crop ${crop.x},${crop.y},${crop.width},${crop.height} runs outside the ${width}x${height} logo.`);
+	return `data:image/png;base64,${(await image.extract({
+		left: crop.x,
+		top: crop.y,
+		width: crop.width,
+		height: crop.height
+	}).png().toBuffer()).toString("base64")}`;
+}
+async function runQr(argv, deps = {}) {
+	const cwd = deps.cwd ?? process.cwd();
+	try {
+		await qr(argv, cwd);
+	} catch (err) {
+		explainError("Could not make that code.", err, ["pnpm backstage qr https://devdogsuga.org --format svg,png --out ~/codes", "pnpm backstage qr https://devdogsuga.org --logo ./mark.png --logo-crop 0,24,265,265"]);
+		process.exitCode = 1;
+	}
+}
+async function qr(argv, cwd) {
+	let asked;
+	if (textGiven(argv) === void 0 && !isNonInteractive()) asked = unwrap(await text({
+		message: "What should the code say?",
+		placeholder: "https://devdogsuga.org",
+		validate: (value) => value?.trim() ? void 0 : "Enter something."
+	}));
+	const invocation = parseQrArgs(argv, cwd, asked);
+	const { text: text$1, options, logo, formats } = resolveQrRequest(invocation.request);
+	const href = invocation.logoFile ? await logoHref(invocation.logoFile) : void 0;
+	const issue = qrVersionIssue(text$1, options.errorLevel, options.version, options.logoSize, options.logoPadding, logo !== "none" || href !== void 0);
+	if (issue) log.warn(`Might not scan: ${issue}.`);
+	const display = (file) => {
+		const rel = relative(cwd, file);
+		return rel.startsWith("..") ? file : rel;
+	};
+	const target = (format) => resolve(invocation.out, `${invocation.name}.${format}`);
+	if (invocation.dryRun) {
+		log.info(`Would write ${formats.map((format) => display(target(format))).join(", ")}`);
+		return;
+	}
+	const files = await renderQr(invocation.request, href);
+	for (const file of files) {
+		const path = target(file.format);
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, file.data);
+		log.success(`${display(path)}  (${Math.round(file.data.length / 1024)} KB)`);
+	}
+}
+const handleQr = async (rest) => {
+	await runQr(rest);
+	return process.exitCode ? null : DONE;
+};
+//#endregion
+export { handleQr };