@lingual/i18n-check 0.1.0

package/src/utils/findInvalidi18nTranslations.test.ts

@@ -0,0 +1,213 @@
+import {
+  compareTranslationFiles,
+  findInvalid18nTranslations,
+} from "./findInvalidi18nTranslations";
+import { flattenTranslations } from "./flattenTranslations";
+
+const sourceFile = require("../../translations/i18NextMessageExamples/en-us.json");
+const targetFile = require("../../translations/i18NextMessageExamples/de-de.json");
+
+describe("findInvalid18nTranslations:compareTranslationFiles", () => {
+  it("should return empty array if files are identical", () => {
+    expect(
+      compareTranslationFiles(
+        flattenTranslations(sourceFile),
+        flattenTranslations(sourceFile)
+      )
+    ).toEqual([]);
+  });
+
+  it("should return the invalid keys in the target file", () => {
+    expect(
+      compareTranslationFiles(
+        flattenTranslations({
+          ...sourceFile,
+          "ten.eleven.twelve": "ten eleven twelve",
+        }),
+        flattenTranslations(targetFile)
+      )
+    ).toEqual(["key_with_broken_de", "intlNumber_broken_de"]);
+  });
+
+  it("should return empty array if placeholders are identical but in different positions", () => {
+    expect(
+      compareTranslationFiles(
+        {
+          basic: "added {{this}} and {{that}} should work.",
+        },
+        {
+          basic: "It is {{this}} with different position {{that}}",
+        }
+      )
+    ).toEqual([]);
+  });
+
+  it("should return the invalid key if tags are not identical", () => {
+    expect(
+      compareTranslationFiles(
+        {
+          tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+        },
+        {
+          tag: "There is some <b>bold text</b> and some other <span>italic</span> text.",
+        }
+      )
+    ).toEqual(["tag"]);
+  });
+
+  it("should return empty array if tags are identical", () => {
+    expect(
+      compareTranslationFiles(
+        {
+          tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+        },
+        {
+          tag: "There is some <b>bold text</b> and some other <i>italic</i> text.",
+        }
+      )
+    ).toEqual([]);
+  });
+});
+
+describe("findInvalidTranslations", () => {
+  it("should return an empty object if all files have no invalid keys", () => {
+    expect(findInvalid18nTranslations(sourceFile, { de: sourceFile })).toEqual(
+      {}
+    );
+  });
+
+  it("should return an object containing the keys for the missing language", () => {
+    expect(
+      findInvalid18nTranslations(
+        { ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" },
+        { de: targetFile }
+      )
+    ).toEqual({ de: ["key_with_broken_de", "intlNumber_broken_de"] });
+  });
+
+  it("should return an object containing the keys for every language with missing key", () => {
+    expect(
+      findInvalid18nTranslations(
+        { ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" },
+        {
+          de: targetFile,
+          fr: {
+            key_with_broken_de:
+              "Some format {{value, formatname}} and some other format {{value, formatname}}",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["key_with_broken_de", "intlNumber_broken_de"],
+      fr: ["key_with_broken_de"],
+    });
+  });
+
+  it("should find invalid interval", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          key1_interval:
+            "(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];",
+        },
+        {
+          de: {
+            key1_interval:
+              "(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["key1_interval"],
+    });
+  });
+
+  it("should find invalid nested interpolation", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          "tree.one": "added {{something}}",
+        },
+        {
+          de: {
+            "tree.one": "added {{somethings}}",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["tree.one"],
+    });
+  });
+
+  it("should find invalid relative time formatting", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          intlRelativeTimeWithOptionsExplicit:
+            "Lorem {{val, relativetime(range: quarter; style: narrow;)}}",
+        },
+        {
+          de: {
+            intlRelativeTimeWithOptionsExplicit:
+              "Lorem {{val, relativetime(range: quarter; style: long;)}}",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["intlRelativeTimeWithOptionsExplicit"],
+    });
+  });
+
+  it("should find invalid key with options", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          keyWithOptions:
+            "Some format {{value, formatname(option1Name: option1Value; option2Name: option2Value)}}",
+        },
+        {
+          de: {
+            keyWithOptions:
+              "Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["keyWithOptions"],
+    });
+  });
+
+  it("should find invalid nesting", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          nesting1: "1 $t(nesting2)",
+        },
+        {
+          de: {
+            nesting1: "1 $t(nesting3)",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["nesting1"],
+    });
+  });
+
+  it("should find invalid tags", () => {
+    expect(
+      findInvalid18nTranslations(
+        {
+          tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+        },
+        {
+          de: {
+            tag: "There is some <b>bold text</b> and some other <span>text inside a span</span>!",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["tag"],
+    });
+  });
+});

