tezx 1.0.13 → 1.0.15

package/dist/cjs/utils/formData.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonBody = parseJsonBody;
-exports.parseTextBody = parseTextBody;
-exports.parseUrlEncodedBody = parseUrlEncodedBody;
-exports.parseMultipartBody = parseMultipartBody;
-const environment_1 = require("../environment");
-async function parseJsonBody(req) {
-    const runtime = environment_1.EnvironmentDetector.getEnvironment;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.json();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-async function parseTextBody(req) {
-    const runtime = environment_1.EnvironmentDetector.getEnvironment;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(body);
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.text();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-async function parseUrlEncodedBody(req) {
-    const runtime = environment_1.EnvironmentDetector.getEnvironment;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const pairs = body.split("&");
-                    const formData = {};
-                    pairs.forEach((pair) => {
-                        const [key, value] = pair.split("=");
-                        formData[decodeURIComponent(key)] = decodeURIComponent(value || "");
-                    });
-                    resolve(formData);
-                }
-                catch {
-                    reject(new Error("Invalid x-www-form-urlencoded format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.formData();
-        const result = {};
-        for (const [key, value] of formData.entries()) {
-            result[key] = value;
-        }
-        return result;
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-async function parseMultipartBody(req, boundary, options) {
-    const runtime = environment_1.EnvironmentDetector.getEnvironment;
-    const x = options?.sanitized;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const formDataField = {};
-                    const formDataFieldParts = body.split("----------------------------");
-                    formDataFieldParts.forEach((part) => {
-                        const match = part.match(/name="(.*)"\r\n\r\n(.*)\r\n/);
-                        if (match && match.length === 3) {
-                            const name = match[1];
-                            const value = match[2];
-                            formDataField[name] = value;
-                        }
-                    });
-                    const parts = body.split(`--${boundary}`);
-                    for (const part of parts) {
-                        if (part.includes("filename")) {
-                            const filenameMatch = part.match(/filename="([^"]+)"/);
-                            const fieldNameMatch = part.match(/name="([^"]+)"/);
-                            const contentTypeMatch = part.match(/Content-Type: ([^\r\n]+)/);
-                            if (filenameMatch && fieldNameMatch && contentTypeMatch) {
-                                let filename = filenameMatch[1];
-                                const fieldName = fieldNameMatch[1];
-                                const contentType = contentTypeMatch[1];
-                                if (options?.sanitized) {
-                                    filename =
-                                        `${Date.now()}-${filename.replace(/\s+/g, "")?.replace(/[^a-zA-Z0-9.-]/g, "-")}`?.toLowerCase();
-                                }
-                                if (Array.isArray(options?.allowedTypes) &&
-                                    !options.allowedTypes?.includes(contentType)) {
-                                    reject(`Invalid file type: "${contentType}". Allowed types: ${options.allowedTypes.join(", ")}`);
-                                }
-                                const fileContentStartIndex = part.indexOf("\r\n\r\n") + 4;
-                                const fileContent = Buffer.from(part.substring(fileContentStartIndex), "binary");
-                                const arrayBuffer = fileContent.buffer.slice(fileContent.byteOffset, fileContent.byteOffset + fileContent.byteLength);
-                                if (typeof options?.maxSize !== "undefined" &&
-                                    fileContent.byteLength > options.maxSize) {
-                                    reject(`File size exceeds the limit: ${fileContent.byteLength} bytes (Max: ${options.maxSize} bytes)`);
-                                }
-                                const file = new File([arrayBuffer], filename, {
-                                    type: contentType,
-                                });
-                                if (typeof options?.maxFiles != "undefined" &&
-                                    options.maxFiles == 0) {
-                                    reject(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                                }
-                                if (formDataField[fieldName]) {
-                                    if (Array.isArray(formDataField[fieldName])) {
-                                        if (typeof options?.maxFiles != "undefined" &&
-                                            formDataField[fieldName]?.length >= options.maxFiles) {
-                                            reject(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                                        }
-                                        formDataField[fieldName].push(file);
-                                    }
-                                    else {
-                                        formDataField[fieldName] = [formDataField[fieldName], file];
-                                    }
-                                }
-                                else {
-                                    formDataField[fieldName] = file;
-                                }
-                            }
-                        }
-                    }
-                    resolve(formDataField);
-                }
-                catch { }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.formData();
-        const result = {};
-        for (const [key, value] of formData.entries()) {
-            let val = value;
-            if (val instanceof File && typeof options == "object") {
-                let filename = val.name;
-                if (options?.sanitized) {
-                    filename =
-                        `${Date.now()}-${filename.replace(/\s+/g, "")?.replace(/[^a-zA-Z0-9.-]/g, "-")}`?.toLowerCase();
-                }
-                if (Array.isArray(options?.allowedTypes) &&
-                    !options.allowedTypes?.includes(val.type)) {
-                    throw new Error(`Invalid file type: "${val.type}". Allowed types: ${options.allowedTypes.join(", ")}`);
-                }
-                if (typeof options?.maxSize !== "undefined" &&
-                    val.size > options.maxSize) {
-                    throw new Error(`File size exceeds the limit: ${val.size} bytes (Max: ${options.maxSize} bytes)`);
-                }
-                if (typeof options?.maxFiles != "undefined" && options.maxFiles == 0) {
-                    throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                }
-                val = new File([await val.arrayBuffer()], filename, {
-                    type: val.type,
-                });
-            }
-            if (result[key]) {
-                if (Array.isArray(result[key])) {
-                    if (val instanceof File &&
-                        typeof options?.maxFiles != "undefined" &&
-                        result[key]?.length >= options.maxFiles) {
-                        throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                    }
-                    result[key].push(val);
-                }
-                else {
-                    result[key] = [result[key], val];
-                }
-            }
-            else {
-                result[key] = val;
-            }
-        }
-        return result;
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}

package/dist/cjs/utils/params.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useParams = useParams;
-function useParams({ path, urlPattern, }) {
-    let params = {};
-    path = path.replace(/^\/+|\/+$/g, "");
-    urlPattern = urlPattern.replace(/^\/+|\/+$/g, "");
-    const pathSegments = path ? path.split("/") : [];
-    const patternSegments = urlPattern ? urlPattern.split("/") : [];
-    const pathLength = pathSegments.length;
-    const patternLength = patternSegments.length;
-    if (pathLength > patternLength && !urlPattern.includes("*")) {
-        return { success: false, params: {} };
-    }
-    let pathIndex = 0;
-    for (let i = 0; i < patternLength; i++) {
-        const patternSegment = patternSegments[i];
-        if (patternSegment?.startsWith("*")) {
-            const trailingPatterns = patternSegments.slice(i + 1);
-            let paramName = patternSegment.length == 1 ? "*" : patternSegment?.slice(1);
-            if (trailingPatterns.length > 0) {
-                const expectedTrailing = trailingPatterns.join("/");
-                const actualTrailing = pathSegments
-                    .slice(pathLength - trailingPatterns.length)
-                    .join("/");
-                const wildcardPath = pathSegments
-                    .slice(pathIndex, pathLength - trailingPatterns.length)
-                    .join("/");
-                if (expectedTrailing !== actualTrailing || !wildcardPath) {
-                    return { success: false, params: {} };
-                }
-                params[paramName] = wildcardPath;
-                return { success: true, params };
-            }
-            else {
-                const wildcardPath = pathSegments.slice(pathIndex).join("/");
-                if (!wildcardPath) {
-                    return { success: false, params: {} };
-                }
-                params[paramName] = wildcardPath;
-                return { success: true, params };
-            }
-        }
-        if (patternSegment.startsWith(":") && patternSegment.endsWith("?")) {
-            const paramName = patternSegment.slice(1, -1);
-            const nextPattern = patternSegments[i + 1];
-            if (nextPattern &&
-                !nextPattern.startsWith(":") &&
-                nextPattern !== "*" &&
-                pathIndex < pathLength &&
-                pathSegments[pathIndex] === nextPattern) {
-                params[paramName] = null;
-                continue;
-            }
-            const remainingPatterns = patternSegments.slice(i + 1);
-            const requiredCount = remainingPatterns.filter((seg) => !(seg.startsWith(":") && seg.endsWith("?"))).length;
-            const remainingPath = pathLength - pathIndex;
-            if (remainingPath === requiredCount) {
-                params[paramName] = null;
-            }
-            else if (pathIndex < pathLength) {
-                params[paramName] = pathSegments[pathIndex];
-                pathIndex++;
-            }
-            else {
-                params[paramName] = null;
-            }
-            continue;
-        }
-        if (patternSegment.startsWith(":")) {
-            const paramName = patternSegment.slice(1);
-            if (!/^[a-zA-Z0-9_]+$/.test(paramName)) {
-                return { success: false, params: {} };
-            }
-            if (pathIndex < pathLength) {
-                params[paramName] = pathSegments[pathIndex];
-                pathIndex++;
-            }
-            else {
-                return { success: false, params: {} };
-            }
-            continue;
-        }
-        const pathSegment = pathSegments[pathIndex];
-        if (patternSegment !== pathSegment) {
-            return { success: false, params: {} };
-        }
-        pathIndex++;
-    }
-    if (pathIndex < pathLength) {
-        return { success: false, params: {} };
-    }
-    return { success: true, params };
-}

package/dist/cjs/utils/state.js

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

package/dist/cjs/utils/staticFile.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMimeType = exports.mimeTypes = void 0;
-exports.getFiles = getFiles;
-const environment_1 = require("../environment");
-exports.mimeTypes = {
-    html: "text/html",
-    htm: "text/html",
-    css: "text/css",
-    js: "text/javascript",
-    mjs: "text/javascript",
-    json: "application/json",
-    xml: "application/xml",
-    txt: "text/plain",
-    md: "text/markdown",
-    csv: "text/csv",
-    tsv: "text/tab-separated-values",
-    rtf: "application/rtf",
-    markdown: "text/markdown",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    svg: "image/svg+xml",
-    webp: "image/webp",
-    ico: "image/x-icon",
-    bmp: "image/bmp",
-    tiff: "image/tiff",
-    psd: "image/vnd.adobe.photoshop",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    ogg: "video/ogg",
-    mov: "video/quicktime",
-    avi: "video/x-msvideo",
-    wmv: "video/x-ms-wmv",
-    flv: "video/x-flv",
-    "3gp": "video/3gpp",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    aac: "audio/aac",
-    flac: "audio/flac",
-    m4a: "audio/mp4",
-    mid: "audio/midi",
-    midi: "audio/midi",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    ttf: "font/ttf",
-    otf: "font/otf",
-    eot: "application/vnd.ms-fontobject",
-    pdf: "application/pdf",
-    odp: "application/vnd.oasis.opendocument.presentation",
-    zip: "application/zip",
-    gz: "application/gzip",
-    tar: "application/x-tar",
-    rar: "application/x-rar-compressed",
-    _7z: "application/x-7z-compressed",
-    bz2: "application/x-bzip2",
-    "7z": "application/x-7z-compressed",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    xls: "application/vnd.ms-excel",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ppt: "application/vnd.ms-powerpoint",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    odt: "application/vnd.oasis.opendocument.text",
-    ods: "application/vnd.oasis.opendocument.spreadsheet",
-    wasm: "application/wasm",
-    map: "application/json",
-    yaml: "application/yaml",
-    yml: "application/yaml",
-    proto: "text/plain",
-    graphql: "application/graphql",
-    pem: "application/x-pem-file",
-    cer: "application/pkix-cert",
-    crt: "application/x-x509-ca-cert",
-    key: "application/x-pem-file",
-    pfx: "application/x-pkcs12",
-    glb: "model/gltf-binary",
-    gltf: "model/gltf+json",
-    obj: "model/obj",
-    stl: "model/stl",
-    usdz: "model/vnd.usdz+zip",
-    exe: "application/x-msdownload",
-    dmg: "application/x-apple-diskimage",
-    deb: "application/x-debian-package",
-    rpm: "application/x-redhat-package-manager",
-    apk: "application/vnd.android.package-archive",
-    webmanifest: "application/manifest+json",
-    ics: "text/calendar",
-    vcf: "text/vcard",
-    warc: "application/warc",
-    atom: "application/atom+xml",
-    rss: "application/rss+xml",
-    dll: "application/x-msdownload",
-    sh: "application/x-sh",
-    py: "text/x-python",
-    rb: "text/x-ruby",
-    pl: "text/x-perl",
-    php: "application/x-httpd-php",
-    torrent: "application/x-bittorrent",
-    ipa: "application/vnd.iphone",
-    eps: "application/postscript",
-    ps: "application/postscript",
-    ai: "application/postscript",
-    swf: "application/x-shockwave-flash",
-    jar: "application/java-archive",
-    gcode: "text/x.gcode",
-};
-exports.defaultMimeType = "application/octet-stream";
-async function getFiles(dir, basePath = "/", ref, option) {
-    const files = [];
-    const runtime = environment_1.EnvironmentDetector.getEnvironment;
-    if (runtime == "deno") {
-        for await (const entry of Deno.readDir(dir)) {
-            const path = `${dir}/${entry.name}`;
-            if (entry.isDirectory) {
-                files.push(...(await getFiles(path, `${basePath}/${entry.name}`, ref, option)));
-            }
-            else {
-                const x = `${basePath}/${entry.name}`;
-                files.push({
-                    file: path,
-                    path: x.replace(/\\/g, "/"),
-                });
-            }
-        }
-    }
-    else {
-        const fs = await Promise.resolve().then(() => require("fs/promises"));
-        const path = await Promise.resolve().then(() => require("path"));
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                files.push(...(await getFiles(fullPath, `${basePath}/${entry.name}`, ref, option)));
-            }
-            else {
-                const path = `${basePath}/${entry.name}`;
-                files.push({
-                    file: fullPath,
-                    path: path.replace(/\\/g, "/"),
-                });
-            }
-        }
-    }
-    files.forEach((r) => {
-        ref.get(r.path, (ctx) => {
-            if (option.cacheControl) {
-                ctx.headers.set("Cache-Control", option.cacheControl);
-            }
-            if (option.headers) {
-                ctx.headers.add(option.headers);
-            }
-            return ctx.sendFile(r.file);
-        });
-    });
-    return files;
-}

package/dist/cjs/utils/url.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizePathSplit = sanitizePathSplit;
-exports.urlParse = urlParse;
-function sanitizePathSplit(basePath, path) {
-    const parts = `${basePath}/${path}`
-        .replace(/\\/g, "")
-        ?.split("/")
-        .filter(Boolean);
-    return parts;
-}
-function urlParse(url) {
-    const urlPattern = /^(?:(\w+):\/\/)?(?:([^:@]+)?(?::([^@]+))?@)?([^:/?#]+)?(?::(\d+))?(\/[^?#]*)?(?:\?([^#]*))?(?:#(.*))?$/;
-    let matches = url.match(urlPattern);
-    if (!matches) {
-        href: url;
-    }
-    const [_, protocol, username, password, hostname, port, path, queryString, hash,] = matches;
-    let origin = hostname;
-    if (protocol) {
-        origin = protocol + "://" + hostname;
-    }
-    if (port) {
-        origin = origin + ":" + port;
-    }
-    let p = path;
-    if (p?.endsWith("/"))
-        p.slice(0, -1);
-    function query() {
-        if (queryString) {
-            const queryPart = decodeURIComponent(queryString);
-            const keyValuePairs = queryPart.split("&");
-            const paramsObj = keyValuePairs?.map((keyValue) => {
-                const [key, value] = keyValue.split("=");
-                return {
-                    [key]: value,
-                };
-            });
-            return paramsObj.reduce(function (total, value) {
-                return { ...total, ...value };
-            }, {});
-        }
-        else {
-            return {};
-        }
-    }
-    return {
-        pathname: p,
-        hash,
-        protocol,
-        origin,
-        username,
-        password,
-        hostname,
-        href: url,
-        port,
-        query: query(),
-    };
-}

package/dist/common.d.ts

@@ -1,21 +0,0 @@
-import { Context } from "./context";
-import { Callback, ctx } from "./router";
-export interface option {
-    status?: number;
-}
-export type onError<T> = (error: string, ctx: Context) => void;
-export declare class CommonHandler {
-    /**
-     * Register a custom 404 handler for missing routes
-     * @param {Callback} callback - Handler function to execute when no route matches
-     * @returns {this} - Returns current instance for chaining
-     *
-     * @example
-     * // Register a custom not-found handler
-     * app.notFound((ctx) => {
-     *   ctx.status(404).text('Custom not found message');
-     * });
-     */
-    notFound(callback: Callback): this;
-    onError(callback: <T extends Record<string, any> = {}>(err: string, ctx: ctx<T>) => any): this;
-}

package/dist/common.js

@@ -1,11 +0,0 @@
-import { GlobalConfig } from "./config/config";
-export class CommonHandler {
-    notFound(callback) {
-        GlobalConfig.notFound = callback;
-        return this;
-    }
-    onError(callback) {
-        GlobalConfig.onError = callback;
-        return this;
-    }
-}

package/dist/config/config.d.ts

@@ -1,17 +0,0 @@
-import { Callback, ctx } from "../router";
-export declare let GlobalConfig: {
-    new (): {};
-    notFound: Callback;
-    onError: <T extends Record<string, any> = {}>(err: string, ctx: ctx<T>) => any;
-    allowDuplicateMw?: boolean;
-    overwriteMethod?: boolean;
-    debugMode?: boolean;
-    serverInfo: any;
-    readonly debugging: {
-        info: (msg: string, ...args: unknown[]) => void;
-        warn: (msg: string, ...args: unknown[]) => void;
-        error: (msg: string, ...args: unknown[]) => void;
-        debug: (msg: string, ...args: unknown[]) => void;
-        success: (msg: string, ...args: unknown[]) => void;
-    };
-};

package/dist/config/config.js

@@ -1,31 +0,0 @@
-import { loggerOutput } from "../utils/debugging";
-export 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) => loggerOutput("info", msg, ...args),
-                warn: (msg, ...args) => loggerOutput("warn", msg, ...args),
-                error: (msg, ...args) => loggerOutput("error", msg, ...args),
-                debug: (msg, ...args) => loggerOutput("debug", msg, ...args),
-                success: (msg, ...args) => loggerOutput("success", msg, ...args),
-            }
-            : {
-                info: (msg, ...args) => { },
-                warn: (msg, ...args) => { },
-                error: (msg, ...args) => { },
-                debug: (msg, ...args) => { },
-                success: (msg, ...args) => { },
-            };
-    }
-};