@lingual/i18n-check 0.6.0 → 0.7.0

package/README.md

@@ -138,11 +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. Additionally an inverse check is run to find any keys that exist in the codebase but not in the translation files.
+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.
 
 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` or `i18next` as value. See the [`format` section](#--format) for more information.
+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
@@ -154,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,7 +18,7 @@ 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")
@@ -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,
@@ -168,9 +158,9 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
             const filesToParse = (0, glob_1.globSync)(`${unusedSrcPath}/**/*.{ts,tsx}`, {
                 ignore: ["node_modules/**"],
             });
-            const unusedKeys = yield (0, __1.checkUnusedKeys)(srcFiles, filesToParse, options, componentFunctions);
+            const unusedKeys = await (0, __1.checkUnusedKeys)(srcFiles, filesToParse, options, componentFunctions);
             printUnusedKeysResult({ unusedKeys });
-            const undefinedKeys = yield (0, __1.checkUndefinedKeys)(srcFiles, filesToParse, options, componentFunctions);
+            const undefinedKeys = await (0, __1.checkUndefinedKeys)(srcFiles, filesToParse, options, componentFunctions);
             printUndefinedKeysResult({
                 undefinedKeys,
             });
@@ -189,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";

package/dist/bin/index.test.js

@@ -295,7 +295,7 @@ Found undefined keys!
             });
         });
         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) => {
+            (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
@@ -320,6 +320,36 @@ Found undefined keys!
 │  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;

package/dist/index.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -17,7 +8,9 @@ const findMissingKeys_1 = require("./utils/findMissingKeys");
 const findInvalidTranslations_1 = require("./utils/findInvalidTranslations");
 const findInvalidi18nTranslations_1 = require("./utils/findInvalidi18nTranslations");
 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)
@@ -53,20 +46,26 @@ const checkTranslations = (source, targets, options = { format: "icu", checks: [
     };
 };
 exports.checkTranslations = checkTranslations;
-const checkUnusedKeys = (translationFiles_1, filesToParse_1, ...args_1) => __awaiter(void 0, [translationFiles_1, filesToParse_1, ...args_1], void 0, function* (translationFiles, filesToParse, 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(translationFiles, filesToParse)
-        : findUnusedI18NextTranslations(translationFiles, filesToParse, 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 = (translationFiles, keysInCode) => __awaiter(void 0, void 0, void 0, function* () {
+const findUnusedReactIntlTranslations = async (translationFiles, filesToParse) => {
     let unusedKeys = {};
-    const extracted = yield (0, cli_lib_1.extract)(keysInCode, {});
+    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);
@@ -79,10 +78,10 @@ const findUnusedReactIntlTranslations = (translationFiles, keysInCode) => __awai
         Object.assign(unusedKeys, { [name]: found });
     });
     return unusedKeys;
-});
-const findUnusedI18NextTranslations = (source_1, filesToParse_1, ...args_1) => __awaiter(void 0, [source_1, filesToParse_1, ...args_1], void 0, function* (source, filesToParse, componentFunctions = []) {
+};
+const findUnusedI18NextTranslations = async (source, filesToParse, componentFunctions = []) => {
     let unusedKeys = {};
-    const { extractedResult, skippableKeys } = yield getI18NextKeysInCode(filesToParse, componentFunctions);
+    const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
     const extractedResultSet = new Set(extractedResult.map(({ key }) => key));
     source.forEach(({ name, content }) => {
         const keysInSource = Object.keys(content);
@@ -101,23 +100,45 @@ const findUnusedI18NextTranslations = (source_1, filesToParse_1, ...args_1) => _
         Object.assign(unusedKeys, { [name]: found });
     });
     return unusedKeys;
-});
-const checkUndefinedKeys = (source_1, filesToParse_1, ...args_1) => __awaiter(void 0, [source_1, filesToParse_1, ...args_1], void 0, function* (source, filesToParse, options = {
+};
+const findUnusedNextIntlTranslations = async (translationFiles, filesToParse) => {
+    let unusedKeys = {};
+    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 });
+    });
+    return unusedKeys;
+};
+const checkUndefinedKeys = async (source, 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"
-        ? findUndefinedReactIntlKeys(source, filesToParse)
-        : findUndefinedI18NextKeys(source, filesToParse, componentFunctions);
-});
+    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 = (translationFiles, keysInCode) => __awaiter(void 0, void 0, void 0, function* () {
+const findUndefinedReactIntlKeys = async (translationFiles, filesToParse) => {
     const sourceKeys = new Set(translationFiles.flatMap(({ content }) => {
         return Object.keys(content);
     }));
-    const extractedResult = yield (0, cli_lib_1.extract)(keysInCode, {
+    const extractedResult = await (0, cli_lib_1.extract)(filesToParse, {
         extractSourceLocation: true,
     });
     let undefinedKeys = {};
@@ -132,9 +153,9 @@ const findUndefinedReactIntlKeys = (translationFiles, keysInCode) => __awaiter(v
         }
     });
     return undefinedKeys;
-});
-const findUndefinedI18NextKeys = (source_1, filesToParse_1, ...args_1) => __awaiter(void 0, [source_1, filesToParse_1, ...args_1], void 0, function* (source, filesToParse, componentFunctions = []) {
-    const { extractedResult, skippableKeys } = yield getI18NextKeysInCode(filesToParse, componentFunctions);
+};
+const findUndefinedI18NextKeys = async (source, filesToParse, componentFunctions = []) => {
+    const { extractedResult, skippableKeys } = await getI18NextKeysInCode(filesToParse, componentFunctions);
     const sourceKeys = new Set(source.flatMap(({ content }) => {
         return Object.keys(content);
     }));
@@ -151,16 +172,34 @@ const findUndefinedI18NextKeys = (source_1, filesToParse_1, ...args_1) => __awai
         }
     });
     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 = (filesToParse_1, ...args_1) => __awaiter(void 0, [filesToParse_1, ...args_1], void 0, function* (filesToParse, componentFunctions = []) {
+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: [
@@ -199,7 +238,7 @@ const getI18NextKeysInCode = (filesToParse_1, ...args_1) => __awaiter(void 0, [f
         }
     });
     return { extractedResult, skippableKeys };
-});
+};
 function flatten(object, prefix = null, result = {}) {
     for (let key in object) {
         let propName = prefix ? `${prefix}.${key}` : key;

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.6.0",
+  "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",