@uxf/router 11.64.3 → 11.72.0

package/README.md

@@ -14,27 +14,53 @@ yarn add @uxf/router
 
 import { createRouter } from "@uxf/router";
 
-interface RouteList {
-    index: null;
-    "admin/index": { param1?: number };
-    "blog/detail": { id: number };
-}
-
-export default createRouter<RouteList>({
-    index: "/",
-    "admin/index": "/admin",
-    "blog/detail": "/blog/[id]",
-});
+export default createRouter(
+    {
+        index: {
+            path: "/"
+        },
+        "admin/index": {
+            path: "/admin",
+            schema: object({
+                param1: optional(number())
+            })
+        },
+        "blog/detail": {
+            path: "/blog/[id]",
+            schema: object({
+                id: number()
+            })
+        },
+        "localized-route": {
+            path: {
+                en: "/en/home",
+                cs: "/cs/domu"
+            },
+            schema: object({
+                term: optional(string()),
+            })
+        }
+    } as const, 
+    { 
+        locales: ["cs", "en"],
+        baseUrl: "https://www.uxf.cz"
+    } as const
+);
 ```
 
 ```ts
 // routes/index.ts
 
-import router, { RouteList } from "./routes";
+import router from "./routes";
 import { UxfGetServerSideProps, UxfGetStaticProps } from "@uxf/router";
 import { PreviewData as NextPreviewData } from "next/types";
 
-export const { route, routeToUrl, sitemapGenerator, useQueryParams } = router;
+export const {
+    routeToUrl, 
+    sitemapGenerator, 
+    useQueryParams, 
+    useQueryParamsStatic 
+} = router;
 
 export type GetStaticProps<
     Route extends keyof RouteList,
@@ -67,12 +93,15 @@ Add configuration to `tsconfig.json`
 ## useQueryParams
 
 ```tsx
-import {useQueryParams} from "@app-routes";
-import {queryParamToNumber} from "./helper";
+import { useQueryParams } from "@app-routes";
+import { queryParamToNumber } from "./helper";
 
-const params = useQueryParams<"route-name">()
+// can be used on SSR pages
+const [query, { push, replace }] = useQueryParams("route-name");
 
-const id = queryParamToNumber(params.id);
+// must be used on static pages, because router is not ready on first render
+// query is null if router is not ready
+const [query, { push, replace }] = useQueryParamsStatic("route-name");
 ```
 
 ## Next Link
@@ -81,10 +110,10 @@ const id = queryParamToNumber(params.id);
 // pages/index.js
 
 import Link from "next/link";
-import { route } from "@app-routes";
+import { routeToUrl } from "@app-routes";
 
 export default () => (
-    <Link href={route("blog/detail", { id: 12 })}>
+    <Link href={routeToUrl("blog/detail", { id: 12 })}>
       Hello world
     </Link>
 )

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/router",
-    "version": "11.64.3",
+    "version": "11.72.0",
     "description": "UXF Router",
     "author": "UXFans <dev@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/router#readme",
@@ -23,7 +23,8 @@
         "url": "https://gitlab.com/uxf-npm/router/issues"
     },
     "dependencies": {
-        "qs": "6.13.0"
+        "qs": "6.13.0",
+        "superstruct": "2.0.2"
     },
     "peerDependencies": {
         "next": ">= 12"

package/router.d.ts

@@ -1,22 +1,52 @@
 import { LinkProps } from "next/link";
+import { Infer, Struct } from "superstruct";
 import { SitemapGeneratorOptions, SitemapGeneratorType } from "./sitemap-generator";
-import { QueryParams } from "./types";
-export type FunctionParametersGenerator<RouteList> = {
-    [K in keyof RouteList]: RouteList[K] extends null ? [K] : [K, RouteList[K]];
+import { QueryParams, RoutesDefinition } from "./types";
+type ExtractSchema<T> = T extends {
+    schema: Struct<infer U, any>;
+} ? U : null;
+type Options = {
+    shouldBeAbsolute?: boolean;
+};
+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>];
 }[keyof RouteList];
