tezx 1.0.13 → 1.0.15

package/dist/context.d.ts

@@ -1,195 +0,0 @@
-import { HeadersParser } from "./header";
-import { ConnAddress, HTTPMethod, Request } from "./request";
-import { State } from "./utils/state";
-export interface CookieOptions {
-    expires?: Date;
-    path?: string;
-    maxAge?: number;
-    domain?: string;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: "Strict" | "Lax" | "None";
-}
-export declare const httpStatusMap: Record<number, string>;
-export type ResponseHeaders = Record<string, string>;
-export declare class Context<T extends Record<string, any> = {}> {
-    #private;
-    [key: string]: any;
-    /**
-     * Environment variables and configuration
-     * @type {object}
-     */
-    env: Record<string, any> & T;
-    /**
-     * Parser for handling and manipulating HTTP headers
-     * @type {HeadersParser}
-     */
-    headers: HeadersParser;
-    /**
-     * Parser for handling and manipulating HTTP response(Read Only)
-     * @type {Response}
-     */
-    readonly res: Response | undefined;
-    /**
-     * Request path without query parameters
-     * @type {string}
-     */
-    readonly pathname: string;
-    /**
-     * Full request URL including protocol and query string
-     * @type {string}
-     */
-    readonly url: string;
-    /**
-     * HTTP request method (GET, POST, PUT, DELETE, etc.)
-     * @type {HTTPMethod}
-     */
-    readonly method: HTTPMethod;
-    /**
-     * Public state container for application data
-     * state storage for middleware and plugins
-     * @type {State}
-     */
-    state: State;
-    constructor(req: any, connInfo: ConnAddress);
-    /**
-     * Cookie handling utility with get/set/delete operations
-     * @returns {{
-     *  get: (name: string) => string | undefined,
-     *  all: () => Record<string, string>,
-     *  delete: (name: string, options?: CookieOptions) => void,
-     *  set: (name: string, value: string, options?: CookieOptions) => void
-     * }} Cookie handling interface
-     */
-    /**
-     * Sets a header value.
-     * @param key - Header name.
-     * @param value - Header value(s).
-     */
-    header(key: string, value: string | string[]): this;
-    get cookies(): {
-        /**
-         * Get a specific cookie by name.
-         * @param {string} cookie - The name of the cookie to retrieve.
-         * @returns {string | undefined} - The cookie value or undefined if not found.
-         */
-        get: (cookie: string) => string;
-        /**
-         * Get all cookies as an object.
-         * @returns {Record<string, string>} - An object containing all cookies.
-         */
-        all: () => Record<string, string>;
-        /**
-         * Delete a cookie by setting its expiration to the past.
-         * @param {string} name - The name of the cookie to delete.
-         * @param {CookieOptions} [options] - Additional cookie options.
-         */
-        delete: (name: string, options?: CookieOptions) => void;
-        /**
-         * Set a new cookie with the given name, value, and options.
-         * @param {string} name - The name of the cookie.
-         * @param {string} value - The value of the cookie.
-         * @param {CookieOptions} [options] - Additional options like expiration.
-         */
-        set: (name: string, value: string, options?: CookieOptions) => void;
-    };
-    /**
-     * Sends a JSON response.
-     * @param body - The response data.
-     * @param status - (Optional) HTTP status code (default: 200).
-     * @param headers - (Optional) Additional response headers.
-     * @returns Response object with JSON data.
-     */
-    json(body: any, status?: number, headers?: ResponseHeaders): Response;
-    json(body: any, headers?: ResponseHeaders): Response;
-    json(body: any, status?: number): Response;
-    /**
-     * Sends a response with any content type.
-     * Automatically determines content type if not provided.
-     * @param body - The response body.
-     * @param status - (Optional) HTTP status code.
-     * @param headers - (Optional) Additional response headers.
-     * @returns Response object.
-     */
-    send(body: any, status?: number, headers?: ResponseHeaders): any;
-    send(body: any, headers?: ResponseHeaders): any;
-    send(body: any, status?: number): any;
-    /**
-     * Sends an HTML response.
-     * @param data - The HTML content as a string.
-     * @param status - (Optional) HTTP status code (default: 200).
-     * @param headers - (Optional) Additional response headers.
-     * @returns Response object with HTML data.
-     */
-    html(data: string, status?: number, headers?: ResponseHeaders): any;
-    html(data: string, headers?: ResponseHeaders): any;
-    html(data: string, status?: number): any;
-    /**
-     * Sends a plain text response.
-     * @param data - The text content.
-     * @param status - (Optional) HTTP status code (default: 200).
-     * @param headers - (Optional) Additional response headers.
-     * @returns Response object with plain text data.
-     */
-    text(data: string, status?: number, headers?: ResponseHeaders): any;
-    text(data: string, headers?: ResponseHeaders): any;
-    text(data: string, status?: number): any;
-    /**
-     * Sends an XML response.
-     * @param data - The XML content.
-     * @param status - (Optional) HTTP status code (default: 200).
-     * @param headers - (Optional) Additional response headers.
-     * @returns Response object with XML data.
-     */
-    xml(data: string, status?: number, headers?: ResponseHeaders): any;
-    xml(data: string, headers?: ResponseHeaders): any;
-    xml(data: string, status?: number): any;
-    /**
-     * HTTP status code..
-     * @param status - number.
-     * @returns Response object with context all method.
-     */
-    status: (status: number) => this;
-    set setStatus(status: number);
-    get getStatus(): number;
-    /**
-     * Redirects to a given URL.
-     * @param url - The target URL.
-     * @param status - (Optional) HTTP status code (default: 302).
-     * @returns Response object with redirect.
-     */
-    redirect(url: string, status?: number): Response;
-    /**
-     * Handles file downloads.
-     * @param filePath - The path to the file.
-     * @param fileName - The name of the downloaded file.
-     * @returns Response object for file download.
-     */
-    download(filePath: string, fileName: string): Promise<Response>;
-    /**
-     * Serves a file to the client.
-     * @param filePath - Absolute or relative path to the file.
-     * @param fileName - (Optional) The name of the send file.
-     * @param headers - (Optional) Additional headers.
-     * @returns Response object with the file stream.
-     */
-    sendFile(filePath: string, fileName?: string, headers?: ResponseHeaders): Promise<Response>;
-    sendFile(filePath: string, headers?: ResponseHeaders): Promise<Response>;
-    sendFile(filePath: string, fileName?: string): Promise<Response>;
-    /**
-     * Getter that creates a standardized Request object from internal state
-     * @returns {Request} - Normalized request object combining:
-     * - Raw platform-specific request
-     * - Parsed headers
-     * - Route parameters
-     *
-     * @example
-     * // Get standardized request
-     * const request = ctx.req;
-     * // Access route params
-     * const id = request.params.get('id');
-     */
-    get req(): Request;
-    protected set params(params: Record<string, any>);
-    protected get params(): Record<string, any>;
-}

