@lingual/i18n-check 0.1.1 → 0.1.5

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/bin/index.js

@@ -0,0 +1,170 @@
+#! /usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const process_1 = require("process");
+const commander_1 = require("commander");
+const __1 = require("..");
+const errorReporters_1 = require("../errorReporters");
+const flattenTranslations_1 = require("../utils/flattenTranslations");
+commander_1.program
+    .version("0.1.0")
+    .option("-t, --target [directory]", "name of the directory containing the JSON files to validate")
+    .option("-s, --source [source file(s)]", "path to the reference file(s)")
+    .option("-f, --format [format type]", "define the specific format, i.e. i18next")
+    .option("-c, --check [checks]", "define the specific checks you want to run: invalid, missing. By default the check will validate against missing and invalid keys, i.e. --check invalidKeys,missingKeys")
+    .option("-r, --reporter [error reporting style]", "define the reporting style: standard or summary")
+    .option("-e, --exclude [file(s), folder(s)]", "define the file(s) and/or folders(s) that should be excluded from the check")
+    .parse();
+const getCheckOptions = () => {
+    const checkOption = commander_1.program.getOptionValue("check");
+    if (!checkOption) {
+        return ["invalidKeys", "missingKeys"];
+    }
+    const checks = checkOption
+        .split(",")
+        .filter((check) => ["invalidKeys", "missingKeys"].includes(check.trim()));
+    return checks.length > 0 ? checks : ["invalidKeys", "missingKeys"];
+};
+const getSourcePath = (sourcePaths, fileName) => {
+    return sourcePaths.find((basePathName) => {
+        return fileName.includes(basePathName);
+    });
+};
+const getTargetPath = (paths, sourcePaths, fileName) => {
+    const basePath = paths.find((path) => {
+        return fileName.includes(path);
+    });
+    if (!basePath) {
+        return null;
+    }
+    return sourcePaths.find((path) => path.includes(basePath));
+};
+const toArray = (input) => {
+    return input
+        .trim()
+        .split(",")
+        .filter((a) => a);
+};
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const start = performance.now();
+    const srcPath = commander_1.program.getOptionValue("source");
+    const targetPath = commander_1.program.getOptionValue("target");
+    const format = commander_1.program.getOptionValue("format");
+    const exclude = commander_1.program.getOptionValue("exclude");
+    if (!srcPath) {
+        console.log(chalk_1.default.red("Source file(s) not found. Please provide valid source file(s), i.e. -s translations/en-us.json"));
+        (0, process_1.exit)(1);
+    }
+    if (!targetPath) {
+        console.log(chalk_1.default.red("Target file(s) not found. Please provide valid target file(s), i.e. -t translations/"));
+        (0, process_1.exit)(1);
+    }
+    const excludedPaths = exclude ? toArray(exclude) : [];
+    const targetPathFolders = toArray(targetPath);
+    const srcPaths = toArray(srcPath);
+    const isMultiFolders = targetPathFolders.length > 1;
+    let srcFiles = [];
+    let targetFiles = [];
+    const pattern = isMultiFolders
+        ? `{${targetPath.trim()}}/**/*.json`
+        : `${targetPath.trim()}/**/*.json`;
+    const files = yield (0, glob_1.glob)(pattern, {
+        ignore: ["node_modules/**"].concat(excludedPaths),
+    });
+    console.log(chalk_1.default.blue("i18n translations checker"));
+    console.log(chalk_1.default.blackBright(`Source file(s): ${srcPath}`));
+    if (format) {
+        console.log(chalk_1.default.blackBright(`Selected format is: ${format}`));
+    }
+    const options = {
+        checks: getCheckOptions(),
+        format: format !== null && format !== void 0 ? format : undefined,
+    };
+    files.forEach((file) => {
+        const content = JSON.parse(fs_1.default.readFileSync(file, "utf-8"));
+        const sourcePath = getSourcePath(srcPaths, file);
+        if (sourcePath) {
+            srcFiles.push({
+                reference: null,
+                name: file,
+                content: (0, flattenTranslations_1.flattenTranslations)(content),
+            });
+        }
+        else {
+            const targetPath = getTargetPath(targetPathFolders, srcPaths, file);
+            const reference = (targetPath === null || targetPath === void 0 ? void 0 : targetPath.includes(".json"))
+                ? targetPath
+                : `${targetPath}${file.split("/").pop()}`;
+            targetFiles.push({
+                reference,
+                name: file,
+                content: (0, flattenTranslations_1.flattenTranslations)(content),
+            });
+        }
+    });
+    if (srcFiles.length === 0) {
+        console.log(chalk_1.default.red("Source file(s) not found. Please provide valid source file(s), i.e. -s translations/en-us.json"));
+        (0, process_1.exit)(1);
+    }
+    if (targetFiles.length === 0) {
+        console.log(chalk_1.default.red("Target file(s) not found. Please provide valid target file(s), i.e. -t translations/"));
+        (0, process_1.exit)(1);
+    }
+    try {
+        const result = (0, __1.checkTranslations)(srcFiles, targetFiles, options);
+        print(result);
+        const end = performance.now();
+        console.log(chalk_1.default.green(`\nDone in ${Math.round(((end - start) * 100) / 1000) / 100}s.`));
+        if ((result.missingKeys && Object.keys(result.missingKeys).length > 0) ||
+            (result.invalidKeys && Object.keys(result.invalidKeys).length > 0)) {
+            (0, process_1.exit)(1);
+        }
+        else {
+            (0, process_1.exit)(0);
+        }
+    }
+    catch (e) {
+        console.log(chalk_1.default.red("\nError: Can't validate translations. Check if the format is supported or specify the translation format i.e. -f i18next"));
+        (0, process_1.exit)(1);
+    }
+});
+const print = ({ missingKeys, invalidKeys, }) => {
+    const reporter = commander_1.program.getOptionValue("reporter");
+    const errorReporter = reporter === "summary" ? errorReporters_1.summaryReporter : errorReporters_1.standardReporter;
+    if (missingKeys && Object.keys(missingKeys).length > 0) {
+        console.log(chalk_1.default.bgRed(chalk_1.default.white("\nFound missing keys!")));
+        for (const [lang, missingMessageKeys] of Object.entries(missingKeys)) {
+            console.log(chalk_1.default.red(`\nIn ${lang}:\n`));
+            console.log(chalk_1.default.red(errorReporter(missingMessageKeys, "missingKeys")));
+        }
+    }
+    else if (missingKeys) {
+        console.log(chalk_1.default.green("\nNo missing keys found!"));
+    }
+    if (invalidKeys && Object.keys(invalidKeys).length > 0) {
+        console.log(chalk_1.default.bgRed(chalk_1.default.white("\nFound invalid keys!")));
+        for (const [lang, invalidMessageKeys] of Object.entries(invalidKeys)) {
+            console.log(chalk_1.default.red(`\nIn ${lang}:\n`));
+            console.log(chalk_1.default.red(errorReporter(invalidMessageKeys, "invalidKeys")));
+        }
+    }
+    else if (invalidKeys) {
+        console.log(chalk_1.default.green("\nNo invalid translations found!"));
+    }
+};
+main();

