@gooddata/i18n-toolkit 11.54.0-alpha.4 → 11.54.0-alpha.5

package/esm/validations/checkTranslations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkTranslations.test.d.ts.map

package/esm/validations/checkTranslations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkTranslations.test.d.ts","sourceRoot":"","sources":["../../src/validations/checkTranslations.test.ts"],"names":[],"mappings":""}

package/esm/validations/checkTranslations.test.js

@@ -0,0 +1,220 @@
+// (C) 2020-2026 GoodData Corporation
+import { describe, expect, it } from "vitest";
+import { checkTranslations } from "./usage/checkTranslations.js";
+describe("check translations", () => {
+    it("valid, extracted and loaded are same", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasic], [PatternAll], createExtracted(["ok.key", "fail.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(1);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 2,
+            loaded: 2,
+        });
+    });
+    it("invalid, only 1 extracted message, but loaded 2", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasic], [PatternAll], createExtracted(["ok.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(1);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 1,
+            loaded: 2,
+            unused: 1,
+            unusedMessages: ["fail.key"],
+        });
+    });
+    it("invalid, extracted 3 message, but loaded 2", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasic], [PatternAll], createExtracted(["ok.key", "fail.key", "fail.key1"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(1);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 3,
+            loaded: 2,
+            missing: 1,
+            missingMessages: ["fail.key1"],
+        });
+    });
+    it("valid with filtered, extracted and loaded are same", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore], [PatternOkAndFail_Filtered], createExtracted(["ok.key", "fail.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(1);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ok\\./,/^fail\\./",
+            extracted: 2,
+            loaded: 2,
+        });
+    });
+    it("valid with filtered, extracted and loaded are same and there is uncontrolled message", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore], [PatternOkAndFail_Filtered], createExtracted(["ok.key", "fail.key", "ignore.key1"]));
+        expect(uncontrolled).toEqual(["ignore.key1"]);
+        expect(results.length).toEqual(1);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ok\\./,/^fail\\./",
+            extracted: 2,
+            loaded: 2,
+        });
+    });
+    it("valid with filtered, extracted and loaded are same and there are ignored messages", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore], [PatternOkAndFail_Filtered, PatternIgnore], createExtracted(["ok.key", "fail.key", "ignored.key1"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(2);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ok\\./,/^fail\\./",
+            extracted: 2,
+            loaded: 2,
+        });
+        checkResults(results[1], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ignored\\./",
+            ignore: true,
+            extracted: 1,
+            loaded: 3,
+            ignored: 3,
+            ignoredMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+    });
+    it("valid, extracted and loaded are same and there are ignored messages", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore], [PatternAll, PatternIgnore], createExtracted(["ok.key", "fail.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(2);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 2,
+            loaded: 2,
+        });
+        checkResults(results[1], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ignored\\./",
+            ignore: true,
+            loaded: 3,
+            ignored: 3,
+            ignoredMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+    });
+    it("invalid, extracted more messages than loaded", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasic], [PatternAll, PatternIgnore], createExtracted(["ok.key", "fail.key", "ignored.key1", "ignored.key2", "ignored.key3"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(2);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 5,
+            loaded: 2,
+            missing: 3,
+            missingMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+        checkResults(results[1], {
+            files: ["defaults/en-US/test.json"],
+            identifier: "/^ignored\\./",
+            ignore: true,
+        });
+    });
+    it("valid, extracted and loaded are same because of ignored messages for all", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore, TestJsonBasicWithIgnore2], [PatternAll, PatternIgnore], createExtracted(["ok.key", "fail.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(2);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json", "extended/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 2,
+            loaded: 2,
+        });
+        checkResults(results[1], {
+            files: ["defaults/en-US/test.json", "extended/en-US/test.json"],
+            identifier: "/^ignored\\./",
+            ignore: true,
+            loaded: 3,
+            ignored: 3,
+            ignoredMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+    });
+    it("invalid, extracted and loaded are not same because of ignored messages for only extended/ directory", () => {
+        const { uncontrolled, results } = checkTranslations([TestJsonBasicWithIgnore, TestJsonBasicWithIgnore2], [PatternAll, PatternIgnoreOnlyExtended], createExtracted(["ok.key", "fail.key"]));
+        expect(uncontrolled).toEqual([]);
+        expect(results.length).toEqual(2);
+        checkResults(results[0], {
+            files: ["defaults/en-US/test.json", "extended/en-US/test.json"],
+            identifier: "/.+/",
+            extracted: 2,
+            loaded: 5,
+            unused: 3,
+            unusedMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+        checkResults(results[1], {
+            files: ["extended/en-US/test.json"],
+            identifier: "/^ignored\\./",
+            ignore: true,
+            loaded: 3,
+            ignored: 3,
+            ignoredMessages: ["ignored.key1", "ignored.key2", "ignored.key3"],
+        });
+    });
+});
+function checkResults(result, { files, identifier, missingMessages = [], unusedMessages = [], ignoredMessages = [], ignore = undefined, loaded = 0, missing = 0, extracted = 0, unused = 0, ignored = 0, }) {
+    expect(result.data.missingMessages).toEqual(missingMessages);
+    expect(result.data.unusedMessages).toEqual(unusedMessages);
+    expect(result.data.ignoredMessages).toEqual(ignoredMessages);
+    expect(result.files).toEqual(files);
+    expect(result.identifier).toEqual(identifier);
+    expect(result.ignore).toEqual(ignore);
+    expect(result.stats.extracted).toBe(extracted);
+    expect(result.stats.loaded).toBe(loaded);
+    expect(result.stats.missing).toBe(missing);
+    expect(result.stats.unused).toBe(unused);
+    expect(result.stats.ignored).toBe(ignored);
+}
+function createExtracted(arr) {
+    return arr.reduce((prev, item) => ({ ...prev, [item]: true }), {});
+}
+//FILES
+const TestJsonBasic = [
+    "defaults/en-US/test.json",
+    {
+        "ok.key": { text: "OK", crowdinContext: "" },
+        "fail.key": { text: "FAIL", crowdinContext: "" },
+    },
+];
+const TestJsonBasicWithIgnore = [
+    "defaults/en-US/test.json",
+    {
+        ...TestJsonBasic[1],
+        "ignored.key1": { text: "Ignore1", crowdinContext: "" },
+        "ignored.key2": { text: "Ignore2", crowdinContext: "" },
+        "ignored.key3": { text: "Ignore3", crowdinContext: "" },
+    },
+];
+const TestJsonBasicWithIgnore2 = [
+    "extended/en-US/test.json",
+    {
+        ...TestJsonBasic[1],
+        "ignored.key1": { text: "Ignore1", crowdinContext: "" },
+        "ignored.key2": { text: "Ignore2", crowdinContext: "" },
+        "ignored.key3": { text: "Ignore3", crowdinContext: "" },
+    },
+];
+//PATTERNS
+const PatternAll = {
+    pattern: [/.+/],
+};
+const PatternOkAndFail_Filtered = {
+    pattern: [/^ok\./, /^fail\./],
+    filterTranslationFile: true,
+};
+const PatternIgnore = {
+    pattern: [/^ignored\./],
+    ignore: true,
+};
+const PatternIgnoreOnlyExtended = {
+    dir: /^extended/,
+    pattern: [/^ignored\./],
+    ignore: true,
+};

