tezx 2.0.8 → 2.0.10

package/cjs/core/router.js

@@ -250,7 +250,7 @@ class Router extends MiddlewareConfigure_js_1.default {
             if (!config_js_1.GlobalConfig.overwriteMethod && handler.has(method))
                 return;
             return handler.set(method, {
-                callback,
+                callback: callback,
                 paramNames: [],
                 regex: regex,
                 middlewares: finalMiddleware
@@ -275,7 +275,7 @@ class Router extends MiddlewareConfigure_js_1.default {
             if (!config_js_1.GlobalConfig.overwriteMethod && handler.has(method))
                 return;
             return handler.set(method, {
-                callback,
+                callback: callback,
                 regex: regex,
                 paramNames: paramNames,
                 middlewares: finalMiddleware

package/cjs/index.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = exports.compileRegexRoute = exports.regexMatchRoute = exports.TezX = exports.Router = void 0;
+exports.version = exports.regexMatchRoute = exports.compileRegexRoute = exports.TezX = exports.Router = void 0;
 const router_js_1 = require("./core/router.js");
 const server_js_1 = require("./core/server.js");
 const regexRouter_js_1 = require("./utils/regexRouter.js");
-Object.defineProperty(exports, "regexMatchRoute", { enumerable: true, get: function () { return regexRouter_js_1.regexMatchRoute; } });
 Object.defineProperty(exports, "compileRegexRoute", { enumerable: true, get: function () { return regexRouter_js_1.compileRegexRoute; } });
+Object.defineProperty(exports, "regexMatchRoute", { enumerable: true, get: function () { return regexRouter_js_1.regexMatchRoute; } });
 var router_js_2 = require("./core/router.js");
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return router_js_2.Router; } });
 var server_js_2 = require("./core/server.js");
 Object.defineProperty(exports, "TezX", { enumerable: true, get: function () { return server_js_2.TezX; } });
-exports.version = "2.0.8";
+exports.version = "2.0.10";
 exports.default = {
     Router: router_js_1.Router,
     regexMatchRoute: regexRouter_js_1.regexMatchRoute, compileRegexRoute: regexRouter_js_1.compileRegexRoute,

package/core/router.d.ts

@@ -80,9 +80,9 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * // With multiple middlewares
      * app.get('/admin', [authMiddleware, adminMiddleware], (ctx) => { ... });
      */
-    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;
+    get<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    get<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    get<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Registers a Server-Sent Events (SSE) route handler for the given path.
      *
@@ -115,63 +115,63 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * @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: PathType, handler: (ctx: Context) => any): void;
+    sse<U extends Record<string, any> = {}>(path: PathType, handler: (ctx: Context<T & U>) => 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: 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;
+    post<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    post<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    post<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Registers a PUT route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    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;
+    put<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    put<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    put<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Registers a PATCH route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    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;
+    patch<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    patch<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    patch<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Registers a DELETE route with optional middleware(s)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    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;
+    delete<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    delete<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    delete<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): 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: 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;
+    options<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    options<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    options<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Registers a HEAD route (returns headers only)
      * @param path - URL path pattern
      * @param args - Handler callback or middleware(s) + handler
      */
-    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;
+    head<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    head<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    head<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): 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: 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;
+    all<U extends Record<string, any> = {}>(path: PathType, callback: Callback<T & U>): this;
+    all<U extends Record<string, any> = {}>(path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    all<U extends Record<string, any> = {}>(path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Generic method registration for custom HTTP methods
      * @param method - HTTP method name (e.g., 'PURGE')
@@ -182,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: 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;
+    addRoute<U extends Record<string, any> = {}>(method: HTTPMethod, path: PathType, callback: Callback<T & U>): this;
+    addRoute<U extends Record<string, any> = {}>(method: HTTPMethod, path: PathType, middleware: Middleware<T & U>): this;
+    addRoute<U extends Record<string, any> = {}>(method: HTTPMethod, path: PathType, middleware: Middleware<T & U>, callback: Callback<T & U>): this;
+    addRoute<U extends Record<string, any> = {}>(method: HTTPMethod, path: PathType, middlewares: Middleware<T & U>[], callback: Callback<T & U>): this;
     /**
      * Mount a sub-router at specific path prefix
      * @param path - Base path for the sub-router
@@ -197,7 +197,7 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * apiRouter.get('/users', () => { ... });
      * server.addRouter('/api', apiRouter);
      */
-    addRouter(path: string, router: Router<T | any>): void;
+    addRouter<U extends Record<string, any> = {}>(path: string, router: Router<T | U | any>): void;
     /**
      * Create route group with shared path prefix
      * @param prefix - Path prefix for the group
@@ -209,7 +209,7 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      *   group.get('/users', v1UserHandler);
      * });
      */
-    group(prefix: string, callback: (group: Router<T>) => void): this;
+    group<U extends Record<string, any> = {}>(prefix: string, callback: (group: Router<T & U>) => void): this;
     /**
      * Register middleware with flexible signature
      * @overload
@@ -217,14 +217,14 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
      * @param middlewares - Middleware(s) to register
      * @param [callback] - Optional sub-router or handler
      */
-    use(path: string, middlewares: Middleware<T>[], callback: Callback<T> | Router<T | any>): this;
-    use(path: string, middleware: Middleware<T>, callback: Callback<T> | Router<T | any>): this;
-    use(path: string, middlewares: Middleware<T>[]): this;
-    use(path: string, middlewares: Middleware<T>): this;
-    use(path: string, callback: Callback<T> | Router<T | any>): this;
-    use(middlewares: Middleware<T>[], callback: Callback<T> | Router<T | any>): this;
-    use(middleware: Middleware<T>, callback: Callback<T> | Router<T | any>): this;
-    use(middlewares: Middleware<T>[]): this;
-    use(middleware: Middleware<T>): this;
-    use(callback: Callback<T> | Router<T | any>): this;
+    use<U extends Record<string, any> = {}>(path: string, middlewares: Middleware<T & U>[], callback: Callback<T & U> | Router<T & U | any>): this;
+    use<U extends Record<string, any> = {}>(path: string, middleware: Middleware<T & U>, callback: Callback<T & U> | Router<T & U | any>): this;
+    use<U extends Record<string, any> = {}>(path: string, middlewares: Middleware<T & U>[]): this;
+    use<U extends Record<string, any> = {}>(path: string, middlewares: Middleware<T & U>): this;
+    use<U extends Record<string, any> = {}>(path: string, callback: Callback<T & U> | Router<T & U | any>): this;
+    use<U extends Record<string, any> = {}>(middlewares: Middleware<T & U>[], callback: Callback<T & U> | Router<T & U | any>): this;
+    use<U extends Record<string, any> = {}>(middleware: Middleware<T & U>, callback: Callback<T & U> | Router<T & U | any>): this;
+    use<U extends Record<string, any> = {}>(middlewares: Middleware<T & U>[]): this;
+    use<U extends Record<string, any> = {}>(middleware: Middleware<T & U>): this;
+    use<U extends Record<string, any> = {}>(callback: Callback<T & U> | Router<T & U | any>): this;
 }

package/core/router.js

@@ -213,7 +213,7 @@ export class Router extends MiddlewareConfigure {
             if (!GlobalConfig.overwriteMethod && handler.has(method))
                 return;
             return handler.set(method, {
-                callback,
+                callback: callback,
                 paramNames: [],
                 regex: regex,
                 middlewares: finalMiddleware
@@ -238,7 +238,7 @@ export class Router extends MiddlewareConfigure {
             if (!GlobalConfig.overwriteMethod && handler.has(method))
                 return;
             return handler.set(method, {
-                callback,
+                callback: callback,
                 regex: regex,
                 paramNames: paramNames,
                 middlewares: finalMiddleware

package/index.d.ts

@@ -1,15 +1,16 @@
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
-import { regexMatchRoute, compileRegexRoute } from "./utils/regexRouter.js";
+import { compileRegexRoute, regexMatchRoute } from "./utils/regexRouter.js";
 export { Router } from "./core/router.js";
-export type { Callback, ctx as Context, Middleware, NextCallback, RouterConfig, PathType, StaticServeOption } from "./core/router.js";
+export type { Callback, ctx as Context, Middleware, NextCallback, PathType, RouterConfig, StaticServeOption } from "./core/router.js";
+export type { Context as BaseContext } from "./core/context.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 { regexMatchRoute, compileRegexRoute };
+export { compileRegexRoute, regexMatchRoute };
 export declare let version: string;
 declare const _default: {
     Router: typeof Router;

package/index.js

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

package/middleware/index.d.ts

@@ -33,6 +33,6 @@ declare const _default: {
     requestTimeout: (options: import("./requestTimeout.js").TimeoutOptions) => import("../index.js").Middleware;
     sanitizeHeaders: (options?: import("./sanitizeHeader.js").SanitizeHeadersOptions) => import("../index.js").Middleware;
     secureHeaders: (options?: import("./secureHeaders.js").SecurityHeaderOptions) => import("../index.js").Middleware;
-    xssProtection: (options?: import("./xssProtection.js").XSSProtectionOptions) => (ctx: import("../core/context.js").Context, next: import("../index.js").NextCallback) => Promise<any>;
+    xssProtection: (options?: import("./xssProtection.js").XSSProtectionOptions) => (ctx: import("../index.js").BaseContext, next: import("../index.js").NextCallback) => Promise<any>;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "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",