@lingual/i18n-check 0.8.2 → 0.8.4

package/dist/errorReporters.d.ts

@@ -1,4 +1,4 @@
-import { CheckResult, InvalidTranslationsResult } from "./types";
+import { CheckResult, InvalidTranslationsResult } from './types';
 export type StandardReporter = {
     file: string;
     key: string;

package/dist/errorReporters.js

@@ -6,16 +6,16 @@ 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',
 };
 function formatSummaryTable(result) {
     return formatTable(getSummaryRows(result));
@@ -25,9 +25,9 @@ const getSummaryRows = (checkResult) => {
     for (const [file, keys] of Object.entries(checkResult)) {
         rows.push([truncate(file), String(keys.length)]);
     }
-    return [[["file", "total"]], rows];
+    return [[['file', 'total']], rows];
 };
-function formatTable(rowGroups, lineSep = "\n") {
+function formatTable(rowGroups, lineSep = '\n') {
     // +2 for whitespace padding left and right
     const padding = 2;
     const colWidths = [];
@@ -39,40 +39,40 @@ function formatTable(rowGroups, lineSep = "\n") {
         }
     }
     const lines = [];
-    lines.push(formatSeparatorRow(colWidths, "┌┬┐"));
+    lines.push(formatSeparatorRow(colWidths, '┌┬┐'));
     for (const rows of rowGroups) {
         for (const row of rows) {
             lines.push(formatRow(row, colWidths));
         }
-        lines.push(formatSeparatorRow(colWidths, "├┼┤"));
+        lines.push(formatSeparatorRow(colWidths, '├┼┤'));
     }
-    lines[lines.length - 1] = formatSeparatorRow(colWidths, "└┴┘");
+    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);
+    return (left + widths.map((width) => ''.padEnd(width, '─')).join(middle) + right);
 }
 function formatRow(values, widths) {
     return (`│` +
         values
-            .map((val, index) => ` ${val} `.padEnd(widths[index], " "))
-            .join("│") +
+            .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"]],
+        [['file', 'key']],
         Object.entries(result).flatMap(([file, keys]) => keys.map((key) => [truncate(file), truncate(key)])),
     ]);
 }
 function formatInvalidTranslationsResultTable(result) {
     return formatTable([
-        [["info", "result"]],
+        [['info', 'result']],
         ...Object.entries(result).flatMap(([file, errors]) => errors.map(({ key, msg }) => [
-            ["file", truncate(file)],
-            ["key", truncate(key)],
-            ["msg", truncate(msg, 120)],
+            ['file', truncate(file)],
+            ['key', truncate(key)],
+            ['msg', truncate(msg, 120)],
         ])),
     ]);
 }

package/dist/errorReporters.test.js

@@ -1,28 +1,28 @@
 "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(`
