@uxf/router 11.80.4 → 11.84.0

package/merge-route-matchers.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeRouteMatchers = mergeRouteMatchers;
 function mergeRouteMatchers(routeMatchers) {
-    return (router) => routeMatchers.some((routeMatcher) => routeMatcher(router));
+    return (...params) => routeMatchers.some((routeMatcher) => routeMatcher(...params));
 }

package/package.json

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

package/router.d.ts

@@ -1,8 +1,7 @@
 import { LinkProps } from "next/link";
-import { NextRouter } from "next/router";
 import { Infer, Struct } from "superstruct";
 import { SitemapGeneratorOptions, SitemapGeneratorType, SitemapRouteResolvers } from "./sitemap-generator";
-import { QueryParams, RoutesDefinition } from "./types";
+import { QueryParams, RouteDefinition, RoutesDefinition } from "./types";
 interface TransitionOptions {
     shallow?: boolean;
     locale?: string | false;
@@ -33,25 +32,27 @@ type QueryParamsResult<Nullable extends boolean, T extends keyof RouteList, Loca
         replace: (params: Infer<NonNullable<RouteList[T]["schema"]>>, options?: TransitionOptions) => Promise<boolean>;
     }
 ];
-type SimplyNextRouter = Pick<NextRouter, "pathname" | "query" | "isReady">;
-export type RouteMatcher = (router: SimplyNextRouter) => boolean;
-type CurrentRoute<RouteList extends RoutesDefinition<any>> = {
-    [K in keyof RouteList]: {
-        route: K;
-        params: "schema" extends keyof RouteList[K] ? ExtractSchema<RouteList[K]> | null : null;
-    };
-}[keyof RouteList];
+export type RouteMatcher = (pathname: string, pathParams?: Record<string, string | string[]>) => boolean;
+type RouteInfo = {
+    pathname: string;
+    routeName: string;
+    routeDefinition: RouteDefinition<any>;
+};
 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;
-    getCurrentRoute: (router: SimplyNextRouter) => CurrentRoute<RouteList>;
-    useActiveRoute: () => ActiveRoute<Locales, 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: () => Record<string, string | string[]> | 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;
@@ -60,9 +61,9 @@ 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 type ExtendedRouteDefinition<Locales extends string[]> = RouteDefinition<Locales> & {
+    regex: RegExp[];
 };
+export type ExtendedRoutesDefinition<Locales extends string[]> = Record<string, ExtendedRouteDefinition<Locales>>;
 export declare function createRouter<Locales extends string[], RouteList extends RoutesDefinition<Locales>>(routes: RouteList, routerOptions: RouterOptions<Locales>): Router<Locales, RouteList>;
 export {};

package/router.js

@@ -2,11 +2,15 @@
 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 throw_error_1 = require("@uxf/core/utils/throw-error");
+const navigation_1 = require("next/navigation");
 const router_1 = require("next/router");
 const qs_1 = require("qs");
 const superstruct_1 = require("superstruct");
 const sitemap_generator_1 = require("./sitemap-generator");
