@lingual/i18n-check 0.8.1 → 0.8.3

package/dist/utils/findInvalidi18nTranslations.js

@@ -9,21 +9,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDiff = exports.compareTranslationFiles = exports.findInvalid18nTranslations = void 0;
 const i18NextParser_1 = require("./i18NextParser");
 const findInvalid18nTranslations = (source, targets) => {
-    let differences = {};
+    const differences = {};
     if (Object.keys(targets).length === 0) {
         return differences;
     }
     for (const [lang, file] of Object.entries(targets)) {
         const result = (0, exports.compareTranslationFiles)(source, file);
         if (result.length > 0) {
-            differences = Object.assign(differences, { [lang]: result });
+            differences[lang] = result;
         }
     }
     return differences;
 };
 exports.findInvalid18nTranslations = findInvalid18nTranslations;
 const compareTranslationFiles = (a, b) => {
-    let diffs = [];
+    const diffs = [];
     for (const key in a) {
         if (b[key] === undefined) {
             continue;
@@ -47,20 +47,20 @@ const lookUp = {
     tag: 5,
 };
 const sortParsedKeys = (a, b) => {
-    if (a.type === b.type && a.type !== "tag" && b.type !== "tag") {
+    if (a.type === b.type && a.type !== 'tag' && b.type !== 'tag') {
         return a.content < b.content ? -1 : 1;
     }
-    if (a.type === "tag" && b.type === "tag") {
+    if (a.type === 'tag' && b.type === 'tag') {
         return a.raw < b.raw ? -1 : 1;
     }
     return lookUp[a.type] - lookUp[b.type];
 };
 const hasDiff = (a, b) => {
     const compA = a
-        .filter((element) => element.type !== "text")
+        .filter((element) => element.type !== 'text')
         .sort(sortParsedKeys);
     const compB = b
-        .filter((element) => element.type !== "text")
+        .filter((element) => element.type !== 'text')
         .sort(sortParsedKeys);
     if (compA.length !== compB.length) {
         return true;
@@ -70,28 +70,28 @@ const hasDiff = (a, b) => {
         if (formatElementA.type !== formatElementB.type) {
             return true;
         }
-        if (formatElementA.type === "tag" && formatElementB.type === "tag") {
+        if (formatElementA.type === 'tag' && formatElementB.type === 'tag') {
             return (formatElementA.raw !== formatElementB.raw ||
                 formatElementA.voidElement !== formatElementB.voidElement);
         }
-        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.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')) {
             const optionsA = formatElementA.variable
-                .split(",")
+                .split(',')
                 .map((value) => value.trim())
                 .sort()
-                .join("-")
+                .join('-')
                 .trim();
             const optionsB = formatElementB.variable
-                .split(",")
+                .split(',')
                 .map((value) => value.trim())
                 .sort()
-                .join("-")
+                .join('-')
                 .trim();
             if (optionsA !== optionsB) {
                 return true;
@@ -110,10 +110,10 @@ const hasDiff = (a, b) => {
 exports.hasDiff = hasDiff;
 const getErrorMessage = (a, b) => {
     const compA = a
-        .filter((element) => element.type !== "text")
+        .filter((element) => element.type !== 'text')
         .sort(sortParsedKeys);
     const compB = b
-        .filter((element) => element.type !== "text")
+        .filter((element) => element.type !== 'text')
         .sort(sortParsedKeys);
     const errors = compA.reduce((acc, formatElementA, index) => {
         const formatElementB = compB[index];
@@ -125,7 +125,7 @@ const getErrorMessage = (a, b) => {
             acc.push(`Expected element of type "${formatElementA.type}" but received "${formatElementB.type}"`);
             return acc;
         }
-        if (formatElementA.type === "tag" && formatElementB.type === "tag") {
+        if (formatElementA.type === 'tag' && formatElementB.type === 'tag') {
             if (formatElementA.raw !== formatElementB.raw) {
                 acc.push(`Expected tag "${formatElementA.raw}" but received "${formatElementB.raw}"`);
             }
@@ -140,13 +140,13 @@ const getErrorMessage = (a, b) => {
                 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.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;
@@ -156,14 +156,14 @@ const getErrorMessage = (a, b) => {
                 return acc;
             }
             const optionsA = formatElementA.variable
-                .split(",")
+                .split(',')
                 .map((value) => value.trim())
                 .sort();
             const optionsB = formatElementB.variable
-                .split(",")
+                .split(',')
                 .map((value) => value.trim())
                 .sort();
-            let elementErrors = [];
+            const elementErrors = [];
             optionsA.forEach((key, index) => {
                 if (key !== optionsB[index]) {
                     elementErrors.push(`Expected ${key} but received ${optionsB[index]}`);
@@ -172,7 +172,7 @@ const getErrorMessage = (a, b) => {
             if (elementErrors.length > 0) {
                 acc.push(`Error in ${formatElementA.type}: ${elementErrors
                     .flatMap((elementError) => elementError)
-                    .join(", ")}`);
+                    .join(', ')}`);
             }
             return acc;
         }
@@ -185,8 +185,8 @@ const getErrorMessage = (a, b) => {
             acc.push(`Unexpected ${formatElementB.type} element`);
             return acc;
         }, [])
-            .join(", ");
-        return [...errors, unexpectedElements].join(", ");
+            .join(', ');
+        return [...errors, unexpectedElements].join(', ');
     }
-    return errors.join(", ");
+    return errors.join(', ');
 };

package/dist/utils/findInvalidi18nTranslations.test.js

@@ -2,204 +2,204 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const findInvalidi18nTranslations_1 = require("./findInvalidi18nTranslations");
 const flattenTranslations_1 = require("./flattenTranslations");
-const sourceFile = require("../../translations/i18NextMessageExamples/en-us.json");
-const targetFile = require("../../translations/i18NextMessageExamples/de-de.json");
-describe("findInvalid18nTranslations:compareTranslationFiles", () => {
-    it("should return empty array if files are identical", () => {
+const sourceFile = require('../../translations/i18NextMessageExamples/en-us.json');
+const targetFile = require('../../translations/i18NextMessageExamples/de-de.json');
+describe('findInvalid18nTranslations:compareTranslationFiles', () => {
+    it('should return empty array if files are identical', () => {
         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", () => {
+    it('should return the invalid keys in the target file', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
             ...sourceFile,
-            "ten.eleven.twelve": "ten eleven twelve",
+            'ten.eleven.twelve': 'ten eleven twelve',
         }), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual([
             {
-                key: "key_with_broken_de",
-                msg: "Error in interpolation: Expected value but received val",
+                key: 'key_with_broken_de',
+                msg: 'Error in interpolation: Expected value but received val',
             },
             {
-                key: "intlNumber_broken_de",
-                msg: "Missing element interpolation",
+                key: 'intlNumber_broken_de',
+                msg: 'Missing element interpolation',
             },
         ]);
     });
-    it("should return an empty array if the strings contain paranthesis that have different content", () => {
+    it('should return an empty array if the strings contain paranthesis that have different content', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
-            keyText: "Key(s)",
-        }), (0, flattenTranslations_1.flattenTranslations)({ keyText: "Taste(n)" }))).toEqual([]);
+            keyText: 'Key(s)',
+        }), (0, flattenTranslations_1.flattenTranslations)({ keyText: 'Taste(n)' }))).toEqual([]);
     });
-    it("should return empty array if placeholders are identical but in different positions", () => {
+    it('should return empty array if placeholders are identical but in different positions', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            basic: "added {{this}} and {{that}} should work.",
+            basic: 'added {{this}} and {{that}} should work.',
         }, {
-            basic: "It is {{this}} with different position {{that}}",
+            basic: 'It is {{this}} with different position {{that}}',
         })).toEqual([]);
     });
-    it("should return the invalid key if tags are not identical", () => {
+    it('should return the invalid key if tags are not identical', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            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.",
+            tag: 'There is some <b>bold text</b> and some other <span>italic</span> text.',
         })).toEqual([
             {
-                key: "tag",
+                key: 'tag',
                 msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
             },
         ]);
     });
-    it("should return empty array if tags are identical", () => {
+    it('should return empty array if tags are identical', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            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 <i>italic</i> text.",
+            tag: 'There is some <b>bold text</b> and some other <i>italic</i> text.',
         })).toEqual([]);
     });
 });
-describe("findInvalidTranslations", () => {
-    it("should return an empty object if all files have no invalid keys", () => {
+describe('findInvalidTranslations', () => {
+    it('should return an empty object if all files have no invalid keys', () => {
         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({
+    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: "key_with_broken_de",
-                    msg: "Error in interpolation: Expected value but received val",
+                    key: 'key_with_broken_de',
+                    msg: 'Error in interpolation: Expected value but received val',
                 },
                 {
-                    key: "intlNumber_broken_de",
-                    msg: "Missing element interpolation",
+                    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" }, {
+    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' }, {
             de: targetFile,
             fr: {
-                key_with_broken_de: "Some format {{value, formatname}} and some other format {{value, formatname}}",
+                key_with_broken_de: 'Some format {{value, formatname}} and some other format {{value, formatname}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "key_with_broken_de",
-                    msg: "Error in interpolation: Expected value but received val",
+                    key: 'key_with_broken_de',
+                    msg: 'Error in interpolation: Expected value but received val',
                 },
                 {
-                    key: "intlNumber_broken_de",
-                    msg: "Missing element interpolation",
+                    key: 'intlNumber_broken_de',
+                    msg: 'Missing element interpolation',
                 },
             ],
             fr: [
                 {
-                    key: "key_with_broken_de",
-                    msg: "Unexpected interpolation element",
+                    key: 'key_with_broken_de',
+                    msg: 'Unexpected interpolation element',
                 },
             ],
         });
     });
-    it("should find invalid interval", () => {
+    it('should find invalid interval', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            key1_interval: "(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];",
+            key1_interval: '(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];',
         }, {
             de: {
-                key1_interval: "(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];",
+                key1_interval: '(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];',
             },
         })).toEqual({
             de: [
                 {
-                    key: "key1_interval",
-                    msg: "Error in plural: Expected 1 but received 1-2, Error in plural: Expected 2-7 but received 3-7",
+                    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", () => {
+    it('should find invalid nested interpolation', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            "tree.one": "added {{something}}",
+            'tree.one': 'added {{something}}',
         }, {
             de: {
-                "tree.one": "added {{somethings}}",
+                'tree.one': 'added {{somethings}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "tree.one",
-                    msg: "Error in interpolation: Expected something but received somethings",
+                    key: 'tree.one',
+                    msg: 'Error in interpolation: Expected something but received somethings',
                 },
             ],
         });
     });
-    it("should find invalid relative time formatting", () => {
+    it('should find invalid relative time formatting', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            intlRelativeTimeWithOptionsExplicit: "Lorem {{val, relativetime(range: quarter; style: narrow;)}}",
+            intlRelativeTimeWithOptionsExplicit: 'Lorem {{val, relativetime(range: quarter; style: narrow;)}}',
         }, {
             de: {
-                intlRelativeTimeWithOptionsExplicit: "Lorem {{val, relativetime(range: quarter; style: long;)}}",
+                intlRelativeTimeWithOptionsExplicit: 'Lorem {{val, relativetime(range: quarter; style: long;)}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "intlRelativeTimeWithOptionsExplicit",
-                    msg: "Error in interpolation: Expected relativetime(range: quarter; style: narrow;) but received relativetime(range: quarter; style: long;)",
+                    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", () => {
+    it('should find invalid key with options', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            keyWithOptions: "Some format {{value, formatname(option1Name: option1Value; option2Name: option2Value)}}",
+            keyWithOptions: 'Some format {{value, formatname(option1Name: option1Value; option2Name: option2Value)}}',
         }, {
             de: {
-                keyWithOptions: "Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}",
+                keyWithOptions: 'Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "keyWithOptions",
-                    msg: "Error in interpolation: Expected formatname(option1Name: option1Value; option2Name: option2Value) but received formatname(option3Name: option3Value; option4Name: option4Value)",
+                    key: 'keyWithOptions',
+                    msg: 'Error in interpolation: Expected formatname(option1Name: option1Value; option2Name: option2Value) but received formatname(option3Name: option3Value; option4Name: option4Value)',
                 },
             ],
         });
     });
-    it("should find invalid nesting", () => {
+    it('should find invalid nesting', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            nesting1: "1 $t(nesting2)",
+            nesting1: '1 $t(nesting2)',
         }, {
             de: {
-                nesting1: "1 $t(nesting3)",
+                nesting1: '1 $t(nesting3)',
             },
         })).toEqual({
             de: [
                 {
-                    key: "nesting1",
-                    msg: "Error in nesting: Expected nesting2 but received nesting3",
+                    key: 'nesting1',
+                    msg: 'Error in nesting: Expected nesting2 but received nesting3',
                 },
             ],
         });
     });
-    it("should find invalid tags", () => {
+    it('should find invalid tags', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            tag: 'This is some <b>bold text</b> and some <i>italic</i> text.',
         }, {
             de: {
-                tag: "There is some <b>bold text</b> and some other <span>text inside a span</span>!",
+                tag: 'There is some <b>bold text</b> and some other <span>text inside a span</span>!',
             },
         })).toEqual({
             de: [
                 {
-                    key: "tag",
+                    key: 'tag',
                     msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
                 },
             ],
         });
     });
-    it("should recognize special characters", () => {
+    it('should recognize special characters', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            key: "Test < {{a}} and > {{max_a}}",
+            key: 'Test < {{a}} and > {{max_a}}',
         }, {
             de: {
-                key: "Test < {{a}} und > {{max_a}}",
+                key: 'Test < {{a}} und > {{max_a}}',
             },
         })).toEqual({});
     });

package/dist/utils/findMissingKeys.d.ts

@@ -1,3 +1,3 @@
-import { Translation } from "../types";
-export declare const findMissingKeys: (source: Translation, targets: Record<string, Translation>) => {};
+import { Translation } from '../types';
+export declare const findMissingKeys: (source: Translation, targets: Record<string, Translation>) => Record<string, string[]>;
 export declare const compareTranslationFiles: (a: Translation, b: Translation) => string[];

package/dist/utils/findMissingKeys.js

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareTranslationFiles = exports.findMissingKeys = void 0;
 const findMissingKeys = (source, targets) => {
-    let differences = {};
+    const differences = {};
     for (const [lang, file] of Object.entries(targets)) {
         const result = (0, exports.compareTranslationFiles)(source, file);
         if (result.length > 0) {
-            differences = Object.assign(differences, { [lang]: result });
+            differences[lang] = result;
         }
     }
     return differences;
 };
 exports.findMissingKeys = findMissingKeys;
 const compareTranslationFiles = (a, b) => {
-    let diffs = [];
+    const diffs = [];
     for (const key in a) {
         const counterKey = b[key];
         if (!counterKey) {

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,13 +12,13 @@ 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 = []) => {
-    let result = {};
+    const result = {};
     if (!entry) {
         return 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);
     });
 });