@lingual/i18n-check 0.9.2 → 0.9.4

package/README.md

@@ -259,6 +259,34 @@ yarn i18n:check --locales translations/i18NextMessageExamples -s en-US -f i18nex
 -u src --parser-component-functions WrappedTransComponent AnotherWrappedTransComponent
 ```
 
+### --next-intl-translation-fn-type-alias
+
+To find any indirect function calls inside a `next-intl` codebase, the parser will try to find the type `ReturnType<typeof useTranslations>` in the function call arguments.
+
+```ts
+const indirectFnCall = (
+  t: ReturnType<typeof useTranslations<'SomeNameSpace'>>
+) => {
+  const indirectTranslation = t('someKey');
+  // Do something with the indirectTranslation
+};
+```
+
+When a type alias is used instead of `ReturnType<typeof useTranslations>`, the `--next-intl-translation-fn-type-alias` option can be used to tell the parser the name of the type or types.
+
+```ts
+import { NextIntlTranslateFnAlias } from './types';
+
+const indirectFnCall = (t: NextIntlTranslateFnAlias<'SomeNameSpace'>) => {
+  const indirectTranslation = t('someKey');
+  // Do something with the indirectTranslation
+};
+```
+
+```bash
+yarn i18n:check --source en --locales translations/codeExamples/next-intl/locales/ -f next-intl -u translations/codeExamples/next-intl/src --next-intl-translation-fn-type-alias NextIntlTranslateFnAlias
+```
+
 ## Examples
 
 i18n-check is able to load and validate against different locale folder structures. Depending on how the locale files are organized, there are different configuration options.

package/dist/bin/index.js

@@ -9,7 +9,7 @@ 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 yaml_1 = require("yaml");
 const __1 = require("..");
 const errorReporters_1 = require("../errorReporters");
 const flattenTranslations_1 = require("../utils/flattenTranslations");
@@ -28,6 +28,7 @@ commander_1.program
     .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')
+    .option('--next-intl-translation-fn-type-alias <nextIntlTranslationFnTypeAliases...>', 'next-intl translation function type aliases')
     .parse();
 const getCheckOptions = () => {
     const checkOption = commander_1.program.getOptionValue('only') || commander_1.program.getOptionValue('check');
@@ -52,6 +53,7 @@ const main = async () => {
     const ignore = commander_1.program.getOptionValue('ignore');
     const unusedSrcPath = commander_1.program.getOptionValue('unused');
     const componentFunctions = commander_1.program.getOptionValue('parserComponentFunctions');
+    const nextIntlTranslationFnTypeAlias = commander_1.program.getOptionValue('nextIntlTranslationFnTypeAlias');
     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);
@@ -81,6 +83,7 @@ const main = async () => {
         checks: getCheckOptions(),
         format: format ?? undefined,
         ignore,
+        nextIntlTranslationFnTypeAlias,
     };
     const fileInfos = [];
     files.sort().forEach((file) => {
@@ -97,7 +100,7 @@ const main = async () => {
     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'));
+            rawContent = (0, yaml_1.parse)(node_fs_1.default.readFileSync(file, 'utf-8'));
         }
         else {
             rawContent = JSON.parse(node_fs_1.default.readFileSync(file, 'utf-8'));

package/dist/index.js

@@ -7,13 +7,13 @@ exports.checkUndefinedKeys = exports.checkUnusedKeys = exports.checkTranslations
 const findMissingKeys_1 = require("./utils/findMissingKeys");
 const findInvalidTranslations_1 = require("./utils/findInvalidTranslations");
 const findInvalidI18NextTranslations_1 = require("./utils/findInvalidI18NextTranslations");
-const cli_lib_1 = require("@formatjs/cli-lib");
 const i18NextSrcParser_1 = require("./utils/i18NextSrcParser");
 const nextIntlSrcParser_1 = require("./utils/nextIntlSrcParser");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("./utils/constants");
 const ParseFormats = ['react-intl', 'i18next', 'next-intl'];
+const CONTEXT_SEPARATOR = '_';
 const checkInvalidTranslations = (source, targets, options = { format: 'icu' }) => {
     return options.format === 'i18next'
         ? (0, findInvalidI18NextTranslations_1.findInvalidI18NextTranslations)(source, targets)
@@ -74,25 +74,28 @@ const checkUnusedKeys = async (translationFiles, filesToParse, options = {
         return findUnusedI18NextTranslations(filteredTranslationFiles, filesToParse, componentFunctions);
     }
     else if (options.format === 'next-intl') {
-        return findUnusedNextIntlTranslations(filteredTranslationFiles, filesToParse);
+        return findUnusedNextIntlTranslations(filteredTranslationFiles, filesToParse, options);
     }
 };
 exports.checkUnusedKeys = checkUnusedKeys;
 const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) => {
-    const unusedKeys = {};
-    const extracted = await (0, cli_lib_1.extract)(filesToParse, {});
-    const extractedResultSet = new Set(Object.keys(JSON.parse(extracted)));
-    translationFiles.forEach(({ name, content }) => {
-        const keysInSource = Object.keys(content);
-        const found = [];
-        for (const keyInSource of keysInSource) {
-            if (!extractedResultSet.has(keyInSource)) {
-                found.push(keyInSource);
+    return (async () => {
+        const { extract } = await import('@formatjs/cli-lib');
+        const unusedKeys = {};
+        const extracted = await extract(filesToParse, {});
+        const extractedResultSet = new Set(Object.keys(JSON.parse(extracted)));
+        translationFiles.forEach(({ name, content }) => {
+            const keysInSource = Object.keys(content);
+            const found = [];
+            for (const keyInSource of keysInSource) {
+                if (!extractedResultSet.has(keyInSource)) {
+                    found.push(keyInSource);
+                }
             }
-        }
-        unusedKeys[name] = found;
-    });
-    return unusedKeys;
+            unusedKeys[name] = found;
+        });
+        return unusedKeys;
+    })();
 };
 const findUnusedI18NextTranslations = async (source, filesToParse, componentFunctions = []) => {
     const unusedKeys = {};
@@ -127,9 +130,9 @@ const findUnusedI18NextTranslations = async (source, filesToParse, componentFunc
     });
     return unusedKeys;
 };
-const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) => {
+const findUnusedNextIntlTranslations = async (translationFiles, filesToParse, options) => {
     const unusedKeys = {};
-    const extracted = (0, nextIntlSrcParser_1.extract)(filesToParse);
+    const extracted = (0, nextIntlSrcParser_1.extract)(filesToParse, options);
     const dynamicNamespaces = extracted.flatMap((namespace) => {
         if (namespace.meta.dynamic) {
             return [namespace.key];
@@ -189,27 +192,30 @@ exports.checkUndefinedKeys = checkUndefinedKeys;
 const findUndefinedReactIntlKeys = async (translationFiles, filesToParse, options = {
     ignore: [],
 }) => {
-    const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
-        return Object.keys(content);
-    }));
-    const extractedResult = await (0, cli_lib_1.extract)(filesToParse, {
-        extractSourceLocation: true,
-    });
-    const undefinedKeys = {};
-    Object.entries(JSON.parse(extractedResult)).forEach(([key, meta]) => {
-        if (!sourceKeys.has(key) && !isIgnoredKey(options.ignore ?? [], key)) {
-            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] = [];
+    return (async () => {
+        const { extract } = await import('@formatjs/cli-lib');
+        const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
+            return Object.keys(content);
+        }));
+        const undefinedKeys = {};
+        const extractedResult = await extract(filesToParse, {
+            extractSourceLocation: true,
+        });
+        Object.entries(JSON.parse(extractedResult)).forEach(([key, meta]) => {
+            if (!sourceKeys.has(key) && !isIgnoredKey(options.ignore ?? [], key)) {
+                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] = [];
+                }
+                undefinedKeys[file].push(key);
             }
-            undefinedKeys[file].push(key);
-        }
-    });
-    return undefinedKeys;
+        });
+        return undefinedKeys;
+    })();
 };
 const findUndefinedI18NextKeys = async (source, filesToParse, options = {
     ignore: [],
@@ -219,7 +225,7 @@ const findUndefinedI18NextKeys = async (source, filesToParse, options = {
         .flatMap(({ content }) => {
         return Object.keys(content);
     })
-        // Ensure that any plural definitiions like key_one, key_other etc.
+        // Ensure that any plural definitions like key_one, key_other etc.
         // are flatted into a single key
         .map((key) => {
         const pluralSuffix = constants_1.I18NEXT_PLURAL_SUFFIX.find((suffix) => {
@@ -249,7 +255,7 @@ const findUndefinedNextIntlKeys = async (translationFiles, filesToParse, options
     const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
         return Object.keys(content);
     }));
-    const extractedResult = (0, nextIntlSrcParser_1.extract)(filesToParse);
+    const extractedResult = (0, nextIntlSrcParser_1.extract)(filesToParse, options);
     const undefinedKeys = {};
     extractedResult.forEach(({ key, meta }) => {
         if (!meta.dynamic &&
@@ -302,7 +308,9 @@ const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
             else {
                 extractedResult.push({
                     file,
-                    key: entry.key,
+                    key: entry.context
+                        ? `${entry.key}${CONTEXT_SEPARATOR}${entry.context}`
+                        : entry.key,
                     namespace: entry.namespace,
                 });
             }

package/dist/types.d.ts

@@ -20,4 +20,5 @@ export type Options = {
     format?: 'icu' | 'i18next' | 'react-intl' | 'next-intl';
     checks?: Context[];
     ignore?: string[];
+    nextIntlTranslationFnTypeAlias?: string[];
 };

package/dist/utils/i18NextParser.js

@@ -10,9 +10,7 @@ const OPEN_PARENTHESIS = '(';
 const OPEN_TAG = '<';
 const CLOSE_TAG = '</';
 const parse = (input) => {
-    let ast = [];
-    ast = parseInput([input]);
-    return ast;
+    return parseInput([input]);
 };
 exports.parse = parse;
 const parseInput = (input) => {

package/dist/utils/i18NextSrcParser.js

@@ -347,6 +347,49 @@ const extractFromExpression = (node, options) => {
             }
             entries[0].key = concatenatedString;
         }
+        else if (ts.isFunctionExpression(keyArgument) ||
+            ts.isFunctionDeclaration(keyArgument) ||
+            ts.isArrowFunction(keyArgument)) {
+            // Try to find selector api definitions: ($) => $.a.b.c
+            if (!keyArgument.body) {
+                return null;
+            }
+            // Check if the function contains a return statement
+            if (ts.isBlock(keyArgument.body)) {
+                const returnStatement = keyArgument.body.statements.find((statement) => ts.isReturnStatement(statement));
+                if (returnStatement &&
+                    returnStatement.expression &&
+                    ts.isPropertyAccessExpression(returnStatement.expression)) {
+                    const [_, ...keys] = returnStatement.expression
+                        .getFullText()
+                        .split('.');
+                    entries[0].key = keys.join('.');
+                }
+                // check if the access is defined as an array.
+                // $["a.b.c"]
+                else if (returnStatement &&
+                    returnStatement.expression &&
+                    ts.isElementAccessExpression(returnStatement.expression)) {
+                    entries[0].key = returnStatement.expression.argumentExpression
+                        .getFullText()
+                        .replace(/['"]/g, '');
+                }
+                else {
+                    return null;
+                }
+                // check if the access is defined as an array.
+                // $["a.b.c"]
+            }
+            else if (ts.isElementAccessExpression(keyArgument.body)) {
+                entries[0].key = keyArgument.body.argumentExpression
+                    .getFullText()
+                    .replace(/['"]/g, '');
+            }
+            else {
+                const [_, ...keys] = keyArgument.body.getFullText().split('.');
+                entries[0].key = keys.join('.');
+            }
+        }
         else {
             return null;
         }

package/dist/utils/nextIntlSrcParser.d.ts

@@ -1,4 +1,5 @@
-export declare const extract: (filesPaths: string[]) => {
+import { Options } from '../types';
+export declare const extract: (filesPaths: string[], options?: Options) => {
     key: string;
     meta: {
         file: string;

package/dist/utils/nextIntlSrcParser.js

@@ -42,13 +42,15 @@ const ts = __importStar(require("typescript"));
 const USE_TRANSLATIONS = 'useTranslations';
 const GET_TRANSLATIONS = 'getTranslations';
 const COMMENT_CONTAINS_STATIC_KEY_REGEX = /i18n-check t\((["'])(.*?[^\\])(["'])\)/;
-const extract = (filesPaths) => {
-    return filesPaths.flatMap(getKeys).sort((a, b) => {
+const extract = (filesPaths, options = {}) => {
+    return filesPaths
+        .flatMap((path) => getKeys(path, options))
+        .sort((a, b) => {
         return a.key > b.key ? 1 : -1;
     });
 };
 exports.extract = extract;
-const getKeys = (path) => {
+const getKeys = (path, options) => {
     const content = node_fs_1.default.readFileSync(path, 'utf-8');
     const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
     const foundKeys = [];
@@ -328,6 +330,83 @@ const getKeys = (path) => {
                     }
                 }
             }
+            // Third scenaro is if t function the type is
+            // an alias for ReturnType<typeof useTranslations>
+            const tFunctionAliasParam = node.parameters &&
+                node.parameters.find((param) => param.type &&
+                    ts.isTypeReferenceNode(param.type) &&
+                    param.type.typeName &&
+                    ts.isIdentifier(param.type.typeName) &&
+                    options &&
+                    options.nextIntlTranslationFnTypeAlias !== undefined &&
+                    options?.nextIntlTranslationFnTypeAlias.includes(param.type.typeName.text));
+            if (tFunctionAliasParam !== undefined &&
+                tFunctionAliasParam.type &&
+                ts.isTypeReferenceNode(tFunctionAliasParam.type)) {
+                const [namespaceArgument] = tFunctionAliasParam.type.typeArguments &&
+                    tFunctionAliasParam.type.typeArguments.length > 0
+                    ? tFunctionAliasParam.type.typeArguments
+                    : [];
+                if (ts.isIdentifier(tFunctionAliasParam.name)) {
+                    const name = namespaceArgument &&
+                        ts.isLiteralTypeNode(namespaceArgument) &&
+                        ts.isStringLiteral(namespaceArgument.literal)
+                        ? namespaceArgument.literal.text
+                        : '';
+                    pushNamespace({
+                        name,
+                        variable: tFunctionAliasParam.name.text,
+                    });
+                }
+            }
+            // Fourth scenario is the t function is defined as an object property and uses an alias:
+            // someFn({t}: {t: AliasForTheOriginalNextIntlType}>
+            const tFunctionParamAliasAsProperty = node.parameters &&
+                node.parameters.find((param) => param.type &&
+                    ts.isTypeLiteralNode(param.type) &&
+                    param.type.members.find((member) => {
+                        return (ts.isPropertySignature(member) &&
+                            member.type &&
+                            ts.isTypeReferenceNode(member.type) &&
+                            member.type.typeName &&
+                            ts.isIdentifier(member.type.typeName) &&
+                            options &&
+                            options.nextIntlTranslationFnTypeAlias !== undefined &&
+                            options?.nextIntlTranslationFnTypeAlias.includes(member.type.typeName.text));
+                    }));
+            if (tFunctionParamAliasAsProperty !== undefined &&
+                tFunctionParamAliasAsProperty.type &&
+                ts.isTypeLiteralNode(tFunctionParamAliasAsProperty.type)) {
+                const fnType = tFunctionParamAliasAsProperty.type.members.find((member) => {
+                    return (ts.isPropertySignature(member) &&
+                        member.type &&
+                        ts.isTypeReferenceNode(member.type) &&
+                        member.type.typeName &&
+                        ts.isIdentifier(member.type.typeName) &&
+                        options &&
+                        options.nextIntlTranslationFnTypeAlias !== undefined &&
+                        options?.nextIntlTranslationFnTypeAlias.includes(member.type.typeName.text));
+                });
+                if (fnType &&
+                    ts.isPropertySignature(fnType) &&
+                    fnType.type &&
+                    ts.isTypeReferenceNode(fnType.type)) {
+                    const [namespaceArgument] = fnType.type.typeArguments && fnType.type.typeArguments.length > 0
+                        ? fnType.type.typeArguments
+                        : [];
+                    if (fnType.name && ts.isIdentifier(fnType.name)) {
+                        const name = namespaceArgument &&
+                            ts.isLiteralTypeNode(namespaceArgument) &&
+                            ts.isStringLiteral(namespaceArgument.literal)
+                            ? namespaceArgument.literal.text
+                            : '';
+                        pushNamespace({
+                            name,
+                            variable: fnType.name.text,
+                        });
+                    }
+                }
+            }
         }
         // Search for `t()` calls
         if (getCurrentNamespaces() !== null &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "i18n translation messages check",
   "license": "MIT",
   "main": "dist/index.js",
@@ -24,24 +24,23 @@
     "!dist/**/*.test.*"
   ],
   "dependencies": {
-    "@formatjs/cli-lib": "^8.2.3",
+    "@formatjs/cli-lib": "^8.5.1",
     "@formatjs/icu-messageformat-parser": "^2.11.4",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
-    "glob": "12.0.0",
-    "js-yaml": "^4.1.1",
-    "typescript": "^5.9.3"
+    "glob": "^13.0.6",
+    "typescript": "^5.9.3",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.1",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.19.1",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.19.17",
     "braces": "^3.0.3",
-    "eslint": "^9.39.1",
-    "globals": "^16.5.0",
-    "prettier": "^3.6.2",
-    "typescript-eslint": "^8.47.0",
-    "vitest": "^4.0.10"
+    "eslint": "^10.2.1",
+    "globals": "^17.5.0",
+    "prettier": "^3.8.3",
+    "typescript-eslint": "^8.59.0",
+    "vitest": "^4.1.5"
   },
   "repository": {
     "type": "git",
@@ -50,5 +49,5 @@
   "engines": {
     "node": ">=20"
   },
-  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39"
+  "packageManager": "pnpm@10.28.2+sha512.41872f037ad22f7348e3b1debbaf7e867cfd448f2726d9cf74c08f19507c31d2c8e7a11525b983febc2df640b5438dee6023ebb1f84ed43cc2d654d2bc326264"
 }