package/esm/validations/htmlSyntax.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=htmlSyntax.test.d.ts.map

package/esm/validations/htmlSyntax.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlSyntax.test.d.ts","sourceRoot":"","sources":["../../src/validations/htmlSyntax.test.ts"],"names":[],"mappings":""}

package/esm/validations/htmlSyntax.test.js

@@ -0,0 +1,34 @@
+// (C) 2020-2026 GoodData Corporation
+import { describe, expect, it } from "vitest";
+import { suppressConsole } from "@gooddata/util";
+import { getHtmlSyntaxCheck } from "./htmlSyntax.js";
+function createLocalizations(value, key = "test.key", file = "test.json") {
+    return [[file, { [key]: value }]];
+}
+describe("validate html message tests", () => {
+    const scenarios = [
+        ["simple text", "This is message", null],
+        ["simple html", "This is <b>message</b>", null],
+        [
+            "simple invalid html non sense",
+            "This is <bmessage</b>",
+            `Html format of localizations is not correct`,
+        ],
+    ];
+    it.each(scenarios)("validate %s", async (_, msg, err) => {
+        if (err) {
+            await expect(suppressConsole(() => getHtmlSyntaxCheck(createLocalizations(msg)), "error", [
+                { type: "startsWith", value: "✘" },
+            ])).rejects.toThrowError(err);
+        }
+        else {
+            await expect(getHtmlSyntaxCheck(createLocalizations(msg))).resolves.not.toThrow();
+        }
+    });
+    it("includes key and file in error message", async () => {
+        const localizations = createLocalizations("This is <bmessage</b>", "my.html.key", "/path/to/en-US.json");
+        await expect(suppressConsole(() => getHtmlSyntaxCheck(localizations), "error", [
+            { type: "startsWith", value: "✘" },
+        ])).rejects.toThrowError(/Key: "my\.html\.key"/);
+    });
+});