package/dist/context.js

@@ -1,424 +0,0 @@
-import { EnvironmentDetector } from "./environment";
-import { HeadersParser } from "./header";
-import { Request } from "./request";
-import { State } from "./utils/state";
-import { defaultMimeType, mimeTypes } from "./utils/staticFile";
-export const httpStatusMap = {
-    100: "Continue",
-    101: "Switching Protocols",
-    102: "Processing",
-    103: "Early Hints",
-    200: "OK",
-    201: "Created",
-    202: "Accepted",
-    203: "Non-Authoritative Information",
-    204: "No Content",
-    205: "Reset Content",
-    206: "Partial Content",
-    207: "Multi-Status",
-    208: "Already Reported",
-    226: "IM Used",
-    300: "Multiple Choices",
-    301: "Moved Permanently",
-    302: "Found",
-    303: "See Other",
-    304: "Not Modified",
-    305: "Use Proxy",
-    306: "Switch Proxy",
-    307: "Temporary Redirect",
-    308: "Permanent Redirect",
-    400: "Bad Request",
-    401: "Unauthorized",
-    402: "Payment Required",
-    403: "Forbidden",
-    404: "Not Found",
-    405: "Method Not Allowed",
-    406: "Not Acceptable",
-    407: "Proxy Authentication Required",
-    408: "Request Timeout",
-    409: "Conflict",
-    410: "Gone",
-    411: "Length Required",
-    412: "Precondition Failed",
-    413: "Payload Too Large",
-    414: "URI Too Long",
-    415: "Unsupported Media Type",
-    416: "Range Not Satisfiable",
-    417: "Expectation Failed",
-    418: "I'm a Teapot",
-    421: "Misdirected Request",
-    422: "Unprocessable Entity",
-    423: "Locked",
-    424: "Failed Dependency",
-    425: "Too Early",
-    426: "Upgrade Required",
-    428: "Precondition Required",
-    429: "Too Many Requests",
-    431: "Request Header Fields Too Large",
-    451: "Unavailable For Legal Reasons",
-    500: "Internal Server Error",
-    501: "Not Implemented",
-    502: "Bad Gateway",
-    503: "Service Unavailable",
-    504: "Gateway Timeout",
-    505: "HTTP Version Not Supported",
-    506: "Variant Also Negotiates",
-    507: "Insufficient Storage",
-    508: "Loop Detected",
-    510: "Not Extended",
-    511: "Network Authentication Required",
-};
-export class Context {
-    #rawRequest;
-    env = {};
-    headers = new HeadersParser();
-    res;
-    pathname;
-    url;
-    method;
-    #status = 200;
-    state = new State();
-    #params = {};
-    #localAddress = {};
-    #remoteAddress = {};
-    constructor(req, connInfo) {
-        this.#rawRequest = req;
-        this.#remoteAddress = connInfo.remoteAddr;
-        this.#localAddress = connInfo.localAddr;
-        this.method = req?.method?.toUpperCase();
-        this.pathname = this.req.urlRef.pathname;
-        this.url = this.req.url;
-    }
-    header(key, value) {
-        this.headers.set(key, value);
-        return this;
-    }
-    get cookies() {
-        const c = this.headers.getAll("cookie");
-        let cookies = {};
-        if (Array.isArray(c) && c.length != 0) {
-            const cookieHeader = c.join("; ").split(";");
-            for (const pair of cookieHeader) {
-                const [key, value] = pair?.trim()?.split("=");
-                cookies[key] = decodeURIComponent(value);
-            }
-        }
-        else if (typeof c == "string") {
-            const cookieHeader = c.split(";");
-            for (const pair of cookieHeader) {
-                const [key, value] = pair?.trim()?.split("=");
-                cookies[key] = decodeURIComponent(value);
-            }
-        }
-        return {
-            get: (cookie) => {
-                return cookies?.[cookie];
-            },
-            all: () => {
-                return cookies;
-            },
-            delete: (name, options) => {
-                const value = "";
-                const cookieOptions = {
-                    ...options,
-                    expires: new Date(0),
-                };
-                const cookieHeader = `${name}=${value};${serializeOptions(cookieOptions)}`;
-                this.headers.set("Set-Cookie", cookieHeader);
-            },
-            set: (name, value, options) => {
-                const cookieHeader = `${name}=${value};${serializeOptions(options || {})}`;
-                this.headers.set("Set-Cookie", cookieHeader);
-            },
-        };
-    }
-    json(body, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "application/json; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(JSON.stringify(body), {
-            status: status,
-            headers: headers,
-        });
-    }
-    send(body, ...args) {
-        let status = this.#status;
-        let headers = {};
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = args[1];
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = args[0];
-        }
-        if (!headers["Content-Type"]) {
-            if (typeof body === "string") {
-                headers["Content-Type"] = "text/plain;";
-            }
-            else if (typeof body === "object" && body !== null) {
-                headers["Content-Type"] = "application/json;";
-                body = JSON.stringify(body);
-            }
-            else {
-                headers["Content-Type"] = "application/octet-stream";
-            }
-        }
-        return this.#handleResponse(body, {
-            status: status,
-            headers,
-        });
-    }
-    html(data, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "text/html; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
-    }
-    text(data, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "text/plain; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
-    }
-    xml(data, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "application/xml; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
-    }
-    status = (status) => {
-        this.#status = status;
-        return this;
-    };
-    set setStatus(status) {
-        this.#status = status;
-    }
-    get getStatus() {
-        return this.#status;
-    }
-    redirect(url, status = 302) {
-        return new Response(null, {
-            status: status,
-            headers: { Location: url },
-        });
-    }
-    async download(filePath, fileName) {
-        try {
-            let fileExists = false;
-            const runtime = EnvironmentDetector.getEnvironment;
-            if (runtime === "node") {
-                const { existsSync } = await import("fs");
-                fileExists = existsSync(filePath);
-            }
-            else if (runtime === "bun") {
-                fileExists = Bun.file(filePath).exists();
-            }
-            else if (runtime === "deno") {
-                try {
-                    await Deno.stat(filePath);
-                    fileExists = true;
-                }
-                catch {
-                    fileExists = false;
-                }
-            }
-            if (!fileExists) {
-                throw Error("File not found");
-            }
-            let fileBuffer;
-            if (runtime === "node") {
-                const { readFileSync } = await import("fs");
-                fileBuffer = await readFileSync(filePath);
-            }
-            else if (runtime === "bun") {
-                fileBuffer = await Bun.file(filePath)
-                    .arrayBuffer()
-                    .then((buf) => new Uint8Array(buf));
-            }
-            else if (runtime === "deno") {
-                fileBuffer = await Deno.readFile(filePath);
-            }
-            return this.#handleResponse(fileBuffer, {
-                status: 200,
-                headers: {
-                    "Content-Disposition": `attachment; filename="${fileName}"`,
-                    "Content-Type": "application/octet-stream",
-                    "Content-Length": fileBuffer.byteLength.toString(),
-                },
-            });
-        }
-        catch (error) {
-            throw Error("Internal Server Error" + error?.message);
-        }
-    }
-    async sendFile(filePath, ...args) {
-        try {
-            const runtime = EnvironmentDetector.getEnvironment;
-            const resolvedPath = filePath;
-            let fileExists = false;
-            if (runtime === "node") {
-                const { existsSync } = await import("fs");
-                fileExists = existsSync(resolvedPath);
-            }
-            else if (runtime === "bun") {
-                fileExists = Bun.file(resolvedPath).exists();
-            }
-            else if (runtime === "deno") {
-                try {
-                    await Deno.stat(resolvedPath);
-                    fileExists = true;
-                }
-                catch {
-                    fileExists = false;
-                }
-            }
-            if (!fileExists) {
-                throw Error("File not found");
-            }
-            let fileSize = 0;
-            if (runtime === "node") {
-                const { statSync } = await import("fs");
-                fileSize = statSync(resolvedPath).size;
-            }
-            else if (runtime === "bun") {
-                fileSize = (await Bun.file(resolvedPath).arrayBuffer()).byteLength;
-            }
-            else if (runtime === "deno") {
-                const fileInfo = await Deno.stat(resolvedPath);
-                fileSize = fileInfo.size;
-            }
-            const ext = filePath.split(".").pop()?.toLowerCase() || "";
-            const mimeType = mimeTypes[ext] || defaultMimeType;
-            let fileStream;
-            if (runtime === "node") {
-                const { createReadStream } = await import("fs");
-                fileStream = createReadStream(resolvedPath);
-            }
-            else if (runtime === "bun") {
-                fileStream = Bun.file(resolvedPath).stream();
-            }
-            else if (runtime === "deno") {
-                const file = await Deno.open(resolvedPath, { read: true });
-                fileStream = file.readable;
-            }
-            let headers = {
-                "Content-Type": mimeType,
-                "Content-Length": fileSize.toString(),
-            };
-            let fileName = "";
-            if (typeof args[0] === "string") {
-                fileName = args[0];
-                if (typeof args[1] === "object") {
-                    headers = { ...headers, ...args[1] };
-                }
-            }
-            else if (typeof args[0] === "object") {
-                headers = { ...headers, ...args[0] };
-            }
-            if (fileName) {
-                headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
-            }
-            return this.#handleResponse(fileStream, {
-                status: 200,
-                headers,
-            });
-        }
-        catch (error) {
-            throw Error("Internal Server Error" + error?.message);
-        }
-    }
-    #handleResponse(body, { headers, status }) {
-        let response = new Response(body, {
-            status: status,
-            headers,
-        });
-        let clone = response.clone();
-        this.res = response;
-        return clone;
-    }
-    get req() {
-        return new Request(this.#rawRequest, this.params, this.#remoteAddress);
-    }
-    set params(params) {
-        this.#params = params;
-    }
-    get params() {
-        return this.#params;
-    }
-}
-function serializeOptions(options) {
-    const parts = [];
-    if (options.maxAge) {
-        parts.push(`Max-Age=${options.maxAge}`);
-    }
-    if (options.expires) {
-        parts.push(`Expires=${options.expires.toUTCString()}`);
-    }
-    if (options.path) {
-        parts.push(`Path=${options.path}`);
-    }
-    if (options.domain) {
-        parts.push(`Domain=${options.domain}`);
-    }
-    if (options.secure) {
-        parts.push(`Secure`);
-    }
-    if (options.httpOnly) {
-        parts.push(`HttpOnly`);
-    }
-    if (options.sameSite) {
-        parts.push(`SameSite=${options.sameSite}`);
-    }
-    return parts.join("; ");
-}

package/dist/environment.d.ts

@@ -1,6 +0,0 @@
-import { HeadersParser } from "./header";
-export declare class EnvironmentDetector {
-    static get getEnvironment(): "node" | "bun" | "deno" | "unknown";
-    static detectProtocol(req: any): "unknown" | "http" | "https";
-    static getHost(headers: HeadersParser): string;
-}

package/dist/environment.js

@@ -1,30 +0,0 @@
-export class EnvironmentDetector {
-    static get getEnvironment() {
-        if (typeof Bun !== "undefined")
-            return "bun";
-        if (typeof Deno !== "undefined")
-            return "deno";
-        if (typeof process !== "undefined" && process.versions?.node)
-            return "node";
-        return "unknown";
-    }
-    static detectProtocol(req) {
-        try {
-            if (this.getEnvironment === "node") {
-                return req?.socket?.encrypted ? "https" : "http";
-            }
-            return "unknown";
-        }
-        catch (error) {
-            throw new Error("Failed to detect protocol.");
-        }
-    }
-    static getHost(headers) {
-        try {
-            return headers?.get("host") || "unknown";
-        }
-        catch (error) {
-            throw new Error("Failed to get host.");
-        }
-    }
-}