@lingual/i18n-check 0.8.1 → 0.8.3

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,92 +1,78 @@
 "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",
-    "unused",
-    "undefined",
+    'invalidKeys',
+    'missingKeys',
+    'unused',
+    'undefined',
 ];
 exports.contextMapping = {
-    invalidKeys: "invalid",
-    missingKeys: "missing",
-    unused: "unused",
-    undefined: "undefined",
+    invalidKeys: 'invalid',
+    missingKeys: 'missing',
+    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 { Context } from "./errorReporters";
+import { CheckResult, InvalidTranslationsResult, Translation, TranslationFile } from './types';
+import { Context } from './errorReporters';
 export type Options = {
-    format?: "icu" | "i18next" | "react-intl" | "next-intl";
+    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>;