tezx 1.0.50 → 1.0.52

package/adapter/bun.d.ts

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

package/adapter/bun.js

@@ -0,0 +1,77 @@
+import { GlobalConfig } from "../core/config.js";
+import { Context } from "../core/context.js";
+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");
+            }
+            GlobalConfig.adapter = "bun";
+            const server = serve({
+                port: port,
+                async fetch(req) {
+                    let options = {
+                        connInfo: {
+                            remoteAddr: server.requestIP(req),
+                            localAddr: server.address,
+                        },
+                    };
+                    const response = await TezX.serve(req, options);
+                    if (typeof response?.websocket == "function" && response.ctx instanceof Context && response.ctx.wsProtocol) {
+                        let websocket = response?.websocket(response?.ctx);
+                        const upgradeSuccess = server.upgrade(req, {
+                            data: { ...websocket },
+                        });
+                        if (upgradeSuccess)
+                            return undefined;
+                    }
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                    return new Response(response.body ?? null, {
+                        status: response.status ?? 200,
+                        statusText: response.statusText || "",
+                        headers: new Headers(response.headers ?? {}),
+                    });
+                },
+                websocket: {
+                    open(ws) {
+                        return ws.data?.open?.(ws);
+                    },
+                    message(ws, msg) {
+                        return ws.data?.message?.(ws, msg);
+                    },
+                    close(ws, code, reason) {
+                        return ws.data?.close?.(ws, { code, reason });
+                    },
+                    ping(ws, data) {
+                        return ws.data?.ping?.(ws, data);
+                    },
+                    pong(ws, data) {
+                        return ws.data?.pong?.(ws, data);
+                    },
+                    drain(ws) {
+                        return ws.data?.drain?.(ws);
+                    },
+                }
+            });
+            GlobalConfig.server = 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,
+    };
+}

package/adapter/deno.d.ts

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

package/adapter/deno.js

@@ -0,0 +1,59 @@
+import { GlobalConfig } from "../core/config.js";
+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,
+                    },
+                };
+                let options = {
+                    connInfo: address,
+                };
+                const response = await TezX.serve(req, options);
+                if (response instanceof Response) {
+                    return response;
+                }
+                return new Response(response.body ?? null, {
+                    status: response.status ?? 200,
+                    statusText: response.statusText || "",
+                    headers: new Headers(response.headers ?? {}),
+                });
+            }
+            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            if (!server) {
+                throw new Error("Deno is not find");
+            }
+            GlobalConfig.adapter = "deno";
+            GlobalConfig.server = server;
+            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,
+    };
+}

package/adapter/index.d.ts

@@ -1,11 +1,4 @@
-import { TezX } from "../core/server.js";
 export type AdapterType = "bun" | "deno" | "node";
-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;
-};
+export * from "./bun.js";
+export * from "./deno.js";
+export * from "./node.js";

package/adapter/index.js

@@ -1,177 +1,3 @@
-import { GlobalConfig } from "../core/config.js";
-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,
-                    },
-                };
-                let options = {
-                    connInfo: address,
-                };
-                const response = await TezX.serve(req, options);
-                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;
-            if (!server) {
-                throw new Error("Deno is not find");
-            }
-            GlobalConfig.adapter = "deno";
-            GlobalConfig.server = server;
-            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");
-            }
-            GlobalConfig.adapter = "bun";
-            const server = serve({
-                port: port,
-                async fetch(req) {
-                    let options = {
-                        connInfo: {
-                            remoteAddr: server.requestIP(req),
-                            localAddr: server.address,
-                        },
-                    };
-                    const response = await TezX.serve(req, options);
-                    if (response instanceof Response) {
-                        return response;
-                    }
-                    else {
-                        return new Response(response.body, {
-                            status: response.status,
-                            statusText: response.statusText || "",
-                            headers: new Headers(response.headers),
-                        });
-                    }
-                },
-            });
-            GlobalConfig.server = 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) => {
-            GlobalConfig.adapter = "node";
-            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,
-                        },
-                    };
-                }
-                let options = {
-                    connInfo: address,
-                };
-                const response = await TezX.serve(req, options);
-                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();
-                    if (body.byteLength > 0) {
-                        return res.end(Buffer.from(body));
-                    }
-                    res.end();
-                }
-            });
-            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.server = server;
-                if (typeof callback == "function") {
-                    callback(message);
-                }
-                else {
-                    GlobalConfig.debugging.success(message);
-                }
-                return server;
-            });
-        })
-            .catch((r) => {
-            throw Error(r.message);
-        });
-    }
-    return {
-        listen,
-    };
-}
+export * from "./bun.js";
+export * from "./deno.js";
+export * from "./node.js";

