@uxf/scripts 11.99.0 → 11.105.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.99.0",
+    "version": "11.105.0",
     "description": "",
     "main": "index.js",
     "bin": {

package/src/uxf-audit/manager/yarn-1.test.js

@@ -0,0 +1,46 @@
+jest.mock("../utils/json-exec");
+
+const { executeJson } = require("../utils/json-exec");
+const { Yarn1 } = require("./yarn-1");
+
+describe("Yarn1.uxfPackagesInfo", () => {
+    it("parses yarn v1 tree output into a package map", async () => {
+        executeJson.mockResolvedValue([
+            {
+                data: {
+                    trees: [
+                        { name: "@uxf/ui@1.0.0", children: [] },
+                        { name: "@uxf/form@2.0.0", children: [{ name: "react@17" }] },
+                    ],
+                },
+            },
+        ]);
+
+        const result = await Yarn1.uxfPackagesInfo();
+
+        expect(result["@uxf/ui"]).toEqual({ name: "@uxf/ui", version: "1.0.0", isError: false });
+        expect(result["@uxf/form"]).toEqual({ name: "@uxf/form", version: "2.0.0", isError: true });
+    });
+
+    it("marks packages with children as errors", async () => {
+        executeJson.mockResolvedValue([
+            {
+                data: {
+                    trees: [{ name: "@uxf/cms@3.1.0", children: [{ name: "dep@1.0" }] }],
+                },
+            },
+        ]);
+
+        const result = await Yarn1.uxfPackagesInfo();
+        expect(result["@uxf/cms"].isError).toBe(true);
+    });
+});
+
+describe("Yarn1.packageVersion", () => {
+    it("returns the version of a given package", async () => {
+        executeJson.mockResolvedValue([{ data: { trees: [{ name: "react@17.0.2" }] } }]);
+
+        const version = await Yarn1.packageVersion("react");
+        expect(version).toBe("17.0.2");
+    });
+});

package/src/uxf-audit/manager/yarn-4.test.js

@@ -0,0 +1,31 @@
+jest.mock("../utils/json-exec");
+
+const { executeJson } = require("../utils/json-exec");
+const { Yarn4 } = require("./yarn-4");
+
+describe("Yarn4.uxfPackagesInfo", () => {
+    it("parses yarn v4 JSON output into a package map", async () => {
+        executeJson.mockResolvedValue([{ value: "@uxf/ui@npm:1.0.0" }, { value: "@uxf/form@npm:2.0.0" }]);
+
+        const result = await Yarn4.uxfPackagesInfo();
+
+        expect(result["@uxf/ui"]).toEqual({ name: "@uxf/ui", version: "1.0.0", isError: false });
+        expect(result["@uxf/form"]).toEqual({ name: "@uxf/form", version: "2.0.0", isError: false });
+    });
+
+    it("marks duplicated packages as errors", async () => {
+        executeJson.mockResolvedValue([{ value: "@uxf/ui@npm:1.0.0" }, { value: "@uxf/ui@npm:1.1.0" }]);
+
+        const result = await Yarn4.uxfPackagesInfo();
+        expect(result["@uxf/ui"].isError).toBe(true);
+    });
+});
+
+describe("Yarn4.packageVersion", () => {
+    it("returns the version of a given package", async () => {
+        executeJson.mockResolvedValue([{ value: "next@npm:14.2.0" }]);
+
+        const version = await Yarn4.packageVersion("next");
+        expect(version).toBe("14.2.0");
+    });
+});

package/src/uxf-audit/utils/json-exec.test.js

@@ -0,0 +1,32 @@
+jest.mock("child_process");
+
+const { exec } = require("child_process");
+const { execute, executeJson } = require("./json-exec");
+
+describe("execute", () => {
+    it("resolves with stdout", async () => {
+        exec.mockImplementation((_cmd, cb) => cb(null, "hello world\n", ""));
+        const result = await execute("echo hello");
+        expect(result).toBe("hello world\n");
+    });
+
+    it("resolves with stdout even when there is an error", async () => {
+        exec.mockImplementation((_cmd, cb) => cb(new Error("fail"), "partial output", "stderr"));
+        const result = await execute("bad-command");
+        expect(result).toBe("partial output");
+    });
+});
+
+describe("executeJson", () => {
+    it("splits stdout by newline and parses each line as JSON", async () => {
+        exec.mockImplementation((_cmd, cb) => cb(null, '{"a":1}\n{"b":2}\n', ""));
+        const result = await executeJson("cmd");
+        expect(result).toEqual([{ a: 1 }, { b: 2 }]);
+    });
+
+    it("ignores empty lines", async () => {
+        exec.mockImplementation((_cmd, cb) => cb(null, '{"a":1}\n\n', ""));
+        const result = await executeJson("cmd");
+        expect(result).toEqual([{ a: 1 }]);
+    });
+});

package/src/uxf-audit/utils/parser.test.js

@@ -0,0 +1,19 @@
+const { parsePackageName } = require("./parser");
+
+describe("parsePackageName", () => {
+    it("parses unscoped package", () => {
+        expect(parsePackageName("react@17.0.2")).toEqual(["react", "17.0.2"]);
+    });
+
+    it("parses scoped package", () => {
+        expect(parsePackageName("@uxf/ui@1.2.3")).toEqual(["@uxf/ui", "1.2.3"]);
+    });
+
+    it("strips npm: prefix from unscoped version", () => {
+        expect(parsePackageName("lodash@npm:4.17.21")).toEqual(["lodash", "4.17.21"]);
+    });
+
+    it("strips npm: prefix from scoped version", () => {
+        expect(parsePackageName("@uxf/form@npm:2.0.0")).toEqual(["@uxf/form", "2.0.0"]);
+    });
+});

package/src/uxf-dependencies-check/index.js

@@ -101,5 +101,6 @@ async function checkUxfDependencies(excludedPackages = new Set()) {
 module.exports = {
     findUxfPackagesInDependencies,
     collectDirectDependencies,
+    checkMultipleVersions,
     checkUxfDependencies,
 };

package/src/uxf-dependencies-check/uxf-dependencies-check.test.js

@@ -1,4 +1,4 @@
-const { findUxfPackagesInDependencies, collectDirectDependencies } = require("./index"); // Adjust the path if needed
+const { findUxfPackagesInDependencies, collectDirectDependencies, checkMultipleVersions } = require("./index"); // Adjust the path if needed
 
 describe("findUxfPackagesInDependencies", () => {
     const lockData = {
@@ -72,3 +72,40 @@ describe("collectDirectDependencies", () => {
         expect(result).toEqual({});
     });
 });
+
+describe("checkMultipleVersions", () => {
+    it("returns empty array when all packages have a single version", () => {
+        const deps = {
+            react: new Set(["17.0.2"]),
+            lodash: new Set(["4.17.21"]),
+        };
+        expect(checkMultipleVersions(deps)).toEqual([]);
+    });
+
+    it("returns conflicts when a package has multiple versions", () => {
+        const deps = {
+            react: new Set(["17.0.2", "18.0.0"]),
+            lodash: new Set(["4.17.21"]),
+        };
+        const conflicts = checkMultipleVersions(deps);
+        expect(conflicts).toHaveLength(1);
+        expect(conflicts[0].name).toBe("react");
+        expect(conflicts[0].versions).toEqual(expect.arrayContaining(["17.0.2", "18.0.0"]));
+    });
+
+    it("excludes packages that are in the excludedPackages set", () => {
+        const deps = {
+            react: new Set(["17.0.2", "18.0.0"]),
+        };
+        const result = checkMultipleVersions(deps, new Set(["react"]));
+        expect(result).toEqual([]);
+    });
+
+    it("returns multiple conflicts when several packages have version mismatches", () => {
+        const deps = {
+            react: new Set(["17.0.2", "18.0.0"]),
+            lodash: new Set(["4.17.0", "4.17.21"]),
+        };
+        expect(checkMultipleVersions(deps)).toHaveLength(2);
+    });
+});

package/src/uxf-i18n-namespaces-gen/index.js

@@ -334,9 +334,18 @@ async function main(include, output, defaultNamespaces, pagesDirectory) {
         }
     }
 
+    if (result["/_app"]) {
+        result["*"] = Array.from(new Set([...result["*"], ...result["/_app"]])).sort();
+        delete result["/_app"];
+    }
+
     writeFileSync(path.resolve(process.cwd(), output), JSON.stringify(result, null, 4));
 
     console.log("Namespaces generated!");
 }
 
 module.exports = main;
+module.exports.isAllowedFile = isAllowedFile;
+module.exports.removeTrailingSlash = removeTrailingSlash;
+module.exports.filePathToRoute = filePathToRoute;
+module.exports.findNamespaces = findNamespaces;

package/src/uxf-i18n-namespaces-gen/index.test.js

@@ -0,0 +1,86 @@
+/** @jest-environment node */
+const { isAllowedFile, removeTrailingSlash, filePathToRoute, findNamespaces } = require("./index");
+
+describe("isAllowedFile", () => {
+    it("allows .ts files outside node_modules", () => {
+        expect(isAllowedFile("src/components/Button.ts")).toBe(true);
+    });
+
+    it("allows .tsx files outside node_modules", () => {
+        expect(isAllowedFile("src/pages/index.tsx")).toBe(true);
+    });
+
+    it("allows files inside node_modules/@uxf/", () => {
+        expect(isAllowedFile("node_modules/@uxf/ui/src/Button.tsx")).toBe(true);
+    });
+
+    it("blocks files inside other node_modules packages", () => {
+        expect(isAllowedFile("node_modules/react/index.js")).toBe(false);
+    });
+
+    it("blocks non-text extensions like .png", () => {
+        expect(isAllowedFile("src/assets/logo.png")).toBe(false);
+    });
+
+    it("blocks .css files", () => {
+        expect(isAllowedFile("src/styles/globals.css")).toBe(false);
+    });
+});
+
+describe("removeTrailingSlash", () => {
+    it("removes trailing slash", () => {
+        expect(removeTrailingSlash("/foo/bar/")).toBe("/foo/bar");
+    });
+
+    it("leaves string without trailing slash unchanged", () => {
+        expect(removeTrailingSlash("/foo/bar")).toBe("/foo/bar");
+    });
+
+    it("returns empty string for single slash", () => {
+        expect(removeTrailingSlash("/")).toBe("");
+    });
+});
+
+describe("filePathToRoute", () => {
+    it("converts index page to /", () => {
+        expect(filePathToRoute("src/pages/index.tsx")).toBe("/");
+    });
+
+    it("converts top-level page to /page-name", () => {
+        expect(filePathToRoute("src/pages/about.tsx")).toBe("/about");
+    });
+
+    it("converts nested index to /directory (no trailing slash)", () => {
+        expect(filePathToRoute("src/pages/blog/index.tsx")).toBe("/blog");
+    });
+
+    it("converts nested page to /directory/page", () => {
+        expect(filePathToRoute("src/pages/blog/post.tsx")).toBe("/blog/post");
+    });
+});
+
+describe("findNamespaces", () => {
+    it("finds namespaces from both t() and Trans components", () => {
+        const content = `
+            <Trans i18nKey="auth:login.title" />
+            {t("common:button.save")}
+        `;
+        const namespaces = findNamespaces(content);
+        expect(namespaces).toContain("auth");
+        expect(namespaces).toContain("common");
+    });
+
+    it("deduplicates namespaces", () => {
+        const content = `
+            {t("common:title")}
+            {t("common:subtitle")}
+        `;
+        const namespaces = findNamespaces(content);
+        expect(namespaces.filter((ns) => ns === "common")).toHaveLength(1);
+    });
+
+    it("returns empty array when no translation calls present", () => {
+        const content = `<div>Hello world</div>`;
+        expect(findNamespaces(content)).toEqual([]);
+    });
+});

package/src/uxf-release/index.js

@@ -121,3 +121,10 @@ module.exports = async function (config) {
 
     await GitLab.createRelease(fullReleaseNotes, config.tagPrefix, config.dryRun);
 };
+
+module.exports.generateSlackCommitMessage = generateSlackCommitMessage;
+module.exports.generateSlackMessage = generateSlackMessage;
+module.exports.generateGoogleCommitMessage = generateGoogleCommitMessage;
+module.exports.generateGoogleMessage = generateGoogleMessage;
+module.exports.generateReleaseCommitMessage = generateReleaseCommitMessage;
+module.exports.generateMigrationWarning = generateMigrationWarning;

package/src/uxf-release/index.test.js

@@ -0,0 +1,110 @@
+const {
+    generateSlackCommitMessage,
+    generateSlackMessage,
+    generateGoogleCommitMessage,
+    generateGoogleMessage,
+    generateReleaseCommitMessage,
+    generateMigrationWarning,
+} = require("./index");
+
+const baseCommit = {
+    title: "fix(bo): [KLK-123] fix the bug",
+    short_id: "abc1234",
+    web_url: "https://gitlab.com/commit/abc1234",
+    author_email: "dev@example.com",
+};
+
+describe("generateMigrationWarning", () => {
+    it("returns empty string for empty array", () => {
+        expect(generateMigrationWarning([])).toBe("");
+    });
+
+    it("returns empty string when called with no args", () => {
+        expect(generateMigrationWarning()).toBe("");
+    });
+
+    it("returns warning text with listed files", () => {
+        const result = generateMigrationWarning(["V1__init.sql", "V2__add_column.sql"]);
+        expect(result).toContain("VAROVÁNÍ");
+        expect(result).toContain("- V1__init.sql");
+        expect(result).toContain("- V2__add_column.sql");
+    });
+});
+
+describe("generateSlackCommitMessage", () => {
+    it("formats commit with type using uppercase type label", () => {
+        const result = generateSlackCommitMessage(baseCommit);
+        expect(result).toContain("_FIX_");
+        expect(result).toContain("fix the bug");
+        expect(result).toContain("abc1234");
+        expect(result).toContain("dev@example.com");
+    });
+
+    it("falls back to plain title when commit format is unrecognized", () => {
+        const commit = { ...baseCommit, title: "bump dependencies" };
+        const result = generateSlackCommitMessage(commit);
+        expect(result).toContain("bump dependencies");
+        expect(result).not.toContain("_");
+    });
+});
+
+describe("generateGoogleCommitMessage", () => {
+    it("formats commit with type, message, and youtrack issue link", () => {
+        const result = generateGoogleCommitMessage(baseCommit);
+        expect(result).toContain("_FIX_");
+        expect(result).toContain("fix the bug");
+        expect(result).toContain("youtrack.uxf.dev/issue/KLK-123");
+    });
+
+    it("falls back to plain title when format is unrecognized", () => {
+        const commit = { ...baseCommit, title: "bump dependencies" };
+        const result = generateGoogleCommitMessage(commit);
+        expect(result).toMatch(/^\* bump dependencies/);
+    });
+
+    it("omits type prefix when type is null (bracket-only format)", () => {
+        const commit = { ...baseCommit, title: "[KLK-456] standalone issue" };
+        const result = generateGoogleCommitMessage(commit);
+        expect(result).toContain("standalone issue");
+        expect(result).not.toContain("_NULL_");
+    });
+});
+
+describe("generateReleaseCommitMessage", () => {
+    it("formats commit with bold type for release notes (markdown)", () => {
+        const result = generateReleaseCommitMessage(baseCommit);
+        expect(result).toContain("**FIX**");
+        expect(result).toContain("fix the bug");
+        expect(result).toMatch(/^-/);
+    });
+
+    it("uses markdown link format for issue and commit", () => {
+        const result = generateReleaseCommitMessage(baseCommit);
+        expect(result).toContain("[abc1234](https://gitlab.com/commit/abc1234)");
+        expect(result).toContain("[KLK-123](https://youtrack.uxf.dev/issue/KLK-123)");
+    });
+
+    it("falls back to plain title for unrecognized format", () => {
+        const commit = { ...baseCommit, title: "bump dependencies" };
+        const result = generateReleaseCommitMessage(commit);
+        expect(result).toMatch(/^- bump dependencies/);
+    });
+});
+
+describe("generateSlackMessage", () => {
+    it("includes message title and formatted commits", () => {
+        const commits = [baseCommit];
+        const result = generateSlackMessage(commits, "Release v1.0.0");
+        expect(result.text).toContain("Release v1.0.0");
+        expect(result.text).toContain("_FIX_");
+    });
+});
+
+describe("generateGoogleMessage", () => {
+    it("includes message title and formatted commits", () => {
+        const commits = [baseCommit];
+        const result = generateGoogleMessage(commits, "Release v1.0.0");
+        expect(result.text).toContain("Release v1.0.0");
+        expect(result.text).toContain("_FIX_");
+    });
+});

package/src/uxf-sitemap-check/index.js

@@ -660,3 +660,12 @@ module.exports = async function run(sitemapUrl, skip, withNested, withImages, ch
         process.exit(1);
     }
 };
