@uxf/router 11.72.1 → 11.72.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/router",
-    "version": "11.72.1",
+    "version": "11.72.3",
     "description": "UXF Router",
     "author": "UXFans <dev@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/router#readme",

package/router.d.ts

@@ -1,6 +1,6 @@
 import { LinkProps } from "next/link";
 import { Infer, Struct } from "superstruct";
-import { SitemapGeneratorOptions, SitemapGeneratorType } from "./sitemap-generator";
+import { SitemapGeneratorOptions, SitemapGeneratorType, SitemapRouteResolvers } from "./sitemap-generator";
 import { QueryParams, RoutesDefinition } from "./types";
 type ExtractSchema<T> = T extends {
     schema: Struct<infer U, any>;
@@ -12,11 +12,7 @@ type LocaleOptions<Locales extends string[]> = {
     locale: Locales[number];
 };
 export type FunctionParametersGenerator<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
-    [K in keyof RouteList]: RouteList[K]["path"] extends string ? RouteList[K] extends {
-        schema: undefined;
-    } ? [K, null?, Options?] : [K, ExtractSchema<RouteList[K]>?, Options?] : RouteList[K] extends {
-        schema: undefined;
-    } ? [K, null, Options & LocaleOptions<Locales>] : [K, ExtractSchema<RouteList[K]>, Options & LocaleOptions<Locales>];
+    [K in keyof RouteList]: RouteList[K]["path"] extends string ? "schema" extends keyof RouteList[K] ? [K, ExtractSchema<RouteList[K]>, Options?] : [K, null?, Options?] : "schema" extends keyof RouteList[K] ? [K, ExtractSchema<RouteList[K]>, Options & LocaleOptions<Locales>] : [K, null, Options & LocaleOptions<Locales>];
 }[keyof RouteList];
 type RouteFunction<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = (...args: FunctionParametersGenerator<Locales, RouteList>) => LinkProps["href"];
 type RouteToUrlFunction<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = (...args: FunctionParametersGenerator<Locales, RouteList>) => string;
@@ -30,7 +26,7 @@ type QueryParamsResult<Nullable extends boolean, T extends keyof RouteList, Loca
 type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
     route: RouteFunction<Locales, RouteList>;
     routeToUrl: RouteToUrlFunction<Locales, RouteList>;