package/src/utils/findInvalidi18nTranslations.ts

@@ -0,0 +1,137 @@
+/**
+ *
+ * i18next specific invalid translations check
+ *
+ *
+ */
+
+import { parse, MessageFormatElement } from "./i18NextParser";
+import { Translation } from "../types";
+
+export const findInvalid18nTranslations = (
+  source: Translation,
+  targets: Record<string, Translation>
+) => {
+  let differences = {};
+  if (Object.keys(targets).length === 0) {
+    return differences;
+  }
+
+  for (const [lang, file] of Object.entries(targets)) {
+    const result = compareTranslationFiles(source, file);
+
+    if (result.length > 0) {
+      differences = Object.assign(differences, { [lang]: result });
+    }
+  }
+
+  return differences;
+};
+
+export const compareTranslationFiles = (a: Translation, b: Translation) => {
+  let diffs: unknown[] = [];
+  for (const key in a) {
+    if (
+      b[key] !== undefined &&
+      hasDiff(parse(String(a[key])), parse(String(b[key])))
+    ) {
+      diffs.push(key);
+    }
+  }
+  return diffs;
+};
+
+const lookUp: Record<MessageFormatElement["type"], number> = {
+  text: 0,
+  interpolation: 1,
+  interpolation_unescaped: 2,
+  nesting: 3,
+  plural: 4,
+  tag: 5,
+};
+
+const sortParsedKeys = (a: MessageFormatElement, b: MessageFormatElement) => {
+  if (a.type === b.type && a.type !== "tag" && b.type !== "tag") {
+    return a.content < b.content ? -1 : 1;
+  }
+
+  if (a.type === "tag" && b.type === "tag") {
+    return a.raw < b.raw ? -1 : 1;
+  }
+
+  return lookUp[a.type] - lookUp[b.type];
+};
+
+export const hasDiff = (
+  a: MessageFormatElement[],
+  b: MessageFormatElement[]
+) => {
+  const compA = a
+    .filter((element) => element.type !== "text")
+    .sort(sortParsedKeys);
+  const compB = b
+    .filter((element) => element.type !== "text")
+    .sort(sortParsedKeys);
+
+  if (compA.length !== compB.length) {
+    return true;
+  }
+
+  const hasErrors = compA.some((formatElementA, index) => {
+    const formatElementB = compB[index];
+
+    if (formatElementA.type !== formatElementB.type) {
+      return true;
+    }
+
+    if (formatElementA.type === "text" && formatElementB.type === "text") {
+      return false;
+    }
+
+    if (formatElementA.type === "tag" && formatElementB.type === "tag") {
+      return (
+        formatElementA.raw !== formatElementB.raw ||
+        formatElementA.voidElement !== formatElementB.voidElement
+      );
+    }
+
+    if (
+      (formatElementA.type === "interpolation" &&
+        formatElementB.type === "interpolation") ||
+      (formatElementA.type === "interpolation_unescaped" &&
+        formatElementB.type === "interpolation_unescaped") ||
+      (formatElementA.type === "nesting" &&
+        formatElementB.type === "nesting") ||
+      (formatElementA.type === "plural" && formatElementB.type === "plural")
+    ) {
+      const optionsA = formatElementA.variable
+        .split(",")
+        .map((value) => value.trim())
+        .sort()
+        .join("-")
+        .trim();
+      const optionsB = formatElementB.variable
+        .split(",")
+        .map((value) => value.trim())
+        .sort()
+        .join("-")
+        .trim();
+
+      if (optionsA !== optionsB) {
+        return true;
+      }
+
+      if (formatElementA.prefix !== formatElementA.prefix) {
+        return true;
+      }
+
+      if (formatElementA.suffix !== formatElementA.suffix) {
+        return true;
+      }
+    }
+
+    return false;
+  });
+
+  return hasErrors;
+};

package/src/utils/findMissingKeys.test.ts

