@i18n-auto/core 0.1.1

package/dist/cli.cjs

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+'use strict';
+
+var path = require('path');
+var commander = require('commander');
+var tinyglobby = require('tinyglobby');
+var promises = require('fs/promises');
+var parser = require('@babel/parser');
+var traverseImport = require('@babel/traverse');
+var translate = require('@google-cloud/translate');
+var crypto = require('crypto');
+var fs = require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var traverseImport__default = /*#__PURE__*/_interopDefault(traverseImport);
+
+var traverse = typeof traverseImport__default.default === "function" ? traverseImport__default.default : traverseImport__default.default.default;
+var FUNCTION_NAME = "i18nTranslate";
+var PACKAGE_NAME = "@i18n-auto/core";
+async function extractTranslations(filePaths) {
+  const entries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const fileEntries = await extractFromFile(filePath);
+    for (const entry of fileEntries) {
+      if (seenKeys.has(entry.key)) {
+        continue;
+      }
+      seenKeys.add(entry.key);
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+async function extractFromFile(filePath) {
+  const code = await promises.readFile(filePath, "utf-8");
+  if (!code.includes(FUNCTION_NAME)) {
+    return [];
+  }
+  let ast;
+  try {
+    ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[i18n-auto] Failed to parse ${filePath}: ${message}`);
+    return [];
+  }
+  if (!hasI18nImport(ast)) {
+    return [];
+  }
+  const entries = [];
+  traverse(ast, {
+    CallExpression(path) {
+      const result = extractCall(path.node, filePath);
+      if (result) {
+        entries.push(result);
+      }
+    }
+  });
+  return entries;
+}
+function hasI18nImport(ast) {
+  let found = false;
+  traverse(ast, {
+    ImportDeclaration(path) {
+      if (path.node.source.value !== PACKAGE_NAME) {
+        return;
+      }
+      for (const specifier of path.node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === FUNCTION_NAME) {
+          found = true;
+          path.stop();
+        }
+      }
+    }
+  });
+  return found;
+}
+function extractCall(node, filePath) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== FUNCTION_NAME) {
+    return null;
+  }
+  const args = node.arguments;
+  const line = node.loc?.start.line ?? 0;
+  if (args.length < 2 || args[0].type !== "StringLiteral") {
+    console.warn(
+      `[i18n-auto] Skipping i18nTranslate() at ${filePath}:${line} \u2014 first argument is not a string literal`
+    );
+    return null;
+  }
+  if (args[1].type !== "ObjectExpression") {
+    console.warn(
+      `[i18n-auto] Skipping i18nTranslate() at ${filePath}:${line} \u2014 second argument is not an object`
+    );
+    return null;
+  }
+  const key = extractKeyFromObject(args[1]);
+  if (!key) {
+    console.warn(
+      `[i18n-auto] Skipping i18nTranslate() at ${filePath}:${line} \u2014 missing or non-literal 'key' property`
+    );
+    return null;
+  }
+  const lock = extractLockFromObject(args[1]);
+  return {
+    text: args[0].value,
+    key,
+    lock,
+    filePath,
+    line
+  };
+}
+function extractKeyFromObject(node) {
+  for (const prop of node.properties) {
+    if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "key" && prop.value.type === "StringLiteral") {
+      return prop.value.value;
+    }
+  }
+  return null;
+}
+function extractLockFromObject(node) {
+  for (const prop of node.properties) {
+    if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "lock" && prop.value.type === "BooleanLiteral") {
+      return prop.value.value;
+    }
+  }
+  return false;
+}
+async function extractConfig(filePath) {
+  const code = await promises.readFile(filePath, "utf-8");
+  if (!code.includes("initI18n")) {
+    return null;
+  }
+  let ast;
+  try {
+    ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[i18n-auto] Failed to parse ${filePath}: ${message}`);
+    return null;
+  }
+  if (!hasInitImport(ast)) {
+    return null;
+  }
+  return findInitConfig(ast);
+}
+function hasInitImport(ast) {
+  let found = false;
+  traverse(ast, {
+    ImportDeclaration(path) {
+      if (path.node.source.value !== PACKAGE_NAME) {
+        return;
+      }
+      for (const specifier of path.node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "initI18n") {
+          found = true;
+          path.stop();
+        }
+      }
+    }
+  });
+  return found;
+}
+function findInitConfig(ast) {
+  let config = null;
+  traverse(ast, {
+    CallExpression(path) {
+      if (path.node.callee.type !== "Identifier" || path.node.callee.name !== "initI18n") {
+        return;
+      }
+      const args = path.node.arguments;
+      if (args.length === 0 || args[0].type !== "ObjectExpression") {
+        return;
+      }
+      config = parseConfigObject(args[0]);
+      path.stop();
+    }
+  });
+  return config;
+}
+function parseConfigObject(node) {
+  const config = {};
+  for (const prop of node.properties) {
+    if (prop.type !== "ObjectProperty" || prop.key.type !== "Identifier") {
+      continue;
+    }
+    const name = prop.key.name;
+    const value = prop.value;
+    if (value.type === "StringLiteral") {
+      config[name] = value.value;
+      continue;
+    }
+    if (value.type === "ArrayExpression") {
+      const items = [];
+      for (const element of value.elements) {
+        if (element && element.type === "StringLiteral") {
+          items.push(element.value);
+        }
+      }
+      if (items.length > 0) {
+        config[name] = items;
+      }
+      continue;
+    }
+    if (value.type === "MemberExpression" && value.object.type === "MemberExpression" && value.object.object.type === "Identifier" && value.object.object.name === "process" && value.object.property.type === "Identifier" && value.object.property.name === "env" && value.property.type === "Identifier") {
+      if (name === "apiKey") {
+        config["apiKeyEnvVar"] = value.property.name;
+      }
+      continue;
+    }
+  }
+  return config;
+}
+var GOOGLE_BATCH_LIMIT = 128;
+var GoogleProvider = class {
+  client;
+  /**
+   * @param apiKey - Google Cloud API key for authentication
+   */
+  constructor(apiKey) {
+    this.client = new translate.v2.Translate({ key: apiKey });
+  }
+  /**
+   * Translates an array of strings from one locale to another using Google Translate.
+   * Automatically chunks large arrays to respect API limits.
+   * @param texts - Array of source strings to translate
+   * @param from - Source locale (e.g., 'en')
+   * @param to - Target locale (e.g., 'ur')
+   * @returns Array of translated strings in the same order
+   * @throws Error if the Google Translate API call fails
+   */
+  async translateBatch(texts, from, to) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const protected_ = texts.map((text) => this.protectPlaceholders(text));
+    const protectedTexts = protected_.map((p) => p.protected);
+    const chunks = this.chunk(protectedTexts, GOOGLE_BATCH_LIMIT);
+    const results = [];
+    for (const chunk of chunks) {
+      try {
+        const [translations] = await this.client.translate(chunk, { from, to });
+        const translated = Array.isArray(translations) ? translations : [translations];
+        results.push(...translated);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[i18n-auto] Google Translate API error: ${message}`);
+        throw new Error(`[i18n-auto] Failed to translate batch: ${message}`);
+      }
+    }
+    return results.map(
+      (text, i) => this.restorePlaceholders(text, protected_[i].placeholders)
+    );
+  }
+  /**
+   * Replaces {{placeholder}} patterns with XML tokens that Google Translate preserves.
+   * @param text - The source string containing {{placeholder}} patterns
+   * @returns The protected string and an array of original placeholders
+   */
+  protectPlaceholders(text) {
+    const placeholders = [];
+    const protectedText = text.replace(/\{\{\s*\w+\s*\}\}/g, (match) => {
+      const index = placeholders.length;
+      placeholders.push(match);
+      return `<x${index}>`;
+    });
+    return { protected: protectedText, placeholders };
+  }
+  /**
+   * Restores XML tokens back to original {{placeholder}} patterns.
+   * @param text - The translated string containing XML tokens
+   * @param placeholders - The original placeholder patterns in order
+   * @returns The string with {{placeholder}} patterns restored
+   */
+  restorePlaceholders(text, placeholders) {
+    return text.replace(/<x(\d+)>/g, (_, index) => {
+      return placeholders[Number(index)] ?? `<x${index}>`;
+    });
+  }
+  /**
+   * Splits an array into smaller chunks of a given size.
+   * @param items - Array to split
+   * @param size - Maximum chunk size
+   * @returns Array of chunks
+   */
+  chunk(items, size) {
+    const chunks = [];
+    for (let i = 0; i < items.length; i += size) {
+      chunks.push(items.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+
+// src/providers/provider.factory.ts
+var SUPPORTED_PROVIDERS = ["google"];
+function getSupportedProviders() {
+  return [...SUPPORTED_PROVIDERS];
+}
+function createProvider(name, apiKey) {
+  switch (name) {
+    case "google":
+      return new GoogleProvider(apiKey);
+    default:
+      throw new Error(
+        `[i18n-auto] Provider '${name}' is not supported. Available: ${SUPPORTED_PROVIDERS.join(", ")}`
+      );
+  }
+}
+var FileCache = class {
+  cachePath;
+  /**
+   * @param cachePath - Directory path where locale JSON files are stored
+   */
+  constructor(cachePath) {
+    this.cachePath = cachePath;
+  }
+  /**
+   * Loads all translations for a given locale from its JSON file.
+   * @param locale - The locale to load (e.g., 'ur', 'fr')
+   * @returns Key-value map of translations, or empty object if file doesn't exist
+   */
+  async load(locale) {
+    const filePath = this.getFilePath(locale);
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const content = await promises.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Synchronously loads all translations for a given locale.
+   * Used by the runtime t() method for fast, synchronous lookups.
+   * @param locale - The locale to load
+   * @returns Key-value map of translations, or empty object if file doesn't exist
+   */
+  loadSync(locale) {
+    const filePath = this.getFilePath(locale);
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Saves translations for a locale to its JSON file.
+   * Creates the directory if it doesn't exist.
+   * @param locale - The locale to save
+   * @param data - Key-value map of translations
+   */
+  async save(locale, data) {
+    await promises.mkdir(this.cachePath, { recursive: true });
+    const filePath = this.getFilePath(locale);
+    const content = JSON.stringify(data, null, 2);
+    await promises.writeFile(filePath, content, "utf-8");
+  }
+  /**
+   * Returns the set of keys that already have translations for a locale.
+   * Used by CLI to determine which strings are new and need translating.
+   * @param locale - The locale to check
+   * @returns Set of existing translation keys
+   */
+  async getExistingKeys(locale) {
+    const data = await this.load(locale);
+    return new Set(Object.keys(data));
+  }
+  /**
+   * Computes a short SHA-256 hash of a string.
+   * Used to detect source text changes without storing full text.
+   * @param text - The source text to hash
+   * @returns 8-character hex hash
+   */
+  static hash(text) {
+    return crypto.createHash("sha256").update(text).digest("hex").slice(0, 8);
+  }
+  /**
+   * Loads the metadata file (.meta.json) containing source text hashes.
+   * Used by CLI to detect when source text has changed for an existing key.
+   * @returns Key-value map of translation key to source text hash
+   */
+  async loadMeta() {
+    const filePath = path.join(this.cachePath, ".meta.json");
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const content = await promises.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Saves the metadata file (.meta.json) with updated source text hashes.
+   * @param data - Key-value map of translation key to source text hash
+   */
+  async saveMeta(data) {
+    await promises.mkdir(this.cachePath, { recursive: true });
+    const filePath = path.join(this.cachePath, ".meta.json");
+    const content = JSON.stringify(data, null, 2);
+    await promises.writeFile(filePath, content, "utf-8");
+  }
+  /**
+   * Builds the file path for a locale's JSON file.
+   * @param locale - The locale identifier
+   * @returns Full file path
+   */
+  getFilePath(locale) {
+    return path.join(this.cachePath, `${locale}.json`);
+  }
+};
+
+// src/cli.ts
+var program = new commander.Command();
+program.name("i18n-auto").description("Auto-translate i18n strings by scanning source code").version("0.1.0");
+program.command("translate").description("Scan source files and translate extracted strings").requiredOption("--config <path>", "Path to the file containing initI18n() call").option("--force", "Re-translate all strings, ignoring cache").action(async (options) => {
+  try {
+    await runTranslate(options.config, options.force ?? false);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[i18n-auto] ${message}`);
+    process.exit(1);
+  }
+});
+program.command("stats").description("Show translation statistics per locale").requiredOption("--config <path>", "Path to the file containing initI18n() call").action(async (options) => {
+  try {
+    await runStats(options.config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[i18n-auto] ${message}`);
+    process.exit(1);
+  }
+});
+program.parse();
+var SOURCE_EXTENSIONS = ["ts", "tsx", "js", "jsx"];
+async function readConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  const config = await extractConfig(absolutePath);
+  if (!config) {
+    throw new Error(
+      `No initI18n() call found in ${configPath}. Make sure the file imports initI18n from '@i18n-auto/core'.`
+    );
+  }
+  const provider = config.provider ?? "google";
+  const supported = getSupportedProviders();
+  if (!supported.includes(provider)) {
+    throw new Error(
+      `Provider '${provider}' is not supported. Available: ${supported.join(", ")}`
+    );
+  }
+  if (!config.apiKeyEnvVar) {
+    throw new Error(
+      "No apiKey found in initI18n() config. Use: apiKey: process.env.YOUR_API_KEY"
+    );
+  }
+  const apiKey = process.env[config.apiKeyEnvVar];
+  if (!apiKey) {
+    throw new Error(
+      `Environment variable '${config.apiKeyEnvVar}' is not set. Set it before running the CLI.`
+    );
+  }
+  const locales = config.locales ?? [];
+  if (locales.length === 0) {
+    throw new Error(
+      "No locales found in initI18n() config. Add: locales: ['ur', 'fr', 'de']"
+    );
+  }
+  return {
+    provider,
+    apiKey,
+    defaultLocale: config.defaultLocale ?? "en",
+    cachePath: path.resolve(config.cachePath ?? "./locales"),
+    locales,
+    sourcePath: path.resolve(config.sourcePath ?? "./src")
+  };
+}
+async function runTranslate(configPath, force) {
+  const config = await readConfig(configPath);
+  const patterns = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);
+  const filePaths = await tinyglobby.glob(patterns, {
+    cwd: config.sourcePath,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  if (filePaths.length === 0) {
+    console.warn(`[i18n-auto] No source files found in ${config.sourcePath}`);
+    return;
+  }
+  console.warn(`[i18n-auto] Scanning ${filePaths.length} files...`);
+  const entries = await extractTranslations(filePaths);
+  if (entries.length === 0) {
+    console.warn("[i18n-auto] No i18nTranslate() calls found");
+    return;
+  }
+  const lockedEntries = entries.filter((entry) => entry.lock);
+  const translatableEntries = entries.filter((entry) => !entry.lock);
+  console.warn(`[i18n-auto] Found ${translatableEntries.length} translatable entries`);
+  if (lockedEntries.length > 0) {
+    console.warn(`[i18n-auto] Found ${lockedEntries.length} locked key(s) (manual translation)`);
+  }
+  const provider = createProvider(config.provider, config.apiKey);
+  const cache = new FileCache(config.cachePath);
+  const meta = await cache.loadMeta();
+  const updatedMeta = { ...meta };
+  for (const entry of lockedEntries) {
+    updatedMeta[entry.key] = "locked";
+  }
+  let totalTranslated = 0;
+  for (const locale of config.locales) {
+    if (locale === config.defaultLocale) {
+      console.warn(`[i18n-auto] Skipping source locale '${locale}'`);
+      continue;
+    }
+    const existingData = await cache.load(locale);
+    let lockedAdded = 0;
+    for (const entry of lockedEntries) {
+      if (!(entry.key in existingData)) {
+        existingData[entry.key] = "";
+        lockedAdded++;
+      }
+    }
+    if (lockedAdded > 0) {
+      await cache.save(locale, existingData);
+      console.warn(`[i18n-auto] ${locale}: Added ${lockedAdded} locked key(s) for manual translation`);
+    }
+    let entriesToTranslate;
+    if (force) {
+      entriesToTranslate = translatableEntries;
+      console.warn(`[i18n-auto] ${locale}: Force mode \u2014 re-translating all ${translatableEntries.length} strings...`);
+    } else {
+      const existingKeys = await cache.getExistingKeys(locale);
+      const newEntries = translatableEntries.filter((entry) => !existingKeys.has(entry.key));
+      const changedEntries = translatableEntries.filter(
+        (entry) => existingKeys.has(entry.key) && meta[entry.key] !== void 0 && meta[entry.key] !== "locked" && meta[entry.key] !== FileCache.hash(entry.text)
+      );
+      entriesToTranslate = [...newEntries, ...changedEntries];
+      if (newEntries.length > 0) {
+        console.warn(`[i18n-auto] ${locale}: Translating ${newEntries.length} new strings...`);
+      }
+      if (changedEntries.length > 0) {
+        console.warn(`[i18n-auto] ${locale}: Re-translating ${changedEntries.length} changed strings...`);
+      }
+    }
+    if (entriesToTranslate.length === 0 && lockedAdded === 0) {
+      console.warn(`[i18n-auto] ${locale}: All ${entries.length} strings up to date`);
+      continue;
+    }
+    if (entriesToTranslate.length === 0) {
+      continue;
+    }
+    const textsToTranslate = entriesToTranslate.map((entry) => entry.text);
+    const translated = await provider.translateBatch(textsToTranslate, config.defaultLocale, locale);
+    for (let i = 0; i < entriesToTranslate.length; i++) {
+      existingData[entriesToTranslate[i].key] = translated[i];
+    }
+    await cache.save(locale, existingData);
+    console.warn(`[i18n-auto] ${locale}: Translated ${entriesToTranslate.length} strings`);
+    totalTranslated += entriesToTranslate.length;
+  }
+  for (const entry of translatableEntries) {
+    updatedMeta[entry.key] = FileCache.hash(entry.text);
+  }
+  await cache.saveMeta(updatedMeta);
+  console.warn(
+    `[i18n-auto] Done! Translated ${totalTranslated} strings for ${config.locales.length} locale(s)`
+  );
+}
+async function runStats(configPath) {
+  const config = await readConfig(configPath);
+  const cache = new FileCache(config.cachePath);
+  const patterns = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);
+  const filePaths = await tinyglobby.glob(patterns, {
+    cwd: config.sourcePath,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  const entries = await extractTranslations(filePaths);
+  const totalKeys = entries.length;
+  console.warn(`[i18n-auto] Total translation keys found: ${totalKeys}`);
+  console.warn("");
+  for (const locale of config.locales) {
+    if (locale === config.defaultLocale) {
+      continue;
+    }
+    const existingKeys = await cache.getExistingKeys(locale);
+    const translated = existingKeys.size;
+    const missing = totalKeys - translated;
+    console.warn(
+      `  ${locale}: ${translated}/${totalKeys} translated` + (missing > 0 ? ` (${missing} missing)` : " \u2713")
+    );
+  }
+}
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map