@lingual/i18n-check 0.8.2 → 0.8.4

package/dist/utils/i18NextParser.test.js

@@ -1,150 +1,150 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const i18NextParser_1 = require("./i18NextParser");
-describe("i18NextParser", () => {
-    it("should parse interpolation", () => {
-        expect((0, i18NextParser_1.parse)("test {{val}} text {{- encoded}} with {{val, format}} some $t{nesting} help")).toEqual([
+describe('i18NextParser', () => {
+    it('should parse interpolation', () => {
+        expect((0, i18NextParser_1.parse)('test {{val}} text {{- encoded}} with {{val, format}} some $t{nesting} help')).toEqual([
             {
-                type: "text",
-                content: "test ",
+                type: 'text',
+                content: 'test ',
             },
             {
-                type: "interpolation",
-                raw: "{{val}}",
-                prefix: "{{",
-                suffix: "}}",
-                content: "val",
-                variable: "val",
+                type: 'interpolation',
+                raw: '{{val}}',
+                prefix: '{{',
+                suffix: '}}',
+                content: 'val',
+                variable: 'val',
             },
             {
-                type: "text",
-                content: " text ",
+                type: 'text',
+                content: ' text ',
             },
             {
-                type: "interpolation_unescaped",
-                raw: "{{- encoded}}",
-                prefix: "{{-",
-                suffix: "}}",
-                content: " encoded",
-                variable: "encoded",
+                type: 'interpolation_unescaped',
+                raw: '{{- encoded}}',
+                prefix: '{{-',
+                suffix: '}}',
+                content: ' encoded',
+                variable: 'encoded',
             },
             {
-                type: "text",
-                content: " with ",
+                type: 'text',
+                content: ' with ',
             },
             {
-                type: "interpolation",
-                raw: "{{val, format}}",
-                prefix: "{{",
-                suffix: "}}",
-                content: "val, format",
-                variable: "val, format",
+                type: 'interpolation',
+                raw: '{{val, format}}',
+                prefix: '{{',
+                suffix: '}}',
+                content: 'val, format',
+                variable: 'val, format',
             },
             {
-                type: "text",
-                content: " some ",
+                type: 'text',
+                content: ' some ',
             },
             {
-                type: "nesting",
-                raw: "$t{nesting}",
-                prefix: "$t{",
-                suffix: "}",
-                content: "nesting",
-                variable: "nesting",
+                type: 'nesting',
+                raw: '$t{nesting}',
+                prefix: '$t{',
+                suffix: '}',
+                content: 'nesting',
+                variable: 'nesting',
             },
             {
-                type: "text",
-                content: " help",
+                type: 'text',
+                content: ' help',
             },
         ]);
     });
-    it("should parse plural translations", () => {
-        expect((0, i18NextParser_1.parse)("(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];")).toEqual([
+    it('should parse plural translations', () => {
+        expect((0, i18NextParser_1.parse)('(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];')).toEqual([
             {
-                type: "plural",
-                raw: "(1)",
-                prefix: "(",
-                suffix: ")",
-                content: "1",
-                variable: "1",
+                type: 'plural',
+                raw: '(1)',
+                prefix: '(',
+                suffix: ')',
+                content: '1',
+                variable: '1',
             },
-            { type: "text", content: "[one item];" },
+            { type: 'text', content: '[one item];' },
             {
-                type: "plural",
-                raw: "(2-7)",
-                prefix: "(",
-                suffix: ")",
-                content: "2-7",
-                variable: "2-7",
+                type: 'plural',
+                raw: '(2-7)',
+                prefix: '(',
+                suffix: ')',
+                content: '2-7',
+                variable: '2-7',
             },
-            { type: "text", content: "[a few items];" },
+            { type: 'text', content: '[a few items];' },
             {
-                type: "plural",
-                raw: "(7-inf)",
-                prefix: "(",
-                suffix: ")",
-                content: "7-inf",
-                variable: "7-inf",
+                type: 'plural',
+                raw: '(7-inf)',
+                prefix: '(',
+                suffix: ')',
+                content: '7-inf',
+                variable: '7-inf',
             },
-            { type: "text", content: "[a lot of items];" },
+            { type: 'text', content: '[a lot of items];' },
         ]);
     });
-    it("should not parse plural translations if regular text inside parenthesis", () => {
-        expect((0, i18NextParser_1.parse)("(This is a regular text inside parenthesis)")).toEqual([
-            { type: "text", content: "(This is a regular text inside parenthesis)" },
+    it('should not parse plural translations if regular text inside parenthesis', () => {
+        expect((0, i18NextParser_1.parse)('(This is a regular text inside parenthesis)')).toEqual([
+            { type: 'text', content: '(This is a regular text inside parenthesis)' },
         ]);
     });
-    it("should parse translations with nesting", () => {
-        expect((0, i18NextParser_1.parse)("1 $t(nesting2)")).toEqual([
+    it('should parse translations with nesting', () => {
+        expect((0, i18NextParser_1.parse)('1 $t(nesting2)')).toEqual([
             {
-                type: "text",
-                content: "1 ",
+                type: 'text',
+                content: '1 ',
             },
             {
-                type: "nesting",
-                raw: "$t(nesting2)",
-                prefix: "$t(",
-                suffix: ")",
-                content: "nesting2",
-                variable: "nesting2",
+                type: 'nesting',
+                raw: '$t(nesting2)',
+                prefix: '$t(',
+                suffix: ')',
+                content: 'nesting2',
+                variable: 'nesting2',
             },
         ]);
     });
-    it("should parse translations with tags", () => {
-        expect((0, i18NextParser_1.parse)("This is some <b>bold text</b> and some <i>italic</i> text.")).toEqual([
-            { type: "text", content: "This is some " },
-            { type: "tag", raw: "<b>", voidElement: false },
-            { type: "text", content: "bold text" },
-            { type: "tag", raw: "</b>", voidElement: false },
-            { type: "text", content: " and some " },
-            { type: "tag", raw: "<i>", voidElement: false },
-            { type: "text", content: "italic" },
-            { type: "tag", raw: "</i>", voidElement: false },
-            { type: "text", content: " text." },
+    it('should parse translations with tags', () => {
+        expect((0, i18NextParser_1.parse)('This is some <b>bold text</b> and some <i>italic</i> text.')).toEqual([
+            { type: 'text', content: 'This is some ' },
+            { type: 'tag', raw: '<b>', voidElement: false },
+            { type: 'text', content: 'bold text' },
+            { type: 'tag', raw: '</b>', voidElement: false },
+            { type: 'text', content: ' and some ' },
+            { type: 'tag', raw: '<i>', voidElement: false },
+            { type: 'text', content: 'italic' },
+            { type: 'tag', raw: '</i>', voidElement: false },
+            { type: 'text', content: ' text.' },
         ]);
     });
-    it("should parse translations with nested tags", () => {
-        expect((0, i18NextParser_1.parse)("This is some <b>bold text and some <i>nested italic</i> text</b>!")).toEqual([
-            { type: "text", content: "This is some " },
-            { type: "tag", raw: "<b>", voidElement: false },
-            { type: "text", content: "bold text and some " },
-            { type: "tag", raw: "<i>", voidElement: false },
-            { type: "text", content: "nested italic" },
-            { type: "tag", raw: "</i>", voidElement: false },
-            { type: "text", content: " text" },
-            { type: "tag", raw: "</b>", voidElement: false },
-            { type: "text", content: "!" },
+    it('should parse translations with nested tags', () => {
+        expect((0, i18NextParser_1.parse)('This is some <b>bold text and some <i>nested italic</i> text</b>!')).toEqual([
+            { type: 'text', content: 'This is some ' },
+            { type: 'tag', raw: '<b>', voidElement: false },
+            { type: 'text', content: 'bold text and some ' },
+            { type: 'tag', raw: '<i>', voidElement: false },
+            { type: 'text', content: 'nested italic' },
+            { type: 'tag', raw: '</i>', voidElement: false },
+            { type: 'text', content: ' text' },
+            { type: 'tag', raw: '</b>', voidElement: false },
+            { type: 'text', content: '!' },
         ]);
     });
-    it("should parse translations with self closing tags", () => {
-        expect((0, i18NextParser_1.parse)("This is some <b>bold text and some </b> and some random self closing tag <img /> as well.")).toEqual([
-            { type: "text", content: "This is some " },
-            { type: "tag", raw: "<b>", voidElement: false },
-            { type: "text", content: "bold text and some " },
-            { type: "tag", raw: "</b>", voidElement: false },
-            { type: "text", content: " and some random self closing tag " },
-            { type: "tag", raw: "<img />", voidElement: true },
-            { type: "text", content: " as well." },
+    it('should parse translations with self closing tags', () => {
+        expect((0, i18NextParser_1.parse)('This is some <b>bold text and some </b> and some random self closing tag <img /> as well.')).toEqual([
+            { type: 'text', content: 'This is some ' },
+            { type: 'tag', raw: '<b>', voidElement: false },
+            { type: 'text', content: 'bold text and some ' },
+            { type: 'tag', raw: '</b>', voidElement: false },
+            { type: 'text', content: ' and some random self closing tag ' },
+            { type: 'tag', raw: '<img />', voidElement: true },
+            { type: 'text', content: ' as well.' },
         ]);
     });
 });

package/dist/utils/nextIntlSrcParser.js

@@ -39,8 +39,8 @@ 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 USE_TRANSLATIONS = 'useTranslations';
+const GET_TRANSLATIONS = 'getTranslations';
 const COMMENT_CONTAINS_STATIC_KEY_REGEX = /t\((["'])(.*?[^\\])(["'])\)/;
 const extract = (filesPaths) => {
     return filesPaths.flatMap(getKeys).sort((a, b) => {
@@ -49,7 +49,7 @@ const extract = (filesPaths) => {
 };
 exports.extract = extract;
 const getKeys = (path) => {
-    const content = node_fs_1.default.readFileSync(path, "utf-8");
+    const content = node_fs_1.default.readFileSync(path, 'utf-8');
     const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
     const foundKeys = [];
     let namespaces = [];
@@ -82,7 +82,7 @@ const getKeys = (path) => {
     };
     const visit = (node) => {
         let key = null;
-        let initialNamespacesLength = namespaces.length;
+        const initialNamespacesLength = namespaces.length;
         if (node === undefined) {
             return;
         }
@@ -94,12 +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";
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : 't';
                         if (argument && ts.isStringLiteral(argument)) {
                             pushNamespace({ name: argument.text, variable });
                         }
                         else if (argument === undefined) {
-                            pushNamespace({ name: "", variable });
+                            pushNamespace({ name: '', variable });
                         }
                     }
                 }
@@ -119,14 +119,14 @@ 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";
+                        const variable = ts.isIdentifier(node.name) ? node.name.text : 't';
                         if (argument && ts.isObjectLiteralExpression(argument)) {
                             argument.properties.forEach((property) => {
                                 if (property &&
                                     ts.isPropertyAssignment(property) &&
                                     property.name &&
                                     ts.isIdentifier(property.name) &&
-                                    property.name.text === "namespace" &&
+                                    property.name.text === 'namespace' &&
                                     ts.isStringLiteral(property.initializer)) {
                                     pushNamespace({ name: property.initializer.text, variable });
                                 }
@@ -136,7 +136,7 @@ const getKeys = (path) => {
                             pushNamespace({ name: argument.text, variable });
                         }
                         else if (argument === undefined) {
-                            pushNamespace({ name: "", variable });
+                            pushNamespace({ name: '', variable });
                         }
                     }
                 }
@@ -225,7 +225,7 @@ const getKeys = (path) => {
         }
         if (key) {
             const namespace = getCurrentNamespaceForIdentifier(key.identifier);
-            const namespaceName = namespace ? namespace.name : "";
+            const namespaceName = namespace ? namespace.name : '';
             foundKeys.push({
                 key: namespaceName ? `${namespaceName}.${key.name}` : key.name,
                 meta: { file: path, namespace: namespaceName },
@@ -249,7 +249,7 @@ const getKeys = (path) => {
                     const commentKey = COMMENT_CONTAINS_STATIC_KEY_REGEX.exec(comment)?.[2];
                     if (commentKey) {
                         const namespace = getCurrentNamespaces();
-                        const namespaceName = namespace ? namespace[0]?.name : "";
+                        const namespaceName = namespace ? namespace[0]?.name : '';
                         foundKeys.push({
                             key: namespaceName
                                 ? `${namespaceName}.${commentKey}`