-    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+    createSitemapGenerator: (resolvers: SitemapRouteResolvers<Locales, RouteList>, options?: SitemapGeneratorOptions) => SitemapGeneratorType;
     routes: RouteList;
     useActiveRoute: () => ActiveRoute<Locales, RouteList>;
     /**

package/router.js

@@ -97,7 +97,9 @@ function createRouter(routes, routerOptions) {
                 locale: ((_a = router.locale) !== null && _a !== void 0 ? _a : null),
             };
         },
-        createSitemapGenerator: sitemap_generator_1.createSitemapGenerator,
+        createSitemapGenerator(resolvers, options) {
+            return new sitemap_generator_1.SitemapGenerator(resolvers, options);
+        },
         routes,
         useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
         useQueryParams(routeName) {

package/routes-check/routes-check.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env ts-node-script
+import { RoutesDefinition } from "../types";
+interface Options {
+    appDir: string;
+    pagesDir: string;
+    shouldProcessExit?: boolean;
+    defaultLocale?: string;
+}
+export declare function routesCheck(routes: RoutesDefinition<any>, options: Options): void;
+export {};

package/routes-check/routes-check.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env ts-node-script
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routesCheck = routesCheck;
+const throw_error_1 = require("@uxf/core/utils/throw-error");
+const path_1 = require("path");
+const process_1 = require("process");
+const true_case_path_1 = require("true-case-path");
+function fileExists(path) {
+    try {
+        return Boolean((0, true_case_path_1.trueCasePathSync)(path));
+    }
+    catch {
+        try {
+            return Boolean((0, true_case_path_1.trueCasePathSync)(path + "x"));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+let hasError = false;
+function routesCheck(routes, options) {
+    Object.entries(routes).forEach(([routeName, routeDefinition]) => {
+        var _a;
+        const pathname = typeof routeDefinition.path === "string"
+            ? routeDefinition.path
+            : routeDefinition.path[(_a = options.defaultLocale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Default locale must be provided")];
+        const pathParts = pathname.substr(1).split("/");
+        try {
+            if (fileExists((0, path_1.join)(options.pagesDir, ...pathParts, "index.ts"))) {
+                return;
+            }
+            // TODO @vejvis - proč tu je tahle podmínka?
+            const lastPart = pathParts.splice(-1);
+            const pagePath = pathParts.length > 0
+                ? (0, path_1.join)(options.pagesDir, ...pathParts, `${lastPart[0] || "index"}.ts`)
+                : (0, path_1.join)(options.pagesDir, `${lastPart[0] || "index"}.tsx`);
+            if (fileExists(pagePath)) {
+                return;
+            }
+            if (fileExists((0, path_1.join)(options.appDir, ...pathname.substr(1).split("/"), "page.ts"))) {
+                // app directory
+                return;
+            }
+            throw new Error("Invalid");
+        }
+        catch {
+            process_1.stdout.write(`❌  ${routeName}\n`);
+            hasError = true;
+        }
+    });
+    if (hasError) {
+        if (options.shouldProcessExit) {
+            process.exit(1);
+        }
+        throw new Error("At least one invalid route found");
+    }
+    else {
+        if (options.shouldProcessExit) {
+            process.exit(0);
+        }
+        process_1.stdout.write("All routes checked.\n");
+    }
+}

package/routes-check/routes-check.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const routes_check_1 = require("./routes-check");
+describe("routesCheck", () => {
+    it("should be valid", () => {
+        expect(() => (0, routes_check_1.routesCheck)({
+            route1: { path: "/" }, // index
+            route2: { path: "/product" }, // index file
+            route3: { path: "/product/edit" }, // file with specific name
+            route4: { path: "/product/[id]" }, // path parameter, file with specific name
+            route5: { path: "/product-2/[id]" }, // path parameter, index file
+            app1: { path: "/app-directory" },
+            app2: { path: "/app-directory/[param]" },
+        }, {
+            shouldProcessExit: false,
+            appDir: (0, path_1.join)(__dirname, "__test__", "app"),
+            pagesDir: (0, path_1.join)(__dirname, "__test__", "pages"),
+        })).not.toThrow();
+    });
+    it("should fail", () => {
+        expect(() => (0, routes_check_1.routesCheck)({
+            unknown: { path: "/unknown-route" }, // index
+        }, {
+            shouldProcessExit: false,
+            appDir: (0, path_1.join)(__dirname, "__test__", "app"),
+            pagesDir: (0, path_1.join)(__dirname, "__test__", "pages"),
+        })).toThrow();
+    });
+});

package/sitemap-generator.d.ts

@@ -7,22 +7,32 @@ export type SitemapItem = {
     changefreq?: ChangeFrequency;
 };
 type RouteResolverResult = null | undefined | SitemapItem | Array<SitemapItem | null | undefined>;
-type RouteResolver<Route> = (route: Route) => Promise<RouteResolverResult>;
-type MissingRoutesError<Routes> = {
-    __nonExhaustive: never;
-    missingRoutes: Routes;
+/**
+ * Object-based approach for sitemap generation with compile-time exhaustiveness checking.
+ *
+ * Instead of builder pattern, this requires all routes to be specified in a single object.
+ * Routes that shouldn't be in sitemap are set to null, others have RouteResolver functions.
+ *
+ * This approach is much faster for TypeScript compiler as it avoids recursive type operations.
+ */
+export type SitemapRouteResolvers<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    [K in keyof RouteList]: ((routeName: K) => Promise<RouteResolverResult>) | null;
 };
