@lingual/i18n-check 0.9.0 → 0.9.1

package/dist/utils/findInvalidTranslations.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDiff = exports.compareTranslationFiles = exports.findInvalidTranslations = exports.CheckError = void 0;
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class CheckError extends Error {
+}
+exports.CheckError = CheckError;
+function isLocation(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        'start' in value &&
+        typeof value.start === 'object' &&
+        value.start != null &&
+        'line' in value.start &&
+        typeof value.start.line === 'number' &&
+        'column' in value.start &&
+        typeof value.start.column === 'number');
+}
+const findInvalidTranslations = (source, files) => {
+    const differences = {};
+    if (Object.keys(files).length === 0) {
+        return differences;
+    }
+    for (const [lang, file] of Object.entries(files)) {
+        try {
+            const result = (0, exports.compareTranslationFiles)(source, file);
+            if (result.length > 0) {
+                differences[lang] = result;
+            }
+        }
+        catch (error) {
+            // Re-throw with file context
+            const enhancedError = new CheckError(`Error in translation file "${lang}": ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error) {
+                if ('location' in error && isLocation(error.location)) {
+                    enhancedError.location = error.location;
+                }
+                if ('originalMessage' in error &&
+                    typeof error.originalMessage === 'string') {
+                    enhancedError.originalMessage = error.originalMessage;
+                }
+            }
+            throw enhancedError;
+        }
+    }
+    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) => {
+    const diffs = [];
+    for (const key in a) {
+        if (b[key] === undefined) {
+            continue;
+        }
+        try {
+            const parsedTranslationA = (0, icu_messageformat_parser_1.parse)(String(a[key]));
+            const parsedTranslationB = (0, icu_messageformat_parser_1.parse)(String(b[key]));
+            if ((0, exports.hasDiff)(parsedTranslationA, parsedTranslationB)) {
+                const msg = getErrorMessage(parsedTranslationA, parsedTranslationB);
+                diffs.push({ key, msg });
+            }
+        }
+        catch (error) {
+            // Re-throw with key context and preserve location/originalMessage
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const enhancedError = new CheckError(`Failed to parse translation key "${key}": ${errorMessage === 'INVALID_TAG' ? 'Invalid ICU message format tags found in translation content' : errorMessage}`);
+            if (error instanceof Error) {
+                if ('location' in error && isLocation(error.location)) {
+                    enhancedError.location = error.location;
+                }
+                if ('originalMessage' in error &&
+                    typeof error.originalMessage === 'string') {
+                    enhancedError.originalMessage = error.originalMessage;
+                }
+            }
+            throw enhancedError;
+        }
+    }
+    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 ((0, icu_messageformat_parser_1.isPluralElement)(formatElementA) || (0, icu_messageformat_parser_1.isPluralElement)(formatElementB)) {
+            const optionsA = (0, icu_messageformat_parser_1.isPluralElement)(formatElementA)
+                ? formatElementA.options
+                : {};
+            const optionsB = (0, icu_messageformat_parser_1.isPluralElement)(formatElementB)
+                ? formatElementB.options
+                : {};
+            return Object.keys(optionsA)
+                .sort()
+                .some((key) => {
+                // We can only compare translations that have the same plural keys.
+                // In English, we might have "one", "other", but in German, we might have "one", "few", "other".
+                // Or, in Arabic it might just be "other".
+                // So, we'll have to skip over the ones that don't have a one-to-one match.
+                if (!optionsB[key]) {
+                    return false;
+                }
+                return (0, exports.hasDiff)(optionsA[key].value, optionsB[key].value);
+            });
+        }
+        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;
+        }
+        if (!(0, icu_messageformat_parser_1.isPoundElement)(formatElementA) &&
+            !(0, icu_messageformat_parser_1.isPoundElement)(formatElementB) &&
+            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)) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            const optionsB = Object.keys(formatElementB.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;
+const getErrorMessage = (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);
+    const errors = compA.reduce((acc, formatElementA, index) => {
+        const formatElementB = compB[index];
+        if (!formatElementB) {
+            acc.push(`Missing element ${typeLookup[formatElementA.type]}`);
+            return acc;
+        }
+        if (formatElementA.type !== formatElementB.type) {
+            acc.push(`Expected element of type "${typeLookup[formatElementA.type]}" but received "${typeLookup[formatElementB.type]}"`);
+            return acc;
+        }
+        if (formatElementA.location !== formatElementB.location) {
+            acc.push(`Expected location to be ${formatElementA.location?.start?.line}:${formatElementA.location?.start?.column}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isPoundElement)(formatElementA) && (0, icu_messageformat_parser_1.isPoundElement)(formatElementB)) {
+            return acc;
+        }
+        if (!(0, icu_messageformat_parser_1.isPoundElement)(formatElementA) &&
+            !(0, icu_messageformat_parser_1.isPoundElement)(formatElementB) &&
+            formatElementA.value !== formatElementB.value) {
+            acc.push(`Expected ${typeLookup[formatElementA.type]} to contain "${formatElementA.value}" but received "${formatElementB.value}"`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isTagElement)(formatElementA) && (0, icu_messageformat_parser_1.isTagElement)(formatElementB)) {
+            acc.push(`Error in pound element: ${getErrorMessage(formatElementA.children, formatElementB.children)}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isSelectElement)(formatElementA) && (0, icu_messageformat_parser_1.isSelectElement)(formatElementB)) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            const elementErrors = [];
+            optionsA.forEach((key) => {
+                if (formatElementB.options[key]) {
+                    elementErrors.push(getErrorMessage(formatElementA.options[key].value, formatElementB.options[key].value));
+                }
+            });
+            acc.push(`Error in select: ${elementErrors
+                .flatMap((elementError) => elementError)
+                .join(', ')}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isPluralElement)(formatElementA) && (0, icu_messageformat_parser_1.isPluralElement)(formatElementB)) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            const elementErrors = [];
+            optionsA.forEach((key) => {
+                if (formatElementB.options[key]) {
+                    elementErrors.push(getErrorMessage(formatElementA.options[key].value, formatElementB.options[key].value));
+                }
+            });
+            acc.push(`Error in plural: ${elementErrors
+                .flatMap((elementError) => elementError)
+                .join(', ')}`);
+            return acc;
+        }
+        return acc;
+    }, []);
+    if (compA.length < compB.length) {
+        const unexpectedElements = compB
+            .slice(compA.length)
+            .reduce((acc, formatElementB) => {
+            acc.push(`Unexpected ${typeLookup[formatElementB.type]} element`);
+            return acc;
+        }, [])
+            .join(', ');
+        return [...errors, unexpectedElements].join(', ');
+    }
+    return errors.join(', ');
+};
+const typeLookup = {
+    0: 'literal',
+    1: 'argument',
+    2: 'number',
+    3: 'date',
+    4: 'time',
+    5: 'select',
+    6: 'plural',
+    7: 'pound',
+    8: 'tag',
+};