package/esm/validations/messageFormat.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messageFormat.test.d.ts.map

package/esm/validations/messageFormat.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageFormat.test.d.ts","sourceRoot":"","sources":["../../src/validations/messageFormat.test.ts"],"names":[],"mappings":""}

package/esm/validations/messageFormat.test.js

@@ -0,0 +1,64 @@
+// (C) 2020-2026 GoodData Corporation
+import { describe, expect, it } from "vitest";
+import { suppressConsole } from "@gooddata/util";
+import { getIntlMessageFormatCheck } from "./messageFormat.js";
+function createLocalizations(value, key = "test.key", file = "test.json") {
+    return [[file, { [key]: value }]];
+}
+describe("validate ICU message tests", () => {
+    const scenarios = [
+        ["simple text", "This is message", null],
+        ["simple text with marks", "This is <strong>message</strong>", null],
+        ["simple text with ICU", "The is {count} {count, plural, one {one} other {mores}}.", null],
+        [
+            "simple text with invalid ICU keyword",
+            "The is {count} {count, plural, one {one} othr {mores}.",
+            `Intl format of localizations is not correct`,
+        ],
+        [
+            "simple text with invalid ICU }",
+            "The is {count} {count, plural, one {one} other {mores}.",
+            `Intl format of localizations is not correct`,
+        ],
+    ];
+    it.each(scenarios)("validate %s", async (_, msg, err) => {
+        if (err) {
+            await expect(suppressConsole(() => getIntlMessageFormatCheck(createLocalizations(msg)), "error", [
+                {
+                    type: "startsWith",
+                    value: "✘",
+                },
+            ])).rejects.toThrowError(err);
+        }
+        else {
+            await expect(getIntlMessageFormatCheck(createLocalizations(msg))).resolves.not.toThrow();
+        }
+    });
+    it("includes key and file in error message", async () => {
+        const localizations = createLocalizations("The is {count} {count, plural, one {one} othr {mores}.", "my.translation.key", "/path/to/en-US.json");
+        await expect(suppressConsole(() => getIntlMessageFormatCheck(localizations), "error", [
+            {
+                type: "startsWith",
+                value: "✘",
+            },
+        ])).rejects.toThrowError(/Key: "my\.translation\.key"/);
+    });
+    it("collects all errors before throwing", async () => {
+        const localizations = [
+            [
+                "en-US.json",
+                {
+                    "error.one": "Invalid {count, plural, one {one} othr {mores}.",
+                    "valid.key": "This is valid",
+                    "error.two": "Another invalid {missing",
+                },
+            ],
+        ];
+        await expect(suppressConsole(() => getIntlMessageFormatCheck(localizations), "error", [
+            {
+                type: "startsWith",
+                value: "✘",
+            },
+        ])).rejects.toThrowError(/error\.one[\s\S]*error\.two/);
+    });
+});

