@ucdjs/cli 0.1.2 → 0.2.0

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

@@ -4,14 +4,14 @@ import yargs from "yargs-parser";
 
 //#region package.json
 var name = "@ucdjs/cli";
-var version = "0.1.2";
+var version = "0.2.0";
 var type = "module";
 var author = {
 	"name": "Lucas Nørgård",
 	"email": "lucasnrgaard@gmail.com",
 	"url": "https://luxass.dev"
 };
-var packageManager = "pnpm@10.10.0";
+var packageManager = "pnpm@10.11.0";
 var license = "MIT";
 var homepage = "https://github.com/ucdjs/ucd";
 var repository = {
@@ -33,10 +33,13 @@ var dependencies = {
 	"@luxass/utils": "catalog:prod",
 	"@ucdjs/schema-gen": "workspace:*",
 	"farver": "catalog:prod",
+	"micromatch": "catalog:prod",
+	"p-limit": "catalog:prod",
 	"yargs-parser": "catalog:prod"
 };
 var devDependencies = {
 	"@luxass/eslint-config": "catalog:dev",
+	"@types/micromatch": "catalog:dev",
 	"@types/yargs-parser": "catalog:dev",
 	"eslint": "catalog:dev",
 	"publint": "catalog:dev",
@@ -65,7 +68,7 @@ var package_default = {
 
 //#endregion
 //#region src/cli-utils.ts
-const SUPPORTED_COMMANDS = new Set(["generate", "codegen"]);
+const SUPPORTED_COMMANDS = new Set(["codegen", "download"]);
 /**
 * Resolves the CLI command based on the provided arguments.
 *
@@ -131,7 +134,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."], ["codegen", "Generate TypeScript code from UCD data."]],
+					"Commands": [["download", "Download Unicode 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."],
@@ -143,27 +146,33 @@ async function runCommand(cmd, flags) {
 		case "version":
 			console.log(`  ${bgGreen(black(` ucd `))} ${green(`v${package_default.version ?? "x.y.z"}`)}`);
 			break;
-		case "generate": {
-			const { runGenerate } = await import("./generate-Z7bYnm_v.js");
+		case "codegen": {
+			const { runCodegenRoot } = await import("./root-CK5_bOyd.js");
+			const subcommand = flags._[3]?.toString() ?? "";
+			await runCodegenRoot(subcommand, { flags });
+			break;
+		}
+		case "download": {
+			const { runDownload } = await import("./download-x471YfwO.js");
 			const versions = flags._.slice(3);
-			await runGenerate({
+			await runDownload({
 				versions,
 				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 },
+		default: { force: false },
+		boolean: [
+			"force",
+			"help",
+			"h"
+		],
 		string: [
 			"output-dir",
 			"input-dir",

package/dist/cli.js

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

package/dist/download-x471YfwO.js

@@ -0,0 +1,196 @@
+import { printHelp } from "./cli-utils-CSnE3roj.js";
+import { gray, green, red, yellow } from "farver/fast";
+import { mkdir, writeFile } from "node:fs/promises";
+import path, { dirname } from "node:path";
+import { UNICODE_VERSION_METADATA, hasUCDPath, mapToUCDPathVersion } from "@luxass/unicode-utils";
+import micromatch from "micromatch";
+
+//#region src/cmd/download.ts
+const CONCURRENCY_LIMIT = 3;
+const API_URL = "https://unicode-api.luxass.dev/api/v1";
+const UNICODE_PROXY_URL = "https://unicode-proxy.ucdjs.dev";
+async function runDownload({ versions: providedVersions, flags }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Download Unicode Data Files",
+			commandName: "ucd download",
+			usage: "<...versions> [...flags]",
+			tables: { Flags: [
+				["--output-dir", "Specify the output directory."],
+				["--exclude", "Exclude files matching glob patterns (e.g., '*Test*,ReadMe.txt,*.draft')."],
+				["--exclude-test", "Exclude all test files (ending with Test.txt)."],
+				["--force", "Force the download, even if the files already exist."],
+				["--debug", "Enable debug output."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	if (providedVersions.length === 0) {
+		console.error(red("No versions provided. Please provide at least one version."));
+		return;
+	}
+	let versions = [];
+	if (providedVersions[0] === "all") versions = UNICODE_VERSION_METADATA.map((v) => {
+		const mappedVersion = mapToUCDPathVersion(v.version);
+		return {
+			version: v.version,
+			mappedVersion: mappedVersion === v.version ? void 0 : mappedVersion
+		};
+	});
+	else versions = providedVersions.map((v) => {
+		const mappedVersion = mapToUCDPathVersion(v);
+		return {
+			version: v,
+			mappedVersion: mappedVersion === v ? void 0 : mappedVersion
+		};
+	});
+	const invalidVersions = versions.filter(({ version }) => !UNICODE_VERSION_METADATA.find((v) => v.version === version));
+	if (invalidVersions.length > 0) {
+		console.error(red(`Invalid version(s): ${invalidVersions.map((v) => v.version).join(", ")}. Please provide valid Unicode versions.`));
+		return;
+	}
+	const outputDir = flags.outputDir ?? path.join(process.cwd(), "data");
+	await mkdir(outputDir, { recursive: true });
+	const excludePatterns = flags.exclude?.split(",").map((p) => p.trim()).filter(Boolean) || [];
+	if (flags.excludeTest) excludePatterns.push("**/*Test*");
+	function getAllFilePaths(entries) {
+		const filePaths = [];
+		function collectPaths(entryList, currentPath = "") {
+			for (const entry of entryList) {
+				const fullPath = currentPath ? `${currentPath}/${entry.path}` : entry.path;
+				if (!entry.children) filePaths.push(fullPath);
+				else if (entry.children.length > 0) collectPaths(entry.children, fullPath);
+			}
+		}
+		collectPaths(entries);
+		return filePaths;
+	}
+	function filterEntriesRecursive(entries) {
+		if (excludePatterns.length === 0) return entries;
+		const allPaths = getAllFilePaths(entries);
+		const patterns = ["**", ...excludePatterns.map((pattern) => `!${pattern}`)];
+		const matchedPaths = new Set(micromatch(allPaths, patterns, {
+			dot: true,
+			nocase: true,
+			debug: flags.debug
+		}));
+		function filterEntries(entryList, prefix = "") {
+			const result = [];
+			for (const entry of entryList) {
+				const fullPath = prefix ? `${prefix}/${entry.path}` : entry.path;
+				if (!entry.children) {
+					if (matchedPaths.has(fullPath)) result.push(entry);
+				} else {
+					const filteredChildren = filterEntries(entry.children, fullPath);
+					if (filteredChildren.length > 0) result.push({
+						...entry,
+						children: filteredChildren
+					});
+				}
+			}
+			return result;
+		}
+		return filterEntries(entries);
+	}
+	async function processFileEntries(entries, basePath, versionOutputDir, downloadedFiles, currentDirPath = "", errors) {
+		const dirPromises = [];
+		const filePromises = [];
+		for (const entry of entries) {
+			const entryOutputPath = currentDirPath ? path.join(currentDirPath, entry.path) : entry.path;
+			const outputPath = path.join(versionOutputDir, entryOutputPath);
+			if (entry.children) dirPromises.push((async () => {
+				await mkdir(outputPath, { recursive: true });
+				await processFileEntries(entry.children || [], `${basePath}/${entry.path}`, versionOutputDir, downloadedFiles, entryOutputPath, errors);
+			})());
+			else filePromises.push((async () => {
+				try {
+					await mkdir(dirname(outputPath), { recursive: true });
+					const url = `${UNICODE_PROXY_URL}${basePath}/${entry.path}`;
+					const response = await fetch(url);
+					if (!response.ok) {
+						errors.push(`Failed to fetch ${entry.path}: ${response.status} ${response.statusText}`);
+						return;
+					}
+					const content = await response.text();
+					await writeFile(outputPath, content);
+					downloadedFiles.push(outputPath);
+				} catch (err) {
+					errors.push(`Error downloading ${entry.path}: ${err.message}`);
+				}
+			})());
+		}
+		await Promise.all([...dirPromises, ...filePromises]);
+	}
+	async function processVersion(version) {
+		console.info(`Starting download for Unicode ${green(version.version)}${version.mappedVersion ? gray(` (${green(version.mappedVersion)})`) : ""}`);
+		const downloadedFiles = [];
+		const errors = [];
+		const versionOutputDir = path.join(outputDir, `v${version.version}`);
+		await mkdir(versionOutputDir, { recursive: true });
+		try {
+			const filesResponse = await fetch(`${API_URL}/unicode-files/${version.version}`);
+			if (!filesResponse.ok) {
+				console.error(red(`Failed to fetch file list for version ${version.version}: ${filesResponse.status} ${filesResponse.statusText}`));
+				return {
+					version: version.version,
+					downloadedFiles,
+					errors: [`Failed to fetch file list: ${filesResponse.statusText}`]
+				};
+			}
+			const fileEntries = await filesResponse.json();
+			if (!Array.isArray(fileEntries)) {
+				console.error(red(`Invalid response format for version ${version.version}`));
+				return {
+					version: version.version,
+					downloadedFiles,
+					errors: ["Invalid response format"]
+				};
+			}
+			const filteredEntries = filterEntriesRecursive(fileEntries);
+			const correctVersion = version.mappedVersion ?? version.version;
+			const basePath = `/${correctVersion}${hasUCDPath(correctVersion) ? "/ucd" : ""}`;
+			await processFileEntries(filteredEntries, basePath, versionOutputDir, downloadedFiles, "", errors);
+			if (downloadedFiles.length === 0 && errors.length === 0) console.warn(yellow(`No files were downloaded for Unicode ${version.version}`));
+			else if (downloadedFiles.length > 0) {
+				console.info(green(`✓ Downloaded ${downloadedFiles.length} files for Unicode ${version.version}`));
+				if (flags.debug) downloadedFiles.forEach((file) => {
+					const relativePath = path.relative(versionOutputDir, file);
+					console.info(green(`  - ${relativePath}`));
+				});
+			}
+			if (errors.length > 0) {
+				console.warn(yellow(`${errors.length} errors occurred during download of Unicode ${version.version}`));
+				if (flags.debug) errors.forEach((error) => console.error(red(`  - ${error}`)));
+			}
+		} catch (err) {
+			const errorMessage = `Error processing version ${version.version}: ${err.message}`;
+			errors.push(errorMessage);
+			console.error(red(errorMessage));
+		}
+		return {
+			version: version.version,
+			downloadedFiles,
+			errors
+		};
+	}
+	const results = [];
+	const versionGroups = [];
+	for (let i = 0; i < versions.length; i += CONCURRENCY_LIMIT) versionGroups.push(versions.slice(i, i + CONCURRENCY_LIMIT));
+	for (const versionGroup of versionGroups) {
+		const batchResults = await Promise.all(versionGroup.map(processVersion));
+		results.push(...batchResults);
+	}
+	const totalFiles = results.reduce((sum, r) => sum + r.downloadedFiles.length, 0);
+	const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+	const successfulVersions = results.filter((r) => r.downloadedFiles.length > 0).length;
+	console.info(`\n${"=".repeat(50)}`);
+	console.info("Download Summary:");
+	console.info(green(`✓ ${successfulVersions}/${results.length} versions processed successfully`));
+	console.info(green(`✓ ${totalFiles} total files downloaded`));
+	if (totalErrors > 0) console.warn(yellow(`⚠ ${totalErrors} total errors encountered`));
+	console.info("=".repeat(50));
+}
+
+//#endregion
+export { runDownload };

package/dist/fields-BCwNC6Tk.js

@@ -0,0 +1,122 @@
+import { printHelp } from "./cli-utils-CSnE3roj.js";
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { runSchemagen } from "@ucdjs/schema-gen";
+
+//#region src/cmd/codegen/fields.ts
+function flattenVersion(version) {
+	const parts = version.split(".");
+	while (parts.length > 1 && parts[parts.length - 1] === "0") parts.pop();
+	return parts.join(".");
+}
+async function scanFiles(inputPath) {
+	const resolvedInputPath = path.resolve(inputPath);
+	const isDirectory = (await stat(resolvedInputPath)).isDirectory();
+	const filesWithVersion = [];
+	if (!isDirectory) {
+		const parentDir = path.dirname(resolvedInputPath);
+		const versionMatch = parentDir.match(/v(\d+\.\d+\.\d+)/);
+		const version = versionMatch ? flattenVersion(versionMatch[1]) : "unknown";
+		filesWithVersion.push({
+			filePath: resolvedInputPath,
+			version
+		});
+	} else {
+		const dir = await readdir(resolvedInputPath, {
+			withFileTypes: true,
+			recursive: true
+		});
+		for (const file of dir) {
+			if (!file.isFile() || !file.name.endsWith(".txt") || file.name.endsWith("Test.txt")) continue;
+			const filePath = path.join(file.parentPath, file.name);
+			const versionMatch = filePath.match(/v(\d+\.\d+\.\d+)/);
+			const version = versionMatch ? flattenVersion(versionMatch[1]) : "unknown";
+			filesWithVersion.push({
+				filePath,
+				version
+			});
+		}
+	}
+	return filesWithVersion;
+}
+async function writeBundledFile(version, results, bundleTemplate, outputDir) {
+	let bundledCode = `// This file is generated by ucd codegen. Do not edit this file directly.\n`;
+	bundledCode += `// Unicode Version: ${version}\n\n`;
+	for (const result of results) {
+		const relativePath = path.relative(process.cwd(), result.fileName);
+		bundledCode += `\n// #region ${relativePath}\n`;
+		bundledCode += result.code;
+		bundledCode += `\n// #endregion\n`;
+	}
+	const bundleFileName = bundleTemplate.replace("{version}", version);
+	let bundlePath;
+	if (path.isAbsolute(bundleFileName) || bundleFileName.startsWith("./") || bundleFileName.startsWith("../")) bundlePath = path.resolve(bundleFileName);
+	else if (outputDir) bundlePath = path.resolve(path.join(outputDir, bundleFileName));
+	else bundlePath = path.resolve(bundleFileName);
+	if (!bundlePath.endsWith(".ts")) bundlePath += ".ts";
+	await mkdir(path.dirname(bundlePath), { recursive: true });
+	await writeFile(bundlePath, bundledCode, "utf-8");
+	console.log(`Generated bundled fields for Unicode ${version} in ${bundlePath}`);
+}
+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 generated files into a single file per version. Use {version} placeholder for version-specific naming"],
+				["--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 shouldBundle = typeof flags.bundle === "string" || flags.bundle === true;
+	const bundleTemplate = typeof flags.bundle === "string" ? flags.bundle : "index.ts";
+	let outputDir = flags.outputDir;
+	if (!outputDir) if (shouldBundle && (path.isAbsolute(bundleTemplate) || bundleTemplate.startsWith("./") || bundleTemplate.startsWith("../"))) outputDir = path.dirname(bundleTemplate);
+	else outputDir = path.join(path.dirname(resolvedInputPath), ".codegen");
+	if (outputDir) await mkdir(outputDir, { recursive: true });
+	const filesWithVersion = await scanFiles(inputPath);
+	console.log(`Found ${filesWithVersion.length} files to process.`);
+	const results = await runSchemagen({
+		files: filesWithVersion,
+		openaiKey
+	});
+	const writePromises = [];
+	if (!shouldBundle) {
+		writePromises.push(...results.map((result) => writeFile(path.join(outputDir, `${result.fileName}.ts`), result.code, "utf-8")));
+		await Promise.all(writePromises);
+		console.log(`Generated fields for ${results.length} files in ${outputDir}`);
+		return;
+	}
+	const resultsByVersion = new Map();
+	for (const result of results) {
+		const versionResults = resultsByVersion.get(result.version) ?? [];
+		versionResults.push(result);
+		resultsByVersion.set(result.version, versionResults);
+	}
+	const bundlePromises = Array.from(resultsByVersion.entries()).map(([version, versionResults]) => writeBundledFile(version, versionResults, bundleTemplate, outputDir));
+	await Promise.all(bundlePromises);
+}
+
+//#endregion
+export { runFieldCodegen };

package/dist/{root-BT7DL0Ms.js → root-CK5_bOyd.js}

@@ -1,4 +1,4 @@
-import { printHelp } from "./cli-utils-DyOk9RI0.js";
+import { printHelp } from "./cli-utils-CSnE3roj.js";
 
 //#region src/cmd/codegen/root.ts
 const CODEGEN_SUBCOMMANDS = ["fields"];
@@ -18,7 +18,7 @@ async function runCodegenRoot(subcommand, { flags }) {
 		return;
 	}
 	if (subcommand === "fields") {
-		const { runFieldCodegen } = await import("./fields-BqikCPbE.js");
+		const { runFieldCodegen } = await import("./fields-BCwNC6Tk.js");
 		const inputPath = flags._.slice(4)?.toString() ?? "";
 		await runFieldCodegen({
 			inputPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -25,20 +25,23 @@
     "dist"
   ],
   "dependencies": {
-    "@luxass/unicode-utils": "^0.4.1",
-    "@luxass/utils": "^1.4.0",
+    "@luxass/unicode-utils": "^0.9.0",
+    "@luxass/utils": "^2.2.1",
     "farver": "^0.4.2",
+    "micromatch": "^4.0.8",
+    "p-limit": "^6.2.0",
     "yargs-parser": "^21.1.1",
-    "@ucdjs/schema-gen": "0.1.0"
+    "@ucdjs/schema-gen": "0.2.1"
   },
   "devDependencies": {
     "@luxass/eslint-config": "^4.18.1",
+    "@types/micromatch": "^4.0.9",
     "@types/yargs-parser": "^21.0.3",
-    "eslint": "^9.25.1",
+    "eslint": "^9.27.0",
     "publint": "^0.3.12",
     "tsdown": "v0.9.3",
     "typescript": "^5.8.3",
-    "vitest-testdirs": "^3.0.1"
+    "vitest-testdirs": "^4.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/fields-BqikCPbE.js

@@ -1,98 +0,0 @@
-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-Z7bYnm_v.js

@@ -1,103 +0,0 @@
-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) {
-		printHelp({
-			headline: "Generate Unicode Data Files",
-			commandName: "ucd generate",
-			usage: "<...versions> [...flags]",
-			tables: { Flags: [["--output-dir", "Specify the output directory."], ["--help (-h)", "See all available 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) {
-		const dirPath = `${BASE_URL}/${version}/ucd/${entry.path}`;
-		const dirResponse = await fetch(dirPath);
-		if (!dirResponse.ok) {
-			console.error(`failed to fetch directory: ${entry.path}`);
-			return;
-		}
-		const dirEntries = await dirResponse.json();
-		if (!Array.isArray(dirEntries)) {
-			console.error(`invalid response format for directory: ${entry.path}`);
-			return;
-		}
-		const fileEntries = dirEntries.filter((e) => e.type === "file" && e.name !== "ReadMe.txt" && !e.path.includes("latest") && !e.path.includes("draft"));
-		await Promise.all(fileEntries.map(async (fileEntry) => {
-			const fullPath = `${basePath}/${entry.path}/${fileEntry.path}`;
-			const pathParts = fullPath.replace(/^\//, "").split("/");
-			const filePath = join(baseOutputDir, pathParts.slice(2).join("/"));
-			await mkdir(dirname(filePath), { recursive: true });
-			try {
-				const content = await fetch(`${BASE_URL}${fullPath}`).then((res) => res.text());
-				await writeFile(filePath, content);
-				downloadedFiles.push(filePath);
-			} catch {
-				console.error(`failed to process file: ${fullPath}`);
-			}
-		}));
-		const dirEntriesToProcess = dirEntries.filter((e) => e.type === "directory");
-		await Promise.all(dirEntriesToProcess.map((dir) => processDirectory(dir, `${basePath}/${entry.path}`, version, baseOutputDir, downloadedFiles)));
-	}
-	for (const version of providedVersions) {
-		console.info(`Starting the generation process for data files for ${green(`Unicode ${version}`)}!`);
-		const downloadedFilesForVersion = [];
-		const versionPath = `/${version}/ucd`;
-		const rootResponse = await fetch(`${BASE_URL}${versionPath}`);
-		if (!rootResponse.ok) {
-			console.error(`failed to fetch data for version ${version}`);
-			continue;
-		}
-		const rootEntries = await rootResponse.json();
-		if (!Array.isArray(rootEntries)) {
-			console.error(`invalid response format for version ${version}`);
-			continue;
-		}
-		const versionOutputDir = path.join(outputDir, `v${version}`);
-		await mkdir(versionOutputDir, { recursive: true });
-		const rootFiles = rootEntries.filter((e) => e.type === "file" && e.name !== "ReadMe.txt" && !e.path.includes("latest") && !e.path.includes("draft"));
-		await Promise.all(rootFiles.map(async (fileEntry) => {
-			const fileUrl = `${versionPath}/${fileEntry.path}`;
-			const outputFilePath = path.join(versionOutputDir, fileEntry.name);
-			try {
-				const content = await fetch(`${BASE_URL}${fileUrl}`).then((res) => res.text());
-				await writeFile(outputFilePath, content);
-				downloadedFilesForVersion.push(outputFilePath);
-			} catch {
-				console.error(`failed to process file: ${fileUrl}`);
-			}
-		}));
-		const directories = rootEntries.filter((e) => e.type === "directory");
-		await Promise.all(directories.map((dir) => processDirectory(dir, versionPath, version, versionOutputDir, downloadedFilesForVersion)));
-		if (downloadedFilesForVersion.length === 0) {
-			console.warn(yellow(`No files were downloaded for Unicode ${version}.`));
-			continue;
-		}
-		console.info(green(`✓ Generated ${downloadedFilesForVersion.length} for Unicode ${version}`));
-		for (const file of downloadedFilesForVersion) {
-			const relativePath = path.relative(versionOutputDir, file);
-			console.info(green(`  - ${relativePath}`));
-		}
-	}
-}
-
-//#endregion
-export { runGenerate };