@lakutata/cli 2.17.1 → 3.0.0-beta.0

package/dist/esm/lib/workspace/Workspace.js

@@ -0,0 +1,231 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { newestVersion } from '../Registry.js';
+/**
+ * The fields of the dependencies of a package
+ */
+export const DEPENDENCY_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+/**
+ * A JSON file, written back with its indentation and its final newline
+ */
+export class JSONFile {
+    constructor(file, data, indent, newline) {
+        this.file = file;
+        this.data = data;
+        this.indent = indent;
+        this.newline = newline;
+    }
+    /**
+     * Read a JSON file
+     * @param file
+     */
+    static async read(file) {
+        const text = await readFile(file, 'utf8');
+        const indent = /^[ \t]+(?=")/m.exec(text)?.[0] ?? '  ';
+        return new JSONFile(file, JSON.parse(text), indent, text.endsWith('\n'));
+    }
+    /**
+     * Write the file back
+     */
+    async write() {
+        await writeFile(this.file, `${JSON.stringify(this.data, null, this.indent)}${this.newline ? '\n' : ''}`);
+    }
+}
+/**
+ * Whether a name matches a pattern with "*" wildcards
+ * @param name
+ * @param pattern
+ */
+export function matchName(name, pattern) {
+    return new RegExp(`^${pattern.split('*').map((part) => part.replace(/[.+?^${}()|[\]\\/]/g, '\\$&')).join('.*')}$`).test(name);
+}
+/**
+ * The directories matching a workspace pattern ("packages/*", "apps/**", "tools/cli")
+ * @param root
+ * @param pattern
+ */
+async function expandPattern(root, pattern) {
+    const segments = pattern.replace(/^\.\//, '').replace(/\/+$/, '').split('/').filter((segment) => !!segment);
+    const walk = async (directory, index) => {
+        if (index === segments.length)
+            return [directory];
+        const segment = segments[index];
+        if (!segment.includes('*'))
+            return existsSync(path.join(directory, segment)) ? walk(path.join(directory, segment), index + 1) : [];
+        let entries;
+        try {
+            entries = (await readdir(directory, { withFileTypes: true }))
+                .filter((entry) => entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.'))
+                .map((entry) => entry.name);
+        }
+        catch {
+            return [];
+        }
+        const found = [];
+        if (segment === '**') {
+            //Any depth, including none
+            found.push(...await walk(directory, index + 1));
+            for (const entry of entries)
+                found.push(...await walk(path.join(directory, entry), index));
+        }
+        else {
+            for (const entry of entries)
+                if (matchName(entry, segment))
+                    found.push(...await walk(path.join(directory, entry), index + 1));
+        }
+        return found;
+    };
+    return walk(root, 0);
+}
+/**
+ * The patterns of the packages of a pnpm workspace
+ * @param file
+ */
+async function pnpmPatterns(file) {
+    const patterns = [];
+    let inPackages = false;
+    for (const line of (await readFile(file, 'utf8')).split('\n')) {
+        if (/^packages:\s*$/.test(line)) {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            const matched = /^\s+-\s+['"]?([^'"#]+?)['"]?\s*(#.*)?$/.exec(line);
+            if (matched)
+                patterns.push(matched[1]);
+            else if (/^\S/.test(line))
+                inPackages = false;
+        }
+    }
+    return patterns;
+}
+/**
+ * A workspace: its root, its packages and their fixed version
+ */
+export class Workspace {
+    constructor(root, manifest, packages, lerna) {
+        this.root = root;
+        this.manifest = manifest;
+        this.packages = packages;
+        this.lerna = lerna;
+    }
+    /**
+     * The workspace of a directory: the nearest directory declaring workspaces
+     * @param start
+     */
+    static async find(start = process.cwd()) {
+        for (let directory = path.resolve(start);; directory = path.dirname(directory)) {
+            const manifestFile = path.join(directory, 'package.json');
+            if (existsSync(manifestFile)) {
+                const manifest = await JSONFile.read(manifestFile);
+                const declared = manifest.data.workspaces;
+                let patterns = Array.isArray(declared) ? declared : Array.isArray(declared?.packages) ? declared.packages : undefined;
+                if (!patterns && existsSync(path.join(directory, 'pnpm-workspace.yaml')))
+                    patterns = await pnpmPatterns(path.join(directory, 'pnpm-workspace.yaml'));
+                if (patterns)
+                    return await this.load(directory, manifest, patterns);
+            }
+            if (path.dirname(directory) === directory)
+                throw new Error(`${path.resolve(start)} is not in a workspace (a package.json declaring "workspaces", or a pnpm-workspace.yaml)`);
+        }
+    }
+    /**
+     * Load the packages of a workspace
+     * @param root
+     * @param manifest
+     * @param patterns
+     */
+    static async load(root, manifest, patterns) {
+        const included = new Set();
+        for (const pattern of patterns.filter((pattern) => !pattern.startsWith('!')))
+            for (const directory of await expandPattern(root, pattern))
+                included.add(directory);
+        for (const pattern of patterns.filter((pattern) => pattern.startsWith('!')))
+            for (const directory of await expandPattern(root, pattern.slice(1)))
+                included.delete(directory);
+        const packages = [];
+        for (const directory of [...included].sort()) {
+            if (!existsSync(path.join(directory, 'package.json')))
+                continue;
+            const packageManifest = await JSONFile.read(path.join(directory, 'package.json'));
+            if (typeof packageManifest.data.name !== 'string')
+                continue;
+            packages.push({
+                name: packageManifest.data.name,
+                version: packageManifest.data.version,
+                directory: directory,
+                manifest: packageManifest,
+                private: packageManifest.data.private === true,
+                scripts: packageManifest.data.scripts ?? {},
+                dependencies: []
+            });
+        }
+        const names = new Set(packages.map((pkg) => pkg.name));
+        for (const pkg of packages) {
+            const dependencies = new Set();
+            for (const field of DEPENDENCY_FIELDS)
+                for (const name of Object.keys(pkg.manifest.data[field] ?? {}))
+                    if (names.has(name) && name !== pkg.name)
+                        dependencies.add(name);
+            pkg.dependencies = [...dependencies];
+        }
+        const lernaFile = path.join(root, 'lerna.json');
+        return new Workspace(root, manifest, packages, existsSync(lernaFile) ? await JSONFile.read(lernaFile) : undefined);
+    }
+    /**
+     * A package by name
+     * @param name
+     */
+    get(name) {
+        return this.packages.find((pkg) => pkg.name === name);
+    }
+    /**
+     * The packages a package depends on, directly or not
+     * @param pkg
+     */
+    transitiveDependencies(pkg) {
+        const found = new Set();
+        const visit = (name) => {
+            for (const dependency of this.get(name)?.dependencies ?? []) {
+                if (found.has(dependency))
+                    continue;
+                found.add(dependency);
+                visit(dependency);
+            }
+        };
+        visit(pkg.name);
+        found.delete(pkg.name);
+        return found;
+    }
+    /**
+     * The cycles of the dependencies, as lists of package names
+     */
+    cycles() {
+        const cycles = [];
+        const state = new Map();
+        const stack = [];
+        const visit = (name) => {
+            state.set(name, 'visiting');
+            stack.push(name);
+            for (const dependency of this.get(name)?.dependencies ?? []) {
+                if (state.get(dependency) === 'visiting')
+                    cycles.push([...stack.slice(stack.indexOf(dependency)), dependency]);
+                else if (!state.has(dependency))
+                    visit(dependency);
+            }
+            stack.pop();
+            state.set(name, 'done');
+        };
+        for (const pkg of this.packages)
+            if (!state.has(pkg.name))
+                visit(pkg.name);
+        return cycles;
+    }
+    /**
+     * The fixed version of the workspace: the one of lerna.json, of the root package.json, or the highest of the packages
+     */
+    get version() {
+        return this.lerna?.data.version ?? this.manifest.data.version ?? newestVersion(this.packages.map((pkg) => pkg.version).filter((version) => !!version));
+    }
+}

package/dist/esm/locales/zh-CN.json

@@ -0,0 +1,194 @@
+{
+    "cli": {
+        "description": "lakutata 框架的命令行工具：从模板创建项目，运行工作区各包的脚本并管理版本，打包应用并生成可执行文件。",
+        "commands": {
+            "create": {
+                "description": "从模板创建一个 lakutata 项目",
+                "options": {
+                    "name": "应用的名称",
+                    "id": "应用的 ID（包名），默认是名称的小写形式",
+                    "template": "模板：官方模板的名称（lakutata templates 会列出）、npm:<包名>、github:<所有者>/<仓库> 或一个目录",
+                    "path": "在哪个目录下创建项目目录",
+                    "init": "直接在该目录中创建项目，目录可以已存在且非空",
+                    "description": "应用的描述",
+                    "author": "应用的作者",
+                    "license": "应用的许可证",
+                    "packageManager": "安装依赖使用的包管理器，默认是运行本工具的那个（none 表示不安装）",
+                    "with": "启用模板的可选功能，多个用逗号分隔（lakutata templates 会列出）：i18n",
+                    "git": "初始化 git 仓库",
+                    "yes": "不经确认直接创建项目"
+                }
+            },
+            "templates": {
+                "description": "列出项目模板",
+                "options": {
+                    "refresh": "重新获取模板目录，即使已有缓存"
+                }
+            },
+            "clean": {
+                "description": "删除当前目录所在包下的路径，在各平台上都可用（默认是其 tsconfig.json 的 outDir）",
+                "arguments": {
+                    "paths": "要删除的路径，相对于包（默认是其 tsconfig.json 的 outDir 和 declarationDir）"
+                }
+            },
+            "info": {
+                "description": "显示本工具和框架的版本"
+            },
+            "run": {
+                "description": "按依赖顺序在工作区的各包中运行一个脚本",
+                "arguments": {
+                    "script": "要运行的脚本，在拥有它的包中运行"
+                },
+                "options": {
+                    "concurrency": "同时运行的包数（默认是处理器数量）",
+                    "bail": "遇到第一个失败就停止",
+                    "parallel": "所有包同时运行，不等待它们的依赖（开发服务器、监视进程）",
+                    "scope": "要运行的包，按名称（可使用 * 通配符）"
+                }
+            },
+            "version": {
+                "description": "为工作区的各包设置下一个版本，并更新它们之间的依赖",
+                "arguments": {
+                    "bump": "major、minor、patch、premajor、preminor、prepatch、prerelease，或一个版本号"
+                },
+                "options": {
+                    "preid": "预发布版本的标识（如 beta）",
+                    "git": "提交这些修改并打上标签 v<版本>",
+                    "yes": "不经确认直接设置版本"
+                }
+            },
+            "add": {
+                "description": "向工作区添加一个包（packages/<名称>）：TypeScript 包，或用 --native [gyp|cmake|rust] 添加原生插件",
+                "arguments": {
+                    "name": "包的名称（工作区的 packages/<名称>）"
+                },
+                "options": {
+                    "native": "原生插件，按构建系统：gyp（C++，node-gyp，默认）、cmake（C++，cmake-js）或 rust（napi-rs）",
+                    "to": "依赖它的工作区包"
+                }
+            },
+            "list": {
+                "description": "列出工作区的包"
+            },
+            "package": {
+                "description": "打包编译后的应用：打包成一个 JavaScript 文件、可执行文件或安装包",
+                "bundle": {
+                    "description": "把编译后的应用及其依赖打包成一个由 node 运行的文件",
+                    "options": {
+                        "entry": "应用编译后的入口（默认是 package.json 的 main）",
+                        "outfile": "打包输出的文件（默认 dist/<名称>.cjs）",
+                        "minify": "压缩打包结果",
+                        "external": "不打进包里的模块，运行时从旁边的 node_modules 加载（原生插件会自动处理）"
+                    }
+                },
+                "exe": {
+                    "description": "为当前平台生成编译后应用的可执行文件，无需安装 Node.js 即可运行",
+                    "options": {
+                        "entry": "应用编译后的入口（默认是 package.json 的 main）",
+                        "outdir": "可执行文件所在的目录（默认 dist）",
+                        "minify": "压缩嵌入可执行文件的包",
+                        "external": "不打进包里的模块（它们不在可执行文件中，而是从旁边的 node_modules 加载）",
+                        "runtime": "嵌入可执行文件的运行时：node（Node.js 的单可执行应用，默认）或 bun（Bun，安装在项目中或系统上）",
+                        "layout": "单个文件，原生插件和资源嵌入其中（file，默认）；或一个目录：可执行文件及其旁边的原生插件和资源（directory）"
+                    }
+                },
+                "installer": {
+                    "description": "为当前平台生成编译后应用的安装包：安装可执行文件、原生插件和资源，把程序加入 PATH，并注册系统服务",
+                    "options": {
+                        "target": "要生成的安装包：Linux 上为 deb、rpm、apk、archlinux、tar.gz，macOS 上为 pkg、tar.gz，Windows 上为 nsis、msi、zip（默认取 package.json 的 lakutata.installer）",
+                        "outdir": "安装包所在的目录（默认 dist/installer）",
+                        "entry": "应用编译后的入口（默认是 package.json 的 main）",
+                        "minify": "压缩嵌入可执行文件的包",
+                        "external": "不打进包里的模块"
+                    }
+                }
+            },
+            "migration": {
+                "description": "生成、创建、执行、回滚或查看应用数据库的迁移",
+                "arguments": {
+                    "action": "generate：根据实体的变化生成迁移；create <名称>：创建空迁移；run：执行待执行的迁移；revert：回滚最近执行的迁移；show：查看已执行和待执行的迁移",
+                    "name": "要创建的迁移的名称（create）"
+                },
+                "options": {
+                    "dir": "迁移所在的目录，相对于包（generate、create）",
+                    "script": "构建并启动应用的包脚本（generate、run、revert、show）",
+                    "package": "应用所在的工作区包（默认是当前目录）",
+                    "database": "数据库：其 Database 组件或提供者的名称（默认全部；应用有多个数据库时，回滚必须指定）",
+                    "transaction": "执行或回滚迁移的事务方式：all（一个事务，默认）、each（每个迁移一个）或 none",
+                    "fake": "只标记迁移为已执行或已回滚，不实际执行"
+                }
+            },
+            "native": {
+                "description": "修改当前目录原生插件的构建（binding.gyp、CMakeLists.txt、Cargo.toml）：链接库、添加头文件目录、定义宏",
+                "arguments": {
+                    "action": "link：链接一个库；include：添加头文件目录；define：定义宏（NAME 或 NAME=value）",
+                    "value": "库（系统库，或包内的文件：.a .lib .so .dylib .dll）、目录或宏"
+                },
+                "options": {
+                    "platform": "修改所针对的平台（默认是库文件所属的平台，否则为所有平台）",
+                    "pkgConfig": "该库是 pkg-config 的包",
+                    "framework": "该库是 macOS 的 framework",
+                    "crate": "该库是一个 crate（Rust 插件，使用 cargo add）",
+                    "target": "要修改的构建目标（默认是唯一的那个）"
+                }
+            },
+            "i18n": {
+                "description": "检查各语言的翻译、声明键名的类型，或添加一种语言",
+                "arguments": {
+                    "action": "check：检查各语言翻译的问题；types：声明消息的键名及其参数的类型；add <语言>：以默认语言的消息为模板添加一种语言",
+                    "locale": "要添加的语言（add）：zh-CN、ja、pt-BR"
+                },
+                "options": {
+                    "dir": "翻译所在的目录：每种语言一个文件（zh-CN.json）或一个目录（zh-CN/）；多个目录用逗号分隔",
+                    "default": "默认语言：检查其他语言时的基准，生成类型声明和新语言时的来源",
+                    "out": "类型声明文件（types）",
+                    "module": "应用引入 i18n 的模块（types）：lakutata/com/i18n 或 @lakutata/i18n",
+                    "strict": "警告也视为检查失败（check）"
+                }
+            }
+        },
+        "help": {
+            "usage": "用法：",
+            "arguments": "参数：",
+            "options": "选项：",
+            "commands": "命令：",
+            "helpOption": "显示命令的帮助",
+            "helpCommand": "显示命令的帮助",
+            "versionOption": "显示版本号",
+            "default": "默认：{value}",
+            "choices": "可选：{choices}",
+            "negate": "关闭 {flag}",
+            "hints": "（{hints}）",
+            "separator": "，"
+        },
+        "prompt": {
+            "json": "不是 JSON 对象"
+        },
+        "prompts": {
+            "features": "项目的功能",
+            "create": "创建这个项目吗？",
+            "notCreated": "项目未创建",
+            "version": "设置这个版本吗？",
+            "notVersioned": "版本未修改"
+        },
+        "plan": {
+            "title": "项目",
+            "name": "名称",
+            "id": "ID",
+            "description": "描述",
+            "author": "作者",
+            "license": "许可证",
+            "template": "模板",
+            "features": "功能",
+            "none": "无",
+            "directory": "目录",
+            "dependencies": "依赖",
+            "notInstalled": "不安装",
+            "installed": "用 {manager} 安装",
+            "git": "Git",
+            "initialized": "初始化",
+            "notInitialized": "不初始化",
+            "version": "版本 {from} → {to}"
+        }
+    }
+}

package/dist/esm/locales/zh-TW.json

@@ -0,0 +1,194 @@
+{
+    "cli": {
+        "description": "lakutata 框架的命令列工具：從範本建立專案，執行工作區各套件的指令碼並管理版本，打包應用程式並產生可執行檔。",
+        "commands": {
+            "create": {
+                "description": "從範本建立一個 lakutata 專案",
+                "options": {
+                    "name": "應用程式的名稱",
+                    "id": "應用程式的 ID（套件名稱），預設為名稱的小寫形式",
+                    "template": "範本：官方範本的名稱（lakutata templates 會列出）、npm:<套件名稱>、github:<擁有者>/<儲存庫> 或一個目錄",
+                    "path": "在哪個目錄下建立專案目錄",
+                    "init": "直接在該目錄中建立專案，目錄可以已存在且非空",
+                    "description": "應用程式的描述",
+                    "author": "應用程式的作者",
+                    "license": "應用程式的授權條款",
+                    "packageManager": "安裝相依套件使用的套件管理器，預設是執行本工具的那個（none 表示不安裝）",
+                    "with": "啟用範本的可選功能，多個用逗號分隔（lakutata templates 會列出）：i18n",
+                    "git": "初始化 git 儲存庫",
+                    "yes": "不經確認直接建立專案"
+                }
+            },
+            "templates": {
+                "description": "列出專案範本",
+                "options": {
+                    "refresh": "重新取得範本目錄，即使已有快取"
+                }
+            },
+            "clean": {
+                "description": "刪除目前目錄所在套件下的路徑，在各平台上都可用（預設是其 tsconfig.json 的 outDir）",
+                "arguments": {
+                    "paths": "要刪除的路徑，相對於套件（預設是其 tsconfig.json 的 outDir 和 declarationDir）"
+                }
+            },
+            "info": {
+                "description": "顯示本工具和框架的版本"
+            },
+            "run": {
+                "description": "依相依關係的順序在工作區的各套件中執行一個指令碼",
+                "arguments": {
+                    "script": "要執行的指令碼，在擁有它的套件中執行"
+                },
+                "options": {
+                    "concurrency": "同時執行的套件數（預設是處理器數量）",
+                    "bail": "遇到第一個失敗就停止",
+                    "parallel": "所有套件同時執行，不等待它們的相依套件（開發伺服器、監看程序）",
+                    "scope": "要執行的套件，依名稱（可使用 * 萬用字元）"
+                }
+            },
+            "version": {
+                "description": "為工作區的各套件設定下一個版本，並更新它們之間的相依關係",
+                "arguments": {
+                    "bump": "major、minor、patch、premajor、preminor、prepatch、prerelease，或一個版本號"
+                },
+                "options": {
+                    "preid": "預先發行版本的識別碼（如 beta）",
+                    "git": "提交這些修改並打上標籤 v<版本>",
+                    "yes": "不經確認直接設定版本"
+                }
+            },
+            "add": {
+                "description": "向工作區新增一個套件（packages/<名稱>）：TypeScript 套件，或用 --native [gyp|cmake|rust] 新增原生外掛",
+                "arguments": {
+                    "name": "套件的名稱（工作區的 packages/<名稱>）"
+                },
+                "options": {
+                    "native": "原生外掛，依建置系統：gyp（C++，node-gyp，預設）、cmake（C++，cmake-js）或 rust（napi-rs）",
+                    "to": "相依於它的工作區套件"
+                }
+            },
+            "list": {
+                "description": "列出工作區的套件"
+            },
+            "package": {
+                "description": "打包編譯後的應用程式：打包成一個 JavaScript 檔案、可執行檔或安裝套件",
+                "bundle": {
+                    "description": "把編譯後的應用程式及其相依套件打包成一個由 node 執行的檔案",
+                    "options": {
+                        "entry": "應用程式編譯後的入口（預設是 package.json 的 main）",
+                        "outfile": "打包輸出的檔案（預設 dist/<名稱>.cjs）",
+                        "minify": "壓縮打包結果",
+                        "external": "不打包進去的模組，執行時從旁邊的 node_modules 載入（原生外掛會自動處理）"
+                    }
+                },
+                "exe": {
+                    "description": "為目前平台產生編譯後應用程式的可執行檔，無需安裝 Node.js 即可執行",
+                    "options": {
+                        "entry": "應用程式編譯後的入口（預設是 package.json 的 main）",
+                        "outdir": "可執行檔所在的目錄（預設 dist）",
+                        "minify": "壓縮嵌入可執行檔的打包結果",
+                        "external": "不打包進去的模組（它們不在可執行檔中，而是從旁邊的 node_modules 載入）",
+                        "runtime": "嵌入可執行檔的執行環境：node（Node.js 的單一可執行應用程式，預設）或 bun（Bun，安裝在專案中或系統上）",
+                        "layout": "單一檔案，原生外掛程式和資源嵌入其中（file，預設）；或一個目錄：可執行檔及其旁邊的原生外掛程式和資源（directory）"
+                    }
+                },
+                "installer": {
+                    "description": "為目前平台產生編譯後應用程式的安裝套件：安裝可執行檔、原生外掛程式和資源，把程式加入 PATH，並註冊系統服務",
+                    "options": {
+                        "target": "要產生的安裝套件：Linux 上為 deb、rpm、apk、archlinux、tar.gz，macOS 上為 pkg、tar.gz，Windows 上為 nsis、msi、zip（預設取 package.json 的 lakutata.installer）",
+                        "outdir": "安裝套件所在的目錄（預設 dist/installer）",
+                        "entry": "應用程式編譯後的入口（預設是 package.json 的 main）",
+                        "minify": "壓縮嵌入可執行檔的打包結果",
+                        "external": "不打包進去的模組"
+                    }
+                }
+            },
+            "migration": {
+                "description": "產生、建立、執行、復原或檢視應用程式資料庫的遷移",
+                "arguments": {
+                    "action": "generate：根據實體的變化產生遷移；create <名稱>：建立空遷移；run：執行待執行的遷移；revert：復原最近執行的遷移；show：檢視已執行和待執行的遷移",
+                    "name": "要建立的遷移的名稱（create）"
+                },
+                "options": {
+                    "dir": "遷移所在的目錄，相對於套件（generate、create）",
+                    "script": "建置並啟動應用程式的套件指令碼（generate、run、revert、show）",
+                    "package": "應用程式所在的工作區套件（預設是目前目錄）",
+                    "database": "資料庫：其 Database 元件或提供者的名稱（預設全部；應用程式有多個資料庫時，復原必須指定）",
+                    "transaction": "執行或復原遷移的交易方式：all（一個交易，預設）、each（每個遷移一個）或 none",
+                    "fake": "只標記遷移為已執行或已復原，不實際執行"
+                }
+            },
+            "native": {
+                "description": "修改目前目錄原生外掛的建置（binding.gyp、CMakeLists.txt、Cargo.toml）：連結程式庫、新增標頭檔目錄、定義巨集",
+                "arguments": {
+                    "action": "link：連結一個程式庫；include：新增標頭檔目錄；define：定義巨集（NAME 或 NAME=value）",
+                    "value": "程式庫（系統程式庫，或套件內的檔案：.a .lib .so .dylib .dll）、目錄或巨集"
+                },
+                "options": {
+                    "platform": "修改所針對的平台（預設是程式庫檔案所屬的平台，否則為所有平台）",
+                    "pkgConfig": "該程式庫是 pkg-config 的套件",
+                    "framework": "該程式庫是 macOS 的 framework",
+                    "crate": "該程式庫是一個 crate（Rust 外掛，使用 cargo add）",
+                    "target": "要修改的建置目標（預設是唯一的那個）"
+                }
+            },
+            "i18n": {
+                "description": "檢查各語言的翻譯、宣告鍵名的型別，或新增一種語言",
+                "arguments": {
+                    "action": "check：檢查各語言翻譯的問題；types：宣告訊息的鍵名及其參數的型別；add <語言>：以預設語言的訊息為範本新增一種語言",
+                    "locale": "要新增的語言（add）：zh-CN、ja、pt-BR"
+                },
+                "options": {
+                    "dir": "翻譯所在的目錄：每種語言一個檔案（zh-CN.json）或一個目錄（zh-CN/）；多個目錄用逗號分隔",
+                    "default": "預設語言：檢查其他語言時的基準，產生型別宣告和新語言時的來源",
+                    "out": "型別宣告檔案（types）",
+                    "module": "應用程式匯入 i18n 的模組（types）：lakutata/com/i18n 或 @lakutata/i18n",
+                    "strict": "警告也視為檢查失敗（check）"
+                }
+            }
+        },
+        "help": {
+            "usage": "用法：",
+            "arguments": "參數：",
+            "options": "選項：",
+            "commands": "命令：",
+            "helpOption": "顯示命令的說明",
+            "helpCommand": "顯示命令的說明",
+            "versionOption": "顯示版本號",
+            "default": "預設：{value}",
+            "choices": "可選：{choices}",
+            "negate": "關閉 {flag}",
+            "hints": "（{hints}）",
+            "separator": "，"
+        },
+        "prompt": {
+            "json": "不是 JSON 物件"
+        },
+        "prompts": {
+            "features": "專案的功能",
+            "create": "建立這個專案嗎？",
+            "notCreated": "專案未建立",
+            "version": "設定這個版本嗎？",
+            "notVersioned": "版本未修改"
+        },
+        "plan": {
+            "title": "專案",
+            "name": "名稱",
+            "id": "ID",
+            "description": "描述",
+            "author": "作者",
+            "license": "授權條款",
+            "template": "範本",
+            "features": "功能",
+            "none": "無",
+            "directory": "目錄",
+            "dependencies": "相依套件",
+            "notInstalled": "不安裝",
+            "installed": "用 {manager} 安裝",
+            "git": "Git",
+            "initialized": "初始化",
+            "notInitialized": "不初始化",
+            "version": "版本 {from} → {to}"
+        }
+    }
+}

package/dist/esm/types/ProcessResult.js

@@ -0,0 +1 @@
+export {};