package/dist/utils/findMissingKeys.d.ts

@@ -0,0 +1,4 @@
+import { Options, Translation } from '../types';
+export declare const findMissingKeys: (source: Translation, targets: Record<string, Translation>, options?: Options) => Record<string, string[]>;
+export declare const compareTranslationFiles: (src: Translation, target: Translation) => string[];
+export declare const compareI18nextTranslationFiles: (src: Translation, target: Translation) => string[];

package/dist/utils/findMissingKeys.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareI18nextTranslationFiles = exports.compareTranslationFiles = exports.findMissingKeys = void 0;
+const constants_1 = require("./constants");
+const findMissingKeys = (source, targets, options = {}) => {
+    const differences = {};
+    for (const [lang, file] of Object.entries(targets)) {
+        const result = options.format === 'i18next'
+            ? (0, exports.compareI18nextTranslationFiles)(source, file)
+            : (0, exports.compareTranslationFiles)(source, file);
+        if (result.length > 0) {
+            differences[lang] = result;
+        }
+    }
+    return differences;
+};
+exports.findMissingKeys = findMissingKeys;
+const compareTranslationFiles = (src, target) => {
+    const diffs = [];
+    for (const key in src) {
+        const counterKey = target[key];
+        if (!counterKey) {
+            diffs.push(key);
+        }
+    }
+    return diffs;
+};
+exports.compareTranslationFiles = compareTranslationFiles;
+const compareI18nextTranslationFiles = (src, target) => {
+    const diffs = [];
+    const flattedSrc = Object.entries(src).reduce((acc, [k, v]) => {
+        const pluralSuffix = constants_1.I18NEXT_PLURAL_SUFFIX.find((suffix) => {
+            return k.endsWith(suffix);
+        });
+        const key = pluralSuffix ? k.replace(pluralSuffix, '') : k;
+        acc[key] = v;
+        return acc;
+    }, {});
+    const flattedTarget = Object.entries(target).reduce((acc, [k, v]) => {
+        const pluralSuffix = constants_1.I18NEXT_PLURAL_SUFFIX.find((suffix) => {
+            return k.endsWith(suffix);
+        });
+        const key = pluralSuffix ? k.replace(pluralSuffix, '') : k;
+        acc[key] = v;
+        return acc;
+    }, {});
+    for (const key in flattedSrc) {
+        const counterKey = flattedTarget[key];
+        if (!counterKey) {
+            diffs.push(key);
+        }
+    }
+    return diffs;
+};
+exports.compareI18nextTranslationFiles = compareI18nextTranslationFiles;