+
+module.exports.createTabSpace = createTabSpace;
+module.exports.isImageUrl = isImageUrl;
+module.exports.validURL = validURL;
+module.exports.convertTime = convertTime;
+module.exports.createErrorList = createErrorList;
+module.exports.createErrorResult = createErrorResult;
+module.exports.createSkippedResult = createSkippedResult;
+module.exports.getUrlOrigin = getUrlOrigin;

package/src/uxf-sitemap-check/index.test.js

@@ -0,0 +1,148 @@
+/**
+ * @jest-environment node
+ */
+
+jest.mock("../Sitemap");
+jest.mock("../GoogleChat");
+jest.mock("cheerio");
+jest.mock("got");
+jest.mock("robots-txt-parser", () => () => ({ useRobotsFor: jest.fn(), canCrawl: jest.fn() }));
+
+const {
+    createTabSpace,
+    isImageUrl,
+    validURL,
+    convertTime,
+    createErrorList,
+    createErrorResult,
+    createSkippedResult,
+    getUrlOrigin,
+} = require("./index");
+
+describe("createTabSpace", () => {
+    it("returns 2 spaces by default", () => {
+        expect(createTabSpace()).toBe("  ");
+    });
+
+    it("returns 4 spaces for length 2", () => {
+        expect(createTabSpace(2)).toBe("    ");
+    });
+
+    it("returns 6 spaces for length 3", () => {
+        expect(createTabSpace(3)).toBe("      ");
+    });
+});
+
+describe("isImageUrl", () => {
+    it.each([".jpg", ".png", ".webp", ".avif", ".gif"])("returns true for %s extension", (ext) => {
+        expect(isImageUrl(`https://example.com/photo${ext}`)).toBe(true);
+    });
+
+    it("returns false for html pages", () => {
+        expect(isImageUrl("https://example.com/page.html")).toBe(false);
+    });
+
+    it("returns false for URLs with no extension", () => {
+        expect(isImageUrl("https://example.com/page")).toBe(false);
+    });
+});
+
+describe("validURL", () => {
+    it("returns true for a valid URL", () => {
+        expect(validURL("https://example.com/path")).toBe(true);
+    });
+
+    it("returns false for a plain string", () => {
+        expect(validURL("not-a-url")).toBe(false);
+    });
+
+    it("returns false for empty string", () => {
+        expect(validURL("")).toBe(false);
+    });
+});
+
+describe("convertTime", () => {
+    it("converts 0 ms to 0 min 00 sec", () => {
+        expect(convertTime(0)).toBe("0 min 00 sec");
+    });
+
+    it("converts 90000 ms to 1 min 30 sec", () => {
+        expect(convertTime(90000)).toBe("1 min 30 sec");
+    });
+
+    it("pads seconds below 10 with leading zero", () => {
+        expect(convertTime(65000)).toBe("1 min 05 sec");
+    });
+
+    it("converts 3600000 ms to 60 min 00 sec", () => {
+        expect(convertTime(3600000)).toBe("60 min 00 sec");
+    });
+});
+
+describe("getUrlOrigin", () => {
+    it("returns origin of a regular URL", () => {
+        expect(getUrlOrigin("https://example.com/some/path")).toBe("https://example.com");
+    });
+
+    it("replaces fb.me hostname with facebook.com", () => {
+        expect(getUrlOrigin("https://fb.me/some-post")).toBe("https://facebook.com");
+    });
+});
+
+describe("createErrorList", () => {
+    it("formats a list of errors with url, status, and optional message", () => {
+        const errors = [
+            { url: "https://example.com/broken", status: 404, message: "Not Found" },
+            { url: "https://example.com/other", status: 500, message: undefined },
+        ];
+        const result = createErrorList(errors);
+        expect(result).toContain("https://example.com/broken");
+        expect(result).toContain("404");
+        expect(result).toContain("– Not Found");
+        expect(result).toContain("https://example.com/other");
+        expect(result).toContain("500");
+        expect(result).not.toContain("undefined");
+    });
+});
+
+describe("createErrorResult", () => {
+    it("separates errors from sitemap pages vs nested pages", () => {
+        const errors = [
+            { url: "https://example.com/page1", parentUrl: undefined, status: 404, message: undefined, isImg: false },
+            {
+                url: "https://example.com/img.jpg",
+                parentUrl: "https://example.com/page2",
+                status: 404,
+                message: undefined,
+                isImg: true,
+            },
+        ];
+        const result = createErrorResult(errors);
+        expect(result).toContain("Pages from sitemap");
+        expect(result).toContain("Nested pages");
+        expect(result).toContain("https://example.com/page1");
+    });
+
+    it("returns empty string when no errors", () => {
+        expect(createErrorResult([])).toBe("");
+    });
+});
+
+describe("createSkippedResult", () => {
+    it("returns empty string for empty list", () => {
+        expect(createSkippedResult([])).toBe("");
+    });
+
+    it("returns unique origins of skipped URLs", () => {
+        const skipped = [
+            { url: "https://twitter.com/post1" },
+            { url: "https://twitter.com/post2" },
+            { url: "https://linkedin.com/profile" },
+        ];
+        const result = createSkippedResult(skipped);
+        expect(result).toContain("https://twitter.com");
+        expect(result).toContain("https://linkedin.com");
+        // twitter appears only once despite two URLs
+        expect(result.split("https://twitter.com")).toHaveLength(2);
+    });
+});