-type RouteFunction<RouteList> = (...args: FunctionParametersGenerator<RouteList>) => LinkProps["href"];
-type RouteToUrlFunction<RouteList> = (...args: FunctionParametersGenerator<RouteList>) => string;
-type Router<RouteList> = {
-    route: RouteFunction<RouteList>;
-    routeToUrl: RouteToUrlFunction<RouteList>;
-    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
-    routes: {
-        [key in keyof RouteList]: string;
-    };
-    useActiveRoute: () => keyof RouteList;
-    useQueryParams: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
+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;
+type QueryParamsResult<Nullable extends boolean, T extends keyof RouteList, Locales extends string[], RouteList extends RoutesDefinition<Locales>> = [
+    Nullable extends true ? Infer<NonNullable<RouteList[T]["schema"]>> | null : Infer<NonNullable<RouteList[T]["schema"]>>,
+    {
+        push: (params: Infer<NonNullable<RouteList[T]["schema"]>>) => Promise<boolean>;
+        replace: (params: Infer<NonNullable<RouteList[T]["schema"]>>) => Promise<boolean>;
+    }
+];
+type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    route: RouteFunction<Locales, RouteList>;
+    routeToUrl: RouteToUrlFunction<Locales, RouteList>;
+    createSitemapGenerator: (options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
+    routes: RouteList;
+    useActiveRoute: () => ActiveRoute<Locales, RouteList>;
+    /**
+     * @deprecated use useQueryParamsStatic or useQueryParams instead
+     */
+    useQueryParamsDeprecated: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
+    useQueryParams: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<false, T, Locales, RouteList>;
+    useQueryParamsStatic: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<true, T, Locales, RouteList>;
+};
+type RouterOptions<L extends string[]> = {
+    baseUrl?: string;
+    locales?: L;
+};
+type ActiveRoute<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+    route: keyof RouteList;
+    locale: Locales[number] | null;
 };
-export declare function createRouter<RouteList>(routes: {
-    [key in keyof RouteList]: string;
-}): Router<RouteList>;
+export declare function createRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>>(routes: RouteList, routerOptions: RouterOptions<Locales>): Router<Locales, RouteList>;
 export {};

package/router.js

@@ -2,18 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRouter = createRouter;
 const empty_object_1 = require("@uxf/core/constants/empty-object");
+const throw_error_1 = require("@uxf/core/utils/throw-error");
 const router_1 = require("next/router");
 const qs_1 = require("qs");
+const superstruct_1 = require("superstruct");
 const sitemap_generator_1 = require("./sitemap-generator");
