@ucdjs/cli 0.1.0 → 0.1.2

package/dist/{cli-utils-Cy8lSvR2.js → cli-utils-DyOk9RI0.js}

@@ -4,14 +4,14 @@ import yargs from "yargs-parser";
 
 //#region package.json
 var name = "@ucdjs/cli";
-var version = "0.1.0";
+var version = "0.1.2";
 var type = "module";
 var author = {
 	"name": "Lucas Nørgård",
 	"email": "lucasnrgaard@gmail.com",
 	"url": "https://luxass.dev"
 };
-var packageManager = "pnpm@10.8.0";
+var packageManager = "pnpm@10.10.0";
 var license = "MIT";
 var homepage = "https://github.com/ucdjs/ucd";
 var repository = {
@@ -30,6 +30,8 @@ var scripts = {
 };
 var dependencies = {
 	"@luxass/unicode-utils": "catalog:prod",
+	"@luxass/utils": "catalog:prod",
+	"@ucdjs/schema-gen": "workspace:*",
 	"farver": "catalog:prod",
 	"yargs-parser": "catalog:prod"
 };
@@ -63,7 +65,7 @@ var package_default = {
 
 //#endregion
 //#region src/cli-utils.ts
-const SUPPORTED_COMMANDS = new Set(["generate"]);
+const SUPPORTED_COMMANDS = new Set(["generate", "codegen"]);
 /**
 * Resolves the CLI command based on the provided arguments.
 *
@@ -129,7 +131,7 @@ async function runCommand(cmd, flags) {
 				headline: "A CLI for working with the Unicode Character Database (UCD).",
 				usage: "[command] [...flags]",
 				tables: {
-					"Commands": [["generate", "Generate UCD data files."]],
+					"Commands": [["generate", "Generate UCD data files."], ["codegen", "Generate TypeScript code from UCD data."]],
 					"Global Flags": [
 						["--force", "Force the operation to run, even if it's not needed."],
 						["--version", "Show the version number and exit."],
@@ -142,7 +144,7 @@ async function runCommand(cmd, flags) {
 			console.log(`  ${bgGreen(black(` ucd `))} ${green(`v${package_default.version ?? "x.y.z"}`)}`);
 			break;
 		case "generate": {
-			const { runGenerate } = await import("./generate-Hwn8O33w.js");
+			const { runGenerate } = await import("./generate-Z7bYnm_v.js");
 			const versions = flags._.slice(3);
 			await runGenerate({
 				versions,
@@ -150,14 +152,23 @@ async function runCommand(cmd, flags) {
 			});
 			break;
 		}
+		case "codegen": {
+			const { runCodegenRoot } = await import("./root-BT7DL0Ms.js");
+			const subcommand = flags._[3]?.toString() ?? "";
+			await runCodegenRoot(subcommand, { flags });
+			break;
+		}
 		default: throw new Error(`Error running ${cmd} -- no command found.`);
 	}
 }
 function parseFlags(args) {
 	return yargs(args, {
 		configuration: { "parse-positional-numbers": false },
-		string: ["output-dir"],
-		default: { "output-dir": "./data" }
+		string: [
+			"output-dir",
+			"input-dir",
+			"output-file"
+		]
 	});
 }
 async function runCLI(args) {

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { runCLI } from "./cli-utils-Cy8lSvR2.js";
+import { runCLI } from "./cli-utils-DyOk9RI0.js";
 import process from "node:process";
 
 //#region src/cli.ts

package/dist/fields-BqikCPbE.js

@@ -0,0 +1,98 @@
+import { printHelp } from "./cli-utils-DyOk9RI0.js";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { RawDataFile } from "@luxass/unicode-utils/data-files";
+import { toKebabCase } from "@luxass/utils";
+import { generateFields } from "@ucdjs/schema-gen";
+
+//#region src/cmd/codegen/fields.ts
+async function runFieldCodegen({ inputPath, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Generate Unicode Data Files",
+			commandName: "ucd codegen fields",
+			usage: "<input> [...flags]",
+			tables: { Flags: [
+				["--openai-key (-k)", "The OpenAI API key to use. (can also be set using OPENAI_API_KEY env var)"],
+				["--output-dir", "Specify the output directory for generated files (defaults to .codegen)"],
+				["--bundle <filename>", "Combine all generated files into a single file, if no filename is provided, the default is index.ts"],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	const openaiKey = flags.openaiKey || process.env.OPENAI_API_KEY;
+	if (!openaiKey) {
+		console.error("No OpenAI API key provided. Please provide an OpenAI API key.");
+		return;
+	}
+	if (inputPath == null) {
+		console.error("No input path provided. Please provide an input path.");
+		return;
+	}
+	const resolvedInputPath = path.resolve(inputPath);
+	if (!existsSync(resolvedInputPath)) {
+		console.error(`invalid input path: ${inputPath}. Please provide a valid input path.`);
+		return;
+	}
+	const outputDir = flags.outputDir || process.cwd();
+	await mkdir(outputDir, { recursive: true });
+	const shouldBundle = typeof flags.bundle === "string" || flags.bundle === true;
+	const bundleFileName = typeof flags.bundle === "string" ? flags.bundle : "index.ts";
+	const isDirectory = (await stat(resolvedInputPath)).isDirectory();
+	const files = [];
+	if (isDirectory) {
+		const dir = await readdir(resolvedInputPath, {
+			withFileTypes: true,
+			recursive: true
+		});
+		for (const file of dir) if (file.isFile()) {
+			if (!file.name.endsWith(".txt")) continue;
+			files.push(path.join(file.parentPath, file.name));
+		}
+	} else files.push(resolvedInputPath);
+	const promises = files.map(async (filePath) => {
+		const content = await readFile(filePath, "utf-8");
+		const datafile = new RawDataFile(content);
+		if (datafile.heading == null) {
+			console.error(`heading for file ${filePath} is null. Skipping file.`);
+			return null;
+		}
+		const code = await generateFields({
+			datafile,
+			apiKey: openaiKey
+		});
+		if (code == null) {
+			console.error(`Error generating fields for file: ${filePath}`);
+			return null;
+		}
+		if (!shouldBundle) {
+			const fileName = toKebabCase(path.basename(filePath).replace(/\.txt$/, "")).toLowerCase();
+			await writeFile(path.join(outputDir, `${fileName}.ts`), code, "utf-8");
+		}
+		return {
+			code,
+			fileName: filePath.replace(`${process.cwd()}/`, "")
+		};
+	});
+	const generatedCode = await Promise.all(promises);
+	if (!shouldBundle) {
+		console.log(`Generated fields for ${files.length} files in ${outputDir}`);
+		return;
+	}
+	let bundledCode = `// This file is generated by ucd codegen. Do not edit this file directly.\n\n`;
+	for (const { fileName, code } of generatedCode.filter((obj) => obj != null)) {
+		bundledCode += `//#region ${fileName}\n`;
+		bundledCode += code;
+		bundledCode += `\n//#endregion\n`;
+		bundledCode += "\n\n";
+	}
+	let bundlePath = path.resolve(path.join(outputDir, bundleFileName));
+	if (path.extname(bundleFileName) === "") bundlePath = path.join(outputDir, `${bundleFileName}.ts`);
+	await writeFile(bundlePath, bundledCode, "utf-8");
+	console.log(`Generated bundled fields in ${bundlePath}`);
+}
+
+//#endregion
+export { runFieldCodegen };

package/dist/{generate-Hwn8O33w.js → generate-Z7bYnm_v.js}

@@ -1,12 +1,13 @@
-import { printHelp } from "./cli-utils-Cy8lSvR2.js";
+import { printHelp } from "./cli-utils-DyOk9RI0.js";
 import { green, yellow } from "farver/fast";
 import { mkdir, writeFile } from "node:fs/promises";
 import path, { dirname, join } from "node:path";
+import { UNICODE_VERSIONS_WITH_UCD } from "@luxass/unicode-utils";
 
 //#region src/cmd/generate.ts
 const BASE_URL = "https://unicode-proxy.ucdjs.dev/proxy";
 async function runGenerate({ versions: providedVersions, flags }) {
-	if (flags?.help || flags?.h || providedVersions.length === 0) {
+	if (flags?.help || flags?.h) {
 		printHelp({
 			headline: "Generate Unicode Data Files",
 			commandName: "ucd generate",
@@ -15,6 +16,16 @@ async function runGenerate({ versions: providedVersions, flags }) {
 		});
 		return;
 	}
+	if (providedVersions.length === 0) {
+		console.error("No versions provided. Please provide at least one version.");
+		return;
+	}
+	if (providedVersions[0] === "all") providedVersions = UNICODE_VERSIONS_WITH_UCD.map((v) => v.version);
+	const invalidVersions = providedVersions.filter((version) => !UNICODE_VERSIONS_WITH_UCD.find((v) => v.version === version));
+	if (invalidVersions.length > 0) {
+		console.error(`Invalid version(s) provided: ${invalidVersions.join(", ")}. Please provide valid Unicode versions.`);
+		return;
+	}
 	const outputDir = flags.outputDir ?? path.join(process.cwd(), "data");
 	await mkdir(outputDir, { recursive: true });
 	async function processDirectory(entry, basePath, version, baseOutputDir, downloadedFiles) {

package/dist/root-BT7DL0Ms.js

@@ -0,0 +1,33 @@
+import { printHelp } from "./cli-utils-DyOk9RI0.js";
+
+//#region src/cmd/codegen/root.ts
+const CODEGEN_SUBCOMMANDS = ["fields"];
+function isValidSubcommand(subcommand) {
+	return CODEGEN_SUBCOMMANDS.includes(subcommand);
+}
+async function runCodegenRoot(subcommand, { flags }) {
+	if (!isValidSubcommand(subcommand) || !isValidSubcommand(subcommand) && (flags?.help || flags?.h)) {
+		printHelp({
+			commandName: "ucd codegen",
+			usage: "[command] [...flags]",
+			tables: {
+				Commands: [["fields", "Generate fields for the Unicode data files."]],
+				Flags: [["--help (-h)", "See all available flags."]]
+			}
+		});
+		return;
+	}
+	if (subcommand === "fields") {
+		const { runFieldCodegen } = await import("./fields-BqikCPbE.js");
+		const inputPath = flags._.slice(4)?.toString() ?? "";
+		await runFieldCodegen({
+			inputPath,
+			flags
+		});
+		return;
+	}
+	throw new Error(`Invalid subcommand: ${subcommand}`);
+}
+
+//#endregion
+export { runCodegenRoot };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -25,17 +25,19 @@
     "dist"
   ],
   "dependencies": {
-    "@luxass/unicode-utils": "^0.0.0",
+    "@luxass/unicode-utils": "^0.4.1",
+    "@luxass/utils": "^1.4.0",
     "farver": "^0.4.2",
-    "yargs-parser": "^21.1.1"
+    "yargs-parser": "^21.1.1",
+    "@ucdjs/schema-gen": "0.1.0"
   },
   "devDependencies": {
     "@luxass/eslint-config": "^4.18.1",
     "@types/yargs-parser": "^21.0.3",
-    "eslint": "^9.23.0",
+    "eslint": "^9.25.1",
     "publint": "^0.3.12",
     "tsdown": "v0.9.3",
-    "typescript": "^5.8.2",
+    "typescript": "^5.8.3",
     "vitest-testdirs": "^3.0.1"
   },
   "publishConfig": {