@liberfi.io/i18n 0.1.0

package/script/json-csv-converter.js

@@ -0,0 +1,201 @@
+const { validateI18nValue } = require("./utils");
+
+const separator = ".";
+
+function multiJson2Csv(jsonList, header) {
+  if (!Array.isArray(jsonList) || jsonList.length === 0) {
+    throw "Object array please.";
+  }
+
+  const baseJson = jsonList[0];
+  const baseKeys = Object.keys(baseJson);
+  const errors = {};
+  let result = header.length ? [header] : [];
+  for (const key of baseKeys) {
+    const values = [];
+    for (const [index, json] of jsonList.entries()) {
+      const val = json[key] || "";
+      values.push(val);
+      const bool = validateI18nValue(val);
+      if (!bool.valid) {
+        const locale = header[index + 1];
+        if (!errors[locale]) {
+          errors[locale] = {};
+        }
+        errors[locale][key] = baseJson[key];
+      }
+    }
+    result.push(stringsToCsvLine([key, ...values]));
+  }
+  if (Object.keys(errors).length > 0) {
+    throw new Error(
+      "valid i18n value failed, please check the value of the following values: " +
+        JSON.stringify(errors, null, 4),
+    );
+  }
+  return result.join("\n");
+}
+
+function csv2multiJson(csv) {
+  if (typeof csv !== "string") throw "String please.";
+  const json = {};
+
+  const lines = csvToLines(csv);
+  const csvLines = lines.filter(Boolean).map(parseCsvLine);
+  const headers = csvLines.shift()[0].split(",");
+  const errors = {};
+  for (const [index, header] of headers.entries()) {
+    json[header] = {};
+    for (const line of csvLines) {
+      const [key, ...values] = line;
+      const val = values[index];
+      json[header][key] = val;
+      const bool = validateI18nValue(val);
+      if (!bool.valid) {
+        if (!errors[header]) {
+          errors[header] = {};
+        }
+        errors[header][key] = values[0];
+      }
+    }
+
+    if (Object.values(json[header]).every((value) => !value)) {
+      delete json[header];
+    }
+  }
+
+  if (Object.keys(errors).length > 0) {
+    throw new Error(
+      "valid i18n value failed, please check the value of the following values: " +
+        JSON.stringify(errors, null, 4),
+    );
+  }
+
+  return json;
+}
+
+function json2Csv(json) {
+  if (typeof json !== "object" || !json) throw "Object please.";
+  return findKeyValues(json).join("\n");
+}
+
+function csv2Json(csv) {
+  if (typeof csv !== "string") throw "String please.";
+  const json = {};
+  parseCsvLines(csv).forEach((line) => {
+    const [path, value] = line;
+    const pathSplit = path.split(separator);
+    deepSet(json, pathSplit, value);
+  });
+  return json;
+}
+
+function findKeyValues(o, prefix, l = 0) {
+  let result = [];
+  for (const key of Object.keys(o)) {
+    const fullKey = prefix ? prefix + separator + key : key;
+    const value = o[key];
+    if (typeof value === "string") {
+      result.push(stringsToCsvLine([fullKey, value]));
+    } else if (typeof value === "object" && value) {
+      result = result.concat(findKeyValues(value, fullKey, l + 1));
+    }
+  }
+  return result;
+}
+
+function stringsToCsvLine(line) {
+  return line.map((s) => `"${s.replace(/"/g, '""')}"`).join(",");
+}
+
+function deepSet(o, path, value) {
+  if (path.length > 1) {
+    const key = path[0];
+    if (!o[key]) {
+      o[key] = {};
+    }
+    deepSet(o[key], path.slice(1), value);
+  } else {
+    o[path[0]] = value;
+  }
+}
+
+function parseCsvLines(csv) {
+  const lines = csvToLines(csv);
+  return lines.filter(Boolean).map(parseCsvLine);
+}
+
+function csvToLines(csv) {
+  return csv.split(/[\r\n]+/);
+}
+
+function parseCsvLine(line) {
+  const result = [];
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    switch (char) {
+      case ",":
+        continue;
+      case '"':
+        i++;
+      default:
+        const [str, i2] = parseCsvString(line, i);
+        i = i2;
+        result.push(str);
+    }
+  }
+  return result;
+}
+
+function parseCsvString(line, i) {
+  let result = "";
+  loop: for (; i < line.length; i++) {
+    const char = line[i];
+    switch (char) {
+      case '"':
+        i++;
+        if (line[i] === '"') {
+          result += '"';
+        } else {
+          break loop;
+        }
+        break;
+      default:
+        result += char;
+    }
+  }
+  return [result, i];
+}
+
+function getMissingKeys(jsonList, header) {
+  if (!Array.isArray(jsonList) || jsonList.length === 0) {
+    throw "Object array please.";
+  }
+
+  const baseJson = jsonList[0];
+  const baseKeys = Object.keys(baseJson);
+  const errors = {};
+  for (const key of baseKeys) {
+    for (const [index, json] of jsonList.entries()) {
+      const val = json[key] || "";
+      const bool = validateI18nValue(val);
+      if (!bool.valid) {
+        const locale = header[index + 1];
+        if (!errors[locale]) {
+          errors[locale] = {};
+        }
+        errors[locale][key] = baseJson[key];
+      }
+    }
+  }
+  return errors;
+}
+
+module.exports = {
+  separator,
+  json2Csv,
+  csv2Json,
+  multiJson2Csv,
+  csv2multiJson,
+  getMissingKeys,
+};