package/adapter/node.d.ts

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

package/adapter/node.js

@@ -0,0 +1,75 @@
+import { GlobalConfig } from "../core/config.js";
+import { Context } from "../core/context.js";
+export function nodeAdapter(TezX) {
+    function listen(port, callback) {
+        import("http")
+            .then((r) => {
+            GlobalConfig.adapter = "node";
+            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,
+                        },
+                    };
+                }
+                let options = {
+                    connInfo: address,
+                };
+                const response = await TezX.serve(req, options);
+                if (typeof response?.websocket == "function" && response.ctx instanceof Context && response.ctx.wsProtocol) {
+                    let ctx = response.ctx;
+                    response.websocket(ctx, server);
+                    res.end();
+                    return;
+                }
+                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();
+                    if (body.byteLength > 0) {
+                        return res.end(Buffer.from(body));
+                    }
+                    res.end();
+                }
+            });
+            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.server = server;
+                if (typeof callback == "function") {
+                    callback(message);
+                }
+                else {
+                    GlobalConfig.debugging.success(message);
+                }
+                return server;
+            });
+        })
+            .catch((r) => {
+            throw Error(r.message);
+        });
+    }
+    return {
+        listen,
+    };
+}

package/cjs/adapter/bun.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bunAdapter = bunAdapter;
+const config_js_1 = require("../core/config.js");
+const context_js_1 = require("../core/context.js");
+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");
+            }
+            config_js_1.GlobalConfig.adapter = "bun";
+            const server = serve({
+                port: port,
+                async fetch(req) {
+                    let options = {
+                        connInfo: {
+                            remoteAddr: server.requestIP(req),
+                            localAddr: server.address,
+                        },
+                    };
+                    const response = await TezX.serve(req, options);
+                    if (typeof response?.websocket == "function" && response.ctx instanceof context_js_1.Context && response.ctx.wsProtocol) {
+                        let websocket = response?.websocket(response?.ctx);
+                        const upgradeSuccess = server.upgrade(req, {
+                            data: { ...websocket },
+                        });
+                        if (upgradeSuccess)
+                            return undefined;
+                    }
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                    return new Response(response.body ?? null, {
+                        status: response.status ?? 200,
+                        statusText: response.statusText || "",
+                        headers: new Headers(response.headers ?? {}),
+                    });
+                },
+                websocket: {
+                    open(ws) {
+                        return ws.data?.open?.(ws);
+                    },
+                    message(ws, msg) {
+                        return ws.data?.message?.(ws, msg);
+                    },
+                    close(ws, code, reason) {
+                        return ws.data?.close?.(ws, { code, reason });
+                    },
+                    ping(ws, data) {
+                        return ws.data?.ping?.(ws, data);
+                    },
+                    pong(ws, data) {
+                        return ws.data?.pong?.(ws, data);
+                    },
+                    drain(ws) {
+                        return ws.data?.drain?.(ws);
+                    },
+                }
+            });
+            config_js_1.GlobalConfig.server = 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_js_1.GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}

package/cjs/adapter/deno.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.denoAdapter = denoAdapter;
+const config_js_1 = require("../core/config.js");
+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,
+                    },
+                };
+                let options = {
+                    connInfo: address,
+                };
+                const response = await TezX.serve(req, options);
+                if (response instanceof Response) {
+                    return response;
+                }
+                return new Response(response.body ?? null, {
+                    status: response.status ?? 200,
+                    statusText: response.statusText || "",
+                    headers: new Headers(response.headers ?? {}),
+                });
+            }
+            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            if (!server) {
+                throw new Error("Deno is not find");
+            }
+            config_js_1.GlobalConfig.adapter = "deno";
+            config_js_1.GlobalConfig.server = server;
+            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_js_1.GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}