tezx 2.0.11 → 3.0.0

package/cjs/core/router.js

@@ -1,65 +1,17 @@
 "use strict";
-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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.TrieRouter = void 0;
-const regexRouter_js_1 = require("../utils/regexRouter.js");
-const staticFile_js_1 = require("../utils/staticFile.js");
-const url_js_1 = require("../utils/url.js");
-const config_js_1 = require("./config.js");
-const MiddlewareConfigure_js_1 = __importStar(require("./MiddlewareConfigure.js"));
-class TrieRouter {
-    children = new Map();
-    handlers = new Map();
-    pathname;
-    paramName;
-    isParam = false;
-    constructor(pathname = "/") {
-        this.children = new Map();
-        this.pathname = pathname;
-    }
-}
-exports.TrieRouter = TrieRouter;
-class Router extends MiddlewareConfigure_js_1.default {
-    routers = new Map();
+exports.Router = void 0;
+const low_level_js_1 = require("../utils/low-level.js");
+const error_js_1 = require("./error.js");
+class Router {
     env = {};
-    triRouter;
+    router;
+    route = [];
+    staticFile = Object.create(null);
+    basePath;
     constructor({ basePath = "/", env = {} } = {}) {
-        super(basePath);
         this.basePath = basePath;
         this.env = { ...env };
-        this.triRouter = new TrieRouter(basePath);
         this.get = this.get.bind(this);
         this.post = this.post.bind(this);
         this.put = this.put.bind(this);
@@ -68,57 +20,30 @@ class Router extends MiddlewareConfigure_js_1.default {
         this.addRouter = this.addRouter.bind(this);
         this.group = this.group.bind(this);
     }
-    static(...args) {
-        let route = "";
-        let dir;
-        let options = {};
-        switch (args.length) {
-            case 3:
-                [route, dir, options] = args;
-                break;
-            case 2:
-                if (typeof args[1] === "object") {
-                    [dir, options] = args;
-                }
-                else {
-                    [route, dir] = args;
-                }
-                break;
-            case 1:
-                [dir] = args;
-                break;
-            default:
-                throw new Error(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+    static(serveStatic) {
+        if (Array.isArray(serveStatic?.files)) {
+            serveStatic?.files.forEach((r) => {
+                this.staticFile[`GET ${r?.route}`] = (ctx) => {
+                    if (serveStatic?.options?.cacheControl) {
+                        ctx.setHeader("Cache-Control", serveStatic?.options.cacheControl);
+                    }
+                    let headers = serveStatic?.options?.headers;
+                    if (headers) {
+                        for (const key in headers) {
+                            let value = headers?.[key];
+                            ctx.headers.set(key, value);
+                        }
+                    }
+                    return ctx.sendFile(r.fileSource);
+                };
+            });
         }
-        (0, staticFile_js_1.getFiles)(dir, route, this, options);
         return this;
     }
     get(path, ...args) {
         this.#registerRoute("GET", path, ...args);
         return this;
     }
-    sse(path, handler) {
-        this.get(path, async (ctx) => {
-            let res = await handler(ctx);
-            const headersMap = {};
-            if (res instanceof Response) {
-                for (const [key, value] of res.headers.entries()) {
-                    headersMap[key.toLowerCase()] = value;
-                }
-                res = res.body;
-            }
-            const headers = {
-                ...headersMap,
-                "content-type": "text/event-stream",
-                "cache-control": "no-cache",
-                connection: "keep-alive",
-            };
-            return new Response(res, {
-                status: 200,
-                headers,
-            });
-        });
-    }
     post(path, ...args) {
         this.#registerRoute("POST", path, ...args);
         return this;
@@ -139,27 +64,26 @@ class Router extends MiddlewareConfigure_js_1.default {
         this.#registerRoute("OPTIONS", path, ...args);
         return this;
     }
-    head(path, ...args) {
-        this.#registerRoute("HEAD", path, ...args);
-        return this;
-    }
     all(path, ...args) {
         this.#registerRoute("ALL", path, ...args);
         return this;
     }
-    addRoute(method, path, ...args) {
-        this.#registerRoute(method, path, ...args);
+    when(methods, path, ...args) {
+        const methodList = Array.isArray(methods) ? methods : [methods];
+        for (const method of methodList) {
+            this.#registerRoute(method.toUpperCase(), path, ...args);
+        }
         return this;
     }
     addRouter(path, router) {
-        return this.#routeAddTriNode(path, router);
+        return this.#addRouterInstance(path, router);
     }
     group(prefix, callback) {
         const router = new Router({
             basePath: prefix,
         });
         callback(router);
-        this.#routeAddTriNode("/", router);
+        this.#addRouterInstance("/", router);
         return this;
     }
     use(...args) {
@@ -196,15 +120,26 @@ class Router extends MiddlewareConfigure_js_1.default {
         else if (args[0] instanceof Router) {
             router = args[0];
         }
-        this.#addRouteMiddleware(path, middlewares);
+        if (middlewares?.length) {
+            this.#addRoute("ALL", path, middlewares);
+        }
         if (router && router instanceof Router) {
             this.addRouter(path, router);
         }
         return this;
     }
+    #addRoute(method, path, handlers) {
+        let pattern = `/${(0, low_level_js_1.sanitizePathSplitBasePath)(this.basePath, path).join("/")}`;
+        this.router?.addRoute(method, pattern, handlers);
+        this.route.push({
+            method: method,
+            pattern: pattern,
+            handlers: handlers,
+        });
+    }
     #registerRoute(method, path, ...args) {
         if (args.length === 0) {
-            throw new Error("At least one handler is required.");
+            throw new error_js_1.TezXError("At least one handler is required.");
         }
         let middlewares = [];
         let callback;
@@ -221,290 +156,22 @@ class Router extends MiddlewareConfigure_js_1.default {
             callback = args[0];
         }
         if (typeof callback !== "function") {
-            throw new Error("Route callback function is missing or invalid.");
+            throw new error_js_1.TezXError("Route callback function is missing or invalid.");
         }
         if (!middlewares.every((middleware) => typeof middleware === "function")) {
-            throw new Error("Middleware must be a function or an array of functions.");
+            throw new error_js_1.TezXError("Middleware must be a function or an array of functions.");
         }
-        this.#addRoute(method, path, callback, middlewares);
+        this.#addRoute(method, path, [...middlewares, callback]);
     }
-    #addRoute(method, path, callback, middlewares) {
-        let finalMiddleware = middlewares;
-        if (!config_js_1.GlobalConfig.allowDuplicateMw) {
-            finalMiddleware = new Set(middlewares);
-        }
-        if (path instanceof RegExp) {
-            let regex = (0, regexRouter_js_1.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 (!config_js_1.GlobalConfig.overwriteMethod && handler.has(method))
-                return;
-            return handler.set(method, {
-                callback: callback,
-                paramNames: [],
-                regex: regex,
-                middlewares: finalMiddleware
-            });
-        }
-        const parts = (0, url_js_1.sanitizePathSplit)(this.basePath, path);
-        let p = parts.join("/");
-        if (url_js_1.wildcardOrOptionalParamRegex.test(`/${p}`)) {
-            let strPath = `string://${p}`;
-            let { paramNames, regex } = (0, regexRouter_js_1.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(strPath, handler);
-            }
-            if (!config_js_1.GlobalConfig.overwriteMethod && handler.has(method))
-                return;
-            return handler.set(method, {
-                callback: callback,
-                regex: regex,
-                paramNames: paramNames,
-                middlewares: finalMiddleware
-            });
-        }
-        let node = this.triRouter;
-        for (const part of parts) {
-            if (part.startsWith(":")) {
-                if (!node.children.has(":")) {
-                    node.children.set(":", new TrieRouter());
-                }
-                node = node.children.get(":");
-                node.isParam = true;
-                if (!node.paramName) {
-                    node.paramName = part.slice(1);
-                }
-            }
-            else {
-                if (!node.children.has(part)) {
-                    node.children.set(part, new TrieRouter());
-                }
-                node = node.children.get(part);
-            }
-        }
-        if (!config_js_1.GlobalConfig.overwriteMethod && node.handlers.has(method))
-            return;
-        node.handlers.set(method, {
-            callback: callback,
-            middlewares: finalMiddleware,
-        });
-        node.pathname = `/${p}`;
-    }
-    #addRouteMiddleware(path, middlewareFunctions) {
-        this.addMiddleware(path, middlewareFunctions);
-    }
-    #routeAddTriNode(path, router) {
+    #addRouterInstance(path, router) {
         this.env = { ...this.env, ...router.env };
         if (!(router instanceof Router)) {
-            throw new Error("Router instance is required.");
-        }
-        const parts = (0, url_js_1.sanitizePathSplit)(this.basePath, path);
-        if (router.routers.size) {
-            for (const [segment, handlers] of router.routers) {
-                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 (!config_js_1.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 } = (0, regexRouter_js_1.compileRegexRoute)(joined);
-                            h.set(method, {
-                                callback: callback,
-                                middlewares: middlewares,
-                                paramNames,
-                                regex
-                            });
-                        }
-                        this.routers.set(strPath, h);
-                    }
-                }
-                else {
-                    let pattern = segment.replace("regex://", "");
-                    let base = parts?.join("/");
-                    let regex = (0, regexRouter_js_1.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 (!config_js_1.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);
-                    }
-                }
-            }
-        }
-        let rootNode = this.triRouter;
-        let rootMiddlewares = this.triMiddlewares;
-        if (parts.length == 0) {
-            this.#addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router);
-        }
-        else {
-            for (const part of parts) {
-                if (part.startsWith(":")) {
-                    if (!rootNode.children.has(":")) {
-                        rootNode.children.set(":", new TrieRouter());
-                    }
-                    rootNode = rootNode.children.get(":");
-                    rootNode.isParam = true;
-                    if (!rootNode.paramName) {
-                        rootNode.paramName = part.slice(1);
-                    }
-                }
-                else {
-                    if (!rootNode.children.has(part)) {
-                        rootNode.children.set(part, new TrieRouter());
-                    }
-                    rootNode = rootNode.children.get(part);
-                }
-            }
-            for (const part of parts) {
-                if (part.startsWith("*")) {
-                    if (!rootMiddlewares.children.has("*")) {
-                        rootMiddlewares.children.set("*", new MiddlewareConfigure_js_1.TriMiddleware());
-                    }
-                    rootMiddlewares = rootMiddlewares.children.get("*");
-                }
-                else if (part.startsWith(":")) {
-                    const isOptional = part?.endsWith("?");
-                    if (isOptional) {
-                        rootMiddlewares.isOptional = isOptional;
-                        continue;
-                    }
-                    if (!rootMiddlewares.children.has(":")) {
-                        rootMiddlewares.children.set(":", new MiddlewareConfigure_js_1.TriMiddleware());
-                    }
-                    rootMiddlewares = rootMiddlewares.children.get(":");
-                }
-                else {
-                    if (!rootMiddlewares.children.has(part)) {
-                        rootMiddlewares.children.set(part, new MiddlewareConfigure_js_1.TriMiddleware());
-                    }
-                    rootMiddlewares = rootMiddlewares.children.get(part);
-                }
-            }
-            this.#addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router);
-        }
-    }
-    #addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router) {
-        function addSubRouter(children, node) {
-            let rtN = node;
-            for (const element of children) {
-                const pathSegment = element[0];
-                const subRouter = element[1];
-                if (rtN.children.has(pathSegment)) {
-                    let findNode = rtN.children.get(pathSegment);
-                    for (const [method, handlers] of subRouter.handlers) {
-                        if (!config_js_1.GlobalConfig.overwriteMethod && node.handlers.has(method))
-                            return;
-                        findNode.handlers.set(method, handlers);
-                    }
-                    if (subRouter.children.size) {
-                        addSubRouter(subRouter.children, findNode);
-                    }
-                }
-                else {
-                    rtN.children.set(pathSegment, subRouter);
-                }
-            }
-        }
-        let routerNode = router.triRouter;
-        const routerMiddlewares = router.triMiddlewares;
-        for (const [method, handlers] of routerNode.handlers) {
-            if (!config_js_1.GlobalConfig.overwriteMethod) {
-                rootNode.handlers.set(method, handlers);
-                continue;
-            }
-            if (!rootNode.handlers.has(method)) {
-                rootNode.handlers.set(method, handlers);
-            }
-        }
-        if (routerNode.children.size > 0) {
-            addSubRouter(routerNode.children, rootNode);
-        }
-        function addMiddleware(children, node) {
-            let n = node;
-            for (const [path, middlewareNode] of children) {
-                if (n.children.has(path)) {
-                    let findNode = n.children.get(path);
-                    if (config_js_1.GlobalConfig.allowDuplicateMw) {
-                        findNode.middlewares.push(...middlewareNode.middlewares);
-                    }
-                    else {
-                        for (const mw of middlewareNode.middlewares) {
-                            if (findNode.middlewares.has(mw)) {
-                                middlewareNode.middlewares.delete(mw);
-                            }
-                            findNode.middlewares.add(mw);
-                        }
-                    }
-                    if (middlewareNode.children.size) {
-                        addMiddleware(middlewareNode.children, findNode);
-                    }
-                }
-                else {
-                    n.children.set(path, middlewareNode);
-                }
-            }
-        }
-        if (config_js_1.GlobalConfig.allowDuplicateMw) {
-            rootMiddlewares.middlewares.push(...routerMiddlewares.middlewares);
-        }
-        else {
-            for (const mw of routerMiddlewares.middlewares) {
-                if (rootMiddlewares.middlewares.has(mw)) {
-                    routerMiddlewares.middlewares.delete(mw);
-                }
-                rootMiddlewares.middlewares.add(mw);
-            }
-        }
-        if (routerMiddlewares.children.size > 0) {
-            addMiddleware(routerMiddlewares.children, rootMiddlewares);
+            throw new error_js_1.TezXError("Router instance is required.");
         }
+        router.route.forEach((r) => {
+            this.#addRoute(r?.method, `/${(0, low_level_js_1.sanitizePathSplitBasePath)(path, r?.pattern).join("/")}`, r?.handlers);
+        });
+        Object.assign(this.staticFile, router.staticFile);
     }
 }
 exports.Router = Router;