-function createRouter(routes) {
+/**
+ * Arguments can be:
+ *
+ * [routeName, params, options]
+ */
+function decodeArgs(args) {
+    return { route: args[0], params: args[1], options: args[2] };
+}
+function createRouter(routes, routerOptions) {
     return {
-        route: (route, params = undefined) => ({
-            pathname: routes[route],
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            query: params !== null && params !== void 0 ? params : null,
-        }),
-        routeToUrl: (route, params = undefined) => {
-            let pathname = routes[route];
+        route(...args) {
+            var _a;
+            const { route, params, options } = decodeArgs(args);
+            return {
+                pathname: typeof routes[route].path === "string"
+                    ? routes[route].path
+                    : routes[route].path[(_a = options === null || options === void 0 ? void 0 : options.locale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Locale is required")],
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                query: params !== null && params !== void 0 ? params : null,
+            };
+        },
+        routeToUrl(...args) {
+            var _a;
+            const { route, params, options } = decodeArgs(args);
+            let pathname = typeof routes[route].path === "string"
+                ? routes[route].path
+                : routes[route].path[(_a = options === null || options === void 0 ? void 0 : options.locale) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)("Locale is required")];
             if (!pathname) {
                 throw new Error(`Route '${String(route)}' not found.`);
             }
@@ -61,18 +81,55 @@ function createRouter(routes) {
             if (Object.keys(restParams).length > 0) {
                 pathname = `${pathname}?${(0, qs_1.stringify)(restParams, { arrayFormat: "repeat" })}`;
             }
-            return pathname;
+            return (options === null || options === void 0 ? void 0 : options.shouldBeAbsolute) ? `${routerOptions.baseUrl}${pathname}` : pathname;
         },
-        useActiveRoute: () => {
+        useActiveRoute() {
+            var _a;
             const router = (0, router_1.useRouter)();
-            const activeRoute = Object.keys(routes).find((route) => routes[route] === router.pathname);
+            const activeRoute = Object.keys(routes).find((route) => typeof routes[route].path === "string"
+                ? routes[route].path === router.pathname
+                : Object.values(routes[route].path).includes(router.pathname));
             if (!activeRoute) {
                 throw new Error("Active route not found.");
             }
-            return activeRoute;
+            return {
+                route: activeRoute,
+                locale: ((_a = router.locale) !== null && _a !== void 0 ? _a : null),
+            };
         },
         createSitemapGenerator: sitemap_generator_1.createSitemapGenerator,
         routes,
-        useQueryParams: () => (0, router_1.useRouter)().query,
+        useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
+        useQueryParams(routeName) {
+            const router = (0, router_1.useRouter)();
+            const schema = routes[routeName].schema;
+            if (!schema) {
+                throw new Error(`Route '${String(routeName)}' has no schema.`);
+            }
+            if (router.isReady) {
+                throw new Error("Router is not ready. Use useQueryParamsStatic instead of useQueryParams.");
+            }
+            return [
+                (0, superstruct_1.mask)(router.query, schema),
+                {
+                    push: (params) => router.push(this.routeToUrl(routeName, params, {})),
+                    replace: (params) => router.replace(this.routeToUrl(routeName, params, {})),
+                },
+            ];
+        },
+        useQueryParamsStatic(routeName) {
+            const router = (0, router_1.useRouter)();
+            const schema = routes[routeName].schema;
+            if (!schema) {
+                throw new Error(`Route '${String(routeName)}' has no schema.`);
+            }
+            return [
+                router.isReady ? (0, superstruct_1.mask)(router.query, schema) : null,
+                {
+                    push: (params) => router.push(this.routeToUrl(routeName, params, {})),
+                    replace: (params) => router.replace(this.routeToUrl(routeName, params, {})),
+                },
+            ];
+        },
     };
 }

package/router.test.js

@@ -1,20 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const superstruct_1 = require("superstruct");
 const router_1 = require("./router");
+const superstruct_2 = require("./superstruct");
 const { routeToUrl } = (0, router_1.createRouter)({
-    index: "/",
-    catchAllSegments: "/catch-all/[...pathParams]",
-    optionalCatchAllSegments: "/catch-all-optional/[[...pathParams]]",
+    index: {
+        path: "/",
+        schema: (0, superstruct_1.object)({
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    catchAllSegments: {
+        path: "/catch-all/[...pathParams]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_2.array)((0, superstruct_1.string)()),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    optionalCatchAllSegments: {
+        path: "/catch-all-optional/[[...pathParams]]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.optional)((0, superstruct_1.nullable)((0, superstruct_1.union)([(0, superstruct_2.array)((0, superstruct_1.string)()), (0, superstruct_1.string)()]))),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    routeWithoutParams: {
+        path: "/route-without-params",
+    },
+    localizedRouteWithoutParams: {
+        path: {
+            cs: "/lokalizovany-odkaz",
+            en: "/localized-url",
+        },
+    },
+    localizedRouteWithParams: {
+        path: {
+            cs: "/lokalizovany-odkaz-s-parametry",
+            en: "/localized-url-with-parameters",
+        },
+        schema: (0, superstruct_1.object)({
+            test: (0, superstruct_1.string)(),
+        }),
+    },
+}, {
+    locales: ["cs", "en"],
+    baseUrl: "https://www.uxf.cz",
 });
+const DATA = [
+    {
+        actual: routeToUrl("index", {}),
+        expected: "/",
+    },
+    {
+        actual: routeToUrl("index", { queryParam: "value" }),
+        expected: "/?queryParam=value",
+    },
+    {
+        actual: routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"] }),
+        expected: "/catch-all/param1/param2",
+    },
+    {
+        actual: routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" }),
+        expected: "/catch-all/param1/param2?queryParam=value",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" }),
+        expected: "/catch-all-optional/param1/param2?queryParam=value",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: [] }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: null }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: undefined }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: "" }),
+        expected: "/catch-all-optional",
+    },
+    {
+        actual: routeToUrl("optionalCatchAllSegments", { pathParams: "", queryParam: "value" }),
+        expected: "/catch-all-optional?queryParam=value",
+    },
+    {
+        actual: routeToUrl("routeWithoutParams"),
+        expected: "/route-without-params",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "en" }),
+        expected: "/localized-url",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "cs" }),
+        expected: "/lokalizovany-odkaz",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "en" }),
+        expected: "/localized-url-with-parameters?test=value",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "cs" }),
+        expected: "/lokalizovany-odkaz-s-parametry?test=value",
+    },
+    {
+        actual: routeToUrl("index", { queryParam: "value" }, { shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/?queryParam=value",
+    },
+    {
+        actual: routeToUrl("routeWithoutParams", null, { shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/route-without-params",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithoutParams", null, { locale: "cs", shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/lokalizovany-odkaz",
+    },
+    {
+        actual: routeToUrl("localizedRouteWithParams", { test: "value" }, { locale: "en", shouldBeAbsolute: true }),
+        expected: "https://www.uxf.cz/localized-url-with-parameters?test=value",
+    },
+];
 test("routeToUrl", () => {
-    expect(routeToUrl("index", {})).toBe("/");
-    expect(routeToUrl("index", { queryParam: "value" })).toBe("/?queryParam=value");
-    expect(routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"] })).toBe("/catch-all/param1/param2");
-    expect(routeToUrl("catchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" })).toBe("/catch-all/param1/param2?queryParam=value");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: ["param1", "param2"], queryParam: "value" })).toBe("/catch-all-optional/param1/param2?queryParam=value");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: [] })).toBe("/catch-all-optional");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: null })).toBe("/catch-all-optional");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: undefined })).toBe("/catch-all-optional");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: "" })).toBe("/catch-all-optional");
-    expect(routeToUrl("optionalCatchAllSegments", { pathParams: "", queryParam: "value" })).toBe("/catch-all-optional?queryParam=value");
+    DATA.map(({ actual, expected }) => expect(actual).toBe(expected));
 });