package/dist/errorReporters.d.ts

@@ -0,0 +1,5 @@
+export type Context = "missingKeys" | "invalidKeys";
+export type ErrorReporter = (result: string[], context: Context) => void;
+export declare const contextMapping: Record<Context, string>;
+export declare const standardReporter: ErrorReporter;
+export declare const summaryReporter: ErrorReporter;

package/dist/errorReporters.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summaryReporter = exports.standardReporter = exports.contextMapping = void 0;
+exports.contextMapping = {
+    invalidKeys: "invalid",
+    missingKeys: "missing",
+};
+const standardReporter = (result) => {
+    return result.map((key) => `◯ ${key}`).join("\n");
+};
+exports.standardReporter = standardReporter;
+const summaryReporter = (result, context) => {
+    const count = result.length;
+    return `Found ${count} ${exports.contextMapping[context]} ${count === 1 ? "key" : "keys"}.`;
+};
+exports.summaryReporter = summaryReporter;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { CheckResult, Translation, TranslationFile } from "./types";
+import { Context } from "./errorReporters";
+export type Options = {
+    format?: "icu" | "i18next";
+    checks?: Context[];
+};
+export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => CheckResult;
+export declare const checkMissingTranslations: (source: Translation, targets: Record<string, Translation>) => CheckResult;
+export declare const checkTranslations: (source: TranslationFile[], targets: TranslationFile[], options?: Options) => {
+    missingKeys: CheckResult | undefined;
+    invalidKeys: CheckResult | undefined;
+};

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTranslations = exports.checkMissingTranslations = exports.checkInvalidTranslations = void 0;
+const findMissingKeys_1 = require("./utils/findMissingKeys");
+const findInvalidTranslations_1 = require("./utils/findInvalidTranslations");
+const findInvalidi18nTranslations_1 = require("./utils/findInvalidi18nTranslations");
+const checkInvalidTranslations = (source, targets, options = { format: "icu" }) => {
+    return options.format === "i18next"
+        ? (0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(source, targets)
+        : (0, findInvalidTranslations_1.findInvalidTranslations)(source, targets);
+};
+exports.checkInvalidTranslations = checkInvalidTranslations;
+const checkMissingTranslations = (source, targets) => {
+    return (0, findMissingKeys_1.findMissingKeys)(source, targets);
+};
+exports.checkMissingTranslations = checkMissingTranslations;
+const checkTranslations = (source, targets, options = { format: "icu", checks: ["invalidKeys", "missingKeys"] }) => {
+    const { checks = ["invalidKeys", "missingKeys"] } = options;
+    let missingKeys = {};
+    let invalidKeys = {};
+    const hasMissingKeys = checks.includes("missingKeys");
+    const hasInvalidKeys = checks.includes("invalidKeys");
+    source.forEach(({ name, content }) => {
+        const files = targets
+            .filter(({ reference }) => reference === name)
+            .reduce((obj, { name: key, content }) => {
+            return Object.assign(obj, { [key]: content });
+        }, {});
+        if (hasMissingKeys) {
+            Object.assign(missingKeys, (0, exports.checkMissingTranslations)(content, files));
+        }
+        if (hasInvalidKeys) {
+            Object.assign(invalidKeys, (0, exports.checkInvalidTranslations)(content, files, options));
+        }
+    });
+    return {
+        missingKeys: hasMissingKeys ? missingKeys : undefined,
+        invalidKeys: hasInvalidKeys ? invalidKeys : undefined,
+    };
+};
+exports.checkTranslations = checkTranslations;

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type Translation = Record<string, unknown>;
+export type CheckResult = Record<string, string[]>;
+export type TranslationFile = {
+    reference: string | null;
+    name: string;
+    content: Translation;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/findInvalidTranslations.d.ts

@@ -0,0 +1,5 @@
+import { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+import { Translation } from "../types";
+export declare const findInvalidTranslations: (source: Translation, files: Record<string, Translation>) => {};
+export declare const compareTranslationFiles: (a: Translation, b: Translation) => string[];
+export declare const hasDiff: (a: MessageFormatElement[], b: MessageFormatElement[]) => boolean;

package/dist/utils/findInvalidTranslations.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDiff = exports.compareTranslationFiles = exports.findInvalidTranslations = void 0;
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const findInvalidTranslations = (source, files) => {
+    let differences = {};
+    if (Object.keys(files).length === 0) {
+        return differences;
+    }
+    for (const [lang, file] of Object.entries(files)) {
+        const result = (0, exports.compareTranslationFiles)(source, file);
+        if (result.length > 0) {
+            differences = Object.assign(differences, { [lang]: result });
+        }
+    }
+    return differences;
+};
+exports.findInvalidTranslations = findInvalidTranslations;
+const sortParsedKeys = (a, b) => {
+    if (a.type === b.type) {
+        return !(0, icu_messageformat_parser_1.isPoundElement)(a) && !(0, icu_messageformat_parser_1.isPoundElement)(b)
+            ? a.value < b.value
+                ? -1
+                : 1
+            : -1;
+    }
+    return a.type - b.type;
+};
+const compareTranslationFiles = (a, b) => {
+    let diffs = [];
+    for (const key in a) {
+        if (b[key] !== undefined &&
+            (0, exports.hasDiff)((0, icu_messageformat_parser_1.parse)(String(a[key])), (0, icu_messageformat_parser_1.parse)(String(b[key])))) {
+            diffs.push(key);
+        }
+    }
+    return diffs;
+};
+exports.compareTranslationFiles = compareTranslationFiles;
+const hasDiff = (a, b) => {
+    const compA = a
+        .filter((element) => !(0, icu_messageformat_parser_1.isLiteralElement)(element))
+        .sort(sortParsedKeys);
+    const compB = b
+        .filter((element) => !(0, icu_messageformat_parser_1.isLiteralElement)(element))
+        .sort(sortParsedKeys);
+    if (compA.length !== compB.length) {
+        return true;
+    }
+    const hasErrors = compA.some((formatElementA, index) => {
+        const formatElementB = compB[index];
+        if (formatElementA.type !== formatElementB.type ||
+            formatElementA.location !== formatElementB.location) {
+            return true;
+        }
+        if (((0, icu_messageformat_parser_1.isLiteralElement)(formatElementA) && (0, icu_messageformat_parser_1.isLiteralElement)(formatElementB)) ||
+            ((0, icu_messageformat_parser_1.isPoundElement)(formatElementA) && (0, icu_messageformat_parser_1.isPoundElement)(formatElementB))) {
+            return false;
+        }
+        // @ts-ignore
+        if (formatElementA.value !== formatElementB.value) {
+            return true;
+        }
+        if ((0, icu_messageformat_parser_1.isTagElement)(formatElementA) && (0, icu_messageformat_parser_1.isTagElement)(formatElementB)) {
+            return (0, exports.hasDiff)(formatElementA.children, formatElementB.children);
+        }
+        if (((0, icu_messageformat_parser_1.isSelectElement)(formatElementA) && (0, icu_messageformat_parser_1.isSelectElement)(formatElementB)) ||
+            ((0, icu_messageformat_parser_1.isPluralElement)(formatElementA) && (0, icu_messageformat_parser_1.isPluralElement)(formatElementB))) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            const optionsB = Object.keys(formatElementA.options).sort();
+            if (optionsA.join("-") !== optionsB.join("-")) {
+                return true;
+            }
+            return optionsA.some((key) => {
+                return (0, exports.hasDiff)(formatElementA.options[key].value, formatElementB.options[key].value);
+            });
+        }
+        return false;
+    });
+    return hasErrors;
+};
+exports.hasDiff = hasDiff;

package/dist/utils/findInvalidTranslations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/findInvalidTranslations.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const findInvalidTranslations_1 = require("./findInvalidTranslations");
+const flattenTranslations_1 = require("./flattenTranslations");
+const sourceFile = require("../../translations/messageExamples/en-us.json");
+const secondaryFile = require("../../translations/messageExamples/de-de.json");
+describe("findInvalidTranslations:compareTranslationFiles", () => {
+    it("should return empty array if files are identical", () => {
+        expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(sourceFile), (0, flattenTranslations_1.flattenTranslations)(sourceFile))).toEqual([]);
+    });
+    it("should return the invalid keys in the target file", () => {
+        expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" })), (0, flattenTranslations_1.flattenTranslations)(secondaryFile))).toEqual(["multipleVariables"]);
+    });
+    it("should return empty array if placeholders are identical but in different positions", () => {
+        expect((0, findInvalidTranslations_1.compareTranslationFiles)({
+            basic: "added {this} and {that} should work.",
+        }, {
+            basic: "It is {this} with different position {that}",
+        })).toEqual([]);
+    });
+});
+describe("findInvalidTranslations", () => {
+    it("should return an empty object if all files have no invalid keys", () => {
+        expect((0, findInvalidTranslations_1.findInvalidTranslations)(sourceFile, { de: sourceFile })).toEqual({});
+    });
+    it("should return an object containing the keys for the missing language", () => {
+        expect((0, findInvalidTranslations_1.findInvalidTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), { de: secondaryFile })).toEqual({ de: ["multipleVariables"] });
+    });
+    it("should return an object containing the keys for every language with missing key", () => {
+        expect((0, findInvalidTranslations_1.findInvalidTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), {
+            de: secondaryFile,
+            fr: {
+                "four.five.six": "four five six",
+                "seven.eight.nine": "seven eight nine",
+                "message.text-format": "yo,<p><b>John</b></p>!",
+            },
+        })).toEqual({
+            de: ["multipleVariables"],
+            fr: ["message.text-format"],
+        });
+    });
+});