@@ -0,0 +1,60 @@
+import { compareTranslationFiles, findMissingKeys } from "./findMissingKeys";
+
+const sourceFile = {
+  "one.two.three": "one two three",
+  "four.five.six": "four five six",
+  "seven.eight.nine": "seven eight nine",
+};
+const secondaryFile = {
+  "one.two.three": "one two three",
+  "four.five.six": "four five six",
+  "seven.eight.nine": "seven eight nine",
+};
+
+describe("findMissingKeys:compareTranslationFiles", () => {
+  it("should return empty array if files are identical", () => {
+    expect(compareTranslationFiles(sourceFile, secondaryFile)).toEqual([]);
+  });
+
+  it("should return the missing keys in the secondary file", () => {
+    expect(
+      compareTranslationFiles(
+        { ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" },
+        secondaryFile
+      )
+    ).toEqual(["ten.eleven.twelve"]);
+  });
+});
+
+describe("findMissingKeys", () => {
+  it("should return an empty object if all files have no missing keys", () => {
+    expect(findMissingKeys(sourceFile, { de: secondaryFile })).toEqual({});
+  });
+
+  it("should return an object containing the keys for the missing language", () => {
+    expect(
+      findMissingKeys(
+        { ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" },
+        { de: secondaryFile }
+      )
+    ).toEqual({ de: ["ten.eleven.twelve"] });
+  });
+
+  it("should return an object containing the keys for every language with missing key", () => {
+    expect(
+      findMissingKeys(
+        { ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" },
+        {
+          de: secondaryFile,
+          fr: {
+            "four.five.six": "four five six",
+            "seven.eight.nine": "seven eight nine",
+          },
+        }
+      )
+    ).toEqual({
+      de: ["ten.eleven.twelve"],
+      fr: ["one.two.three", "ten.eleven.twelve"],
+    });
+  });
+});

package/src/utils/findMissingKeys.ts

@@ -0,0 +1,27 @@
+import { Translation } from "../types";
+
+export const findMissingKeys = (
+  source: Translation,
+  targets: Record<string, Translation>
+) => {
+  let differences = {};
+  for (const [lang, file] of Object.entries(targets)) {
+    const result = compareTranslationFiles(source, file);
+    if (result.length > 0) {
+      differences = Object.assign(differences, { [lang]: result });
+    }
+  }
+
+  return differences;
+};
+
+export const compareTranslationFiles = (a: Translation, b: Translation) => {
+  let diffs = [];
+  for (const key in a) {
+    const counterKey = b[key];
+    if (!counterKey) {
+      diffs.push(key);
+    }
+  }
+  return diffs;
+};

package/src/utils/flattenTranslations.test.ts

@@ -0,0 +1,32 @@
+import { flattenEntry, flattenTranslations } from "./flattenTranslations";
+
+const flatStructure = require("../../translations/en-us.json");
+const nestedStructure = require("../../translations/flattenExamples/en-us.json");
+
+const expectedFlatStructure = {
+  "test.drive.one": "testing one",
+  "test.drive.two": "testing two",
+  "other.nested.three": "testing three",
+  "other.nested.deep.more.final": "nested translation",
+};
+
+describe("flattenTranslations", () => {
+  it("should do nothing if the file structure is flat", () => {
+    expect(flattenTranslations(flatStructure)).toEqual(flatStructure);
+  });
+  describe("flattenEntry", () => {
+    it("should flatten a nested object", () => {
+      expect(
+        flattenEntry({
+          a: {
+            b: { c: "one" },
+          },
+        })
+      ).toEqual({ "a.b.c": "one" });
+    });
+  });
+
+  it("should do nothing if the file structure is flat", () => {
+    expect(flattenTranslations(nestedStructure)).toEqual(expectedFlatStructure);
+  });
+});

package/src/utils/flattenTranslations.ts

@@ -0,0 +1,42 @@
+import { Translation } from "../types";
+
+export const flattenTranslations = (translations: Translation) => {
+  if (!hasNestedDefinitions(translations)) {
+    return translations;
+  }
+  return flattenEntry(translations);
+};
+
+/**
+ * Top level search for any objects
+ */
+const hasNestedDefinitions = (translations: Translation) => {
+  return Object.values(translations).find(
+    (translation) => typeof translation === "object"
+  );
+};
+
+const isTranslationObject = (entry: unknown): entry is Translation => {
+  return typeof entry === "object";
+};
+
+export const flattenEntry = (
+  entry: Translation,
+  keys: string[] = []
+): Translation => {
+  let result = {};
+  if (!entry) {
+    return result;
+  }
+  const entries = Object.entries(entry);
+  for (const [k, v] of entries) {
+    Object.assign(
+      result,
+      isTranslationObject(v)
+        ? flattenEntry(v, [...keys, String(k)])
+        : { [[...keys, String(k)].join(".")]: v }
+    );
+  }
+
+  return result;
+};

package/src/utils/i18NextParser.test.ts

@@ -0,0 +1,169 @@
+import { parse } from "./i18NextParser";
+
+describe("i18NextParser", () => {
+  it("should parse interpolation", () => {
+    expect(
+      parse(
+        "test {{val}} text {{- encoded}} with {{val, format}} some $t{nesting} help"
+      )
+    ).toEqual([
+      {
+        type: "text",
+        content: "test ",
+      },
+      {
+        type: "interpolation",
+        raw: "{{val}}",
+        prefix: "{{",
+        suffix: "}}",
+        content: "val",
+        variable: "val",
+      },
+      {
+        type: "text",
+        content: " text ",
+      },
+      {
+        type: "interpolation_unescaped",
+        raw: "{{- encoded}}",
+        prefix: "{{-",
+        suffix: "}}",
+        content: " encoded",
+        variable: "encoded",
+      },
+      {
+        type: "text",
+        content: " with ",
+      },
+      {
+        type: "interpolation",
+        raw: "{{val, format}}",
+        prefix: "{{",
+        suffix: "}}",
+        content: "val, format",
+        variable: "val, format",
+      },
+      {
+        type: "text",
+        content: " some ",
+      },
+      {
+        type: "nesting",
+        raw: "$t{nesting}",
+        prefix: "$t{",
+        suffix: "}",
+        content: "nesting",
+        variable: "nesting",
+      },
+      {
+        type: "text",
+        content: " help",
+      },
+    ]);
+  });
+
+  it("should parse plural translations", () => {
+    expect(
+      parse("(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];")
+    ).toEqual([
+      {
+        type: "plural",
+        raw: "(1)",
+        prefix: "(",
+        suffix: ")",
+        content: "1",
+        variable: "1",
+      },
+      { type: "text", content: "[one item];" },
+      {
+        type: "plural",
+        raw: "(2-7)",
+        prefix: "(",
+        suffix: ")",
+        content: "2-7",
+        variable: "2-7",
+      },
+      { type: "text", content: "[a few items];" },
+      {
+        type: "plural",
+        raw: "(7-inf)",
+        prefix: "(",
+        suffix: ")",
+        content: "7-inf",
+        variable: "7-inf",
+      },
+      { type: "text", content: "[a lot of items];" },
+    ]);
+  });
+
+  it("should not parse plural translations if regular text inside parenthesis", () => {
+    expect(parse("(This is a regular text inside parenthesis)")).toEqual([
+      { type: "text", content: "(This is a regular text inside parenthesis)" },
+    ]);
+  });
+
+  it("should parse translations with nesting", () => {
+    expect(parse("1 $t(nesting2)")).toEqual([
+      {
+        type: "text",
+        content: "1 ",
+      },
+      {
+        type: "nesting",
+        raw: "$t(nesting2)",
+        prefix: "$t(",
+        suffix: ")",
+        content: "nesting2",
+        variable: "nesting2",
+      },
+    ]);
+  });
+
+  it("should parse translations with tags", () => {
+    expect(
+      parse("This is some <b>bold text</b> and some <i>italic</i> text.")
+    ).toEqual([
+      { type: "text", content: "This is some " },
+      { type: "tag", raw: "<b>", voidElement: false },
+      { type: "text", content: "bold text" },
+      { type: "tag", raw: "</b>", voidElement: false },
+      { type: "text", content: " and some " },
+      { type: "tag", raw: "<i>", voidElement: false },
+      { type: "text", content: "italic" },
+      { type: "tag", raw: "</i>", voidElement: false },
+      { type: "text", content: " text." },
+    ]);
+  });
+
+  it("should parse translations with nested tags", () => {
+    expect(
+      parse("This is some <b>bold text and some <i>nested italic</i> text</b>!")
+    ).toEqual([
+      { type: "text", content: "This is some " },
+      { type: "tag", raw: "<b>", voidElement: false },
+      { type: "text", content: "bold text and some " },
+      { type: "tag", raw: "<i>", voidElement: false },
+      { type: "text", content: "nested italic" },
+      { type: "tag", raw: "</i>", voidElement: false },
+      { type: "text", content: " text" },
+      { type: "tag", raw: "</b>", voidElement: false },
+      { type: "text", content: "!" },
+    ]);
+  });
+
+  it("should parse translations with self closing tags", () => {
+    expect(
+      parse(
+        "This is some <b>bold text and some </b> and some random self closing tag <img /> as well."
+      )
+    ).toEqual([
+      { type: "text", content: "This is some " },
+      { type: "tag", raw: "<b>", voidElement: false },
+      { type: "text", content: "bold text and some " },
+      { type: "tag", raw: "</b>", voidElement: false },
+      { type: "text", content: " and some random self closing tag " },
+      { type: "tag", raw: "<img />", voidElement: true },
+      { type: "text", content: " as well." },
+    ]);
+  });
+});