@worldware/msg-cli 0.0.4 → 0.1.0

package/dist/chunk-4Q2252JQ.mjs

@@ -0,0 +1,50 @@
+import {
+  dynamicImportFromUrl
+} from "./chunk-KKYCVD5M.mjs";
+import {
+  loadPackageJsonForMsg
+} from "./chunk-DBC2Y6VQ.mjs";
+
+// src/lib/create-project-helpers.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join, relative } from "path";
+import { pathToFileURL } from "url";
+function calculateRelativePath(projectsDir, translationsDir) {
+  const rel = relative(projectsDir, translationsDir);
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+async function importMsgProjectFile(projectsDir, projectName) {
+  const basePath = join(projectsDir, projectName);
+  const exts = [".ts", ".js"];
+  for (const ext of exts) {
+    const p = `${basePath}${ext}`;
+    if (existsSync(p)) {
+      try {
+        const url = pathToFileURL(p).href;
+        const mod = await dynamicImportFromUrl(url);
+        return mod?.default ?? mod;
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function writeMsgProjectFile(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+}
+function loadPackageJsonForCreateProject(cwd) {
+  const ctx = loadPackageJsonForMsg(cwd, { requireL10n: true });
+  return ctx.pkg;
+}
+
+export {
+  calculateRelativePath,
+  importMsgProjectFile,
+  writeMsgProjectFile,
+  loadPackageJsonForCreateProject
+};

package/dist/chunk-DBC2Y6VQ.mjs

@@ -0,0 +1,167 @@
+// src/lib/init-helpers.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var DEFAULT_I18N_DIR = "src/i18n";
+var DEFAULT_L10N_DIR = "res/l10n";
+function findPackageJsonPath(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    const p = join(dir, "package.json");
+    if (existsSync(p)) return p;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readPackageJson(pkgPath) {
+  const raw = readFileSync(pkgPath, "utf-8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("package.json must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error("Invalid package.json: " + err.message);
+    }
+    throw err;
+  }
+}
+function loadPackageJsonForMsg(cwd, options) {
+  const pkgPath = findPackageJsonPath(cwd);
+  if (!pkgPath) {
+    throw new Error("package.json not found. Run this command from the project root.");
+  }
+  let pkg;
+  try {
+    pkg = readPackageJson(pkgPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "package.json could not be parsed.";
+    throw new Error(msg);
+  }
+  const dirs = pkg.directories;
+  if (!dirs || typeof dirs !== "object" || !dirs.i18n) {
+    throw new Error("package.json must contain directories.i18n. Run 'msg init' first.");
+  }
+  if (options?.requireL10n && !dirs.l10n) {
+    throw new Error(
+      "package.json must contain directories.i18n and directories.l10n. Run 'msg init' first."
+    );
+  }
+  const rootDir = dirname(pkgPath);
+  const useTypeScript = existsSync(join(rootDir, "tsconfig.json"));
+  const isEsm = pkg.type === "module";
+  return {
+    pkgPath,
+    rootDir,
+    pkg,
+    i18nDir: dirs.i18n,
+    l10nDir: dirs.l10n,
+    isEsm,
+    useTypeScript
+  };
+}
+function writePackageJson(pkgPath, pkg) {
+  const json = JSON.stringify(pkg, null, 2) + "\n";
+  writeFileSync(pkgPath, json, "utf-8");
+}
+function validatePaths(rootDir, i18nDir, l10nDir) {
+  const trimmedI18n = i18nDir.trim();
+  const trimmedL10n = l10nDir.trim();
+  if (!trimmedI18n) return { valid: false, error: "i18n directory path cannot be empty" };
+  if (!trimmedL10n) return { valid: false, error: "l10n directory path cannot be empty" };
+  if (trimmedI18n.startsWith("/") || /^[A-Za-z]:/.test(trimmedI18n)) {
+    return { valid: false, error: "i18n path must be relative" };
+  }
+  if (trimmedL10n.startsWith("/") || /^[A-Za-z]:/.test(trimmedL10n)) {
+    return { valid: false, error: "l10n path must be relative" };
+  }
+  return { valid: true };
+}
+var GITKEEP = ".gitkeep";
+function ensureDirectoriesWithGitkeep(rootDir, i18nDir, l10nDir, force) {
+  const leaves = [
+    join(rootDir, i18nDir, "projects"),
+    join(rootDir, i18nDir, "resources"),
+    join(rootDir, l10nDir, "translations"),
+    join(rootDir, l10nDir, "xliff")
+  ];
+  for (const leaf of leaves) {
+    const parent = dirname(leaf);
+    if (!existsSync(parent)) {
+      mkdirSync(parent, { recursive: true });
+    }
+    if (!existsSync(leaf)) {
+      mkdirSync(leaf, { recursive: true });
+    }
+    const gitkeepPath = join(leaf, GITKEEP);
+    if (force || !existsSync(gitkeepPath)) {
+      writeFileSync(gitkeepPath, "", "utf-8");
+    }
+  }
+}
+function isAlreadyInitialized(pkg, rootDir, i18nDir, l10nDir) {
+  const dirs = pkg.directories;
+  if (!dirs || typeof dirs !== "object") return false;
+  if (dirs.i18n !== i18nDir || dirs.l10n !== l10nDir) return false;
+  const i18nFull = join(rootDir, i18nDir);
+  const l10nFull = join(rootDir, l10nDir);
+  return existsSync(i18nFull) && existsSync(l10nFull);
+}
+function addDirectoriesToPackageJson(pkg, i18nDir, l10nDir) {
+  const directories = { ...pkg.directories, i18n: i18nDir, l10n: l10nDir, root: "." };
+  return { ...pkg, directories };
+}
+function addImportAliasesToPackageJson(pkg, i18nDir, l10nDir) {
+  const imports = {
+    ...pkg.imports,
+    "#i18n/*": `${i18nDir}/*`,
+    "#l10n/*": `${l10nDir}/*`,
+    "#root/*": "./*"
+  };
+  return { ...pkg, imports };
+}
+function addScriptsToPackageJson(pkg) {
+  const scripts = {
+    ...pkg.scripts,
+    "i18n-export": "msg export:resources",
+    "l10n-import": "msg import:translations"
+  };
+  return { ...pkg, scripts };
+}
+function addTsconfigPaths(tsconfigPath, i18nDir, l10nDir) {
+  const raw = readFileSync(tsconfigPath, "utf-8");
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid tsconfig.json");
+  }
+  if (!config.compilerOptions) config.compilerOptions = {};
+  const co = config.compilerOptions;
+  co.baseUrl = co.baseUrl ?? ".";
+  co.paths = {
+    ...co.paths,
+    "#i18n/*": [`${i18nDir}/*`],
+    "#l10n/*": [`${l10nDir}/*`],
+    "#root/*": ["./*"]
+  };
+  writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+export {
+  DEFAULT_I18N_DIR,
+  DEFAULT_L10N_DIR,
+  findPackageJsonPath,
+  readPackageJson,
+  loadPackageJsonForMsg,
+  writePackageJson,
+  validatePaths,
+  ensureDirectoriesWithGitkeep,
+  isAlreadyInitialized,
+  addDirectoriesToPackageJson,
+  addImportAliasesToPackageJson,
+  addScriptsToPackageJson,
+  addTsconfigPaths
+};

package/dist/chunk-KKYCVD5M.mjs

@@ -0,0 +1,136 @@
+import {
+  loadPackageJsonForMsg
+} from "./chunk-DBC2Y6VQ.mjs";
+
+// src/lib/create-resource-helpers.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+async function dynamicImportFromUrl(url) {
+  try {
+    return await import(
+      /* @vite-ignore */
+      url
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const useRequire = msg.includes("dynamic import callback") || msg.includes("ERR_VM_DYNAMIC_IMPORT");
+    if (useRequire) {
+      try {
+        const path = url.startsWith("file:") ? fileURLToPath(url) : url;
+        const base = pathToFileURL(process.cwd()).href;
+        const req = createRequire(base);
+        const mod = req(path);
+        return Promise.resolve(mod ?? {});
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function readPackageJsonForCreateResource(cwd) {
+  const ctx = loadPackageJsonForMsg(cwd);
+  return {
+    i18nDir: ctx.i18nDir,
+    isEsm: ctx.isEsm,
+    useTypeScript: ctx.useTypeScript
+  };
+}
+function dirFromSourceLocale(sourceLocale) {
+  const lang = sourceLocale.split("-")[0]?.toLowerCase() ?? "";
+  return lang === "ar" || lang === "he" ? "rtl" : "ltr";
+}
+async function importMsgProjectForResource(projectsDir, projectName) {
+  const basePath = join(projectsDir, projectName);
+  const exts = [".ts", ".js"];
+  for (const ext of exts) {
+    const p = `${basePath}${ext}`;
+    if (existsSync(p)) {
+      try {
+        const url = pathToFileURL(p).href;
+        const mod = await dynamicImportFromUrl(url);
+        const data = mod?.default ?? mod;
+        const sourceLocale = data?.locales?.sourceLocale;
+        if (!sourceLocale || typeof sourceLocale !== "string") {
+          throw new Error(
+            `Project file must export a default with locales.sourceLocale (got ${typeof data?.locales?.sourceLocale}).`
+          );
+        }
+        return {
+          sourceLocale,
+          dir: dirFromSourceLocale(sourceLocale)
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Project file '${projectName}${ext}' could not be loaded: ${message}`
+        );
+      }
+    }
+  }
+  return void 0;
+}
+function generateMsgResourceContent(params) {
+  const { title, projectName, sourceLocale, dir, isEsm } = params;
+  const projectImport = isEsm ? `../projects/${projectName}.js` : `../projects/${projectName}`;
+  const messagesBlock = `  messages: [
+    {
+      key: 'example.message',
+      value: 'Example message.',
+      notes: [
+        { type: 'description', content: 'This is an example message. You can delete it.' }
+      ]
+    }
+  ]`;
+  const titleStr = `'${title.replace(/'/g, "\\'")}'`;
+  const langStr = `'${sourceLocale.replace(/'/g, "\\'")}'`;
+  const dirStr = `'${dir}'`;
+  if (isEsm) {
+    return `import { MsgResource } from '@worldware/msg';
+import project from '${projectImport}';
+
+export default MsgResource.create({
+  title: ${titleStr},
+  attributes: {
+    lang: ${langStr},
+    dir: ${dirStr}
+  },
+  notes: [
+    { type: 'DESCRIPTION', content: 'This is a generated file. Replace this description with your own.' }
+  ],
+${messagesBlock}
+}, project);
+`;
+  }
+  return `const { MsgResource } = require('@worldware/msg');
+const project = require('${projectImport}');
+
+module.exports = MsgResource.create({
+  title: ${titleStr},
+  attributes: {
+    lang: ${langStr},
+    dir: ${dirStr}
+  },
+  notes: [
+    { type: 'DESCRIPTION', content: 'This is a generated file. Replace this description with your own.' }
+  ],
+${messagesBlock}
+}, project);
+`;
+}
+function writeMsgResourceFile(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+}
+
+export {
+  dynamicImportFromUrl,
+  readPackageJsonForCreateResource,
+  importMsgProjectForResource,
+  generateMsgResourceContent,
+  writeMsgResourceFile
+};

package/dist/commands/create/project.cjs

@@ -0,0 +1,293 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/create/project.ts
+var project_exports = {};
+__export(project_exports, {
+  default: () => CreateProject
+});
+module.exports = __toCommonJS(project_exports);
+var import_core = require("@oclif/core");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+
+// src/lib/create-project-helpers.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_url2 = require("url");
+
+// src/lib/create-resource-helpers.ts
+var import_module = require("module");
+var import_url = require("url");
+
+// src/lib/init-helpers.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function findPackageJsonPath(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    const p = (0, import_path.join)(dir, "package.json");
+    if ((0, import_fs.existsSync)(p)) return p;
+    const parent = (0, import_path.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readPackageJson(pkgPath) {
+  const raw = (0, import_fs.readFileSync)(pkgPath, "utf-8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("package.json must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error("Invalid package.json: " + err.message);
+    }
+    throw err;
+  }
+}
+function loadPackageJsonForMsg(cwd, options) {
+  const pkgPath = findPackageJsonPath(cwd);
+  if (!pkgPath) {
+    throw new Error("package.json not found. Run this command from the project root.");
+  }
+  let pkg;
+  try {
+    pkg = readPackageJson(pkgPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "package.json could not be parsed.";
+    throw new Error(msg);
+  }
+  const dirs = pkg.directories;
+  if (!dirs || typeof dirs !== "object" || !dirs.i18n) {
+    throw new Error("package.json must contain directories.i18n. Run 'msg init' first.");
+  }
+  if (options?.requireL10n && !dirs.l10n) {
+    throw new Error(
+      "package.json must contain directories.i18n and directories.l10n. Run 'msg init' first."
+    );
+  }
+  const rootDir = (0, import_path.dirname)(pkgPath);
+  const useTypeScript = (0, import_fs.existsSync)((0, import_path.join)(rootDir, "tsconfig.json"));
+  const isEsm = pkg.type === "module";
+  return {
+    pkgPath,
+    rootDir,
+    pkg,
+    i18nDir: dirs.i18n,
+    l10nDir: dirs.l10n,
+    isEsm,
+    useTypeScript
+  };
+}
+
+// src/lib/create-resource-helpers.ts
+async function dynamicImportFromUrl(url) {
+  try {
+    return await import(
+      /* @vite-ignore */
+      url
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const useRequire = msg.includes("dynamic import callback") || msg.includes("ERR_VM_DYNAMIC_IMPORT");
+    if (useRequire) {
+      try {
+        const path = url.startsWith("file:") ? (0, import_url.fileURLToPath)(url) : url;
+        const base = (0, import_url.pathToFileURL)(process.cwd()).href;
+        const req = (0, import_module.createRequire)(base);
+        const mod = req(path);
+        return Promise.resolve(mod ?? {});
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+
+// src/lib/create-project-helpers.ts
+function calculateRelativePath(projectsDir, translationsDir) {
+  const rel = (0, import_path2.relative)(projectsDir, translationsDir);
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+async function importMsgProjectFile(projectsDir, projectName) {
+  const basePath = (0, import_path2.join)(projectsDir, projectName);
+  const exts = [".ts", ".js"];
+  for (const ext of exts) {
+    const p = `${basePath}${ext}`;
+    if ((0, import_fs2.existsSync)(p)) {
+      try {
+        const url = (0, import_url2.pathToFileURL)(p).href;
+        const mod = await dynamicImportFromUrl(url);
+        return mod?.default ?? mod;
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function writeMsgProjectFile(filePath, content) {
+  const dir = (0, import_path2.dirname)(filePath);
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs2.writeFileSync)(filePath, content, "utf-8");
+}
+function loadPackageJsonForCreateProject(cwd) {
+  const ctx = loadPackageJsonForMsg(cwd, { requireL10n: true });
+  return ctx.pkg;
+}
+
+// src/commands/create/project.ts
+var CreateProject = class _CreateProject extends import_core.Command {
+  static description = "Create a new MsgProject file in the projects directory (i18n/projects)";
+  static strict = false;
+  static args = {
+    projectName: import_core.Args.string({
+      required: false,
+      description: "Name of the project (used as file name)"
+    }),
+    source: import_core.Args.string({
+      required: false,
+      description: "Source locale for the project"
+    }),
+    targets: import_core.Args.string({
+      required: false,
+      description: "Target locale(s) (variadic)"
+    })
+  };
+  static flags = {
+    help: import_core.Flags.help({ char: "h" }),
+    extend: import_core.Flags.string({
+      char: "e",
+      description: "Extend an existing project"
+    })
+  };
+  async run() {
+    const { argv, flags } = await this.parse(_CreateProject);
+    const [projectName, source, ...targets] = argv;
+    if (!projectName?.trim()) {
+      this.error("projectName is required.", { exit: 1 });
+    }
+    if (!source?.trim()) {
+      this.error("source locale is required.", { exit: 1 });
+    }
+    if (!targets?.length || targets.every((t) => !t?.trim())) {
+      this.error("At least one target locale is required.", { exit: 1 });
+    }
+    const cwd = process.cwd();
+    const pkgPath = findPackageJsonPath(cwd);
+    if (!pkgPath) {
+      this.error("package.json not found. Run this command from the project root.", { exit: 1 });
+    }
+    let pkg;
+    try {
+      pkg = loadPackageJsonForCreateProject(cwd);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.error(msg, { exit: 1 });
+    }
+    const rootDir = (0, import_path3.join)(pkgPath, "..");
+    const i18nDir = pkg.directories.i18n;
+    const l10nDir = pkg.directories.l10n;
+    const projectsDir = (0, import_path3.join)(rootDir, i18nDir, "projects");
+    const translationsDir = (0, import_path3.join)(rootDir, l10nDir, "translations");
+    const relPath = calculateRelativePath(projectsDir, translationsDir);
+    const useTypeScript = (0, import_fs3.existsSync)((0, import_path3.join)(rootDir, "tsconfig.json"));
+    const isEsm = pkg.type === "module";
+    const ext = useTypeScript ? ".ts" : ".js";
+    const outPath = (0, import_path3.join)(projectsDir, `${projectName}${ext}`);
+    if ((0, import_fs3.existsSync)(outPath)) {
+      this.error(`A project with the name '${projectName}' already exists.`, { exit: 1 });
+    }
+    let targetLocales = {};
+    let pseudoLocale = "en-XA";
+    if (flags.extend) {
+      const base = await importMsgProjectFile(projectsDir, flags.extend);
+      if (!base) {
+        this.error(`Project '${flags.extend}' could not be found to extend.`, { exit: 1 });
+      }
+      if (base.locales?.targetLocales && typeof base.locales.targetLocales === "object") {
+        targetLocales = { ...base.locales.targetLocales };
+      }
+      if (base.locales?.pseudoLocale) {
+        pseudoLocale = base.locales.pseudoLocale;
+      }
+    }
+    targetLocales[source] = [source];
+    for (const t of targets) {
+      if (t?.trim()) targetLocales[t.trim()] = [t.trim()];
+    }
+    const loaderPathLine = "const path = `${TRANSLATION_IMPORT_PATH}/${project}/${language}/${title}.json`;";
+    const loaderWarnLine = "console.warn(`Translations for locale ${language} could not be loaded.`, error);";
+    const loaderBody = `${loaderPathLine}
+  try {
+    const module = await import(path, { with: { type: 'json' } });
+    return module.default;
+  } catch (error) {
+    ${loaderWarnLine}
+    return {
+      title,
+      attributes: { lang: language, dir: '' },
+      notes: [],
+      messages: []
+    };
+  }`;
+    const importPath = relPath.replace(/\\/g, "/");
+    const content = isEsm ? `import { MsgProject } from '@worldware/msg';
+
+const TRANSLATION_IMPORT_PATH = ${JSON.stringify(importPath)};
+const loader = async (project, title, language) => {
+  ${loaderBody}
+};
+
+export default MsgProject.create({
+  project: { name: ${JSON.stringify(projectName)}, version: 1 },
+  locales: {
+    sourceLocale: ${JSON.stringify(source)},
+    pseudoLocale: ${JSON.stringify(pseudoLocale)},
+    targetLocales: ${JSON.stringify(targetLocales)}
+  },
+  loader
+});
+` : `const { MsgProject } = require('@worldware/msg');
+
+const TRANSLATION_IMPORT_PATH = ${JSON.stringify(importPath)};
+const loader = async (project, title, language) => {
+  ${loaderBody}
+};
+
+module.exports = MsgProject.create({
+  project: { name: ${JSON.stringify(projectName)}, version: 1 },
+  locales: {
+    sourceLocale: ${JSON.stringify(source)},
+    pseudoLocale: ${JSON.stringify(pseudoLocale)},
+    targetLocales: ${JSON.stringify(targetLocales)}
+  },
+  loader
+});
+`;
+    this.log("Creating MsgProject file...");
+    writeMsgProjectFile(outPath, content);
+    this.log(`Created ${outPath}`);
+  }
+};

package/dist/commands/create/project.d.mts

@@ -0,0 +1,22 @@
+import * as _oclif_core_lib_interfaces_parser_js from '@oclif/core/lib/interfaces/parser.js';
+import { Command } from '@oclif/core';
+
+/**
+ * Creates a new MsgProject file in the i18n projects directory.
+ */
+declare class CreateProject extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        projectName: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+        source: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+        targets: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        help: _oclif_core_lib_interfaces_parser_js.BooleanFlag<void>;
+        extend: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+
+export { CreateProject as default };

package/dist/commands/create/project.d.ts

@@ -0,0 +1,22 @@
+import * as _oclif_core_lib_interfaces_parser_js from '@oclif/core/lib/interfaces/parser.js';
+import { Command } from '@oclif/core';
+
+/**
+ * Creates a new MsgProject file in the i18n projects directory.
+ */
+declare class CreateProject extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        projectName: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+        source: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+        targets: _oclif_core_lib_interfaces_parser_js.Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        help: _oclif_core_lib_interfaces_parser_js.BooleanFlag<void>;
+        extend: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+
+export { CreateProject as default };