@lingual/i18n-check 0.8.2 → 0.8.3

package/dist/utils/findMissingKeys.test.js

@@ -2,40 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const findMissingKeys_1 = require("./findMissingKeys");
 const sourceFile = {
-    "one.two.three": "one two three",
-    "four.five.six": "four five six",
-    "seven.eight.nine": "seven eight nine",
+    'one.two.three': 'one two three',
+    'four.five.six': 'four five six',
+    'seven.eight.nine': 'seven eight nine',
 };
 const secondaryFile = {
-    "one.two.three": "one two three",
-    "four.five.six": "four five six",
-    "seven.eight.nine": "seven eight nine",
+    'one.two.three': 'one two three',
+    'four.five.six': 'four five six',
+    'seven.eight.nine': 'seven eight nine',
 };
-describe("findMissingKeys:compareTranslationFiles", () => {
-    it("should return empty array if files are identical", () => {
+describe('findMissingKeys:compareTranslationFiles', () => {
+    it('should return empty array if files are identical', () => {
         expect((0, findMissingKeys_1.compareTranslationFiles)(sourceFile, secondaryFile)).toEqual([]);
     });
-    it("should return the missing keys in the secondary file", () => {
-        expect((0, findMissingKeys_1.compareTranslationFiles)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, secondaryFile)).toEqual(["ten.eleven.twelve"]);
+    it('should return the missing keys in the secondary file', () => {
+        expect((0, findMissingKeys_1.compareTranslationFiles)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, secondaryFile)).toEqual(['ten.eleven.twelve']);
     });
 });
-describe("findMissingKeys", () => {
-    it("should return an empty object if all files have no missing keys", () => {
+describe('findMissingKeys', () => {
+    it('should return an empty object if all files have no missing keys', () => {
         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)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: secondaryFile })).toEqual({ de: ["ten.eleven.twelve"] });
+    it('should return an object containing the keys for the missing language', () => {
+        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)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
+    it('should return an object containing the keys for every language with missing key', () => {
+        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, {
             de: secondaryFile,
             fr: {
-                "four.five.six": "four five six",
-                "seven.eight.nine": "seven eight nine",
+                'four.five.six': 'four five six',
+                'seven.eight.nine': 'seven eight nine',
             },
         })).toEqual({
-            de: ["ten.eleven.twelve"],
-            fr: ["one.two.three", "ten.eleven.twelve"],
+            de: ['ten.eleven.twelve'],
+            fr: ['one.two.three', 'ten.eleven.twelve'],
         });
     });
 });

package/dist/utils/flattenTranslations.d.ts

@@ -1,3 +1,3 @@
-import { Translation } from "../types";
+import { Translation } from '../types';
 export declare const flattenTranslations: (translations: Translation) => Translation;
 export declare const flattenEntry: (entry: Translation, keys?: string[]) => Translation;

package/dist/utils/flattenTranslations.js

@@ -12,10 +12,10 @@ exports.flattenTranslations = flattenTranslations;
  * Top level search for any objects
  */
 const hasNestedDefinitions = (translations) => {
-    return Object.values(translations).find((translation) => typeof translation === "object");
+    return Object.values(translations).find((translation) => typeof translation === 'object');
 };
 const isTranslationObject = (entry) => {
-    return typeof entry === "object";
+    return typeof entry === 'object';
 };
 const flattenEntry = (entry, keys = []) => {
     const result = {};
@@ -26,7 +26,7 @@ const flattenEntry = (entry, keys = []) => {
     for (const [k, v] of entries) {
         Object.assign(result, isTranslationObject(v)
             ? (0, exports.flattenEntry)(v, [...keys, String(k)])
-            : { [[...keys, String(k)].join(".")]: v });
+            : { [[...keys, String(k)].join('.')]: v });
     }
     return result;
 };

package/dist/utils/flattenTranslations.test.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const flattenTranslations_1 = require("./flattenTranslations");
-const flatStructure = require("../../translations/en-us.json");
-const nestedStructure = require("../../translations/flattenExamples/en-us.json");
+const flatStructure = require('../../translations/en-us.json');
+const nestedStructure = require('../../translations/flattenExamples/en-us.json');
 const expectedFlatStructure = {
-    "test.drive.one": "testing one",
-    "test.drive.two": "testing two",
-    "other.nested.three": "testing three",
-    "other.nested.deep.more.final": "nested translation",
+    'test.drive.one': 'testing one',
+    'test.drive.two': 'testing two',
+    'other.nested.three': 'testing three',
+    'other.nested.deep.more.final': 'nested translation',
 };
-describe("flattenTranslations", () => {
-    it("should do nothing if the file structure is flat", () => {
+describe('flattenTranslations', () => {
+    it('should do nothing if the file structure is flat', () => {
         expect((0, flattenTranslations_1.flattenTranslations)(flatStructure)).toEqual(flatStructure);
     });
-    describe("flattenEntry", () => {
-        it("should flatten a nested object", () => {
+    describe('flattenEntry', () => {
+        it('should flatten a nested object', () => {
             expect((0, flattenTranslations_1.flattenEntry)({
                 a: {
-                    b: { c: "one" },
+                    b: { c: 'one' },
                 },
-            })).toEqual({ "a.b.c": "one" });
+            })).toEqual({ 'a.b.c': 'one' });
         });
     });
-    it("should do nothing if the file structure is flat", () => {
+    it('should do nothing if the file structure is flat', () => {
         expect((0, flattenTranslations_1.flattenTranslations)(nestedStructure)).toEqual(expectedFlatStructure);
     });
 });

package/dist/utils/i18NextParser.d.ts

@@ -1,36 +1,36 @@
 export type MessageFormatElement = {
-    type: "text";
+    type: 'text';
     content: string;
 } | {
-    type: "interpolation";
+    type: 'interpolation';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "interpolation_unescaped";
+    type: 'interpolation_unescaped';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "nesting";
+    type: 'nesting';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "plural";
+    type: 'plural';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "tag";
+    type: 'tag';
     raw: string;
     voidElement: boolean;
 };

package/dist/utils/i18NextParser.js

@@ -2,13 +2,13 @@
 //  Based on https://github.com/i18next/i18next-translation-parser/blob/v1.0.0/src/parse.js
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = void 0;
-const REGEXP = new RegExp("({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)(?=\\[)|<[^>]+>)", "g");
-const DOUBLE_BRACE = "{{";
-const $_T_BRACE = "$t{";
-const $_T_PARENTHESIS = "$t(";
-const OPEN_PARENTHESIS = "(";
-const OPEN_TAG = "<";
-const CLOSE_TAG = "</";
+const REGEXP = new RegExp('({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)(?=\\[)|<[^>]+>)', 'g');
+const DOUBLE_BRACE = '{{';
+const $_T_BRACE = '$t{';
+const $_T_PARENTHESIS = '$t(';
+const OPEN_PARENTHESIS = '(';
+const OPEN_TAG = '<';
+const CLOSE_TAG = '</';
 const parse = (input) => {
     let ast = [];
     ast = parseInput([input]);
@@ -21,15 +21,15 @@ const parseInput = (input) => {
     }
     let ast = [];
     input.forEach((element) => {
-        const elements = element.split(REGEXP).filter((element) => element !== "");
+        const elements = element.split(REGEXP).filter((element) => element !== '');
         const result = elements.reduce((acc, match) => {
-            if (match.indexOf("{{-") === 0) {
+            if (match.indexOf('{{-') === 0) {
                 const content = match.substring(3, match.length - 2);
                 acc.push({
-                    type: "interpolation_unescaped",
+                    type: 'interpolation_unescaped',
                     raw: match,
-                    prefix: "{{-",
-                    suffix: "}}",
+                    prefix: '{{-',
+                    suffix: '}}',
                     content,
                     variable: content.trim(),
                 });
@@ -37,10 +37,10 @@ const parseInput = (input) => {
             else if (match.indexOf(DOUBLE_BRACE) === 0) {
                 const content = match.substring(2, match.length - 2);
                 acc.push({
-                    type: "interpolation",
+                    type: 'interpolation',
                     raw: match,
-                    prefix: "{{",
-                    suffix: "}}",
+                    prefix: '{{',
+                    suffix: '}}',
                     content,
                     variable: content.trim(),
                 });
@@ -48,10 +48,10 @@ const parseInput = (input) => {
             else if (match.indexOf($_T_BRACE) === 0) {
                 const content = match.substring(3, match.length - 1);
                 acc.push({
-                    type: "nesting",
+                    type: 'nesting',
                     raw: match,
-                    prefix: "$t{",
-                    suffix: "}",
+                    prefix: '$t{',
+                    suffix: '}',
                     content,
                     variable: content.trim(),
                 });
@@ -59,10 +59,10 @@ const parseInput = (input) => {
             else if (match.indexOf($_T_PARENTHESIS) === 0) {
                 const content = match.substring(3, match.length - 1);
                 acc.push({
-                    type: "nesting",
+                    type: 'nesting',
                     raw: match,
-                    prefix: "$t(",
-                    suffix: ")",
+                    prefix: '$t(',
+                    suffix: ')',
                     content,
                     variable: content.trim(),
                 });
@@ -71,30 +71,30 @@ const parseInput = (input) => {
                 /\([0-9\-inf]+\)/.test(match)) {
                 const content = match.substring(1, match.length - 1);
                 acc.push({
-                    type: "plural",
+                    type: 'plural',
                     raw: match,
-                    prefix: "(",
-                    suffix: ")",
+                    prefix: '(',
+                    suffix: ')',
                     content,
                     variable: content.trim(),
                 });
             }
             else if (match.indexOf(CLOSE_TAG) === 0) {
                 acc.push({
-                    type: "tag",
+                    type: 'tag',
                     raw: match,
-                    voidElement: match.substring(match.length - 2) === "/>",
+                    voidElement: match.substring(match.length - 2) === '/>',
                 });
             }
             else if (match.indexOf(OPEN_TAG) === 0 && /<[^\s]+/.test(match)) {
                 acc.push({
-                    type: "tag",
+                    type: 'tag',
                     raw: match,
-                    voidElement: match.substring(match.length - 2) === "/>",
+                    voidElement: match.substring(match.length - 2) === '/>',
                 });
             }
             else {
-                acc.push({ type: "text", content: match });
+                acc.push({ type: 'text', content: match });
             }
             return acc;
         }, []);

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.' },
         ]);
     });
 });