-export type SitemapGeneratorType<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
-    add: <Route extends keyof RouteList>(route: Route, resolver: RouteResolver<Route>) => SitemapGeneratorType<Locales, Omit<RouteList, Route>>;
-    skip: <Route extends keyof RouteList>(route: Route) => SitemapGeneratorType<Locales, Omit<RouteList, Route>>;
-    exhaustive: keyof RouteList extends never ? () => SitemapGeneratorType<Locales, RouteList> : MissingRoutesError<keyof RouteList>;
-    toXml: keyof RouteList extends never ? () => Promise<string> : MissingRoutesError<keyof RouteList>;
-    toJson: keyof RouteList extends never ? () => Promise<any> : MissingRoutesError<keyof RouteList>;
+export type SitemapGeneratorType = {
+    toXml(): Promise<string>;
+    toJson(): Promise<string>;
 };
 export type SitemapGeneratorOptions = {
     baseUrl?: string;
     defaultPriority?: number;
     defaultChangeFreq?: ChangeFrequency;
 };
-export declare const createSitemapGenerator: <Locales extends string[], RouteList extends RoutesDefinition<Locales>>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+export declare class SitemapGenerator<Locales extends string[], RouteList extends RoutesDefinition<Locales>> {
+    private routeResolvers;
+    private options;
+    constructor(resolvers: SitemapRouteResolvers<Locales, RouteList>, options?: SitemapGeneratorOptions);
+    private getSitemapItems;
+    toXml(): Promise<string>;
+    toJson(): Promise<string>;
+}
 export {};

package/sitemap-generator.js

