@lingual/i18n-check 0.1.0 → 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/{src/types.ts → dist/types.d.ts}

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