@lingual/i18n-check 0.7.4 → 0.8.0

package/dist/utils/findInvalidTranslations.js

@@ -29,9 +29,14 @@ const sortParsedKeys = (a, b) => {
 const compareTranslationFiles = (a, b) => {
     let diffs = [];
     for (const key in a) {
-        if (b[key] !== undefined &&
-            (0, exports.hasDiff)((0, icu_messageformat_parser_1.parse)(String(a[key])), (0, icu_messageformat_parser_1.parse)(String(b[key])))) {
-            diffs.push(key);
+        if (b[key] === undefined) {
+            continue;
+        }
+        const parsedTranslationA = (0, icu_messageformat_parser_1.parse)(String(a[key]));
+        const parsedTranslationB = (0, icu_messageformat_parser_1.parse)(String(b[key]));
+        if ((0, exports.hasDiff)(parsedTranslationA, parsedTranslationB)) {
+            const msg = getErrorMessage(parsedTranslationA, parsedTranslationB);
+            diffs.push({ key, msg });
         }
     }
     return diffs;
@@ -64,7 +69,7 @@ const hasDiff = (a, b) => {
         if ((0, icu_messageformat_parser_1.isTagElement)(formatElementA) && (0, icu_messageformat_parser_1.isTagElement)(formatElementB)) {
             return (0, exports.hasDiff)(formatElementA.children, formatElementB.children);
         }
-        if (((0, icu_messageformat_parser_1.isSelectElement)(formatElementA) && (0, icu_messageformat_parser_1.isSelectElement)(formatElementB))) {
+        if ((0, icu_messageformat_parser_1.isSelectElement)(formatElementA) && (0, icu_messageformat_parser_1.isSelectElement)(formatElementB)) {
             const optionsA = Object.keys(formatElementA.options).sort();
             const optionsB = Object.keys(formatElementB.options).sort();
             if (optionsA.join("-") !== optionsB.join("-")) {
@@ -92,3 +97,88 @@ const hasDiff = (a, b) => {
     return hasErrors;
 };
 exports.hasDiff = hasDiff;
+const getErrorMessage = (a, b) => {
+    const compA = a
+        .filter((element) => !(0, icu_messageformat_parser_1.isLiteralElement)(element))
+        .sort(sortParsedKeys);
+    const compB = b
+        .filter((element) => !(0, icu_messageformat_parser_1.isLiteralElement)(element))
+        .sort(sortParsedKeys);
+    const errors = compA.reduce((acc, formatElementA, index) => {
+        const formatElementB = compB[index];
+        if (!formatElementB) {
+            acc.push(`Missing element ${typeLookup[formatElementA.type]}`);
+            return acc;
+        }
+        if (formatElementA.type !== formatElementB.type) {
+            acc.push(`Expected element of type "${typeLookup[formatElementA.type]}" but received "${typeLookup[formatElementB.type]}"`);
+            return acc;
+        }
+        if (formatElementA.location !== formatElementB.location) {
+            acc.push(`Expected location to be ${formatElementA.location?.start?.line}:${formatElementA.location?.start?.column}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isPoundElement)(formatElementA) && (0, icu_messageformat_parser_1.isPoundElement)(formatElementB)) {
+            return acc;
+        }
+        if (!(0, icu_messageformat_parser_1.isPoundElement)(formatElementA) &&
+            !(0, icu_messageformat_parser_1.isPoundElement)(formatElementB) &&
+            formatElementA.value !== formatElementB.value) {
+            acc.push(`Expected ${typeLookup[formatElementA.type]} to contain "${formatElementA.value}" but received "${formatElementB.value}"`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isTagElement)(formatElementA) && (0, icu_messageformat_parser_1.isTagElement)(formatElementB)) {
+            acc.push(`Error in pound element: ${getErrorMessage(formatElementA.children, formatElementB.children)}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isSelectElement)(formatElementA) && (0, icu_messageformat_parser_1.isSelectElement)(formatElementB)) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            let elementErrors = [];
+            optionsA.forEach((key) => {
+                if (formatElementB.options[key]) {
+                    elementErrors.push(getErrorMessage(formatElementA.options[key].value, formatElementB.options[key].value));
+                }
+            });
+            acc.push(`Error in select: ${elementErrors
+                .flatMap((elementError) => elementError)
+                .join(", ")}`);
+            return acc;
+        }
+        if ((0, icu_messageformat_parser_1.isPluralElement)(formatElementA) && (0, icu_messageformat_parser_1.isPluralElement)(formatElementB)) {
+            const optionsA = Object.keys(formatElementA.options).sort();
+            let elementErrors = [];
+            optionsA.forEach((key) => {
+                if (formatElementB.options[key]) {
+                    elementErrors.push(getErrorMessage(formatElementA.options[key].value, formatElementB.options[key].value));
+                }
+            });
+            acc.push(`Error in plural: ${elementErrors
+                .flatMap((elementError) => elementError)
+                .join(", ")}`);
+            return acc;
+        }
+        return acc;
+    }, []);
+    if (compA.length < compB.length) {
+        const unexpectedElements = compB
+            .slice(compA.length)
+            .reduce((acc, formatElementB) => {
+            acc.push(`Unexpected ${typeLookup[formatElementB.type]} element`);
+            return acc;
+        }, [])
+            .join(", ");
+        return [...errors, unexpectedElements].join(", ");
+    }
+    return errors.join(", ");
+};
+const typeLookup = {
+    0: "literal",
+    1: "argument",
+    2: "number",
+    3: "date",
+    4: "time",
+    5: "select",
+    6: "plural",
+    7: "pound",
+    8: "tag",
+};

package/dist/utils/findInvalidTranslations.test.js

@@ -12,7 +12,7 @@ describe("findInvalidTranslations:compareTranslationFiles", () => {
         expect((0, findInvalidTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
             ...sourceFile,
             "ten.eleven.twelve": "ten eleven twelve",
-        }), (0, flattenTranslations_1.flattenTranslations)(secondaryFile))).toEqual(["multipleVariables"]);
+        }), (0, flattenTranslations_1.flattenTranslations)(secondaryFile))).toEqual([{ key: "multipleVariables", msg: "Unexpected date element" }]);
     });
     it("should return empty array if placeholders are identical but in different positions", () => {
         expect((0, findInvalidTranslations_1.compareTranslationFiles)({
@@ -27,7 +27,9 @@ 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)({ ...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: [{ key: "multipleVariables", msg: "Unexpected date element" }],
+        });
     });
     it("should return an object containing the keys for every language with missing key", () => {
         expect((0, findInvalidTranslations_1.findInvalidTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
@@ -38,8 +40,13 @@ describe("findInvalidTranslations", () => {
                 "message.text-format": "yo,<p><b>John</b></p>!",
             },
         })).toEqual({
-            de: ["multipleVariables"],
-            fr: ["message.text-format"],
+            de: [{ key: "multipleVariables", msg: "Unexpected date element" }],
+            fr: [
+                {
+                    key: "message.text-format",
+                    msg: 'Expected tag to contain "b" but received "p"',
+                },
+            ],
         });
     });
     it("should allow for different types of keys per locale", () => {
@@ -47,9 +54,14 @@ describe("findInvalidTranslations", () => {
             de: {
                 ...secondaryFile,
                 "message.plural": "{count, plural, other {# of {total} items}}",
-            }
+            },
         })).toEqual({
-            de: ["multipleVariables"]
+            de: [
+                {
+                    key: "multipleVariables",
+                    msg: "Unexpected date element",
+                },
+            ],
         });
     });
     it("should fail if a variable is changed in one of the translations", () => {
@@ -57,9 +69,15 @@ describe("findInvalidTranslations", () => {
             de: {
                 ...secondaryFile,
                 "message.plural": "{count, plural, other {# of {cargado} items}}",
-            }
+            },
         })).toEqual({
-            de: ["message.plural", "multipleVariables"]
+            de: [
+                {
+                    key: "message.plural",
+                    msg: 'Error in plural: Expected argument to contain "total" but received "cargado"',
+                },
+                { key: "multipleVariables", msg: "Unexpected date element" },
+            ],
         });
     });
 });

