@uxf/scripts 11.123.0 → 11.124.0

package/src/http.js

@@ -0,0 +1,86 @@
+/**
+ * Minimalistická náhrada axiosu nad globálním `fetch` (Node >= 18).
+ *
+ * Existuje proto, aby notifiery běžely v CI bez `npm install` — viz
+ * `docs/decisions/package-manager.md`. Drží se chování axiosu ve třech věcech,
+ * na kterých volající stojí: vyhazuje na non-2xx, parsuje JSON odpověď
+ * a zahazuje `undefined` query parametry.
+ */
+
+/**
+ * Chyba HTTP požadavku. `message` má stejný tvar jako u axiosu, protože
+ * `GitLab.findMigrationFiles` ho loguje.
+ */
+class HttpError extends Error {
+    /**
+     * @param {number} status
+     * @param {string} url
+     * @param {any} body
+     */
+    constructor(status, url, body) {
+        super(`Request failed with status code ${status}`);
+        this.name = "HttpError";
+        this.status = status;
+        this.url = url;
+        this.body = body;
+    }
+}
+
+/**
+ * Poskládá query string a zahodí `undefined`/`null` hodnoty — axios se choval stejně.
+ *
+ * @param {string} url
+ * @param {Record<string, any> | undefined} params
+ */
+function withQuery(url, params) {
+    const search = new URLSearchParams();
+
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value !== undefined && value !== null) {
+            search.append(key, String(value));
+        }
+    }
+
+    const query = search.toString();
+
+    if (!query) {
+        return url;
+    }
+
+    return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+}
+
+/**
+ * @param {string} url
+ * @param {{baseUrl?: string, method?: string, headers?: Record<string, string>, params?: Record<string, any>, body?: any}} options
+ * @returns {Promise<{data: any, headers: Headers, status: number}>}
+ */
+async function request(url, options = {}) {
+    const { baseUrl = "", method = "GET", headers = {}, params, body } = options;
+    const target = withQuery(`${baseUrl}${url}`, params);
+
+    /** @type {RequestInit} */
+    const init = { method, headers: { ...headers } };
+
+    if (body !== undefined) {
+        init.body = JSON.stringify(body);
+        init.headers["Content-Type"] = init.headers["Content-Type"] ?? "application/json";
+    }
+
+    const response = await fetch(target, init);
+    const text = await response.text();
+    const isJson = (response.headers.get("content-type") ?? "").includes("application/json");
+    const data = isJson && text ? JSON.parse(text) : text;
+
+    if (!response.ok) {
+        throw new HttpError(response.status, target, data);
+    }
+
+    return { data, headers: response.headers, status: response.status };
+}
+
+module.exports = {
+    HttpError,
+    request,
+    withQuery,
+};

package/src/http.test.js

