@red-hat-developer-hub/translations-cli 0.0.1

package/dist/commands/generate.cjs.js

@@ -0,0 +1,1294 @@
+'use strict';
+
+var path = require('node:path');
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var glob = require('glob');
+var extractKeys = require('../lib/i18n/extractKeys.cjs.js');
+var generateFiles = require('../lib/i18n/generateFiles.cjs.js');
+var mergeFiles = require('../lib/i18n/mergeFiles.cjs.js');
+var config = require('../lib/i18n/config.cjs.js');
+var exec = require('../lib/utils/exec.cjs.js');
+var deployTranslations = require('../lib/i18n/deployTranslations.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var glob__default = /*#__PURE__*/_interopDefaultCompat(glob);
+
+function detectRepoName(repoPath) {
+  const targetPath = repoPath || process.cwd();
+  try {
+    const gitRepoUrl = exec.safeExecSyncOrThrow(
+      "git",
+      ["config", "--get", "remote.origin.url"],
+      {
+        cwd: targetPath
+      }
+    );
+    if (gitRepoUrl) {
+      let repoName = gitRepoUrl.replace(/\.git$/, "");
+      const lastSlashIndex = repoName.lastIndexOf("/");
+      if (lastSlashIndex >= 0) {
+        repoName = repoName.substring(lastSlashIndex + 1);
+      }
+      if (repoName) {
+        return repoName;
+      }
+    }
+  } catch {
+  }
+  return path__default.default.basename(targetPath);
+}
+function isNestedStructure(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const firstKey = Object.keys(data)[0];
+  if (!firstKey) return false;
+  const firstValue = data[firstKey];
+  return typeof firstValue === "object" && firstValue !== null && "en" in firstValue;
+}
+const LANGUAGE_CODES = [
+  "de",
+  "es",
+  "fr",
+  "it",
+  "ja",
+  "ko",
+  "pt",
+  "zh",
+  "ru",
+  "ar",
+  "hi",
+  "nl",
+  "pl",
+  "sv",
+  "tr",
+  "uk",
+  "vi"
+];
+function isLanguageFile(fileName) {
+  const isNonEnglishLanguage = LANGUAGE_CODES.some((code) => {
+    if (fileName === code) return true;
+    if (fileName.endsWith(`-${code}`)) return true;
+    if (fileName.includes(`.${code}.`) || fileName.includes(`-${code}-`)) {
+      return true;
+    }
+    return false;
+  });
+  return isNonEnglishLanguage && !fileName.includes("-en") && fileName !== "en";
+}
+function isEnglishReferenceFile(filePath, content) {
+  const fileName = path__default.default.basename(filePath, path__default.default.extname(filePath));
+  const fullFileName = path__default.default.basename(filePath);
+  if (isLanguageFile(fileName)) {
+    return false;
+  }
+  const hasCreateTranslationRef = content.includes("createTranslationRef") && (content.includes("from '@backstage/core-plugin-api/alpha'") || content.includes("from '@backstage/frontend-plugin-api'"));
+  const isEnglishFile = fullFileName.endsWith("-en.ts") || fullFileName.endsWith("-en.tsx") || fullFileName === "en.ts" || fullFileName === "en.tsx" || fileName.endsWith("-en") || fileName === "en";
+  const hasCreateTranslationMessagesWithRef = isEnglishFile && content.includes("createTranslationMessages") && content.includes("ref:") && (content.includes("from '@backstage/core-plugin-api/alpha'") || content.includes("from '@backstage/frontend-plugin-api'"));
+  return hasCreateTranslationRef || hasCreateTranslationMessagesWithRef;
+}
+async function findEnglishReferenceFiles(sourceDir, includePattern, excludePattern) {
+  const allSourceFiles = glob__default.default.sync(includePattern, {
+    cwd: sourceDir,
+    ignore: excludePattern,
+    absolute: true
+  });
+  const sourceFiles = [];
+  for (const filePath of allSourceFiles) {
+    try {
+      const content = await fs__default.default.readFile(filePath, "utf-8");
+      if (isEnglishReferenceFile(filePath, content)) {
+        sourceFiles.push(filePath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return sourceFiles;
+}
+async function findJsonTranslationFiles(sourceDir) {
+  const repoRoot = process.cwd();
+  const jsonPatterns = [
+    // Patterns relative to sourceDir
+    "**/translations/**/*.json",
+    "packages/app/src/translations/**/*.json",
+    "packages/app/translations/**/*.json",
+    // Patterns at repo root level (for RHDH repo)
+    "translations/**/*-en.json",
+    "translations/**/*en*.json"
+  ];
+  const jsonFiles = [];
+  for (const pattern of jsonPatterns) {
+    try {
+      const filesFromSource = glob__default.default.sync(pattern, {
+        cwd: sourceDir,
+        ignore: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/test/**"
+        ],
+        absolute: true
+      });
+      jsonFiles.push(...filesFromSource);
+      if (pattern.startsWith("translations/")) {
+        const filesFromRoot = glob__default.default.sync(pattern, {
+          cwd: repoRoot,
+          ignore: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/test/**"
+          ],
+          absolute: true
+        });
+        jsonFiles.push(...filesFromRoot);
+      }
+    } catch {
+      continue;
+    }
+  }
+  const uniqueFiles = Array.from(new Set(jsonFiles));
+  const englishJsonFiles = [];
+  for (const filePath of uniqueFiles) {
+    const fileName = path__default.default.basename(filePath, ".json").toLowerCase();
+    if (fileName.includes("en") || fileName.includes("reference")) {
+      if (!isLanguageFile(fileName.replace(/en|reference/gi, ""))) {
+        englishJsonFiles.push(filePath);
+      }
+    }
+  }
+  return englishJsonFiles;
+}
+function pathContainsTranslationsOrI18n(filePath) {
+  if (filePath.includes("/translations/") || filePath.includes("/i18n/")) {
+    return true;
+  }
+  const fileName = path__default.default.basename(filePath).toLowerCase();
+  const translationFileNames = [
+    "translation.ts",
+    "ref.ts",
+    "translationref.ts",
+    "messages.ts",
+    "data.json",
+    "alpha.ts"
+  ];
+  if (translationFileNames.some(
+    (name) => fileName === name || fileName.endsWith(name)
+  )) {
+    return true;
+  }
+  return false;
+}
+function isNonEnglishLanguageFile(filePath) {
+  const languageCodes = [
+    "de",
+    // German
+    "fr",
+    // French
+    "es",
+    // Spanish
+    "it",
+    // Italian
+    "ja",
+    // Japanese
+    "zh",
+    // Chinese
+    "pt",
+    // Portuguese
+    "ru",
+    // Russian
+    "ko",
+    // Korean
+    "nl",
+    // Dutch
+    "sv",
+    // Swedish
+    "pl",
+    // Polish
+    "cs",
+    // Czech
+    "tr",
+    // Turkish
+    "ar",
+    // Arabic
+    "he",
+    // Hebrew
+    "hi"
+    // Hindi
+  ];
+  const fileName = filePath.toLowerCase();
+  for (const lang of languageCodes) {
+    if (fileName.includes(`.${lang}.`) || fileName.includes(`-${lang}.`) || fileName.includes(`_${lang}.`)) {
+      return true;
+    }
+    if (fileName.includes(`/translations/${lang}/`) || fileName.includes(`/i18n/${lang}/`) || fileName.includes(`\\translations\\${lang}\\`) || fileName.includes(`\\i18n\\${lang}\\`)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function findBackstagePluginTranslationRefs(backstageRepoPath) {
+  if (!await fs__default.default.pathExists(backstageRepoPath)) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Backstage repository path does not exist: ${backstageRepoPath}`
+      )
+    );
+    return [];
+  }
+  const patterns = [
+    // plugins/ directory structure (simpler structure: plugins/{name}/src/translation.ts)
+    "plugins/*/src/translation.ts",
+    "plugins/*/src/ref.ts",
+    "plugins/*/src/translationRef.ts",
+    "plugins/*/src/messages.ts",
+    "plugins/*/src/data.json",
+    "plugins/*/src/**/translation.ts",
+    "plugins/*/src/**/ref.ts",
+    "plugins/*/src/**/translationRef.ts",
+    "plugins/*/src/**/messages.ts",
+    "plugins/*/src/**/data.json",
+    "plugins/*/src/**/alpha.ts",
+    // plugins/ directory structure (packages subdirectory: plugins/*/packages/plugin-*/...)
+    "plugins/*/packages/plugin-*/**/translation.ts",
+    "plugins/*/packages/plugin-*/**/ref.ts",
+    "plugins/*/packages/plugin-*/**/translationRef.ts",
+    "plugins/*/packages/plugin-*/**/messages.ts",
+    "plugins/*/packages/plugin-*/**/data.json",
+    "plugins/*/packages/core-*/**/translation.ts",
+    "plugins/*/packages/core-*/**/ref.ts",
+    "plugins/*/packages/core-*/**/translationRef.ts",
+    "plugins/*/packages/core-*/**/messages.ts",
+    "plugins/*/packages/core-*/**/data.json",
+    // packages/ directory structure
+    "packages/plugin-*/**/translation.ts",
+    "packages/plugin-*/**/ref.ts",
+    "packages/plugin-*/**/translationRef.ts",
+    "packages/plugin-*/**/messages.ts",
+    "packages/plugin-*/**/data.json",
+    "packages/core-*/**/translation.ts",
+    "packages/core-*/**/ref.ts",
+    "packages/core-*/**/translationRef.ts",
+    "packages/core-*/**/messages.ts",
+    "packages/core-*/**/data.json",
+    // workspaces/ directory structure
+    "workspaces/*/packages/plugin-*/**/translation.ts",
+    "workspaces/*/packages/plugin-*/**/ref.ts",
+    "workspaces/*/packages/plugin-*/**/translationRef.ts",
+    "workspaces/*/packages/plugin-*/**/messages.ts",
+    "workspaces/*/packages/plugin-*/**/data.json",
+    "workspaces/*/packages/core-*/**/translation.ts",
+    "workspaces/*/packages/core-*/**/ref.ts",
+    "workspaces/*/packages/core-*/**/translationRef.ts",
+    "workspaces/*/packages/core-*/**/messages.ts",
+    "workspaces/*/packages/core-*/**/data.json",
+    // Also check for alpha.ts files (some plugins export refs from alpha.ts)
+    "plugins/*/packages/plugin-*/**/alpha.ts",
+    "plugins/*/packages/core-*/**/alpha.ts",
+    "packages/plugin-*/**/alpha.ts",
+    "packages/core-*/**/alpha.ts",
+    "workspaces/*/packages/plugin-*/**/alpha.ts",
+    "workspaces/*/packages/core-*/**/alpha.ts"
+  ];
+  const pluginRefFiles = [];
+  for (const pattern of patterns) {
+    try {
+      const files = glob__default.default.sync(pattern, {
+        cwd: backstageRepoPath,
+        ignore: [
+          "**/build/**",
+          "**/dist/**",
+          "**/node_modules/**",
+          "**/*.test.ts",
+          "**/*.spec.ts",
+          "**/*.test.d.ts",
+          "**/*.spec.d.ts"
+        ],
+        absolute: true
+      });
+      const filteredFiles = files.filter(
+        (file) => pathContainsTranslationsOrI18n(file) && !isNonEnglishLanguageFile(file)
+      );
+      pluginRefFiles.push(...filteredFiles);
+    } catch {
+      continue;
+    }
+  }
+  return Array.from(new Set(pluginRefFiles));
+}
+function extractBackstagePluginName(filePath) {
+  const normalizePluginName = (name) => {
+    return name.endsWith("-react") ? name.replace(/-react$/, "") : name;
+  };
+  const simplePluginsMatch = /plugins\/([^/]+)\//.exec(filePath);
+  if (simplePluginsMatch && filePath.includes("/src/")) {
+    return normalizePluginName(simplePluginsMatch[1]);
+  }
+  const pluginsMatch = /plugins\/([^/]+)\/packages\/plugin-([^/]+)/.exec(
+    filePath
+  );
+  if (pluginsMatch) {
+    return normalizePluginName(pluginsMatch[2]);
+  }
+  const packagesPluginMatch = /packages\/plugin-([^/]+)/.exec(filePath);
+  if (packagesPluginMatch) {
+    return normalizePluginName(packagesPluginMatch[1]);
+  }
+  const packagesCoreMatch = /packages\/core-([^/]+)/.exec(filePath);
+  if (packagesCoreMatch) {
+    return `core-${packagesCoreMatch[1]}`;
+  }
+  const workspacesMatch = /workspaces\/([^/]+)\/packages\/plugin-([^/]+)/.exec(
+    filePath
+  );
+  if (workspacesMatch) {
+    return normalizePluginName(workspacesMatch[2]);
+  }
+  const nodeModulesPluginMatch = /@backstage\/plugin-([^/]+)/.exec(filePath);
+  if (nodeModulesPluginMatch) {
+    return normalizePluginName(nodeModulesPluginMatch[1]);
+  }
+  const nodeModulesCoreMatch = /@backstage\/core-([^/]+)/.exec(filePath);
+  if (nodeModulesCoreMatch) {
+    return `core-${nodeModulesCoreMatch[1]}`;
+  }
+  return null;
+}
+function buildPackageName(pluginName) {
+  return pluginName.startsWith("core-") ? `@backstage/${pluginName}` : `@backstage/plugin-${pluginName}`;
+}
+async function checkPackageJsonDependencies(packageJsonPath, packageName) {
+  if (!await fs__default.default.pathExists(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = await fs__default.default.readJson(packageJsonPath);
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+      ...packageJson.peerDependencies
+    };
+    return packageName in allDeps;
+  } catch {
+    return false;
+  }
+}
+function buildPackagePatterns(pluginName, packageName) {
+  const patterns = [
+    packageName,
+    `backstage-plugin-${pluginName}`,
+    `backstage/core-${pluginName.replace("core-", "")}`,
+    `backstage-plugin-${pluginName}-react`,
+    `plugin-${pluginName}-react`,
+    packageName.replace("@backstage/", "")
+  ];
+  if (pluginName === "home" || pluginName === "home-react") {
+    patterns.push("dynamic-home-page");
+    patterns.push("backstage-plugin-dynamic-home-page");
+  }
+  return patterns;
+}
+function buildPluginIdPatterns(pluginName) {
+  return [
+    `backstage.plugin-${pluginName}`,
+    `backstage.core-${pluginName.replace("core-", "")}`
+  ];
+}
+function matchesPackagePattern(line, pattern) {
+  if (line.includes("backend") || line.includes("module")) {
+    return false;
+  }
+  if (line.includes(pattern)) {
+    return true;
+  }
+  return line.includes(`./dynamic-plugins/dist/${pattern}`) || line.includes(`dynamic-plugins/dist/${pattern}`);
+}
+function matchesPluginIdPattern(trimmedLine, pattern) {
+  return trimmedLine.includes(`"${pattern}"`) || trimmedLine.includes(`'${pattern}'`);
+}
+function parseDynamicPluginsFile(content, packagePatterns, pluginIdPatterns) {
+  const lines = content.split("\n");
+  const pluginEntries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmedLine = line.trim();
+    const matchesPackage = packagePatterns.some(
+      (pattern) => matchesPackagePattern(line, pattern)
+    );
+    const matchesPluginId = pluginIdPatterns.some(
+      (pattern) => matchesPluginIdPattern(trimmedLine, pattern)
+    );
+    if (matchesPackage || matchesPluginId && trimmedLine.startsWith("backstage.")) {
+      pluginEntries.push({ startLine: i, disabled: null });
+    }
+    for (const entry of pluginEntries) {
+      if (i >= entry.startLine && i < entry.startLine + 10) {
+        if (trimmedLine.startsWith("disabled:")) {
+          entry.disabled = trimmedLine.includes("disabled: false") ? false : trimmedLine.includes("disabled: true");
+        }
+      }
+    }
+  }
+  return pluginEntries.some(
+    (entry) => entry.disabled === false || entry.disabled === null
+  );
+}
+async function checkDynamicPlugins(repoRoot, pluginName, packageName) {
+  const dynamicPluginsPath = path__default.default.join(
+    repoRoot,
+    "dynamic-plugins.default.yaml"
+  );
+  if (!await fs__default.default.pathExists(dynamicPluginsPath)) {
+    return false;
+  }
+  try {
+    const content = await fs__default.default.readFile(dynamicPluginsPath, "utf-8");
+    const packagePatterns = buildPackagePatterns(pluginName, packageName);
+    const pluginIdPatterns = buildPluginIdPatterns(pluginName);
+    return parseDynamicPluginsFile(content, packagePatterns, pluginIdPatterns);
+  } catch {
+    return false;
+  }
+}
+async function checkSourceCodeImports(repoRoot, packageName) {
+  const searchPatterns = [
+    `packages/app/src/**/*.{ts,tsx,js,jsx}`,
+    `packages/app/src/**/*.tsx`,
+    `src/**/*.{ts,tsx,js,jsx}`
+  ];
+  for (const pattern of searchPatterns) {
+    try {
+      const files = glob__default.default.sync(pattern, {
+        cwd: repoRoot,
+        ignore: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/*.test.*",
+          "**/*.spec.*"
+        ],
+        absolute: true
+      });
+      for (const file of files.slice(0, 50)) {
+        try {
+          const content = await fs__default.default.readFile(file, "utf-8");
+          if (content.includes(`from '${packageName}'`) || content.includes(`from "${packageName}"`) || content.includes(`require('${packageName}')`) || content.includes(`require("${packageName}")`) || content.includes(`'${packageName}'`) || content.includes(`"${packageName}"`)) {
+            return true;
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+async function isPluginUsedInRhdh(pluginName, repoRoot) {
+  const packageName = buildPackageName(pluginName);
+  const nodeModulesPath = path__default.default.join(repoRoot, "node_modules", packageName);
+  if (!await fs__default.default.pathExists(nodeModulesPath)) {
+    return false;
+  }
+  const packageJsonPath = path__default.default.join(repoRoot, "package.json");
+  if (await checkPackageJsonDependencies(packageJsonPath, packageName)) {
+    return true;
+  }
+  const appPackageJsonPath = path__default.default.join(
+    repoRoot,
+    "packages",
+    "app",
+    "package.json"
+  );
+  if (await checkPackageJsonDependencies(appPackageJsonPath, packageName)) {
+    return true;
+  }
+  if (await checkDynamicPlugins(repoRoot, pluginName, packageName)) {
+    return true;
+  }
+  if (await checkSourceCodeImports(repoRoot, packageName)) {
+    return true;
+  }
+  return false;
+}
+function findLanguageData(pluginData, isCorePlugins) {
+  if ("en" in pluginData && typeof pluginData.en === "object" && pluginData.en !== null) {
+    return pluginData.en;
+  }
+  if (isCorePlugins) {
+    for (const [, langData] of Object.entries(pluginData)) {
+      if (typeof langData === "object" && langData !== null) {
+        return langData;
+      }
+    }
+  } else {
+    for (const [lang, langData] of Object.entries(pluginData)) {
+      if (typeof langData === "object" && langData !== null && lang !== "en") {
+        return langData;
+      }
+    }
+  }
+  return null;
+}
+function extractKeysFromLanguageData(languageData, isCorePlugins, hasEnglish) {
+  const keys = {};
+  for (const [key, value] of Object.entries(languageData)) {
+    if (typeof value === "string") {
+      keys[key] = isCorePlugins && !hasEnglish ? key : value;
+    }
+  }
+  return keys;
+}
+function extractNestedStructure(data, isCorePlugins) {
+  const result = {};
+  for (const [pluginName, pluginData] of Object.entries(data)) {
+    if (typeof pluginData !== "object" || pluginData === null) {
+      continue;
+    }
+    const languageData = findLanguageData(
+      pluginData,
+      isCorePlugins
+    );
+    if (languageData) {
+      const hasEnglish = "en" in pluginData;
+      result[pluginName] = extractKeysFromLanguageData(
+        languageData,
+        isCorePlugins,
+        hasEnglish
+      );
+    }
+  }
+  return result;
+}
+function extractFlatStructure(data, filePath) {
+  const translations = typeof data === "object" && data !== null && "translations" in data ? data.translations : data;
+  if (typeof translations !== "object" || translations === null) {
+    return {};
+  }
+  const pluginName = detectPluginName(filePath) || "translations";
+  const result = {};
+  result[pluginName] = {};
+  for (const [key, value] of Object.entries(translations)) {
+    if (typeof value === "string") {
+      result[pluginName][key] = value;
+    }
+  }
+  return result;
+}
+async function extractKeysFromJsonFile(filePath, isCorePlugins = false) {
+  try {
+    const content = await fs__default.default.readFile(filePath, "utf-8");
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null) {
+      const nestedResult = extractNestedStructure(
+        data,
+        isCorePlugins
+      );
+      if (Object.keys(nestedResult).length > 0) {
+        return nestedResult;
+      }
+    }
+    return extractFlatStructure(data, filePath);
+  } catch (error) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: Could not extract keys from JSON file ${filePath}: ${error}`
+      )
+    );
+    return {};
+  }
+}
+function detectPluginName(filePath) {
+  const workspaceRegex = /workspaces\/([^/]+)\/plugins\/([^/]+)/;
+  const workspaceMatch = workspaceRegex.exec(filePath);
+  if (workspaceMatch) {
+    return workspaceMatch[2];
+  }
+  const translationsRegex = /translations\/([^/]+)\//;
+  const translationsMatch = translationsRegex.exec(filePath);
+  if (translationsMatch) {
+    return translationsMatch[1];
+  }
+  const dirName = path__default.default.dirname(filePath);
+  const parentDir = path__default.default.basename(dirName);
+  if (parentDir === "translations" || parentDir.includes("translation")) {
+    const grandParentDir = path__default.default.basename(path__default.default.dirname(dirName));
+    return grandParentDir;
+  }
+  return parentDir;
+}
+const INVALID_PLUGIN_NAMES = /* @__PURE__ */ new Set([
+  "dist",
+  "build",
+  "node_modules",
+  "packages",
+  "src",
+  "lib",
+  "components",
+  "utils"
+]);
+function validatePluginName(pluginName, filePath) {
+  if (!pluginName) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: Could not determine plugin name for ${path__default.default.relative(
+          process.cwd(),
+          filePath
+        )}, skipping`
+      )
+    );
+    return false;
+  }
+  if (INVALID_PLUGIN_NAMES.has(pluginName.toLowerCase())) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: Skipping invalid plugin name "${pluginName}" from ${path__default.default.relative(
+          process.cwd(),
+          filePath
+        )}`
+      )
+    );
+    return false;
+  }
+  return true;
+}
+function mergeKeysIntoPluginGroup(pluginGroups, pluginName, keys, filePath) {
+  if (!pluginGroups[pluginName]) {
+    pluginGroups[pluginName] = {};
+  }
+  const overwrittenKeys = [];
+  for (const [key, value] of Object.entries(keys)) {
+    const stringValue = String(value);
+    if (pluginGroups[pluginName][key] && pluginGroups[pluginName][key] !== stringValue) {
+      overwrittenKeys.push(key);
+    }
+    pluginGroups[pluginName][key] = stringValue;
+  }
+  if (overwrittenKeys.length > 0) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  Warning: ${overwrittenKeys.length} keys were overwritten in plugin "${pluginName}" from ${path__default.default.relative(
+          process.cwd(),
+          filePath
+        )}`
+      )
+    );
+  }
+}
+async function processSourceFile(filePath, pluginGroups) {
+  try {
+    const content = await fs__default.default.readFile(filePath, "utf-8");
+    const extractResult = extractKeys.extractTranslationKeys(content, filePath);
+    const keys = extractResult.keys;
+    const pluginName = extractResult.pluginId || detectPluginName(filePath);
+    if (!validatePluginName(pluginName, filePath)) {
+      return;
+    }
+    mergeKeysIntoPluginGroup(pluginGroups, pluginName, keys, filePath);
+  } catch (error) {
+    console.warn(
+      chalk__default.default.yellow(`\u26A0\uFE0F  Warning: Could not process ${filePath}: ${error}`)
+    );
+  }
+}
+function convertToStructuredData(pluginGroups) {
+  const structuredData = {};
+  for (const [pluginName, keys] of Object.entries(pluginGroups)) {
+    structuredData[pluginName] = { en: keys };
+  }
+  return structuredData;
+}
+async function extractAndGroupKeys(sourceFiles) {
+  const pluginGroups = {};
+  for (const filePath of sourceFiles) {
+    await processSourceFile(filePath, pluginGroups);
+  }
+  return convertToStructuredData(pluginGroups);
+}
+async function generateOrMergeFiles(translationKeys, outputPath, formatStr, mergeExisting) {
+  if (mergeExisting && await fs__default.default.pathExists(outputPath)) {
+    console.log(chalk__default.default.yellow(`\u{1F504} Merging with existing ${outputPath}...`));
+    await mergeFiles.mergeTranslationFiles(translationKeys, outputPath, formatStr);
+  } else {
+    console.log(chalk__default.default.yellow(`\u{1F4DD} Generating ${outputPath}...`));
+    await generateFiles.generateTranslationFiles(translationKeys, outputPath, formatStr);
+  }
+}
+async function validateGeneratedFile(outputPath, formatStr) {
+  if (formatStr !== "json") {
+    return;
+  }
+  console.log(chalk__default.default.yellow(`\u{1F50D} Validating generated file...`));
+  const { validateTranslationFile } = await import('../lib/i18n/validateFile.cjs.js');
+  const isValid = await validateTranslationFile(outputPath);
+  if (!isValid) {
+    throw new Error(`Generated file failed validation: ${outputPath}`);
+  }
+  console.log(chalk__default.default.green(`\u2705 Generated file is valid`));
+}
+function displaySummary(translationKeys) {
+  console.log(chalk__default.default.blue("\n\u{1F4CB} Included Plugins Summary:"));
+  console.log(chalk__default.default.gray("\u2500".repeat(60)));
+  const plugins = Object.entries(translationKeys).map(([pluginName, pluginData]) => ({
+    name: pluginName,
+    keyCount: Object.keys(pluginData.en || {}).length
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  let totalKeys = 0;
+  for (const plugin of plugins) {
+    const keyLabel = plugin.keyCount === 1 ? "key" : "keys";
+    console.log(
+      chalk__default.default.cyan(
+        `  \u2022 ${plugin.name.padEnd(35)} ${chalk__default.default.yellow(
+          plugin.keyCount.toString().padStart(4)
+        )} ${keyLabel}`
+      )
+    );
+    totalKeys += plugin.keyCount;
+  }
+  console.log(chalk__default.default.gray("\u2500".repeat(60)));
+  const pluginLabel = plugins.length === 1 ? "plugin" : "plugins";
+  const totalKeyLabel = totalKeys === 1 ? "key" : "keys";
+  console.log(
+    chalk__default.default.cyan(
+      `  Total: ${chalk__default.default.yellow(
+        plugins.length.toString()
+      )} ${pluginLabel}, ${chalk__default.default.yellow(
+        totalKeys.toString()
+      )} ${totalKeyLabel}`
+    )
+  );
+  console.log("");
+}
+function validateSprintOptions(outputFilename, sprint) {
+  if (!outputFilename && !sprint) {
+    throw new Error(
+      "--sprint is required. Please provide a sprint value (e.g., --sprint s3285)"
+    );
+  }
+  if (sprint && !/^s?\d+$/i.test(sprint)) {
+    throw new Error(
+      `Invalid sprint format: "${sprint}". Sprint should be in format "s3285" or "3285"`
+    );
+  }
+}
+function getBackstageRepoPath(opts, config) {
+  return opts.backstageRepoPath || config.backstageRepoPath || process.env.BACKSTAGE_REPO_PATH || null;
+}
+function mapPluginName(pluginName, refFile) {
+  let mapped = pluginName.replace(/^plugin-/, "");
+  if (pluginName === "plugin-home-react" || refFile.includes("home-react")) {
+    mapped = "home-react";
+  } else if (pluginName === "plugin-home") {
+    mapped = "home";
+  }
+  return mapped;
+}
+async function extractKeysFromDataJson(refFile) {
+  const keys = {};
+  const jsonContent = await fs__default.default.readJson(refFile);
+  if (typeof jsonContent === "object" && jsonContent !== null) {
+    for (const [key, value] of Object.entries(jsonContent)) {
+      if (typeof value === "string") {
+        keys[key] = value;
+      } else if (typeof value === "object" && value !== null && "defaultMessage" in value) {
+        keys[key] = value.defaultMessage;
+      }
+    }
+  }
+  const pluginName = extractBackstagePluginName(refFile);
+  return { keys, pluginName };
+}
+async function extractKeysFromRefFile(refFile) {
+  if (refFile.endsWith("data.json")) {
+    return extractKeysFromDataJson(refFile);
+  }
+  const content = await fs__default.default.readFile(refFile, "utf-8");
+  const extractResult = extractKeys.extractTranslationKeys(content, refFile);
+  const pluginName = extractResult.pluginId || extractBackstagePluginName(refFile);
+  return { keys: extractResult.keys, pluginName };
+}
+async function checkPluginUsage(pluginRefFiles, rhdhRepoPath) {
+  const usedPlugins = /* @__PURE__ */ new Set();
+  const unusedPlugins = /* @__PURE__ */ new Set();
+  for (const refFile of pluginRefFiles) {
+    try {
+      const pluginName = extractBackstagePluginName(refFile);
+      if (!pluginName) continue;
+      const mappedPluginName = mapPluginName(pluginName, refFile);
+      const isUsed = await isPluginUsedInRhdh(mappedPluginName, rhdhRepoPath);
+      if (isUsed) {
+        usedPlugins.add(mappedPluginName);
+      } else {
+        unusedPlugins.add(mappedPluginName);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { usedPlugins, unusedPlugins };
+}
+async function extractKeysFromCorePluginRefs(pluginRefFiles, shouldFilterByUsage, usedPlugins, communityPluginsRoot) {
+  const structuredData = {};
+  const isCommunityPluginsRepo = communityPluginsRoot && pluginRefFiles.some(
+    (file) => file.includes("workspaces/") && file.includes("/plugins/") && !file.includes("/packages/")
+  );
+  let filteredCount = 0;
+  for (const refFile of pluginRefFiles) {
+    try {
+      const { keys, pluginName } = await extractKeysFromRefFile(refFile);
+      if (!pluginName || Object.keys(keys).length === 0) {
+        continue;
+      }
+      const mappedPluginName = mapPluginName(pluginName, refFile);
+      if (isCommunityPluginsRepo && communityPluginsRoot) {
+        if (!deployTranslations.isRedHatOwnedPlugin(mappedPluginName, communityPluginsRoot)) {
+          filteredCount++;
+          continue;
+        }
+      }
+      if (shouldFilterByUsage && !usedPlugins.has(mappedPluginName)) {
+        continue;
+      }
+      if (!structuredData[mappedPluginName]) {
+        structuredData[mappedPluginName] = { en: {} };
+      }
+      for (const [key, value] of Object.entries(keys)) {
+        if (!structuredData[mappedPluginName].en[key]) {
+          structuredData[mappedPluginName].en[key] = value;
+        }
+      }
+    } catch (error) {
+      console.warn(
+        chalk__default.default.yellow(
+          `\u26A0\uFE0F  Warning: Could not extract from ${refFile}: ${error}`
+        )
+      );
+    }
+  }
+  if (isCommunityPluginsRepo && filteredCount > 0) {
+    console.log(
+      chalk__default.default.gray(
+        `  Filtered out ${filteredCount} non-Red Hat owned plugin(s) from community-plugins repo`
+      )
+    );
+  }
+  return structuredData;
+}
+function filterTranslatedFiles(files, outputDirPath, outputFileName) {
+  return files.filter((file) => {
+    const fileName = path__default.default.basename(file);
+    if (file.startsWith(outputDirPath) && fileName === outputFileName) {
+      return false;
+    }
+    if (fileName.includes("reference") || fileName.includes("core-plugins-reference")) {
+      return false;
+    }
+    return true;
+  });
+}
+async function findCorePluginsTranslatedFiles(repoRoot, outputDir) {
+  const corePluginsJsonPatterns = [
+    "translations/core-plugins*.json",
+    "translations/**/core-plugins*.json"
+  ];
+  const translatedFiles = [];
+  const outputDirPath = path__default.default.resolve(repoRoot, String(outputDir || "i18n"));
+  const outputFileName = "core-plugins-reference.json";
+  for (const pattern of corePluginsJsonPatterns) {
+    try {
+      const files = glob__default.default.sync(pattern, {
+        cwd: repoRoot,
+        ignore: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/test/**"
+        ],
+        absolute: true
+      });
+      const filteredFiles = filterTranslatedFiles(
+        files,
+        outputDirPath,
+        outputFileName
+      );
+      translatedFiles.push(...filteredFiles);
+    } catch {
+    }
+  }
+  return translatedFiles;
+}
+async function extractKeysFromTranslatedFiles(translatedFiles, repoRoot) {
+  const structuredData = {};
+  for (const translatedFile of translatedFiles) {
+    console.log(
+      chalk__default.default.gray(`  Processing: ${path__default.default.relative(repoRoot, translatedFile)}`)
+    );
+    const translatedKeys = await extractKeysFromJsonFile(translatedFile, true);
+    const totalKeys = Object.values(translatedKeys).reduce(
+      (sum, keys) => sum + Object.keys(keys).length,
+      0
+    );
+    const pluginCount = Object.keys(translatedKeys).length;
+    console.log(
+      chalk__default.default.gray(
+        `    Extracted ${totalKeys} keys from ${pluginCount} plugin${pluginCount !== 1 ? "s" : ""}`
+      )
+    );
+    for (const [pluginName, pluginKeys] of Object.entries(translatedKeys)) {
+      if (!structuredData[pluginName]) {
+        structuredData[pluginName] = {};
+      }
+      for (const [key, value] of Object.entries(pluginKeys)) {
+        if (!structuredData[pluginName][key]) {
+          structuredData[pluginName][key] = value;
+        }
+      }
+    }
+  }
+  return structuredData;
+}
+async function processCorePlugins(backstageRepoPath, repoRoot, outputDir) {
+  console.log(
+    chalk__default.default.yellow(
+      `\u{1F4C1} Scanning Backstage plugin packages in: ${backstageRepoPath}`
+    )
+  );
+  const pluginRefFiles = await findBackstagePluginTranslationRefs(
+    backstageRepoPath
+  );
+  console.log(
+    chalk__default.default.gray(
+      `Found ${pluginRefFiles.length} Backstage plugin translation ref files`
+    )
+  );
+  const structuredData = {};
+  if (pluginRefFiles.length === 0) {
+    return structuredData;
+  }
+  const rhdhRepoPath = process.env.RHDH_REPO_PATH || null;
+  const shouldFilterByUsage = Boolean(rhdhRepoPath);
+  let usedPlugins = /* @__PURE__ */ new Set();
+  if (shouldFilterByUsage) {
+    console.log(
+      chalk__default.default.yellow(`\u{1F50D} Checking which plugins are actually used in RHDH...`)
+    );
+    const { usedPlugins: checkedUsed, unusedPlugins } = await checkPluginUsage(
+      pluginRefFiles,
+      rhdhRepoPath
+    );
+    usedPlugins = checkedUsed;
+    if (unusedPlugins.size > 0) {
+      console.log(
+        chalk__default.default.gray(
+          `  Skipping ${unusedPlugins.size} unused plugin(s): ${Array.from(
+            unusedPlugins
+          ).slice(0, 5).join(", ")}${unusedPlugins.size > 5 ? "..." : ""}`
+        )
+      );
+    }
+    console.log(
+      chalk__default.default.gray(`  Found ${usedPlugins.size} plugin(s) actually used in RHDH`)
+    );
+  } else {
+    console.log(
+      chalk__default.default.yellow(
+        `\u{1F4E6} Extracting all Backstage core plugins (RHDH_REPO_PATH not set, skipping usage filter)...`
+      )
+    );
+  }
+  const isCommunityPluginsRepo = pluginRefFiles.some(
+    (file) => file.includes("workspaces/") && file.includes("/plugins/") && !file.includes("/packages/")
+  );
+  const communityPluginsRoot = isCommunityPluginsRepo ? backstageRepoPath : null;
+  if (isCommunityPluginsRepo) {
+    console.log(
+      chalk__default.default.yellow(
+        `\u{1F50D} Detected community-plugins repo - filtering to Red Hat owned plugins only...`
+      )
+    );
+  }
+  const refData = await extractKeysFromCorePluginRefs(
+    pluginRefFiles,
+    shouldFilterByUsage,
+    usedPlugins,
+    communityPluginsRoot
+  );
+  Object.assign(structuredData, refData);
+  const pluginCount = Object.keys(structuredData).length;
+  if (isCommunityPluginsRepo) {
+    console.log(
+      chalk__default.default.green(
+        `\u2705 Extracted keys from ${pluginCount} Red Hat owned plugin(s) in community-plugins repo`
+      )
+    );
+  } else {
+    console.log(
+      chalk__default.default.green(
+        `\u2705 Extracted keys from ${usedPlugins.size} Backstage plugin packages used in RHDH`
+      )
+    );
+  }
+  const translatedFiles = await findCorePluginsTranslatedFiles(
+    repoRoot,
+    outputDir
+  );
+  if (translatedFiles.length > 0) {
+    console.log(
+      chalk__default.default.yellow(
+        `\u{1F4C1} Scanning ${translatedFiles.length} existing core-plugins file(s) to extract translation keys...`
+      )
+    );
+    const translatedData = await extractKeysFromTranslatedFiles(
+      translatedFiles,
+      repoRoot
+    );
+    let filteredTranslatedCount = 0;
+    for (const [pluginName, pluginKeys] of Object.entries(translatedData)) {
+      if (isCommunityPluginsRepo && communityPluginsRoot) {
+        if (!deployTranslations.isRedHatOwnedPlugin(pluginName, communityPluginsRoot)) {
+          filteredTranslatedCount++;
+          continue;
+        }
+      }
+      if (!structuredData[pluginName]) {
+        structuredData[pluginName] = { en: {} };
+      }
+      for (const [key, value] of Object.entries(pluginKeys)) {
+        if (!structuredData[pluginName].en[key]) {
+          structuredData[pluginName].en[key] = value;
+        }
+      }
+    }
+    if (isCommunityPluginsRepo && filteredTranslatedCount > 0) {
+      console.log(
+        chalk__default.default.gray(
+          `  Filtered out ${filteredTranslatedCount} non-Red Hat owned plugin(s) from translated files`
+        )
+      );
+    }
+    console.log(
+      chalk__default.default.green(
+        `\u2705 Extracted keys from ${translatedFiles.length} existing core-plugins translation file(s)`
+      )
+    );
+  }
+  return structuredData;
+}
+function filterRhdhPlugins(rhdhData) {
+  const backstageCorePlugins = /* @__PURE__ */ new Set([
+    "home",
+    "catalog-graph",
+    "api-docs",
+    "kubernetes",
+    "kubernetes-cluster",
+    "techdocs",
+    "home-react",
+    "catalog-react",
+    "org",
+    "search-react",
+    "kubernetes-react",
+    "scaffolder-react"
+  ]);
+  const rhdhPlugins = {};
+  for (const [pluginName, pluginData] of Object.entries(rhdhData)) {
+    if (!backstageCorePlugins.has(pluginName) || pluginName === "catalog" || pluginName === "scaffolder" || pluginName === "search" || pluginName === "core-components" || pluginName === "catalog-import" || pluginName === "user-settings") {
+      rhdhPlugins[pluginName] = pluginData;
+    }
+  }
+  return rhdhPlugins;
+}
+async function processRhdhPlugins(sourceDir, includePattern, excludePattern) {
+  console.log(chalk__default.default.yellow(`\u{1F4C1} Scanning ${sourceDir} for translation keys...`));
+  const allSourceFiles = glob__default.default.sync(includePattern, {
+    cwd: sourceDir,
+    ignore: excludePattern,
+    absolute: true
+  });
+  const sourceFiles = await findEnglishReferenceFiles(
+    sourceDir,
+    includePattern,
+    excludePattern
+  );
+  console.log(
+    chalk__default.default.gray(
+      `Found ${allSourceFiles.length} files, ${sourceFiles.length} are English reference files`
+    )
+  );
+  const rhdhData = await extractAndGroupKeys(sourceFiles);
+  console.log(chalk__default.default.yellow(`\u{1F4C1} Scanning for JSON translation files...`));
+  const jsonFiles = await findJsonTranslationFiles(sourceDir);
+  console.log(chalk__default.default.gray(`Found ${jsonFiles.length} JSON translation files`));
+  if (jsonFiles.length > 0) {
+    for (const jsonFile of jsonFiles) {
+      const jsonKeys = await extractKeysFromJsonFile(jsonFile);
+      for (const [pluginName, keys] of Object.entries(jsonKeys)) {
+        if (!rhdhData[pluginName]) {
+          rhdhData[pluginName] = { en: {} };
+        }
+        for (const [key, value] of Object.entries(keys)) {
+          if (!rhdhData[pluginName].en[key]) {
+            rhdhData[pluginName].en[key] = value;
+          }
+        }
+      }
+    }
+    console.log(
+      chalk__default.default.green(
+        `\u2705 Merged keys from ${jsonFiles.length} JSON translation files`
+      )
+    );
+  }
+  return filterRhdhPlugins(rhdhData);
+}
+function generateFilename(outputFilename, sprint, corePlugins, backstageRepoPath) {
+  if (outputFilename) {
+    return outputFilename.replace(/\.json$/, "");
+  }
+  if (!sprint) {
+    throw new Error(
+      "Sprint value is required. Please provide --sprint option (e.g., --sprint s3285)"
+    );
+  }
+  const normalizedSprint = sprint.startsWith("s") || sprint.startsWith("S") ? sprint.toLowerCase() : `s${sprint}`;
+  const repoName = corePlugins && backstageRepoPath ? detectRepoName(backstageRepoPath) : detectRepoName();
+  return `${repoName.toLowerCase()}-${normalizedSprint}`;
+}
+function getOutputDirectory(corePlugins, backstageRepoPath, outputDir) {
+  if (corePlugins && backstageRepoPath) {
+    return path__default.default.join(backstageRepoPath, "i18n");
+  }
+  return String(outputDir || "i18n");
+}
+async function generateCommand(opts) {
+  const corePlugins = Boolean(opts.corePlugins) || opts.corePlugins === "true";
+  const outputFilename = opts.outputFilename;
+  const sprint = opts.sprint;
+  validateSprintOptions(outputFilename, sprint);
+  if (corePlugins) {
+    console.log(
+      chalk__default.default.blue("\u{1F30D} Generating core-plugins translation reference file...")
+    );
+  } else {
+    console.log(chalk__default.default.blue("\u{1F30D} Generating RHDH translation reference file..."));
+  }
+  const config$1 = await config.loadI18nConfig();
+  const mergedOpts = await config.mergeConfigWithOptions(config$1, opts);
+  const {
+    sourceDir = "src",
+    outputDir = "i18n",
+    format = "json",
+    includePattern = "**/*.{ts,tsx,js,jsx}",
+    excludePattern = "**/node_modules/**",
+    extractKeys = true,
+    mergeExisting = false
+  } = mergedOpts;
+  try {
+    await fs__default.default.ensureDir(outputDir);
+    const translationKeys = {};
+    const backstageRepoPath = getBackstageRepoPath(opts, config$1);
+    if (extractKeys) {
+      const repoRoot = process.cwd();
+      let structuredData;
+      if (corePlugins) {
+        if (!backstageRepoPath) {
+          console.error(
+            chalk__default.default.red(
+              "\u274C Backstage repository path is required for --core-plugins mode"
+            )
+          );
+          console.error(
+            chalk__default.default.yellow(
+              '   Please provide one of:\n     1. --backstage-repo-path <path>\n     2. Add "backstageRepoPath" to .i18n.config.json\n     3. Set BACKSTAGE_REPO_PATH environment variable'
+            )
+          );
+          process.exit(1);
+        }
+        structuredData = await processCorePlugins(
+          backstageRepoPath,
+          repoRoot,
+          outputDir
+        );
+        console.log(
+          chalk__default.default.gray(
+            `  Including all ${Object.keys(structuredData).length} core plugins (including React versions with unique translations)`
+          )
+        );
+      } else {
+        structuredData = await processRhdhPlugins(
+          sourceDir,
+          includePattern,
+          excludePattern
+        );
+      }
+      const totalKeys = Object.values(structuredData).reduce(
+        (sum, pluginData) => sum + Object.keys(pluginData.en || {}).length,
+        0
+      );
+      console.log(
+        chalk__default.default.green(
+          `\u2705 Extracted ${totalKeys} translation keys from ${Object.keys(structuredData).length} plugins`
+        )
+      );
+      Object.assign(translationKeys, structuredData);
+    }
+    const formatStr = String(format || "json");
+    const filename = generateFilename(
+      outputFilename,
+      sprint,
+      corePlugins,
+      backstageRepoPath
+    );
+    const finalOutputDir = getOutputDirectory(
+      corePlugins,
+      backstageRepoPath,
+      outputDir
+    );
+    if (corePlugins && backstageRepoPath) {
+      await fs__default.default.ensureDir(finalOutputDir);
+    }
+    const outputPath = path__default.default.join(finalOutputDir, `${filename}.${formatStr}`);
+    await generateOrMergeFiles(
+      translationKeys,
+      outputPath,
+      formatStr,
+      mergeExisting
+    );
+    await validateGeneratedFile(outputPath, formatStr);
+    if (extractKeys && isNestedStructure(translationKeys)) {
+      displaySummary(
+        translationKeys
+      );
+    }
+    console.log(
+      chalk__default.default.green(`\u2705 Translation reference files generated successfully!`)
+    );
+    console.log(chalk__default.default.gray(`   Output: ${outputPath}`));
+    if (extractKeys && isNestedStructure(translationKeys)) {
+      const totalKeys = Object.values(
+        translationKeys
+      ).reduce(
+        (sum, pluginData) => sum + Object.keys(pluginData.en || {}).length,
+        0
+      );
+      console.log(
+        chalk__default.default.gray(`   Plugins: ${Object.keys(translationKeys).length}`)
+      );
+      console.log(chalk__default.default.gray(`   Keys: ${totalKeys}`));
+    } else {
+      console.log(
+        chalk__default.default.gray(`   Keys: ${Object.keys(translationKeys).length}`)
+      );
+    }
+  } catch (error) {
+    console.error(chalk__default.default.red("\u274C Error generating translation files:"), error);
+    throw error;
+  }
+}
+
+exports.generateCommand = generateCommand;
+//# sourceMappingURL=generate.cjs.js.map