@lingual/i18n-check 0.7.3 → 0.7.5

package/dist/utils/nextIntlSrcParser.js

@@ -53,19 +53,23 @@ 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 removeNamespaces = (range = 1) => {
         if (namespaces.length > 0) {
-            namespaces.pop();
+            namespaces = namespaces.slice(0, namespaces.length - range);
         }
     };
     const visit = (node) => {
@@ -82,14 +86,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 +111,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 +120,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 });
                         }
                     }
                 }
@@ -162,49 +162,52 @@ const getKeys = (path) => {
                         if (argument && ts.isStringLiteral(argument)) {
                             inlineNamespace = argument.text;
                         }
-                    }
-                    const [callArgument] = node.expression.arguments;
-                    if (callArgument && ts.isStringLiteral(callArgument)) {
-                        const key = callArgument.text;
-                        if (key) {
-                            foundKeys.push({
-                                key: inlineNamespace ? `${inlineNamespace}.${key}` : key,
-                                meta: { file: path },
-                            });
+                        const [callArgument] = node.expression.arguments;
+                        if (callArgument && ts.isStringLiteral(callArgument)) {
+                            const key = callArgument.text;
+                            if (key) {
+                                foundKeys.push({
+                                    key: inlineNamespace ? `${inlineNamespace}.${key}` : key,
+                                    meta: { file: 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 };
                 }
             }
         }
         // 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 };
                 }
             }
         }
         if (key) {
-            const namespace = getCurrentNamespace();
+            const namespace = getCurrentNamespaceForIdentifier(key.identifier);
+            const namespaceName = namespace ? namespace.name : "";
             foundKeys.push({
-                key: namespace ? `${namespace}.${key}` : key,
+                key: namespaceName ? `${namespaceName}.${key.name}` : key.name,
                 meta: { file: path },
             });
         }
@@ -225,9 +228,12 @@ 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,
+                            key: namespaceName
+                                ? `${namespaceName}.${commentKey}`
+                                : commentKey,
                             meta: { file: path },
                         });
                     }
@@ -236,7 +242,7 @@ const getKeys = (path) => {
         }
         ts.forEachChild(node, visit);
         if (ts.isFunctionLike(node) && namespaces.length > current) {
-            removeNamespace();
+            removeNamespaces(namespaces.length - current);
         }
     };
     ts.forEachChild(sourceFile, visit);

package/dist/utils/nextIntlSrcParser.test.js

@@ -11,8 +11,9 @@ 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");
+const dynamicKeysExampleFile = node_path_1.default.join(srcPath, "DynamicKeysExample.tsx");
 const strictTypesExample = node_path_1.default.join(srcPath, "StrictTypesExample.tsx");
+const advancedExample = node_path_1.default.join(srcPath, "AdvancedExample.tsx");
 describe("nextIntlSrcParser", () => {
     it("should find all the translation keys", () => {
         const keys = (0, nextIntlSrcParser_1.extract)([basicFile, counterFile, clientCounterFile]);
@@ -216,7 +217,7 @@ describe("nextIntlSrcParser", () => {
         ]);
     });
     it("should find all dynamic keys defined as comments", () => {
-        const keys = (0, nextIntlSrcParser_1.extract)([dynamicKeysExamplFile]);
+        const keys = (0, nextIntlSrcParser_1.extract)([dynamicKeysExampleFile]);
         expect(keys).toEqual([
             {
                 key: "dynamic.three.value",
@@ -477,4 +478,63 @@ describe("nextIntlSrcParser", () => {
             },
         ]);
     });
+    it("should find all the keys for multiple useTranslations aliases", () => {
+        const keys = (0, nextIntlSrcParser_1.extract)([advancedExample]);
+        expect(keys).toEqual([
+            {
+                key: "aliasNestedOne.one",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedTwo.two",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedThree.threeThree",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedTwo.threeTwo",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedOne.threeOne",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedThree.three",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasNestedFour.four",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasTwo.keyTwo",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+            {
+                key: "aliasOne.keyOne",
+                meta: {
+                    file: advancedExample,
+                },
+            },
+        ]);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingual/i18n-check",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "i18n translation messages check",
   "license": "MIT",
   "main": "dist/index.js",