@@ -1,29 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSitemapGenerator = void 0;
+exports.SitemapGenerator = void 0;
 const object_to_xml_1 = require("./utils/object-to-xml");
 function filterNullish(val) {
     return val.filter((item) => item !== null && item !== undefined);
 }
 class SitemapGenerator {
-    constructor(options) {
-        this.routeResolvers = {};
-        this.options = null;
-        this.exhaustive = () => this;
-        this.toXml = () => {
-            return this.getSitemapItems().then((sitemapItems) => {
-                return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
-${sitemapItems.map((item) => `    <url>\n${(0, object_to_xml_1.objectToXml)(item)}\n    </url>`).join("\n")}
-</urlset>`;
-            });
-        };
-        this.toJson = () => this.getSitemapItems().then(JSON.stringify);
-        this.options = options !== null && options !== void 0 ? options : null;
+    constructor(resolvers, options) {
+        this.routeResolvers = resolvers;
+        this.options = options !== null && options !== void 0 ? options : {};
     }
     async getSitemapItems() {
         const routes = Object.keys(this.routeResolvers);
-        const allSitemapItems = await Promise.all(routes.map((route) => { var _a, _b; return (_b = (_a = this.routeResolvers)[route]) === null || _b === void 0 ? void 0 : _b.call(_a, route); })).then((resolverResults) => {
+        const resolversWithRoutes = routes
+            .map((route) => ({ route, resolver: this.routeResolvers[route] }))
+            .filter(({ resolver }) => resolver !== null);
+        const allSitemapItems = await Promise.all(resolversWithRoutes.map(({ route, resolver }) => resolver(route))).then((resolverResults) => {
             const sitemapItems = [];
             resolverResults.forEach((result) => {
                 if (!result) {
@@ -38,22 +30,25 @@ ${sitemapItems.map((item) => `    <url>\n${(0, object_to_xml_1.objectToXml)(item
             return sitemapItems;
         });
         return allSitemapItems.map((sitemapItem) => {
-            var _a, _b, _c, _d;
+            var _a;
             return ({
                 lastmod: sitemapItem.lastmod,
-                loc: ((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.baseUrl) !== null && _b !== void 0 ? _b : "") + sitemapItem.loc,
-                changefreq: sitemapItem.changefreq !== undefined ? sitemapItem.changefreq : (_c = this.options) === null || _c === void 0 ? void 0 : _c.defaultChangeFreq,
-                priority: sitemapItem.priority !== undefined ? sitemapItem.priority : (_d = this.options) === null || _d === void 0 ? void 0 : _d.defaultPriority,
+                loc: ((_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : "") + sitemapItem.loc,
+                changefreq: sitemapItem.changefreq !== undefined ? sitemapItem.changefreq : this.options.defaultChangeFreq,
+                priority: sitemapItem.priority !== undefined ? sitemapItem.priority : this.options.defaultPriority,
             });
         });
     }
-    add(route, resolver) {
-        this.routeResolvers[route] = resolver;
-        return this;
+    toXml() {
+        return this.getSitemapItems().then((sitemapItems) => {
+            return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
+${sitemapItems.map((item) => `    <url>\n${(0, object_to_xml_1.objectToXml)(item)}\n    </url>`).join("\n")}
+</urlset>`;
+        });
     }
-    skip() {
-        return this;
+    toJson() {
+        return this.getSitemapItems().then(JSON.stringify);
     }
 }
-const createSitemapGenerator = (options) => new SitemapGenerator(options);
-exports.createSitemapGenerator = createSitemapGenerator;
+exports.SitemapGenerator = SitemapGenerator;

package/sitemap-generator.test.js

@@ -9,6 +9,9 @@ const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
             queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
         }),
     },
+    skippedRoute: {
+        path: "/skipped",
+    },
     catchAllSegments: {
         path: "/catch-all/[...pathParams]",
         schema: (0, superstruct_1.object)({
@@ -26,18 +29,21 @@ const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
 }, { baseUrl: "https://www.uxf.cz" });
 const BASE_URL = "www.uxf.cz";
 test("routeToUrl", async () => {
-    const xml = await createSitemapGenerator({ baseUrl: BASE_URL })
-        .add("index", async () => ({ loc: routeToUrl("index", {}) }))
-        .add("catchAllSegments", async () => ({ loc: routeToUrl("catchAllSegments", { pathParams: ["param-1"] }) }))
-        .add("optionalCatchAllSegments", async () => ({
-        loc: routeToUrl("optionalCatchAllSegments", { pathParams: ["param-1", "param-2"] }),
-        priority: 10,
-    }))
-        .toXml();
+    const xml = await createSitemapGenerator({
+        index: async (route) => ({ loc: routeToUrl(route, { queryParam: "test" }) }),
+        catchAllSegments: async (route) => ({ loc: routeToUrl(route, { pathParams: ["param-1"] }) }),
+        optionalCatchAllSegments: async (route) => ({
+            loc: routeToUrl(route, { pathParams: ["param-1", "param-2"] }),
+            priority: 10,
+        }),
+        skippedRoute: null,
+    }, {
+        baseUrl: BASE_URL,
+    }).toXml();
     expect(xml).toBe(`<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
     <url>
-        <loc>${BASE_URL}/</loc>
+        <loc>${BASE_URL}/?queryParam=test</loc>
     </url>
     <url>
         <loc>${BASE_URL}/catch-all/param-1</loc>

package/routes-check.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env ts-node-script
-export declare function routesCheck(routes: Record<string, string>, shouldProcessExit?: boolean): void;

package/routes-check.js

@@ -1,117 +0,0 @@
-#!/usr/bin/env ts-node-script
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.routesCheck = routesCheck;
-const is_not_empty_1 = require("@uxf/core/utils/is-not-empty");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const true_case_path_1 = require("true-case-path");
-let error = false;
-function fileExists(path) {
-    try {
-        return Boolean((0, true_case_path_1.trueCasePathSync)(path));
-    }
-    catch {
-        return false;
-    }
-}
-function directoryExists(path) {
-    try {
-        const stats = fs_1.default.lstatSync(path);
-        return stats.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Filters out folders used for organizational purposes in the app folder
- * such as parallel routes (e.g., (group)) and dynamic routes ([param]).
- */
-function cleanPathSegments(pathSegments) {
-    return pathSegments.filter((segment) => !segment.startsWith("(") && !segment.endsWith(")"));
-}
-function normalizeDynamicSegment(segment) {
-    return (segment === null || segment === void 0 ? void 0 : segment.startsWith("[")) ? "index" : segment || "";
-}
-/**
- * Checks for collisions in the path (in `baseDir`) * between the `segment.tsx` file and the `segment/` folder within one level.
- *
- * Example:
- * - route `/payments/export` gives segments ["payments", "export"]
- * - check if it exists at the same time `pages/payments.tsx` and `pages/payments/`.
- */
-function checkFolderFileCollision(baseDir, pathSegments) {
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-        const segment = pathSegments[i];
-        const parentDir = (0, path_1.join)(baseDir, ...pathSegments.slice(0, i));
-        const filePath = (0, path_1.join)(parentDir, `${segment}.tsx`);
-        const folderPath = (0, path_1.join)(parentDir, segment);
-        if (fileExists(filePath) && directoryExists(folderPath)) {
-            // eslint-disable-next-line no-console
-            console.log(`Colission: For segment '${segment}' there is file and folder at the same time.\n` +
-                `Replace file ${segment}.tsx with ${segment}/index.tsx.`);
-            throw new Error("Route colission");
-        }
-    }
-}
-function routesCheck(routes, shouldProcessExit = true) {
-    Object.keys(routes).forEach((route) => {
-        const pathname = routes[route];
-        try {
-            const basePath = (0, path_1.join)(__dirname, "..", "..", "src", "pages");
-            const appBasePath = (0, path_1.join)(__dirname, "..", "..", "src", "app");
-            const rawPathSegments = pathname.substring(1).split("/");
-            const pathSegments = cleanPathSegments(rawPathSegments);
-            checkFolderFileCollision(basePath, pathSegments);
-            checkFolderFileCollision(appBasePath, pathSegments);
-            // Find the last segment (e.g. for /payments/export it will be "export")
-            const lastPart = pathSegments.splice(-1);
-            const normalizedLastPart = normalizeDynamicSegment(lastPart.at(0));
-            // --- Checks in `pages` folder ---
-            // 1) path like pages/product.tsx (if it's at "first level")
-            const firstLevelPagePath = (0, path_1.join)(basePath, `${normalizedLastPart}.tsx`);
-            /// 2) path type pages/product/index.tsx
-            const firstLevelFolderPath = (0, path_1.join)(basePath, normalizedLastPart, "index.tsx");
-            // 3) paths for nested pages (pages/payments/export.tsx etc.)
-            const nestedPaths = (0, path_1.join)(basePath, ...pathSegments, `${normalizedLastPart || "index"}.tsx`);
-            const pagePath = (0, is_not_empty_1.isNotEmpty)(pathSegments)
-                ? nestedPaths
-                : fileExists(firstLevelFolderPath)
-                    ? firstLevelFolderPath
-                    : firstLevelPagePath;
-            // --- Checks in `app folder ` ---
-            const appPath = (0, path_1.join)(appBasePath, ...pathSegments, normalizedLastPart, "page.tsx");
-            // Check if the path exists in either `pages` or `app`
-            if (fileExists(pagePath) || fileExists(appPath)) {
-                return; // Valid route
-            }
-            throw new Error("Missing file for route!");
-        }
-        catch (err) {
-            // eslint-disable-next-line no-console
-            console.log("❌ Invalid route: " + pathname);
-            if (err instanceof Error) {
-                // eslint-disable-next-line no-console
-                console.error(err.message);
-            }
-            error = true;
-        }
-    });
-    if (error) {
-        if (shouldProcessExit) {
-            process.exit(1);
-        }
-        throw new Error("At least one invalid route found");
-    }
-    else {
-        if (shouldProcessExit) {
-            process.exit(0);
-        }
-        // eslint-disable-next-line no-console
-        console.log("All routes checked.");
-    }
-}

package/routes-check.test.js

@@ -1,130 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = require("path");
-const true_case_path_1 = require("true-case-path");
-const routes_check_1 = require("./routes-check");
-jest.mock("fs", () => {
-    // Access the actual fs module so we can spread it
-    const actualFs = jest.requireActual("fs");
-    return {
-        ...actualFs,
-        // We'll mock only the function(s) we need
-        lstatSync: jest.fn(),
-    };
-});
-jest.mock("true-case-path", () => ({
-    trueCasePathSync: jest.fn(),
-}));
-const mockTrueCasePathSync = true_case_path_1.trueCasePathSync;
-/**
- * Helper function to mock:
- *  1) Which file paths "exist"
- *  2) Which directory paths "exist"
- */
-function mockFileExists(knownPaths, knownDirs = []) {
-    // Mock the trueCasePathSync behavior (our fileExists check)
-    mockTrueCasePathSync.mockImplementation((inputPath) => {
-        if (knownPaths.includes(inputPath)) {
-            return inputPath; // indicates file exists
-        }
-        throw new Error(`Path not found: ${inputPath}`);
-    });
-    // Mock lstatSync for directory checks
-    fs_1.default.lstatSync.mockImplementation((inputPath) => {
-        if (knownDirs.includes(inputPath)) {
-            return { isDirectory: () => true };
-        }
-        // if it's in knownPaths but not in knownDirs => treat it as a file
-        if (knownPaths.includes(inputPath)) {
-            return { isDirectory: () => false };
-        }
-        // otherwise, it's not found => throw
-        throw new Error(`No such file or directory: ${inputPath}`);
-    });
-}
-const rootDirPages = (0, path_1.join)(__dirname, "..", "..", "src", "pages");
-const rootDirApp = (0, path_1.join)(__dirname, "..", "..", "src", "app");
-describe("routesCheck", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it("should handle multiple valid routes at once (pages + app)", () => {
-        /**
-         *  1) /product   => pages/product/index.tsx
-         *  2) /product/edit => pages/product/edit.tsx
-         *  3) /product/[id] => pages/product/[id].tsx
-         *  4) /dashboard => app/dashboard/page.tsx
-         *  5) /settings/privacy => app/settings/privacy/page.tsx
-         */
-        mockFileExists([
-            // pages
-            (0, path_1.join)(rootDirPages, "product", "index.tsx"),
-            (0, path_1.join)(rootDirPages, "product", "edit.tsx"),
-            (0, path_1.join)(rootDirPages, "product", "[id].tsx"),
-            // app
-            (0, path_1.join)(rootDirApp, "dashboard", "page.tsx"),
-            (0, path_1.join)(rootDirApp, "settings", "privacy", "page.tsx"),
-        ], [
-            // directories
-            (0, path_1.join)(rootDirPages, "product"),
-            (0, path_1.join)(rootDirApp, "dashboard"),
-            (0, path_1.join)(rootDirApp, "settings"),
-            (0, path_1.join)(rootDirApp, "settings", "privacy"),
-        ]);
-        const routes = {
-            product: "/product",
-            productEdit: "/product/edit",
-            productDetail: "/product/[id]",
-            dashboard: "/dashboard",
-            privacy: "/settings/privacy",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).not.toThrow();
-    });
-    it("should fail when invalid routes are provided", () => {
-        /**
-         * We'll test multiple routes that do not exist in either pages or app:
-         *  1) /unknown
-         *  2) /product/unknown
-         */
-        // Intentionally not mocking any matching paths here
-        mockFileExists([]);
-        const routes = {
-            unknown: "/unknown",
-            productUnknown: "/product/unknown",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
-    });
-    it("Pages folder: should detect collisions (file + folder) in multiple segments", () => {
-        /**
-         * Testing collision scenarios together:
-         *  1) /payments/export in pages => collision with payments.tsx + payments/ folder
-         */
-        mockFileExists([
-            // pages collisions
-            (0, path_1.join)(rootDirPages, "payments.tsx"),
-            (0, path_1.join)(rootDirPages, "payments", "export.tsx"),
-        ], [(0, path_1.join)(rootDirPages, "payments")]);
-        const routes = {
-            paymentsExport: "/payments/export",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
-    });
-    it("App folder: should detect that page.tsx is not created for the route", () => {
-        /**
-         * Testing collision scenarios together:
-         *  1) /admin/analytics in app => collision with analytics.tsx + analytics/ folder
-         */
-        mockFileExists([
-            // app collisions
-            (0, path_1.join)(rootDirApp, "admin", "analytics.tsx"),
-        ], [(0, path_1.join)(rootDirApp, "admin"), (0, path_1.join)(rootDirApp, "admin", "analytics")]);
-        const routes = {
-            adminAnalytics: "/admin/analytics",
-        };
-        expect(() => (0, routes_check_1.routesCheck)(routes, false)).toThrow();
-    });
-});