@@ -0,0 +1,155 @@
+const { request, withQuery, HttpError } = require("./http");
+
+/**
+ * Minimální náhrada `Response` — testy nesmí záviset na tom, jestli ji testovací
+ * prostředí (jsdom) vystavuje.
+ */
+function fakeResponse({ status = 200, body = "", contentType = "application/json" } = {}) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        headers: { get: (name) => (name.toLowerCase() === "content-type" ? contentType : null) },
+        text: async () => body,
+    };
+}
+
+function stubFetch(response) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return typeof response === "function" ? response(url, init) : response;
+    };
+    return calls;
+}
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+});
+
+describe("withQuery", () => {
+    it("returns the url untouched when there are no params", () => {
+        expect(withQuery("/projects", undefined)).toBe("/projects");
+        expect(withQuery("/projects", {})).toBe("/projects");
+    });
+
+    it("drops undefined and null values", () => {
+        expect(withQuery("/mr", { a: "1", b: undefined, c: null, d: "2" })).toBe("/mr?a=1&d=2");
+    });
+
+    it("keeps falsy values that are not undefined or null", () => {
+        expect(withQuery("/mr", { page: 0, simple: false, empty: "" })).toBe("/mr?page=0&simple=false&empty=");
+    });
+
+    it("appends with & when the url already has a query string", () => {
+        expect(withQuery("/mr?state=open", { page: "2" })).toBe("/mr?state=open&page=2");
+    });
+
+    it("encodes values", () => {
+        expect(withQuery("/tags", { search: "^release-" })).toBe("/tags?search=%5Erelease-");
+    });
+});
+
+describe("request", () => {
+    it("joins baseUrl, path and params", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/projects", { baseUrl: "https://git.test/api/v4", params: { per_page: "100" } });
+
+        expect(calls[0].url).toBe("https://git.test/api/v4/projects?per_page=100");
+    });
+
+    it("defaults to GET and sends no body", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x");
+
+        expect(calls[0].init.method).toBe("GET");
+        expect(calls[0].init.body).toBeUndefined();
+    });
+
+    it("serializes the body as JSON and sets the content type", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", { method: "POST", body: { text: "ahoj" } });
+
+        expect(calls[0].init.body).toBe('{"text":"ahoj"}');
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json");
+    });
+
+    it("does not override an explicitly provided content type", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", {
+            method: "POST",
+            headers: { "Content-Type": "application/json; charset=UTF-8" },
+            body: { a: 1 },
+        });
+
+        expect(calls[0].init.headers["Content-Type"]).toBe("application/json; charset=UTF-8");
+    });
+
+    it("passes custom headers through", async () => {
+        const calls = stubFetch(fakeResponse({ body: "{}" }));
+
+        await request("/x", { headers: { Authorization: "Bearer t" } });
+
+        expect(calls[0].init.headers.Authorization).toBe("Bearer t");
+    });
+
+    it("parses a JSON response", async () => {
+        stubFetch(fakeResponse({ body: '{"id":1}' }));
+
+        const response = await request("/x");
+
+        expect(response.data).toEqual({ id: 1 });
+        expect(response.status).toBe(200);
+    });
+
+    it("returns raw text when the response is not JSON", async () => {
+        stubFetch(fakeResponse({ body: "<html></html>", contentType: "text/html" }));
+
+        const response = await request("/x");
+
+        expect(response.data).toBe("<html></html>");
+    });
+
+    it("returns an empty string for an empty JSON response instead of throwing", async () => {
+        stubFetch(fakeResponse({ body: "" }));
+
+        const response = await request("/x");
+
+        expect(response.data).toBe("");
+    });
+
+    it("exposes response headers so callers can paginate", async () => {
+        globalThis.fetch = async () => ({
+            ok: true,
+            status: 200,
+            headers: { get: (name) => (name === "x-next-page" ? "2" : "application/json") },
+            text: async () => "[]",
+        });
+
+        const response = await request("/x");
+
+        expect(response.headers.get("x-next-page")).toBe("2");
+    });
+
+    it("throws on a non-2xx status, the way axios did", async () => {
+        stubFetch(fakeResponse({ status: 404, body: '{"message":"404 Not found"}' }));
+
+        await expect(request("/missing")).rejects.toThrow("Request failed with status code 404");
+    });
+
+    it("carries status, url and parsed body on the error", async () => {
+        stubFetch(fakeResponse({ status: 500, body: '{"message":"boom"}' }));
+
+        const error = await request("/x", { baseUrl: "https://git.test" }).catch((e) => e);
+
+        expect(error).toBeInstanceOf(HttpError);
+        expect(error.status).toBe(500);
+        expect(error.url).toBe("https://git.test/x");
+        expect(error.body).toEqual({ message: "boom" });
+    });
+});

package/src/sitemap.js

