@codenhub/styles 0.7.0 → 0.8.0

package/dist/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+// src/cli/run.ts
+const BIN = "codenhub-styles";
+const MIN_NODE_MAJOR = 24;
+const TAILWIND_PACKAGES = ["@tailwindcss/cli", "tailwindcss"];
+const TW_AESTHETIC_EXPORT = /^\.\/tw\/aesthetics\/([^/]+)$/;
+const USAGE = `Usage: ${BIN} build --content <glob> [--content <glob> ...] --output <file> [options]
+
+Builds a StyleKit stylesheet holding only the classes your templates use.
+
+Options:
+  -c, --content <glob>   Files to scan for class names, relative to the current
+                         directory. Repeat for more globs. Quote each glob.
+  -o, --output <file>    Stylesheet to write. Parent directories are created.
+  --aesthetic <name>     Add an aesthetic: {names}. Repeatable.
+  --no-minify            Write readable CSS instead of minified CSS.
+  --help                 Show this help.
+  --version              Show the version.`;
+const POLYFILLS_NONE = 0;
+async function run(argv, io) {
+	try {
+		const parsed = parseCommandLine(argv);
+		if (parsed === "help") io.stdout(USAGE.replace("{names}", readAestheticNames().join(", ")));
+		else if (parsed === "version") io.stdout(readManifest().version);
+		else {
+			const output = await build(parsed, io);
+			const { size } = await fs.stat(output);
+			io.stdout(`${output} ${size} bytes`);
+		}
+		return 0;
+	} catch (error) {
+		io.stderr(`${BIN}: ${error instanceof Error ? error.message : String(error)}`);
+		return 1;
+	}
+}
+function parseCommandLine(argv) {
+	const { values, positionals } = parseFlags(argv);
+	if (values.help) return "help";
+	if (values.version) return "version";
+	const [command, ...extra] = positionals;
+	if (command === void 0) throw new Error(`missing command; run "${BIN} build --content <glob> --output <file>".`);
+	if (command !== "build") throw new Error(`unknown command "${command}"; the only command is "build".`);
+	if (extra.length > 0) throw new Error(`unexpected argument "${extra[0]}"; quote each --content glob so the shell does not expand it, as in --content "app/views/**/*.erb".`);
+	if (!values.content?.length) throw new Error(`missing --content; name the templates to scan, as in --content "app/views/**/*.erb".`);
+	const output = values.output?.trim();
+	if (!output) throw new Error("missing --output; name the stylesheet to write, as in --output public/app.css.");
+	return {
+		contentGlobs: values.content,
+		output,
+		aesthetics: [...new Set(values.aesthetic ?? [])],
+		shouldMinify: !values["no-minify"]
+	};
+}
+function parseFlags(argv) {
+	try {
+		return parseArgs({
+			args: [...argv],
+			allowPositionals: true,
+			options: {
+				content: {
+					type: "string",
+					short: "c",
+					multiple: true
+				},
+				output: {
+					type: "string",
+					short: "o"
+				},
+				aesthetic: {
+					type: "string",
+					multiple: true
+				},
+				"no-minify": { type: "boolean" },
+				help: { type: "boolean" },
+				version: { type: "boolean" }
+			}
+		});
+	} catch (error) {
+		const flag = error instanceof Error ? /'([^']+)'/.exec(error.message)?.[1] : void 0;
+		if (flag === void 0) throw error;
+		const code = error.code;
+		throw new Error(code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" ? `unknown option "${flag}"; run "${BIN} --help" for the options.` : `option "${/--[\w-]+/.exec(flag)?.[0] ?? flag}" is missing its value or does not take one; run "${BIN} --help" for the options.`);
+	}
+}
+async function build(options, io) {
+	assertNodeVersion(io.nodeVersion);
+	const tailwind = loadTailwind(io);
+	const validAesthetics = readAestheticNames();
+	const unknown = options.aesthetics.find((name) => !validAesthetics.includes(name));
+	if (unknown !== void 0) throw new Error(`unknown aesthetic "${unknown}"; choose from ${validAesthetics.join(", ")}.`);
+	await Promise.all(options.contentGlobs.map((pattern) => assertMatches(pattern, io.cwd)));
+	const output = path.resolve(io.cwd, options.output);
+	const input = [
+		`@import ${cssString(resolveExport("./tw"))};`,
+		...options.aesthetics.map((name) => `@import ${cssString(resolveExport(`./tw/aesthetics/${name}`))};`),
+		...options.contentGlobs.map((pattern) => `@source ${cssString(toCssPath(path.resolve(io.cwd, pattern)))};`)
+	].join("\n");
+	try {
+		const css = await compileStylesheet(tailwind, input, io.cwd, options.shouldMinify);
+		await fs.mkdir(path.dirname(output), { recursive: true });
+		await fs.writeFile(output, css);
+	} catch (error) {
+		throw new Error(`Tailwind failed to build the stylesheet: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return output;
+}
+async function assertMatches(pattern, cwd) {
+	for await (const entry of fs.glob(pattern, {
+		cwd,
+		withFileTypes: true
+	})) if (entry.isFile()) return;
+	throw new Error(`--content "${pattern}" matches no file in ${cwd}; check the path, or run from the project root.`);
+}
+async function compileStylesheet(tailwind, input, cwd, shouldMinify) {
+	const compiler = await tailwind.compile(input, {
+		base: cwd,
+		from: path.join(cwd, "codenhub-styles.css"),
+		polyfills: POLYFILLS_NONE,
+		onDependency() {}
+	});
+	const scanner = new tailwind.Scanner({ sources: compiler.sources });
+	const css = compiler.build(scanner.scan());
+	return shouldMinify ? tailwind.optimize(css, { minify: true }).code : css;
+}
+function readAestheticNames() {
+	const { exports } = readManifest();
+	return Object.keys(exports).map((subpath) => TW_AESTHETIC_EXPORT.exec(subpath)?.[1]).filter((name) => name !== void 0).sort();
+}
+/** Returns the nearest folder at or above `from` that holds a `package.json`. */
+function findPackageRoot(from) {
+	for (let dir = from;; dir = path.dirname(dir)) {
+		if (existsSync(path.join(dir, "package.json"))) return dir;
+		if (path.dirname(dir) === dir) throw new Error(`cannot find the package.json of @codenhub/styles above ${from}.`);
+	}
+}
+const packageRoot = findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+function readManifest() {
+	return JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+}
+function resolveExport(subpath) {
+	const target = readManifest().exports[subpath].import;
+	return pathToFileURL(path.resolve(packageRoot, target)).href;
+}
+function assertNodeVersion(nodeVersion) {
+	if (Number.parseInt(nodeVersion, 10) < MIN_NODE_MAJOR) throw new Error(`this command needs Node.js ${MIN_NODE_MAJOR} or newer; this is Node.js ${nodeVersion}.`);
+}
+/** Loads Tailwind's compiler from where `@tailwindcss/cli` is installed, after checking both Tailwind packages are. */
+function loadTailwind(io) {
+	const manifests = TAILWIND_PACKAGES.map((name) => resolveManifest(name, io));
+	const missing = TAILWIND_PACKAGES.filter((_, index) => manifests[index] === void 0);
+	if (missing.length > 0) throw new Error(`this command needs ${missing.join(" and ")}, which ${missing.length > 1 ? "are" : "is"} not installed. Run: npm install --save-dev ${missing.join(" ")}`);
+	const requireFromCli = createRequire(manifests[0]);
+	const { compile, optimize } = requireFromCli("@tailwindcss/node");
+	const { Scanner } = requireFromCli("@tailwindcss/oxide");
+	return {
+		compile,
+		optimize,
+		Scanner
+	};
+}
+function resolveManifest(name, io) {
+	try {
+		return io.resolvePackage(`${name}/package.json`);
+	} catch (error) {
+		if (error.code === "MODULE_NOT_FOUND") return;
+		throw error;
+	}
+}
+function toCssPath(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function cssString(value) {
+	return `"${value.replace(/["\\]/g, "\\$&")}"`;
+}
+// src/cli/cli.ts
+process.exitCode = await run(process.argv.slice(2), {
+	cwd: process.cwd(),
+	nodeVersion: process.versions.node,
+	resolvePackage: createRequire(import.meta.url).resolve,
+	stdout: (line) => process.stdout.write(`${line}\n`),
+	stderr: (line) => process.stderr.write(`${line}\n`)
+});
+export {};