package/script/json2csv.js

@@ -0,0 +1,38 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { multiJson2Csv } = require("./json-csv-converter");
+const { checkFileExists, findJsonFiles } = require("./utils");
+const { LocaleEnum } = require("../dist");
+
+/** Convert multiple locale JSON files to a locale CSV file */
+async function json2csv(inputDir, outputPath) {
+  const inputFiles = await findJsonFiles(inputDir);
+
+  // Sort input files by locale
+  inputFiles.sort((a, b) => (b.startsWith(LocaleEnum.en) ? 1 : -1));
+
+  const jsonList = [];
+  const headers = [""];
+  for (const filePath of inputFiles) {
+    const json = await fs.readJSON(path.resolve(inputDir, filePath), {
+      encoding: "utf8",
+    });
+    jsonList.push(json);
+    const fileName = path.basename(filePath, path.extname(filePath));
+    headers.push(fileName);
+  }
+
+  const csv = multiJson2Csv(jsonList, headers);
+
+  const csvPath = path.resolve(outputPath);
+
+  await checkFileExists(csvPath);
+
+  await fs.outputFile(csvPath, csv, { encoding: "utf8" });
+
+  console.log("json2csv success =>", csvPath);
+}
+
+module.exports = {
+  json2csv,
+};

package/script/mergeJson.js

@@ -0,0 +1,62 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { checkFileExists, findJsonFiles } = require("./utils");
+const { LocaleEnum } = require("../dist");
+
+/**
+ * Merge default and extend JSON files back into one file
+ * @param {string} inputDir - The input directory containing both default and extend JSON files
+ * @param {string} outputDir - The output directory for merged JSON files
+ */
+async function mergeJson(inputDir, outputDir) {
+  const jsonFiles = await findJsonFiles(inputDir);
+
+  // Sort input files by locale
+  jsonFiles.sort((a, b) => (b.startsWith(LocaleEnum.en) ? 1 : -1));
+  let baseJson = {};
+
+  for (const [index, file] of jsonFiles.entries()) {
+    const defaultJsonPath = path.resolve(inputDir, file);
+    const extendJsonPath = path.resolve(inputDir, "extend", file);
+
+    // Read default JSON file
+    const defaultJson = await fs.readJSON(defaultJsonPath, {
+      encoding: "utf8",
+    });
+
+    // Read extend JSON file if it exists
+    let extendJson = {};
+    if (await fs.pathExists(extendJsonPath)) {
+      extendJson = await fs.readJSON(extendJsonPath, {
+        encoding: "utf8",
+      });
+    }
+
+    // Merge the JSON objects
+    const mergedJson = { ...defaultJson, ...extendJson };
+
+    let sortedJson = {};
+
+    // base json
+    if (index === 0) {
+      baseJson = mergedJson;
+      sortedJson = mergedJson;
+    } else {
+      for (const key of Object.keys(baseJson)) {
+        sortedJson[key] = mergedJson[key];
+      }
+    }
+
+    const outputPath = path.resolve(outputDir, file);
+
+    await fs.outputFile(outputPath, JSON.stringify(sortedJson, null, 2), {
+      encoding: "utf8",
+    });
+
+    console.log("mergeJson success =>", outputPath);
+  }
+}
+
+module.exports = {
+  mergeJson,
+};

package/script/separateJson.js

