@uxf/scripts 11.123.0 → 11.124.0

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const madge = require("madge");
+const buildDependencyTree = require("./dependency-tree");
 const path = require("path");
 const { readFileSync, readdirSync, writeFileSync, statSync, existsSync } = require("fs");
 const { findTFunctionNamespaces } = require("./utils/find-t-function-namespaces");
@@ -8,7 +8,8 @@ const join = require("node:path").join;
 
 const UXF_PACKAGES_PATH = "node_modules/@uxf";
 const FILE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "tsx", "d.ts", "mts", "cts", "d.mts", "d.cts"];
-const TEXT_FILE_EXTENSIONS = new Set(FILE_EXTENSIONS.map((e) => (e.startsWith(".") ? e : "." + e)));
+const DOTTED_FILE_EXTENSIONS = FILE_EXTENSIONS.map((e) => (e.startsWith(".") ? e : "." + e));
+const TEXT_FILE_EXTENSIONS = new Set(DOTTED_FILE_EXTENSIONS);
 const TS_CONFIG_PATH = path.resolve(process.cwd(), "tsconfig.json");
 const TS_CONFIG = existsSync(TS_CONFIG_PATH) ? TS_CONFIG_PATH : undefined;
 
@@ -44,6 +45,38 @@ function isAllowedFile(file) {
     return !file.includes("node_modules") || file.includes(UXF_PACKAGES_PATH);
 }
 