package/dist/utils/flattenTranslations.d.ts

@@ -0,0 +1,3 @@
+import { Translation } from '../types';
+export declare const flattenTranslations: (translations: Translation) => Translation;
+export declare const flattenEntry: (entry: Translation, keys?: string[]) => Translation;

package/dist/utils/flattenTranslations.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenEntry = exports.flattenTranslations = void 0;
+const flattenTranslations = (translations) => {
+    if (!hasNestedDefinitions(translations)) {
+        return translations;
+    }
+    return (0, exports.flattenEntry)(translations);
+};
+exports.flattenTranslations = flattenTranslations;
+/**
+ * Top level search for any objects
+ */
+const hasNestedDefinitions = (translations) => {
+    return Object.values(translations).find((translation) => typeof translation === 'object');
+};
+const isTranslationObject = (entry) => {
+    return typeof entry === 'object';
+};
+const flattenEntry = (entry, keys = []) => {
+    const result = {};
+    if (!entry) {
+        return result;
+    }
+    const entries = Object.entries(entry);
+    for (const [k, v] of entries) {
+        Object.assign(result, isTranslationObject(v)
+            ? (0, exports.flattenEntry)(v, [...keys, String(k)])
+            : { [[...keys, String(k)].join('.')]: v });
+    }
+    return result;
+};
+exports.flattenEntry = flattenEntry;

package/dist/utils/i18NextParser.d.ts

@@ -0,0 +1,37 @@
+export type MessageFormatElement = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'interpolation';
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: 'interpolation_unescaped';
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: 'nesting';
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: 'plural';
+    raw: string;
+    prefix: string;
+    suffix: string;
+    content: string;
+    variable: string;
+} | {
+    type: 'tag';
+    raw: string;
+    voidElement: boolean;
+};
+export declare const parse: (input: string) => MessageFormatElement[];

package/dist/utils/i18NextParser.js

