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

package/dist/lib/i18n/deployTranslations.cjs.js

@@ -0,0 +1,1213 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('node:path');
+var os = require('node:os');
+var chalk = require('chalk');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+function findRefImportPath(translationDir) {
+  if (fs__default.default.existsSync(path__default.default.join(translationDir, "ref.ts"))) {
+    return "./ref";
+  }
+  if (fs__default.default.existsSync(path__default.default.join(translationDir, "translations.ts"))) {
+    return "./translations";
+  }
+  return "./ref";
+}
+function extractRefInfo(filePath) {
+  try {
+    const content = fs__default.default.readFileSync(filePath, "utf-8");
+    const refImportMatch = content.match(
+      /import\s*{\s*(\w+TranslationRef)\s*}\s*from\s*['"]([^'"]+)['"]/
+    );
+    if (!refImportMatch) {
+      return null;
+    }
+    const refImportName = refImportMatch[1];
+    let refImportPath = refImportMatch[2];
+    if (refImportPath.startsWith("./")) {
+      const translationDir = path__default.default.dirname(filePath);
+      const expectedFile = path__default.default.join(
+        translationDir,
+        `${refImportPath.replace("./", "")}.ts`
+      );
+      if (!fs__default.default.existsSync(expectedFile)) {
+        refImportPath = findRefImportPath(translationDir);
+      }
+    }
+    let variableMatch = content.match(
+      /const\s+(\w+Translation(?:It|Ja|De|Fr|Es))\s*=/
+    );
+    if (!variableMatch) {
+      variableMatch = content.match(
+        /const\s+([a-z]+)\s*=\s*createTranslationMessages/
+      );
+    }
+    if (!variableMatch) {
+      return null;
+    }
+    const variableName = variableMatch[1];
+    return { refImportName, refImportPath, variableName };
+  } catch {
+    return null;
+  }
+}
+function getPluginPackageImport(pluginName) {
+  const pluginPackageMap = {
+    search: "@backstage/plugin-search/alpha",
+    "user-settings": "@backstage/plugin-user-settings/alpha",
+    scaffolder: "@backstage/plugin-scaffolder/alpha",
+    "core-components": "@backstage/core-components/alpha",
+    "catalog-import": "@backstage/plugin-catalog-import/alpha",
+    catalog: "@backstage/plugin-catalog-react/alpha"
+  };
+  return pluginPackageMap[pluginName] || null;
+}
+function sanitizePluginName(pluginName) {
+  if (pluginName.includes(".")) {
+    const parts = pluginName.split(".");
+    return parts[parts.length - 1];
+  }
+  return pluginName.split("-").map(
+    (word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
+  ).join("");
+}
+function inferRefInfo(pluginName, lang, repoType, translationDir) {
+  const sanitized = sanitizePluginName(pluginName);
+  const refImportName = `${sanitized}TranslationRef`;
+  const langCapitalized = lang.charAt(0).toUpperCase() + lang.slice(1);
+  const variableName = `${sanitized}Translation${langCapitalized}`;
+  let refImportPath = "./ref";
+  if (repoType === "rhdh") {
+    const packageImport = getPluginPackageImport(pluginName);
+    if (packageImport) {
+      refImportPath = packageImport;
+    }
+  } else if (translationDir) {
+    refImportPath = findRefImportPath(translationDir);
+  }
+  return { refImportName, refImportPath, variableName };
+}
+function detectRepoType(repoRoot) {
+  const workspacesDir = path__default.default.join(repoRoot, "workspaces");
+  const packagesDir = path__default.default.join(repoRoot, "packages");
+  const pluginsDir = path__default.default.join(repoRoot, "plugins");
+  if (fs__default.default.existsSync(workspacesDir)) {
+    const repoName = path__default.default.basename(repoRoot);
+    if (repoName === "community-plugins") {
+      return "community-plugins";
+    }
+    return "rhdh-plugins";
+  }
+  if (fs__default.default.existsSync(packagesDir)) {
+    const appDir = path__default.default.join(packagesDir, "app");
+    if (fs__default.default.existsSync(appDir)) {
+      return "rhdh";
+    }
+  }
+  if (fs__default.default.existsSync(pluginsDir)) {
+    const repoName = path__default.default.basename(repoRoot);
+    if (repoName === "backstage") {
+      return "backstage";
+    }
+  }
+  return "unknown";
+}
+function findPluginInWorkspaces(pluginName, repoRoot) {
+  const workspacesDir = path__default.default.join(repoRoot, "workspaces");
+  if (!fs__default.default.existsSync(workspacesDir)) {
+    return null;
+  }
+  const cleanPluginName = pluginName.replace(/^plugin\./, "");
+  const workspaceDirs = fs__default.default.readdirSync(workspacesDir);
+  for (const workspace of workspaceDirs) {
+    const pluginsDir = path__default.default.join(
+      workspacesDir,
+      workspace,
+      "plugins",
+      cleanPluginName,
+      "src",
+      "translations"
+    );
+    if (fs__default.default.existsSync(pluginsDir)) {
+      return pluginsDir;
+    }
+  }
+  return null;
+}
+function findPluginInRhdh(pluginName, repoRoot) {
+  const searchPaths = [
+    // Standard location: packages/app/src/translations/{plugin}/
+    path__default.default.join(repoRoot, "packages", "app", "src", "translations", pluginName),
+    // Alternative location: packages/app/src/components/{plugin}/translations/
+    path__default.default.join(
+      repoRoot,
+      "packages",
+      "app",
+      "src",
+      "components",
+      pluginName,
+      "translations"
+    )
+  ];
+  for (const searchPath of searchPaths) {
+    if (fs__default.default.existsSync(searchPath)) {
+      const refFile = path__default.default.join(searchPath, "ref.ts");
+      const translationsFile = path__default.default.join(searchPath, "translations.ts");
+      if (fs__default.default.existsSync(refFile) || fs__default.default.existsSync(translationsFile)) {
+        return searchPath;
+      }
+    }
+  }
+  const appSrcDir = path__default.default.join(repoRoot, "packages", "app", "src");
+  if (fs__default.default.existsSync(appSrcDir)) {
+    const findTranslationDir = (dir, depth = 0) => {
+      if (depth > 3) return null;
+      try {
+        const entries = fs__default.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const subDir = path__default.default.join(dir, entry.name);
+            const langFiles = fs__default.default.readdirSync(subDir).filter(
+              (f) => /^(fr|it|ja|de|es|ko|zh|pt|ru|ar|hi|nl|pl|sv)\.ts$/.test(f)
+            );
+            if (langFiles.length > 0) {
+              const refFile = path__default.default.join(subDir, "ref.ts");
+              const translationsFile = path__default.default.join(subDir, "translations.ts");
+              if (fs__default.default.existsSync(refFile) || fs__default.default.existsSync(translationsFile)) {
+                const sampleLangFile = path__default.default.join(subDir, langFiles[0]);
+                try {
+                  const content = fs__default.default.readFileSync(sampleLangFile, "utf-8");
+                  const pluginRefPattern = new RegExp(
+                    `(?:${pluginName}|${pluginName.replace(
+                      /-/g,
+                      ""
+                    )})TranslationRef`,
+                    "i"
+                  );
+                  if (pluginRefPattern.test(content)) {
+                    return subDir;
+                  }
+                } catch {
+                }
+              }
+            }
+            const found = findTranslationDir(subDir, depth + 1);
+            if (found) return found;
+          }
+        }
+      } catch {
+      }
+      return null;
+    };
+    const foundDir = findTranslationDir(appSrcDir);
+    if (foundDir) {
+      return foundDir;
+    }
+  }
+  const standardPluginDir = path__default.default.join(
+    repoRoot,
+    "packages",
+    "app",
+    "src",
+    "translations",
+    pluginName
+  );
+  const translationsDir = path__default.default.join(
+    repoRoot,
+    "packages",
+    "app",
+    "src",
+    "translations"
+  );
+  if (fs__default.default.existsSync(translationsDir)) {
+    fs__default.default.ensureDirSync(standardPluginDir);
+    return standardPluginDir;
+  }
+  return null;
+}
+function getTargetRepoRoot(repoRoot, repoType) {
+  if (repoType === "backstage" || repoType === "community-plugins") {
+    const possibleRhdhPaths = [
+      path__default.default.join(path__default.default.dirname(repoRoot), "rhdh"),
+      // Fallback: Try environment variable or common development location
+      process.env.RHDH_REPO_PATH || path__default.default.join(os__default.default.homedir(), "redhat", "rhdh")
+    ];
+    for (const rhdhPath of possibleRhdhPaths) {
+      if (fs__default.default.existsSync(rhdhPath)) {
+        return rhdhPath;
+      }
+    }
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  RHDH repo not found. Deploying to translations directory in current location.`
+      )
+    );
+  }
+  return repoRoot;
+}
+function getCommunityPluginsRepoRoot(repoRoot) {
+  const possiblePaths = [
+    path__default.default.join(path__default.default.dirname(repoRoot), "community-plugins"),
+    // Fallback: Try environment variable or common development location
+    process.env.COMMUNITY_PLUGINS_REPO_PATH || path__default.default.join(os__default.default.homedir(), "redhat", "community-plugins")
+  ];
+  for (const communityPluginsPath of possiblePaths) {
+    if (fs__default.default.existsSync(communityPluginsPath)) {
+      const workspacesDir = path__default.default.join(communityPluginsPath, "workspaces");
+      if (fs__default.default.existsSync(workspacesDir)) {
+        return communityPluginsPath;
+      }
+    }
+  }
+  return null;
+}
+function isRedHatOwnedPlugin(pluginName, communityPluginsRoot) {
+  if (!communityPluginsRoot) {
+    return false;
+  }
+  const cleanPluginName = pluginName.replace(/^plugin\./, "");
+  const workspacesDir = path__default.default.join(communityPluginsRoot, "workspaces");
+  if (!fs__default.default.existsSync(workspacesDir)) {
+    return false;
+  }
+  const workspaceDirs = fs__default.default.readdirSync(workspacesDir);
+  for (const workspace of workspaceDirs) {
+    const pluginDir = path__default.default.join(
+      workspacesDir,
+      workspace,
+      "plugins",
+      cleanPluginName
+    );
+    if (fs__default.default.existsSync(pluginDir)) {
+      const packageJsonPath = path__default.default.join(pluginDir, "package.json");
+      if (fs__default.default.existsSync(packageJsonPath)) {
+        try {
+          const packageJson = fs__default.default.readJsonSync(packageJsonPath);
+          if (packageJson.author === "Red Hat") {
+            return true;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return false;
+}
+function findPluginTranslationDir(pluginName, repoRoot, repoType) {
+  if (repoType === "backstage" || repoType === "community-plugins") {
+    const workspacesDir = path__default.default.join(repoRoot, "workspaces");
+    if (fs__default.default.existsSync(workspacesDir)) {
+      return findPluginInWorkspaces(pluginName, repoRoot);
+    }
+    const targetRoot = getTargetRepoRoot(repoRoot, repoType);
+    const translationsDir = path__default.default.join(targetRoot, "translations");
+    const pluginDir = path__default.default.join(translationsDir, pluginName);
+    if (!fs__default.default.existsSync(pluginDir)) {
+      fs__default.default.ensureDirSync(pluginDir);
+    }
+    return pluginDir;
+  }
+  if (repoType === "rhdh-plugins") {
+    return findPluginInWorkspaces(pluginName, repoRoot);
+  }
+  if (repoType === "rhdh") {
+    if (pluginName === "rhdh") {
+      const rhdhDir = path__default.default.join(
+        repoRoot,
+        "packages",
+        "app",
+        "src",
+        "translations",
+        "rhdh"
+      );
+      if (!fs__default.default.existsSync(rhdhDir)) {
+        fs__default.default.ensureDirSync(rhdhDir);
+      }
+      return rhdhDir;
+    }
+    return findPluginInRhdh(pluginName, repoRoot);
+  }
+  return null;
+}
+function extractCopyrightHeader(filePath) {
+  try {
+    if (!fs__default.default.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs__default.default.readFileSync(filePath, "utf-8");
+    const headerMatch = content.match(/\/\*[\s\S]*?\*\//);
+    if (headerMatch) {
+      return headerMatch[0];
+    }
+  } catch {
+  }
+  return null;
+}
+function getCopyrightHeader(translationDir) {
+  const refFile = path__default.default.join(translationDir, "ref.ts");
+  let header = extractCopyrightHeader(refFile);
+  if (header) {
+    return header;
+  }
+  if (fs__default.default.existsSync(translationDir)) {
+    const langFiles = fs__default.default.readdirSync(translationDir).filter(
+      (f) => f.endsWith(".ts") && !f.includes("ref") && !f.includes("translations") && !f.includes("index")
+    );
+    for (const langFile of langFiles) {
+      const langFilePath = path__default.default.join(translationDir, langFile);
+      header = extractCopyrightHeader(langFilePath);
+      if (header) {
+        return header;
+      }
+    }
+  }
+  return `/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */`;
+}
+function generateTranslationFile(pluginName, lang, messages, refImportName, refImportPath, variableName, translationDir) {
+  let langName;
+  if (lang === "it") {
+    langName = "Italian";
+  } else if (lang === "ja") {
+    langName = "Japanese";
+  } else {
+    langName = lang;
+  }
+  const messagesContent = Object.entries(messages).map(([key, value]) => {
+    const escapedValue = value.replaceAll(/\\/g, "\\\\").replaceAll(/'/g, "\\'").replaceAll(/\n/g, "\\n");
+    return `    '${key}': '${escapedValue}',`;
+  }).join("\n");
+  const copyrightHeader = translationDir ? getCopyrightHeader(translationDir) : `/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */`;
+  return `${copyrightHeader}
+
+import { createTranslationMessages } from '@backstage/core-plugin-api/alpha';
+import { ${refImportName} } from '${refImportPath}';
+
+/**
+ * ${langName} translation for ${pluginName}.
+ * @public
+ */
+const ${variableName} = createTranslationMessages({
+  ref: ${refImportName},
+  messages: {
+${messagesContent}
+  },
+});
+
+export default ${variableName};
+`;
+}
+function detectDownloadedFiles(downloadDir, repoType) {
+  const files = {};
+  if (!fs__default.default.existsSync(downloadDir)) {
+    return files;
+  }
+  const allFiles = fs__default.default.readdirSync(downloadDir).filter((f) => f.endsWith(".json"));
+  for (const file of allFiles) {
+    const langCodes = "(it|ja|fr|de|es|ko|zh|pt|ru|ar|hi|nl|pl|sv)";
+    let match = file.match(
+      new RegExp(`^([a-z-]+)-(s\\d+)-${langCodes}(?:-C)?\\.json$`, "i")
+    );
+    if (!match) {
+      match = file.match(
+        new RegExp(
+          `^([a-z-]+)-(\\d{4}-\\d{2}-\\d{2})-${langCodes}(?:-C)?\\.json$`,
+          "i"
+        )
+      );
+    }
+    if (!match) {
+      match = file.match(
+        new RegExp(
+          `^([a-z-]+)-reference-(\\d{4}-\\d{2}-\\d{2})-${langCodes}(?:-C)?\\.json$`,
+          "i"
+        )
+      );
+    }
+    if (match) {
+      const fileRepo = match[1];
+      const lang = match[3];
+      if (repoType === "rhdh-plugins" && fileRepo === "rhdh-plugins" || repoType === "community-plugins" && fileRepo === "community-plugins" || repoType === "rhdh" && fileRepo === "rhdh" || repoType === "backstage" && fileRepo === "backstage" || // Allow backstage and community-plugins files when running from rhdh repo
+      // (since they deploy to rhdh/translations)
+      repoType === "rhdh" && (fileRepo === "backstage" || fileRepo === "community-plugins")) {
+        files[lang] = file;
+      }
+    }
+  }
+  return files;
+}
+function determineTargetFile(pluginName, lang, repoType, translationDir) {
+  if (repoType === "backstage" || repoType === "community-plugins") {
+    return path__default.default.join(translationDir, `${lang}.ts`);
+  }
+  if (repoType === "rhdh") {
+    if (pluginName === "rhdh") {
+      return path__default.default.join(translationDir, `${lang}.ts`);
+    }
+    if (fs__default.default.existsSync(translationDir)) {
+      const existingFiles = fs__default.default.readdirSync(translationDir).filter(
+        (f) => f.endsWith(".ts") && !f.includes("ref") && !f.includes("translations")
+      );
+      const pluginLangPattern = new RegExp(`^${pluginName}-[a-z]{2}\\.ts$`);
+      const pluginLangFile2 = existingFiles.find((f) => pluginLangPattern.test(f));
+      if (pluginLangFile2) {
+        return path__default.default.join(translationDir, `${pluginName}-${lang}.ts`);
+      }
+      const langPattern = /^[a-z]{2}\.ts$/;
+      const langFile2 = existingFiles.find((f) => langPattern.test(f));
+      if (langFile2) {
+        return path__default.default.join(translationDir, `${lang}.ts`);
+      }
+    }
+    const pluginLangFile = path__default.default.join(
+      translationDir,
+      `${pluginName}-${lang}.ts`
+    );
+    const langFile = path__default.default.join(translationDir, `${lang}.ts`);
+    if (fs__default.default.existsSync(pluginLangFile)) {
+      return pluginLangFile;
+    }
+    if (fs__default.default.existsSync(langFile)) {
+      return langFile;
+    }
+    return pluginLangFile;
+  }
+  return path__default.default.join(translationDir, `${lang}.ts`);
+}
+function getOtherLanguageFiles(lang, repoType, pluginName, translationDir) {
+  const otherLangs = ["it", "ja", "de", "fr", "es", "en"].filter(
+    (l) => l !== lang
+  );
+  if (repoType === "rhdh") {
+    return otherLangs.flatMap((l) => {
+      const pluginLangFile = path__default.default.join(translationDir, `${pluginName}-${l}.ts`);
+      const langFile = path__default.default.join(translationDir, `${l}.ts`);
+      const files = [];
+      if (fs__default.default.existsSync(pluginLangFile)) files.push(pluginLangFile);
+      if (fs__default.default.existsSync(langFile)) files.push(langFile);
+      return files;
+    });
+  }
+  return otherLangs.map((l) => path__default.default.join(translationDir, `${l}.ts`)).filter((f) => fs__default.default.existsSync(f));
+}
+function transformVariableName(variableName, lang) {
+  const langCapitalized = lang.charAt(0).toUpperCase() + lang.slice(1);
+  if (variableName.match(/Translation(It|Ja|De|Fr|Es)$/)) {
+    return variableName.replaceAll(
+      /Translation(It|Ja|De|Fr|Es)$/g,
+      `Translation${langCapitalized}`
+    );
+  }
+  return lang;
+}
+function verifyImportPath(refInfo, translationDir) {
+  if (!refInfo.refImportPath.startsWith("./")) {
+    return;
+  }
+  const expectedFile = path__default.default.join(
+    translationDir,
+    `${refInfo.refImportPath.replace("./", "")}.ts`
+  );
+  if (!fs__default.default.existsSync(expectedFile)) {
+    refInfo.refImportPath = findRefImportPath(translationDir);
+  }
+}
+function extractRefInfoFromOtherFiles(otherLangFiles, repoType, lang, translationDir) {
+  for (const otherFile of otherLangFiles) {
+    const otherRefInfo = extractRefInfo(otherFile);
+    if (!otherRefInfo) {
+      continue;
+    }
+    verifyImportPath(otherRefInfo, translationDir);
+    const isExternalImport = !otherRefInfo.refImportPath.startsWith("./");
+    const shouldUseForRhdh = repoType === "rhdh" && isExternalImport;
+    const shouldUseForOthers = repoType !== "rhdh" || !isExternalImport;
+    if (shouldUseForRhdh || shouldUseForOthers) {
+      return {
+        refImportName: otherRefInfo.refImportName,
+        refImportPath: otherRefInfo.refImportPath,
+        variableName: transformVariableName(otherRefInfo.variableName, lang)
+      };
+    }
+  }
+  return null;
+}
+function extractRefInfoFromRefFile(translationDir) {
+  const refFile = path__default.default.join(translationDir, "ref.ts");
+  if (!fs__default.default.existsSync(refFile)) {
+    return null;
+  }
+  try {
+    const content = fs__default.default.readFileSync(refFile, "utf-8");
+    const refExportMatch = content.match(
+      /export\s+const\s+(\w+TranslationRef)\s*=/
+    );
+    if (refExportMatch) {
+      return {
+        refImportName: refExportMatch[1],
+        refImportPath: "./ref"
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function getRefInfoForPlugin(pluginName, lang, repoType, translationDir, targetFile, exists) {
+  const otherLangFiles = getOtherLanguageFiles(
+    lang,
+    repoType,
+    pluginName,
+    translationDir
+  );
+  const refInfoFromOthers = extractRefInfoFromOtherFiles(
+    otherLangFiles,
+    repoType,
+    lang,
+    translationDir
+  );
+  if (refInfoFromOthers) {
+    return refInfoFromOthers;
+  }
+  if (exists) {
+    const existingRefInfo = extractRefInfo(targetFile);
+    if (existingRefInfo) {
+      return existingRefInfo;
+    }
+  }
+  const anyOtherFile = otherLangFiles.find((f) => fs__default.default.existsSync(f));
+  if (anyOtherFile) {
+    const otherRefInfo = extractRefInfo(anyOtherFile);
+    if (otherRefInfo) {
+      verifyImportPath(otherRefInfo, translationDir);
+      return {
+        refImportName: otherRefInfo.refImportName,
+        refImportPath: otherRefInfo.refImportPath,
+        variableName: transformVariableName(otherRefInfo.variableName, lang)
+      };
+    }
+  }
+  const refInfoFromRef = extractRefInfoFromRefFile(translationDir);
+  if (refInfoFromRef) {
+    const langCapitalized = lang.charAt(0).toUpperCase() + lang.slice(1);
+    const baseName = refInfoFromRef.refImportName.replace("TranslationRef", "");
+    const variableName = `${baseName}Translation${langCapitalized}`;
+    return {
+      refImportName: refInfoFromRef.refImportName,
+      refImportPath: refInfoFromRef.refImportPath,
+      variableName
+    };
+  }
+  return inferRefInfo(pluginName, lang, repoType, translationDir);
+}
+function processPluginTranslation(pluginName, translations, lang, repoType, repoRoot) {
+  const translationDir = findPluginTranslationDir(
+    pluginName,
+    repoRoot,
+    repoType
+  );
+  if (!translationDir) {
+    console.warn(
+      chalk__default.default.yellow(`    \u26A0\uFE0F  Plugin "${pluginName}" not found, skipping...`)
+    );
+    return null;
+  }
+  console.log(chalk__default.default.gray(`    \u{1F4E6} Plugin: ${pluginName} \u2192 ${translationDir}`));
+  const targetFile = determineTargetFile(
+    pluginName,
+    lang,
+    repoType,
+    translationDir
+  );
+  const exists = fs__default.default.existsSync(targetFile);
+  const refInfo = getRefInfoForPlugin(
+    pluginName,
+    lang,
+    repoType,
+    translationDir,
+    targetFile,
+    exists
+  );
+  const refFile = path__default.default.join(translationDir, "ref.ts");
+  let filteredTranslations = translations;
+  let filteredCount = 0;
+  if (fs__default.default.existsSync(refFile)) {
+    const refKeys = extractKeysFromRefFile(refFile);
+    if (refKeys.size > 0) {
+      const validKeys = new Set(refKeys);
+      const originalCount = Object.keys(translations).length;
+      filteredTranslations = Object.fromEntries(
+        Object.entries(translations).filter(([key]) => validKeys.has(key))
+      );
+      filteredCount = originalCount - Object.keys(filteredTranslations).length;
+      if (filteredCount > 0) {
+        const invalidKeys = Object.keys(translations).filter(
+          (key) => !validKeys.has(key)
+        );
+        console.warn(
+          chalk__default.default.yellow(
+            `    \u26A0\uFE0F  Filtered out ${filteredCount} invalid key(s) not in ref.ts: ${invalidKeys.slice(0, 3).join(", ")}${invalidKeys.length > 3 ? "..." : ""}`
+          )
+        );
+      }
+    }
+  }
+  const content = generateTranslationFile(
+    pluginName,
+    lang,
+    filteredTranslations,
+    refInfo.refImportName,
+    refInfo.refImportPath,
+    refInfo.variableName,
+    translationDir
+  );
+  fs__default.default.writeFileSync(targetFile, content, "utf-8");
+  const relativePath = path__default.default.relative(repoRoot, targetFile);
+  const keyCount = Object.keys(filteredTranslations).length;
+  if (exists) {
+    console.log(
+      chalk__default.default.green(`    \u2705 Updated: ${relativePath} (${keyCount} keys)`)
+    );
+    return { updated: true, created: false };
+  }
+  console.log(
+    chalk__default.default.green(`    \u2728 Created: ${relativePath} (${keyCount} keys)`)
+  );
+  return { updated: false, created: true };
+}
+function processLanguageTranslations(data, lang, repoType, repoRoot, communityPluginsRoot) {
+  let updated = 0;
+  let created = 0;
+  for (const [pluginName, pluginData] of Object.entries(data)) {
+    const pluginDataObj = pluginData;
+    let translations = pluginDataObj[lang] || {};
+    if (Object.keys(translations).length === 0 && pluginDataObj.en) {
+      pluginDataObj[lang] = pluginDataObj.en;
+      translations = pluginDataObj[lang];
+    }
+    if (Object.keys(translations).length === 0) {
+      continue;
+    }
+    if (repoType === "backstage") {
+      continue;
+    }
+    if (repoType === "community-plugins") {
+      if (communityPluginsRoot && isRedHatOwnedPlugin(pluginName, communityPluginsRoot)) {
+        console.log(
+          chalk__default.default.cyan(
+            `    \u{1F534} Red Hat owned plugin detected: ${pluginName} \u2192 deploying to community-plugins`
+          )
+        );
+        const communityPluginsResult = processPluginTranslation(
+          pluginName,
+          translations,
+          lang,
+          "community-plugins",
+          communityPluginsRoot
+        );
+        if (communityPluginsResult) {
+          if (communityPluginsResult.updated) updated++;
+          if (communityPluginsResult.created) created++;
+        }
+      }
+      continue;
+    }
+    const result = processPluginTranslation(
+      pluginName,
+      translations,
+      lang,
+      repoType,
+      repoRoot
+    );
+    if (result) {
+      if (result.updated) updated++;
+      if (result.created) created++;
+    }
+  }
+  return { updated, created };
+}
+function extractKeysFromTranslationFile(filePath) {
+  const keys = /* @__PURE__ */ new Set();
+  try {
+    const content = fs__default.default.readFileSync(filePath, "utf-8");
+    const messagesMatch = content.match(/messages:\s*\{([\s\S]*?)\}\s*\}\)/);
+    if (messagesMatch) {
+      const messagesContent = messagesMatch[1];
+      const keyPattern = /['"]([^'"]+)['"]\s*:\s*['"]/g;
+      let match = keyPattern.exec(messagesContent);
+      while (match !== null) {
+        keys.add(match[1]);
+        match = keyPattern.exec(messagesContent);
+      }
+    }
+  } catch (error) {
+  }
+  return keys;
+}
+function extractKeysFromRefFile(refFilePath) {
+  const keys = /* @__PURE__ */ new Set();
+  try {
+    const content = fs__default.default.readFileSync(refFilePath, "utf-8");
+    const messagesMatch = content.match(
+      /export\s+const\s+\w+Messages\s*=\s*\{([\s\S]*?)\};/
+    );
+    if (!messagesMatch) {
+      return keys;
+    }
+    const messagesContent = messagesMatch[1];
+    const extractNestedKeys = (nestedContent, prefix = "", depth = 0, maxDepth = 10) => {
+      if (depth > maxDepth) {
+        return;
+      }
+      const isWhitespace = (char) => {
+        return char === " " || char === "	" || char === "\n" || char === "\r";
+      };
+      const isIdentifierStart = (char) => {
+        return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "$";
+      };
+      const isIdentifierPart = (char) => {
+        return isIdentifierStart(char) || char >= "0" && char <= "9";
+      };
+      const skipWhitespace = (text, startIndex) => {
+        let idx = startIndex;
+        while (idx < text.length && isWhitespace(text[idx])) {
+          idx++;
+        }
+        return idx;
+      };
+      const findMatchingBrace = (textContent, startIndex) => {
+        const valueStart = textContent.indexOf("{", startIndex);
+        if (valueStart === -1) {
+          return null;
+        }
+        let braceCount = 0;
+        for (let i = valueStart; i < textContent.length; i++) {
+          if (textContent[i] === "{") braceCount++;
+          if (textContent[i] === "}") {
+            braceCount--;
+            if (braceCount === 0) {
+              return textContent.substring(valueStart, i + 1);
+            }
+          }
+        }
+        return null;
+      };
+      const MAX_CONTENT_LENGTH = 1024 * 1024;
+      if (nestedContent.length > MAX_CONTENT_LENGTH) {
+        console.warn(
+          `Content too large (${nestedContent.length} chars), skipping extraction`
+        );
+        return;
+      }
+      const allMatches = [];
+      const parseKeyValuePairs = (textToParse) => {
+        let i = 0;
+        const MAX_VALUE_LENGTH = 5e3;
+        const MAX_KEY_LENGTH = 500;
+        while (i < textToParse.length) {
+          i = skipWhitespace(textToParse, i);
+          if (i >= textToParse.length) break;
+          const keyStart = i;
+          let key = "";
+          let keyEnd = i;
+          if (textToParse[i] === "'" || textToParse[i] === '"') {
+            const quote = textToParse[i];
+            i++;
+            const keyStartInner = i;
+            while (i < textToParse.length && textToParse[i] !== quote) {
+              if (i - keyStartInner > MAX_KEY_LENGTH) break;
+              i++;
+            }
+            if (i < textToParse.length && textToParse[i] === quote) {
+              key = textToParse.substring(keyStartInner, i);
+              i++;
+              keyEnd = i;
+            } else {
+              i++;
+              continue;
+            }
+          } else if (isIdentifierStart(textToParse[i])) {
+            const keyStartInner = i;
+            while (i < textToParse.length && isIdentifierPart(textToParse[i])) {
+              if (i - keyStartInner > MAX_KEY_LENGTH) break;
+              i++;
+            }
+            key = textToParse.substring(keyStartInner, i);
+            keyEnd = i;
+          } else {
+            i++;
+            continue;
+          }
+          i = skipWhitespace(textToParse, i);
+          if (i >= textToParse.length || textToParse[i] !== ":") {
+            i = keyEnd + 1;
+            continue;
+          }
+          i++;
+          i = skipWhitespace(textToParse, i);
+          const valueStart = i;
+          let valueEnd = i;
+          let foundDelimiter = false;
+          while (i < textToParse.length && !foundDelimiter) {
+            if (i - valueStart > MAX_VALUE_LENGTH) {
+              break;
+            }
+            const char = textToParse[i];
+            if (char === "," || char === "}" || char === "\n") {
+              valueEnd = i;
+              foundDelimiter = true;
+            } else {
+              i++;
+            }
+          }
+          if (foundDelimiter && valueEnd > valueStart) {
+            const value = textToParse.substring(valueStart, valueEnd).trim();
+            if (value.length > 0) {
+              allMatches.push({
+                key,
+                value,
+                index: keyStart,
+                endIndex: valueEnd + 1
+              });
+            }
+            i = valueEnd + 1;
+          } else {
+            i = keyEnd + 1;
+          }
+        }
+      };
+      parseKeyValuePairs(nestedContent);
+      allMatches.sort((a, b) => a.index - b.index);
+      for (const matchData of allMatches) {
+        const fullKey = prefix ? `${prefix}.${matchData.key}` : matchData.key;
+        if (matchData.value.startsWith("{")) {
+          const nestedSubContent = findMatchingBrace(
+            nestedContent,
+            matchData.index
+          );
+          if (nestedSubContent) {
+            extractNestedKeys(nestedSubContent, fullKey, depth + 1, maxDepth);
+          }
+        } else if (matchData.value.length > 0 && (matchData.value[0] === "'" || matchData.value[0] === '"')) {
+          keys.add(fullKey);
+        }
+      }
+    };
+    extractNestedKeys(messagesContent);
+  } catch (error) {
+  }
+  return keys;
+}
+function validateTranslationKeys(_repoType, repoRoot) {
+  const errors = [];
+  const supportedLangs = ["fr", "it", "ja", "de", "es"];
+  const workspacesDir = path__default.default.join(repoRoot, "workspaces");
+  if (!fs__default.default.existsSync(workspacesDir)) {
+    return { hasErrors: false, errors: [] };
+  }
+  const workspaceDirs = fs__default.default.readdirSync(workspacesDir);
+  for (const workspace of workspaceDirs) {
+    const pluginsDir = path__default.default.join(workspacesDir, workspace, "plugins");
+    if (!fs__default.default.existsSync(pluginsDir)) {
+      continue;
+    }
+    const pluginDirs = fs__default.default.readdirSync(pluginsDir);
+    for (const plugin of pluginDirs) {
+      const translationDir = path__default.default.join(
+        pluginsDir,
+        plugin,
+        "src",
+        "translations"
+      );
+      if (!fs__default.default.existsSync(translationDir)) {
+        continue;
+      }
+      const refFile = path__default.default.join(translationDir, "ref.ts");
+      if (!fs__default.default.existsSync(refFile)) {
+        continue;
+      }
+      const refKeys = extractKeysFromRefFile(refFile);
+      if (refKeys.size === 0) {
+        continue;
+      }
+      for (const lang of supportedLangs) {
+        const langFile = path__default.default.join(translationDir, `${lang}.ts`);
+        if (!fs__default.default.existsSync(langFile)) {
+          continue;
+        }
+        const langKeys = extractKeysFromTranslationFile(langFile);
+        const missingKeys = Array.from(refKeys).filter(
+          (key) => !langKeys.has(key)
+        );
+        if (missingKeys.length > 0) {
+          errors.push(
+            `\u274C ${workspace}/plugins/${plugin}/src/translations/${lang}.ts is missing ${missingKeys.length} key(s): ${missingKeys.slice(0, 5).join(", ")}${missingKeys.length > 5 ? "..." : ""}`
+          );
+        }
+        const extraKeys = Array.from(langKeys).filter((key) => !refKeys.has(key));
+        if (extraKeys.length > 0) {
+          errors.push(
+            `\u26A0\uFE0F  ${workspace}/plugins/${plugin}/src/translations/${lang}.ts has ${extraKeys.length} extra key(s) not in ref: ${extraKeys.slice(0, 5).join(", ")}${extraKeys.length > 5 ? "..." : ""}`
+          );
+        }
+      }
+    }
+  }
+  return { hasErrors: errors.length > 0, errors };
+}
+async function deployTranslations(downloadDir, repoRoot) {
+  console.log(chalk__default.default.blue("\u{1F680} Deploying translations...\n"));
+  const repoType = detectRepoType(repoRoot);
+  console.log(chalk__default.default.cyan(`\u{1F4E6} Detected repository: ${repoType}
+`));
+  if (repoType === "unknown") {
+    throw new Error(
+      "Could not detect repository type. Expected: rhdh-plugins, community-plugins, rhdh, or backstage"
+    );
+  }
+  const repoFiles = detectDownloadedFiles(downloadDir, repoType);
+  if (Object.keys(repoFiles).length === 0) {
+    console.warn(
+      chalk__default.default.yellow(
+        `\u26A0\uFE0F  No translation files found for ${repoType} in ${downloadDir}`
+      )
+    );
+    console.warn(
+      chalk__default.default.gray(
+        `   Expected files like: ${repoType}-*-{lang}.json or ${repoType}-*-{lang}-C.json`
+      )
+    );
+    return;
+  }
+  console.log(
+    chalk__default.default.cyan(
+      `\u{1F4C1} Found ${Object.keys(repoFiles).length} translation file(s) for ${repoType}`
+    )
+  );
+  let totalUpdated = 0;
+  let totalCreated = 0;
+  for (const [lang, originalFilename] of Object.entries(repoFiles)) {
+    const filepath = path__default.default.join(downloadDir, originalFilename);
+    if (!fs__default.default.existsSync(filepath)) {
+      console.warn(chalk__default.default.yellow(`  \u26A0\uFE0F  File not found: ${originalFilename}`));
+      continue;
+    }
+    let displayFilename = originalFilename;
+    displayFilename = displayFilename.replace(/-C\.json$/, ".json");
+    displayFilename = displayFilename.replace(/-reference-/, "-");
+    let effectiveRepoType = repoType;
+    const fileRepoMatch = originalFilename.match(
+      /^(backstage|community-plugins|rhdh-plugins|rhdh)-/
+    );
+    if (fileRepoMatch && repoType === "rhdh") {
+      const fileRepo = fileRepoMatch[1];
+      if (fileRepo === "backstage" || fileRepo === "community-plugins") {
+        effectiveRepoType = fileRepo;
+      }
+    }
+    let data;
+    try {
+      const fileContent = fs__default.default.readFileSync(filepath, "utf-8");
+      data = JSON.parse(fileContent);
+    } catch (error) {
+      console.error(
+        chalk__default.default.red(`
+\u274C Error parsing JSON file: ${displayFilename}`)
+      );
+      console.error(
+        chalk__default.default.red(
+          `   ${error instanceof Error ? error.message : "Invalid JSON format"}`
+        )
+      );
+      console.error(
+        chalk__default.default.yellow(
+          `   Skipping this file. Please check the file and try again.`
+        )
+      );
+      continue;
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      console.error(
+        chalk__default.default.red(`
+\u274C Invalid JSON structure in file: ${displayFilename}`)
+      );
+      console.error(
+        chalk__default.default.red(`   Expected a JSON object, got: ${typeof data}`)
+      );
+      continue;
+    }
+    console.log(chalk__default.default.cyan(`
+  \u{1F30D} Language: ${lang.toUpperCase()}`));
+    console.log(chalk__default.default.gray(`  \u{1F4C4} Processing: ${displayFilename}`));
+    let communityPluginsRoot = null;
+    if (effectiveRepoType === "backstage") {
+      const targetRoot = getTargetRepoRoot(repoRoot, effectiveRepoType);
+      const translationsDir = path__default.default.join(targetRoot, "translations");
+      if (fs__default.default.existsSync(translationsDir)) {
+        let timestamp = "";
+        const dateMatch = displayFilename.match(/(\d{4}-\d{2}-\d{2})/);
+        const sprintMatch = displayFilename.match(/(s\d+)/);
+        if (dateMatch) {
+          timestamp = dateMatch[1];
+        } else if (sprintMatch) {
+          timestamp = sprintMatch[1];
+        } else {
+          timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        }
+        const cleanFilename = `${effectiveRepoType}-${timestamp}-${lang}.json`;
+        const targetJsonPath = path__default.default.join(translationsDir, cleanFilename);
+        if (filepath !== targetJsonPath) {
+          const jsonData = JSON.parse(fs__default.default.readFileSync(filepath, "utf-8"));
+          const updatedData = {};
+          for (const [pluginName, pluginData] of Object.entries(jsonData)) {
+            const pluginDataObj = pluginData;
+            updatedData[pluginName] = {};
+            if (pluginDataObj.en) {
+              updatedData[pluginName][lang] = pluginDataObj.en;
+            } else if (pluginDataObj[lang]) {
+              updatedData[pluginName][lang] = pluginDataObj[lang];
+            } else {
+              updatedData[pluginName] = pluginDataObj;
+            }
+          }
+          fs__default.default.writeFileSync(
+            targetJsonPath,
+            JSON.stringify(updatedData, null, 2),
+            "utf-8"
+          );
+          console.log(
+            chalk__default.default.green(
+              `  \u{1F4CB} Copied and updated JSON to: ${path__default.default.relative(
+                repoRoot,
+                targetJsonPath
+              )} (replaced "en" with "${lang}")`
+            )
+          );
+        } else {
+          const jsonData = JSON.parse(fs__default.default.readFileSync(filepath, "utf-8"));
+          const updatedData = {};
+          let needsUpdate = false;
+          for (const [pluginName, pluginData] of Object.entries(jsonData)) {
+            const pluginDataObj = pluginData;
+            updatedData[pluginName] = {};
+            if (pluginDataObj.en) {
+              updatedData[pluginName][lang] = pluginDataObj.en;
+              needsUpdate = true;
+            } else if (pluginDataObj[lang]) {
+              updatedData[pluginName][lang] = pluginDataObj[lang];
+            } else {
+              updatedData[pluginName] = pluginDataObj;
+            }
+          }
+          if (needsUpdate) {
+            fs__default.default.writeFileSync(
+              targetJsonPath,
+              JSON.stringify(updatedData, null, 2),
+              "utf-8"
+            );
+            console.log(
+              chalk__default.default.green(
+                `  \u{1F4CB} Updated JSON file: ${path__default.default.relative(
+                  repoRoot,
+                  targetJsonPath
+                )} (replaced "en" with "${lang}")`
+              )
+            );
+          } else {
+            console.log(
+              chalk__default.default.gray(
+                `  \u{1F4CB} JSON already in target location: ${path__default.default.relative(
+                  repoRoot,
+                  targetJsonPath
+                )}`
+              )
+            );
+          }
+        }
+      }
+    }
+    if (repoType === "rhdh" && effectiveRepoType === "community-plugins") {
+      communityPluginsRoot = getCommunityPluginsRepoRoot(repoRoot);
+      if (communityPluginsRoot) {
+        console.log(
+          chalk__default.default.gray(
+            `  \u{1F4E6} Community-plugins repo found: ${communityPluginsRoot}`
+          )
+        );
+      }
+    }
+    const { updated, created } = processLanguageTranslations(
+      data,
+      lang,
+      effectiveRepoType,
+      repoRoot,
+      communityPluginsRoot
+    );
+    totalUpdated += updated;
+    totalCreated += created;
+  }
+  console.log(chalk__default.default.blue(`
+
+\u{1F4CA} Summary:`));
+  console.log(chalk__default.default.green(`  \u2705 Updated: ${totalUpdated} files`));
+  console.log(chalk__default.default.green(`  \u2728 Created: ${totalCreated} files`));
+  console.log(chalk__default.default.blue(`
+\u{1F50D} Validating translation keys...`));
+  const validationResults = validateTranslationKeys(repoType, repoRoot);
+  if (validationResults.hasErrors) {
+    console.log(chalk__default.default.red(`
+\u274C Validation found issues:`));
+    validationResults.errors.forEach((error) => {
+      console.log(chalk__default.default.red(`  ${error}`));
+    });
+    console.log(
+      chalk__default.default.yellow(
+        `
+\u26A0\uFE0F  Please review and fix the missing keys before committing.`
+      )
+    );
+  } else {
+    console.log(chalk__default.default.green(`
+\u2705 All translation files have matching keys!`));
+  }
+  console.log(chalk__default.default.blue(`
+\u{1F389} Deployment complete!`));
+}
+
+exports.deployTranslations = deployTranslations;
+exports.isRedHatOwnedPlugin = isRedHatOwnedPlugin;
+//# sourceMappingURL=deployTranslations.cjs.js.map