@lingual/i18n-check 0.8.0 → 0.8.2

package/dist/errorReporters.d.ts

@@ -1,3 +1,4 @@
+import { CheckResult, InvalidTranslationsResult } from "./types";
 export type StandardReporter = {
     file: string;
     key: string;
@@ -6,10 +7,7 @@ export type StandardReporter = {
 export declare const CheckOptions: string[];
 export type Context = (typeof CheckOptions)[number];
 export declare const contextMapping: Record<Context, string>;
-export declare const standardReporter: (result: StandardReporter[], flatten?: boolean) => string;
-export declare const summaryReporter: (result: {
-    file: string;
-    total: number;
-}[]) => string;
-export declare const createTable: (input: unknown[]) => string;
-export declare const createVerticalTable: (input: unknown[]) => string;
+export declare function formatSummaryTable<T>(result: Record<string, T[]>): string;
+export declare function formatTable(rowGroups: string[][][], lineSep?: string): string;
+export declare function formatCheckResultTable(result: CheckResult): string;
+export declare function formatInvalidTranslationsResultTable(result: InvalidTranslationsResult): string;

package/dist/errorReporters.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVerticalTable = exports.createTable = exports.summaryReporter = exports.standardReporter = exports.contextMapping = exports.CheckOptions = void 0;
-const console_1 = require("console");
-const stream_1 = require("stream");
+exports.contextMapping = exports.CheckOptions = void 0;
+exports.formatSummaryTable = formatSummaryTable;
+exports.formatTable = formatTable;
+exports.formatCheckResultTable = formatCheckResultTable;
+exports.formatInvalidTranslationsResultTable = formatInvalidTranslationsResultTable;
 exports.CheckOptions = [
     "invalidKeys",
     "missingKeys",
@@ -15,78 +17,62 @@ exports.contextMapping = {
     unused: "unused",
     undefined: "undefined",
 };
-const standardReporter = (result, flatten = false) => {
-    if (flatten) {
-        const data = result.reduce((acc, row) => {
-            Object.entries(row).forEach(([info, result]) => {
-                acc.push({ info, result });
-            });
-            return acc;
-        }, []);
-        return (0, exports.createVerticalTable)(data);
+function formatSummaryTable(result) {
+    return formatTable(getSummaryRows(result));
+}
+const getSummaryRows = (checkResult) => {
+    const rows = [];
+    for (const [file, keys] of Object.entries(checkResult)) {
+        rows.push([truncate(file), String(keys.length)]);
     }
-    return (0, exports.createTable)(result);
+    return [[["file", "total"]], rows];
 };
-exports.standardReporter = standardReporter;
-const summaryReporter = (result) => {
-    return (0, exports.createTable)(result.map(({ file, total }) => ({ file, total })));
-};
-exports.summaryReporter = summaryReporter;
-const createTable = (input) => {
-    // https://stackoverflow.com/a/67859384
-    const ts = new stream_1.Transform({
-        transform(chunk, enc, cb) {
-            cb(null, chunk);
-        },
-    });
-    const logger = new console_1.Console({ stdout: ts });
-    logger.table(input);
-    const table = (ts.read() || "").toString();
-    // https://stackoverflow.com/a/69874540
-    let output = "";
-    const lines = table.split(/[\r\n]+/);
-    for (let line of lines) {
-        output += `${line
-            .replace(/[^┬]*┬/, "┌")
-            .replace(/^├─*┼/, "├")
-            .replace(/│[^│]*/, "")
-            .replace(/^└─*┴/, "└")
-            .replace(/'/g, " ")}\n`;
-    }
-    return output.replace(/\n\n$/, "");
-};
-exports.createTable = createTable;
-const createVerticalTable = (input) => {
-    // https://stackoverflow.com/a/67859384
-    const ts = new stream_1.Transform({
-        transform(chunk, enc, cb) {
-            cb(null, chunk);
-        },
-    });
-    const logger = new console_1.Console({ stdout: ts });
-    logger.table(input);
-    const table = (ts.read() || "").toString();
-    // https://stackoverflow.com/a/69874540
-    let output = "";
-    let firstLine = "";
-    let index = 0;
-    const lines = table.split(/[\r\n]+/);
-    for (let line of lines) {
-        const transformedLine = `${line
-            .replace(/[^┬]*┬/, "┌")
-            .replace(/^├─*┼/, "├")
-            .replace(/│[^│]*/, "")
-            .replace(/^└─*┴/, "└")
-            .replace(/'/g, " ")}\n`;
-        output += transformedLine;
-        if (index === 2) {
-            firstLine = transformedLine;
+function formatTable(rowGroups, lineSep = "\n") {
+    // +2 for whitespace padding left and right
+    const padding = 2;
+    const colWidths = [];
+    for (const rows of rowGroups) {
+        for (const row of rows) {
+            for (let index = 0; index < row.length; ++index) {
+                colWidths[index] = Math.max(colWidths[index] ?? 0, row[index].length + padding);
+            }
         }
-        if (index > 3 && (index + 1) % 3 === 0 && index !== lines.length - 3) {
-            output += firstLine;
+    }
+    const lines = [];
+    lines.push(formatSeparatorRow(colWidths, "┌┬┐"));
+    for (const rows of rowGroups) {
+        for (const row of rows) {
+            lines.push(formatRow(row, colWidths));
         }
-        index++;
+        lines.push(formatSeparatorRow(colWidths, "├┼┤"));
     }
-    return output.replace(/\n\n$/, "");
-};
-exports.createVerticalTable = createVerticalTable;
+    lines[lines.length - 1] = formatSeparatorRow(colWidths, "└┴┘");
+    return lines.join(lineSep);
+}
+function formatSeparatorRow(widths, [left, middle, right]) {
+    return (left + widths.map((width) => "".padEnd(width, "─")).join(middle) + right);
+}
+function formatRow(values, widths) {
+    return (`│` +
+        values
+            .map((val, index) => ` ${val} `.padEnd(widths[index], " "))
+            .join("│") +
+        `│`);
+}
+const truncate = (chars, len = 80) => chars.length > 80 ? `${chars.substring(0, len)}...` : chars;
+function formatCheckResultTable(result) {
+    return formatTable([
+        [["file", "key"]],
+        Object.entries(result).flatMap(([file, keys]) => keys.map((key) => [truncate(file), truncate(key)])),
+    ]);
+}
+function formatInvalidTranslationsResultTable(result) {
+    return formatTable([
+        [["info", "result"]],
+        ...Object.entries(result).flatMap(([file, errors]) => errors.map(({ key, msg }) => [
+            ["file", truncate(file)],
+            ["key", truncate(key)],
+            ["msg", truncate(msg, 120)],
+        ])),
+    ]);
+}

package/dist/errorReporters.test.d.ts

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

package/dist/errorReporters.test.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errorReporters_1 = require("./errorReporters");
+describe("formatTable", () => {
+    test("single col and row", () => {
+        expect((0, errorReporters_1.formatTable)([[["lorem ipsum"]]])).toEqual(`
+┌─────────────┐
+│ lorem ipsum │
+└─────────────┘
+  `.trim());
+    });
+    test("single col and two rows", () => {
+        expect((0, errorReporters_1.formatTable)([[["lorem ipsum"], ["foo bar"]]])).toEqual(`
+┌─────────────┐
+│ lorem ipsum │
+│ foo bar     │
+└─────────────┘
+    `.trim());
+    });
+    test("with two columns and two row groups", () => {
+        expect((0, errorReporters_1.formatTable)([
+            [["col1", "col2"]],
+            [
+                ["lorem ipsum dolor", "foobar"],
+                ["baz", "more text"],
+            ],
+        ])).toEqual(`
+┌───────────────────┬───────────┐
+│ col1              │ col2      │
+├───────────────────┼───────────┤
+│ lorem ipsum dolor │ foobar    │
+│ baz               │ more text │
+└───────────────────┴───────────┘
+`.trim());
+    });
+    test("with two columns and three row groups", () => {
+        expect((0, errorReporters_1.formatTable)([
+            [["one", "two"]],
+            [
+                ["lorem ipsum dolor", "foobar"],
+                ["baz", "more text"],
+            ],
+            [["hello world", "here is more text for testing"]],
+        ])).toEqual(`
+┌───────────────────┬───────────────────────────────┐
+│ one               │ two                           │
+├───────────────────┼───────────────────────────────┤
+│ lorem ipsum dolor │ foobar                        │
+│ baz               │ more text                     │
+├───────────────────┼───────────────────────────────┤
+│ hello world       │ here is more text for testing │
+└───────────────────┴───────────────────────────────┘
+  `.trim());
+    });
+});
+describe("formatCheckResultTable", () => {
+    test("with one file and two keys", () => {
+        expect((0, errorReporters_1.formatCheckResultTable)({
+            "some/file.json": ["key.one", "key.two"],
+        })).toEqual(`
+┌────────────────┬─────────┐
+│ file           │ key     │
+├────────────────┼─────────┤
+│ some/file.json │ key.one │
+│ some/file.json │ key.two │
+└────────────────┴─────────┘
+`.trim());
+    });
+    test("with two files and three keys", () => {
+        expect((0, errorReporters_1.formatCheckResultTable)({
+            "some/de.json": ["key.one", "key.two"],
+            "some/en.json": ["key.three"],
+        })).toEqual(`
+┌──────────────┬───────────┐
+│ file         │ key       │
+├──────────────┼───────────┤
+│ some/de.json │ key.one   │
+│ some/de.json │ key.two   │
+│ some/en.json │ key.three │
+└──────────────┴───────────┘
+`.trim());
+    });
+});
+describe("formatInvalidTranslationsResultTable", () => {
+    test("with one file and one key", () => {
+        expect((0, errorReporters_1.formatInvalidTranslationsResultTable)({
+            "some/en.json": [{ key: "key.one", msg: "key one error msg" }],
+        })).toEqual(`
+┌──────┬───────────────────┐
+│ info │ result            │
+├──────┼───────────────────┤
+│ file │ some/en.json      │
+│ key  │ key.one           │
+│ msg  │ key one error msg │
+└──────┴───────────────────┘
+`.trim());
+    });
+    test("with two files and three keys", () => {
+        expect((0, errorReporters_1.formatInvalidTranslationsResultTable)({
+            "some/en-US.json": [
+                { key: "key.one", msg: "key one error msg" },
+                { key: "key.two", msg: "another msg" },
+            ],
+            "some/de.json": [{ key: "key.three", msg: "key three msg" }],
+        })).toEqual(`
+┌──────┬───────────────────┐
+│ info │ result            │
+├──────┼───────────────────┤
+│ file │ some/en-US.json   │
+│ key  │ key.one           │
+│ msg  │ key one error msg │
+├──────┼───────────────────┤
+│ file │ some/en-US.json   │
+│ key  │ key.two           │
+│ msg  │ another msg       │
+├──────┼───────────────────┤
+│ file │ some/de.json      │
+│ key  │ key.three         │
+│ msg  │ key three msg     │
+└──────┴───────────────────┘
+`.trim());
+    });
+});
+describe("formatSummaryTable", () => {
+    test("with CheckResult with single file and key", () => {
+        expect((0, errorReporters_1.formatSummaryTable)({
+            "some/file.json": ["key.one"],
+        })).toEqual(`
+┌────────────────┬───────┐
+│ file           │ total │
+├────────────────┼───────┤
+│ some/file.json │ 1     │
+└────────────────┴───────┘
+`.trim());
+    });
+    test("with CheckResult with two files and three keys", () => {
+        expect((0, errorReporters_1.formatSummaryTable)({
+            "some/de.json": ["key.one", "key.two"],
+            "some/en.json": ["key.three"],
+        })).toEqual(`
+┌──────────────┬───────┐
+│ file         │ total │
+├──────────────┼───────┤
+│ some/de.json │ 2     │
+│ some/en.json │ 1     │
+└──────────────┴───────┘
+`.trim());
+    });
+    test("with InvalidTranslationsResult with two files and three keys", () => {
+        expect((0, errorReporters_1.formatSummaryTable)({
+            "some/en-US.json": [
+                { key: "key.one", msg: "key one error msg" },
+                { key: "key.two", msg: "another msg" },
+            ],
+            "some/de.json": [{ key: "key.three", msg: "key three msg" }],
+        })).toEqual(`
+┌─────────────────┬───────┐
+│ file            │ total │
+├─────────────────┼───────┤
+│ some/en-US.json │ 2     │
+│ some/de.json    │ 1     │
+└─────────────────┴───────┘
+`.trim());
+    });
+});

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { CheckResult, Translation, TranslationFile } from "./types";
+import { CheckResult, InvalidTranslationsResult, Translation, TranslationFile } from "./types";
 import { Context } from "./errorReporters";
 export type Options = {
     format?: "icu" | "i18next" | "react-intl" | "next-intl";
     checks?: Context[];
 };
-export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => CheckResult;
+export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => InvalidTranslationsResult;
 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;
+    invalidKeys: InvalidTranslationsResult | undefined;
 };
-export declare const checkUnusedKeys: (translationFiles: TranslationFile[], filesToParse: string[], options?: Options, componentFunctions?: never[]) => Promise<CheckResult | undefined>;
-export declare const checkUndefinedKeys: (source: TranslationFile[], filesToParse: string[], options?: Options, componentFunctions?: never[]) => Promise<CheckResult | undefined>;
+export declare const checkUnusedKeys: (translationFiles: TranslationFile[], filesToParse: string[], options?: Options, componentFunctions?: string[]) => Promise<CheckResult | undefined>;
+export declare const checkUndefinedKeys: (source: TranslationFile[], filesToParse: string[], options?: Options, componentFunctions?: string[]) => Promise<CheckResult | undefined>;

package/dist/index.js

@@ -10,6 +10,7 @@ const findInvalidi18nTranslations_1 = require("./utils/findInvalidi18nTranslatio
 const cli_lib_1 = require("@formatjs/cli-lib");
 const nextIntlSrcParser_1 = require("./utils/nextIntlSrcParser");
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const ParseFormats = ["react-intl", "i18next", "next-intl"];
 const checkInvalidTranslations = (source, targets, options = { format: "icu" }) => {
     return options.format === "i18next"
@@ -28,16 +29,14 @@ const checkTranslations = (source, targets, options = { format: "icu", checks: [
     const hasMissingKeys = checks.includes("missingKeys");
     const hasInvalidKeys = checks.includes("invalidKeys");
     source.forEach(({ name, content }) => {
-        const files = targets
+        const files = Object.fromEntries(targets
             .filter(({ reference }) => reference === name)
-            .reduce((obj, { name: key, content }) => {
-            return Object.assign(obj, { [key]: content });
-        }, {});
+            .map(({ name, content }) => [name, content]));
         if (hasMissingKeys) {
-            Object.assign(missingKeys, (0, exports.checkMissingTranslations)(content, files));
+            merge(missingKeys, (0, exports.checkMissingTranslations)(content, files));
         }
         if (hasInvalidKeys) {
-            Object.assign(invalidKeys, (0, exports.checkInvalidTranslations)(content, files, options));
+            merge(invalidKeys, (0, exports.checkInvalidTranslations)(content, files, options));
         }
     });
     return {
@@ -46,6 +45,11 @@ const checkTranslations = (source, targets, options = { format: "icu", checks: [
     };
 };
 exports.checkTranslations = checkTranslations;
+function merge(left, right) {
+    for (let [k, v] of Object.entries(right)) {
+        left[k] = (left?.[k] ?? []).concat(v);
+    }
+}
 const checkUnusedKeys = async (translationFiles, filesToParse, options = {
     format: "react-intl",
     checks: [],
@@ -68,7 +72,7 @@ const checkUnusedKeys = async (translationFiles, filesToParse, options = {
 };
 exports.checkUnusedKeys = checkUnusedKeys;
 const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) => {
-    let unusedKeys = {};
+    const unusedKeys = {};
     const extracted = await (0, cli_lib_1.extract)(filesToParse, {});
     const extractedResultSet = new Set(Object.keys(JSON.parse(extracted)));
     translationFiles.forEach(({ name, content }) => {
@@ -79,12 +83,12 @@ const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) =
                 found.push(keyInSource);
             }
         }
-        Object.assign(unusedKeys, { [name]: found });
+        unusedKeys[name] = found;
     });
     return unusedKeys;
 };
 const findUnusedI18NextTranslations = async (source, filesToParse, componentFunctions = []) => {
-    let unusedKeys = {};
+    const unusedKeys = {};
     const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
     const extractedResultSet = new Set(extractedResult.map(({ key }) => key));
     source.forEach(({ name, content }) => {
@@ -101,12 +105,12 @@ const findUnusedI18NextTranslations = async (source, filesToParse, componentFunc
                 found.push(keyInSource);
             }
         }
-        Object.assign(unusedKeys, { [name]: found });
+        unusedKeys[name] = found;
     });
     return unusedKeys;
 };
 const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) => {
-    let unusedKeys = {};
+    const unusedKeys = {};
     const extracted = (0, nextIntlSrcParser_1.extract)(filesToParse);
     const dynamicNamespaces = extracted.flatMap((namespace) => {
         if (namespace.meta.dynamic) {
@@ -139,7 +143,7 @@ const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) =>
                 found.push(keyInSource);
             }
         }
-        Object.assign(unusedKeys, { [name]: found });
+        unusedKeys[name] = found;
     });
     return unusedKeys;
 };
@@ -174,8 +178,11 @@ const findUndefinedReactIntlKeys = async (translationFiles, filesToParse) => {
     let undefinedKeys = {};
     Object.entries(JSON.parse(extractedResult)).forEach(([key, meta]) => {
         if (!sourceKeys.has(key)) {
-            // @ts-ignore
-            const file = meta.file;
+            const data = meta;
+            if (!("file" in data) || typeof data.file !== "string") {
+                return;
+            }
+            const file = path_1.default.normalize(data.file);
             if (!undefinedKeys[file]) {
                 undefinedKeys[file] = [];
             }

package/dist/types.d.ts

@@ -1,5 +1,10 @@
 export type Translation = Record<string, unknown>;
 export type CheckResult = Record<string, string[]>;
+export type InvalidTranslationEntry = {
+    key: string;
+    msg: string;
+};
+export type InvalidTranslationsResult = Record<string, InvalidTranslationEntry[]>;
 export type TranslationFile = {
     reference: string | null;
     name: string;

package/dist/utils/findInvalidTranslations.d.ts

@@ -1,8 +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) => {
-    key: string;
-    msg: string;
-}[];
+import { InvalidTranslationEntry, InvalidTranslationsResult, Translation } from "../types";
+export declare const findInvalidTranslations: (source: Translation, files: Record<string, Translation>) => InvalidTranslationsResult;
+export declare const compareTranslationFiles: (a: Translation, b: Translation) => InvalidTranslationEntry[];
 export declare const hasDiff: (a: MessageFormatElement[], b: MessageFormatElement[]) => boolean;

package/dist/utils/findInvalidTranslations.js

@@ -3,14 +3,14 @@ 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 = {};
+    const 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 });
+            differences[lang] = result;
         }
     }
     return differences;
@@ -27,7 +27,7 @@ const sortParsedKeys = (a, b) => {
     return a.type - b.type;
 };
 const compareTranslationFiles = (a, b) => {
-    let diffs = [];
+    const diffs = [];
     for (const key in a) {
         if (b[key] === undefined) {
             continue;

package/dist/utils/findInvalidi18nTranslations.d.ts

@@ -5,7 +5,7 @@
  *
  */
 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[];
+import { InvalidTranslationEntry, InvalidTranslationsResult, Translation } from "../types";
+export declare const findInvalid18nTranslations: (source: Translation, targets: Record<string, Translation>) => InvalidTranslationsResult;
+export declare const compareTranslationFiles: (a: Translation, b: Translation) => InvalidTranslationEntry[];
 export declare const hasDiff: (a: MessageFormatElement[], b: MessageFormatElement[]) => boolean;

package/dist/utils/findInvalidi18nTranslations.js

@@ -16,7 +16,7 @@ const findInvalid18nTranslations = (source, targets) => {
     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 });
+            differences[lang] = result;
         }
     }
     return differences;

package/dist/utils/findMissingKeys.d.ts

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

package/dist/utils/findMissingKeys.js

@@ -6,7 +6,7 @@ const findMissingKeys = (source, targets) => {
     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 });
+            differences[lang] = result;
         }
     }
     return differences;

package/dist/utils/flattenTranslations.js

@@ -18,7 +18,7 @@ const isTranslationObject = (entry) => {
     return typeof entry === "object";
 };
 const flattenEntry = (entry, keys = []) => {
-    let result = {};
+    const result = {};
     if (!entry) {
         return result;
     }