@@ -0,0 +1,50 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { checkFileExists, findJsonFiles } = require("./utils");
+
+/**
+ * Separate json file default and extend key values based on the key
+ * @param {string} inputDir - The input directory for locale JSON files
+ * @param {string} outputDir - The output directory for locale JSON files
+ * @param {string} separateKey - The key to separate the json files
+ */
+async function separateJson(inputDir, outputDir, separateKey) {
+  const jsonFiles = await findJsonFiles(inputDir);
+
+  const separateKeys = separateKey.split(",");
+  for (const file of jsonFiles) {
+    const json = await fs.readJSON(path.resolve(inputDir, file), {
+      encoding: "utf8",
+    });
+
+    const defaultJson = {};
+    const extendJson = {};
+    Object.keys(json).forEach((key) => {
+      if (separateKeys.some((k) => key.startsWith(k))) {
+        extendJson[key] = json[key];
+      } else {
+        defaultJson[key] = json[key];
+      }
+    });
+
+    const jsonPath = path.resolve(outputDir, file);
+    await checkFileExists(jsonPath);
+
+    await fs.outputFile(jsonPath, JSON.stringify(defaultJson, null, 2), {
+      encoding: "utf8",
+    });
+
+    const extendPath = path.resolve(outputDir, "extend", file);
+    await checkFileExists(extendPath);
+
+    await fs.outputFile(extendPath, JSON.stringify(extendJson, null, 2), {
+      encoding: "utf8",
+    });
+
+    console.log("separateJson success =>", jsonPath, extendPath);
+  }
+}
+
+module.exports = {
+  separateJson,
+};

package/script/utils.js

@@ -0,0 +1,88 @@
+const fs = require("fs-extra");
+
+async function checkFileExists(filePath) {
+  if (await fs.exists(filePath)) {
+    throw new Error(`${filePath} already exists, please modify file path`);
+  }
+}
+
+const i18nValidErrors = {
+  string: "Value must be a string",
+  empty: "Value cannot be empty",
+  interpolation: "Invalid interpolation",
+  mismatchedClosingTag: (tagName) => `Mismatched closing tag: </${tagName}>`,
+  unclosedTag: (tagName) => `Unclosed tag: <${tagName}>`,
+};
+
+/**
+ * Validate the value of i18n
+ * @param {string} value - The value to validate
+ * @returns {Object} - The validation result
+ */
+function validateI18nValue(value) {
+  if (typeof value !== "string") {
+    return { valid: false, error: i18nValidErrors.string };
+  }
+
+  // 1. check if value is empty
+  if (value.trim() === "") {
+    return { valid: false, error: i18nValidErrors.empty };
+  }
+
+  // 2. check if placeholder format is correct (allow `{{variable}}`)
+  // allow `{{variable}}` or `{{ variable }}`
+  const interpolationRegex = /{{\s*[\w.-]+\s*}}/g;
+  // check if `{{` is not closed or `}}` is not opened
+  const invalidInterpolationRegex =
+    /{{[^{}]*$|^[^{}]*}}|[^{]{{|}}[^}]}|^{|}$|{[^{}]*}|}/;
+
+  if (
+    value.match(invalidInterpolationRegex) &&
+    !value.match(interpolationRegex)
+  ) {
+    return { valid: false, error: i18nValidErrors.interpolation };
+  }
+
+  // 3. check if HTML tags are correctly closed
+  const tagRegex = /<\/?([a-zA-Z0-9]+)(\s*\/?)>/g;
+  let stack = [];
+  let match;
+
+  while ((match = tagRegex.exec(value)) !== null) {
+    let [, tagName, selfClosing] = match;
+
+    if (selfClosing === "/") {
+      // self-closing tag, no need to push to stack
+      continue;
+    } else if (match[0].startsWith("</")) {
+      // closing tag, check if stack top matches
+      if (stack.length === 0 || stack.pop() !== tagName) {
+        return {
+          valid: false,
+          error: i18nValidErrors.mismatchedClosingTag(tagName),
+        };
+      }
+    } else {
+      // opening tag, push to stack
+      stack.push(tagName);
+    }
+  }
+
+  if (stack.length > 0) {
+    return { valid: false, error: i18nValidErrors.unclosedTag(stack.pop()) };
+  }
+
+  return { valid: true, error: null };
+}
+
+async function findJsonFiles(dir) {
+  const files = await fs.readdir(dir);
+  return files.filter((file) => file.endsWith(".json"));
+}
+
+module.exports = {
+  checkFileExists,
+  validateI18nValue,
+  i18nValidErrors,
+  findJsonFiles,
+};