tezx 2.0.11 → 3.0.0

package/utils/state.js

@@ -1,30 +0,0 @@
-export class State {
-    state;
-    constructor() {
-        this.state = new Map();
-    }
-    set(key, value) {
-        this.state.set(key, value);
-    }
-    get(key) {
-        return this.state.get(key);
-    }
-    delete(key) {
-        return this.state.delete(key);
-    }
-    has(key) {
-        return this.state.has(key);
-    }
-    keys() {
-        return Array.from(this.state.keys());
-    }
-    values() {
-        return Array.from(this.state.values());
-    }
-    entries() {
-        return Array.from(this.state.entries());
-    }
-    clear() {
-        this.state.clear();
-    }
-}

package/utils/staticFile.d.ts

@@ -1,10 +0,0 @@
-import { Router } from "../core/router.js";
-import { StaticServeOption } from "../types/index.js";
-export declare const mimeTypes: {
-    [key: string]: string;
-};
-export declare const defaultMimeType = "application/octet-stream";
-export declare function getFiles(dir: string, basePath: string | undefined, ref: Router<any>, option: StaticServeOption): Promise<{
-    file: string;
-    path: string;
-}[]>;

package/utils/toWebRequest.js

@@ -1,32 +0,0 @@
-import { Readable } from "node:stream";
-export function toWebRequest(req, method = "GET") {
-    const headers = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-        if (Array.isArray(value)) {
-            headers[key] = value.join(", ");
-        }
-        else if (typeof value === "string") {
-            headers[key] = value;
-        }
-    }
-    const isEncrypted = (req.socket && req.socket.encrypted) || false;
-    const protocol = isEncrypted ? "https:" : "http:";
-    let host = "localhost";
-    const hostHeader = req.headers.host;
-    if (typeof hostHeader === "string") {
-        host = hostHeader;
-    }
-    const urlStr = req.url ?? "/";
-    const fullUrl = new URL(urlStr, `${protocol}//${host}`);
-    const hasBody = !["GET", "HEAD"].includes(method.toUpperCase());
-    const body = hasBody ? Readable.toWeb(req) : undefined;
-    const abortController = new AbortController();
-    req?.once("close", () => abortController.abort());
-    return new Request(fullUrl.href, {
-        method,
-        headers,
-        body,
-        signal: abortController.signal,
-        duplex: hasBody ? "half" : undefined,
-    });
-}

package/ws/deno.d.ts

@@ -1,6 +0,0 @@
-import { Context } from "../index.js";
-import { WebSocketEvent, WebSocketOptions } from "./index.js";
-export declare class DenoTransport {
-    upgrade(ctx: Context, event: WebSocketEvent, options: WebSocketOptions): Promise<Response>;
-    private setupHandlers;
-}

package/ws/deno.js

@@ -1,16 +0,0 @@
-export class DenoTransport {
-    async upgrade(ctx, event, options) {
-        const { socket, response } = Deno.upgradeWebSocket(ctx.req.rawRequest, {
-            protocol: options.protocol,
-            idleTimeout: options.idleTimeout,
-        });
-        this.setupHandlers(socket, ctx, event);
-        return response;
-    }
-    setupHandlers(ws, ctx, event) {
-        ws.onopen = () => event.open?.(ws, ctx);
-        ws.onmessage = (e) => event.message?.(ws, e.data);
-        ws.onclose = (e) => event.close?.(ws, { code: e.code, reason: e.reason });
-        ws.onerror = (err) => event.error?.(ws, err);
-    }
-}

package/ws/index.d.ts

