@lingual/i18n-check 0.9.0 → 0.9.2

package/dist/bin/index.d.ts

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

package/dist/bin/index.js

@@ -0,0 +1,286 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_process_1 = require("node:process");
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const glob_1 = require("glob");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const __1 = require("..");
+const errorReporters_1 = require("../errorReporters");
+const flattenTranslations_1 = require("../utils/flattenTranslations");
+const node_path_1 = __importDefault(require("node:path"));
+const findInvalidTranslations_1 = require("../utils/findInvalidTranslations");
+const version = require('../../package.json').version;
+commander_1.program
+    .version(version)
+    .option('-l, --locales <locales...>', 'name of the directory containing the locales to validate')
+    .option('-s, --source <locale>', 'the source locale to validate against')
+    .option('-f, --format <type>', 'define the specific format: i18next, react-intl or next-intl')
+    .option('-c, --check <checks...>', 'this option is deprecated - use -o or --only instead')
+    .option('-o, --only <only...>', 'define the specific checks you want to run: invalidKeys, missingKeys, unused, undefined. By default the check will validate against missing and invalid keys, i.e. --only invalidKeys,missingKeys')
+    .option('-r, --reporter <style>', 'define the reporting style: standard or summary')
+    .option('-e, --exclude <exclude...>', 'define the file(s) and/or folders(s) that should be excluded from the check')
+    .option('-i, --ignore <ignore...>', 'define the key(s) or group of keys (i.e. `some.namespace.*`) that should be excluded from the check')
+    .option('-u, --unused <paths...>', 'define the source path(s) to find all unused and undefined keys')
+    .option('--parser-component-functions <components...>', 'a list of component names to parse when using the --unused option')
+    .parse();
+const getCheckOptions = () => {
+    const checkOption = commander_1.program.getOptionValue('only') || commander_1.program.getOptionValue('check');
+    if (commander_1.program.getOptionValue('check')) {
+        console.log(chalk_1.default.yellow('The --check option has been deprecated, use the --only option instead.'));
+    }
+    if (!checkOption) {
+        return errorReporters_1.CheckOptions;
+    }
+    const checks = checkOption.filter((check) => errorReporters_1.CheckOptions.includes(check.trim()));
+    return checks.length > 0 ? checks : errorReporters_1.CheckOptions;
+};
+const isSource = (fileInfo, srcPath) => {
+    return (fileInfo.path.some((path) => path.toLowerCase() === srcPath.toLowerCase()) || fileInfo.name.toLowerCase().slice(0, -5) === srcPath.toLowerCase());
+};
+const main = async () => {
+    const start = performance.now();
+    const srcPath = commander_1.program.getOptionValue('source');
+    const localePath = commander_1.program.getOptionValue('locales');
+    const format = commander_1.program.getOptionValue('format');
+    const exclude = commander_1.program.getOptionValue('exclude');
+    const ignore = commander_1.program.getOptionValue('ignore');
+    const unusedSrcPath = commander_1.program.getOptionValue('unused');
+    const componentFunctions = commander_1.program.getOptionValue('parserComponentFunctions');
+    if (!srcPath) {
+        console.log(chalk_1.default.red('Source not found. Please provide a valid source locale, i.e. -s en-US'));
+        (0, node_process_1.exit)(1);
+    }
+    if (!localePath || localePath.length === 0) {
+        console.log(chalk_1.default.red('Locale file(s) not found. Please provide valid locale file(s), i.e. -locales translations/'));
+        (0, node_process_1.exit)(1);
+    }
+    const excludedPaths = exclude ?? [];
+    const localePathFolders = localePath;
+    const isMultiFolders = localePathFolders.length > 1;
+    const srcFiles = [];
+    const targetFiles = [];
+    const pattern = isMultiFolders
+        ? `{${localePath.join(',').trim()}}/**/*.{json,yaml,yml}`
+        : `${localePath.join(',').trim()}/**/*.{json,yaml,yml}`;
+    const files = await (0, glob_1.glob)(pattern, {
+        ignore: ['node_modules/**'].concat(excludedPaths),
+        windowsPathsNoEscape: true,
+    });
+    console.log('i18n translations checker');
+    console.log(chalk_1.default.gray(`Source: ${srcPath}`));
+    if (format) {
+        console.log(chalk_1.default.blackBright(`Selected format is: ${format}`));
+    }
+    const options = {
+        checks: getCheckOptions(),
+        format: format ?? undefined,
+        ignore,
+    };
+    const fileInfos = [];
+    files.sort().forEach((file) => {
+        const filePath = file.split(node_path_1.default.sep);
+        const name = filePath.pop() ?? '';
+        const extension = name.split('.').pop() ?? 'json';
+        fileInfos.push({
+            extension,
+            file,
+            name,
+            path: filePath,
+        });
+    });
+    fileInfos.forEach(({ extension, file, name, path }) => {
+        let rawContent;
+        if (extension === 'yaml') {
+            rawContent = js_yaml_1.default.load(node_fs_1.default.readFileSync(file, 'utf-8'));
+        }
+        else {
+            rawContent = JSON.parse(node_fs_1.default.readFileSync(file, 'utf-8'));
+        }
+        const content = (0, flattenTranslations_1.flattenTranslations)(rawContent);
+        if (isSource({ file, name, path }, srcPath)) {
+            srcFiles.push({
+                reference: null,
+                name: file,
+                content,
+            });
+        }
+        else {
+            const fullPath = path.join('-');
+            const reference = fileInfos.find((fileInfo) => {
+                if (!isSource(fileInfo, srcPath)) {
+                    return false;
+                }
+                if (fileInfo.path.join('-') === fullPath) {
+                    return true;
+                }
+                // Check if the folder path matches - ignoring the last folder
+                // Then check if the file names are the same
+                // Example folder structure:
+                // path/to/locales/
+                //   en-US/
+                //      one.json
+                //      two.json
+                //      three.json
+                //   de-DE/
+                //      one.json
+                //      two.json
+                //      three.json
+                //
+                // Referencing: `path/to/locales/en-US/one.json`, `path/to/locales/de-DE/one.json`
+                // Non Referencing: `path/to/locales/en-US/one.json`, `path/to/other/locales/de-DE/one.json`
+                if (fileInfo.path.slice(0, fileInfo.path.length - 1).join('-') ===
+                    path.slice(0, path.length - 1).join('-')) {
+                    return fileInfo.name === name;
+                }
+                return false;
+            });
+            if (reference) {
+                targetFiles.push({
+                    reference: reference.file,
+                    name: file,
+                    content,
+                });
+            }
+        }
+    });
+    if (srcFiles.length === 0) {
+        console.log(chalk_1.default.red('Source not found. Please provide a valid source locale, i.e. -s en-US'));
+        (0, node_process_1.exit)(1);
+    }
+    if ((options.checks.includes('missingKeys') ||
+        options.checks.includes('invalidKeys')) &&
+        targetFiles.length === 0) {
+        // Remove missingKeys and invalidKeys from checks since they require multiple files
+        options.checks = options.checks.filter((check) => check !== 'missingKeys' && check !== 'invalidKeys');
+        console.log(chalk_1.default.yellow('\nOnly one locale file found. Skipping missingKeys and invalidKeys checks.\n'));
+    }
+    try {
+        const result = (0, __1.checkTranslations)(srcFiles, targetFiles, options);
+        let unusedKeyResult = undefined;
+        let undefinedKeyResult = undefined;
+        printTranslationResult(result);
+        if (unusedSrcPath) {
+            const isMultiUnusedFolders = unusedSrcPath.length > 1;
+            const pattern = isMultiUnusedFolders
+                ? `{${unusedSrcPath.join(',').trim()}}/**/*.{js,jsx,ts,tsx}`
+                : `${unusedSrcPath.join(',').trim()}/**/*.{js,jsx,ts,tsx}`;
+            const filesToParse = (0, glob_1.globSync)(pattern, {
+                ignore: ['node_modules/**'],
+                windowsPathsNoEscape: true,
+            });
+            const unusedKeys = await (0, __1.checkUnusedKeys)(srcFiles, filesToParse, options, componentFunctions);
+            printUnusedKeysResult({ unusedKeys });
+            unusedKeyResult = unusedKeys;
+            const undefinedKeys = await (0, __1.checkUndefinedKeys)(srcFiles, filesToParse, options, componentFunctions);
+            printUndefinedKeysResult({
+                undefinedKeys,
+            });
+            undefinedKeyResult = undefinedKeys;
+        }
+        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) ||
+            (unusedKeyResult && hasKeys(unusedKeyResult)) ||
+            (undefinedKeyResult && hasKeys(undefinedKeyResult))) {
+            (0, node_process_1.exit)(1);
+        }
+        else {
+            (0, node_process_1.exit)(0);
+        }
+    }
+    catch (e) {
+        let errorMessage = "\nError: Can't validate translations. Check if the format is supported or specify the translation format i.e. -f i18next";
+        // Use enhanced error message if available
+        if (e instanceof findInvalidTranslations_1.CheckError) {
+            errorMessage = `\n${e.message}`;
+            // Check if the error has location information (from ICU parser)
+            if (e.location) {
+                errorMessage += `\nLocation: Line ${e.location.start.line}, Column ${e.location.start.column}`;
+            }
+            // Check if the error has originalMessage (from ICU parser)
+            if (e.originalMessage != null) {
+                errorMessage += `\nProblematic translation: "${e.originalMessage}"`;
+            }
+        }
+        console.log(chalk_1.default.red(errorMessage));
+        (0, node_process_1.exit)(1);
+    }
+};
+const printTranslationResult = ({ missingKeys, invalidKeys, }) => {
+    const reporter = commander_1.program.getOptionValue('reporter');
+    const isSummary = reporter === 'summary';
+    if (missingKeys && Object.keys(missingKeys).length > 0) {
+        console.log(chalk_1.default.red('\nFound missing keys!'));
+        if (isSummary) {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatSummaryTable)(missingKeys)));
+        }
+        else {
+            const table = (0, errorReporters_1.formatCheckResultTable)(missingKeys);
+            console.log(chalk_1.default.red(table));
+        }
+    }
+    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.red('\nFound invalid keys!'));
+        if (isSummary) {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatSummaryTable)(invalidKeys)));
+        }
+        else {
+            const table = (0, errorReporters_1.formatInvalidTranslationsResultTable)(invalidKeys);
+            console.log(chalk_1.default.red(table));
+        }
+    }
+    else if (invalidKeys) {
+        console.log(chalk_1.default.green('\nNo invalid translations found!'));
+    }
+};
+const printUnusedKeysResult = ({ unusedKeys, }) => {
+    const reporter = commander_1.program.getOptionValue('reporter');
+    const isSummary = reporter === 'summary';
+    if (unusedKeys && hasKeys(unusedKeys)) {
+        console.log(chalk_1.default.red('\nFound unused keys!'));
+        if (isSummary) {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatSummaryTable)(unusedKeys)));
+        }
+        else {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatCheckResultTable)(unusedKeys)));
+        }
+    }
+    else if (unusedKeys) {
+        console.log(chalk_1.default.green('\nNo unused keys found!'));
+    }
+};
+const printUndefinedKeysResult = ({ undefinedKeys, }) => {
+    const reporter = commander_1.program.getOptionValue('reporter');
+    const isSummary = reporter === 'summary';
+    if (undefinedKeys && hasKeys(undefinedKeys)) {
+        console.log(chalk_1.default.red('\nFound undefined keys!'));
+        if (isSummary) {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatSummaryTable)(undefinedKeys)));
+        }
+        else {
+            console.log(chalk_1.default.red((0, errorReporters_1.formatCheckResultTable)(undefinedKeys)));
+        }
+    }
+    else if (undefinedKeys) {
+        console.log(chalk_1.default.green('\nNo undefined keys found!'));
+    }
+};
+const hasKeys = (checkResult) => {
+    for (const [_, keys] of Object.entries(checkResult)) {
+        if (keys.length > 0) {
+            return true;
+        }
+    }
+    return false;
+};
+main();