@@ -0,0 +1,80 @@
+const cheerio = require("cheerio");
+
+const { HTTP_USERNAME, HTTP_PASSWORD } = process.env;
+
+// got v15 je ESM-only, proto dynamický import — stejný vzorec jako v uxf-sitemap-check.
+const got = (url, init) => import("got").then((mod) => mod.default(url, init));
+
+const REQUEST_TIMEOUT_MS = 20_000;
+
+const HEADERS = {
+    "User-Agent":
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36",
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9,cs-CZ;q=0.8,cs;q=0.7,de;q=0.6",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    Pragma: "no-cache",
+    "Sec-Ch-Ua": '"Google Chrome";v="111", "Not(A:Brand";v="8", "Chromium";v="111"',
+    "Sec-Ch-Ua-Arch": '"x86"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"Windows"',
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "cross-site",
+    "Sec-Fetch-User": "?1",
+    "Sec-Fetch-User-Agent": "?1",
+};
+
+/**
+ * Stáhne stránku se stejnou konfigurací, jakou měla původní axios instance:
+ * basic auth z env, žádné následování redirectů, 20s timeout a vypnuté ověřování
+ * TLS certifikátu (kvůli staging webům se self-signed certy).
+ *
+ * `https.rejectUnauthorized` je důvod, proč tenhle modul jede na `got` a ne na
+ * globálním `fetch` — undici žádnou per-request TLS volbu nenabízí.
+ *
+ * @param {string} url
+ * @returns {Promise<string>} tělo odpovědi
+ */
+async function fetchPage(url) {
+    const response = await got(url, {
+        headers: HEADERS,
+        username: HTTP_USERNAME || undefined,
+        password: HTTP_PASSWORD || undefined,
+        followRedirect: false,
+        // BEZPEČNOST: vypnuté ověřování TLS certifikátu. Zděděno z axios verze
+        // (`httpsAgent` s `rejectUnauthorized: false`), zachováno kvůli staging webům
+        // se self-signed certy. Platí to ale na VŠECHNY URL, včetně produkčních —
+        // takže crawler nepozná podvržený certifikát a je náchylný na MITM.
+        // Čistší by bylo podmínit to env proměnnou nebo přidat CA do trust storu.
+        https: { rejectUnauthorized: false },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+
+    // got s `followRedirect: false` vrací 3xx jako úspěch s prázdným tělem, kdežto
+    // axios s `maxRedirects: 0` na něj vyhazoval. Bez tohohle by přesměrované URL
+    // tiše propadly do exportu jako řádek s prázdným titulkem.
+    if (response.statusCode >= 300) {
+        throw new Error(`Request failed with status code ${response.statusCode}`);
+    }
+
+    return response.body;
+}
+
+async function getSitemap(xml) {
+    const $ = cheerio.load(await fetchPage(xml), { xmlMode: true });
+
+    const urls = [];
+
+    $("loc").each(function () {
+        urls.push($(this).text());
+    });
+
+    return urls;
+}
+
+module.exports = {
+    getSitemap,
+    fetchPage,
+};

package/src/sitemap.test.js

@@ -0,0 +1,64 @@
+const mockGot = jest.fn();
+
+jest.mock("got", () => ({ __esModule: true, default: (...args) => mockGot(...args) }));
+// cheerio je ESM-only a jest ho neprochází (viz transformIgnorePatterns v jest.config.js),
+// proto je mockované — stejně jako v uxf-sitemap-check/index.test.js. Parsování sitemapy
+// v `getSitemap` tím pádem testovat nejde; testy tu pokrývají `fetchPage`, tedy to,
+// co se převodem z axiosu na got mohlo rozejít.
+jest.mock("cheerio", () => ({ load: jest.fn() }));
+
+const Sitemap = require("./sitemap");
+
+function response({ statusCode = 200, body = "" } = {}) {
+    return { statusCode, body, headers: {} };
+}
+
+afterEach(() => {
+    mockGot.mockReset();
+});
+
+describe("fetchPage", () => {
+    it("returns the response body", async () => {
+        mockGot.mockResolvedValue(response({ body: "<html>ok</html>" }));
+
+        await expect(Sitemap.fetchPage("https://x.test/a")).resolves.toBe("<html>ok</html>");
+    });
+
+    it("does not follow redirects and skips TLS verification", async () => {
+        mockGot.mockResolvedValue(response({ body: "" }));
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        const [, options] = mockGot.mock.calls[0];
+        expect(options.followRedirect).toBe(false);
+        expect(options.https).toEqual({ rejectUnauthorized: false });
+        expect(options.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    // got s `followRedirect: false` vrací 3xx jako úspěch s prázdným tělem, zatímco
+    // axios s `maxRedirects: 0` vyhazoval. Bez tohohle by přesměrované URL propadly
+    // do meta exportu jako řádek s prázdným titulkem.
+    it("throws on a redirect instead of returning an empty body", async () => {
+        mockGot.mockResolvedValue(response({ statusCode: 302, body: "" }));
+
+        await expect(Sitemap.fetchPage("https://x.test/redirect")).rejects.toThrow(
+            "Request failed with status code 302",
+        );
+    });
+
+    it("passes the requested url through", async () => {
+        mockGot.mockResolvedValue(response());
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        expect(mockGot.mock.calls[0][0]).toBe("https://x.test/a");
+    });
+
+    it("sends a browser-like user agent", async () => {
+        mockGot.mockResolvedValue(response());
+
+        await Sitemap.fetchPage("https://x.test/a");
+
+        expect(mockGot.mock.calls[0][1].headers["User-Agent"]).toContain("Mozilla/5.0");
+    });
+});

package/src/{Slack.js → slack.js}

@@ -1,12 +1,7 @@
 const { env } = require("process");
-const { create } = require("axios");
+const { request } = require("./http");
 
-const axios = create({
-    baseURL: "https://slack.com/api",
-    headers: {
-        Authorization: `Bearer ${env.SLACK_TOKEN}`,
-    },
-});
+const BASE_URL = "https://slack.com/api";
 
 /**
  * @see https://api.slack.com/methods/chat.postMessage
@@ -14,7 +9,13 @@ const axios = create({
  */
 async function chatPostMessage(channel, data, dryRun = false) {
     if (env.SLACK_TOKEN && !dryRun) {
-        const res = await axios.post("/chat.postMessage", { ...data, channel });
+        // Slack vrací HTTP 200 i pro chyby API, rozlišuje je až polem `ok`.
+        const res = await request("/chat.postMessage", {
+            baseUrl: BASE_URL,
+            method: "POST",
+            headers: { Authorization: `Bearer ${env.SLACK_TOKEN}` },
+            body: { ...data, channel },
+        });
         if (res.data.ok === false) {
             process.stdout.write("SLACK: chat.postMessage error - " + JSON.stringify(res.data));
             return;

package/src/slack.test.js

@@ -0,0 +1,81 @@
+const Slack = require("./slack");
+
+const originalFetch = globalThis.fetch;
+const { SLACK_TOKEN } = process.env;
+
+function stubFetch(payload = { ok: true }) {
+    const calls = [];
+    globalThis.fetch = async (url, init) => {
+        calls.push({ url, init });
+        return {
+            ok: true,
+            status: 200,
+            headers: { get: () => "application/json" },
+            text: async () => JSON.stringify(payload),
+        };
+    };
+    return calls;
+}
+
+beforeEach(() => {
+    process.env.SLACK_TOKEN = "xoxb-test";
+    jest.spyOn(process.stdout, "write").mockImplementation(() => true);
+});
+
+afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.SLACK_TOKEN = SLACK_TOKEN;
+    jest.restoreAllMocks();
+});
+
+describe("chatPostMessage", () => {
+    it("posts to the Slack API with the bearer token and the channel merged in", async () => {
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(calls[0].url).toBe("https://slack.com/api/chat.postMessage");
+        expect(calls[0].init.method).toBe("POST");
+        expect(calls[0].init.headers.Authorization).toBe("Bearer xoxb-test");
+        expect(JSON.parse(calls[0].init.body)).toEqual({ text: "ahoj", channel: "#releases" });
+    });
+
+    it("reports a done message on success", async () => {
+        stubFetch({ ok: true });
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - done\n");
+    });
+
+    // Slack vrací HTTP 200 i pro chyby API, rozlišuje je až polem `ok` — proto se
+    // na to nedá spolehnout na status kód.
+    it("reports an error when Slack answers ok:false despite HTTP 200", async () => {
+        stubFetch({ ok: false, error: "channel_not_found" });
+
+        await Slack.chatPostMessage("#nope", { text: "ahoj" });
+
+        expect(process.stdout.write).toHaveBeenCalledWith(
+            'SLACK: chat.postMessage error - {"ok":false,"error":"channel_not_found"}',
+        );
+    });
+
+    it("skips when there is no token", async () => {
+        delete process.env.SLACK_TOKEN;
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" });
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - skipped\n");
+    });
+
+    it("skips in dry run mode", async () => {
+        const calls = stubFetch();
+
+        await Slack.chatPostMessage("#releases", { text: "ahoj" }, true);
+
+        expect(calls).toHaveLength(0);
+        expect(process.stdout.write).toHaveBeenCalledWith("SLACK: chat.postMessage - skipped\n");
+    });
+});

package/src/uxf-i18n-namespaces-gen/dependency-tree.js

@@ -0,0 +1,102 @@
+const { execFileSync } = require("child_process");
+const path = require("path");
+
+// 256 MB. `rev-dep`'s own `bin.js` wrapper shells out with `execSync` and no `maxBuffer`, so it
+// silently truncates at Node's 1 MB default and still exits 0 — we resolve the platform binary
+// ourselves to avoid that.
+const MAX_BUFFER = 256 * 1024 * 1024;
+
+function resolveRevDepBinary() {
+    const suffix = process.platform === "win32" ? ".exe" : "";
+    const request = `@rev-dep/${process.platform}-${process.arch}/bin/rev-dep${suffix}`;
+
+    try {
+        return require.resolve(request, { paths: [__dirname] });
+    } catch {
+        throw new Error(
+            `Could not locate the rev-dep binary for your platform (${request}). ` +
+                `It ships as an optionalDependency of rev-dep — reinstall without --omit=optional.`,
+        );
+    }
+}
+
+function runRevDep(cwd, tsConfig) {
+    const args = ["debug", "get-tree-for-cwd", "--cwd", cwd];
+
+    if (tsConfig) {
+        args.push("--tsconfig-json", tsConfig);
+    }
+
+    try {
+        return execFileSync(resolveRevDepBinary(), args, { encoding: "utf8", maxBuffer: MAX_BUFFER });
+    } catch (error) {
+        const details = error.stderr ? `\n${error.stderr}` : "";
+        throw new Error(`rev-dep failed to build the dependency tree for ${cwd}.${details}`);
+    }
+}
+
+/**
+ * Turns rev-dep's tree into the shape madge's `res.obj()` returned, so the callers' traversal
+ * keeps working unchanged:
+ *
+ *   { "<cwd-relative file>": ["<cwd-relative dep>" | "<bare specifier>", ...] }
+ *
+ * Imports that rev-dep could not resolve to a project file (node modules, unresolved requests)
+ * are kept as their raw specifier — callers resolve those themselves via `require.resolve`,
+ * which is how `node_modules/@uxf/**` gets picked up.
+ *
+ * @param {string} cwd
+ * @param {{ tsConfig?: string, fileExtensions?: string[], include?: string[] }} options
+ * @returns {Record<string, string[]>}
+ */
+function buildDependencyTree(cwd, options = {}) {
+    const { tsConfig, fileExtensions, include } = options;
+
+    const graph = JSON.parse(runRevDep(cwd, tsConfig));
+
+    const toRelative = (filePath) => (path.isAbsolute(filePath) ? path.relative(cwd, filePath) : filePath);
+
+    const extensions = fileExtensions?.map((extension) => (extension.startsWith(".") ? extension : `.${extension}`));
+
+    // `node_modules` is deliberately left to the callers' own resolution — rev-dep does not
+    // traverse into it, and it is the one place where the raw specifiers above are needed.
+    const isOutOfScope = (relativePath) =>
+        relativePath.startsWith("node_modules") || relativePath.startsWith("..") || path.isAbsolute(relativePath);
+
+    // `include` used to be madge's `excludeRegExp`: keep only files under the given prefixes.
+    const isIncluded = (relativePath) => !include?.length || include.some((prefix) => relativePath.startsWith(prefix));
+
+    const hasAllowedExtension = (relativePath) =>
+        !extensions || extensions.some((extension) => relativePath.endsWith(extension));
+
+    const isProjectFile = (relativePath) =>
+        !isOutOfScope(relativePath) && isIncluded(relativePath) && hasAllowedExtension(relativePath);
+
+    const tree = {};
+
+    for (const [file, dependencies] of Object.entries(graph)) {
+        const relativeFile = toRelative(file);
+
+        if (!isProjectFile(relativeFile)) {
+            continue;
+        }
+
+        tree[relativeFile] = (dependencies ?? [])
+            .map((dependency) => {
+                if (dependency.resolvedTypeLabel !== "UserModule" || !dependency.id) {
+                    // node module or unresolved — hand the specifier over untouched
+                    return dependency.request;
+                }
+
+                const relativeDependency = toRelative(dependency.id);
+
+                return isProjectFile(relativeDependency) ? relativeDependency : undefined;
+            })
+            .filter((dependency) => typeof dependency === "string" && dependency.length > 0);
+    }
+
+    return tree;
+}
+
+module.exports = buildDependencyTree;
+module.exports.resolveRevDepBinary = resolveRevDepBinary;

package/src/uxf-i18n-namespaces-gen/dependency-tree.test.js

@@ -0,0 +1,46 @@
+/** @jest-environment node */
+const path = require("path");
+const buildDependencyTree = require("./dependency-tree");
+
+const FIXTURE_CWD = path.join(__dirname, "tests");
+
+describe("buildDependencyTree", () => {
+    const tree = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts", "tsx"] });
+
+    it("keys the tree by cwd-relative paths", () => {
+        expect(Object.keys(tree)).toEqual(expect.arrayContaining(["pages/page-a.tsx", "utils.tsx"]));
+    });
+
+    it("resolves relative imports to project files", () => {
+        expect(tree["pages/page-a.tsx"]).toEqual(
+            expect.arrayContaining(["components/no-index-file.tsx", "components/with-index-file/index.ts"]),
+        );
+    });
+
+    it("resolves a directory import to its index file", () => {
+        expect(tree["components/with-index-file/index.ts"]).toEqual(["components/with-index-file/with-index-file.tsx"]);
+    });
+
+    it("keeps unresolved node module imports as raw specifiers", () => {
+        // callers resolve these themselves — that is how node_modules/@uxf/** gets picked up
+        expect(tree["components/with-index-file/with-index-file.tsx"]).toEqual(
+            expect.arrayContaining(["@uxf/ui/chip", "@uxf/core/utils/noop"]),
+        );
+    });
+
+    it("does not emit node_modules files as tree keys", () => {
+        expect(Object.keys(tree).filter((file) => file.startsWith("node_modules"))).toEqual([]);
+    });
+
+    it("honours the include filter", () => {
+        const filtered = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts", "tsx"], include: ["pages"] });
+
+        expect(Object.keys(filtered).every((file) => file.startsWith("pages"))).toBe(true);
+    });
+
+    it("honours the fileExtensions filter", () => {
+        const filtered = buildDependencyTree(FIXTURE_CWD, { fileExtensions: ["ts"] });
+
+        expect(Object.keys(filtered).every((file) => file.endsWith(".ts"))).toBe(true);
+    });
+});