+/**
+ * Resolve an extension-less path the way TypeScript would: as a file with one of the known
+ * extensions appended, or as a directory holding an index file.
+ * @param {string} basePath
+ * @returns {string | undefined}
+ */
+function resolveFileCandidate(basePath) {
+    for (const extension of DOTTED_FILE_EXTENSIONS) {
+        const candidate = basePath + extension;
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+
+    if (existsSync(basePath)) {
+        if (statSync(basePath).isFile()) {
+            return basePath;
+        }
+
+        for (const extension of DOTTED_FILE_EXTENSIONS) {
+            const candidate = path.join(basePath, "index" + extension);
+
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+
+    return undefined;
+}
+
 /**
  * Resolve a module specifier (bare, relative, or absolute) to a real filesystem path if possible.
  * Falls back to the original specifier when not resolvable.
@@ -71,13 +104,9 @@ function resolveModuleSpecifier(spec) {
                         for (const target of targets) {
                             const mapped = target.includes("*") ? target.replace("*", middle) : target;
 
-                            const candidates = [
-                                path.resolve(ts.baseUrl, mapped),
-                                ...FILE_EXTENSIONS.map((e) => path.resolve(ts.baseUrl, mapped + e)),
-                                ...FILE_EXTENSIONS.map((e) => path.join(ts.baseUrl, mapped, "index" + e)),
-                            ].find(existsSync);
+                            const candidate = resolveFileCandidate(path.resolve(ts.baseUrl, mapped));
 
-                            if (candidates) return candidates;
+                            if (candidate) return candidate;
                         }
                     }
                 } else if (spec === pattern) {
@@ -87,8 +116,19 @@ function resolveModuleSpecifier(spec) {
             }
         }
 
-        const resolved = require.resolve(spec, { paths: [process.cwd()] });
-        return isAllowedFile(resolved) ? resolved : spec;
+        try {
+            const resolved = require.resolve(spec, { paths: [process.cwd()] });
+            if (isAllowedFile(resolved)) return resolved;
+        } catch {
+            // not resolvable by Node — fall through to the TypeScript probe below
+        }
+
+        // Node's resolver only knows .js, so packages published (or symlinked by a workspace) as
+        // TypeScript source are invisible to it. Probe node_modules directly for those.
+        const candidate = resolveFileCandidate(path.resolve(process.cwd(), "node_modules", spec));
+        if (candidate && isAllowedFile(candidate)) return candidate;
+
+        return spec;
     } catch {
         return spec;
     }
@@ -107,20 +147,9 @@ function resolveImportFrom(spec, fromFile) {
         // Relative path from the file's directory
         if (spec.startsWith(".")) {
             const baseDir = path.dirname(fromFile);
-            let candidate = path.resolve(baseDir, spec);
 
-            // Try as file
-            for (const e of FILE_EXTENSIONS) {
-                const c = candidate + e;
-                if (existsSync(c)) return c;
-            }
-            // Try as directory index
-            if (existsSync(candidate) && statSync(candidate).isDirectory()) {
-                for (const e of FILE_EXTENSIONS) {
-                    const idx = path.join(candidate, "index" + e);
-                    if (existsSync(idx)) return idx;
-                }
-            }
+            const candidate = resolveFileCandidate(path.resolve(baseDir, spec));
+            if (candidate) return candidate;
 
             // Fallback to Node resolver with file dir as base
             const resolved = require.resolve(spec, { paths: [baseDir] });
@@ -191,26 +220,14 @@ const filePathToRoute = (filePath) => {
     return removeTrailingSlash(route);
 };
 
-async function getMadgeTree(entries, include) {
-    // Build madge options; allow traversing UXF packages in node_modules.
-    const options = {
+function getDependencyTree(cwd, include) {
+    // Only project files come from here — imports of node_modules/@uxf are handed over as raw
+    // specifiers and resolved by getFiles() below.
+    return buildDependencyTree(cwd, {
         tsConfig: TS_CONFIG,
         fileExtensions: FILE_EXTENSIONS,
-        includeNpm: true,
-        dependencyFilter: (dependency) => {
-            return !dependency.includes("node_modules") || dependency.includes(UXF_PACKAGES_PATH);
-        },
-    };
-
-    // If include is provided, limit traversal to those prefixes AND node_modules/@uxf.
-    if (Array.isArray(include) && include.length > 0) {
-        const allowedPrefixes = [...include, UXF_PACKAGES_PATH];
-        const searchDirs = new RegExp(`^(?!(${allowedPrefixes.join("|")}))`, "i");
-        options.excludeRegExp = [searchDirs];
-    }
-
-    const res = await madge(entries, options);
-    return res.obj();
+        include,
+    });
 }
 
 async function getFiles(entryPoint, tree) {
@@ -243,7 +260,7 @@ async function getFiles(entryPoint, tree) {
     const queue = [];
     const visited = new Set();
 
-    // Seed queue with initial files from madge tree
+    // Seed queue with initial files from the dependency tree
     for (const file of flattenFilesOnPath) {
         if (file && typeof file === "string") {
             const fsPath = resolveModuleSpecifier(file);
@@ -302,8 +319,8 @@ async function main(include, output, defaultNamespaces, pagesDirectory) {
 
     const pages = walk(pagesDirectory).flat(Number.POSITIVE_INFINITY);
 
-    // Build a global dependency tree rooted at project to leverage madge resolution across aliases/packages
-    const tree = await getMadgeTree(process.cwd(), include);
+    // Build a global dependency tree rooted at project to leverage rev-dep resolution across aliases/packages
+    const tree = getDependencyTree(process.cwd(), include);
 
     for (const entryPoint of pages) {
         let namespaces = [];
@@ -346,6 +363,7 @@ async function main(include, output, defaultNamespaces, pagesDirectory) {
 
 module.exports = main;
 module.exports.isAllowedFile = isAllowedFile;
+module.exports.resolveFileCandidate = resolveFileCandidate;
 module.exports.removeTrailingSlash = removeTrailingSlash;
 module.exports.filePathToRoute = filePathToRoute;
 module.exports.findNamespaces = findNamespaces;

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

@@ -1,5 +1,36 @@
 /** @jest-environment node */
-const { isAllowedFile, removeTrailingSlash, filePathToRoute, findNamespaces } = require("./index");
+const path = require("path");
+const {
+    isAllowedFile,
+    removeTrailingSlash,
+    filePathToRoute,
+    findNamespaces,
+    resolveFileCandidate,
+} = require("./index");
+
+const FIXTURES = path.join(__dirname, "tests");
+
+describe("resolveFileCandidate", () => {
+    it("appends the extension to an extension-less path", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "utils"))).toBe(path.join(FIXTURES, "utils.tsx"));
+    });
+
+    it("resolves a directory to its index file", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "components/with-index-file"))).toBe(
+            path.join(FIXTURES, "components/with-index-file/index.ts"),
+        );
+    });
+
+    it("returns a path that already points at a file unchanged", () => {
+        const file = path.join(FIXTURES, "utils.tsx");
+
+        expect(resolveFileCandidate(file)).toBe(file);
+    });
+
+    it("returns undefined when nothing matches", () => {
+        expect(resolveFileCandidate(path.join(FIXTURES, "does-not-exist"))).toBeUndefined();
+    });
+});
 
 describe("isAllowedFile", () => {
     it("allows .ts files outside node_modules", () => {

package/src/uxf-merge-requests-notifier/cli.js

@@ -1,27 +1,24 @@
 const { argv, env } = require("process");
+const { hasFlag } = require("../cli-args");
 
 const AVAILABLE_VARIANTS = ["CR", "STALE"];
 
-module.exports = async () => {
-    const cli = require("yargs")()
-        .command("$0", "UXF merge requests notifier", (yargs) => {
-            yargs.demandCommand(0, 0).usage(`Usage:
+const USAGE = `Usage:
   uxf-merge-requests-notifier [options]
 
+Options:
+  -h, --help         zobrazí tuto nápovědu
+
 Environment variables:
   VARIANT            - optional - CR (default), STALE
   GITLAB_TOKEN       - required
   GOOGLE_WEBHOOK_URL - required
-  CI_SERVER_URL      - required - setting by GitLab CI`);
-        })
-        .option("h", { alias: "help", group: "Options" })
-        .strict(false)
-        .exitProcess(false);
+  CI_SERVER_URL      - required - setting by GitLab CI`;
 
+module.exports = async () => {
     try {
-        const { help, ...options } = cli.parse(argv.slice(2));
-
-        if (Boolean(help)) {
+        if (hasFlag(argv.slice(2), ["-h", "--help"])) {
+            console.log(USAGE);
             return 0;
         }
 

package/src/uxf-merge-requests-notifier/index.js

@@ -1,13 +1,42 @@
-const GitLab = require("../GitLab");
-const GoogleChat = require("../GoogleChat");
-const relativeTime = require("dayjs/plugin/relativeTime");
-const dayjs = require("dayjs");
-require("dayjs/locale/cs");
-dayjs.locale("cs");
-dayjs.extend(relativeTime);
+const GitLab = require("../gitlab");
+const GoogleChat = require("../google-chat");
 
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+
+// `numeric: "always"` drží číselný tvar ("před 2 dny") tak, jak ho dělal dayjs.
+// S "auto" by Intl střídalo slovní tvary ("předevčírem") jen pro některé hodnoty.
+const RELATIVE_TIME = new Intl.RelativeTimeFormat("cs", { numeric: "always" });
+
+/** @type {Array<[Intl.RelativeTimeFormatUnit, number]>} */
+const RELATIVE_TIME_UNITS = [
+    ["year", 365 * 86400],
+    ["month", 30 * 86400],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1],
+];
+
+/** Náhrada `dayjs(date).fromNow()` s českou lokalizací. */
+function fromNow(date) {
+    const diffInSeconds = (new Date(date).getTime() - Date.now()) / 1000;
+    const absolute = Math.abs(diffInSeconds);
+
+    for (const [unit, seconds] of RELATIVE_TIME_UNITS) {
+        if (absolute >= seconds || unit === "second") {
+            return RELATIVE_TIME.format(Math.round(diffInSeconds / seconds), unit);
+        }
+    }
+}
+
+/** Náhrada `dayjs().diff(date, "days")` — ořezává k nule stejně jako dayjs. */
+function daysSince(date) {
+    return Math.trunc((Date.now() - new Date(date).getTime()) / DAY_IN_MS);
+}
+
+/** Česká shoda čísla se jménem: 1 → word1, 2–4 → word2, jinak (včetně 0) → word3. */
 function inflect(value, word1, word2, word3) {
-    return `${value} ${value === 1 ? word1 : value <= 4 ? word2 : word3}`;
+    return `${value} ${value === 1 ? word1 : value > 1 && value <= 4 ? word2 : word3}`;
 }
 
 function mapMergeRequests(mrs, projects) {
@@ -52,7 +81,7 @@ module.exports = async function run(variant) {
             result = result.filter((mr) => mr.reviewers.length === 0);
             break;
         case "STALE":
-            result = result.filter((mr) => dayjs().diff(mr.updatedAt, "days") > 30);
+            result = result.filter((mr) => daysSince(mr.updatedAt) > 30);
             break;
     }
 
@@ -75,7 +104,7 @@ module.exports = async function run(variant) {
                 card: {
                     header: {
                         title: `${mr.project.name} | ${mr.title}`,
-                        subtitle: `${mr.author.name} | ${dayjs(mr.updatedAt).fromNow()} | ${inflect(
+                        subtitle: `${mr.author.name} | ${fromNow(mr.updatedAt)} | ${inflect(
                             changesCount,
                             "soubor",
                             "soubory",
@@ -98,3 +127,8 @@ module.exports = async function run(variant) {
         ]);
     }
 };
+
+// Vystaveno kvůli testům — stejný vzorec jako v uxf-release/index.js.
+module.exports.fromNow = fromNow;
+module.exports.daysSince = daysSince;
+module.exports.inflect = inflect;

package/src/uxf-merge-requests-notifier/index.test.js

@@ -0,0 +1,103 @@
+const { fromNow, daysSince, inflect } = require("./index");
+
+const NOW = new Date("2026-06-15T12:00:00.000Z").getTime();
+
+function ago(milliseconds) {
+    return new Date(NOW - milliseconds).toISOString();
+}
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+beforeEach(() => {
+    jest.spyOn(Date, "now").mockReturnValue(NOW);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+// `fromNow` a `daysSince` nahradily dayjs (`.fromNow()` a `.diff(x, "days")`),
+// proto na ně testy — jsou to jediná místa, kde se formátování času mohlo rozejít.
+describe("fromNow", () => {
+    it("formats seconds in Czech", () => {
+        expect(fromNow(ago(30 * SECOND))).toBe("před 30 sekundami");
+    });
+
+    it("formats minutes", () => {
+        expect(fromNow(ago(5 * MINUTE))).toBe("před 5 minutami");
+    });
+
+    it("formats hours", () => {
+        expect(fromNow(ago(3 * HOUR))).toBe("před 3 hodinami");
+    });
+
+    it("formats days numerically rather than as a word", () => {
+        // Se `numeric: "auto"` by Intl vrátilo "předevčírem", což dayjs nedělal.
+        expect(fromNow(ago(2 * DAY))).toBe("před 2 dny");
+    });
+
+    it("formats months", () => {
+        expect(fromNow(ago(40 * DAY))).toBe("před 1 měsícem");
+    });
+
+    it("formats years", () => {
+        expect(fromNow(ago(400 * DAY))).toBe("před 1 rokem");
+    });
+
+    it("picks the largest fitting unit", () => {
+        expect(fromNow(ago(23 * HOUR))).toBe("před 23 hodinami");
+        expect(fromNow(ago(25 * HOUR))).toBe("před 1 dnem");
+    });
+
+    it("handles a future timestamp", () => {
+        expect(fromNow(new Date(NOW + 2 * DAY).toISOString())).toBe("za 2 dny");
+    });
+});
+
+describe("daysSince", () => {
+    it("counts whole days", () => {
+        expect(daysSince(ago(3 * DAY))).toBe(3);
+    });
+
+    it("truncates a partial day, the way dayjs diff did", () => {
+        expect(daysSince(ago(3 * DAY + 23 * HOUR))).toBe(3);
+    });
+
+    it("returns 0 for something that happened moments ago", () => {
+        expect(daysSince(ago(MINUTE))).toBe(0);
+    });
+
+    it("crosses the 30 day threshold used by the STALE variant", () => {
+        expect(daysSince(ago(30 * DAY))).toBe(30);
+        expect(daysSince(ago(31 * DAY))).toBe(31);
+    });
+});
+
+describe("inflect", () => {
+    it("uses the singular for one", () => {
+        expect(inflect(1, "soubor", "soubory", "souborů")).toBe("1 soubor");
+    });
+
+    it("uses the 2-4 form", () => {
+        expect(inflect(2, "soubor", "soubory", "souborů")).toBe("2 soubory");
+        expect(inflect(4, "soubor", "soubory", "souborů")).toBe("4 soubory");
+    });
+
+    it("uses the plural genitive from five up", () => {
+        expect(inflect(5, "soubor", "soubory", "souborů")).toBe("5 souborů");
+        expect(inflect(12, "soubor", "soubory", "souborů")).toBe("12 souborů");
+    });
+
+    // Regrese: původní podmínka `value <= 4` posílala nulu do tvaru pro 2–4
+    // ("0 soubory"). Čeština má pro nulu genitiv plurálu.
+    it("uses the plural genitive for zero", () => {
+        expect(inflect(0, "soubor", "soubory", "souborů")).toBe("0 souborů");
+    });
+
+    it("uses the plural genitive for a value that is not a number", () => {
+        expect(inflect(NaN, "soubor", "soubory", "souborů")).toBe("NaN souborů");
+    });
+});

package/src/uxf-push-notifier/cli.js

@@ -1,27 +1,28 @@
-const { argv, env } = require("process");
+const { argv } = require("process");
+const { hasFlag, readOption } = require("../cli-args");
 
-module.exports = async () => {
-    const cli = require("yargs")()
-        .command("$0", "UXF push notifier", (yargs) => {
-            yargs.demandCommand(0, 0).usage(`Usage:
+const USAGE = `Usage:
   uxf-push-notifier [options]
 
+Options:
+  -g, --google-chat-webhook-url   URL Google Chat webhooku
+  -h, --help                      zobrazí tuto nápovědu
+
 Environment variables:
   GITLAB_TOKEN - required
-`);
-        })
-        .option("g", { alias: "google-chat-webhook-url", group: "Options" })
-        .option("h", { alias: "help", group: "Options" })
-        .strict(false)
-        .exitProcess(false);
+`;
 
+module.exports = async () => {
     try {
-        const { help, g: googleChatWebhookUrl } = cli.parse(argv.slice(2));
+        const args = argv.slice(2);
 
-        if (Boolean(help)) {
+        if (hasFlag(args, ["-h", "--help"])) {
+            console.log(USAGE);
             return 0;
         }
 
+        const googleChatWebhookUrl = readOption(args, ["-g", "--google-chat-webhook-url"]);
+
         await require("./index")(googleChatWebhookUrl);
     } catch (e) {
         console.error(e);

package/src/uxf-push-notifier/index.js

@@ -1,30 +1,36 @@
-const { create } = require("axios");
 const process = require("process");
+const { request } = require("../http");
 
 const { GITLAB_TOKEN, CI_SERVER_URL, CI_COMMIT_SHA, CI_COMMIT_BEFORE_SHA, CI_PROJECT_ID, CI_COMMIT_REF_NAME } =
     process.env;
 
-const gitlabAxios = create({
-    baseURL: `${CI_SERVER_URL}/api/v4`,
-    headers: {
-        Authorization: `Bearer ${GITLAB_TOKEN}`,
-    },
-});
-
-const googleChatAxios = create({});
+/**
+ * @param {string} url
+ * @param {{params?: Record<string, any>}} options
+ */
+function gitlabRequest(url, options = {}) {
+    return request(url, {
+        ...options,
+        baseUrl: `${CI_SERVER_URL}/api/v4`,
+        headers: { Authorization: `Bearer ${GITLAB_TOKEN}` },
+    });
+}
 
 function findCurrentlyMergedMergeRequest() {
-    return gitlabAxios
-        .get(
-            `/projects/${CI_PROJECT_ID}/merge_requests?state=merged&target_branch=${CI_COMMIT_REF_NAME}&order_by=updated_at&sort=desc`,
-        )
-        .then((response) => (response.data?.[0]?.sha === CI_COMMIT_SHA ? response.data[0] : null));
+    return gitlabRequest(`/projects/${CI_PROJECT_ID}/merge_requests`, {
+        params: {
+            state: "merged",
+            target_branch: CI_COMMIT_REF_NAME,
+            order_by: "updated_at",
+            sort: "desc",
+        },
+    }).then((response) => (response.data?.[0]?.sha === CI_COMMIT_SHA ? response.data[0] : null));
 }
 
 function getApprovalUserNames(iid) {
-    return gitlabAxios
-        .get(`/projects/${CI_PROJECT_ID}/merge_requests/${iid}/approvals`)
-        .then((response) => response.data.approved_by.map((item) => item.user.name));
+    return gitlabRequest(`/projects/${CI_PROJECT_ID}/merge_requests/${iid}/approvals`).then((response) =>
+        response.data.approved_by.map((item) => item.user.name),
+    );
 }
 
 function getPushedCommits() {
@@ -35,9 +41,9 @@ function getPushedCommits() {
         return Promise.resolve([]);
     }
 
-    return gitlabAxios
-        .get(`/projects/${CI_PROJECT_ID}/repository/compare?from=${CI_COMMIT_BEFORE_SHA}&to=${CI_COMMIT_SHA}`)
-        .then((response) => response.data.commits);
+    return gitlabRequest(`/projects/${CI_PROJECT_ID}/repository/compare`, {
+        params: { from: CI_COMMIT_BEFORE_SHA, to: CI_COMMIT_SHA },
+    }).then((response) => response.data.commits);
 }
 
 module.exports = async function (googleChatWebhookUrl) {
@@ -54,15 +60,18 @@ Autor: ${mr.author.name}
 Schválil: ${isApproved ? approvalUserNames.join(", ") : "*bez schválení*"}
 Zamergoval: ${mr.merged_by.name}`;
 
-        await googleChatAxios.post(googleChatWebhookUrl, { text });
+        await request(googleChatWebhookUrl, { method: "POST", body: { text } });
     } else {
         const commits = (await getPushedCommits()).map(
             (commit) => `${commit.author_name} - <${commit.web_url}|${commit.title}>`,
         );
 
-        await googleChatAxios.post(googleChatWebhookUrl, {
-            text: `❗ Bylo pushnuto do developu.
+        await request(googleChatWebhookUrl, {
+            method: "POST",
+            body: {
+                text: `❗ Bylo pushnuto do developu.
 ${commits.join("\n")}`,
+            },
         });
     }
 };

package/src/uxf-release/index.js

@@ -1,6 +1,6 @@
-const GitLab = require("../GitLab");
-const Slack = require("../Slack");
-const GoogleChat = require("../GoogleChat");
+const GitLab = require("../gitlab");
+const Slack = require("../slack");
+const GoogleChat = require("../google-chat");
 const parseCommitMessage = require("./utils/parse-commit-message");
 
 function generateSlackCommitMessage(commit) {

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

@@ -1,8 +1,8 @@
-const Sitemap = require("../Sitemap");
+const Sitemap = require("../sitemap");
 const { performance } = require("perf_hooks");
 const { stdout } = require("process");
 const cheerio = require("cheerio");
-const GoogleChat = require("../GoogleChat");
+const GoogleChat = require("../google-chat");
 const robotsTxtParser = require("robots-txt-parser");
 
 const got = (url, init) => import("got").then((mod) => mod.default(url, init));
@@ -78,6 +78,10 @@ function fetcher(url, options) {
     return got(url, {
         throwHttpErrors: false,
         decompress: false,
+        // BEZPEČNOST: vypnuté ověřování TLS certifikátu — platí na VŠECHNY procházené
+        // URL, tedy i externí a produkční, ne jen na staging se self-signed certem.
+        // Crawler tím nepozná podvržený certifikát (MITM). Čistší by bylo podmínit to
+        // env proměnnou nebo přidat CA do trust storu. Stejná poznámka je v sitemap.js.
         https: {
             rejectUnauthorized: false,
         },

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

@@ -2,8 +2,8 @@
  * @jest-environment node
  */
 
-jest.mock("../Sitemap");
-jest.mock("../GoogleChat");
+jest.mock("../sitemap");
+jest.mock("../google-chat");
 jest.mock("cheerio");
 jest.mock("got");
 jest.mock("robots-txt-parser", () => () => ({ useRobotsFor: jest.fn(), canCrawl: jest.fn() }));

package/src/uxf-sitemap-meta-export/index.js

@@ -1,4 +1,4 @@
-const Sitemap = require("../Sitemap");
+const Sitemap = require("../sitemap");
 const cheerio = require("cheerio");
 const fs = require("fs");
 
@@ -17,9 +17,9 @@ module.exports = async function run() {
     for (const url of urls) {
         process.stdout.write(`${++i} / ${urls.length} ${url} \n`);
         try {
-            const response = await Sitemap.axios.get(url);
+            const body = await Sitemap.fetchPage(url);
 
-            const $ = cheerio.load(response.data, { xmlMode: true, decodeEntities: false });
+            const $ = cheerio.load(body, { xmlMode: true, decodeEntities: false });
 
             let title = "";
             let ogTitle = "";

package/src/Logger.js

@@ -1,12 +0,0 @@
-function debug(message) {
-    console.debug(message);
-}
-
-function info(message) {
-    console.info(message);
-}
-
-module.exports = {
-    debug,
-    info,
-};