@better-intl/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,571 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var compiler = require('@better-intl/compiler');
+var ink = require('ink');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var core = require('@better-intl/core');
+
+// src/commands.ts
+async function resolveFiles(patterns, exclude, cwd) {
+  const files = [];
+  for (const pattern of patterns) {
+    for await (const entry of promises.glob(pattern, { cwd })) {
+      const filePath = path.resolve(cwd, entry);
+      const rel = path.relative(cwd, filePath);
+      const isExcluded = exclude.some((ex) => {
+        const regex = new RegExp(
+          ex.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
+        );
+        return regex.test(rel);
+      });
+      if (!isExcluded) {
+        files.push(filePath);
+      }
+    }
+  }
+  return [...new Set(files)];
+}
+async function extractAllMessages(config, cwd) {
+  const files = await resolveFiles(config.include, config.exclude, cwd);
+  const allMessages = [];
+  for (const file of files) {
+    const source = await promises.readFile(file, "utf-8");
+    const relPath = path.relative(cwd, file);
+    allMessages.push(...compiler.extract(source, { filePath: relPath }));
+  }
+  return allMessages;
+}
+async function loadAllCatalogs(config, cwd) {
+  const catalogs = {};
+  for (const locale of config.locales) {
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    try {
+      catalogs[locale] = JSON.parse(await promises.readFile(catalogPath, "utf-8"));
+    } catch {
+      catalogs[locale] = {};
+    }
+  }
+  return catalogs;
+}
+async function getTranslationsData(config, cwd) {
+  const allMessages = await extractAllMessages(config, cwd);
+  const catalogs = await loadAllCatalogs(config, cwd);
+  const extractedIds = new Set(allMessages.map((m) => m.id));
+  const manualKeys = /* @__PURE__ */ new Set();
+  for (const messages of Object.values(catalogs)) {
+    for (const key of Object.keys(messages)) {
+      if (!extractedIds.has(key)) {
+        manualKeys.add(key);
+      }
+    }
+  }
+  const extracted = allMessages.map((msg) => {
+    const translations = {};
+    for (const locale of config.locales) {
+      if (msg.id in (catalogs[locale] ?? {})) {
+        translations[locale] = catalogs[locale][msg.id];
+      }
+    }
+    return {
+      id: msg.id,
+      source: `${msg.filePath}:${msg.line} <${msg.elementType}>`,
+      default: msg.defaultMessage,
+      translations
+    };
+  });
+  const manual = [...manualKeys].map((key) => {
+    const translations = {};
+    for (const locale of config.locales) {
+      if (key in (catalogs[locale] ?? {})) {
+        translations[locale] = catalogs[locale][key];
+      }
+    }
+    return { key, translations };
+  });
+  return {
+    locales: config.locales,
+    defaultLocale: config.defaultLocale,
+    extracted,
+    manual
+  };
+}
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+function pad(text, width) {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+function Header({ data }) {
+  const totalKeys = data.extracted.length + data.manual.length;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { bold: true, children: [
+      "better-intl ",
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "dashboard" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
+      totalKeys,
+      " keys \xB7 ",
+      data.locales.length,
+      " locales \xB7",
+      " ",
+      data.extracted.length,
+      " extracted \xB7 ",
+      data.manual.length,
+      " manual"
+    ] })
+  ] });
+}
+function StatusIcon({ has, isDefault }) {
+  if (isDefault) return /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "\u2500" });
+  if (has) return /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "green", children: "\u2713" });
+  return /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "red", children: "\u2717" });
+}
+function ExtractedTable({ data }) {
+  if (data.extracted.length === 0) return null;
+  const sourceWidth = 28;
+  const defaultWidth = 22;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "gray", children: "EXTRACTED FROM SOURCE" }),
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
+      pad("Source", sourceWidth),
+      " ",
+      pad("Default", defaultWidth),
+      " ",
+      data.locales.map((l) => pad(l, 8)).join("")
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "\u2500".repeat(sourceWidth + defaultWidth + data.locales.length * 8 + 2) }),
+    data.extracted.map((msg) => /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "cyan", children: [
+        pad(truncate(msg.source, sourceWidth), sourceWidth),
+        " "
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
+        pad(truncate(msg.default, defaultWidth), defaultWidth),
+        " "
+      ] }),
+      data.locales.map((locale) => /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { width: 8, children: /* @__PURE__ */ jsxRuntime.jsx(
+        StatusIcon,
+        {
+          has: !!msg.translations[locale],
+          isDefault: locale === data.defaultLocale
+        }
+      ) }, locale))
+    ] }, msg.id))
+  ] });
+}
+function ManualTable({ data }) {
+  if (data.manual.length === 0) return null;
+  const keyWidth = 32;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "gray", children: "MANUAL KEYS" }),
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
+      pad("Key", keyWidth),
+      " ",
+      data.locales.map((l) => pad(l, 8)).join("")
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "\u2500".repeat(keyWidth + data.locales.length * 8 + 1) }),
+    data.manual.map((msg) => /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "magenta", children: [
+        pad(truncate(msg.key, keyWidth), keyWidth),
+        " "
+      ] }),
+      data.locales.map((locale) => /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { width: 8, children: /* @__PURE__ */ jsxRuntime.jsx(StatusIcon, { has: !!msg.translations[locale], isDefault: false }) }, locale))
+    ] }, msg.key))
+  ] });
+}
+function Coverage({ data }) {
+  const totalKeys = data.extracted.length + data.manual.length;
+  if (totalKeys === 0) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "gray", children: "COVERAGE" }),
+    data.locales.map((locale) => {
+      const isDefault = locale === data.defaultLocale;
+      const translated = isDefault ? totalKeys : data.extracted.filter((m) => m.translations[locale]).length + data.manual.filter((m) => m.translations[locale]).length;
+      const pct = Math.round(translated / totalKeys * 100);
+      const barWidth = 20;
+      const filled = Math.round(pct / 100 * barWidth);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+      const color = pct === 100 ? "green" : pct >= 50 ? "yellow" : "red";
+      return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: pad(locale, 8) }),
+        /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color, children: bar }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color, bold: true, children: [
+          pct,
+          "%"
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
+          "(",
+          translated,
+          "/",
+          totalKeys,
+          ")"
+        ] })
+      ] }, locale);
+    })
+  ] });
+}
+function App({ config, cwd }) {
+  const { exit } = ink.useApp();
+  const [data, setData] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  ink.useInput((input) => {
+    if (input === "q") exit();
+  });
+  react.useEffect(() => {
+    getTranslationsData(config, cwd).then(setData).catch((err) => setError(String(err)));
+  }, [config, cwd]);
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "red", bold: true, children: "Error loading translations" }),
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "red", children: error })
+    ] });
+  }
+  if (!data) {
+    return /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { padding: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "Loading translations\u2026" }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Header, { data }),
+    /* @__PURE__ */ jsxRuntime.jsx(ExtractedTable, { data }),
+    /* @__PURE__ */ jsxRuntime.jsx(ManualTable, { data }),
+    /* @__PURE__ */ jsxRuntime.jsx(Coverage, { data }),
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { marginTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { dimColor: true, children: "Press q to exit" }) })
+  ] });
+}
+async function devCommand(config, cwd) {
+  const instance = ink.render(/* @__PURE__ */ jsxRuntime.jsx(App, { config, cwd }));
+  await instance.waitUntilExit();
+}
+
+// src/commands.ts
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+function logHeader(msg) {
+  console.log(`
+\u2726 ${msg}
+`);
+}
+async function resolveFiles2(patterns, exclude, cwd) {
+  const files = [];
+  for (const pattern of patterns) {
+    for await (const entry of promises.glob(pattern, { cwd })) {
+      const filePath = path.resolve(cwd, entry);
+      const rel = path.relative(cwd, filePath);
+      const isExcluded = exclude.some((ex) => {
+        const regex = new RegExp(
+          ex.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
+        );
+        return regex.test(rel);
+      });
+      if (!isExcluded) {
+        files.push(filePath);
+      }
+    }
+  }
+  return [...new Set(files)];
+}
+async function extractAllMessages2(config, cwd) {
+  const files = await resolveFiles2(config.include, config.exclude, cwd);
+  const allMessages = [];
+  for (const file of files) {
+    const source = await promises.readFile(file, "utf-8");
+    const relPath = path.relative(cwd, file);
+    allMessages.push(...compiler.extract(source, { filePath: relPath }));
+  }
+  return allMessages;
+}
+async function loadAllCatalogs2(config, cwd) {
+  const catalogs = {};
+  for (const locale of config.locales) {
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    try {
+      catalogs[locale] = JSON.parse(await promises.readFile(catalogPath, "utf-8"));
+    } catch {
+      catalogs[locale] = {};
+    }
+  }
+  return catalogs;
+}
+async function extractCommand(config, cwd) {
+  logHeader("Extracting messages...");
+  const allMessages = await extractAllMessages2(config, cwd);
+  log(`Extracted ${allMessages.length} messages`);
+  for (const locale of config.locales) {
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    await promises.mkdir(path.dirname(catalogPath), { recursive: true });
+    let existing = {};
+    try {
+      existing = JSON.parse(await promises.readFile(catalogPath, "utf-8"));
+    } catch {
+    }
+    if (locale === config.defaultLocale) {
+      compiler.generateDefaultCatalog(allMessages);
+      const { messages, added, removed } = compiler.mergeCatalog(existing, allMessages);
+      await promises.writeFile(catalogPath, `${JSON.stringify(messages, null, 2)}
+`);
+      log(
+        `${locale}: ${Object.keys(messages).length} keys (${added.length} added, ${removed.length} removed)`
+      );
+    } else {
+      const { messages, added } = compiler.mergeCatalog(existing, allMessages);
+      await promises.writeFile(catalogPath, `${JSON.stringify(messages, null, 2)}
+`);
+      log(
+        `${locale}: ${Object.keys(messages).length} keys (${added.length} need translation)`
+      );
+    }
+  }
+  logHeader("Done!");
+}
+async function validateCommand(config, cwd) {
+  logHeader("Validating catalogs...");
+  const defaultPath = path.resolve(
+    cwd,
+    config.catalogs.replace("{locale}", config.defaultLocale)
+  );
+  let defaultCatalog;
+  try {
+    defaultCatalog = JSON.parse(await promises.readFile(defaultPath, "utf-8"));
+  } catch {
+    console.error(`  \u2717 Default catalog not found: ${defaultPath}`);
+    console.error("  Run 'i18n extract' first.");
+    process.exitCode = 1;
+    return;
+  }
+  let hasErrors = false;
+  for (const locale of config.locales) {
+    if (locale === config.defaultLocale) continue;
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    try {
+      const catalog = JSON.parse(
+        await promises.readFile(catalogPath, "utf-8")
+      );
+      const missing = compiler.findMissingKeys(defaultCatalog, catalog);
+      if (missing.length > 0) {
+        log(`\u2717 ${locale}: ${missing.length} missing keys`);
+        for (const key of missing.slice(0, 5)) {
+          log(`  - ${key}: "${defaultCatalog[key]}"`);
+        }
+        if (missing.length > 5) {
+          log(`  ... and ${missing.length - 5} more`);
+        }
+        hasErrors = true;
+      } else {
+        log(`\u2713 ${locale}: complete`);
+      }
+    } catch {
+      log(`\u2717 ${locale}: catalog not found`);
+      hasErrors = true;
+    }
+  }
+  if (hasErrors) {
+    process.exitCode = 1;
+  } else {
+    logHeader("All catalogs valid!");
+  }
+}
+async function deadKeysCommand(config, cwd) {
+  logHeader("Finding dead keys...");
+  const allMessages = await extractAllMessages2(config, cwd);
+  const catalogs = await loadAllCatalogs2(config, cwd);
+  for (const locale of config.locales) {
+    const catalog = catalogs[locale];
+    const dead = compiler.findDeadKeys(catalog, allMessages);
+    if (dead.length > 0) {
+      log(`${locale}: ${dead.length} dead keys`);
+      for (const key of dead) {
+        log(`  - ${key}`);
+      }
+    } else {
+      log(`${locale}: no dead keys`);
+    }
+  }
+}
+async function missingCommand(config, cwd) {
+  logHeader("Finding missing translations...");
+  const defaultPath = path.resolve(
+    cwd,
+    config.catalogs.replace("{locale}", config.defaultLocale)
+  );
+  let defaultCatalog;
+  try {
+    defaultCatalog = JSON.parse(await promises.readFile(defaultPath, "utf-8"));
+  } catch {
+    console.error("  Default catalog not found. Run 'i18n extract' first.");
+    process.exitCode = 1;
+    return;
+  }
+  for (const locale of config.locales) {
+    if (locale === config.defaultLocale) continue;
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    try {
+      const catalog = JSON.parse(
+        await promises.readFile(catalogPath, "utf-8")
+      );
+      const missing = compiler.findMissingKeys(defaultCatalog, catalog);
+      log(`${locale}: ${missing.length} missing`);
+    } catch {
+      log(`${locale}: catalog not found (all keys missing)`);
+    }
+  }
+}
+async function compileCommand(config, cwd) {
+  logHeader("Compiling catalogs...");
+  const outDir = path.resolve(cwd, ".better-intl");
+  await promises.mkdir(outDir, { recursive: true });
+  for (const locale of config.locales) {
+    const catalogPath = path.resolve(
+      cwd,
+      config.catalogs.replace("{locale}", locale)
+    );
+    try {
+      const catalog = JSON.parse(
+        await promises.readFile(catalogPath, "utf-8")
+      );
+      const compiled = `export default ${JSON.stringify(catalog)};
+`;
+      const outPath = path.resolve(outDir, `${locale}.js`);
+      await promises.writeFile(outPath, compiled);
+      log(`${locale}: ${Object.keys(catalog).length} keys \u2192 ${outPath}`);
+    } catch {
+      log(`${locale}: catalog not found, skipping`);
+    }
+  }
+  logHeader("Done!");
+}
+async function showCommand(config, cwd) {
+  logHeader("Translation Status");
+  const allMessages = await extractAllMessages2(config, cwd);
+  const catalogs = await loadAllCatalogs2(config, cwd);
+  const extractedIds = new Set(allMessages.map((m) => m.id));
+  const manualKeys = /* @__PURE__ */ new Set();
+  for (const messages of Object.values(catalogs)) {
+    for (const key of Object.keys(messages)) {
+      if (!extractedIds.has(key)) {
+        manualKeys.add(key);
+      }
+    }
+  }
+  if (allMessages.length > 0) {
+    log("Extracted messages (from source)");
+    log("\u2500".repeat(76));
+    const localeHeaders = config.locales.map((l) => padRight(l, 20)).join("");
+    log(
+      `  ${padRight("Source", 28)} ${padRight("Default", 22)} ${localeHeaders}`
+    );
+    log("\u2500".repeat(76));
+    for (const msg of allMessages) {
+      const source = truncate2(
+        `${msg.filePath}:${msg.line} <${msg.elementType}>`,
+        26
+      );
+      const defaultText = truncate2(msg.defaultMessage, 20);
+      const localeCells = config.locales.map((locale) => {
+        const catalog = catalogs[locale] ?? {};
+        if (!(msg.id in catalog)) return padRight("\u2717 MISSING", 20);
+        if (locale === config.defaultLocale) return padRight("\u2713", 20);
+        const val = catalog[msg.id];
+        if (val === msg.defaultMessage) return padRight("~ untranslated", 20);
+        return padRight(`\u2713 ${truncate2(val, 16)}`, 20);
+      }).join("");
+      log(
+        `  ${padRight(source, 28)} ${padRight(defaultText, 22)} ${localeCells}`
+      );
+    }
+    log("\u2500".repeat(76));
+    const extractedCounts = config.locales.map((locale) => {
+      const catalog = catalogs[locale] ?? {};
+      const found = allMessages.filter((m) => m.id in catalog).length;
+      return `${locale}: ${found}/${allMessages.length}`;
+    }).join("  ");
+    log(`  ${allMessages.length} extracted  |  ${extractedCounts}`);
+    console.log();
+  }
+  if (manualKeys.size > 0) {
+    log("Manual keys");
+    log("\u2500".repeat(76));
+    const localeHeaders = config.locales.map((l) => padRight(l, 24)).join("");
+    log(`  ${padRight("Key", 24)} ${localeHeaders}`);
+    log("\u2500".repeat(76));
+    for (const key of manualKeys) {
+      const localeCells = config.locales.map((locale) => {
+        const catalog = catalogs[locale] ?? {};
+        if (!(key in catalog)) return padRight("\u2717 MISSING", 24);
+        return padRight(truncate2(catalog[key], 22), 24);
+      }).join("");
+      log(`  ${padRight(key, 24)} ${localeCells}`);
+    }
+    log("\u2500".repeat(76));
+    const manualCounts = config.locales.map((locale) => {
+      const catalog = catalogs[locale] ?? {};
+      const found = [...manualKeys].filter((k) => k in catalog).length;
+      return `${locale}: ${found}/${manualKeys.size}`;
+    }).join("  ");
+    log(`  ${manualKeys.size} manual  |  ${manualCounts}`);
+    console.log();
+  }
+  const total = allMessages.length + manualKeys.size;
+  logHeader(`Total: ${total} keys, ${config.locales.length} locales`);
+}
+function truncate2(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return `${text.slice(0, maxLen - 3)}...`;
+}
+function padRight(text, width) {
+  if (text.length >= width) return text.slice(0, width);
+  return text + " ".repeat(width - text.length);
+}
+var CONFIG_FILES = [
+  "better-intl.config.json",
+  "better-intl.config.js",
+  ".better-intlrc.json"
+];
+async function loadConfig(cwd = process.cwd()) {
+  for (const file of CONFIG_FILES) {
+    const path$1 = path.resolve(cwd, file);
+    try {
+      const raw = await promises.readFile(path$1, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { ...core.DEFAULT_CONFIG, ...parsed };
+    } catch {
+    }
+  }
+  try {
+    const pkgPath = path.resolve(cwd, "package.json");
+    const pkg = JSON.parse(await promises.readFile(pkgPath, "utf-8"));
+    if (pkg["better-intl"]) {
+      return { ...core.DEFAULT_CONFIG, ...pkg["better-intl"] };
+    }
+  } catch {
+  }
+  return core.DEFAULT_CONFIG;
+}
+
+exports.compileCommand = compileCommand;
+exports.deadKeysCommand = deadKeysCommand;
+exports.devCommand = devCommand;
+exports.extractCommand = extractCommand;
+exports.loadConfig = loadConfig;
+exports.missingCommand = missingCommand;
+exports.showCommand = showCommand;
+exports.validateCommand = validateCommand;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map