package/routes-check.d.ts

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

package/routes-check.js

@@ -0,0 +1,117 @@
+#!/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.d.ts

@@ -0,0 +1 @@
+export {};

package/routes-check.test.js

@@ -0,0 +1,130 @@
+"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();
+    });
+});

package/sitemap-generator.d.ts

@@ -1,3 +1,4 @@
+import { RoutesDefinition } from "./types";
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
 export type SitemapItem = {
     loc: string;
@@ -11,10 +12,10 @@ type MissingRoutesError<Routes> = {
     __nonExhaustive: never;
     missingRoutes: Routes;
 };
-export type SitemapGeneratorType<RouteList> = {
-    add: <Route extends keyof RouteList>(route: Route, resolver: RouteResolver<Route>) => SitemapGeneratorType<Omit<RouteList, Route>>;
-    skip: <Route extends keyof RouteList>(route: Route) => SitemapGeneratorType<Omit<RouteList, Route>>;
-    exhaustive: keyof RouteList extends never ? () => SitemapGeneratorType<RouteList> : MissingRoutesError<keyof RouteList>;
+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>;
 };
@@ -23,5 +24,5 @@ export type SitemapGeneratorOptions = {
     defaultPriority?: number;
     defaultChangeFreq?: ChangeFrequency;
 };
-export declare const createSitemapGenerator: <RouteList>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<RouteList>;
+export declare const createSitemapGenerator: <Locales extends string[], RouteList extends RoutesDefinition<Locales>>(options?: SitemapGeneratorOptions) => SitemapGeneratorType<Locales, RouteList>;
 export {};

package/sitemap-generator.test.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const superstruct_1 = require("superstruct");
 const router_1 = require("./router");
 const { createSitemapGenerator, routeToUrl } = (0, router_1.createRouter)({
-    index: "/",
-    catchAllSegments: "/catch-all/[...pathParams]",
-    optionalCatchAllSegments: "/catch-all-optional/[[...pathParams]]",
-});
+    index: {
+        path: "/",
+        schema: (0, superstruct_1.object)({
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    catchAllSegments: {
+        path: "/catch-all/[...pathParams]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.array)(),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+    optionalCatchAllSegments: {
+        path: "/catch-all-optional/[[...pathParams]]",
+        schema: (0, superstruct_1.object)({
+            pathParams: (0, superstruct_1.optional)((0, superstruct_1.nullable)((0, superstruct_1.union)([(0, superstruct_1.array)(), (0, superstruct_1.string)()]))),
+            queryParam: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+        }),
+    },
+}, { baseUrl: "https://www.uxf.cz" });
 const BASE_URL = "www.uxf.cz";
 test("routeToUrl", async () => {
     const xml = await createSitemapGenerator({ baseUrl: BASE_URL })

package/superstruct/array.d.ts

@@ -0,0 +1,7 @@
+import { Infer, Struct } from "superstruct";
+/**
+ * NextJS používá následující zápis pole v url  `?item=a&item=b&item=c`
+ *
+ * Není teda schopen rozeznat, zda parametr `?item=a` je pole o jednom prvku nebo pouze string
+ */
+export declare function array<T extends Struct<any>>(inner: T): Struct<Infer<T>[], null>;

package/superstruct/array.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = array;
+const superstruct_1 = require("superstruct");
+/**
+ * NextJS používá následující zápis pole v url  `?item=a&item=b&item=c`
+ *
+ * Není teda schopen rozeznat, zda parametr `?item=a` je pole o jednom prvku nebo pouze string
+ */
+function array(inner) {
+    return (0, superstruct_1.coerce)((0, superstruct_1.array)(inner), (0, superstruct_1.union)([(0, superstruct_1.string)(), (0, superstruct_1.array)((0, superstruct_1.string)())]), (value) => {
+        return Array.isArray(value) ? value : [value];
+    });
+}

package/superstruct/boolean.d.ts

@@ -0,0 +1 @@
+export declare const boolean: () => import("superstruct").Struct<boolean, null>;

package/superstruct/boolean.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const superstruct_1 = require("superstruct");
+const boolean = () => (0, superstruct_1.coerce)((0, superstruct_1.boolean)(), (0, superstruct_1.string)(), (value) => {
+    return value === "1" || value === "true" || value === "";
+});
+exports.boolean = boolean;

package/superstruct/index.d.ts

@@ -0,0 +1,4 @@
+export { object, optional, string } from "superstruct";
+export * from "./array";
+export * from "./boolean";
+export * from "./integer";

package/superstruct/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.optional = exports.object = void 0;
+var superstruct_1 = require("superstruct");
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return superstruct_1.object; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return superstruct_1.optional; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return superstruct_1.string; } });
+__exportStar(require("./array"), exports);
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./integer"), exports);

package/superstruct/integer.d.ts

@@ -0,0 +1 @@
+export declare const integer: () => import("superstruct").Struct<number, null>;

package/superstruct/integer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integer = void 0;
+const superstruct_1 = require("superstruct");
+const integer = () => (0, superstruct_1.coerce)((0, superstruct_1.integer)(), (0, superstruct_1.string)(), (value) => {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed)) {
+        throw new Error("Invalid number string");
+    }
+    return parsed;
+});
+exports.integer = integer;

package/types.d.ts

@@ -1,4 +1,9 @@
 import { GetServerSideProps, GetStaticProps, PreviewData as NextPreviewData } from "next";
+import { Struct } from "superstruct";
+export type RoutesDefinition<Locales extends string[]> = Record<string, {
+    path: string | Record<Locales[number], string>;
+    schema?: Struct<any, any> | null;
+}>;
 export type QueryParams<RouteList, Route extends keyof RouteList> = RouteList[Route] extends null ? never : {
     [key in keyof RouteList[Route]]: string | string[] | undefined;
 };