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

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

@@ -0,0 +1,93 @@
+'use strict';
+
+require('node:path');
+var fs = require('fs-extra');
+var translationUtils = require('../utils/translationUtils.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function extractPoString(line, prefixLength) {
+  return translationUtils.unescapePoString(
+    line.substring(prefixLength).replaceAll(/(^["']|["']$)/g, "")
+  );
+}
+function extractPoContinuation(line) {
+  return translationUtils.unescapePoString(line.replaceAll(/(^["']|["']$)/g, ""));
+}
+function processMsgIdLine(line, currentKey, currentValue, data) {
+  if (currentKey && currentValue) {
+    data[currentKey] = currentValue;
+  }
+  return {
+    key: extractPoString(line, 6),
+    value: "",
+    inMsgId: true,
+    inMsgStr: false
+  };
+}
+function processMsgStrLine(line) {
+  return {
+    value: extractPoString(line, 7),
+    inMsgId: false,
+    inMsgStr: true
+  };
+}
+function processContinuationLine(line, currentKey, currentValue, inMsgId, inMsgStr) {
+  const value = extractPoContinuation(line);
+  return {
+    key: inMsgId ? currentKey + value : currentKey,
+    value: inMsgStr ? currentValue + value : currentValue
+  };
+}
+async function loadPoFile(filePath) {
+  try {
+    const content = await fs__default.default.readFile(filePath, "utf-8");
+    const data = {};
+    const lines = content.split("\n");
+    let currentKey = "";
+    let currentValue = "";
+    let inMsgId = false;
+    let inMsgStr = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("msgid ")) {
+        const result = processMsgIdLine(
+          trimmed,
+          currentKey,
+          currentValue,
+          data
+        );
+        currentKey = result.key;
+        currentValue = result.value;
+        inMsgId = result.inMsgId;
+        inMsgStr = result.inMsgStr;
+      } else if (trimmed.startsWith("msgstr ")) {
+        const result = processMsgStrLine(trimmed);
+        currentValue = result.value;
+        inMsgId = result.inMsgId;
+        inMsgStr = result.inMsgStr;
+      } else if (trimmed.startsWith('"') && (inMsgId || inMsgStr)) {
+        const result = processContinuationLine(
+          trimmed,
+          currentKey,
+          currentValue,
+          inMsgId,
+          inMsgStr
+        );
+        currentKey = result.key;
+        currentValue = result.value;
+      }
+    }
+    if (currentKey && currentValue) {
+      data[currentKey] = currentValue;
+    }
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to load PO file ${filePath}: ${error}`);
+  }
+}
+
+exports.loadPoFile = loadPoFile;
+//# sourceMappingURL=loadFile.cjs.js.map

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

@@ -0,0 +1,126 @@
+'use strict';
+
+var fs = require('fs-extra');
+var translationUtils = require('../utils/translationUtils.cjs.js');
+var loadFile = require('./loadFile.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+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;
+}
+async function loadExistingFile(existingPath, format) {
+  try {
+    switch (format.toLowerCase()) {
+      case "json":
+        return await loadJsonFile(existingPath);
+      case "po":
+        return await loadFile.loadPoFile(existingPath);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  } catch (error) {
+    console.warn(
+      `Warning: Could not load existing file ${existingPath}: ${error}`
+    );
+    return {};
+  }
+}
+function mergeNestedStructures(newKeys, existingData) {
+  if (!isNestedStructure(existingData)) {
+    return newKeys;
+  }
+  const mergedData = { ...existingData };
+  for (const [pluginName, pluginData] of Object.entries(newKeys)) {
+    if (mergedData[pluginName]) {
+      mergedData[pluginName] = {
+        en: { ...mergedData[pluginName].en, ...pluginData.en }
+      };
+    } else {
+      mergedData[pluginName] = pluginData;
+    }
+  }
+  return mergedData;
+}
+function mergeFlatStructures(newKeys, existingData) {
+  const existingFlat = isNestedStructure(existingData) ? {} : existingData;
+  return { ...existingFlat, ...newKeys };
+}
+async function saveMergedFlatData(mergedData, existingPath, format) {
+  switch (format.toLowerCase()) {
+    case "json":
+      await saveJsonFile(mergedData, existingPath);
+      break;
+    case "po":
+      await savePoFile(mergedData, existingPath);
+      break;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+async function mergeTranslationFiles(newKeys, existingPath, format) {
+  if (!await fs__default.default.pathExists(existingPath)) {
+    throw new Error(`Existing file not found: ${existingPath}`);
+  }
+  const existingData = await loadExistingFile(existingPath, format);
+  if (isNestedStructure(newKeys)) {
+    const mergedData = mergeNestedStructures(newKeys, existingData);
+    await saveNestedJsonFile(mergedData, existingPath);
+  } else {
+    const mergedData = mergeFlatStructures(newKeys, existingData);
+    await saveMergedFlatData(mergedData, existingPath, format);
+  }
+}
+async function loadJsonFile(filePath) {
+  const data = await fs__default.default.readJson(filePath);
+  if (isNestedStructure(data)) {
+    return data;
+  }
+  if (data.translations && typeof data.translations === "object") {
+    return data.translations;
+  }
+  if (typeof data === "object" && data !== null) {
+    return data;
+  }
+  return {};
+}
+async function saveJsonFile(data, filePath) {
+  const output = {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "1.0",
+      totalKeys: Object.keys(data).length
+    },
+    translations: data
+  };
+  await fs__default.default.writeJson(filePath, output, { spaces: 2 });
+}
+async function saveNestedJsonFile(data, filePath) {
+  await fs__default.default.writeJson(filePath, data, { spaces: 2 });
+}
+async function savePoFile(data, filePath) {
+  const headerLines = [
+    'msgid ""',
+    'msgstr ""',
+    String.raw`"Content-Type: text/plain; charset=UTF-8\n"`,
+    String.raw`"Generated: ${(/* @__PURE__ */ new Date()).toISOString()}\n"`,
+    String.raw`"Total-Keys: ${Object.keys(data).length}\n"`,
+    ""
+  ];
+  const translationLines = Object.entries(data).flatMap(([key, value]) => [
+    `msgid "${translationUtils.escapePoString(key)}"`,
+    `msgstr "${translationUtils.escapePoString(value)}"`,
+    ""
+  ]);
+  const lines = [...headerLines, ...translationLines];
+  await fs__default.default.writeFile(filePath, lines.join("\n"), "utf-8");
+}
+
+exports.mergeTranslationFiles = mergeTranslationFiles;
+//# sourceMappingURL=mergeFiles.cjs.js.map

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

@@ -0,0 +1,83 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+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);
+
+function getCacheDir() {
+  return path__default.default.join(process.cwd(), ".i18n-cache");
+}
+function getCacheFilePath(projectId, tmsUrl) {
+  const cacheDir = getCacheDir();
+  const safeProjectId = projectId.replaceAll(/[^a-zA-Z0-9]/g, "_");
+  const urlHash = node_crypto.createHash("sha256").update(tmsUrl).digest("hex").substring(0, 8);
+  return path__default.default.join(cacheDir, `upload_${safeProjectId}_${urlHash}.json`);
+}
+async function calculateFileHash(filePath) {
+  const content = await fs__default.default.readFile(filePath, "utf-8");
+  const data = JSON.parse(content);
+  if (data.metadata) {
+    delete data.metadata.generated;
+  }
+  const normalizedContent = JSON.stringify(data, null, 2);
+  return node_crypto.createHash("sha256").update(normalizedContent).digest("hex");
+}
+async function getCachedUpload(filePath, projectId, tmsUrl) {
+  try {
+    const cacheFilePath = getCacheFilePath(projectId, tmsUrl);
+    if (!await fs__default.default.pathExists(cacheFilePath)) {
+      return null;
+    }
+    const cacheData = await fs__default.default.readJson(cacheFilePath);
+    const entry = cacheData;
+    if (entry.filePath !== filePath) {
+      return null;
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}
+async function hasFileChanged(filePath, projectId, tmsUrl) {
+  const cachedEntry = await getCachedUpload(filePath, projectId, tmsUrl);
+  if (!cachedEntry) {
+    return true;
+  }
+  if (!await fs__default.default.pathExists(filePath)) {
+    return true;
+  }
+  const currentHash = await calculateFileHash(filePath);
+  return currentHash !== cachedEntry.fileHash;
+}
+async function saveUploadCache(filePath, projectId, tmsUrl, keyCount, uploadFileName) {
+  try {
+    const cacheDir = getCacheDir();
+    await fs__default.default.ensureDir(cacheDir);
+    const fileHash = await calculateFileHash(filePath);
+    const cacheEntry = {
+      filePath,
+      fileHash,
+      projectId,
+      tmsUrl,
+      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      keyCount,
+      uploadFileName
+      // Store the upload filename to track what was actually uploaded
+    };
+    const cacheFilePath = getCacheFilePath(projectId, tmsUrl);
+    await fs__default.default.writeJson(cacheFilePath, cacheEntry, { spaces: 2 });
+  } catch (error) {
+    console.warn(`Warning: Failed to save upload cache: ${error}`);
+  }
+}
+
+exports.calculateFileHash = calculateFileHash;
+exports.getCachedUpload = getCachedUpload;
+exports.hasFileChanged = hasFileChanged;
+exports.saveUploadCache = saveUploadCache;
+//# sourceMappingURL=uploadCache.cjs.js.map

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

@@ -0,0 +1,189 @@
+'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 validateTranslationFile(filePath) {
+  try {
+    const ext = path__default.default.extname(filePath).toLowerCase();
+    switch (ext) {
+      case ".json":
+        return await validateJsonFile(filePath);
+      case ".po":
+        return await validatePoFile(filePath);
+      default:
+        throw new Error(`Unsupported file format: ${ext}`);
+    }
+  } catch (error) {
+    console.error(`Validation error for ${filePath}:`, error);
+    return false;
+  }
+}
+function validateFileContent(content) {
+  if (!isValidUTF8(content)) {
+    throw new Error("File contains invalid UTF-8 sequences");
+  }
+  if (content.includes("\0")) {
+    throw new Error(
+      String.raw`File contains null bytes (\x00) which are not valid in JSON`
+    );
+  }
+}
+function parseJsonContent(content) {
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch (parseError) {
+    throw new Error(
+      `JSON parse error: ${parseError instanceof Error ? parseError.message : "Unknown error"}`
+    );
+  }
+  if (typeof data !== "object" || data === null) {
+    throw new TypeError("Root element must be a JSON object");
+  }
+  return data;
+}
+function isNestedStructure(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const firstKey = Object.keys(obj)[0];
+  if (!firstKey) return false;
+  const firstValue = obj[firstKey];
+  return typeof firstValue === "object" && firstValue !== null && "en" in firstValue;
+}
+function validateTranslationValue(value, keyPath) {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `Translation value for "${keyPath}" must be a string, got ${typeof value}`
+    );
+  }
+  if (value.includes("\0")) {
+    throw new Error(`Translation value for "${keyPath}" contains null byte`);
+  }
+  const curlyApostrophe = /[\u2018\u2019]/;
+  const curlyQuotes = /[\u201C\u201D]/;
+  if (curlyApostrophe.test(value) || curlyQuotes.test(value)) {
+    console.warn(
+      `Warning: Translation value for "${keyPath}" contains Unicode curly quotes/apostrophes.`
+    );
+    console.warn(`  Consider normalizing to standard quotes: ' \u2192 ' and " \u2192 "`);
+  }
+}
+function validateNestedStructure(data) {
+  let totalKeys = 0;
+  for (const [pluginName, pluginData] of Object.entries(data)) {
+    if (typeof pluginData !== "object" || pluginData === null) {
+      throw new TypeError(`Plugin "${pluginName}" must be an object`);
+    }
+    if (!("en" in pluginData)) {
+      throw new Error(`Plugin "${pluginName}" must have an "en" property`);
+    }
+    const enData = pluginData.en;
+    if (typeof enData !== "object" || enData === null) {
+      throw new TypeError(`Plugin "${pluginName}".en must be an object`);
+    }
+    for (const [key, value] of Object.entries(enData)) {
+      validateTranslationValue(value, `${pluginName}.en.${key}`);
+      totalKeys++;
+    }
+  }
+  return totalKeys;
+}
+function validateFlatStructure(data) {
+  const translations = data.translations || data;
+  if (typeof translations !== "object" || translations === null) {
+    throw new TypeError("Translations must be an object");
+  }
+  let totalKeys = 0;
+  for (const [key, value] of Object.entries(translations)) {
+    validateTranslationValue(value, key);
+    totalKeys++;
+  }
+  return totalKeys;
+}
+function countNestedKeys(data) {
+  let count = 0;
+  for (const pluginData of Object.values(data)) {
+    if (pluginData.en && typeof pluginData.en === "object") {
+      count += Object.keys(pluginData.en).length;
+    }
+  }
+  return count;
+}
+function countFlatKeys(data) {
+  const translations = data.translations || data;
+  return Object.keys(translations).length;
+}
+function validateRoundTrip(data, originalKeyCount) {
+  const reStringified = JSON.stringify(data, null, 2);
+  const reparsed = JSON.parse(reStringified);
+  const reparsedKeys = isNestedStructure(reparsed) ? countNestedKeys(reparsed) : countFlatKeys(reparsed);
+  if (originalKeyCount !== reparsedKeys) {
+    throw new Error(
+      `Key count mismatch: original has ${originalKeyCount} keys, reparsed has ${reparsedKeys} keys`
+    );
+  }
+}
+async function validateJsonFile(filePath) {
+  try {
+    const content = await fs__default.default.readFile(filePath, "utf-8");
+    validateFileContent(content);
+    const data = parseJsonContent(content);
+    const totalKeys = isNestedStructure(data) ? validateNestedStructure(data) : validateFlatStructure(data);
+    validateRoundTrip(data, totalKeys);
+    return true;
+  } catch (error) {
+    console.error(
+      `JSON validation error for ${filePath}:`,
+      error instanceof Error ? error.message : error
+    );
+    return false;
+  }
+}
+function isValidUTF8(str) {
+  try {
+    const encoded = Buffer.from(str, "utf-8");
+    const decoded = encoded.toString("utf-8");
+    return decoded === str;
+  } catch {
+    return false;
+  }
+}
+async function validatePoFile(filePath) {
+  try {
+    const content = await fs__default.default.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    let hasMsgId = false;
+    let hasMsgStr = false;
+    let inEntry = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("msgid ")) {
+        hasMsgId = true;
+        inEntry = true;
+      } else if (trimmed.startsWith("msgstr ")) {
+        hasMsgStr = true;
+      } else if (trimmed === "" && inEntry) {
+        if (!hasMsgId || !hasMsgStr) {
+          return false;
+        }
+        hasMsgId = false;
+        hasMsgStr = false;
+        inEntry = false;
+      }
+    }
+    if (inEntry && (!hasMsgId || !hasMsgStr)) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+exports.validateTranslationFile = validateTranslationFile;
+//# sourceMappingURL=validateFile.cjs.js.map

package/dist/lib/paths.cjs.js

@@ -0,0 +1,51 @@
+'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);
+
+function findProjectRoot() {
+  let currentDir = process.cwd();
+  const root = path__default.default.parse(currentDir).root;
+  let gitRoot = null;
+  while (currentDir !== root) {
+    const gitDir = path__default.default.join(currentDir, ".git");
+    if (fs__default.default.existsSync(gitDir)) {
+      gitRoot = currentDir;
+      break;
+    }
+    const parentDir = path__default.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  if (gitRoot) {
+    const gitRootConfig = path__default.default.join(gitRoot, ".i18n.config.json");
+    if (fs__default.default.existsSync(gitRootConfig)) {
+      return gitRoot;
+    }
+  }
+  currentDir = process.cwd();
+  while (currentDir !== root) {
+    const configFile = path__default.default.join(currentDir, ".i18n.config.json");
+    if (fs__default.default.existsSync(configFile)) {
+      return currentDir;
+    }
+    const parentDir = path__default.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return gitRoot || process.cwd();
+}
+const paths = {
+  targetDir: findProjectRoot()};
+
+exports.paths = paths;
+//# sourceMappingURL=paths.cjs.js.map

package/dist/lib/utils/exec.cjs.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var child_process = require('child_process');
+var os = require('node:os');
+
+function safeExecSync(command, args = [], options = {}) {
+  const defaultOptions = {
+    encoding: "utf-8",
+    stdio: "pipe",
+    ...options
+  };
+  const result = child_process.spawnSync(command, args, defaultOptions);
+  return {
+    stdout: (result.stdout?.toString() || "").trim(),
+    stderr: (result.stderr?.toString() || "").trim(),
+    status: result.status,
+    error: result.error
+  };
+}
+function commandExists(command) {
+  const isWindows = os.platform() === "win32";
+  const checkCommand = isWindows ? "where" : "which";
+  const result = safeExecSync(checkCommand, [command], { stdio: "pipe" });
+  return result.status === 0 && result.stdout.length > 0;
+}
+function safeExecSyncOrThrow(command, args = [], options = {}) {
+  const result = safeExecSync(command, args, options);
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const errorMessage = result.stderr || `Command failed with status ${result.status}`;
+    throw new Error(errorMessage);
+  }
+  return result.stdout;
+}
+
+exports.commandExists = commandExists;
+exports.safeExecSync = safeExecSync;
+exports.safeExecSyncOrThrow = safeExecSyncOrThrow;
+//# sourceMappingURL=exec.cjs.js.map

package/dist/lib/utils/translationUtils.cjs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+function countTranslationKeys(data) {
+  if (!data || typeof data !== "object") {
+    return 0;
+  }
+  const isNested = Object.values(data).some(
+    (val) => typeof val === "object" && val !== null && "en" in val
+  );
+  if (isNested) {
+    let keyCount = 0;
+    for (const pluginData of Object.values(data)) {
+      const enData = pluginData?.en;
+      if (enData && typeof enData === "object") {
+        keyCount += Object.keys(enData).length;
+      }
+    }
+    return keyCount;
+  }
+  const translations = data.translations || data;
+  return Object.keys(translations).length;
+}
+function escapePoString(str) {
+  return str.replaceAll(/\\/g, "\\\\").replaceAll(/"/g, '\\"').replaceAll(/\n/g, "\\n").replaceAll(/\r/g, "\\r").replaceAll(/\t/g, "\\t");
+}
+function unescapePoString(str) {
+  return str.replaceAll(/\\n/g, "\n").replaceAll(/\\r/g, "\r").replaceAll(/\\t/g, "	").replaceAll(/\\"/g, '"').replaceAll(/\\\\/g, "\\");
+}
+
+exports.countTranslationKeys = countTranslationKeys;
+exports.escapePoString = escapePoString;
+exports.unescapePoString = unescapePoString;
+//# sourceMappingURL=translationUtils.cjs.js.map

package/dist/lib/version.cjs.js

@@ -0,0 +1,38 @@
+'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);
+
+function findVersion() {
+  try {
+    const possiblePaths = [
+      // From package root (most common case)
+      path__default.default.resolve(process.cwd(), "package.json"),
+      // From workspace root if running from translations workspace
+      path__default.default.resolve(process.cwd(), "..", "..", "package.json"),
+      // From repo root if running from monorepo root
+      path__default.default.resolve(
+        process.cwd(),
+        "workspaces/translations/packages/cli/package.json"
+      )
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (fs__default.default.existsSync(pkgPath)) {
+        const pkgContent = fs__default.default.readFileSync(pkgPath, "utf8");
+        return JSON.parse(pkgContent).version;
+      }
+    }
+    return "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+const version = findVersion();
+
+exports.version = version;
+//# sourceMappingURL=version.cjs.js.map