tezx 1.0.20 → 1.0.22

package/.gitignore

@@ -0,0 +1,22 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*.local
+
+

package/.npmignore

@@ -0,0 +1,18 @@
+# Ignore all .ts files except .d.ts files
+# *.ts
+
+# Optional: Allow specific .ts files if needed
+# !/specific-directory/*.ts
+/test
+/query
+/utilities
+/docs
+/dist/test
+/src
+/dist/DataTypes
+!/dist/index.d.ts
+*.md
+!README.md
+tsconfig.json
+.npmignore
+.gitignore

package/MiddlewareConfigure.d.ts

@@ -0,0 +1,17 @@
+import { CommonHandler } from "./common";
+import { Middleware } from "./router";
+export type DuplicateMiddlewares = Middleware<any>[];
+export type UniqueMiddlewares = Set<Middleware<any>>;
+export declare class TriMiddleware {
+    children: Map<string, TriMiddleware>;
+    middlewares: DuplicateMiddlewares | UniqueMiddlewares;
+    isOptional: boolean;
+    pathname: string;
+    constructor(pathname?: string);
+}
+export default class MiddlewareConfigure<T extends Record<string, any> = {}> extends CommonHandler {
+    triMiddlewares: TriMiddleware;
+    protected basePath: string;
+    constructor(basePath?: string);
+    protected addMiddleware(pathname: string, middlewares: Middleware<T>[]): void;
+}

package/MiddlewareConfigure.js

@@ -0,0 +1,63 @@
+import { CommonHandler } from "./common";
+import { GlobalConfig } from "./config/config";
+import { sanitizePathSplit } from "./utils/url";
+export class TriMiddleware {
+    children = new Map();
+    middlewares = new Set();
+    isOptional = false;
+    pathname;
+    constructor(pathname = "/") {
+        this.pathname = pathname;
+        if (GlobalConfig.allowDuplicateMw) {
+            this.middlewares = [];
+        }
+        else {
+            this.middlewares = new Set();
+        }
+    }
+}
+export default class MiddlewareConfigure extends CommonHandler {
+    triMiddlewares = new TriMiddleware();
+    basePath;
+    constructor(basePath = "/") {
+        super();
+        this.basePath = basePath;
+    }
+    addMiddleware(pathname, middlewares) {
+        const parts = sanitizePathSplit(this.basePath, pathname);
+        let node = this.triMiddlewares;
+        for (const part of parts) {
+            if (part.startsWith("*")) {
+                if (!node.children.has("*")) {
+                    node.children.set("*", new TriMiddleware());
+                }
+                node = node.children.get("*");
+            }
+            else if (part.startsWith(":")) {
+                const isOptional = part?.endsWith("?");
+                if (isOptional) {
+                    node.isOptional = isOptional;
+                    continue;
+                }
+                if (!node.children.has(":")) {
+                    node.children.set(":", new TriMiddleware());
+                }
+                node = node.children.get(":");
+            }
+            else {
+                if (!node.children.has(part)) {
+                    node.children.set(part, new TriMiddleware());
+                }
+                node = node.children.get(part);
+            }
+        }
+        if (GlobalConfig.allowDuplicateMw) {
+            node.middlewares.push(...middlewares);
+        }
+        else {
+            for (const middleware of middlewares) {
+                node.middlewares.add(middleware);
+            }
+        }
+    }
+}

package/adapter.d.ts

@@ -0,0 +1,10 @@
+import { TezX } from "./server";
+export declare function denoAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => any;
+};
+export declare function bunAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => any;
+};
+export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => void;
+};

package/adapter.js

