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

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

@@ -0,0 +1,418 @@
+'use strict';
+
+var ts = require('typescript');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespaceCompat(ts);
+
+function extractTranslationKeys(content, filePath) {
+  const keys = {};
+  let pluginId = null;
+  if (filePath.endsWith(".d.ts")) {
+    return { keys: extractKeysWithRegex(content), pluginId: null };
+  }
+  try {
+    const sourceFile = ts__namespace.createSourceFile(
+      filePath,
+      content,
+      ts__namespace.ScriptTarget.Latest,
+      true
+    );
+    const invalidKeys = [];
+    const unwrapTypeAssertion = (node) => {
+      return ts__namespace.isAsExpression(node) ? node.expression : node;
+    };
+    const extractPropertyKeyName = (propertyName) => {
+      if (ts__namespace.isIdentifier(propertyName)) {
+        return propertyName.text;
+      }
+      if (ts__namespace.isStringLiteral(propertyName)) {
+        return propertyName.text;
+      }
+      return null;
+    };
+    const isValidKey = (key) => {
+      if (!key || key.trim() === "") {
+        return false;
+      }
+      return /^[a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/.test(
+        key
+      );
+    };
+    const trackInvalidKey = (key) => {
+      if (!invalidKeys.includes(key)) {
+        invalidKeys.push(key);
+      }
+    };
+    const extractTemplateText = (template) => {
+      let templateText = "";
+      for (const part of template.templateSpans) {
+        if (part.literal) {
+          templateText += part.literal.text;
+        }
+      }
+      if (template.head) {
+        templateText = template.head.text + templateText;
+      }
+      return templateText;
+    };
+    const extractValueFromInitializer = (initializer) => {
+      const unwrapped = unwrapTypeAssertion(initializer);
+      if (ts__namespace.isStringLiteral(unwrapped)) {
+        return unwrapped.text;
+      }
+      if (ts__namespace.isTemplateExpression(unwrapped)) {
+        return extractTemplateText(unwrapped);
+      }
+      if (ts__namespace.isNoSubstitutionTemplateLiteral(unwrapped)) {
+        return unwrapped.text;
+      }
+      return null;
+    };
+    const extractFromObjectLiteral = (node, prefix = "") => {
+      const objectNode = unwrapTypeAssertion(node);
+      if (!ts__namespace.isObjectLiteralExpression(objectNode)) {
+        return;
+      }
+      for (const property of objectNode.properties) {
+        if (!ts__namespace.isPropertyAssignment(property) || !property.name) {
+          continue;
+        }
+        const keyName = extractPropertyKeyName(property.name);
+        if (!keyName) {
+          continue;
+        }
+        const fullKey = prefix ? `${prefix}.${keyName}` : keyName;
+        if (!isValidKey(fullKey)) {
+          trackInvalidKey(fullKey);
+          continue;
+        }
+        const initializer = property.initializer;
+        if (!initializer) {
+          continue;
+        }
+        const unwrappedInitializer = unwrapTypeAssertion(initializer);
+        const value = extractValueFromInitializer(unwrappedInitializer);
+        if (value !== null) {
+          keys[fullKey] = value;
+          continue;
+        }
+        if (ts__namespace.isObjectLiteralExpression(unwrappedInitializer)) {
+          extractFromObjectLiteral(unwrappedInitializer, fullKey);
+        }
+      }
+    };
+    const extractMessagesFromProperty = (property, propertyName) => {
+      if (!ts__namespace.isPropertyAssignment(property)) {
+        return;
+      }
+      const propName = extractPropertyKeyName(property.name);
+      if (propName !== propertyName) {
+        return;
+      }
+      const messagesNode = unwrapTypeAssertion(property.initializer);
+      if (ts__namespace.isObjectLiteralExpression(messagesNode)) {
+        extractFromObjectLiteral(messagesNode);
+      }
+    };
+    const extractFromCreateTranslationRef = (node) => {
+      const args = node.arguments;
+      if (args.length === 0 || !ts__namespace.isObjectLiteralExpression(args[0])) {
+        return null;
+      }
+      let extractedPluginId = null;
+      for (const property of args[0].properties) {
+        if (ts__namespace.isPropertyAssignment(property) && ts__namespace.isIdentifier(property.name) && property.name.text === "id" && ts__namespace.isStringLiteral(property.initializer)) {
+          extractedPluginId = property.initializer.text;
+        }
+        if (property.name) {
+          const propName = extractPropertyKeyName(property.name);
+          if (propName === "messages") {
+            extractMessagesFromProperty(property, "messages");
+          }
+        }
+      }
+      return extractedPluginId;
+    };
+    const extractFromCreateTranslationResource = (node) => {
+      const args = node.arguments;
+      if (args.length === 0 || !ts__namespace.isObjectLiteralExpression(args[0])) {
+        return;
+      }
+      for (const property of args[0].properties) {
+        if (ts__namespace.isPropertyAssignment(property) && ts__namespace.isIdentifier(property.name) && property.name.text === "translations" && ts__namespace.isObjectLiteralExpression(property.initializer)) {
+          extractFromObjectLiteral(property.initializer);
+        }
+      }
+    };
+    const extractFromCreateTranslationMessages = (node) => {
+      const args = node.arguments;
+      if (args.length === 0 || !ts__namespace.isObjectLiteralExpression(args[0])) {
+        return;
+      }
+      for (const property of args[0].properties) {
+        extractMessagesFromProperty(property, "messages");
+      }
+    };
+    const extractFromDefineMessages = (node) => {
+      const args = node.arguments;
+      if (args.length === 0 || !ts__namespace.isObjectLiteralExpression(args[0])) {
+        return;
+      }
+      for (const property of args[0].properties) {
+        if (ts__namespace.isPropertyAssignment(property) && property.initializer && ts__namespace.isObjectLiteralExpression(property.initializer)) {
+          const keyName = extractPropertyKeyName(property.name);
+          if (!keyName) {
+            continue;
+          }
+          for (const msgProperty of property.initializer.properties) {
+            if (ts__namespace.isPropertyAssignment(msgProperty) && msgProperty.name && ts__namespace.isIdentifier(msgProperty.name)) {
+              const propName = msgProperty.name.text;
+              if ((propName === "defaultMessage" || propName === "id") && ts__namespace.isStringLiteral(msgProperty.initializer)) {
+                const value = msgProperty.initializer.text;
+                if (isValidKey(keyName)) {
+                  keys[keyName] = value;
+                }
+                break;
+              }
+            }
+          }
+        }
+      }
+    };
+    const isMessagesVariableName = (varName) => {
+      return varName.includes("Messages") || varName.includes("messages") || varName.includes("translations");
+    };
+    const extractFromVariableStatement = (node) => {
+      const isExported = node.modifiers?.some(
+        (m) => m.kind === ts__namespace.SyntaxKind.ExportKeyword
+      );
+      if (!isExported) {
+        return;
+      }
+      for (const declaration of node.declarationList.declarations) {
+        if (!declaration.initializer || !ts__namespace.isObjectLiteralExpression(declaration.initializer)) {
+          continue;
+        }
+        const varName = ts__namespace.isIdentifier(declaration.name) ? declaration.name.text : "";
+        if (isMessagesVariableName(varName)) {
+          extractFromObjectLiteral(declaration.initializer);
+        }
+      }
+    };
+    const extractFromTranslationCall = (args) => {
+      if (args.length === 0 || !ts__namespace.isStringLiteral(args[0])) {
+        return;
+      }
+      const key = args[0].text;
+      if (!isValidKey(key)) {
+        if (!invalidKeys.includes(key)) {
+          invalidKeys.push(key);
+        }
+        return;
+      }
+      const value = args.length > 1 && ts__namespace.isStringLiteral(args[1]) ? args[1].text : key;
+      keys[key] = value;
+    };
+    const extractFromTFunction = (node) => {
+      extractFromTranslationCall(node.arguments);
+    };
+    const isI18nTCall = (node) => {
+      return ts__namespace.isPropertyAccessExpression(node.expression) && ts__namespace.isIdentifier(node.expression.expression) && node.expression.expression.text === "i18n" && ts__namespace.isIdentifier(node.expression.name) && node.expression.name.text === "t";
+    };
+    const extractFromI18nT = (node) => {
+      if (!isI18nTCall(node)) {
+        return;
+      }
+      extractFromTranslationCall(node.arguments);
+    };
+    const isUseTranslationTCall = (node) => {
+      if (!ts__namespace.isPropertyAccessExpression(node.expression)) {
+        return false;
+      }
+      const propertyAccess = node.expression;
+      if (!ts__namespace.isCallExpression(propertyAccess.expression)) {
+        return false;
+      }
+      const innerCall = propertyAccess.expression;
+      return ts__namespace.isIdentifier(innerCall.expression) && innerCall.expression.text === "useTranslation" && ts__namespace.isIdentifier(propertyAccess.name) && propertyAccess.name.text === "t";
+    };
+    const extractFromUseTranslationT = (node) => {
+      if (!isUseTranslationTCall(node)) {
+        return;
+      }
+      extractFromTranslationCall(node.arguments);
+    };
+    const extractFromJsxTrans = (node) => {
+      const tagName = ts__namespace.isJsxElement(node) ? node.openingElement.tagName : node.tagName;
+      if (!ts__namespace.isIdentifier(tagName) || tagName.text !== "Trans") {
+        return;
+      }
+      const attributes = ts__namespace.isJsxElement(node) ? node.openingElement.attributes : node.attributes;
+      if (!ts__namespace.isJsxAttributes(attributes)) {
+        return;
+      }
+      attributes.properties.forEach((attr) => {
+        if (ts__namespace.isJsxAttribute(attr) && ts__namespace.isIdentifier(attr.name) && attr.name.text === "i18nKey" && attr.initializer && ts__namespace.isStringLiteral(attr.initializer)) {
+          const key = attr.initializer.text;
+          keys[key] = key;
+        }
+      });
+    };
+    const isCallExpressionWithName = (node, functionName) => {
+      return ts__namespace.isCallExpression(node) && ts__namespace.isIdentifier(node.expression) && node.expression.text === functionName;
+    };
+    const extractFromTranslationRefType = (messagesType) => {
+      for (const member of messagesType.members) {
+        if (!ts__namespace.isPropertySignature(member) || !member.name) {
+          continue;
+        }
+        const keyName = extractPropertyKeyName(member.name);
+        if (!keyName || !member.type) {
+          continue;
+        }
+        if (!ts__namespace.isLiteralTypeNode(member.type)) {
+          continue;
+        }
+        const literalType = member.type;
+        if (!literalType.literal || !ts__namespace.isStringLiteral(literalType.literal)) {
+          continue;
+        }
+        const stringValue = literalType.literal.text;
+        if (isValidKey(keyName)) {
+          keys[keyName] = stringValue;
+        } else {
+          trackInvalidKey(keyName);
+        }
+      }
+    };
+    const extractFromTranslationRefDeclarations = (node) => {
+      for (const decl of node.declarationList.declarations) {
+        if (!decl.type || !ts__namespace.isTypeReferenceNode(decl.type)) {
+          continue;
+        }
+        const typeRef = decl.type;
+        if (!ts__namespace.isIdentifier(typeRef.typeName) || typeRef.typeName.text !== "TranslationRef" || !typeRef.typeArguments || typeRef.typeArguments.length < 2) {
+          continue;
+        }
+        const messagesType = typeRef.typeArguments[1];
+        if (ts__namespace.isTypeLiteralNode(messagesType)) {
+          extractFromTranslationRefType(messagesType);
+        }
+      }
+    };
+    const handleCallExpression = (node) => {
+      if (isCallExpressionWithName(node, "createTranslationRef")) {
+        const extractedPluginId = extractFromCreateTranslationRef(node);
+        if (extractedPluginId && !pluginId) {
+          pluginId = extractedPluginId;
+        }
+      } else if (isCallExpressionWithName(node, "createTranslationResource")) {
+        extractFromCreateTranslationResource(node);
+      } else if (isCallExpressionWithName(node, "createTranslationMessages")) {
+        extractFromCreateTranslationMessages(node);
+      } else if (isCallExpressionWithName(node, "defineMessages")) {
+        extractFromDefineMessages(node);
+      } else if (isCallExpressionWithName(node, "t")) {
+        extractFromTFunction(node);
+      } else if (isI18nTCall(node)) {
+        extractFromI18nT(node);
+      } else if (isUseTranslationTCall(node)) {
+        extractFromUseTranslationT(node);
+      }
+    };
+    const handleVariableStatement = (node) => {
+      extractFromVariableStatement(node);
+      extractFromTranslationRefDeclarations(node);
+    };
+    const handleJsxNode = (node) => {
+      extractFromJsxTrans(node);
+    };
+    const visit = (node) => {
+      if (ts__namespace.isCallExpression(node)) {
+        handleCallExpression(node);
+      } else if (ts__namespace.isVariableStatement(node)) {
+        handleVariableStatement(node);
+      } else if (ts__namespace.isJsxElement(node) || ts__namespace.isJsxSelfClosingElement(node)) {
+        handleJsxNode(node);
+      }
+      ts__namespace.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    if (invalidKeys.length > 0) {
+      console.warn(
+        `\u26A0\uFE0F  Skipped ${invalidKeys.length} invalid key(s) in ${filePath}: ${invalidKeys.slice(0, 5).join(", ")}${invalidKeys.length > 5 ? "..." : ""}`
+      );
+    }
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Warning: AST parsing failed for ${filePath}, falling back to regex: ${error}`
+    );
+    return { keys: extractKeysWithRegex(content), pluginId: null };
+  }
+  return { keys, pluginId };
+}
+function isValidKeyRegex(key) {
+  if (!key || key.trim() === "") {
+    return false;
+  }
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/.test(key);
+}
+function extractKeysWithRegex(content) {
+  const keys = {};
+  const patterns = [
+    // TranslationRef type declarations: readonly "key": "value"
+    // Pattern from .d.ts files: readonly "starredEntities.noStarredEntitiesMessage": "Click the star..."
+    /readonly\s+["']([^"']+)["']\s*:\s*["']([^"']*?)["']/g,
+    // t('key', 'value') - with second parameter
+    /t\s*\(\s*['"`]([^'"`]+?)['"`]\s*,\s*['"`]([^'"`]*?)['"`]\s*\)/g,
+    // t('key') - without second parameter
+    /t\s*\(\s*['"`]([^'"`]+?)['"`]\s*\)/g,
+    // i18n.t('key', 'value') - with second parameter
+    /i18n\s*\.\s*t\s*\(\s*['"`]([^'"`]+?)['"`]\s*,\s*['"`]([^'"`]*?)['"`]\s*\)/g,
+    // i18n.t('key') - without second parameter
+    /i18n\s*\.\s*t\s*\(\s*['"`]([^'"`]+?)['"`]\s*\)/g,
+    // useTranslation().t('key', 'value') - with second parameter
+    /useTranslation\s*\(\s*\)\s*\.\s*t\s*\(\s*['"`]([^'"`]+?)['"`]\s*,\s*['"`]([^'"`]*?)['"`]\s*\)/g,
+    // useTranslation().t('key') - without second parameter
+    /useTranslation\s*\(\s*\)\s*\.\s*t\s*\(\s*['"`]([^'"`]+?)['"`]\s*\)/g,
+    // Trans i18nKey="key"
+    /i18nKey\s*=\s*['"`]([^'"`]+?)['"`]/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const key = match[1];
+      if (!isValidKeyRegex(key)) {
+        continue;
+      }
+      const value = match[2] || key;
+      if (value && value !== key) {
+        keys[key] = value;
+      } else if (!keys[key]) {
+        keys[key] = key;
+      }
+    }
+  }
+  return keys;
+}
+
+exports.extractTranslationKeys = extractTranslationKeys;
+//# sourceMappingURL=extractKeys.cjs.js.map

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

@@ -0,0 +1,138 @@
+'use strict';
+
+var chalk = require('chalk');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+async function formatStatusReport(status, format, includeStats) {
+  switch (format.toLowerCase()) {
+    case "table":
+      return formatTableReport(status, includeStats);
+    case "json":
+      return formatJsonReport(status, includeStats);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function addHeader(lines) {
+  lines.push(chalk__default.default.blue("\u{1F4CA} Translation Status Report"));
+  lines.push(chalk__default.default.gray("\u2550".repeat(50)));
+}
+function addSummary(lines, status) {
+  lines.push(chalk__default.default.yellow("\n\u{1F4C8} Summary:"));
+  lines.push(`   Total Keys: ${status.totalKeys}`);
+  lines.push(`   Languages: ${status.languages.length}`);
+  lines.push(`   Overall Completion: ${status.overallCompletion.toFixed(1)}%`);
+}
+function addLanguageBreakdown(lines, status) {
+  if (status.languages.length === 0) {
+    return;
+  }
+  lines.push(chalk__default.default.yellow("\n\u{1F30D} Language Status:"));
+  lines.push(chalk__default.default.gray("   Language    | Translated | Total | Completion"));
+  lines.push(chalk__default.default.gray("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  for (const language of status.languages) {
+    const stats = status.languageStats[language];
+    const completion = stats.completion.toFixed(1);
+    const completionBar = getCompletionBar(stats.completion);
+    lines.push(
+      `   ${language.padEnd(12)} | ${stats.translated.toString().padStart(10)} | ${stats.total.toString().padStart(5)} | ${completion.padStart(8)}% ${completionBar}`
+    );
+  }
+}
+function addMissingKeys(lines, status) {
+  if (status.missingKeys.length === 0) {
+    return;
+  }
+  lines.push(chalk__default.default.red(`
+\u274C Missing Keys (${status.missingKeys.length}):`));
+  for (const key of status.missingKeys.slice(0, 10)) {
+    lines.push(chalk__default.default.gray(`   ${key}`));
+  }
+  if (status.missingKeys.length > 10) {
+    lines.push(chalk__default.default.gray(`   ... and ${status.missingKeys.length - 10} more`));
+  }
+}
+function addExtraKeys(lines, status) {
+  const languagesWithExtraKeys = status.languages.filter(
+    (lang) => status.extraKeys[lang] && status.extraKeys[lang].length > 0
+  );
+  if (languagesWithExtraKeys.length === 0) {
+    return;
+  }
+  lines.push(chalk__default.default.yellow(`
+\u26A0\uFE0F  Extra Keys:`));
+  for (const language of languagesWithExtraKeys) {
+    const extraKeys = status.extraKeys[language];
+    lines.push(chalk__default.default.gray(`   ${language}: ${extraKeys.length} extra keys`));
+    for (const key of extraKeys.slice(0, 5)) {
+      lines.push(chalk__default.default.gray(`     ${key}`));
+    }
+    if (extraKeys.length > 5) {
+      lines.push(chalk__default.default.gray(`     ... and ${extraKeys.length - 5} more`));
+    }
+  }
+}
+function addDetailedStats(lines, status) {
+  lines.push(chalk__default.default.yellow("\n\u{1F4CA} Detailed Statistics:"));
+  lines.push(`   Source Files: ${status.sourceFiles.length}`);
+  lines.push(
+    `   Total Translations: ${status.languages.reduce(
+      (sum, lang) => sum + (status.languageStats[lang]?.translated || 0),
+      0
+    )}`
+  );
+  lines.push(
+    `   Average Completion: ${(status.languages.reduce(
+      (sum, lang) => sum + (status.languageStats[lang]?.completion || 0),
+      0
+    ) / status.languages.length).toFixed(1)}%`
+  );
+}
+function formatTableReport(status, includeStats) {
+  const lines = [];
+  addHeader(lines);
+  addSummary(lines, status);
+  addLanguageBreakdown(lines, status);
+  addMissingKeys(lines, status);
+  addExtraKeys(lines, status);
+  if (includeStats) {
+    addDetailedStats(lines, status);
+  }
+  return lines.join("\n");
+}
+function formatJsonReport(status, includeStats) {
+  const summary = {
+    totalKeys: status.totalKeys,
+    languages: status.languages.length,
+    overallCompletion: status.overallCompletion
+  };
+  if (includeStats) {
+    summary.sourceFiles = status.sourceFiles.length;
+    summary.totalTranslations = status.languages.reduce(
+      (sum, lang) => sum + (status.languageStats[lang]?.translated || 0),
+      0
+    );
+    summary.averageCompletion = status.languages.reduce(
+      (sum, lang) => sum + (status.languageStats[lang]?.completion || 0),
+      0
+    ) / status.languages.length;
+  }
+  const report = {
+    summary,
+    languages: status.languageStats,
+    missingKeys: status.missingKeys,
+    extraKeys: status.extraKeys
+  };
+  return JSON.stringify(report, null, 2);
+}
+function getCompletionBar(completion) {
+  const filled = Math.floor(completion / 10);
+  const empty = 10 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+
+exports.formatStatusReport = formatStatusReport;
+//# sourceMappingURL=formatReport.cjs.js.map

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

@@ -0,0 +1,94 @@
+'use strict';
+
+var path = require('node:path');
+var fs = require('fs-extra');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function generateTranslationFiles(keys, outputPath, format) {
+  const outputDir = path__default.default.dirname(outputPath);
+  await fs__default.default.ensureDir(outputDir);
+  switch (format.toLowerCase()) {
+    case "json":
+      await generateJsonFile(keys, outputPath);
+      break;
+    case "po":
+      await generatePoFile(keys, outputPath);
+      break;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function isNestedStructure(data) {
+  const keys = Object.keys(data);
+  if (keys.length === 0) return true;
+  const firstKey = keys[0];
+  const firstValue = data[firstKey];
+  return typeof firstValue === "object" && firstValue !== null && "en" in firstValue;
+}
+async function generateJsonFile(keys, outputPath) {
+  const normalizeValue = (value) => {
+    return value.replaceAll(/'/g, "'").replaceAll(/'/g, "'").replaceAll(/"/g, '"').replaceAll(/"/g, '"');
+  };
+  if (isNestedStructure(keys)) {
+    const normalizedData = {};
+    for (const [pluginName, pluginData] of Object.entries(keys)) {
+      normalizedData[pluginName] = {
+        en: {}
+      };
+      for (const [key, value] of Object.entries(pluginData.en)) {
+        normalizedData[pluginName].en[key] = normalizeValue(value);
+      }
+    }
+    await fs__default.default.writeJson(outputPath, normalizedData, { spaces: 2 });
+  } else {
+    const normalizedKeys = {};
+    for (const [key, value] of Object.entries(keys)) {
+      normalizedKeys[key] = normalizeValue(value);
+    }
+    const data = {
+      metadata: {
+        generated: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "1.0",
+        totalKeys: Object.keys(normalizedKeys).length
+      },
+      translations: normalizedKeys
+    };
+    await fs__default.default.writeJson(outputPath, data, { spaces: 2 });
+  }
+}
+async function generatePoFile(keys, outputPath) {
+  const lines = [];
+  let flatKeys;
+  if (isNestedStructure(keys)) {
+    flatKeys = {};
+    for (const [pluginName, pluginData] of Object.entries(keys)) {
+      for (const [key, value] of Object.entries(pluginData.en)) {
+        flatKeys[`${pluginName}.${key}`] = value;
+      }
+    }
+  } else {
+    flatKeys = keys;
+  }
+  lines.push('msgid ""');
+  lines.push('msgstr ""');
+  lines.push(String.raw`"Content-Type: text/plain; charset=UTF-8\n"`);
+  lines.push(String.raw`"Generated: ${(/* @__PURE__ */ new Date()).toISOString()}\n"`);
+  lines.push(String.raw`"Total-Keys: ${Object.keys(flatKeys).length}\n"`);
+  lines.push("");
+  for (const [key, value] of Object.entries(flatKeys)) {
+    lines.push(`msgid "${escapePoString(key)}"`);
+    lines.push(`msgstr "${escapePoString(value)}"`);
+    lines.push("");
+  }
+  await fs__default.default.writeFile(outputPath, lines.join("\n"), "utf-8");
+}
+function escapePoString(str) {
+  return str.replaceAll(/\\/g, "\\\\").replaceAll(/"/g, '\\"').replaceAll(/\n/g, "\\n").replaceAll(/\r/g, "\\r").replaceAll(/\t/g, "\\t");
+}
+
+exports.generateTranslationFiles = generateTranslationFiles;
+//# sourceMappingURL=generateFiles.cjs.js.map