package/dist/utils/findInvalidi18nTranslations.js

@@ -25,9 +25,14 @@ exports.findInvalid18nTranslations = findInvalid18nTranslations;
 const compareTranslationFiles = (a, b) => {
     let diffs = [];
     for (const key in a) {
-        if (b[key] !== undefined &&
-            (0, exports.hasDiff)((0, i18NextParser_1.parse)(String(a[key])), (0, i18NextParser_1.parse)(String(b[key])))) {
-            diffs.push(key);
+        if (b[key] === undefined) {
+            continue;
+        }
+        const parsedTranslationA = (0, i18NextParser_1.parse)(String(a[key]));
+        const parsedTranslationB = (0, i18NextParser_1.parse)(String(b[key]));
+        if ((0, exports.hasDiff)(parsedTranslationA, parsedTranslationB)) {
+            const msg = getErrorMessage(parsedTranslationA, parsedTranslationB);
+            diffs.push({ key, msg });
         }
     }
     return diffs;
@@ -103,3 +108,85 @@ const hasDiff = (a, b) => {
     return hasErrors;
 };
 exports.hasDiff = hasDiff;
+const getErrorMessage = (a, b) => {
+    const compA = a
+        .filter((element) => element.type !== "text")
+        .sort(sortParsedKeys);
+    const compB = b
+        .filter((element) => element.type !== "text")
+        .sort(sortParsedKeys);
+    const errors = compA.reduce((acc, formatElementA, index) => {
+        const formatElementB = compB[index];
+        if (!formatElementB) {
+            acc.push(`Missing element ${formatElementA.type}`);
+            return acc;
+        }
+        if (formatElementA.type !== formatElementB.type) {
+            acc.push(`Expected element of type "${formatElementA.type}" but received "${formatElementB.type}"`);
+            return acc;
+        }
+        if (formatElementA.type === "tag" && formatElementB.type === "tag") {
+            if (formatElementA.raw !== formatElementB.raw) {
+                acc.push(`Expected tag "${formatElementA.raw}" but received "${formatElementB.raw}"`);
+            }
+            else if (formatElementA.voidElement !== formatElementB.voidElement &&
+                formatElementA.voidElement === true) {
+                acc.push(`Expected a self-closing "${formatElementB.raw}" tag`);
+                return acc;
+            }
+            else if (formatElementA.voidElement !== formatElementB.voidElement &&
+                formatElementA.voidElement === false) {
+                acc.push(`Non expected self-closing "${formatElementB.raw}" tag`);
+                return acc;
+            }
+        }
+        if ((formatElementA.type === "interpolation" &&
+            formatElementB.type === "interpolation") ||
+            (formatElementA.type === "interpolation_unescaped" &&
+                formatElementB.type === "interpolation_unescaped") ||
+            (formatElementA.type === "nesting" &&
+                formatElementB.type === "nesting") ||
+            (formatElementA.type === "plural" && formatElementB.type === "plural")) {
+            if (formatElementA.prefix !== formatElementA.prefix) {
+                acc.push(`Error in ${formatElementA.type}: Expected prefix "${formatElementA.prefix}" but received "${formatElementB.prefix}"`);
+                return acc;
+            }
+            if (formatElementA.suffix !== formatElementA.suffix) {
+                acc.push(`Error in ${formatElementA.type}: Expected suffix "${formatElementA.suffix}" but received "${formatElementB.suffix}"`);
+                return acc;
+            }
+            const optionsA = formatElementA.variable
+                .split(",")
+                .map((value) => value.trim())
+                .sort();
+            const optionsB = formatElementB.variable
+                .split(",")
+                .map((value) => value.trim())
+                .sort();
+            let elementErrors = [];
+            optionsA.forEach((key, index) => {
+                if (key !== optionsB[index]) {
+                    elementErrors.push(`Expected ${key} but received ${optionsB[index]}`);
+                }
+            });
+            if (elementErrors.length > 0) {
+                acc.push(`Error in ${formatElementA.type}: ${elementErrors
+                    .flatMap((elementError) => elementError)
+                    .join(", ")}`);
+            }
+            return acc;
+        }
+        return acc;
+    }, []);
+    if (compA.length < compB.length) {
+        const unexpectedElements = compB
+            .slice(compA.length)
+            .reduce((acc, formatElementB) => {
+            acc.push(`Unexpected ${formatElementB.type} element`);
+            return acc;
+        }, [])
+            .join(", ");
+        return [...errors, unexpectedElements].join(", ");
+    }
+    return errors.join(", ");
+};

package/dist/utils/findInvalidi18nTranslations.test.js

@@ -12,7 +12,16 @@ describe("findInvalid18nTranslations:compareTranslationFiles", () => {
         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"]);
+        }), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual([
+            {
+                key: "key_with_broken_de",
+                msg: "Error in interpolation: Expected value but received val",
+            },
+            {
+                key: "intlNumber_broken_de",
+                msg: "Missing element interpolation",
+            },
+        ]);
     });
     it("should return an empty array if the strings contain paranthesis that have different content", () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
@@ -31,7 +40,12 @@ describe("findInvalid18nTranslations:compareTranslationFiles", () => {
             tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
         }, {
             tag: "There is some <b>bold text</b> and some other <span>italic</span> text.",
-        })).toEqual(["tag"]);
+        })).toEqual([
+            {
+                key: "tag",
+                msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
+            },
+        ]);
     });
     it("should return empty array if tags are identical", () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
@@ -46,7 +60,18 @@ 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)({ ...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: "key_with_broken_de",
+                    msg: "Error in interpolation: Expected value but received val",
+                },
+                {
+                    key: "intlNumber_broken_de",
+                    msg: "Missing element interpolation",
+                },
+            ],
+        });
     });
     it("should return an object containing the keys for every language with missing key", () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
@@ -55,8 +80,22 @@ describe("findInvalidTranslations", () => {
                 key_with_broken_de: "Some format {{value, formatname}} and some other format {{value, formatname}}",
             },
         })).toEqual({
-            de: ["key_with_broken_de", "intlNumber_broken_de"],
-            fr: ["key_with_broken_de"],
+            de: [
+                {
+                    key: "key_with_broken_de",
+                    msg: "Error in interpolation: Expected value but received val",
+                },
+                {
+                    key: "intlNumber_broken_de",
+                    msg: "Missing element interpolation",
+                },
+            ],
+            fr: [
+                {
+                    key: "key_with_broken_de",
+                    msg: "Unexpected interpolation element",
+                },
+            ],
         });
     });
     it("should find invalid interval", () => {
@@ -67,7 +106,12 @@ describe("findInvalidTranslations", () => {
                 key1_interval: "(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];",
             },
         })).toEqual({
-            de: ["key1_interval"],
+            de: [
+                {
+                    key: "key1_interval",
+                    msg: "Error in plural: Expected 1 but received 1-2, Error in plural: Expected 2-7 but received 3-7",
+                },
+            ],
         });
     });
     it("should find invalid nested interpolation", () => {
@@ -78,7 +122,12 @@ describe("findInvalidTranslations", () => {
                 "tree.one": "added {{somethings}}",
             },
         })).toEqual({
-            de: ["tree.one"],
+            de: [
+                {
+                    key: "tree.one",
+                    msg: "Error in interpolation: Expected something but received somethings",
+                },
+            ],
         });
     });
     it("should find invalid relative time formatting", () => {
@@ -89,7 +138,12 @@ describe("findInvalidTranslations", () => {
                 intlRelativeTimeWithOptionsExplicit: "Lorem {{val, relativetime(range: quarter; style: long;)}}",
             },
         })).toEqual({
-            de: ["intlRelativeTimeWithOptionsExplicit"],
+            de: [
+                {
+                    key: "intlRelativeTimeWithOptionsExplicit",
+                    msg: "Error in interpolation: Expected relativetime(range: quarter; style: narrow;) but received relativetime(range: quarter; style: long;)",
+                },
+            ],
         });
     });
     it("should find invalid key with options", () => {
@@ -100,7 +154,12 @@ describe("findInvalidTranslations", () => {
                 keyWithOptions: "Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}",
             },
         })).toEqual({
-            de: ["keyWithOptions"],
+            de: [
+                {
+                    key: "keyWithOptions",
+                    msg: "Error in interpolation: Expected formatname(option1Name: option1Value; option2Name: option2Value) but received formatname(option3Name: option3Value; option4Name: option4Value)",
+                },
+            ],
         });
     });
     it("should find invalid nesting", () => {
@@ -111,7 +170,12 @@ describe("findInvalidTranslations", () => {
                 nesting1: "1 $t(nesting3)",
             },
         })).toEqual({
-            de: ["nesting1"],
+            de: [
+                {
+                    key: "nesting1",
+                    msg: "Error in nesting: Expected nesting2 but received nesting3",
+                },
+            ],
         });
     });
     it("should find invalid tags", () => {
@@ -122,7 +186,12 @@ describe("findInvalidTranslations", () => {
                 tag: "There is some <b>bold text</b> and some other <span>text inside a span</span>!",
             },
         })).toEqual({
-            de: ["tag"],
+            de: [
+                {
+                    key: "tag",
+                    msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
+                },
+            ],
         });
     });
     it("should recognize special characters", () => {

package/dist/utils/nextIntlSrcParser.d.ts

@@ -2,5 +2,7 @@ export declare const extract: (filesPaths: string[]) => {
     key: string;
     meta: {
         file: string;
+        namespace?: string;
+        dynamic?: boolean;
     };
 }[];

package/dist/utils/nextIntlSrcParser.js

@@ -44,7 +44,7 @@ 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;
+        return a.key > b.key ? 1 : -1;
     });
 };
 exports.extract = extract;
