@uxf/router 11.114.0 → 11.120.0

package/README.md

@@ -6,61 +6,64 @@
 yarn add @uxf/router
 ```
 
-- Create `routes` directory
-- Create `routes.ts` and `index.ts` inside `routes` directory:
+There are two factories:
 
-```ts
-// routes/routes.ts
+- `createRouter` from `@uxf/router` is the default. It is server-safe (no React hooks, no client-only imports) and can be used anywhere, including React Server Components. It returns `routeToUrl`, `route`, `routes`, `getRouteInfo`, `createRouteMatcher` and `createSitemapGenerator`.
+- `createClientRouter` from `@uxf/router/client` is a superset that adds the React hooks (`useQueryParams`, `useQueryParamsStatic`, `usePageParams`, `useRouteInfo`). It imports `next/navigation` and `next/router`, so it must only be used in client components.
 
-import { createRouter } from "@uxf/router";
+Define the routes once as plain data, then build each router from it:
 
-export default createRouter(
-    {
-        index: {
-            path: "/"
-        },
-        "admin/index": {
-            path: "/admin",
-            schema: object({
-                param1: optional(number())
-            })
-        },
-        "blog/detail": {
-            path: "/blog/[id]",
-            schema: object({
-                id: number()
-            })
+```ts
+// routes/routes.ts – plain route definitions, importable anywhere
+
+import { number, object, optional, string } from "superstruct";
+
+export const routes = {
+    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",
         },
-        "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
-);
+        schema: object({
+            term: optional(string()),
+        }),
+    },
+} as const;
+
+export const routerOptions = {
+    locales: ["cs", "en"],
+    baseUrl: "https://www.uxf.cz",
+} as const;
+
+export type RouteList = typeof routes;
 ```
 
 ```ts
-// routes/index.ts
+// routes/index.ts – server-safe entry (`@app-routes`), usable in RSC
 
-import router from "./routes";
-import { UxfGetServerSideProps, UxfGetStaticProps, ExtractSchema } from "@uxf/router";
+import { createRouter, ExtractSchema, UxfGetServerSideProps, UxfGetStaticProps } from "@uxf/router";
 import { PreviewData as NextPreviewData } from "next/types";
+import { RouteList, routerOptions, routes } from "./routes";
 
-export const {
-    routeToUrl, 
-    sitemapGenerator, 
-    useQueryParams, 
-    useQueryParamsStatic 
-} = router;
+export const { route, routeToUrl, getRouteInfo, createRouteMatcher, createSitemapGenerator } = createRouter(
+    routes,
+    routerOptions,
+);
 
 export type GetRouteSchema<K extends keyof RouteList> = ExtractSchema<RouteList[K]>;
 
@@ -68,13 +71,27 @@ export type GetStaticProps<
     Route extends keyof RouteList,
     Props extends { [key: string]: any } = { [key: string]: any },
     PreviewData extends NextPreviewData = NextPreviewData,
-    > = UxfGetStaticProps<RouteList, Route, Props, PreviewData>;
+> = UxfGetStaticProps<RouteList, Route, Props, PreviewData>;
 
 export type GetServerSideProps<
     Route extends keyof RouteList,
     Props extends { [key: string]: any } = { [key: string]: any },
     PreviewData extends NextPreviewData = NextPreviewData,
-    > = UxfGetServerSideProps<RouteList, Route, Props, PreviewData>;
+> = UxfGetServerSideProps<RouteList, Route, Props, PreviewData>;
+```
+
+```ts
+// routes/client.ts – client entry (`@app-routes/client`), hooks for client components
+
+"use client";
+
+import { createClientRouter } from "@uxf/router/client";
+import { routerOptions, routes } from "./routes";
+
+export const { useQueryParams, useQueryParamsStatic, usePageParams, useRouteInfo } = createClientRouter(
+    routes,
+    routerOptions,
+);
 ```
 
 Add configuration to `tsconfig.json`
@@ -86,6 +103,9 @@ Add configuration to `tsconfig.json`
     "paths": {
       "@app-routes": [
         "routes"
+      ],
+      "@app-routes/client": [
+        "routes/client"
       ]
     }
   }
@@ -94,9 +114,11 @@ Add configuration to `tsconfig.json`
 
 ## useQueryParams
 
+Hooks live in the client entry (`@app-routes/client`):
+
 ```tsx
-import { useQueryParams } from "@app-routes";
-import { queryParamToNumber } from "./helper";
+import { useQueryParams } from "@app-routes/client";
+import { queryParamToNumber } from "@uxf/router";
 
 // can be used on SSR pages
 const [query, { push, replace }] = useQueryParams("route-name");

package/client.d.ts

@@ -0,0 +1 @@
+export * from "./create-client-router";

package/client.js

@@ -0,0 +1,23 @@
+"use strict";
+"use client";
+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 });
+// Client entry point for `@uxf/router/client`.
+//
+// Exposes `createClientRouter` – a superset of `createRouter` (`@uxf/router`) that adds the React
+// hooks. It imports client-only modules (`next/navigation`, `next/router`), so it must not be
+// imported into React Server Components. For server-safe usage import from `@uxf/router` instead.
+__exportStar(require("./create-client-router"), exports);

package/create-client-router.d.ts

@@ -0,0 +1,44 @@
+import { Params } from "next/dist/server/request/params";
+import { Infer } from "superstruct";
+import { RouteInfo, Router, RouterOptions } from "./create-router";
+import { QueryParams, RoutesDefinition } from "./types";
+export interface TransitionOptions {
+    shallow?: boolean;
+    locale?: string | false;
+    scroll?: boolean;
+    unstable_skipClientCache?: boolean;
+}
+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"]>>, options?: TransitionOptions) => Promise<boolean>;
+        replace: (params: Infer<NonNullable<RouteList[T]["schema"]>>, options?: TransitionOptions) => Promise<boolean>;
+    }
+];
+/**
+ * The client router – a superset of `createRouter` (`@uxf/router`) that adds the React hooks.
+ * Lives in a separate client-only module (`@uxf/router/client`) because it imports `next/navigation`
+ * and `next/router`, which are not safe to pull into React Server Components.
+ */
+export type ClientRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = Router<Locales, RouteList> & {
+    useRouteInfo: () => RouteInfo | null;
+    /**
+     * @deprecated use useQueryParamsStatic or useQueryParams instead
+     */
+    useQueryParamsDeprecated: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
+    /**
+     * Returns path params merged with search params
+     */
+    usePageParams: () => Params | null;
+    useQueryParams: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<false, T, Locales, RouteList>;
+    useQueryParamsStatic: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<true, T, Locales, RouteList>;
+};
+/**
+ * Creates the client router – everything `createRouter` returns plus the React hooks
+ * (`useQueryParams`, `useQueryParamsStatic`, `usePageParams`, `useRouteInfo`).
+ *
+ * Use this in client components. For server-safe usage (including React Server Components) use
+ * `createRouter` from `@uxf/router` instead.
+ */
+export declare function createClientRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>>(routes: RouteList, routerOptions: RouterOptions<Locales>): ClientRouter<Locales, RouteList>;
+export {};

package/create-client-router.js

@@ -0,0 +1,100 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientRouter = createClientRouter;
+const is_nil_1 = require("@uxf/core/utils/is-nil");
+const is_not_nil_1 = require("@uxf/core/utils/is-not-nil");
+const throw_error_1 = require("@uxf/core/utils/throw-error");
+const navigation_1 = require("next/navigation");
+const router_1 = require("next/router");
+const superstruct_1 = require("superstruct");
+const create_router_1 = require("./create-router");
+/**
+ * Creates the client router – everything `createRouter` returns plus the React hooks
+ * (`useQueryParams`, `useQueryParamsStatic`, `usePageParams`, `useRouteInfo`).
+ *
+ * Use this in client components. For server-safe usage (including React Server Components) use
+ * `createRouter` from `@uxf/router` instead.
+ */
+function createClientRouter(routes, routerOptions) {
+    const base = (0, create_router_1.createRouter)(routes, routerOptions);
+    const { routeToUrl, getRouteInfo } = base;
+    const useRouteInfo = () => {
+        const pathname = (0, navigation_1.usePathname)();
+        return (0, is_not_nil_1.isNotNil)(pathname) ? getRouteInfo(pathname) : null;
+    };
+    const usePageParams = () => {
+        const searchParams = (0, navigation_1.useSearchParams)();
+        const params = (0, navigation_1.useParams)();
+        if ((0, is_nil_1.isNil)(searchParams) || (0, is_nil_1.isNil)(params)) {
+            return null;
+        }
+        // Collect all query params, handling duplicate keys as arrays
+        const queryParams = Array.from(searchParams.entries()).reduce((acc, [key, value]) => {
+            const existing = acc[key];
+            if (existing === undefined) {
+                // First occurrence - set as single value
+                acc[key] = value;
+            }
+            else if (Array.isArray(existing)) {
+                // Already an array - append
+                existing.push(value);
+            }
+            else {
+                // Second occurrence - convert to array
+                acc[key] = [existing, value];
+            }
+            return acc;
+        }, {});
+        return { ...params, ...queryParams };
+    };
+    return {
+        ...base,
+        useRouteInfo,
+        usePageParams,
+        useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
+        useQueryParams(routeName) {
+            var _a;
+            const router = (0, navigation_1.useRouter)();
+            const pageParams = usePageParams();
+            if ((0, is_nil_1.isNil)(pageParams)) {
+                throw new Error("Router is not ready. Use useQueryParamsStatic instead of useQueryParams.");
+            }
+            const schema = (_a = routes[routeName].schema) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)(`Route '${String(routeName)}' has no schema.`);
+            return [
+                (0, superstruct_1.mask)(pageParams, schema),
+                {
+                    push: (params, options) => {
+                        router.push(routeToUrl(routeName, params, {}), options);
+                        return Promise.resolve(true); // remove me
+                    },
+                    replace: (params, options) => {
+                        router.replace(routeToUrl(routeName, params, {}), options);
+                        return Promise.resolve(true); // remove me
+                    },
+                },
+            ];
+        },
+        useQueryParamsStatic(routeName) {
+            const router = (0, navigation_1.useRouter)();
+            const pageParams = usePageParams();
+            const schema = routes[routeName].schema;
+            if (!schema) {
+                throw new Error(`Route '${String(routeName)}' has no schema.`);
+            }
+            return [
+                (0, is_not_nil_1.isNotNil)(pageParams) ? (0, superstruct_1.mask)(pageParams, schema) : null,
+                {
+                    push: (params) => {
+                        router.push(routeToUrl(routeName, params, {}));
+                        return Promise.resolve(true); // remove me
+                    },
+                    replace: (params) => {
+                        router.replace(routeToUrl(routeName, params, {}));
+                        return Promise.resolve(true); // remove me
+                    },
+                },
+            ];
+        },
+    };
+}

package/{router.d.ts → create-router.d.ts}

@@ -1,14 +1,7 @@
-import { Params } from "next/dist/server/request/params";
-import { LinkProps } from "next/link";
-import { Infer, Struct } from "superstruct";
+import type { LinkProps } from "next/link";
+import type { Struct } from "superstruct";
 import { SitemapGeneratorOptions, SitemapGeneratorType, SitemapRouteResolvers } from "./sitemap-generator";
-import { QueryParams, RouteDefinition, RoutesDefinition } from "./types";
-export interface TransitionOptions {
-    shallow?: boolean;
-    locale?: string | false;
-    scroll?: boolean;
-    unstable_skipClientCache?: boolean;
-}
+import { RouteDefinition, RoutesDefinition } from "./types";
 export type ExtractSchema<T> = T extends {
     schema: Struct<infer U, any>;
 } ? U : null;
@@ -26,39 +19,28 @@ export type FunctionParametersGeneratorWithPartialParams<Locales extends string[
 }[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;
-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"]>>, options?: TransitionOptions) => Promise<boolean>;
-        replace: (params: Infer<NonNullable<RouteList[T]["schema"]>>, options?: TransitionOptions) => Promise<boolean>;
-    }
-];
 export type RouteMatcher = (pathname: string, pathParams?: Record<string, string | string[]>) => boolean;
-type RouteInfo = {
+export type RouteInfo = {
     pathname: string;
     routeName: string;
     routeDefinition: RouteDefinition<any>;
 };
-type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
+/**
+ * The router. Contains only pure URL/route helpers – no React hooks and no client-only imports
+ * (`next/navigation`, `next/router`), so it is safe to import into React Server Components.
+ *
+ * For the React hooks (`useQueryParams`, `usePageParams`, …) use `createClientRouter`
+ * from `@uxf/router/client`, which is a superset of this router.
+ */
+export type Router<Locales extends string[], RouteList extends RoutesDefinition<Locales>> = {
     route: RouteFunction<Locales, RouteList>;
     routeToUrl: RouteToUrlFunction<Locales, RouteList>;
     createSitemapGenerator: (resolvers: SitemapRouteResolvers<Locales, RouteList>, options?: SitemapGeneratorOptions) => SitemapGeneratorType;
     routes: RouteList;
     getRouteInfo: (pathname: string) => RouteInfo | null;
-    useRouteInfo: () => RouteInfo | null;
-    /**
-     * @deprecated use useQueryParamsStatic or useQueryParams instead
-     */
-    useQueryParamsDeprecated: <T extends keyof RouteList>() => QueryParams<RouteList, T>;
-    /**
-     * Returns path params merged with search params
-     */
-    usePageParams: () => Params | null;
-    useQueryParams: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<false, T, Locales, RouteList>;
-    useQueryParamsStatic: <T extends keyof RouteList>(routeName: T) => QueryParamsResult<true, T, Locales, RouteList>;
     createRouteMatcher: (...args: FunctionParametersGeneratorWithPartialParams<Locales, RouteList>) => RouteMatcher;
 };
-type RouterOptions<L extends string[]> = {
+export type RouterOptions<L extends string[]> = {
     baseUrl?: string;
     locales?: L;
 };
@@ -66,5 +48,13 @@ export type ExtendedRouteDefinition<Locales extends string[]> = RouteDefinition<
     regex: RegExp[];
 };
 export type ExtendedRoutesDefinition<Locales extends string[]> = Record<string, ExtendedRouteDefinition<Locales>>;
+/**
+ * Creates the router – URL building, route matching and sitemap generation.
+ *
+ * This is the server-safe default: it contains no React hooks and no client-only imports, so it can
+ * be used anywhere, including React Server Components. If you need the React hooks (`useQueryParams`,
+ * `usePageParams`, …) use `createClientRouter` from `@uxf/router/client` instead – it returns
+ * everything this router does plus the hooks.
+ */
 export declare function createRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>>(routes: RouteList, routerOptions: RouterOptions<Locales>): Router<Locales, RouteList>;
 export {};

package/{router.js → create-router.js}

@@ -2,13 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRouter = createRouter;
 const empty_object_1 = require("@uxf/core/constants/empty-object");
-const is_nil_1 = require("@uxf/core/utils/is-nil");
-const is_not_nil_1 = require("@uxf/core/utils/is-not-nil");
 const qs_1 = require("@uxf/core/utils/qs");
 const throw_error_1 = require("@uxf/core/utils/throw-error");
-const navigation_1 = require("next/navigation");
-const router_1 = require("next/router");
-const superstruct_1 = require("superstruct");
 const sitemap_generator_1 = require("./sitemap-generator");
 const path_to_regex_1 = require("./utils/path-to-regex");
 /**
@@ -19,6 +14,14 @@ const path_to_regex_1 = require("./utils/path-to-regex");
 function decodeArgs(args) {
     return { route: args[0], params: args[1], options: args[2] };
 }
+/**
+ * Creates the router – URL building, route matching and sitemap generation.
+ *
+ * This is the server-safe default: it contains no React hooks and no client-only imports, so it can
+ * be used anywhere, including React Server Components. If you need the React hooks (`useQueryParams`,
+ * `usePageParams`, …) use `createClientRouter` from `@uxf/router/client` instead – it returns
+ * everything this router does plus the hooks.
+ */
 function createRouter(routes, routerOptions) {
     const routesWithRegex = Object.entries(routes).reduce((acc, [routeName, routeDefinition]) => ({
         ...acc,
@@ -94,35 +97,6 @@ function createRouter(routes, routerOptions) {
             routeDefinition: entry[1],
         };
     };
-    const useRouteInfo = () => {
-        const pathname = (0, navigation_1.usePathname)();
-        return (0, is_not_nil_1.isNotNil)(pathname) ? getRouteInfo(pathname) : null;
-    };
-    const usePageParams = () => {
-        const searchParams = (0, navigation_1.useSearchParams)();
-        const params = (0, navigation_1.useParams)();
-        if ((0, is_nil_1.isNil)(searchParams) || (0, is_nil_1.isNil)(params)) {
-            return null;
-        }
-        // Collect all query params, handling duplicate keys as arrays
-        const queryParams = Array.from(searchParams.entries()).reduce((acc, [key, value]) => {
-            const existing = acc[key];
-            if (existing === undefined) {
-                // First occurrence - set as single value
-                acc[key] = value;
-            }
-            else if (Array.isArray(existing)) {
-                // Already an array - append
-                existing.push(value);
-            }
-            else {
-                // Second occurrence - convert to array
-                acc[key] = [existing, value];
-            }
-            return acc;
-        }, {});
-        return { ...params, ...queryParams };
-    };
     return {
         route(...args) {
             var _a;
@@ -140,52 +114,6 @@ function createRouter(routes, routerOptions) {
         },
         routes,
         getRouteInfo,
-        useRouteInfo,
-        usePageParams,
-        useQueryParamsDeprecated: () => (0, router_1.useRouter)().query,
-        useQueryParams(routeName) {
-            var _a;
-            const router = (0, navigation_1.useRouter)();
-            const pageParams = usePageParams();
-            if ((0, is_nil_1.isNil)(pageParams)) {
-                throw new Error("Router is not ready. Use useQueryParamsStatic instead of useQueryParams.");
-            }
-            const schema = (_a = routes[routeName].schema) !== null && _a !== void 0 ? _a : (0, throw_error_1.throwError)(`Route '${String(routeName)}' has no schema.`);
-            return [
-                (0, superstruct_1.mask)(pageParams, schema),
-                {
-                    push: (params, options) => {
-                        router.push(routeToUrl(routeName, params, {}), options);
-                        return Promise.resolve(true); // remove me
-                    },
-                    replace: (params, options) => {
-                        router.replace(routeToUrl(routeName, params, {}), options);
-                        return Promise.resolve(true); // remove me
-                    },
-                },
-            ];
-        },
-        useQueryParamsStatic(routeName) {
-            const router = (0, navigation_1.useRouter)();
-            const pageParams = usePageParams();
-            const schema = routes[routeName].schema;
-            if (!schema) {
-                throw new Error(`Route '${String(routeName)}' has no schema.`);
-            }
-            return [
-                (0, is_not_nil_1.isNotNil)(pageParams) ? (0, superstruct_1.mask)(pageParams, schema) : null,
-                {
-                    push: (params) => {
-                        router.push(routeToUrl(routeName, params, {}));
-                        return Promise.resolve(true); // remove me
-                    },
-                    replace: (params) => {
-                        router.replace(routeToUrl(routeName, params, {}));
-                        return Promise.resolve(true); // remove me
-                    },
-                },
-            ];
-        },
         createRouteMatcher(...args) {
             const [requiredRouteName, requiredParams] = args;
             return (pathname, pageParams) => {

package/{router.test.js → create-router.test.js}

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
 const superstruct_1 = require("superstruct");
+const create_router_1 = require("./create-router");
 const merge_route_matchers_1 = require("./merge-route-matchers");
-const router_1 = require("./router");
 const superstruct_2 = require("./superstruct");
-const { routeToUrl, createRouteMatcher } = (0, router_1.createRouter)({
+const { routeToUrl, createRouteMatcher } = (0, create_router_1.createRouter)({
     index: {
         path: "/",
         schema: (0, superstruct_1.object)({
@@ -168,3 +170,11 @@ test("merge route matchers", () => {
         param2: "any",
     })).toBe(false);
 });
+// Guards the RSC-safety invariant: the router must not pull in any client-only modules.
+test("create-router has no client-only imports", () => {
+    const source = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, "create-router.ts"), "utf8");
+    expect(source).not.toMatch(/from "next\/navigation"/);
+    expect(source).not.toMatch(/from "next\/router"/);
+    expect(source).not.toMatch(/from "react"/);
+    expect(source).not.toMatch(/from "react-dom"/);
+});

package/index.d.ts

@@ -1,4 +1,4 @@
+export * from "./create-router";
 export * from "./helper";
 export * from "./merge-route-matchers";
-export * from "./router";
 export * from "./types";

package/index.js

@@ -1,4 +1,6 @@
 "use strict";
+// Root entry point for `@uxf/router`. RSC-safe: contains no React hooks and no client-only imports.
+// For the React hooks use `createClientRouter` from `@uxf/router/client`.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,7 +16,7 @@ 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 });
+__exportStar(require("./create-router"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./merge-route-matchers"), exports);
-__exportStar(require("./router"), exports);
 __exportStar(require("./types"), exports);

package/merge-route-matchers.d.ts

@@ -1,2 +1,2 @@
-import { RouteMatcher } from "./router";
+import { RouteMatcher } from "./create-router";
 export declare function mergeRouteMatchers(routeMatchers: RouteMatcher[]): RouteMatcher;

package/package.json

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

package/routes-check/routes-check.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.routesCheck = routesCheck;
 const throw_error_1 = require("@uxf/core/utils/throw-error");
+const fs_1 = require("fs");
 const path_1 = require("path");
 const process_1 = require("process");
 const true_case_path_1 = require("true-case-path");
@@ -19,6 +20,33 @@ function fileExists(path) {
         }
     }
 }
+function findAppRoute(dir, parts) {
+    if (parts.length === 0) {
+        if (fileExists((0, path_1.join)(dir, "page.ts")) || fileExists((0, path_1.join)(dir, "route.ts"))) {
+            return true;
+        }
+    }
+    else {
+        if (findAppRoute((0, path_1.join)(dir, parts[0]), parts.slice(1))) {
+            return true;
+        }
+    }
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith("(") && entry.endsWith(")")) {
+            if (findAppRoute((0, path_1.join)(dir, entry), parts)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 let hasError = false;
 function routesCheck(routes, options) {
     Object.entries(routes).forEach(([routeName, routeDefinition]) => {
@@ -40,10 +68,7 @@ function routesCheck(routes, options) {
             if (fileExists(pagePath)) {
                 return;
             }
-            if (fileExists((0, path_1.join)(options.appDir, ...pathParts, "page.ts"))) {
-                return;
-            }
-            if (fileExists((0, path_1.join)(options.appDir, ...pathParts, "route.ts"))) {
+            if (findAppRoute(options.appDir, pathParts)) {
                 return;
             }
             throw new Error("Invalid");

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

@@ -13,6 +13,8 @@ describe("routesCheck", () => {
             app1: { path: "/app-directory" },
             app2: { path: "/app-directory/[param]" },
             app3: { path: "/api" },
+            app4: { path: "/grouped-route" }, // page lives inside a (group) folder
+            app5: { path: "/nested/deep" }, // page lives inside nested (group) folders
         }, {
             shouldProcessExit: false,
             appDir: (0, path_1.join)(__dirname, "__test__", "app"),

package/sitemap-generator.test.js

@@ -1,8 +1,8 @@
 "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)({
+const create_router_1 = require("./create-router");
+const { createSitemapGenerator, routeToUrl } = (0, create_router_1.createRouter)({
     index: {
         path: "/",
         schema: (0, superstruct_1.object)({