tezx 3.0.10-beta → 3.0.12-beta

package/cjs/registry/RadixRouter.js

@@ -39,20 +39,18 @@ class RadixRouter {
     search(method, path) {
         let params = {};
         let middlewares = [];
-        const { success, node } = this._match(method, this.root, (0, index_js_1.sanitizePathSplit)(path), 0, params, middlewares, new Set());
+        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
         if (success && node) {
             const handlers = node.handlers?.[method] ?? [];
             return { method, params, handlers, middlewares };
         }
         return { method, params: {}, handlers: [], middlewares };
     }
-    _match(method, node, segments, index, params, middlewares, seen) {
-        if (node.handlers?.ALL) {
-            for (const mw of node.handlers.ALL) {
-                if (!seen.has(mw)) {
-                    seen.add(mw);
-                    middlewares.push(mw);
-                }
+    _match(method, node, segments, index, params, middlewares) {
+        if (node?.handlers?.ALL) {
+            const mw = node.handlers?.ALL;
+            for (let i = 0; i < mw.length; i++) {
+                middlewares.push(mw[i]);
             }
         }
         if (index === segments.length) {
@@ -61,40 +59,59 @@ class RadixRouter {
             const opt = node.children[":"];
             if (opt?.isOptional) {
                 params[opt.paramName] = null;
-                return this._match(method, opt, segments, index, params, middlewares, seen);
+                return this._match(method, opt, segments, index, params, middlewares);
             }
             return { success: false, node: node };
         }
         const wc = node.children["*"];
-        if (wc?.handlers?.ALL) {
-            for (const mw of wc.handlers.ALL) {
-                if (!seen.has(mw)) {
-                    seen.add(mw);
-                    middlewares.push(mw);
-                }
-            }
-        }
         const seg = segments[index];
         if (node.children[seg]) {
-            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares, seen);
-            if (res.success)
+            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
                 return res;
+            }
         }
         const dyn = node.children[":"];
         if (dyn) {
             params[dyn.paramName] = seg;
-            const res = this._match(method, dyn, segments, index + 1, params, middlewares, seen);
-            if (res.success)
+            const res = this._match(method, dyn, segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
                 return res;
+            }
             if (dyn.isOptional) {
                 params[dyn.paramName] = null;
-                const skip = this._match(method, dyn, segments, index, params, middlewares, seen);
-                if (skip.success)
+                const skip = this._match(method, dyn, segments, index, params, middlewares);
+                if (skip.success) {
+                    if (wc?.handlers?.ALL) {
+                        const mw = wc.handlers?.ALL;
+                        for (let i = 0; i < mw.length; i++) {
+                            middlewares.push(mw[i]);
+                        }
+                    }
                     return skip;
+                }
             }
         }
         if (wc) {
             let wildcard = segments.slice(index).join("/");
+            if (wc?.handlers?.ALL) {
+                const mw = wc.handlers?.ALL;
+                for (let i = 0; i < mw.length; i++) {
+                    middlewares.push(mw[i]);
+                }
+            }
             if (wildcard) {
                 params[wc.paramName] = wildcard;
                 return { node: wc, success: true };
@@ -128,3 +145,35 @@ class RadixRouter {
     }
 }
 exports.RadixRouter = RadixRouter;
+const routes = [
+    "/",
+    "/users",
+    "/users/:id",
+    "/users/:id/profile",
+    "/posts/:postId?",
+    "/files/*",
+    "/admin/settings",
+    "/search/:term?",
+    "/categories/:categoryId/products/:productId",
+    "/about",
+];
+const testPaths = [
+    "/",
+    "/users",
+    "/users/123",
+    "/users/123/profile",
+    "/posts",
+    "/posts/456",
+    "/files/path/to/file.txt",
+    "/admin/settings",
+    "/search",
+    "/search/nodejs",
+    "/categories/12/products/999",
+    "/notfound",
+];
+const router = new RadixRouter();
+let x = function xx() {
+    return {
+        body: "3453455",
+    };
+};

package/cjs/utils/cookie.js

@@ -34,7 +34,7 @@ function allCookies(ctx) {
     return cookies;
 }
 function setCookie(ctx, name, value, options) {
-    ctx.setHeader("Set-Cookie", `${name}=${value}; ${serializeOptions(options || {})}`);
+    ctx.setHeader("Set-Cookie", `${name}=${value}; ${serializeOptions(options ?? {})}`);
 }
 function deleteCookie(ctx, name, options) {
     ctx.setHeader("Set-Cookie", `${name}=; ${serializeOptions({ ...options, maxAge: 0, expires: new Date(0) })}`);

package/cjs/utils/rateLimit.js

@@ -17,8 +17,8 @@ function createRateLimitDefaultStorage() {
         },
     };
 }
-function isRateLimit(ctx, key, store, maxRequests, windowMs) {
-    store.clearExpired();
+function isRateLimit(key, store, maxRequests, windowMs) {
+    store?.clearExpired();
     const now = Date.now();
     let entry = store.get(key) || { count: 0, resetTime: now + windowMs };
     if (now < entry.resetTime) {

package/cjs/utils/regexRouter.js

@@ -19,6 +19,7 @@ function compileRegexRoute(seg) {
             const name = seg.slice(1) || "*";
             paramNames.push(name);
             regexStr += `\\/(.+)`;
+            break;
         }
         else {
             regexStr += `\\/${seg}`;

package/cjs/utils/response.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFoundResponse = void 0;
 exports.handleErrorResponse = handleErrorResponse;
+exports.toString = toString;
 exports.determineContentTypeBody = determineContentTypeBody;
-exports.newResponse = newResponse;
+const config_js_1 = require("../core/config.js");
+const error_js_1 = require("../core/error.js");
 let notFoundResponse = (ctx) => {
     const { method, pathname } = ctx;
     return ctx.text(`${method}: '${pathname}' could not find\n`, {
@@ -11,14 +13,24 @@ let notFoundResponse = (ctx) => {
     });
 };
 exports.notFoundResponse = notFoundResponse;
-async function handleErrorResponse(message = new Error("Internal Server Error"), ctx) {
-    let error = message;
-    if (message instanceof Error) {
-        error = message.stack;
+async function handleErrorResponse(err = error_js_1.TezXError.internal(), ctx) {
+    if (err instanceof error_js_1.TezXError) {
+        config_js_1.GlobalConfig.debugging.error(err.details ?? err?.message);
+        return ctx.status(err.statusCode ?? 500).send(err.details ?? err?.message ?? "Internal Server Error");
     }
-    return ctx.text(error, {
-        status: 500,
-    });
+    return await handleErrorResponse(error_js_1.TezXError.internal(), ctx);
+}
+function toString(input, values) {
+    if (typeof input === "string") {
+        return input;
+    }
+    let result = "";
+    for (let i = 0; i < input.length; i++) {
+        result += input[i];
+        if (i < values.length)
+            result += values[i];
+    }
+    return result;
 }
 function determineContentTypeBody(body) {
     if (typeof body === "string" ||
@@ -49,24 +61,3 @@ function determineContentTypeBody(body) {
     }
     return { type: "text/plain; charset=utf-8", body: String(body ?? "") };
 }
-function newResponse(body, type, init = {}, baseHeaders, defaultStatus) {
-    let headers;
-    if (init.headers) {
-        headers = {
-            "Content-Type": type,
-            ...baseHeaders,
-            ...init.headers,
-        };
-    }
-    else {
-        headers = {
-            "Content-Type": type,
-            ...baseHeaders,
-        };
-    }
-    return new Response(body, {
-        status: init.status || defaultStatus,
-        statusText: init.statusText,
-        headers,
-    });
-}

package/core/context.d.ts

@@ -1,19 +1,6 @@
-import { HttpBaseResponse, ResHeaderKey, ResponseHeaders, ResponseInit } from "../types/index.js";
+import { HttpBaseResponse, ResHeaderKey, ResponseInit } from "../types/index.js";
 import { TezXRequest } from "./request.js";
-export type ContextOptions<T> = {
-    pathname: string;
-    method: string;
-    env: Record<string, any> & T;
-    args?: any[];
-};
-/**
- * Represents the context of an HTTP request lifecycle.
- * Provides utilities to handle request, response, headers, and body.
- *
- * @template T - The type for environment variables or shared state.
- * @template Path - The string literal type for route paths.
- */
-export declare class Context<T extends Record<string, any> = {}, Path extends string = any> {
+export declare class Context<TEnv extends Record<string, any> = {}, TPath extends string = any> {
     #private;
     [key: string]: any;
     /**
@@ -22,11 +9,29 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
      * @type {Request}
      */
     rawRequest: Request;
+    /**
+     * The URL associated with the current context.
+     *
+     * This is a read-only string representing the resource location or endpoint.
+     */
+    readonly url: string;
+    /**
+     * The native Response object associated with this context, if available.
+     *
+     * This property is set when a response has been created or is being manipulated directly.
+     * It may be undefined if the response has not yet been constructed.
+     *
+     * @type {Response | undefined}
+     * @remarks
+     * - When present, headers and status should be set directly on this object.
+     * - When undefined, internal header and status management is used.
+     */
+    res?: Response;
     /**
      * Environment variables or shared state accessible in context.
-     * @type {Record<string, any> & T}
+     * @type {Record<string, any> & TEnv}
      */
-    env: Record<string, any> & T;
+    env: Record<string, any> & TEnv;
     /**
      * Request pathname (URL path without domain).
      * @readonly
@@ -43,14 +48,9 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
      * Creates a new context instance.
      *
      * @param {Request} req - The native Request object.
-     * @param {ContextOptions<T>} options - Context options including pathname, method, env, params, and args.
+     * @param {ContextOptions<TEnv>} options - Context options including pathname, method, env, params, and args.
      */
-    constructor(req: Request, options: ContextOptions<T>);
-    /**
-     * Returns the full URL string of the request, including query parameters.
-     * @type {string}
-     */
-    get url(): string;
+    constructor(req: Request, pathname: string, method: string, env: Record<string, any> & TEnv, args: any[]);
     /**
      * Gets the current HTTP status code.
      * @returns {number} The HTTP status code.
@@ -62,19 +62,34 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
      */
     set setStatus(code: number);
     /**
-     * Retrieves a specific header value or all headers.
+     * Access the response headers.
      *
-     * @param {ResHeaderKey} [header] - Optional header name (case-insensitive, internally lowercased).
-     * @returns {string | undefined | ResponseHeaders} - Returns the header value if key is provided,
-     * or the entire headers object if no key is passed.
+     * @remarks
+     * This returns the native {@link Headers} object associated with the response.
+     * It gives you full control over reading, setting, appending, and deleting headers
+     * using the standard Web Headers API.
      *
      * @example
-     * ctx.header('content-type'); // → 'application/json'
-     * ctx.header(); // → { 'content-type': 'application/json' }
+     * ```ts
+     * // Get a header value
+     * const contentType = ctx.headers.get("content-type")
+     *
+     * // Set or overwrite a header
+     * ctx.headers.set("x-powered-by", "tezx")
+     *
+     * // Append multiple values
+     * ctx.headers.append("set-cookie", "id=123")
+     * ctx.headers.append("set-cookie", "token=xyz")
+     *
+     * // Iterate all headers
+     * for (const [key, value] of ctx.headers.entries()) {
+     *   console.log(key, value)
+     * }
+     * ```
+     *
+     * @returns {Headers} The response headers object.
      */
-    header(): Record<string, string>;
-    header(header: ResHeaderKey): string | undefined;
-    protected set clearHeader(header: ResponseHeaders);
+    get headers(): Headers;
     /**
      * Sets or appends a header to the response.
      *
@@ -91,26 +106,15 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
     setHeader(key: ResHeaderKey, value: string, options?: {
         append?: boolean;
     }): this;
-    /**
-     * Deletes a response header by key.
-     *
-     * If the native Response object is not yet available (`this.res` is falsy),
-     * it removes the header from the internal headers store.
-     * If the native Response object is available, it removes the header directly from the response headers.
-     *
-     * @param {ResHeaderKey} key - The name of the header to delete (case-insensitive).
-     * @returns {this} Returns the current instance for method chaining.
-     */
-    deleteHeader(key: ResHeaderKey): this;
     protected set params(params: Record<string, any>);
     /**
      * Gets the wrapped request object (`TezXRequest`).
      *
      * Lazily initializes the wrapped request on first access.
      *
-     * @returns {TezXRequest<Path>} The wrapped request.
+     * @returns {TezXRequest<TPath>} The wrapped request.
      */
-    get req(): TezXRequest<Path>;
+    get req(): TezXRequest<TPath>;
     /**
      * Gets the response body.
      * @returns {*} The response body.
@@ -140,7 +144,7 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
      * @returns {HttpBaseResponse} Response object suitable for runtime.
      * @protected
      */
-    newResponse(body: BodyInit | null, init?: ResponseInit): HttpBaseResponse;
+    newResponse(body: BodyInit | null, init?: ResponseInit): Response;
     /**
      * Sends a plain text response.
      *
@@ -154,28 +158,33 @@ export declare class Context<T extends Record<string, any> = {}, Path extends st
     /**
      * Sends an HTML response.
      *
-     * Can be used as a template literal or simple HTML string.
+     * Supports both:
+     * - Simple string: `ctx.html("<h1>Hello</h1>")`
+     * - Template literal: `ctx.html`<h1>${title}</h1>``
      *
-     * @param {string | readonly string[]} strings - HTML string or template literals.
-     * @param {...any[]} [args] - Optional values for template literals or ResponseInit.
-     * @returns {HttpBaseResponse} A properly constructed HTML response.
+     * Minimizes intermediate string allocations for lower GC overhead.
      *
-     * @example
-     * ctx.html("<h1>Hello</h1>");
-     * ctx.html`<h1>${title}</h1>`;
+     * @param {string | readonly string[]} strings - HTML string or template literal array.
+     * @param {...any[]} args - Values for template literals or a ResponseInit object if using a string.
+     * @returns {HttpBaseResponse} Constructed HTML response.
      */
     html(strings: string, init?: ResponseInit): HttpBaseResponse;
     html(strings: readonly string[], ...values: any[]): HttpBaseResponse;
     /**
      * Sends an XML response.
      *
-     * Automatically sets Content-Type to `application/xml; charset=utf-8`.
+     * Supports both:
+     * - Simple string: `ctx.xml("<note><to>User</to></note>")`
+     * - Template literal: `ctx.xml`<note><to>${user}</to></note>``
      *
-     * @param {string} xml - XML string.
-     * @param {ResponseInit} [init] - Optional response init.
-     * @returns {HttpBaseResponse} The response object.
+     * Minimizes intermediate string allocations for lower GC overhead.
+     *
+     * @param {string | readonly string[]} strings - XML string or template literal array.
+     * @param {...any[]} args - Values for template literals or a ResponseInit object if using a string.
+     * @returns {HttpBaseResponse} Constructed XML response.
      */
-    xml(xml: string, init?: ResponseInit): HttpBaseResponse;
+    xml(strings: string, init?: ResponseInit): HttpBaseResponse;
+    xml(strings: readonly string[], ...values: any[]): HttpBaseResponse;
     /**
      * Sends a JSON response.
      *