package/dist/utils/findInvalidi18nTranslations.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * i18next specific invalid translations check
+ *
+ *
+ */
+import { MessageFormatElement } from "./i18NextParser";
+import { Translation } from "../types";
+export declare const findInvalid18nTranslations: (source: Translation, targets: Record<string, Translation>) => {};
+export declare const compareTranslationFiles: (a: Translation, b: Translation) => unknown[];
+export declare const hasDiff: (a: MessageFormatElement[], b: MessageFormatElement[]) => boolean;

package/dist/utils/findInvalidi18nTranslations.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ *
+ * i18next specific invalid translations check
+ *
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDiff = exports.compareTranslationFiles = exports.findInvalid18nTranslations = void 0;
+const i18NextParser_1 = require("./i18NextParser");
+const findInvalid18nTranslations = (source, targets) => {
+    let differences = {};
+    if (Object.keys(targets).length === 0) {
+        return differences;
+    }
+    for (const [lang, file] of Object.entries(targets)) {
+        const result = (0, exports.compareTranslationFiles)(source, file);
+        if (result.length > 0) {
+            differences = Object.assign(differences, { [lang]: result });
+        }
+    }
+    return differences;
+};
+exports.findInvalid18nTranslations = findInvalid18nTranslations;
+const compareTranslationFiles = (a, b) => {
+    let diffs = [];
+    for (const key in a) {
+        if (b[key] !== undefined &&
+            (0, exports.hasDiff)((0, i18NextParser_1.parse)(String(a[key])), (0, i18NextParser_1.parse)(String(b[key])))) {
+            diffs.push(key);
+        }
+    }
+    return diffs;
+};
+exports.compareTranslationFiles = compareTranslationFiles;
+const lookUp = {
+    text: 0,
+    interpolation: 1,
+    interpolation_unescaped: 2,
+    nesting: 3,
+    plural: 4,
+    tag: 5,
+};
+const sortParsedKeys = (a, b) => {
+    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];
+};
+const hasDiff = (a, b) => {
+    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;
+};
+exports.hasDiff = hasDiff;

