tezx 1.0.13 → 1.0.15

package/dist/cjs/router.js

@@ -1,377 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = void 0;
-const config_1 = require("./config/config");
-const MiddlewareConfigure_1 = require("./MiddlewareConfigure");
-const staticFile_1 = require("./utils/staticFile");
-const url_1 = require("./utils/url");
-class TrieRouter {
-    children = new Map();
-    handlers = new Map();
-    pathname;
-    paramName;
-    isParam = false;
-    constructor(pathname = "/") {
-        this.children = new Map();
-        this.pathname = pathname;
-    }
-}
-class Router extends MiddlewareConfigure_1.default {
-    routers = new Map();
-    env = {};
-    triRouter;
-    constructor({ basePath = "/", env = {} } = {}) {
-        super(basePath);
-        this.basePath = basePath;
-        this.env = { ...env };
-        this.triRouter = new TrieRouter(basePath);
-        this.get.bind(this);
-        this.post.bind(this);
-        this.put.bind(this);
-        this.delete.bind(this);
-        this.all.bind(this);
-        this.#routeAddTriNode.bind(this);
-        this.addRouter.bind(this);
-        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`);
-        }
-        (0, staticFile_1.getFiles)(dir, route, this, options);
-        return this;
-    }
-    get(path, ...args) {
-        this.#registerRoute("GET", path, ...args);
-        return this;
-    }
-    post(path, ...args) {
-        this.#registerRoute("POST", path, ...args);
-        return this;
-    }
-    put(path, ...args) {
-        this.#registerRoute("PUT", path, ...args);
-        return this;
-    }
-    patch(path, ...args) {
-        this.#registerRoute("PATCH", path, ...args);
-        return this;
-    }
-    delete(path, ...args) {
-        this.#registerRoute("DELETE", path, ...args);
-        return this;
-    }
-    options(path, ...args) {
-        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);
-        return this;
-    }
-    addRouter(path, router) {
-        return this.#routeAddTriNode(path, router);
-    }
-    group(prefix, callback) {
-        const router = new Router({
-            basePath: prefix,
-        });
-        callback(router);
-        this.#routeAddTriNode("/", router);
-        return this;
-    }
-    use(...args) {
-        let path = "/";
-        let middlewares = [];
-        let router;
-        if (typeof args[0] === "string") {
-            path = args[0];
-            if (Array.isArray(args[1])) {
-                middlewares = args[1];
-                router = args[2];
-            }
-            else if (typeof args[1] === "function") {
-                middlewares = [args[1]];
-                router = args[2];
-            }
-            else {
-                router = args[1];
-            }
-        }
-        else if (typeof args[0] === "function") {
-            if (args.length === 1) {
-                middlewares = [args[0]];
-            }
-            else {
-                middlewares = [args[0]];
-                router = args[1];
-            }
-        }
-        else if (Array.isArray(args[0])) {
-            middlewares = args[0];
-            router = args[1];
-        }
-        else if (args[0] instanceof Router) {
-            router = args[0];
-        }
-        this.#addRouteMiddleware(path, middlewares);
-        if (router && router instanceof Router) {
-            this.addRouter(path, router);
-        }
-        return this;
-    }
-    #registerRoute(method, path, ...args) {
-        if (args.length === 0) {
-            throw new Error("At least one handler is required.");
-        }
-        let middlewares = [];
-        let callback;
-        if (args.length > 1) {
-            if (Array.isArray(args[0])) {
-                middlewares = args[0];
-            }
-            else if (typeof args[0] === "function") {
-                middlewares = [args[0]];
-            }
-            callback = args[args.length - 1];
-        }
-        else {
-            callback = args[0];
-        }
-        if (typeof callback !== "function") {
-            throw new Error("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.");
-        }
-        this.#addRoute(method, path, callback, middlewares);
-    }
-    #addRoute(method, path, callback, middlewares) {
-        const parts = (0, url_1.sanitizePathSplit)(this.basePath, path);
-        let finalMiddleware = middlewares;
-        if (!config_1.GlobalConfig.allowDuplicateMw) {
-            finalMiddleware = new Set(middlewares);
-        }
-        let p = parts.join("/");
-        if (/(\/\*|\?)/.test(p)) {
-            let handler = this.routers.get(p);
-            if (!handler) {
-                handler = new Map();
-                handler.set(method, {
-                    callback: callback,
-                    middlewares: finalMiddleware,
-                });
-                return this.routers.set(p, handler);
-            }
-            if (!config_1.GlobalConfig.overwriteMethod && handler.has(method))
-                return;
-            return handler.set(method, { callback, 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_1.GlobalConfig.overwriteMethod && node.handlers.has(method))
-            return;
-        node.handlers.set(method, {
-            callback: callback,
-            middlewares: finalMiddleware,
-        });
-        node.pathname = path;
-    }
-    #addRouteMiddleware(path, middlewareFunctions) {
-        this.addMiddleware(path, middlewareFunctions);
-    }
-    #routeAddTriNode(path, router) {
-        this.env = { ...this.env, ...router.env };
-        if (!(router instanceof Router)) {
-            throw new Error("Router instance is required.");
-        }
-        const parts = (0, url_1.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 (!config_1.GlobalConfig.overwriteMethod && baseRouter.has(method))
-                            return;
-                        baseRouter.set(method, handler);
-                    }
-                }
-                else {
-                    this.routers.set(path, new Map(handlers));
-                }
-            }
-        }
-        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_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_1.TriMiddleware());
-                    }
-                    rootMiddlewares = rootMiddlewares.children.get(":");
-                }
-                else {
-                    if (!rootMiddlewares.children.has(part)) {
-                        rootMiddlewares.children.set(part, new MiddlewareConfigure_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_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_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_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_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);
-        }
-    }
-}
-exports.Router = Router;

package/dist/cjs/server.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TezX = void 0;
-const config_1 = require("./config/config");
-const context_1 = require("./context");
-const router_1 = require("./router");
-const colors_1 = require("./utils/colors");
-const params_1 = require("./utils/params");
-class TezX extends router_1.Router {
-    constructor({ basePath = "/", env = {}, debugMode = false, allowDuplicateMw = false, overwriteMethod = true, } = {}) {
-        config_1.GlobalConfig.allowDuplicateMw = allowDuplicateMw;
-        config_1.GlobalConfig.overwriteMethod = overwriteMethod;
-        if (debugMode) {
-            config_1.GlobalConfig.debugMode = debugMode;
-        }
-        super({ basePath, env });
-        this.serve = this.serve.bind(this);
-    }
-    #hashRouter(method, pathname) {
-        const routers = this.routers;
-        for (let pattern of this.routers.keys()) {
-            const { success, params } = (0, params_1.useParams)({
-                path: pathname,
-                urlPattern: pattern,
-            });
-            const handlers = routers.get(pattern)?.get(method) || routers.get(pattern)?.get("ALL");
-            if (success && handlers) {
-                return {
-                    callback: handlers.callback,
-                    middlewares: handlers.middlewares,
-                    params: params,
-                };
-            }
-        }
-        return null;
-    }
-    #triRouter(method, pathname) {
-        const parts = pathname.split("/").filter(Boolean);
-        const params = {};
-        let node = this.triRouter;
-        for (let part of parts) {
-            if (node.children.has(part)) {
-                node = node.children.get(part);
-            }
-            else if (node.children.has(":")) {
-                node = node.children.get(":");
-                if (node.paramName)
-                    params[node.paramName] = part;
-            }
-            else {
-                return null;
-            }
-        }
-        if (node?.handlers?.size && node?.pathname) {
-            const handlers = node.handlers.get(method) || node.handlers.get("ALL");
-            if (handlers) {
-                return {
-                    middlewares: handlers.middlewares,
-                    callback: handlers.callback,
-                    params: params,
-                };
-            }
-            return null;
-        }
-        return null;
-    }
-    findRoute(method, pathname) {
-        const route = this.#triRouter(method, pathname) || this.#hashRouter(method, pathname);
-        if (route) {
-            return {
-                ...route,
-                middlewares: [...route.middlewares],
-            };
-        }
-        return null;
-    }
-    #createHandler(middlewares, finalCallback) {
-        return async (ctx) => {
-            let index = 0;
-            const next = async () => {
-                if (index < middlewares.length) {
-                    return await middlewares[index++](ctx, next);
-                }
-                else {
-                    return await finalCallback(ctx);
-                }
-            };
-            const response = await next();
-            if (!response) {
-                throw new Error(`Handler did not return a response or next() was not called. Path: ${ctx.pathname}, Method: ${ctx.method}`);
-            }
-            return response;
-        };
-    }
-    #findMiddleware(pathname) {
-        const parts = pathname.split("/").filter(Boolean);
-        let middlewares = [];
-        let node = this.triMiddlewares;
-        for (let part of parts) {
-            if (node.children.has(part)) {
-                node = node.children.get(part);
-            }
-            else if (node.children.has("*")) {
-                node = node.children.get("*");
-            }
-            else if (node.children.has(":")) {
-                node = node.children.get(":");
-            }
-            else {
-                break;
-            }
-            middlewares.push(...node.middlewares);
-        }
-        return middlewares;
-    }
-    async #handleRequest(req, connInfo) {
-        let ctx = new context_1.Context(req, connInfo);
-        const urlRef = ctx.req.urlRef;
-        const { pathname } = urlRef;
-        let middlewares = this.#findMiddleware(pathname);
-        ctx.env = this.env;
-        try {
-            let callback = async (ctx) => {
-                const find = this.findRoute(ctx.req.method, pathname);
-                if (find?.callback) {
-                    ctx.params = find.params;
-                    const callback = find.callback;
-                    let middlewares = find.middlewares;
-                    return (await this.#createHandler(middlewares, callback)(ctx));
-                }
-                else {
-                    let res = await config_1.GlobalConfig.notFound(ctx);
-                    ctx.setStatus = res.status;
-                    return res;
-                }
-            };
-            let response = await this.#createHandler([...this.triMiddlewares.middlewares, ...middlewares], callback)(ctx);
-            let finalResponse = () => {
-                return (ctx) => {
-                    if (response?.headers) {
-                        ctx.headers.add(response.headers);
-                    }
-                    const statusText = response?.statusText || context_1.httpStatusMap[response?.status] || "";
-                    const status = response.status || ctx.getStatus;
-                    let headers = ctx.headers.toObject();
-                    return new Response(response.body, {
-                        status,
-                        statusText,
-                        headers,
-                    });
-                };
-            };
-            return finalResponse()(ctx);
-        }
-        catch (err) {
-            let error = err;
-            if (err instanceof Error) {
-                error = err.stack;
-            }
-            config_1.GlobalConfig.debugging.error(`${colors_1.COLORS.bgRed} ${ctx.pathname}, Method: ${ctx.method} ${colors_1.COLORS.reset}`, `${context_1.httpStatusMap[500]}: ${error} `);
-            let res = await config_1.GlobalConfig.onError(error, ctx);
-            ctx.setStatus = res.status;
-            return res;
-        }
-    }
-    async serve(req, connInfo) {
-        return this.#handleRequest(req, connInfo);
-    }
-}
-exports.TezX = TezX;

package/dist/cjs/utils/colors.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COLORS = void 0;
-exports.COLORS = {
-    reset: "\x1b[0m",
-    bold: "\x1b[1m",
-    underline: "\x1b[4m",
-    gray: "\x1b[90m",
-    white: "\x1b[97m",
-    black: "\x1b[30m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-    bgRed: "\x1b[41m",
-    bgGreen: "\x1b[42m",
-    bgYellow: "\x1b[43m",
-    bgBlue: "\x1b[44m",
-    bgMagenta: "\x1b[45m",
-    bgCyan: "\x1b[46m",
-    bgWhite: "\x1b[47m",
-};

package/dist/cjs/utils/debugging.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loggerOutput = void 0;
-const colors_1 = require("./colors");
-const loggerOutput = (level, message, ...args) => {
-    const timestamp = new Date().toISOString();
-    const LEVEL_COLORS = {
-        info: colors_1.COLORS.blue,
-        warn: colors_1.COLORS.yellow,
-        error: colors_1.COLORS.red,
-        debug: colors_1.COLORS.cyan,
-        success: colors_1.COLORS.green,
-    };
-    const levelText = `${LEVEL_COLORS[level]}[${level.toUpperCase()}]${colors_1.COLORS.reset}`;
-    console.log(` ${levelText} ${message}`, ...args?.flat());
-};
-exports.loggerOutput = loggerOutput;