@@ -1,180 +0,0 @@
-import { Context } from "../index.js";
-import { CallbackReturn, Middleware } from "../types/index.js";
-/**
- * Type definition for WebSocket event handlers.
- * @template T - The type of data expected by the handler
- * @param {WebSocket} ws - The WebSocket instance
- * @param {T} [data] - Optional data associated with the event
- * @returns {Promise<void> | void}
- */
-type WebSocketHandler<T = any> = (ws: WebSocket, data?: T) => Promise<void> | void;
-/**
- * Defines all supported WebSocket event handlers.
- */
-export type WebSocketEvent = {
-    /**
-     * Triggered when the WebSocket connection is successfully opened.(make sure it support in node)
-     */
-    open?: WebSocketHandler;
-    /**
-     * Triggered when a message is received from the client.
-     * Supports `string`, `Buffer`, or `ArrayBuffer` payloads.
-     */
-    message?: WebSocketHandler<string | Buffer | ArrayBuffer>;
-    /**
-     * Triggered when the WebSocket connection is closed.
-     * Provides the close code and reason.
-     */
-    close?: WebSocketHandler<{
-        code: number;
-        reason: string;
-    }>;
-    /**
-     * Triggered when an error occurs during the WebSocket lifecycle.
-     * Not supported in Bun.
-     */
-    error?: WebSocketHandler<Error | any>;
-    /**
-     * Triggered when the socket drain event occurs.
-     * Not supported in Deno and Node.
-     */
-    drain?: WebSocketHandler;
-    /**
-     * Triggered when a ping frame is received from the client.
-     * Not supported in Deno.
-     */
-    ping?: WebSocketHandler<Buffer>;
-    /**
-     * Triggered when a pong frame is received from the client.
-     * Not supported in Deno.
-     */
-    pong?: WebSocketHandler<Buffer>;
-};
-/**
- * Callback function that returns WebSocket event handlers based on context.
- * @param {Context} ctx - The request context
- * @returns {WebSocketEvent} - Object containing WebSocket event handlers
- */
-export type WebSocketCallback = (ctx: Context) => WebSocketEvent;
-/**
- * Options for Zlib compression and decompression (Node.js only).
- */
-interface ZlibOptions {
-    /**
-     * The flush flag used by default.
-     * @default constants.Z_NO_FLUSH
-     */
-    flush?: number;
-    /**
-     * The flush flag used when calling the end() method.
-     * @default constants.Z_FINISH
-     */
-    finishFlush?: number;
-    /**
-     * The chunk size to use during compression.
-     * @default 16 * 1024 (16384 bytes)
-     */
-    chunkSize?: number;
-    /**
-     * The base two logarithm of the window size (range: 8–15).
-     */
-    windowBits?: number;
-    /**
-     * Compression level (range: 0–9).
-     * 0 = no compression, 9 = max compression.
-     */
-    level?: number;
-    /**
-     * Specifies how much memory should be allocated for internal compression state (1–9).
-     * Only used during compression.
-     */
-    memLevel?: number;
-    /**
-     * Compression strategy to use (e.g., Z_DEFAULT_STRATEGY).
-     * Only applies during compression.
-     */
-    strategy?: number;
-    /**
-     * A dictionary to use during compression/decompression.
-     * Useful for specific protocols.
-     */
-    dictionary?: NodeJS.ArrayBufferView | ArrayBuffer;
-    /**
-     * If true, returns an object with `buffer` and `engine`.
-     */
-    info?: boolean;
-}
-interface ZlibInflateOptions extends ZlibOptions {
-    /**
-     * Limit the output buffer size when using convenience methods like `deflateSync`.
-     * @default buffer.kMaxLength
-     */
-    maxOutputLength?: number;
-}
-/**
- * Options for enabling and configuring permessage-deflate compression in WebSocket.
- * Applicable only in Node.js environments.
- */
-interface PerMessageDeflateOptions {
-    /**
-     * When true, disables context takeover on the server side.
-     * This can help reduce memory usage at the cost of compression efficiency.
-     */
-    serverNoContextTakeover?: boolean;
-    /**
-     * When true, disables context takeover on the client side.
-     */
-    clientNoContextTakeover?: boolean;
-    /**
-     * Specifies the server's maximum window bits (compression history buffer size).
-     */
-    serverMaxWindowBits?: number;
-    /**
-     * Specifies the client's maximum window bits.
-     */
-    clientMaxWindowBits?: number;
-    /**
-     * Options passed directly to zlib for the deflate (compression) stream.
-     */
-    zlibDeflateOptions?: ZlibOptions;
-    /**
-     * Options passed to zlib for the inflate (decompression) stream.
-     */
-    zlibInflateOptions?: ZlibInflateOptions;
-    /**
-     * Only compress messages bigger than this threshold (in bytes).
-     */
-    threshold?: number;
-    /**
-     * Limits how many concurrent zlib operations can be running.
-     * Useful for limiting CPU/memory usage under heavy load.
-     */
-    concurrencyLimit?: number;
-}
-/**
- * Dynamic options for configuring WebSocket behavior across different runtimes.
- */
-export type WebSocketOptions = {
-    /**
-     * Called when an error occurs during the upgrade process.
-     */
-    onUpgradeError?: (err: Error, ctx: Context) => CallbackReturn;
-    /**
-     * Supported WebSocket subprotocols. (Deno only)
-     */
-    protocol?: string;
-    /**
-     * Time (in seconds) after which the WebSocket connection will be closed if idle. (Deno only)
-     */
-    idleTimeout?: number;
-    /**
-     * Enables per-message deflate compression. Can be a boolean or a detailed config. (Node.js only)
-     */
-    perMessageDeflate?: boolean | PerMessageDeflateOptions;
-    /**
-     * Maximum allowed message size in bytes. Default is 1MB if not provided. (Node.js only)
-     */
-    maxPayload?: number;
-};
-export declare function upgradeWebSocket(callback: WebSocketCallback, options?: WebSocketOptions): Middleware;
-export default upgradeWebSocket;