package/dist/errorReporters.d.ts

@@ -0,0 +1,13 @@
+import { CheckResult, InvalidTranslationsResult } from './types';
+export type StandardReporter = {
+    file: string;
+    key: string;
+    msg?: string;
+};
+export declare const CheckOptions: string[];
+export type Context = (typeof CheckOptions)[number];
+export declare const contextMapping: Record<Context, 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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextMapping = exports.CheckOptions = void 0;
+exports.formatSummaryTable = formatSummaryTable;
+exports.formatTable = formatTable;
+exports.formatCheckResultTable = formatCheckResultTable;
+exports.formatInvalidTranslationsResultTable = formatInvalidTranslationsResultTable;
+exports.CheckOptions = [
+    'invalidKeys',
+    'missingKeys',
+    'unused',
+    'undefined',
+];
+exports.contextMapping = {
+    invalidKeys: 'invalid',
+    missingKeys: 'missing',
+    unused: 'unused',
+    undefined: 'undefined',
+};
+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 [[['file', 'total']], rows];
+};
+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);
+            }
+        }
+    }
+    const lines = [];
+    lines.push(formatSeparatorRow(colWidths, '┌┬┐'));
+    for (const rows of rowGroups) {
+        for (const row of rows) {
+            lines.push(formatRow(row, colWidths));
+        }
+        lines.push(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);
+}
+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/index.d.ts

@@ -0,0 +1,9 @@
+import { CheckResult, InvalidTranslationsResult, Options, Translation, TranslationFile } from './types';
+export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => InvalidTranslationsResult;
+export declare const checkMissingTranslations: (source: Translation, targets: Record<string, Translation>, options: Options) => CheckResult;
+export declare const checkTranslations: (source: TranslationFile[], targets: TranslationFile[], options?: Options) => {
+    missingKeys: CheckResult | undefined;
+    invalidKeys: InvalidTranslationsResult | 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>;