+const path_to_regex_1 = require("./utils/path-to-regex");
 /**
  * Arguments can be:
  *
@@ -16,6 +20,15 @@ function decodeArgs(args) {
     return { route: args[0], params: args[1], options: args[2] };
 }
 function createRouter(routes, routerOptions) {
+    const routesWithRegex = Object.entries(routes).reduce((acc, [routeName, routeDefinition]) => ({
+        ...acc,
+        [routeName]: {
+            ...routeDefinition,
+            regex: typeof routeDefinition.path === "string"
+                ? [(0, path_to_regex_1.pathToRegex)(routeDefinition.path)]
+                : Object.values(routeDefinition.path).map((path) => (0, path_to_regex_1.pathToRegex)(path)),
+        },
+    }), {});
     const routeToUrl = (...args) => {
         var _a;
         const { route, params, options } = decodeArgs(args);
@@ -71,16 +84,28 @@ function createRouter(routes, routerOptions) {
         }
         return (options === null || options === void 0 ? void 0 : options.shouldBeAbsolute) ? `${routerOptions.baseUrl}${pathname}` : pathname;
     };
-    const getCurrentRoute = (router) => {
-        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.");
+    const getRouteInfo = (pathname) => {
+        const entry = Object.entries(routesWithRegex).find(([, routeDefinition]) => routeDefinition.regex.some((regex) => regex.test(pathname)));
+        if (!entry) {
+            throw new Error(`Active route not found (${pathname}).`);
+        }
+        return {
+            pathname,
+            routeName: entry[0],
+            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;
         }
-        const schema = routes[activeRoute].schema;
-        const params = router.isReady && schema ? (0, superstruct_1.mask)(router.query, schema) : null;
-        return { route: activeRoute, params };
+        return Array.from(searchParams.entries()).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), params);
     };
     return {
         route(...args) {
@@ -95,69 +120,69 @@ function createRouter(routes, routerOptions) {
             };
         },
         routeToUrl,
-        useActiveRoute() {
-            var _a;
-            const router = (0, router_1.useRouter)();
-            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 {
-                route: activeRoute,
-                locale: ((_a = router.locale) !== null && _a !== void 0 ? _a : null),
-            };
-        },
         createSitemapGenerator(resolvers, options) {
             return new sitemap_generator_1.SitemapGenerator(resolvers, options);
         },
         routes,
+        getRouteInfo,
+        useRouteInfo,
+        usePageParams,
         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) {
+            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)(router.query, schema),
+                (0, superstruct_1.mask)(pageParams, schema),
                 {
-                    push: (params, options) => router.push(routeToUrl(routeName, params, {}), undefined, options),
-                    replace: (params, options) => router.replace(routeToUrl(routeName, params, {}), undefined, options),
+                    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, router_1.useRouter)();
+            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 [
-                router.isReady ? (0, superstruct_1.mask)(router.query, schema) : null,
+                (0, is_not_nil_1.isNotNil)(pageParams) ? (0, superstruct_1.mask)(pageParams, schema) : null,
                 {
-                    push: (params) => router.push(routeToUrl(routeName, params, {})),
-                    replace: (params) => router.replace(routeToUrl(routeName, params, {})),
+                    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
+                    },
                 },
             ];
         },
-        getCurrentRoute,
         createRouteMatcher(...args) {
             const [requiredRouteName, requiredParams] = args;
-            return (router) => {
-                const { route, params } = getCurrentRoute(router);
-                if (route !== requiredRouteName) {
+            return (pathname, pageParams) => {
+                const routeInfo = getRouteInfo(pathname);
+                if (routeInfo.routeName !== requiredRouteName) {
                     return false;
                 }
                 if (!requiredParams || Object.keys(requiredParams).length === 0) {
                     return true;
                 }
                 for (const [paramName, paramValue] of Object.entries(requiredParams)) {
-                    if ((params === null || params === void 0 ? void 0 : params[paramName]) !== paramValue) {
+                    if ((pageParams === null || pageParams === void 0 ? void 0 : pageParams[paramName]) !== paramValue) {
                         return false;
                     }
                 }

package/router.test.js

@@ -138,39 +138,33 @@ test("routeToUrl", () => {
     DATA.map(({ actual, expected }) => expect(actual).toBe(expected));
 });
 test("create route matcher", () => {
-    expect(createRouteMatcher("manyParameters", { param1: "value-1" })({
-        isReady: true,
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "value-1", param2: "any", queryParam1: "any", queryParam2: "any" },
+    expect(createRouteMatcher("manyParameters", { param1: "value-1" })("/many-parameters/value-1/form/any", {
+        param1: "value-1",
+        param2: "any",
     })).toBe(true);
-    expect(createRouteMatcher("manyParameters", { param1: "value-1" })({
-        isReady: true,
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "any", param2: "any" },
+    expect(createRouteMatcher("manyParameters", { param1: "value-1" })("/many-parameters/any/form/any", {
+        param1: "any",
+        param2: "any",
     })).toBe(false);
-    expect(createRouteMatcher("manyParameters", { param1: "value-1", queryParam1: "query-1" })({
-        isReady: true,
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "value-1", param2: "any", queryParam1: "query-1" },
+    expect(createRouteMatcher("manyParameters", { param1: "value-1" })("/many-parameters/value-1/form/any", {
+        param1: "value-1",
+        param2: "any",
     })).toBe(true);
 });
 test("merge route matchers", () => {
-    const routeMatcher1 = createRouteMatcher("manyParameters", { param1: "value-1", queryParam1: "query-1" });
-    const routeMatcher2 = createRouteMatcher("manyParameters", { param1: "value-2", queryParam1: "query-2" });
+    const routeMatcher1 = createRouteMatcher("manyParameters", { param1: "value-1" });
+    const routeMatcher2 = createRouteMatcher("manyParameters", { param1: "value-2" });
     const routeMatcher = (0, merge_route_matchers_1.mergeRouteMatchers)([routeMatcher1, routeMatcher2]);
-    expect(routeMatcher({
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "value-1", queryParam1: "query-1", param2: "any" },
-        isReady: true,
+    expect(routeMatcher("/many-parameters/value-1/form/any", {
+        param1: "value-1",
+        param2: "any",
     })).toBe(true);
-    expect(routeMatcher({
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "value-2", queryParam1: "query-2", param2: "any" },
-        isReady: true,
+    expect(routeMatcher("/many-parameters/value-2/form/any", {
+        param1: "value-2",
+        param2: "any",
     })).toBe(true);
-    expect(routeMatcher({
-        pathname: "/many-parameters/[param1]/form/[param2]",
-        query: { param1: "value-3", queryParam1: "query-3", param2: "any" },
-        isReady: true,
+    expect(routeMatcher("/many-parameters/value-3/form/any", {
+        param1: "value-3",
+        param2: "any",
     })).toBe(false);
 });

package/routes-check/routes-check.js

@@ -31,16 +31,19 @@ function routesCheck(routes, options) {
             if (fileExists((0, path_1.join)(options.pagesDir, ...pathParts, "index.ts"))) {
                 return;
             }
+            const pagesPathParts = [...pathParts]; // clone
             // 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`)
+            const lastPart = pagesPathParts.splice(-1);
+            const pagePath = pagesPathParts.length > 0
+                ? (0, path_1.join)(options.pagesDir, ...pagesPathParts, `${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
+            if (fileExists((0, path_1.join)(options.appDir, ...pathParts, "page.ts"))) {
+                return;
+            }
+            if (fileExists((0, path_1.join)(options.appDir, ...pathParts, "route.ts"))) {
                 return;
             }
             throw new Error("Invalid");

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

@@ -12,6 +12,7 @@ describe("routesCheck", () => {
             route5: { path: "/product-2/[id]" }, // path parameter, index file
             app1: { path: "/app-directory" },
             app2: { path: "/app-directory/[param]" },
+            app3: { path: "/api" },
         }, {
             shouldProcessExit: false,
             appDir: (0, path_1.join)(__dirname, "__test__", "app"),

package/types.d.ts

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

package/utils/path-to-regex.d.ts

@@ -0,0 +1 @@
+export declare function pathToRegex(path: string): RegExp;

package/utils/path-to-regex.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToRegex = pathToRegex;
+function pathToRegex(path) {
+    const paramNames = [];
+    // Replace Next.js route patterns with named placeholders
+    let pattern = path
+        // Optional catch-all: [[...param]] -> __OPTIONAL_CATCHALL_param__
+        .replace(/\/\[\[\.\.\.([^\]]+)\]\]/g, (_, param) => {
+        paramNames.push(param);
+        return `__OPTIONAL_CATCHALL_${param}__`;
+    })
+        .replace(/^\[\[\.\.\.([^\]]+)\]\]$/g, (_, param) => {
+        paramNames.push(param);
+        return `__ROOT_OPTIONAL_CATCHALL_${param}__`;
+    })
+        .replace(/^\[\[\.\.\.([^\]]+)\]\]/g, (_, param) => {
+        paramNames.push(param);
+        return `__ROOT_OPTIONAL_CATCHALL_${param}__`;
+    })
+        // Catch-all: [...param] -> __CATCHALL_param__
+        .replace(/\/\[\.\.\.([^\]]+)\]/g, (_, param) => {
+        paramNames.push(param);
+        return `__CATCHALL_${param}__`;
+    })
+        // Dynamic: [param] -> __DYNAMIC_param__
+        .replace(/\[([^\]]+)\]/g, (_, param) => {
+        paramNames.push(param);
+        return `__DYNAMIC_${param}__`;
+    });
+    // Escape special regex characters
+    pattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Replace placeholders with named regex patterns
+    paramNames.forEach((param) => {
+        // Sanitize parameter name for use in named capture groups (only alphanumeric and underscore allowed)
+        const sanitizedParam = param.replace(/[^a-zA-Z0-9_]/g, "_");
+        pattern = pattern
+            .replace(`__OPTIONAL_CATCHALL_${param}__`, `(?:/(?<${sanitizedParam}>.*))?`)
+            .replace(`__ROOT_OPTIONAL_CATCHALL_${param}__`, `(?<${sanitizedParam}>.*)`)
+            .replace(`__CATCHALL_${param}__`, `/(?<${sanitizedParam}>.+)`)
+            .replace(`__DYNAMIC_${param}__`, `(?<${sanitizedParam}>[^/]+)`);
+    });
+    // Ensure the pattern matches the exact path (no extra segments)
+    return new RegExp("^" + pattern + "$");
+}

package/utils/path-to-regex.test.d.ts

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

package/utils/path-to-regex.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_to_regex_1 = require("./path-to-regex");
+describe("pathToRegex", () => {
+    describe("static routes", () => {
+        it("should match exact static paths", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/product/detail");
+            expect(regex.test("/product/detail")).toBe(true);
+            expect(regex.test("/product/detail/extra")).toBe(false);
+            expect(regex.test("/product")).toBe(false);
+        });
+        it("should handle root path", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/");
+            expect(regex.test("/")).toBe(true);
+            expect(regex.test("/anything")).toBe(false);
+        });
+    });
+    describe("dynamic routes [param]", () => {
+        it("should match single dynamic segment", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/product/[id]");
+            expect(regex.test("/product/1")).toBe(true);
+            expect(regex.test("/product/abc")).toBe(true);
+            expect(regex.test("/product/123-xyz")).toBe(true);
+            expect(regex.test("/product/")).toBe(false);
+            expect(regex.test("/product/1/extra")).toBe(false);
+        });
+        it("should match dynamic route with detail", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/product/[id]/detail");
+            expect(regex.test("/product/1/detail")).toBe(true);
+            expect(regex.test("/product/abc/detail")).toBe(true);
+            expect(regex.test("/product/1/detail/extra")).toBe(false);
+            expect(regex.test("/product/detail")).toBe(false);
+        });
+        it("should handle multiple dynamic segments", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/[category]/[id]/edit");
+            expect(regex.test("/electronics/123/edit")).toBe(true);
+            expect(regex.test("/books/abc/edit")).toBe(true);
+            expect(regex.test("/electronics/123/edit/more")).toBe(false);
+        });
+    });
+    describe("catch-all routes [...slug]", () => {
+        it("should match catch-all segments", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/docs/[...slug]");
+            expect(regex.test("/docs/getting-started")).toBe(true);
+            expect(regex.test("/docs/api/reference")).toBe(true);
+            expect(regex.test("/docs/api/reference/auth")).toBe(true);
+            expect(regex.test("/docs")).toBe(false);
+        });
+        it("should require at least one segment for catch-all", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/blog/[...slug]");
+            expect(regex.test("/blog/2023")).toBe(true);
+            expect(regex.test("/blog/2023/12/post")).toBe(true);
+            expect(regex.test("/blog/")).toBe(false);
+            expect(regex.test("/blog")).toBe(false);
+        });
+    });
+    describe("optional catch-all routes [[...slug]]", () => {
+        it("should match optional catch-all segments", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/shop/[[...categories]]");
+            expect(regex.test("/shop")).toBe(true);
+            expect(regex.test("/shop/")).toBe(true);
+            expect(regex.test("/shop/electronics")).toBe(true);
+            expect(regex.test("/shop/electronics/phones")).toBe(true);
+            expect(regex.test("/shop/electronics/phones/iphone")).toBe(true);
+        });
+        it("should handle optional catch-all at root", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/[[...slug]]");
+            expect(regex.test("/")).toBe(true);
+            expect(regex.test("/about")).toBe(true);
+            expect(regex.test("/about/team")).toBe(true);
+        });
+    });
+    describe("complex combinations", () => {
+        it("should handle dynamic + catch-all", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/user/[id]/posts/[...slug]");
+            expect(regex.test("/user/123/posts/my-first-post")).toBe(true);
+            expect(regex.test("/user/abc/posts/category/tech/post-1")).toBe(true);
+            expect(regex.test("/user/123/posts")).toBe(false);
+        });
+        it("should handle dynamic + optional catch-all", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/user/[id]/files/[[...path]]");
+            expect(regex.test("/user/123/files")).toBe(true);
+            expect(regex.test("/user/123/files/documents")).toBe(true);
+            expect(regex.test("/user/123/files/documents/pdf/report.pdf")).toBe(true);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle special regex characters in static parts", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/api/v1.0/users");
+            expect(regex.test("/api/v1.0/users")).toBe(true);
+            expect(regex.test("/api/v1x0/users")).toBe(false);
+        });
+        it("should handle paths with hyphens and underscores", () => {
+            const regex = (0, path_to_regex_1.pathToRegex)("/api-v1/user_profile/[user-id]");
+            expect(regex.test("/api-v1/user_profile/123-abc")).toBe(true);
+            expect(regex.test("/api-v1/user_profile/user_123")).toBe(true);
+        });
+    });
+    describe("regex checks", () => {
+        const PATHS = [
+            "/",
+            "/product/[id]",
+            "/product/[id]/detail",
+            "/user/files/[...path]",
+            "/user/files/[[...path]]",
+        ];
+        expect(PATHS.reduce((acc, curr) => ({ ...acc, [curr]: (0, path_to_regex_1.pathToRegex)(curr).source }), {})).toMatchSnapshot();
+    });
+});