package/ws/index.js

@@ -1,50 +0,0 @@
-import { Environment } from "../core/environment.js";
-import { DenoTransport } from "./deno.js";
-import { NodeTransport } from "./node.js";
-export function upgradeWebSocket(callback, options = {}) {
-    const { onUpgradeError = (error, ctx) => {
-        ctx.setStatus = 401;
-        return ctx.text(error.message);
-    }, protocol, idleTimeout = 30000, perMessageDeflate, maxPayload = 1048576, } = options;
-    return async (ctx, next) => {
-        const upgrade = ctx.req.headers.get("upgrade")?.toLowerCase();
-        const connection = ctx.req.headers.get("connection")?.toLowerCase();
-        const key = ctx.req.headers.get("sec-websocket-key");
-        if (upgrade !== "websocket" || !connection?.includes("upgrade") || !key) {
-            if (next) {
-                ctx.body = { error: "401 Bad Request: Invalid WebSocket headers" };
-                return next();
-            }
-            ctx.setStatus = 401;
-            return onUpgradeError(new Error("401 Bad Request: Invalid WebSocket headers"), ctx);
-        }
-        ctx.wsProtocol = ctx.req.urlRef.protocol === "https:" ? "wss" : "ws";
-        try {
-            const env = Environment.getEnvironment;
-            if (!callback) {
-                throw new Error("WebSocket callback is missing. Please provide a valid callback function to handle the WebSocket events.");
-            }
-            let websocketCallback = callback(ctx);
-            switch (env) {
-                case "deno":
-                    return new DenoTransport().upgrade(ctx, websocketCallback, {
-                        idleTimeout,
-                        protocol,
-                    });
-                case "bun":
-                    return callback;
-                case "node":
-                    return new NodeTransport().upgrade(ctx, websocketCallback, {
-                        maxPayload,
-                        perMessageDeflate,
-                    });
-                default:
-                    throw new Error("Unsupported environment for WebSocket upgrade.");
-            }
-        }
-        catch (err) {
-            return onUpgradeError(new Error("WebSocket Upgrade Failed"), ctx);
-        }
-    };
-}
-export default upgradeWebSocket;

package/ws/node.d.ts

@@ -1,7 +0,0 @@
-import { Context } from "../index.js";
-import { WebSocketEvent, WebSocketOptions } from "./index.js";
-export declare class NodeTransport {
-    private wss?;
-    upgrade(ctx: Context, event: WebSocketEvent, options: WebSocketOptions): Promise<(ctx: Context, server: any) => void>;
-    private setupHandlers;
-}

package/ws/node.js

@@ -1,28 +0,0 @@
-export class NodeTransport {
-    wss;
-    async upgrade(ctx, event, options) {
-        let { WebSocketServer } = await import("ws");
-        return (ctx, server) => {
-            this.wss = new WebSocketServer({
-                noServer: true,
-                maxPayload: options.maxPayload ?? 1048576,
-                perMessageDeflate: options.perMessageDeflate ?? false,
-            });
-            server?.on("upgrade", (request, socket, head) => {
-                this.wss?.handleUpgrade(request, socket, head, (ws) => {
-                    this.wss?.emit("connection", ws, request);
-                    this.setupHandlers(ws, event, options);
-                });
-            });
-        };
-    }
-    setupHandlers(ws, event, options) {
-        event.open?.(ws);
-        ws.on("open", () => event.open?.(ws));
-        ws.on("message", (data) => event.message?.(ws, data));
-        ws.on("close", (code, reason) => event.close?.(ws, { code, reason }));
-        ws.on("error", (err) => event.error?.(ws, err));
-        ws.on("ping", (data) => event.ping?.(ws, data));
-        ws.on("pong", (data) => event.pong?.(ws, data));
-    }
-}