tezx 2.0.6 → 2.0.8

package/core/router.d.ts

@@ -6,6 +6,7 @@ export type NextCallback = () => Promise<any>;
 export type CallbackReturn = Promise<Response> | Response;
 export type Callback<T extends Record<string, any> = {}> = (ctx: ctx<T>) => CallbackReturn;
 export type Middleware<T extends Record<string, any> = {}> = (ctx: ctx<T>, next: NextCallback) => Promise<Response | void> | Response | NextCallback;
+export type PathType = string | RegExp;
 export type RouterConfig = {
     /**
      * `env` allows you to define environment variables for the router.
@@ -36,6 +37,8 @@ export type StaticServeOption = {
 };
 export type RouterHandler<T extends Record<string, any>> = {
     callback: Callback<T>;
+    paramNames: string[];
+    regex: RegExp;
     middlewares: UniqueMiddlewares | DuplicateMiddlewares;
 };
 export declare class Router<T extends Record<string, any> = {}> extends MiddlewareConfigure<T> {
@@ -72,13 +75,14 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      *
      * // With middleware
      * app.get('/secure', authMiddleware, (ctx) => { ... });
+     * app.get(/^\/item\/(\d+)\/(edit|view)?\/?$/, (ctx) => { ... });
      *
      * // With multiple middlewares
      * app.get('/admin', [authMiddleware, adminMiddleware], (ctx) => { ... });
      */
-    get(path: string, callback: Callback<T>): this;
-    get(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    get(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    get(path: PathType, callback: Callback<T>): this;
+    get(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    get(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a Server-Sent Events (SSE) route handler for the given path.
      *
@@ -108,66 +112,66 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * });
      * ```
      *
-     * @param {string} path - The route path for SSE (e.g. `/events`).
+     * @param {PathType} path - The route path for SSE (e.g. `/events`).
      * @param {(ctx: Context) => any} handler - A handler function that returns a streamed response.
      */
-    sse(path: string, handler: (ctx: Context) => any): void;
+    sse(path: PathType, handler: (ctx: Context) => any): void;
     /**
      * Registers a POST route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    post(path: string, callback: Callback<T>): this;
-    post(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    post(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    post(path: PathType, callback: Callback<T>): this;
+    post(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    post(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a PUT route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    put(path: string, callback: Callback<T>): this;
-    put(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    put(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    put(path: PathType, callback: Callback<T>): this;
+    put(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    put(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a PATCH route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    patch(path: string, callback: Callback<T>): this;
-    patch(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    patch(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    patch(path: PathType, callback: Callback<T>): this;
+    patch(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    patch(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a DELETE route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    delete(path: string, callback: Callback<T>): this;
-    delete(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    delete(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    delete(path: PathType, callback: Callback<T>): this;
+    delete(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    delete(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers an OPTIONS route (primarily for CORS preflight requests)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    options(path: string, callback: Callback<T>): this;
-    options(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    options(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    options(path: PathType, callback: Callback<T>): this;
+    options(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    options(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a HEAD route (returns headers only)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    head(path: string, callback: Callback<T>): this;
-    head(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    head(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    head(path: PathType, callback: Callback<T>): this;
+    head(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    head(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Registers a route that responds to all HTTP methods
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    all(path: string, callback: Callback<T>): this;
-    all(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    all(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    all(path: PathType, callback: Callback<T>): this;
+    all(path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    all(path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Generic method registration for custom HTTP methods
      * @param method - HTTP method name (e.g., 'PURGE')
@@ -178,10 +182,10 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * // Register custom method
      * server.addRoute('PURGE', '/cache', purgeHandler);
      */
-    addRoute(method: HTTPMethod, path: string, callback: Callback<T>): this;
-    addRoute(method: HTTPMethod, path: string, middleware: Middleware<T>): this;
-    addRoute(method: HTTPMethod, path: string, middleware: Middleware<T>, callback: Callback<T>): this;
-    addRoute(method: HTTPMethod, path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    addRoute(method: HTTPMethod, path: PathType, callback: Callback<T>): this;
+    addRoute(method: HTTPMethod, path: PathType, middleware: Middleware<T>): this;
+    addRoute(method: HTTPMethod, path: PathType, middleware: Middleware<T>, callback: Callback<T>): this;
+    addRoute(method: HTTPMethod, path: PathType, middlewares: Middleware<T>[], callback: Callback<T>): this;
     /**
      * Mount a sub-router at specific path prefix
      * @param path - Base path for the sub-router

package/core/router.js

@@ -1,3 +1,4 @@
+import { addBaseToRegex, compileRegexRoute } from "../utils/regexRouter.js";
 import { getFiles } from "../utils/staticFile.js";
 import { sanitizePathSplit, wildcardOrOptionalParamRegex, } from "../utils/url.js";
 import { GlobalConfig } from "./config.js";
@@ -191,25 +192,57 @@ export class Router extends MiddlewareConfigure {
         this.#addRoute(method, path, callback, middlewares);
     }
     #addRoute(method, path, callback, middlewares) {
-        const parts = sanitizePathSplit(this.basePath, path);
         let finalMiddleware = middlewares;
         if (!GlobalConfig.allowDuplicateMw) {
             finalMiddleware = new Set(middlewares);
         }
+        if (path instanceof RegExp) {
+            let regex = addBaseToRegex(this.basePath, path);
+            let regexPath = `regex://${regex?.source}`;
+            let handler = this.routers.get(regexPath);
+            if (!handler) {
+                handler = new Map();
+                handler.set(method, {
+                    callback: callback,
+                    paramNames: [],
+                    regex: regex,
+                    middlewares: finalMiddleware,
+                });
+                return this.routers.set(regexPath, handler);
+            }
+            if (!GlobalConfig.overwriteMethod && handler.has(method))
+                return;
+            return handler.set(method, {
+                callback,
+                paramNames: [],
+                regex: regex,
+                middlewares: finalMiddleware
+            });
+        }
+        const parts = sanitizePathSplit(this.basePath, path);
         let p = parts.join("/");
         if (wildcardOrOptionalParamRegex.test(`/${p}`)) {
-            let handler = this.routers.get(p);
+            let strPath = `string://${p}`;
+            let { paramNames, regex } = compileRegexRoute(parts);
+            let handler = this.routers.get(strPath);
             if (!handler) {
                 handler = new Map();
                 handler.set(method, {
                     callback: callback,
+                    regex: regex,
+                    paramNames: paramNames,
                     middlewares: finalMiddleware,
                 });
-                return this.routers.set(p, handler);
+                return this.routers.set(strPath, handler);
             }
             if (!GlobalConfig.overwriteMethod && handler.has(method))
                 return;
-            return handler.set(method, { callback, middlewares: finalMiddleware });
+            return handler.set(method, {
+                callback,
+                regex: regex,
+                paramNames: paramNames,
+                middlewares: finalMiddleware
+            });
         }
         let node = this.triRouter;
         for (const part of parts) {
@@ -249,17 +282,62 @@ export class Router extends MiddlewareConfigure {
         const parts = sanitizePathSplit(this.basePath, path);
         if (router.routers.size) {
             for (const [segment, handlers] of router.routers) {
-                let path = parts.length ? parts.join("/") + "/" + segment : segment;
-                if (this.routers.has(path)) {
-                    const baseRouter = this.routers.get(path);
-                    for (const [method, handler] of handlers) {
-                        if (!GlobalConfig.overwriteMethod && baseRouter.has(method))
-                            return;
-                        baseRouter.set(method, handler);
+                if (segment.indexOf("string://") == 0) {
+                    let pattern = segment.replace(/^string:\/\//, "");
+                    let joined = [...parts, pattern].join("/");
+                    let strPath = `string://${joined}`;
+                    if (this.routers.has(strPath)) {
+                        const baseRouter = this.routers.get(strPath);
+                        for (const [method, handler] of handlers) {
+                            let { regex, paramNames } = baseRouter?.get(method);
+                            handler.regex = regex;
+                            handler.paramNames = paramNames;
+                            if (!GlobalConfig.overwriteMethod && baseRouter.has(method))
+                                continue;
+                            baseRouter.set(method, handler);
+                        }
+                    }
+                    else {
+                        let h = new Map();
+                        for (const [method, { callback, middlewares }] of handlers) {
+                            let { paramNames, regex } = compileRegexRoute(joined);
+                            h.set(method, {
+                                callback: callback,
+                                middlewares: middlewares,
+                                paramNames,
+                                regex
+                            });
+                        }
+                        this.routers.set(strPath, h);
                     }
                 }
                 else {
-                    this.routers.set(path, new Map(handlers));
+                    let pattern = segment.replace("regex://", "");
+                    let base = parts?.join("/");
+                    let regex = addBaseToRegex(base, new RegExp(pattern));
+                    let regexPath = `regex://${regex.source}`;
+                    if (this.routers.has(regexPath)) {
+                        const baseRouter = this.routers.get(regexPath);
+                        for (const [method, handler] of handlers) {
+                            handler.regex = regex;
+                            handler.paramNames = [];
+                            if (!GlobalConfig.overwriteMethod && baseRouter.has(method))
+                                continue;
+                            baseRouter.set(method, handler);
+                        }
+                    }
+                    else {
+                        let h = new Map();
+                        for (const [method, { callback, middlewares }] of handlers) {
+                            h.set(method, {
+                                callback: callback,
+                                middlewares: middlewares,
+                                paramNames: [],
+                                regex
+                            });
+                        }
+                        this.routers.set(regexPath, h);
+                    }
                 }
             }
         }

package/core/server.d.ts

@@ -62,7 +62,7 @@ export declare class TezX<T extends Record<string, any> = {}> extends Router<T>
     protected findRoute(method: HTTPMethod, pathname: string): {
         callback: any;
         middlewares: Middleware<T>[];
-        params: Record<string, string>;
+        params: Record<string, null | string>;
     } | null;
     serve(req: Request, options: TezXServeOptions): Promise<Response | {
         websocket: (props: any) => any;

package/core/server.js

@@ -1,6 +1,6 @@
 import { colorText } from "../utils/colors.js";
 import { httpStatusMap } from "../utils/httpStatusMap.js";
-import { useParams } from "../utils/params.js";
+import { regexMatchRoute } from "../utils/regexRouter.js";
 import { GlobalConfig } from "./config.js";
 import { Context } from "./context.js";
 import { Router } from "./router.js";
@@ -16,18 +16,14 @@ export class TezX extends Router {
         this.#onPathResolve = onPathResolve;
         this.serve = this.serve.bind(this);
     }
-    #hashRouter(method, pathname) {
-        const routers = this.routers;
-        for (let pattern of this.routers.keys()) {
-            const { success, params } = useParams({
-                path: pathname,
-                urlPattern: pattern,
-            });
-            const handlers = routers.get(pattern)?.get(method) || routers.get(pattern)?.get("ALL");
-            if (success && handlers) {
+    #regexRouter(method, pathname) {
+        for (let pattern of this.routers.values()) {
+            const handler = pattern?.get(method) || pattern?.get("ALL");
+            const { success, params } = regexMatchRoute(handler?.regex, pathname, handler?.paramNames || []);
+            if (success && handler) {
                 return {
-                    callback: handlers.callback,
-                    middlewares: handlers.middlewares,
+                    callback: handler.callback,
+                    middlewares: handler.middlewares,
                     params: params,
                 };
             }
@@ -83,7 +79,7 @@ export class TezX extends Router {
     }
     findRoute(method, pathname) {
         const route = this.#triRouter(method, pathname) ||
-            this.#hashRouter(method, pathname) ||
+            this.#regexRouter(method, pathname) ||
             this.#triRouter(method, pathname, "param");
         if (route) {
             return {

package/helper/index.d.ts

@@ -1,9 +1,11 @@
 import { Environment } from "../core/environment.js";
 import { sanitizePathSplit } from "../utils/url.js";
 import { generateID } from "./common.js";
-export { AdapterType, GlobalConfig } from "../core/config.js";
+export { GlobalConfig } from "../core/config.js";
+export type { AdapterType } from "../core/config.js";
 export { Environment } from "../core/environment.js";
-export { sanitizePathSplit, UrlRef } from "../utils/url.js";
+export { sanitizePathSplit } from "../utils/url.js";
+export type { UrlRef } from "../utils/url.js";
 export { generateID } from "./common.js";
 declare const _default: {
     Environment: typeof Environment;

package/index.d.ts

@@ -1,20 +1,21 @@
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
-import { useParams } from "./utils/params.js";
+import { regexMatchRoute, compileRegexRoute } from "./utils/regexRouter.js";
 export { Router } from "./core/router.js";
-export type { Callback, ctx as Context, Middleware, NextCallback, RouterConfig, StaticServeOption } from "./core/router.js";
+export type { Callback, ctx as Context, Middleware, NextCallback, RouterConfig, PathType, StaticServeOption } from "./core/router.js";
 export type { AdapterType } from "./core/config.js";
 export type { CookieOptions, ResponseHeaders } from "./core/context.js";
 export type { NetAddr as AddressType, ConnAddress, FormDataOptions, HTTPMethod } from "./core/request.js";
 export { TezX } from "./core/server.js";
 export type { TezXConfig, TezXServeOptions } from "./core/server.js";
 export type { UrlRef } from "./utils/url.js";
-export { useParams };
+export { regexMatchRoute, compileRegexRoute };
 export declare let version: string;
 declare const _default: {
     Router: typeof Router;
+    regexMatchRoute: typeof regexMatchRoute;
+    compileRegexRoute: typeof compileRegexRoute;
     TezX: typeof TezX;
-    useParams: typeof useParams;
     version: string;
 };
 export default _default;

package/index.js

@@ -1,13 +1,13 @@
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
-import { useParams } from "./utils/params.js";
+import { regexMatchRoute, compileRegexRoute } from "./utils/regexRouter.js";
 export { Router } from "./core/router.js";
 export { TezX } from "./core/server.js";
-export { useParams };
-export let version = "2.0.6";
+export { regexMatchRoute, compileRegexRoute };
+export let version = "2.0.8";
 export default {
     Router,
+    regexMatchRoute, compileRegexRoute,
     TezX,
-    useParams,
     version,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "TezX is a high-performance, lightweight JavaScript framework designed for speed, scalability, and flexibility. It enables efficient routing, middleware management, and static file serving with minimal configuration. Fully compatible with Node.js, Deno, and Bun.",
   "main": "cjs/index.js",
   "module": "index.js",

package/utils/regexRouter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Compiles a route string or segment array into a regular expression for matching URL paths.
+ * Supports dynamic `:param`, optional `:param?`, and wildcard `*param` segments.
+ *
+ * @param {string | string[]} seg - The route pattern, either as a string (`'/user/:id'`)
+ *   or an array of segments (`['user', ':id']`).
+ *
+ * @returns {{
+*   regex: RegExp,
+*   paramNames: string[]
+* }}
+* @example
+* const { regex, paramNames } = compileRegexRoute('/user/:id/post/:slug?');
+* // regex: /^\/user\/([^\/]+)\/(?:([^\/]+))?\/?$/
+* // paramNames: ['id', 'slug']
+*
+* regex.test('/user/123/post/hello'); // ✅ true
+* regex.test('/user/123/post');       // ✅ true (because :slug? is optional)
+*
+* @example
+* const { regex, paramNames } = compileRegexRoute('/files/*path');
+* // regex: /^\/files\/(.+)\/?$/
+* // paramNames: ['path']
+*
+* regex.test('/files/images/cat.jpg'); // ✅ true
+*/
+export declare function compileRegexRoute(seg: string | string[]): {
+    regex: RegExp;
+    paramNames: string[];
+};
+/**
+ * Combines a base path with a route regex pattern.
+ *
+ * @param basePath - The base path to prepend (e.g., '/api/v1')
+ * @param routeRegex - The original route regex (e.g., /^\/users\/([^/]+?)$/)
+ * @returns A new regex that includes the base path
+ */
+export declare function addBaseToRegex(basePath: string, routeRegex: RegExp): RegExp;
+/**
+ * Matches a given URL against a provided regular expression and extracts named parameters.
+ *
+ * @param {RegExp} regex - The regular expression to match against the URL.
+ *   It should include capturing groups for each parameter.
+ *   Example: /^\/user\/(\d+)\/post\/(\w+)$/
+ *
+ * @param {string} url - The URL string to match.
+ *   Example: "/user/123/post/abc"
+ *
+ * @param {string[]} paramNames - An array of parameter names corresponding to the capturing groups in the regex.
+ *   Example: ["userId", "postId"]
+ *
+ * @returns {{ success: boolean, params: Record<string, string | null> }} An object indicating:
+ *   - `success`: whether the URL matched the regex.
+ *   - `params`: an object mapping parameter names to their matched values, or `null` if not found.
+ *
+ * @example
+ * const regex = /^\/user\/(\d+)\/post\/(\w+)$/;
+ * const url = "/user/123/post/abc";
+ * const paramNames = ["userId", "postId"];
+ * const result = regexMatchRoute(regex, url, paramNames);
+ * // result = { success: true, params: { userId: "123", postId: "abc" } }
+ */
+export declare function regexMatchRoute(regex: RegExp, url: string, paramNames: string[]): {
+    params: Record<string, string | null>;
+    success: boolean;
+};

package/utils/regexRouter.js

@@ -0,0 +1,53 @@
+import { sanitizePathSplit } from "./url.js";
+export function compileRegexRoute(seg) {
+    const segments = typeof seg == 'string' ? seg.split("/").filter(Boolean) : seg;
+    let regexStr = "^";
+    const paramNames = [];
+    for (let seg of segments) {
+        if (seg.startsWith(":")) {
+            const isOptional = seg.endsWith("?");
+            const name = seg.replace(":", "").replace("?", "");
+            paramNames.push(name);
+            regexStr += isOptional
+                ? `(?:\\/([^\\/]+))?`
+                : `\\/([^\\/]+)`;
+        }
+        else if (seg.startsWith("*")) {
+            const name = seg.slice(1) || "*";
+            paramNames.push(name);
+            regexStr += `\\/(.+)`;
+        }
+        else {
+            regexStr += `\\/${seg}`;
+        }
+    }
+    regexStr += "\\/?$";
+    return {
+        regex: new RegExp(regexStr),
+        paramNames,
+    };
+}
+export function addBaseToRegex(basePath, routeRegex) {
+    basePath = "/" + sanitizePathSplit("/", basePath)?.join("/");
+    if (basePath === "/")
+        basePath = "";
+    let body = routeRegex.source.replace(/^(\^)/, '').replace(/(\$)$/, '');
+    body = body.replace(/\\\//g, "/");
+    if (body.startsWith("/")) {
+        body = body.slice(1);
+    }
+    const cleaned = body.replace(/^\/+|\/+$/g, "").replace(/\/?\?$/, "");
+    const combined = basePath + "/" + cleaned + "/?";
+    const finalRegex = new RegExp(`^${combined}$`);
+    return finalRegex;
+}
+export function regexMatchRoute(regex, url, paramNames) {
+    const match = url.match(regex);
+    if (!match)
+        return { success: false, params: {} };
+    const params = {};
+    paramNames.forEach((name, idx) => {
+        params[name] = match[idx + 1] ?? null;
+    });
+    return { params, success: true };
+}

package/cjs/utils/params.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useParams = useParams;
-function useParams({ path, urlPattern, }) {
-    let params = {};
-    path = path.replace(/^\/+|\/+$/g, "");
-    urlPattern = urlPattern.replace(/^\/+|\/+$/g, "");
-    const pathSegments = path ? path.split("/") : [];
-    const patternSegments = urlPattern ? urlPattern.split("/") : [];
-    const pathLength = pathSegments.length;
-    const patternLength = patternSegments.length;
-    if (pathLength > patternLength && !urlPattern.includes("*")) {
-        return { success: false, params: {} };
-    }
-    let pathIndex = 0;
-    for (let i = 0; i < patternLength; i++) {
-        const patternSegment = patternSegments[i];
-        if (patternSegment?.startsWith("*")) {
-            const trailingPatterns = patternSegments.slice(i + 1);
-            let paramName = patternSegment.length == 1 ? "*" : patternSegment?.slice(1);
-            if (trailingPatterns.length > 0) {
-                const expectedTrailing = trailingPatterns.join("/");
-                const actualTrailing = pathSegments
-                    .slice(pathLength - trailingPatterns.length)
-                    .join("/");
-                const wildcardPath = pathSegments
-                    .slice(pathIndex, pathLength - trailingPatterns.length)
-                    .join("/");
-                if (expectedTrailing !== actualTrailing || !wildcardPath) {
-                    return { success: false, params: {} };
-                }
-                params[paramName] = wildcardPath;
-                return { success: true, params };
-            }
-            else {
-                const wildcardPath = pathSegments.slice(pathIndex).join("/");
-                if (!wildcardPath) {
-                    return { success: false, params: {} };
-                }
-                params[paramName] = wildcardPath;
-                return { success: true, params };
-            }
-        }
-        if (patternSegment.startsWith(":") && patternSegment.endsWith("?")) {
-            const paramName = patternSegment.slice(1, -1);
-            const nextPattern = patternSegments[i + 1];
-            if (nextPattern &&
-                !nextPattern.startsWith(":") &&
-                nextPattern !== "*" &&
-                pathIndex < pathLength &&
-                pathSegments[pathIndex] === nextPattern) {
-                params[paramName] = null;
-                continue;
-            }
-            const remainingPatterns = patternSegments.slice(i + 1);
-            const requiredCount = remainingPatterns.filter((seg) => !(seg.startsWith(":") && seg.endsWith("?"))).length;
-            const remainingPath = pathLength - pathIndex;
-            if (remainingPath === requiredCount) {
-                params[paramName] = null;
-            }
-            else if (pathIndex < pathLength) {
-                params[paramName] = pathSegments[pathIndex];
-                pathIndex++;
-            }
-            else {
-                params[paramName] = null;
-            }
-            continue;
-        }
-        if (patternSegment.startsWith(":")) {
-            const paramName = patternSegment.slice(1);
-            if (!/^[a-zA-Z0-9_]+$/.test(paramName)) {
-                return { success: false, params: {} };
-            }
-            if (pathIndex < pathLength) {
-                params[paramName] = pathSegments[pathIndex];
-                pathIndex++;
-            }
-            else {
-                return { success: false, params: {} };
-            }
-            continue;
-        }
-        const pathSegment = pathSegments[pathIndex];
-        if (patternSegment !== pathSegment) {
-            return { success: false, params: {} };
-        }
-        pathIndex++;
-    }
-    if (pathIndex < pathLength) {
-        return { success: false, params: {} };
-    }
-    return { success: true, params };
-}

package/utils/params.d.ts

@@ -1,7 +0,0 @@
-export declare function useParams({ path, urlPattern, }: {
-    path: string;
-    urlPattern: string;
-}): {
-    success: boolean;
-    params: Record<string, any>;
-};