package/esm/validations/structure.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=structure.test.d.ts.map

package/esm/validations/structure.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure.test.d.ts","sourceRoot":"","sources":["../../src/validations/structure.test.ts"],"names":[],"mappings":""}

package/esm/validations/structure.test.js

@@ -0,0 +1,78 @@
+// (C) 2020-2026 GoodData Corporation
+import { describe, expect, it } from "vitest";
+import { suppressConsole } from "@gooddata/util";
+import { getStructureCheck } from "./structure.js";
+describe("validate structure tests", () => {
+    const scenarios = [
+        [
+            "basic format with required only",
+            { "message.id": { text: "This is value", crowdinContext: "This is comment" } },
+            null,
+        ],
+        ["basic format with string", { "message.id": "This is value" }, null],
+        [
+            "basic format with all props",
+            {
+                "message.id": {
+                    text: "This is value",
+                    crowdinContext: "This is comment",
+                    translate: false,
+                },
+            },
+            null,
+        ],
+        [
+            "basic format with more props",
+            {
+                "message.id": {
+                    text: "This is value",
+                    crowdinContext: "This is comment",
+                    translate: false,
+                    limit: 2,
+                },
+            },
+            `Structure of localizations is not correct`,
+        ],
+        [
+            "basic format with missing comment",
+            {
+                "message.id": {
+                    text: "This is value",
+                },
+            },
+            `Structure of localizations is not correct`,
+        ],
+        [
+            "basic format with missing value",
+            {
+                "message.id": {
+                    crowdinContext: "",
+                },
+            },
+            `Structure of localizations is not correct`,
+        ],
+    ];
+    it.each(scenarios)("validate %s", async (_, structure, err) => {
+        if (err) {
+            await expect(suppressConsole(() => getStructureCheck([["en-US.json", structure]]), "error", [
+                {
+                    type: "startsWith",
+                    value: "✘",
+                },
+            ])).rejects.toThrowError(err);
+        }
+        else {
+            await expect(getStructureCheck([["en-US.json", structure]])).resolves.not.toThrow();
+        }
+    });
+    it("includes file in error message", async () => {
+        const structure = {
+            "message.id": {
+                text: "This is value",
+            },
+        };
+        await expect(suppressConsole(() => getStructureCheck([["/path/to/en-US.json", structure]]), "error", [
+            { type: "startsWith", value: "✘" },
+        ])).rejects.toThrowError(/File: \/path\/to\/en-US\.json/);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/i18n-toolkit",
-  "version": "11.54.0-alpha.4",
+  "version": "11.54.0-alpha.5",
   "description": "Localization validator to validate localization complexity and intl and html format.",
   "license": "MIT",
   "author": "GoodData",
@@ -34,7 +34,7 @@
     "lodash-es": "^4.17.23",
     "tslib": "2.8.1",
     "util": "^0.12.3",
-    "@gooddata/util": "11.54.0-alpha.4"
+    "@gooddata/util": "11.54.0-alpha.5"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
@@ -59,8 +59,8 @@
     "oxlint-tsgolint": "0.15.0",
     "typescript": "5.9.3",
     "vitest": "4.1.8",
-    "@gooddata/eslint-config": "11.54.0-alpha.4",
-    "@gooddata/oxlint-config": "11.54.0-alpha.4"
+    "@gooddata/oxlint-config": "11.54.0-alpha.5",
+    "@gooddata/eslint-config": "11.54.0-alpha.5"
   },
   "scripts": {
     "_phase:build": "npm run build",