package/dist/utils/findInvalidi18nTranslations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/findInvalidi18nTranslations.test.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const findInvalidi18nTranslations_1 = require("./findInvalidi18nTranslations");
+const flattenTranslations_1 = require("./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((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(sourceFile), (0, flattenTranslations_1.flattenTranslations)(sourceFile))).toEqual([]);
+    });
+    it("should return the invalid keys in the target file", () => {
+        expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" })), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual(["key_with_broken_de", "intlNumber_broken_de"]);
+    });
+    it("should return empty array if placeholders are identical but in different positions", () => {
+        expect((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(sourceFile, { de: sourceFile })).toEqual({});
+    });
+    it("should return an object containing the keys for the missing language", () => {
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(Object.assign(Object.assign({}, 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((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(Object.assign(Object.assign({}, 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((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
+            "tree.one": "added {{something}}",
+        }, {
+            de: {
+                "tree.one": "added {{somethings}}",
+            },
+        })).toEqual({
+            de: ["tree.one"],
+        });
+    });
+    it("should find invalid relative time formatting", () => {
+        expect((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.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((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
+            nesting1: "1 $t(nesting2)",
+        }, {
+            de: {
+                nesting1: "1 $t(nesting3)",
+            },
+        })).toEqual({
+            de: ["nesting1"],
+        });
+    });
+    it("should find invalid tags", () => {
+        expect((0, findInvalidi18nTranslations_1.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/dist/utils/findMissingKeys.d.ts

@@ -0,0 +1,3 @@
+import { Translation } from "../types";
+export declare const findMissingKeys: (source: Translation, targets: Record<string, Translation>) => {};
+export declare const compareTranslationFiles: (a: Translation, b: Translation) => string[];

package/dist/utils/findMissingKeys.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareTranslationFiles = exports.findMissingKeys = void 0;
+const findMissingKeys = (source, targets) => {
+    let differences = {};
+    for (const [lang, file] of Object.entries(targets)) {
+        const result = (0, exports.compareTranslationFiles)(source, file);
+        if (result.length > 0) {
+            differences = Object.assign(differences, { [lang]: result });
+        }
+    }
+    return differences;
+};
+exports.findMissingKeys = findMissingKeys;
+const compareTranslationFiles = (a, b) => {
+    let diffs = [];
+    for (const key in a) {
+        const counterKey = b[key];
+        if (!counterKey) {
+            diffs.push(key);
+        }
+    }
+    return diffs;
+};
+exports.compareTranslationFiles = compareTranslationFiles;

package/dist/utils/findMissingKeys.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/findMissingKeys.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const findMissingKeys_1 = require("./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((0, findMissingKeys_1.compareTranslationFiles)(sourceFile, secondaryFile)).toEqual([]);
+    });
+    it("should return the missing keys in the secondary file", () => {
+        expect((0, findMissingKeys_1.compareTranslationFiles)(Object.assign(Object.assign({}, 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((0, findMissingKeys_1.findMissingKeys)(sourceFile, { de: secondaryFile })).toEqual({});
+    });
+    it("should return an object containing the keys for the missing language", () => {
+        expect((0, findMissingKeys_1.findMissingKeys)(Object.assign(Object.assign({}, 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((0, findMissingKeys_1.findMissingKeys)(Object.assign(Object.assign({}, 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/dist/utils/flattenTranslations.d.ts

@@ -0,0 +1,3 @@
+import { Translation } from "../types";
+export declare const flattenTranslations: (translations: Translation) => Translation;
+export declare const flattenEntry: (entry: Translation, keys?: string[]) => Translation;

package/dist/utils/flattenTranslations.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenEntry = exports.flattenTranslations = void 0;
+const flattenTranslations = (translations) => {
+    if (!hasNestedDefinitions(translations)) {
+        return translations;
+    }
+    return (0, exports.flattenEntry)(translations);
+};
+exports.flattenTranslations = flattenTranslations;
+/**
+ * Top level search for any objects
+ */
+const hasNestedDefinitions = (translations) => {
+    return Object.values(translations).find((translation) => typeof translation === "object");
+};
+const isTranslationObject = (entry) => {
+    return typeof entry === "object";
+};
+const flattenEntry = (entry, keys = []) => {
+    let result = {};
+    if (!entry) {
+        return result;
+    }
+    const entries = Object.entries(entry);
+    for (const [k, v] of entries) {
+        Object.assign(result, isTranslationObject(v)
+            ? (0, exports.flattenEntry)(v, [...keys, String(k)])
+            : { [[...keys, String(k)].join(".")]: v });
+    }
+    return result;
+};
+exports.flattenEntry = flattenEntry;

package/dist/utils/flattenTranslations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/flattenTranslations.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flattenTranslations_1 = require("./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((0, flattenTranslations_1.flattenTranslations)(flatStructure)).toEqual(flatStructure);
+    });
+    describe("flattenEntry", () => {
+        it("should flatten a nested object", () => {
+            expect((0, flattenTranslations_1.flattenEntry)({
+                a: {
+                    b: { c: "one" },
+                },
+            })).toEqual({ "a.b.c": "one" });
+        });
+    });
+    it("should do nothing if the file structure is flat", () => {
+        expect((0, flattenTranslations_1.flattenTranslations)(nestedStructure)).toEqual(expectedFlatStructure);
+    });
+});

package/dist/utils/i18NextParser.d.ts

@@ -0,0 +1,37 @@
+export type MessageFormatElement = {
+    type: "text";
+    content: string;
+} | {
+    type: "interpolation";
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: "interpolation_unescaped";
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: "nesting";
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: "plural";
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: "tag";
+    raw: string;
+    voidElement: boolean;
+};
+export declare const parse: (input: string) => MessageFormatElement[];

package/dist/utils/i18NextParser.js

@@ -0,0 +1,104 @@
+"use strict";
+//  Based on https://github.com/i18next/i18next-translation-parser/blob/v1.0.0/src/parse.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const REGEXP = new RegExp("({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)|<[^>]+>)", "g");
+const DOUBLE_BRACE = "{{";
+const $_T_BRACE = "$t{";
+const $_T_PARENTHESIS = "$t(";
+const OPEN_PARENTHESIS = "(";
+const OPEN_TAG = "<";
+const CLOSE_TAG = "</";
+const parse = (input) => {
+    let ast = [];
+    ast = parseInput([input]);
+    return ast;
+};
+exports.parse = parse;
+const parseInput = (input) => {
+    if (input.length === 0) {
+        return [];
+    }
+    let ast = [];
+    input.forEach((element) => {
+        const elements = element.split(REGEXP).filter((element) => element !== "");
+        const result = elements.reduce((acc, match) => {
+            if (match.indexOf("{{-") === 0) {
+                const content = match.substring(3, match.length - 2);
+                acc.push({
+                    type: "interpolation_unescaped",
+                    raw: match,
+                    prefix: "{{-",
+                    suffix: "}}",
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(DOUBLE_BRACE) === 0) {
+                const content = match.substring(2, match.length - 2);
+                acc.push({
+                    type: "interpolation",
+                    raw: match,
+                    prefix: "{{",
+                    suffix: "}}",
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf($_T_BRACE) === 0) {
+                const content = match.substring(3, match.length - 1);
+                acc.push({
+                    type: "nesting",
+                    raw: match,
+                    prefix: "$t{",
+                    suffix: "}",
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf($_T_PARENTHESIS) === 0) {
+                const content = match.substring(3, match.length - 1);
+                acc.push({
+                    type: "nesting",
+                    raw: match,
+                    prefix: "$t(",
+                    suffix: ")",
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(OPEN_PARENTHESIS) === 0 &&
+                /\([0-9\-inf]+\)/.test(match)) {
+                const content = match.substring(1, match.length - 1);
+                acc.push({
+                    type: "plural",
+                    raw: match,
+                    prefix: "(",
+                    suffix: ")",
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(CLOSE_TAG) === 0) {
+                acc.push({
+                    type: "tag",
+                    raw: match,
+                    voidElement: match.substring(match.length - 2) === "/>",
+                });
+            }
+            else if (match.indexOf(OPEN_TAG) === 0) {
+                acc.push({
+                    type: "tag",
+                    raw: match,
+                    voidElement: match.substring(match.length - 2) === "/>",
+                });
+            }
+            else {
+                acc.push({ type: "text", content: match });
+            }
+            return acc;
+        }, []);
+        ast = ast.concat(result);
+    });
+    return ast;
+};

package/dist/utils/i18NextParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/i18NextParser.test.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const i18NextParser_1 = require("./i18NextParser");
+describe("i18NextParser", () => {
+    it("should parse interpolation", () => {
+        expect((0, i18NextParser_1.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((0, i18NextParser_1.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((0, i18NextParser_1.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((0, i18NextParser_1.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((0, i18NextParser_1.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((0, i18NextParser_1.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((0, i18NextParser_1.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." },
+        ]);
+    });
+});

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "license": "MIT",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
   "bin": {
-    "i18n-check": "./dist/bin/index.js"
+    "i18n-check": "dist/bin/index.js"
+  },
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
   },
-  "types": "./dist/index.d.ts",
   "files": [
     "dist/"
   ],
@@ -23,9 +27,5 @@
     "@types/node": "^20.12.12",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "jest"
   }
-}
+}