+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(`
+    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", () => {
+    test('with two columns and two row groups', () => {
         expect((0, errorReporters_1.formatTable)([
-            [["col1", "col2"]],
+            [['col1', 'col2']],
             [
-                ["lorem ipsum dolor", "foobar"],
-                ["baz", "more text"],
+                ['lorem ipsum dolor', 'foobar'],
+                ['baz', 'more text'],
             ],
         ])).toEqual(`
 ┌───────────────────┬───────────┐
@@ -33,14 +33,14 @@ describe("formatTable", () => {
 └───────────────────┴───────────┘
 `.trim());
     });
-    test("with two columns and three row groups", () => {
+    test('with two columns and three row groups', () => {
         expect((0, errorReporters_1.formatTable)([
-            [["one", "two"]],
+            [['one', 'two']],
             [
-                ["lorem ipsum dolor", "foobar"],
-                ["baz", "more text"],
+                ['lorem ipsum dolor', 'foobar'],
+                ['baz', 'more text'],
             ],
-            [["hello world", "here is more text for testing"]],
+            [['hello world', 'here is more text for testing']],
         ])).toEqual(`
 ┌───────────────────┬───────────────────────────────┐
 │ one               │ two                           │
@@ -53,10 +53,10 @@ describe("formatTable", () => {
   `.trim());
     });
 });
-describe("formatCheckResultTable", () => {
-    test("with one file and two keys", () => {
+describe('formatCheckResultTable', () => {
+    test('with one file and two keys', () => {
         expect((0, errorReporters_1.formatCheckResultTable)({
-            "some/file.json": ["key.one", "key.two"],
+            'some/file.json': ['key.one', 'key.two'],
         })).toEqual(`
 ┌────────────────┬─────────┐
 │ file           │ key     │
@@ -66,10 +66,10 @@ describe("formatCheckResultTable", () => {
 └────────────────┴─────────┘
 `.trim());
     });
-    test("with two files and three keys", () => {
+    test('with two files and three keys', () => {
         expect((0, errorReporters_1.formatCheckResultTable)({
-            "some/de.json": ["key.one", "key.two"],
-            "some/en.json": ["key.three"],
+            'some/de.json': ['key.one', 'key.two'],
+            'some/en.json': ['key.three'],
         })).toEqual(`
 ┌──────────────┬───────────┐
 │ file         │ key       │
@@ -81,10 +81,10 @@ describe("formatCheckResultTable", () => {
 `.trim());
     });
 });
-describe("formatInvalidTranslationsResultTable", () => {
-    test("with one file and one key", () => {
+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" }],
+            'some/en.json': [{ key: 'key.one', msg: 'key one error msg' }],
         })).toEqual(`
 ┌──────┬───────────────────┐
 │ info │ result            │
@@ -95,13 +95,13 @@ describe("formatInvalidTranslationsResultTable", () => {
 └──────┴───────────────────┘
 `.trim());
     });
-    test("with two files and three keys", () => {
+    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/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" }],
+            'some/de.json': [{ key: 'key.three', msg: 'key three msg' }],
         })).toEqual(`
 ┌──────┬───────────────────┐
 │ info │ result            │
@@ -121,10 +121,10 @@ describe("formatInvalidTranslationsResultTable", () => {
 `.trim());
     });
 });
-describe("formatSummaryTable", () => {
-    test("with CheckResult with single file and key", () => {
+describe('formatSummaryTable', () => {
+    test('with CheckResult with single file and key', () => {
         expect((0, errorReporters_1.formatSummaryTable)({
-            "some/file.json": ["key.one"],
+            'some/file.json': ['key.one'],
         })).toEqual(`
 ┌────────────────┬───────┐
 │ file           │ total │
@@ -133,10 +133,10 @@ describe("formatSummaryTable", () => {
 └────────────────┴───────┘
 `.trim());
     });
-    test("with CheckResult with two files and three keys", () => {
+    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"],
+            'some/de.json': ['key.one', 'key.two'],
+            'some/en.json': ['key.three'],
         })).toEqual(`
 ┌──────────────┬───────┐
 │ file         │ total │
@@ -146,13 +146,13 @@ describe("formatSummaryTable", () => {
 └──────────────┴───────┘
 `.trim());
     });
-    test("with InvalidTranslationsResult with two files and three keys", () => {
+    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/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" }],
+            'some/de.json': [{ key: 'key.three', msg: 'key three msg' }],
         })).toEqual(`
 ┌─────────────────┬───────┐
 │ file            │ total │

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { CheckResult, InvalidTranslationsResult, 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[];
+    ignore?: string[];
 };
 export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => InvalidTranslationsResult;
 export declare const checkMissingTranslations: (source: Translation, targets: Record<string, Translation>) => CheckResult;

package/dist/index.js

@@ -11,9 +11,9 @@ 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"
+const ParseFormats = ['react-intl', 'i18next', 'next-intl'];
+const checkInvalidTranslations = (source, targets, options = { format: 'icu' }) => {
+    return options.format === 'i18next'
         ? (0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(source, targets)
         : (0, findInvalidTranslations_1.findInvalidTranslations)(source, targets);
 };
@@ -22,51 +22,52 @@ 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");
+const checkTranslations = (source, targets, options = { format: 'icu', checks: ['invalidKeys', 'missingKeys'] }) => {
+    const { checks = ['invalidKeys', 'missingKeys'] } = options;
+    const missingKeys = {};
+    const invalidKeys = {};
+    const hasMissingKeysCheck = checks.includes('missingKeys');
+    const hasInvalidKeysCheck = checks.includes('invalidKeys');
     source.forEach(({ name, content }) => {
         const files = Object.fromEntries(targets
             .filter(({ reference }) => reference === name)
             .map(({ name, content }) => [name, content]));
-        if (hasMissingKeys) {
-            merge(missingKeys, (0, exports.checkMissingTranslations)(content, files));
+        if (hasMissingKeysCheck) {
+            const filteredContent = filterKeys(content, options.ignore ?? []);
+            merge(missingKeys, (0, exports.checkMissingTranslations)(filteredContent, files));
         }
-        if (hasInvalidKeys) {
+        if (hasInvalidKeysCheck) {
             merge(invalidKeys, (0, exports.checkInvalidTranslations)(content, files, options));
         }
     });
     return {
-        missingKeys: hasMissingKeys ? missingKeys : undefined,
-        invalidKeys: hasInvalidKeys ? invalidKeys : undefined,
+        missingKeys: hasMissingKeysCheck ? missingKeys : undefined,
+        invalidKeys: hasInvalidKeysCheck ? invalidKeys : undefined,
     };
 };
 exports.checkTranslations = checkTranslations;
 function merge(left, right) {
-    for (let [k, v] of Object.entries(right)) {
+    for (const [k, v] of Object.entries(right)) {
         left[k] = (left?.[k] ?? []).concat(v);
     }
 }
 const checkUnusedKeys = async (translationFiles, filesToParse, options = {
-    format: "react-intl",
+    format: 'react-intl',
     checks: [],
 }, componentFunctions = []) => {
     if (!options.format || !ParseFormats.includes(options.format)) {
         return undefined;
     }
-    if (!options.checks || !options.checks.includes("unused")) {
+    if (!options.checks || !options.checks.includes('unused')) {
         return undefined;
     }
-    if (options.format === "react-intl") {
+    if (options.format === 'react-intl') {
         return findUnusedReactIntlTranslations(translationFiles, filesToParse);
     }
-    else if (options.format === "i18next") {
+    else if (options.format === 'i18next') {
         return findUnusedI18NextTranslations(translationFiles, filesToParse, componentFunctions);
     }
-    else if (options.format === "next-intl") {
+    else if (options.format === 'next-intl') {
         return findUnusedNextIntlTranslations(translationFiles, filesToParse);
     }
 };
@@ -90,7 +91,7 @@ const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) =
 const findUnusedI18NextTranslations = async (source, filesToParse, componentFunctions = []) => {
     const unusedKeys = {};
     const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
-    const extractedResultSet = new Set(extractedResult.map(({ key }) => key));
+    const extractedResultSet = new Set(extractedResult.map(({ key, namespace }) => namespace ? `${namespace}.${key}` : key));
     source.forEach(({ name, content }) => {
         const keysInSource = Object.keys(content);
         const found = [];
@@ -101,7 +102,10 @@ const findUnusedI18NextTranslations = async (source, filesToParse, componentFunc
             if (isSkippable !== undefined) {
                 continue;
             }
-            if (!extractedResultSet.has(keyInSource)) {
+            // find the file name
+            const [fileName] = (name.split(path_1.default.sep).pop() ?? '').split('.');
+            if (!extractedResultSet.has(`${fileName}.${keyInSource}`) &&
+                !extractedResultSet.has(keyInSource)) {
                 found.push(keyInSource);
             }
         }
@@ -131,8 +135,8 @@ const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) =>
             // Check if key is part of a dynamic namespace
             // Skip the key if it is part of the dynamic namespace
             const isDynamicNamespace = dynamicNamespaces.find((dynamicNamespace) => {
-                const keyInSourceNamespaces = keyInSource.split(".");
-                return dynamicNamespace.split(".").every((namePart, index) => {
+                const keyInSourceNamespaces = keyInSource.split('.');
+                return dynamicNamespace.split('.').every((namePart, index) => {
                     return namePart === keyInSourceNamespaces[index];
                 });
             });
@@ -148,22 +152,22 @@ const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) =>
     return unusedKeys;
 };
 const checkUndefinedKeys = async (source, filesToParse, options = {
-    format: "react-intl",
+    format: 'react-intl',
     checks: [],
 }, componentFunctions = []) => {
     if (!options.format || !ParseFormats.includes(options.format)) {
         return undefined;
     }
-    if (!options.checks || !options.checks.includes("undefined")) {
+    if (!options.checks || !options.checks.includes('undefined')) {
         return undefined;
     }
-    if (options.format === "react-intl") {
+    if (options.format === 'react-intl') {
         return findUndefinedReactIntlKeys(source, filesToParse);
     }
-    else if (options.format === "i18next") {
+    else if (options.format === 'i18next') {
         return findUndefinedI18NextKeys(source, filesToParse, componentFunctions);
     }
-    else if (options.format === "next-intl") {
+    else if (options.format === 'next-intl') {
         return findUndefinedNextIntlKeys(source, filesToParse);
     }
 };
@@ -175,11 +179,11 @@ const findUndefinedReactIntlKeys = async (translationFiles, filesToParse) => {
     const extractedResult = await (0, cli_lib_1.extract)(filesToParse, {
         extractSourceLocation: true,
     });
-    let undefinedKeys = {};
+    const undefinedKeys = {};
     Object.entries(JSON.parse(extractedResult)).forEach(([key, meta]) => {
         if (!sourceKeys.has(key)) {
             const data = meta;
-            if (!("file" in data) || typeof data.file !== "string") {
+            if (!('file' in data) || typeof data.file !== 'string') {
                 return;
             }
             const file = path_1.default.normalize(data.file);
@@ -196,7 +200,7 @@ const findUndefinedI18NextKeys = async (source, filesToParse, componentFunctions
     const sourceKeys = new Set(source.flatMap(({ content }) => {
         return Object.keys(content);
     }));
-    let undefinedKeys = {};
+    const undefinedKeys = {};
     extractedResult.forEach(({ file, key }) => {
         const isSkippable = skippableKeys.find((skippableKey) => {
             return key.includes(skippableKey);
@@ -215,10 +219,9 @@ const findUndefinedNextIntlKeys = async (translationFiles, filesToParse) => {
         return Object.keys(content);
     }));
     const extractedResult = (0, nextIntlSrcParser_1.extract)(filesToParse);
-    let undefinedKeys = {};
+    const undefinedKeys = {};
     extractedResult.forEach(({ key, meta }) => {
         if (!meta.dynamic && !sourceKeys.has(key)) {
-            // @ts-ignore
             const file = meta.file;
             if (!undefinedKeys[file]) {
                 undefinedKeys[file] = [];
@@ -229,26 +232,27 @@ const findUndefinedNextIntlKeys = async (translationFiles, filesToParse) => {
     return undefinedKeys;
 };
 const isRecord = (data) => {
-    return (typeof data === "object" &&
+    return (typeof data === 'object' &&
         !Array.isArray(data) &&
         data !== null &&
         data !== undefined);
 };
 const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    const { transform } = await import("i18next-parser");
+    const { transform } = await import('i18next-parser');
     const i18nextParser = new transform({
         lexers: {
             jsx: [
                 {
-                    lexer: "JsxLexer",
-                    componentFunctions: componentFunctions.concat(["Trans"]),
+                    lexer: 'JsxLexer',
+                    componentFunctions: componentFunctions.concat(['Trans']),
                 },
             ],
             tsx: [
                 {
-                    lexer: "JsxLexer",
-                    componentFunctions: componentFunctions.concat(["Trans"]),
+                    lexer: 'JsxLexer',
+                    componentFunctions: componentFunctions.concat(['Trans']),
                 },
             ],
         },
@@ -256,32 +260,63 @@ const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
     // Skip any parsed keys that have the `returnObjects` property set to true
     // As these are used dynamically, they will be skipped to prevent
     // these keys from being marked as unused.
-    let extractedResult = [];
+    const extractedResult = [];
     const skippableKeys = [];
     filesToParse.forEach((file) => {
-        const rawContent = fs_1.default.readFileSync(file, "utf-8");
+        const rawContent = fs_1.default.readFileSync(file, 'utf-8');
         const entries = i18nextParser.parser.parse(rawContent, file);
         // Intermediate solution to retrieve all keys from the parser.
         // This will be built out to also include the namespace and check
         // the key against the namespace corresponding file.
         // The current implementation considers the key as used no matter the namespace.
         for (const entry of entries) {
+            // check for namespace, i.e. `namespace:some.key`
+            const [namespace, ...keyParts] = entry.key.split(':');
+            // If there is a namespace make sure to assign the namespace
+            // and update the key name
+            // Ensure that the assumed key is not the default value
+            if (keyParts.length > 0 && entry.key !== entry.defaultValue) {
+                entry.namespace = namespace;
+                // rebuild the key without the namespace
+                entry.key = keyParts.join(':');
+            }
             if (entry.returnObjects) {
                 skippableKeys.push(entry.key);
             }
             else {
-                extractedResult.push({ file, key: entry.key });
+                extractedResult.push({
+                    file,
+                    key: entry.key,
+                    namespace: entry.namespace,
+                });
             }
         }
     });
     return { extractedResult, skippableKeys };
 };
-function flatten(object, prefix = null, result = {}) {
-    for (let key in object) {
-        let propName = prefix ? `${prefix}.${key}` : key;
+const filterKeys = (content, keysToIgnore = []) => {
+    if (keysToIgnore.length > 0) {
+        return Object.entries(content).reduce((acc, [key, value]) => {
+            if (keysToIgnore.find((ignoreKey) => {
+                if (ignoreKey.endsWith('*')) {
+                    return key.includes(ignoreKey.slice(0, ignoreKey.length - 1));
+                }
+                return ignoreKey === key;
+            })) {
+                return acc;
+            }
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+    return content;
+};
+function _flatten(object, prefix = null, result = {}) {
+    for (const key in object) {
+        const propName = prefix ? `${prefix}.${key}` : key;
         const data = object[key];
         if (isRecord(data)) {
-            flatten(data, propName, result);
+            _flatten(data, propName, result);
         }
         else {
             result[propName] = data;

package/dist/utils/findInvalidTranslations.d.ts

@@ -1,5 +1,5 @@
-import { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
-import { InvalidTranslationEntry, InvalidTranslationsResult, Translation } from "../types";
+import { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
+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;