@@ -0,0 +1,104 @@
+"use strict";
+//  Based on https://github.com/i18next/i18next-translation-parser/blob/v1.0.0/src/parse.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const REGEXP = new RegExp('({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)(?=\\[)|<[^>]+>)', 'g');
+const DOUBLE_BRACE = '{{';
+const $_T_BRACE = '$t{';
+const $_T_PARENTHESIS = '$t(';
+const OPEN_PARENTHESIS = '(';
+const OPEN_TAG = '<';
+const CLOSE_TAG = '</';
+const parse = (input) => {
+    let ast = [];
+    ast = parseInput([input]);
+    return ast;
+};
+exports.parse = parse;
+const parseInput = (input) => {
+    if (input.length === 0) {
+        return [];
+    }
+    let ast = [];
+    input.forEach((element) => {
+        const elements = element.split(REGEXP).filter((element) => element !== '');
+        const result = elements.reduce((acc, match) => {
+            if (match.indexOf('{{-') === 0) {
+                const content = match.substring(3, match.length - 2);
+                acc.push({
+                    type: 'interpolation_unescaped',
+                    raw: match,
+                    prefix: '{{-',
+                    suffix: '}}',
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(DOUBLE_BRACE) === 0) {
+                const content = match.substring(2, match.length - 2);
+                acc.push({
+                    type: 'interpolation',
+                    raw: match,
+                    prefix: '{{',
+                    suffix: '}}',
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf($_T_BRACE) === 0) {
+                const content = match.substring(3, match.length - 1);
+                acc.push({
+                    type: 'nesting',
+                    raw: match,
+                    prefix: '$t{',
+                    suffix: '}',
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf($_T_PARENTHESIS) === 0) {
+                const content = match.substring(3, match.length - 1);
+                acc.push({
+                    type: 'nesting',
+                    raw: match,
+                    prefix: '$t(',
+                    suffix: ')',
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(OPEN_PARENTHESIS) === 0 &&
+                /\([0-9\-inf]+\)/.test(match)) {
+                const content = match.substring(1, match.length - 1);
+                acc.push({
+                    type: 'plural',
+                    raw: match,
+                    prefix: '(',
+                    suffix: ')',
+                    content,
+                    variable: content.trim(),
+                });
+            }
+            else if (match.indexOf(CLOSE_TAG) === 0) {
+                acc.push({
+                    type: 'tag',
+                    raw: match,
+                    voidElement: match.substring(match.length - 2) === '/>',
+                });
+            }
+            else if (match.indexOf(OPEN_TAG) === 0 && /<[^\s]+/.test(match)) {
+                acc.push({
+                    type: 'tag',
+                    raw: match,
+                    voidElement: match.substring(match.length - 2) === '/>',
+                });
+            }
+            else {
+                acc.push({ type: 'text', content: match });
+            }
+            return acc;
+        }, []);
+        ast = ast.concat(result);
+    });
+    return ast;
+};

package/dist/utils/i18NextSrcParser.d.ts

@@ -0,0 +1,35 @@
+/**
+ *
+ * Based on the original [i18next-parser](https://github.com/i18next/i18next-parser)
+ *
+ */
+type Options = {
+    attr: string;
+    componentFunctions: string[];
+    functions: string[];
+    namespaceFunctions: string[];
+    parseGenerics: boolean;
+    transSupportBasicHtmlNodes: boolean;
+    transIdentityFunctionsToIgnore: string[];
+    typeMap: Record<string, unknown>;
+    translationFunctionsWithArgs: Record<string, {
+        pos: number;
+        storeGlobally: boolean;
+        keyPrefix?: string;
+        ns?: string;
+    }>;
+    keyPrefix?: string;
+    defaultNamespace?: string;
+    transKeepBasicHtmlNodesFor: string[];
+    omitAttributes: string[];
+};
+type FoundKey = {
+    key: string;
+    ns?: string;
+    namespace?: string;
+    functionName?: string;
+    defaultValue?: string;
+    [key: string]: unknown;
+};
+export declare const getKeys: (path: string, options: Partial<Options>, content: string) => FoundKey[];
+export {};