@lingual/i18n-check 0.5.5 → 0.7.0

package/README.md

@@ -138,9 +138,11 @@ yarn i18n:check --locales translations/messageExamples -s en-US -o missingKeys i
 
 ### --unused, -u
 
-This feature is currently only supported for `react-intl` and `i18next` based React applications and is useful when you need to know which keys exist in your translation files but not in your codebase. Via the `-u` or `--unused` option you provide a source path to the code, which will be parsed to find all unused keys in the primary target language.
+This feature is currently only supported for `react-intl` and `i18next` as well as `next-intl` (experimental at the moment) based React applications and is useful when you need to know which keys exist in your translation files but not in your codebase. Additionally an inverse check is run to find any keys that exist in the codebase but not in the translation files.
 
-It is important to note that you must also provide the `-f` or `--format` option with `react-intl` or `i18next` as value. See the [`format` section](#--format) for more information.
+Via the `-u` or `--unused` option you provide a source path to the code, which will be parsed to find all unused as well as undefined keys in the primary target language.
+
+It is important to note that you must also provide the `-f` or `--format` option with `react-intl`, `i18next` or `next-intl` as value. See the [`format` section](#--format) for more information.
 
 ```bash
 yarn i18n:check --locales translations/messageExamples -s en-US -u client/ -f react-intl
@@ -152,6 +154,12 @@ or
 yarn i18n:check --locales translations/messageExamples -s en-US -u client/ -f i18next
 ```
 
+or
+
+```bash
+yarn i18n:check --locales translations/messageExamples -s en-US -u client/ -f next-intl
+```
+
 ### --reporter, -r
 
 The standard reporting prints out all the missing or invalid keys.

package/dist/bin/index.js

@@ -1,14 +1,5 @@
 #! /usr/bin/env node
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -27,12 +18,12 @@ 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 or react-intl")
+    .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: invalid, missing. 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("-u, --unused <path>", "define the source path to find all unused keys")
+    .option("-u, --unused <path>", "define the source path 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 = () => {
@@ -49,7 +40,7 @@ const getCheckOptions = () => {
 const isSource = (fileInfo, srcPath) => {
     return (fileInfo.path.some((path) => path.toLowerCase() === srcPath.toLowerCase()) || fileInfo.name.toLowerCase().slice(0, -5) === srcPath.toLowerCase());
 };
-const main = () => __awaiter(void 0, void 0, void 0, function* () {
+const main = async () => {
     const start = performance.now();
     const srcPath = commander_1.program.getOptionValue("source");
     const localePath = commander_1.program.getOptionValue("locales");
@@ -65,7 +56,7 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
         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 !== null && exclude !== void 0 ? exclude : [];
+    const excludedPaths = exclude ?? [];
     const localePathFolders = localePath;
     const isMultiFolders = localePathFolders.length > 1;
     let srcFiles = [];
@@ -73,7 +64,7 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
     const pattern = isMultiFolders
         ? `{${localePath.join(",").trim()}}/**/*.{json,yaml,yml}`
         : `${localePath.join(",").trim()}/**/*.{json,yaml,yml}`;
-    const files = yield (0, glob_1.glob)(pattern, {
+    const files = await (0, glob_1.glob)(pattern, {
         ignore: ["node_modules/**"].concat(excludedPaths),
     });
     console.log("i18n translations checker");
@@ -83,14 +74,13 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const options = {
         checks: getCheckOptions(),
-        format: format !== null && format !== void 0 ? format : undefined,
+        format: format ?? undefined,
     };
     const fileInfos = [];
     files.sort().forEach((file) => {
-        var _a, _b;
         const path = file.split("/");
-        const name = (_a = path.pop()) !== null && _a !== void 0 ? _a : "";
-        const extension = (_b = name.split(".").pop()) !== null && _b !== void 0 ? _b : "json";
+        const name = path.pop() ?? "";
+        const extension = name.split(".").pop() ?? "json";
         fileInfos.push({
             extension,
             file,
@@ -165,8 +155,15 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
         const result = (0, __1.checkTranslations)(srcFiles, localeFiles, options);
         printTranslationResult(result);
         if (unusedSrcPath) {
-            const unusedKeys = yield (0, __1.checkUnusedKeys)(srcFiles, unusedSrcPath, options, componentFunctions);
+            const filesToParse = (0, glob_1.globSync)(`${unusedSrcPath}/**/*.{ts,tsx}`, {
+                ignore: ["node_modules/**"],
+            });
+            const unusedKeys = await (0, __1.checkUnusedKeys)(srcFiles, filesToParse, options, componentFunctions);
             printUnusedKeysResult({ unusedKeys });
+            const undefinedKeys = await (0, __1.checkUndefinedKeys)(srcFiles, filesToParse, options, componentFunctions);
+            printUndefinedKeysResult({
+                undefinedKeys,
+            });
         }
         const end = performance.now();
         console.log(chalk_1.default.green(`\nDone in ${Math.round(((end - start) * 100) / 1000) / 100}s.`));
@@ -182,7 +179,7 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
         console.log(chalk_1.default.red("\nError: Can't validate translations. Check if the format is supported or specify the translation format i.e. -f i18next"));
         (0, node_process_1.exit)(1);
     }
-});
+};
 const printTranslationResult = ({ missingKeys, invalidKeys, }) => {
     const reporter = commander_1.program.getOptionValue("reporter");
     const isSummary = reporter === "summary";
@@ -214,7 +211,7 @@ const printTranslationResult = ({ missingKeys, invalidKeys, }) => {
 const printUnusedKeysResult = ({ unusedKeys, }) => {
     const reporter = commander_1.program.getOptionValue("reporter");
     const isSummary = reporter === "summary";
-    if (unusedKeys && hasUnusedKeys(unusedKeys)) {
+    if (unusedKeys && hasKeys(unusedKeys)) {
         console.log(chalk_1.default.red("\nFound unused keys!"));
         if (isSummary) {
             console.log(chalk_1.default.red((0, errorReporters_1.summaryReporter)(getSummaryRows(unusedKeys))));
@@ -227,6 +224,22 @@ const printUnusedKeysResult = ({ 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.summaryReporter)(getSummaryRows(undefinedKeys))));
+        }
+        else {
+            console.log(chalk_1.default.red((0, errorReporters_1.standardReporter)(getStandardRows(undefinedKeys))));
+        }
+    }
+    else if (undefinedKeys) {
+        console.log(chalk_1.default.green("\nNo undefined keys found!"));
+    }
+};
 const truncate = (chars) => chars.length > 80 ? `${chars.substring(0, 80)}...` : chars;
 const getSummaryRows = (checkResult) => {
     const formattedRows = [];
@@ -250,7 +263,7 @@ const getStandardRows = (checkResult) => {
     }
     return formattedRows;
 };
-const hasUnusedKeys = (checkResult) => {
+const hasKeys = (checkResult) => {
     for (const [_, keys] of Object.entries(checkResult)) {
         if (keys.length > 0) {
             return true;

package/dist/bin/index.test.js

@@ -264,7 +264,7 @@ No invalid translations found!
                 done();
             });
         });
-        it("should find unused keys for react-i18next applications", (done) => {
+        it("should find unused and undefined keys for react-i18next applications", (done) => {
             (0, child_process_1.exec)("node dist/bin/index.js --source en --locales translations/codeExamples/reacti18next/locales -f i18next -u translations/codeExamples/reacti18next/src --parser-component-functions WrappedTransComponent", (_error, stdout, _stderr) => {
                 const result = stdout.split("Done")[0];
                 expect(result).toEqual(`i18n translations checker
@@ -283,6 +283,73 @@ Found unused keys!
 │  translations/codeExamples/reacti18next/locales/en/translation.json  │  nonExistentKey  │
 └──────────────────────────────────────────────────────────────────────┴──────────────────┘
 
+Found undefined keys!
+┌──────────────────────────────────────────────────────┬────────────────────────────────┐
+│ file                                                 │ key                            │
+├──────────────────────────────────────────────────────┼────────────────────────────────┤
+│  translations/codeExamples/reacti18next/src/App.tsx  │  some.key.that.is.not.defined  │
+└──────────────────────────────────────────────────────┴────────────────────────────────┘
+
+`);
+                done();
+            });
+        });
+        it("should find unused and undefined keys for react-intl applications", (done) => {
+            (0, child_process_1.exec)("node dist/bin/index.js --source en-US --locales translations/codeExamples/react-intl/locales -f react-intl -u translations/codeExamples/react-intl/src", (_error, stdout, _stderr) => {
+                const result = stdout.split("Done")[0];
+                expect(result).toEqual(`i18n translations checker
+Source: en-US
+Selected format is: react-intl
+
+No missing keys found!
+
+No invalid translations found!
+
+Found unused keys!
+┌─────────────────────────────────────────────────────────────────┬─────────────────────────┐
+│ file                                                            │ key                     │
+├─────────────────────────────────────────────────────────────────┼─────────────────────────┤
+│  translations/codeExamples/react-intl/locales/en-US/one.json    │  message.number-format  │
+│  translations/codeExamples/react-intl/locales/en-US/three.json  │  multipleVariables      │
+└─────────────────────────────────────────────────────────────────┴─────────────────────────┘
+
+Found undefined keys!
+┌────────────────────────────────────────────────────┬────────────────────────────────┐
+│ file                                               │ key                            │
+├────────────────────────────────────────────────────┼────────────────────────────────┤
+│  translations/codeExamples/react-intl/src/App.tsx  │  some.key.that.is.not.defined  │
+└────────────────────────────────────────────────────┴────────────────────────────────┘
+
+`);
+                done();
+            });
+        });
+        it("should find unused and undefined keys for next-intl applications", (done) => {
+            (0, child_process_1.exec)("node dist/bin/index.js --source en --locales translations/codeExamples/next-intl/locales/ -f next-intl -u translations/codeExamples/next-intl/src", (_error, stdout, _stderr) => {
+                const result = stdout.split("Done")[0];
+                expect(result).toEqual(`i18n translations checker
+Source: en
+Selected format is: next-intl
+
+No missing keys found!
+
+No invalid translations found!
+
+Found unused keys!
+┌───────────────────────────────────────────────────────────────────┬──────────────────┐
+│ file                                                              │ key              │
+├───────────────────────────────────────────────────────────────────┼──────────────────┤
+│  translations/codeExamples/next-intl/locales/en/translation.json  │  message.plural  │
+│  translations/codeExamples/next-intl/locales/en/translation.json  │  notUsedKey      │
+└───────────────────────────────────────────────────────────────────┴──────────────────┘
+
+Found undefined keys!
+┌─────────────────────────────────────────────────────┬──────────────────┐
+│ file                                                │ key              │
+├─────────────────────────────────────────────────────┼──────────────────┤
+│  translations/codeExamples/next-intl/src/Basic.tsx  │  message.select  │
+└─────────────────────────────────────────────────────┴──────────────────┘
+
 `);
                 done();
             });

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { CheckResult, Translation, TranslationFile } from "./types";
 import { Context } from "./errorReporters";
 export type Options = {
-    format?: "icu" | "i18next" | "react-intl" | "react-i18next";
+    format?: "icu" | "i18next" | "react-intl" | "next-intl";
     checks?: Context[];
 };
 export declare const checkInvalidTranslations: (source: Translation, targets: Record<string, Translation>, options?: Options) => CheckResult;
@@ -10,4 +10,5 @@ export declare const checkTranslations: (source: TranslationFile[], targets: Tra
     missingKeys: CheckResult | undefined;
     invalidKeys: CheckResult | undefined;
 };
-export declare const checkUnusedKeys: (source: TranslationFile[], codebaseSrc: string, options?: Options, componentFunctions?: never[]) => Promise<CheckResult | 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>;

package/dist/index.js

@@ -1,24 +1,16 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkUnusedKeys = exports.checkTranslations = exports.checkMissingTranslations = exports.checkInvalidTranslations = void 0;
+exports.checkUndefinedKeys = exports.checkUnusedKeys = exports.checkTranslations = exports.checkMissingTranslations = exports.checkInvalidTranslations = void 0;
 const findMissingKeys_1 = require("./utils/findMissingKeys");
 const findInvalidTranslations_1 = require("./utils/findInvalidTranslations");
 const findInvalidi18nTranslations_1 = require("./utils/findInvalidi18nTranslations");
-const glob_1 = require("glob");
 const cli_lib_1 = require("@formatjs/cli-lib");
+const nextIntlSrcParser_1 = require("./utils/nextIntlSrcParser");
 const fs_1 = __importDefault(require("fs"));
+const ParseFormats = ["react-intl", "i18next", "next-intl"];
 const checkInvalidTranslations = (source, targets, options = { format: "icu" }) => {
     return options.format === "i18next"
         ? (0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(source, targets)
@@ -54,29 +46,53 @@ const checkTranslations = (source, targets, options = { format: "icu", checks: [
     };
 };
 exports.checkTranslations = checkTranslations;
-const checkUnusedKeys = (source_1, codebaseSrc_1, ...args_1) => __awaiter(void 0, [source_1, codebaseSrc_1, ...args_1], void 0, function* (source, codebaseSrc, options = {
+const checkUnusedKeys = async (translationFiles, filesToParse, options = {
     format: "react-intl",
-}, componentFunctions = []) {
-    if (!options.format || !["react-intl", "i18next"].includes(options.format)) {
+}, componentFunctions = []) => {
+    if (!options.format || !ParseFormats.includes(options.format)) {
         return undefined;
     }
-    return options.format === "react-intl"
-        ? findUnusedReactIntlTranslations(source, codebaseSrc)
-        : findUnusedI18NextTranslations(source, codebaseSrc, componentFunctions);
-});
+    if (options.format === "react-intl") {
+        return findUnusedReactIntlTranslations(translationFiles, filesToParse);
+    }
+    else if (options.format === "i18next") {
+        return findUnusedI18NextTranslations(translationFiles, filesToParse, componentFunctions);
+    }
+    else if (options.format === "next-intl") {
+        return findUnusedNextIntlTranslations(translationFiles, filesToParse);
+    }
+};
 exports.checkUnusedKeys = checkUnusedKeys;
-const findUnusedReactIntlTranslations = (source, codebaseSrc) => __awaiter(void 0, void 0, void 0, function* () {
+const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) => {
     let unusedKeys = {};
-    // find any unused keys in a react-intl code base
-    const unusedKeysFiles = (0, glob_1.globSync)(codebaseSrc, {
-        ignore: ["node_modules/**"],
-    });
-    const extracted = yield (0, cli_lib_1.extract)(unusedKeysFiles, {});
+    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);
+            }
+        }
+        Object.assign(unusedKeys, { [name]: found });
+    });
+    return unusedKeys;
+};
+const findUnusedI18NextTranslations = async (source, filesToParse, componentFunctions = []) => {
+    let unusedKeys = {};
+    const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
+    const extractedResultSet = new Set(extractedResult.map(({ key }) => key));
     source.forEach(({ name, content }) => {
         const keysInSource = Object.keys(content);
         const found = [];
         for (const keyInSource of keysInSource) {
+            const isSkippable = skippableKeys.find((skippableKey) => {
+                return keyInSource.includes(skippableKey);
+            });
+            if (isSkippable !== undefined) {
+                continue;
+            }
             if (!extractedResultSet.has(keyInSource)) {
                 found.push(keyInSource);
             }
@@ -84,16 +100,106 @@ const findUnusedReactIntlTranslations = (source, codebaseSrc) => __awaiter(void
         Object.assign(unusedKeys, { [name]: found });
     });
     return unusedKeys;
-});
-const findUnusedI18NextTranslations = (source_1, codebaseSrc_1, ...args_1) => __awaiter(void 0, [source_1, codebaseSrc_1, ...args_1], void 0, function* (source, codebaseSrc, componentFunctions = []) {
+};
+const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) => {
     let unusedKeys = {};
-    // find any unused keys in a react-i18next code base
-    const unusedKeysFiles = (0, glob_1.globSync)(`${codebaseSrc}/**/*.{ts,tsx}`, {
-        ignore: ["node_modules/**"],
+    const extracted = (0, nextIntlSrcParser_1.extract)(filesToParse);
+    const extractedResultSet = new Set(extracted.map(({ key }) => key));
+    translationFiles.forEach(({ name, content }) => {
+        const keysInSource = Object.keys(content);
+        const found = [];
+        for (const keyInSource of keysInSource) {
+            if (!extractedResultSet.has(keyInSource)) {
+                found.push(keyInSource);
+            }
+        }
+        Object.assign(unusedKeys, { [name]: found });
     });
-    let extractedResult = [];
+    return unusedKeys;
+};
+const checkUndefinedKeys = async (source, filesToParse, options = {
+    format: "react-intl",
+}, componentFunctions = []) => {
+    if (!options.format || !ParseFormats.includes(options.format)) {
+        return undefined;
+    }
+    if (options.format === "react-intl") {
+        return findUndefinedReactIntlKeys(source, filesToParse);
+    }
+    else if (options.format === "i18next") {
+        return findUndefinedI18NextKeys(source, filesToParse, componentFunctions);
+    }
+    else if (options.format === "next-intl") {
+        return findUndefinedNextIntlKeys(source, filesToParse);
+    }
+};
+exports.checkUndefinedKeys = checkUndefinedKeys;
+const findUndefinedReactIntlKeys = async (translationFiles, filesToParse) => {
+    const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
+        return Object.keys(content);
+    }));
+    const extractedResult = await (0, cli_lib_1.extract)(filesToParse, {
+        extractSourceLocation: true,
+    });
+    let undefinedKeys = {};
+    Object.entries(JSON.parse(extractedResult)).forEach(([key, meta]) => {
+        if (!sourceKeys.has(key)) {
+            // @ts-ignore
+            const file = meta.file;
+            if (!undefinedKeys[file]) {
+                undefinedKeys[file] = [];
+            }
+            undefinedKeys[file].push(key);
+        }
+    });
+    return undefinedKeys;
+};
+const findUndefinedI18NextKeys = async (source, filesToParse, componentFunctions = []) => {
+    const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
+    const sourceKeys = new Set(source.flatMap(({ content }) => {
+        return Object.keys(content);
+    }));
+    let undefinedKeys = {};
+    extractedResult.forEach(({ file, key }) => {
+        const isSkippable = skippableKeys.find((skippableKey) => {
+            return key.includes(skippableKey);
+        });
+        if (isSkippable === undefined && !sourceKeys.has(key)) {
+            if (!undefinedKeys[file]) {
+                undefinedKeys[file] = [];
+            }
+            undefinedKeys[file].push(key);
+        }
+    });
+    return undefinedKeys;
+};
+const findUndefinedNextIntlKeys = async (translationFiles, filesToParse) => {
+    const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
+        return Object.keys(content);
+    }));
+    const extractedResult = (0, nextIntlSrcParser_1.extract)(filesToParse);
+    let undefinedKeys = {};
+    extractedResult.forEach(({ key, meta }) => {
+        if (!sourceKeys.has(key)) {
+            // @ts-ignore
+            const file = meta.file;
+            if (!undefinedKeys[file]) {
+                undefinedKeys[file] = [];
+            }
+            undefinedKeys[file].push(key);
+        }
+    });
+    return undefinedKeys;
+};
+const isRecord = (data) => {
+    return (typeof data === "object" &&
+        !Array.isArray(data) &&
+        data !== null &&
+        data !== undefined);
+};
+const getI18NextKeysInCode = async (filesToParse, componentFunctions = []) => {
     // @ts-ignore
-    const { transform } = yield import("i18next-parser");
+    const { transform } = await import("i18next-parser");
     const i18nextParser = new transform({
         lexers: {
             jsx: [
@@ -113,8 +219,9 @@ const findUnusedI18NextTranslations = (source_1, codebaseSrc_1, ...args_1) => __
     // 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 skippableKeys = [];
-    unusedKeysFiles.forEach((file) => {
+    filesToParse.forEach((file) => {
         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.
@@ -126,34 +233,11 @@ const findUnusedI18NextTranslations = (source_1, codebaseSrc_1, ...args_1) => __
                 skippableKeys.push(entry.key);
             }
             else {
-                extractedResult.push(entry.key);
+                extractedResult.push({ file, key: entry.key });
             }
         }
     });
-    const extractedResultSet = new Set(extractedResult);
-    source.forEach(({ name, content }) => {
-        const keysInSource = Object.keys(content);
-        const found = [];
-        for (const keyInSource of keysInSource) {
-            const isSkippable = skippableKeys.find((skippableKey) => {
-                return keyInSource.includes(skippableKey);
-            });
-            if (isSkippable !== undefined) {
-                continue;
-            }
-            if (!extractedResultSet.has(keyInSource)) {
-                found.push(keyInSource);
-            }
-        }
-        Object.assign(unusedKeys, { [name]: found });
-    });
-    return unusedKeys;
-});
-const isRecord = (data) => {
-    return (typeof data === "object" &&
-        !Array.isArray(data) &&
-        data !== null &&
-        data !== undefined);
+    return { extractedResult, skippableKeys };
 };
 function flatten(object, prefix = null, result = {}) {
     for (let key in object) {

package/dist/utils/findInvalidTranslations.test.js

@@ -9,7 +9,10 @@ describe("findInvalidTranslations:compareTranslationFiles", () => {
         expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(sourceFile), (0, flattenTranslations_1.flattenTranslations)(sourceFile))).toEqual([]);
     });
     it("should return the invalid keys in the target file", () => {
-        expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" })), (0, flattenTranslations_1.flattenTranslations)(secondaryFile))).toEqual(["multipleVariables"]);
+        expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
+            ...sourceFile,
+            "ten.eleven.twelve": "ten eleven twelve",
+        }), (0, flattenTranslations_1.flattenTranslations)(secondaryFile))).toEqual(["multipleVariables"]);
     });
     it("should return empty array if placeholders are identical but in different positions", () => {
         expect((0, findInvalidTranslations_1.compareTranslationFiles)({
@@ -24,10 +27,10 @@ describe("findInvalidTranslations", () => {
         expect((0, findInvalidTranslations_1.findInvalidTranslations)(sourceFile, { de: sourceFile })).toEqual({});
     });
     it("should return an object containing the keys for the missing language", () => {
-        expect((0, findInvalidTranslations_1.findInvalidTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), { de: secondaryFile })).toEqual({ de: ["multipleVariables"] });
+        expect((0, findInvalidTranslations_1.findInvalidTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: secondaryFile })).toEqual({ de: ["multipleVariables"] });
     });
     it("should return an object containing the keys for every language with missing key", () => {
-        expect((0, findInvalidTranslations_1.findInvalidTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), {
+        expect((0, findInvalidTranslations_1.findInvalidTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
             de: secondaryFile,
             fr: {
                 "four.five.six": "four five six",
@@ -41,14 +44,20 @@ describe("findInvalidTranslations", () => {
     });
     it("should allow for different types of keys per locale", () => {
         expect((0, findInvalidTranslations_1.findInvalidTranslations)(sourceFile, {
-            de: Object.assign(Object.assign({}, secondaryFile), { "message.plural": "{count, plural, other {# of {total} items}}" })
+            de: {
+                ...secondaryFile,
+                "message.plural": "{count, plural, other {# of {total} items}}",
+            }
         })).toEqual({
             de: ["multipleVariables"]
         });
     });
     it("should fail if a variable is changed in one of the translations", () => {
         expect((0, findInvalidTranslations_1.findInvalidTranslations)(sourceFile, {
-            de: Object.assign(Object.assign({}, secondaryFile), { "message.plural": "{count, plural, other {# of {cargado} items}}" })
+            de: {
+                ...secondaryFile,
+                "message.plural": "{count, plural, other {# of {cargado} items}}",
+            }
         })).toEqual({
             de: ["message.plural", "multipleVariables"]
         });

package/dist/utils/findInvalidi18nTranslations.test.js

@@ -9,7 +9,10 @@ describe("findInvalid18nTranslations:compareTranslationFiles", () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(sourceFile), (0, flattenTranslations_1.flattenTranslations)(sourceFile))).toEqual([]);
     });
     it("should return the invalid keys in the target file", () => {
-        expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" })), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual(["key_with_broken_de", "intlNumber_broken_de"]);
+        expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
+            ...sourceFile,
+            "ten.eleven.twelve": "ten eleven twelve",
+        }), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual(["key_with_broken_de", "intlNumber_broken_de"]);
     });
     it("should return an empty array if the strings contain paranthesis that have different content", () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
@@ -43,10 +46,10 @@ describe("findInvalidTranslations", () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(sourceFile, { de: sourceFile })).toEqual({});
     });
     it("should return an object containing the keys for the missing language", () => {
-        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), { de: targetFile })).toEqual({ de: ["key_with_broken_de", "intlNumber_broken_de"] });
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: targetFile })).toEqual({ de: ["key_with_broken_de", "intlNumber_broken_de"] });
     });
     it("should return an object containing the keys for every language with missing key", () => {
-        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), {
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
             de: targetFile,
             fr: {
                 key_with_broken_de: "Some format {{value, formatname}} and some other format {{value, formatname}}",
@@ -122,4 +125,13 @@ describe("findInvalidTranslations", () => {
             de: ["tag"],
         });
     });
+    it("should recognize special characters", () => {
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
+            key: "Test < {{a}} and > {{max_a}}",
+        }, {
+            de: {
+                key: "Test < {{a}} und > {{max_a}}",
+            },
+        })).toEqual({});
+    });
 });

package/dist/utils/findMissingKeys.test.js

@@ -16,7 +16,7 @@ describe("findMissingKeys:compareTranslationFiles", () => {
         expect((0, findMissingKeys_1.compareTranslationFiles)(sourceFile, secondaryFile)).toEqual([]);
     });
     it("should return the missing keys in the secondary file", () => {
-        expect((0, findMissingKeys_1.compareTranslationFiles)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), secondaryFile)).toEqual(["ten.eleven.twelve"]);
+        expect((0, findMissingKeys_1.compareTranslationFiles)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, secondaryFile)).toEqual(["ten.eleven.twelve"]);
     });
 });
 describe("findMissingKeys", () => {
@@ -24,10 +24,10 @@ describe("findMissingKeys", () => {
         expect((0, findMissingKeys_1.findMissingKeys)(sourceFile, { de: secondaryFile })).toEqual({});
     });
     it("should return an object containing the keys for the missing language", () => {
-        expect((0, findMissingKeys_1.findMissingKeys)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), { de: secondaryFile })).toEqual({ de: ["ten.eleven.twelve"] });
+        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: secondaryFile })).toEqual({ de: ["ten.eleven.twelve"] });
     });
     it("should return an object containing the keys for every language with missing key", () => {
-        expect((0, findMissingKeys_1.findMissingKeys)(Object.assign(Object.assign({}, sourceFile), { "ten.eleven.twelve": "ten eleven twelve" }), {
+        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
             de: secondaryFile,
             fr: {
                 "four.five.six": "four five six",

package/dist/utils/i18NextParser.js

@@ -86,7 +86,7 @@ const parseInput = (input) => {
                     voidElement: match.substring(match.length - 2) === "/>",
                 });
             }
-            else if (match.indexOf(OPEN_TAG) === 0) {
+            else if (match.indexOf(OPEN_TAG) === 0 && /<[^\s]+/.test(match)) {
                 acc.push({
                     type: "tag",
                     raw: match,

package/dist/utils/nextIntlSrcParser.d.ts

@@ -0,0 +1,6 @@
+export declare const extract: (filesPaths: string[]) => {
+    key: string;
+    meta: {
+        file: string;
+    };
+}[];

package/dist/utils/nextIntlSrcParser.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const ts = __importStar(require("typescript"));
+const USE_TRANSLATIONS = "useTranslations";
+const GET_TRANSLATIONS = "getTranslations";
+const COMMENT_CONTAINS_STATIC_KEY_REGEX = /t\((["'])(.*?[^\\])(["'])\)/;
+const extract = (filesPaths) => {
+    return filesPaths.flatMap(getKeys).sort((a, b) => {
+        return a > b ? 1 : -1;
+    });
+};
+exports.extract = extract;
+const getKeys = (path) => {
+    const content = node_fs_1.default.readFileSync(path, "utf-8");
+    const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
+    const foundKeys = [];
+    let namespaces = [];
+    let variable = "t";
+    const getCurrentNamespace = () => {
+        if (namespaces.length > 0) {
+            return namespaces[namespaces.length - 1];
+        }
+        return null;
+    };
+    const pushNamespace = (name) => {
+        namespaces.push(name);
+    };
+    const removeNamespace = () => {
+        if (namespaces.length > 0) {
+            namespaces.pop();
+        }
+    };
+    const visit = (node) => {
+        let key = null;
+        let current = namespaces.length;
+        if (node === undefined) {
+            return;
+        }
+        if (ts.isVariableDeclaration(node)) {
+            if (node.initializer && ts.isCallExpression(node.initializer)) {
+                if (ts.isIdentifier(node.initializer.expression)) {
+                    // Search for `useTranslations` calls and extract the namespace
+                    // Additionally check for assigned variable name, as it might differ
+                    // from the default `t`, i.e.: const other = useTranslations("namespace1");
+                    if (node.initializer.expression.text === USE_TRANSLATIONS) {
+                        const [argument] = node.initializer.arguments;
+                        if (argument && ts.isStringLiteral(argument)) {
+                            pushNamespace(argument.text);
+                        }
+                        else if (argument === undefined) {
+                            pushNamespace("");
+                        }
+                        if (ts.isIdentifier(node.name)) {
+                            variable = node.name.text;
+                        }
+                    }
+                }
+            }
+            // Search for `getTranslations` calls and extract the namespace
+            // There are two different ways `getTranslations` can be used:
+            //
+            // import {getTranslations} from 'next-intl/server';
+            // const t = await getTranslations(namespace?);
+            // const t = await getTranslations({locale, namespace});
+            //
+            // Additionally check for assigned variable name, as it might differ
+            // from the default `t`, i.e.: const other = getTranslations("namespace1");
+            // Simplified usage in async components
+            if (node.initializer && ts.isAwaitExpression(node.initializer)) {
+                if (ts.isCallExpression(node.initializer.expression) &&
+                    ts.isIdentifier(node.initializer.expression.expression)) {
+                    if (node.initializer.expression.expression.text === GET_TRANSLATIONS) {
+                        const [argument] = node.initializer.expression.arguments;
+                        if (argument && ts.isObjectLiteralExpression(argument)) {
+                            argument.properties.forEach((property) => {
+                                if (property &&
+                                    ts.isPropertyAssignment(property) &&
+                                    property.name &&
+                                    ts.isIdentifier(property.name) &&
+                                    property.name.text === "namespace" &&
+                                    ts.isStringLiteral(property.initializer)) {
+                                    pushNamespace(property.initializer.text);
+                                }
+                            });
+                        }
+                        else if (argument && ts.isStringLiteral(argument)) {
+                            pushNamespace(argument.text);
+                        }
+                        else if (argument === undefined) {
+                            pushNamespace("");
+                        }
+                        if (ts.isIdentifier(node.name)) {
+                            variable = node.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // Search for `t()` calls
+        if (getCurrentNamespace() !== null &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression)) {
+            const expressionName = node.expression.text;
+            if (expressionName === variable) {
+                const [argument] = node.arguments;
+                if (argument && ts.isStringLiteral(argument)) {
+                    key = argument.text;
+                }
+            }
+        }
+        // Search for `t.*()` calls, i.e. t.html() or t.rich()
+        if (getCurrentNamespace() !== null &&
+            ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            ts.isIdentifier(node.expression.expression)) {
+            const expressionName = node.expression.expression.text;
+            if (expressionName === variable) {
+                const [argument] = node.arguments;
+                if (argument && ts.isStringLiteral(argument)) {
+                    key = argument.text;
+                }
+            }
+        }
+        if (key) {
+            const namespace = getCurrentNamespace();
+            foundKeys.push({
+                key: namespace ? `${namespace}.${key}` : key,
+                meta: { file: path },
+            });
+        }
+        // Search for single-line comments that contain the static values of a dynamic key
+        // Example:
+        // const someKeys = messages[selectedOption];
+        // Define as a single-line comment all the possible static keys for that dynamic key
+        // t('some.static.key.we.want.to.extract');
+        // t('some.other.key.we.want.to.extract.without.semicolons')
+        const commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
+        if (commentRanges?.length && commentRanges.length > 0) {
+            commentRanges.forEach((range) => {
+                const comment = sourceFile.getFullText().slice(range.pos, range.end);
+                // parse the string and check if it includes the following format:
+                // t('someString')
+                const hasStaticKeyComment = COMMENT_CONTAINS_STATIC_KEY_REGEX.test(comment);
+                if (hasStaticKeyComment) {
+                    // capture the string comment
+                    const commentKey = COMMENT_CONTAINS_STATIC_KEY_REGEX.exec(comment)?.[2];
+                    if (commentKey) {
+                        const namespace = getCurrentNamespace();
+                        foundKeys.push({
+                            key: namespace ? `${namespace}.${commentKey}` : commentKey,
+                            meta: { file: path },
+                        });
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, visit);
+        if (ts.isFunctionLike(node) && namespaces.length > current) {
+            removeNamespace();
+        }
+    };
+    ts.forEachChild(sourceFile, visit);
+    return foundKeys;
+};

package/dist/utils/nextIntlSrcParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/nextIntlSrcParser.test.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nextIntlSrcParser_1 = require("./nextIntlSrcParser");
+const node_path_1 = __importDefault(require("node:path"));
+const srcPath = "./translations/codeExamples/next-intl/src/";
+const basicFile = node_path_1.default.join(srcPath, "Basic.tsx");
+const counterFile = node_path_1.default.join(srcPath, "Counter.tsx");
+const clientCounterFile = node_path_1.default.join(srcPath, "ClientCounter.tsx");
+const nestedExampleFile = node_path_1.default.join(srcPath, "NestedExample.tsx");
+const asyncExampleFile = node_path_1.default.join(srcPath, "AsyncExample.tsx");
+const dynamicKeysExamplFile = node_path_1.default.join(srcPath, "DynamicKeysExample.tsx");
+describe("nextIntlSrcParser", () => {
+    it("should find all the translation keys", () => {
+        const keys = (0, nextIntlSrcParser_1.extract)([basicFile, counterFile, clientCounterFile]);
+        expect(keys).toEqual([
+            {
+                key: "ClientCounter2.increment",
+                meta: {
+                    file: clientCounterFile,
+                },
+            },
+            {
+                key: "ClientCounter2.count",
+                meta: {
+                    file: clientCounterFile,
+                },
+            },
+            {
+                key: "ClientCounter.increment",
+                meta: {
+                    file: clientCounterFile,
+                },
+            },
+            {
+                key: "ClientCounter.count",
+                meta: {
+                    file: clientCounterFile,
+                },
+            },
+            {
+                key: "Counter.increment",
+                meta: {
+                    file: counterFile,
+                },
+            },
+            {
+                key: "Counter.count",
+                meta: {
+                    file: counterFile,
+                },
+            },
+            {
+                key: "testKeyWithoutNamespace",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "message.argument",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "message.select",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "message.simple",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "Navigation.news",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "Navigation.nested",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "Navigation.about",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "Navigation.client",
+                meta: {
+                    file: basicFile,
+                },
+            },
+            {
+                key: "Navigation.home",
+                meta: {
+                    file: basicFile,
+                },
+            },
+        ]);
+    });
+    it("should find all the nested translation keys", () => {
+        const keys = (0, nextIntlSrcParser_1.extract)([nestedExampleFile]);
+        expect(keys).toEqual([
+            {
+                key: "nested.three.htmlKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.three.markupKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.three.richTextKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.three.hasKeyCheck",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.three.basicKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "deepNested.level1.one",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "deepNested.level2.two",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "deepNested.level3.three",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "deepNested.level4.four",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.two.regularKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.two.nestedKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.nested.two.nestedTwoKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.one.regularKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+            {
+                key: "nested.one.nestedKey",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/NestedExample.tsx",
+                },
+            },
+        ]);
+    });
+    it("should find all the async translation keys", () => {
+        const keys = (0, nextIntlSrcParser_1.extract)([asyncExampleFile]);
+        expect(keys).toEqual([
+            {
+                key: "async.two.title",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/AsyncExample.tsx",
+                },
+            },
+            {
+                key: "Async.title",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/AsyncExample.tsx",
+                },
+            },
+        ]);
+    });
+    it("should find all dynamic keys defined as comments", () => {
+        const keys = (0, nextIntlSrcParser_1.extract)([dynamicKeysExamplFile]);
+        expect(keys).toEqual([
+            {
+                key: "dynamic.three.value",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.three.title",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.two.value",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.two.title",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.one.value",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.one.title",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.four",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.three",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.two",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.one",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.nameFour",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.nameThree",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.nameTwo",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+            {
+                key: "dynamic.four.nameOne",
+                meta: {
+                    file: "translations/codeExamples/next-intl/src/DynamicKeysExample.tsx",
+                },
+            },
+        ]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.5.5",
+  "version": "0.7.0",
   "description": "i18n translation messages check",
   "license": "MIT",
   "main": "dist/index.js",
@@ -24,7 +24,8 @@
     "commander": "^12.1.0",
     "glob": "^11.0.1",
     "i18next-parser": "^9.3.0",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "typescript": "^5.8.3"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -33,8 +34,7 @@
     "@types/vinyl": "^2.0.12",
     "braces": "^3.0.3",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.6",
-    "typescript": "^5.7.3"
+    "ts-jest": "^29.2.6"
   },
   "repository": {
     "type": "git",