@@ -0,0 +1,162 @@
+import { GlobalConfig } from "./config/config";
+export function denoAdapter(TezX) {
+    function listen(port, callback) {
+        const isDeno = typeof Deno !== "undefined";
+        try {
+            async function handleRequest(req, connInfo) {
+                let remoteAddr = connInfo.remoteAddr;
+                let localAddr = { ...server.addr };
+                let address = {
+                    remoteAddr: {
+                        port: remoteAddr?.port,
+                        address: remoteAddr?.hostname,
+                        transport: remoteAddr?.transport,
+                        family: remoteAddr?.family,
+                    },
+                    localAddr: {
+                        port: localAddr?.port,
+                        address: localAddr?.hostname,
+                        transport: localAddr?.transport,
+                        family: localAddr?.family,
+                    },
+                };
+                const response = await TezX.serve(req, address);
+                if (response instanceof Response) {
+                    return response;
+                }
+                else {
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText || "",
+                        headers: new Headers(response.headers),
+                    });
+                }
+            }
+            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            GlobalConfig.serverInfo = server;
+            if (!server) {
+                throw new Error("Deno is not find");
+            }
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m🚀 Deno TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback === "function") {
+                callback(message);
+            }
+            else {
+                GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+export function bunAdapter(TezX) {
+    function listen(port, callback) {
+        const serve = typeof Bun !== "undefined" ? Bun.serve : null;
+        try {
+            if (!serve) {
+                throw new Error("Bun is not find");
+            }
+            const server = serve({
+                port: port,
+                async fetch(req) {
+                    const response = await TezX.serve(req, {
+                        remoteAddr: server.requestIP(req),
+                        localAddr: server.address,
+                    });
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                    else {
+                        return new Response(response.body, {
+                            status: response.status,
+                            statusText: response.statusText || "",
+                            headers: new Headers(response.headers),
+                        });
+                    }
+                },
+            });
+            GlobalConfig.serverInfo = server;
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m Bun TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback == "function") {
+                callback(message);
+            }
+            else {
+                GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+export function nodeAdapter(TezX) {
+    function listen(port, callback) {
+        import("http")
+            .then((r) => {
+            let server = r.createServer(async (req, res) => {
+                let address = {};
+                if (req.socket) {
+                    address = {
+                        remoteAddr: {
+                            family: req.socket.remoteFamily,
+                            address: req.socket.remoteAddress,
+                            port: req.socket.remotePort,
+                        },
+                        localAddr: {
+                            address: req.socket.localAddress,
+                            port: req.socket.localPort,
+                            family: req.socket.localFamily,
+                        },
+                    };
+                }
+                const response = await TezX.serve(req, address);
+                const statusText = response?.statusText;
+                if (!(response instanceof Response)) {
+                    throw new Error("Invalid response from TezX.serve");
+                }
+                const headers = Object.fromEntries(await response.headers.entries());
+                if (statusText) {
+                    res.statusMessage = statusText;
+                }
+                res.writeHead(response.status, headers);
+                const { Readable } = await import("stream");
+                if (response.body instanceof Readable) {
+                    response.body.pipe(res);
+                }
+                else {
+                    const body = await response.arrayBuffer();
+                    res.end(Buffer.from(body));
+                }
+            });
+            server.listen(port, () => {
+                const protocol = "\x1b[1;34mhttp\x1b[0m";
+                const message = `\x1b[1m NodeJS TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+                GlobalConfig.serverInfo = server;
+                if (typeof callback == "function") {
+                    callback(message);
+                }
+                else {
+                    GlobalConfig.debugging.success(message);
+                }
+                return server;
+            });
+        })
+            .catch((r) => {
+            throw Error(r.message);
+        });
+    }
+    return {
+        listen,
+    };
+}

package/cjs/MiddlewareConfigure.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriMiddleware = void 0;
+const common_1 = require("./common");
+const config_1 = require("./config/config");
+const url_1 = require("./utils/url");
+class TriMiddleware {
+    children = new Map();
+    middlewares = new Set();
+    isOptional = false;
+    pathname;
+    constructor(pathname = "/") {
+        this.pathname = pathname;
+        if (config_1.GlobalConfig.allowDuplicateMw) {
+            this.middlewares = [];
+        }
+        else {
+            this.middlewares = new Set();
+        }
+    }
+}
+exports.TriMiddleware = TriMiddleware;
+class MiddlewareConfigure extends common_1.CommonHandler {
+    triMiddlewares = new TriMiddleware();
+    basePath;
+    constructor(basePath = "/") {
+        super();
+        this.basePath = basePath;
+    }
+    addMiddleware(pathname, middlewares) {
+        const parts = (0, url_1.sanitizePathSplit)(this.basePath, pathname);
+        let node = this.triMiddlewares;
+        for (const part of parts) {
+            if (part.startsWith("*")) {
+                if (!node.children.has("*")) {
+                    node.children.set("*", new TriMiddleware());
+                }
+                node = node.children.get("*");
+            }
+            else if (part.startsWith(":")) {
+                const isOptional = part?.endsWith("?");
+                if (isOptional) {
+                    node.isOptional = isOptional;
+                    continue;
+                }
+                if (!node.children.has(":")) {
+                    node.children.set(":", new TriMiddleware());
+                }
+                node = node.children.get(":");
+            }
+            else {
+                if (!node.children.has(part)) {
+                    node.children.set(part, new TriMiddleware());
+                }
+                node = node.children.get(part);
+            }
+        }
+        if (config_1.GlobalConfig.allowDuplicateMw) {
+            node.middlewares.push(...middlewares);
+        }
+        else {
+            for (const middleware of middlewares) {
+                node.middlewares.add(middleware);
+            }
+        }
+    }
+}
+exports.default = MiddlewareConfigure;

package/cjs/adapter.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.denoAdapter = denoAdapter;
+exports.bunAdapter = bunAdapter;
+exports.nodeAdapter = nodeAdapter;
+const config_1 = require("./config/config");
+function denoAdapter(TezX) {
+    function listen(port, callback) {
+        const isDeno = typeof Deno !== "undefined";
+        try {
+            async function handleRequest(req, connInfo) {
+                let remoteAddr = connInfo.remoteAddr;
+                let localAddr = { ...server.addr };
+                let address = {
+                    remoteAddr: {
+                        port: remoteAddr?.port,
+                        address: remoteAddr?.hostname,
+                        transport: remoteAddr?.transport,
+                        family: remoteAddr?.family,
+                    },
+                    localAddr: {
+                        port: localAddr?.port,
+                        address: localAddr?.hostname,
+                        transport: localAddr?.transport,
+                        family: localAddr?.family,
+                    },
+                };
+                const response = await TezX.serve(req, address);
+                if (response instanceof Response) {
+                    return response;
+                }
+                else {
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText || "",
+                        headers: new Headers(response.headers),
+                    });
+                }
+            }
+            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            config_1.GlobalConfig.serverInfo = server;
+            if (!server) {
+                throw new Error("Deno is not find");
+            }
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m🚀 Deno TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback === "function") {
+                callback(message);
+            }
+            else {
+                config_1.GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+function bunAdapter(TezX) {
+    function listen(port, callback) {
+        const serve = typeof Bun !== "undefined" ? Bun.serve : null;
+        try {
+            if (!serve) {
+                throw new Error("Bun is not find");
+            }
+            const server = serve({
+                port: port,
+                async fetch(req) {
+                    const response = await TezX.serve(req, {
+                        remoteAddr: server.requestIP(req),
+                        localAddr: server.address,
+                    });
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                    else {
+                        return new Response(response.body, {
+                            status: response.status,
+                            statusText: response.statusText || "",
+                            headers: new Headers(response.headers),
+                        });
+                    }
+                },
+            });
+            config_1.GlobalConfig.serverInfo = server;
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m Bun TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback == "function") {
+                callback(message);
+            }
+            else {
+                config_1.GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+function nodeAdapter(TezX) {
+    function listen(port, callback) {
+        Promise.resolve().then(() => require("http")).then((r) => {
+            let server = r.createServer(async (req, res) => {
+                let address = {};
+                if (req.socket) {
+                    address = {
+                        remoteAddr: {
+                            family: req.socket.remoteFamily,
+                            address: req.socket.remoteAddress,
+                            port: req.socket.remotePort,
+                        },
+                        localAddr: {
+                            address: req.socket.localAddress,
+                            port: req.socket.localPort,
+                            family: req.socket.localFamily,
+                        },
+                    };
+                }
+                const response = await TezX.serve(req, address);
+                const statusText = response?.statusText;
+                if (!(response instanceof Response)) {
+                    throw new Error("Invalid response from TezX.serve");
+                }
+                const headers = Object.fromEntries(await response.headers.entries());
+                if (statusText) {
+                    res.statusMessage = statusText;
+                }
+                res.writeHead(response.status, headers);
+                const { Readable } = await Promise.resolve().then(() => require("stream"));
+                if (response.body instanceof Readable) {
+                    response.body.pipe(res);
+                }
+                else {
+                    const body = await response.arrayBuffer();
+                    res.end(Buffer.from(body));
+                }
+            });
+            server.listen(port, () => {
+                const protocol = "\x1b[1;34mhttp\x1b[0m";
+                const message = `\x1b[1m NodeJS TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+                config_1.GlobalConfig.serverInfo = server;
+                if (typeof callback == "function") {
+                    callback(message);
+                }
+                else {
+                    config_1.GlobalConfig.debugging.success(message);
+                }
+                return server;
+            });
+        })
+            .catch((r) => {
+            throw Error(r.message);
+        });
+    }
+    return {
+        listen,
+    };
+}

package/cjs/common.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHandler = void 0;
+const config_1 = require("./config/config");
+class CommonHandler {
+    notFound(callback) {
+        config_1.GlobalConfig.notFound = callback;
+        return this;
+    }
+    onError(callback) {
+        config_1.GlobalConfig.onError = callback;
+        return this;
+    }
+}
+exports.CommonHandler = CommonHandler;

package/cjs/config/config.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalConfig = void 0;
+const debugging_1 = require("../utils/debugging");
+let GlobalConfig = class {
+    static notFound = (ctx) => {
+        const { method, urlRef: { pathname }, } = ctx.req;
+        return ctx.text(`${method}: '${pathname}' could not find\n`, 404);
+    };
+    static onError = (err, ctx) => {
+        return ctx.text(err, 500);
+    };
+    static allowDuplicateMw = false;
+    static overwriteMethod = true;
+    static debugMode = false;
+    static serverInfo;
+    static get debugging() {
+        return this.debugMode
+            ? {
+                info: (msg, ...args) => (0, debugging_1.loggerOutput)("info", msg, ...args),
+                warn: (msg, ...args) => (0, debugging_1.loggerOutput)("warn", msg, ...args),
+                error: (msg, ...args) => (0, debugging_1.loggerOutput)("error", msg, ...args),
+                debug: (msg, ...args) => (0, debugging_1.loggerOutput)("debug", msg, ...args),
+                success: (msg, ...args) => (0, debugging_1.loggerOutput)("success", msg, ...args),
+            }
+            : {
+                info: (msg, ...args) => { },
+                warn: (msg, ...args) => { },
+                error: (msg, ...args) => { },
+                debug: (msg, ...args) => { },
+                success: (msg, ...args) => { },
+            };
+    }
+};
+exports.GlobalConfig = GlobalConfig;