@@ -53,24 +53,36 @@ const getKeys = (path) => {
     const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
     const foundKeys = [];
     let namespaces = [];
-    let variable = "t";
-    const getCurrentNamespace = () => {
+    const getCurrentNamespaces = (range = 1) => {
         if (namespaces.length > 0) {
-            return namespaces[namespaces.length - 1];
+            return namespaces.slice(namespaces.length - range);
         }
         return null;
     };
-    const pushNamespace = (name) => {
-        namespaces.push(name);
+    const getCurrentNamespaceForIdentifier = (name) => {
+        return [...namespaces].reverse().find((namespace) => {
+            return namespace.variable === name;
+        });
     };
-    const removeNamespace = () => {
+    const pushNamespace = (namespace) => {
+        namespaces.push(namespace);
+    };
+    const setNamespaceAsDynamic = (name) => {
+        namespaces = namespaces.map((namespace) => {
+            if (namespace.name === name) {
+                return { ...namespace, dynamic: true };
+            }
+            return namespace;
+        });
+    };
+    const removeNamespaces = (range = 1) => {
         if (namespaces.length > 0) {
-            namespaces.pop();
+            namespaces = namespaces.slice(0, namespaces.length - range);
         }
     };
     const visit = (node) => {
         let key = null;
-        let current = namespaces.length;
+        let initialNamespacesLength = namespaces.length;
         if (node === undefined) {
             return;
         }
@@ -82,14 +94,12 @@ const getKeys = (path) => {
                     // from the default `t`, i.e.: const other = useTranslations("namespace1");
                     if (node.initializer.expression.text === USE_TRANSLATIONS) {
                         const [argument] = node.initializer.arguments;
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : "t";
                         if (argument && ts.isStringLiteral(argument)) {
-                            pushNamespace(argument.text);
+                            pushNamespace({ name: argument.text, variable });
                         }
                         else if (argument === undefined) {
-                            pushNamespace("");
-                        }
-                        if (ts.isIdentifier(node.name)) {
-                            variable = node.name.text;
+                            pushNamespace({ name: "", variable });
                         }
                     }
                 }
@@ -109,6 +119,7 @@ const getKeys = (path) => {
                     ts.isIdentifier(node.initializer.expression.expression)) {
                     if (node.initializer.expression.expression.text === GET_TRANSLATIONS) {
                         const [argument] = node.initializer.expression.arguments;
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : "t";
                         if (argument && ts.isObjectLiteralExpression(argument)) {
                             argument.properties.forEach((property) => {
                                 if (property &&
@@ -117,18 +128,15 @@ const getKeys = (path) => {
                                     ts.isIdentifier(property.name) &&
                                     property.name.text === "namespace" &&
                                     ts.isStringLiteral(property.initializer)) {
-                                    pushNamespace(property.initializer.text);
+                                    pushNamespace({ name: property.initializer.text, variable });
                                 }
                             });
                         }
                         else if (argument && ts.isStringLiteral(argument)) {
-                            pushNamespace(argument.text);
+                            pushNamespace({ name: argument.text, variable });
                         }
                         else if (argument === undefined) {
-                            pushNamespace("");
-                        }
-                        if (ts.isIdentifier(node.name)) {
-                            variable = node.name.text;
+                            pushNamespace({ name: "", variable });
                         }
                     }
                 }
@@ -168,7 +176,7 @@ const getKeys = (path) => {
                             if (key) {
                                 foundKeys.push({
                                     key: inlineNamespace ? `${inlineNamespace}.${key}` : key,
-                                    meta: { file: path },
+                                    meta: { file: path, namespace: inlineNamespace ?? undefined },
                                 });
                             }
                         }
@@ -177,35 +185,50 @@ const getKeys = (path) => {
             }
         }
         // Search for `t()` calls
-        if (getCurrentNamespace() !== null &&
+        if (getCurrentNamespaces() !== null &&
             ts.isCallExpression(node) &&
             ts.isIdentifier(node.expression)) {
             const expressionName = node.expression.text;
-            if (expressionName === variable) {
+            const namespace = getCurrentNamespaceForIdentifier(expressionName);
+            if (namespace) {
                 const [argument] = node.arguments;
                 if (argument && ts.isStringLiteral(argument)) {
-                    key = argument.text;
+                    key = { name: argument.text, identifier: expressionName };
+                }
+                else if (argument && ts.isIdentifier(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+                else if (argument && ts.isTemplateExpression(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
                 }
             }
         }
         // Search for `t.*()` calls, i.e. t.html() or t.rich()
-        if (getCurrentNamespace() !== null &&
+        if (getCurrentNamespaces() !== null &&
             ts.isCallExpression(node) &&
             ts.isPropertyAccessExpression(node.expression) &&
             ts.isIdentifier(node.expression.expression)) {
             const expressionName = node.expression.expression.text;
-            if (expressionName === variable) {
+            const namespace = getCurrentNamespaceForIdentifier(expressionName);
+            if (namespace) {
                 const [argument] = node.arguments;
                 if (argument && ts.isStringLiteral(argument)) {
-                    key = argument.text;
+                    key = { name: argument.text, identifier: expressionName };
+                }
+                else if (argument && ts.isIdentifier(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
+                }
+                else if (argument && ts.isTemplateExpression(argument)) {
+                    setNamespaceAsDynamic(namespace.name);
                 }
             }
         }
         if (key) {
-            const namespace = getCurrentNamespace();
+            const namespace = getCurrentNamespaceForIdentifier(key.identifier);
+            const namespaceName = namespace ? namespace.name : "";
             foundKeys.push({
-                key: namespace ? `${namespace}.${key}` : key,
-                meta: { file: path },
+                key: namespaceName ? `${namespaceName}.${key.name}` : key.name,
+                meta: { file: path, namespace: namespaceName },
             });
         }
         // Search for single-line comments that contain the static values of a dynamic key
@@ -225,18 +248,32 @@ const getKeys = (path) => {
                     // capture the string comment
                     const commentKey = COMMENT_CONTAINS_STATIC_KEY_REGEX.exec(comment)?.[2];
                     if (commentKey) {
-                        const namespace = getCurrentNamespace();
+                        const namespace = getCurrentNamespaces();
+                        const namespaceName = namespace ? namespace[0]?.name : "";
                         foundKeys.push({
-                            key: namespace ? `${namespace}.${commentKey}` : commentKey,
-                            meta: { file: path },
+                            key: namespaceName
+                                ? `${namespaceName}.${commentKey}`
+                                : commentKey,
+                            meta: { file: path, namespace: namespaceName },
                         });
                     }
                 }
             });
         }
         ts.forEachChild(node, visit);
-        if (ts.isFunctionLike(node) && namespaces.length > current) {
-            removeNamespace();
+        if (ts.isFunctionLike(node) &&
+            namespaces.length > initialNamespacesLength) {
+            // check if the namespaces are dynamic and add a placeholder key
+            const currentNamespaces = getCurrentNamespaces(namespaces?.length - initialNamespacesLength);
+            currentNamespaces?.forEach((namespace) => {
+                if (namespace.dynamic) {
+                    foundKeys.push({
+                        key: namespace.name,
+                        meta: { file: path, namespace: namespace.name, dynamic: true },
+                    });
+                }
+            });
+            removeNamespaces(namespaces.length - initialNamespacesLength);
         }
     };
     ts.forEachChild(sourceFile, visit);