tezx 1.0.13 → 1.0.15

package/dist/cjs/context.js

@@ -1,428 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.httpStatusMap = void 0;
-const environment_1 = require("./environment");
-const header_1 = require("./header");
-const request_1 = require("./request");
-const state_1 = require("./utils/state");
-const staticFile_1 = require("./utils/staticFile");
-exports.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",
-};
-class Context {
-    #rawRequest;
-    env = {};
-    headers = new header_1.HeadersParser();
-    res;
-    pathname;
-    url;
-    method;
-    #status = 200;
-    state = new state_1.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 = environment_1.EnvironmentDetector.getEnvironment;
-            if (runtime === "node") {
-                const { existsSync } = await Promise.resolve().then(() => require("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 Promise.resolve().then(() => require("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 = environment_1.EnvironmentDetector.getEnvironment;
-            const resolvedPath = filePath;
-            let fileExists = false;
-            if (runtime === "node") {
-                const { existsSync } = await Promise.resolve().then(() => require("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 Promise.resolve().then(() => require("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 = staticFile_1.mimeTypes[ext] || staticFile_1.defaultMimeType;
-            let fileStream;
-            if (runtime === "node") {
-                const { createReadStream } = await Promise.resolve().then(() => require("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_1.Request(this.#rawRequest, this.params, this.#remoteAddress);
-    }
-    set params(params) {
-        this.#params = params;
-    }
-    get params() {
-        return this.#params;
-    }
-}
-exports.Context = Context;
-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/cjs/environment.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvironmentDetector = void 0;
-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.");
-        }
-    }
-}
-exports.EnvironmentDetector = EnvironmentDetector;

package/dist/cjs/header.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeadersParser = void 0;
-class HeadersParser {
-    headers = new Map();
-    constructor(init) {
-        if (init) {
-            this.add(init);
-        }
-    }
-    add(headers) {
-        if (Array.isArray(headers)) {
-            for (const [key, value] of headers) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof Headers !== "undefined" && headers instanceof Headers) {
-            for (const [key, value] of headers.entries()) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof headers === "object") {
-            for (const key in headers) {
-                if (Object.prototype.hasOwnProperty.call(headers, key)) {
-                    this.set(key, headers[key]);
-                }
-            }
-        }
-        return this;
-    }
-    set(key, value) {
-        this.headers.set(key.toLowerCase(), Array.isArray(value) ? value : [value]);
-        return this;
-    }
-    clear() {
-        this.headers.clear();
-        return this;
-    }
-    get(key) {
-        const values = this.headers.get(key.toLowerCase());
-        return values ? values[0] : undefined;
-    }
-    getAll(key) {
-        return this.headers.get(key.toLowerCase()) || [];
-    }
-    has(key) {
-        return this.headers.has(key.toLowerCase());
-    }
-    delete(key) {
-        return this.headers.delete(key.toLowerCase());
-    }
-    append(key, value) {
-        const lowerKey = key.toLowerCase();
-        if (this.headers.has(lowerKey)) {
-            this.headers.get(lowerKey).push(value);
-        }
-        else {
-            this.headers.set(lowerKey, [value]);
-        }
-        return this;
-    }
-    entries() {
-        return this.headers.entries();
-    }
-    keys() {
-        return this.headers.keys();
-    }
-    values() {
-        return this.headers.values();
-    }
-    forEach(callback) {
-        for (const [key, value] of this.headers) {
-            callback(value, key);
-        }
-    }
-    toObject() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = value.length > 1 ? value : value[0];
-        }
-        return obj;
-    }
-}
-exports.HeadersParser = HeadersParser;
-Object.defineProperty(HeadersParser, "name", { value: "Headers" });

package/dist/cjs/helper/common.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateID = generateID;
-function generateID() {
-    const timestamp = Date.now().toString(16);
-    const random = Math.floor(Math.random() * 0xffffffffffff)
-        .toString(16)
-        .padStart(12, "0");
-    const pid = (process.pid % 0x10000).toString(16).padStart(4, "0");
-    return `${timestamp}-${random}-${pid}`;
-}

package/dist/cjs/helper/env-parser.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEnv = loadEnv;
-const environment_1 = require("../environment");
-function parseEnvFile(filePath, result) {
-    try {
-        let fileExists = false;
-        let runtime = environment_1.EnvironmentDetector.getEnvironment;
-        if (runtime === "node" || runtime === "bun") {
-            const { existsSync } = require("fs");
-            fileExists = existsSync(filePath);
-        }
-        else if (runtime === "deno") {
-            try {
-                Deno.statSync(filePath);
-                fileExists = true;
-            }
-            catch {
-                fileExists = false;
-            }
-        }
-        if (!fileExists) {
-            return;
-        }
-        let fileContent = "";
-        if (runtime === "node" || runtime === "bun") {
-            const { readFileSync } = require("fs");
-            fileContent = readFileSync(filePath, "utf8");
-        }
-        else if (runtime === "deno") {
-            fileContent = new TextDecoder("utf-8").decode(Deno.readFileSync(filePath));
-        }
-        const lines = fileContent.split("\n");
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (!trimmedLine || trimmedLine.startsWith("#"))
-                continue;
-            const [key, value] = trimmedLine.split("=", 2).map((part) => part.trim());
-            if (key && value) {
-                const parsedValue = value
-                    .replace(/^"(.*)"$/, "$1")
-                    .replace(/^'(.*)'$/, "$1");
-                result[key] = parsedValue;
-                if (runtime === "node" || runtime === "bun") {
-                    process.env[key] = parsedValue;
-                }
-                else if (runtime === "deno") {
-                    Deno.env.set(key, parsedValue);
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(`[dotenv] Error parsing file: ${filePath}`, error);
-    }
-}
-function loadEnv(basePath = "./") {
-    const result = {};
-    const envFiles = [
-        ".env",
-        ".env.local",
-        `.env.${process?.env?.NODE_ENV || "development"}`,
-        `.env.${process?.env?.NODE_ENV || "development"}.local`,
-    ];
-    for (const envFile of envFiles) {
-        parseEnvFile(`${basePath}${envFile}`, result);
-    }
-    return result;
-}

package/dist/cjs/helper/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEnv = void 0;
-__exportStar(require("./common"), exports);
-var env_parser_1 = require("./env-parser");
-Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return env_parser_1.loadEnv; } });

package/dist/cjs/middleware/cors.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cors = cors;
-function cors(option = {}) {
-    const { methods, allowedHeaders, credentials, exposedHeaders, maxAge, origin, } = option;
-    return async (ctx, next) => {
-        const reqOrigin = ctx.req.headers.get("origin") || "";
-        let allowOrigin = "*";
-        if (typeof origin === "string") {
-            allowOrigin = origin;
-        }
-        else if (origin instanceof RegExp) {
-            allowOrigin = origin.test(reqOrigin) ? reqOrigin : "";
-        }
-        else if (Array.isArray(origin)) {
-            const isAllowed = origin.some((item) => {
-                if (typeof item === "string") {
-                    return item === reqOrigin;
-                }
-                else if (item instanceof RegExp) {
-                    return item.test(reqOrigin);
-                }
-            });
-            allowOrigin = isAllowed ? reqOrigin : "";
-        }
-        else if (typeof origin === "function") {
-            allowOrigin = origin(reqOrigin) ? reqOrigin : "";
-        }
-        ctx.headers.set("Access-Control-Allow-Origin", allowOrigin);
-        ctx.headers.set("Access-Control-Allow-Methods", (methods || ["GET", "POST", "PUT", "DELETE"]).join(", "));
-        ctx.headers.set("Access-Control-Allow-Headers", (allowedHeaders || ["Content-Type", "Authorization"]).join(", "));
-        if (exposedHeaders) {
-            ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "));
-        }
-        if (credentials) {
-            ctx.headers.set("Access-Control-Allow-Credentials", "true");
-        }
-        if (maxAge) {
-            ctx.headers.set("Access-Control-Max-Age", maxAge.toString());
-        }
-        if (ctx.req.method === "OPTIONS") {
-            return new Response(null, {
-                status: 204,
-                headers: ctx.headers.toObject(),
-            });
-        }
-        return await next();
-    };
-}