tezx 1.0.21 → 1.0.23

package/utils/formData.js

@@ -0,0 +1,213 @@
+import { EnvironmentDetector } from "../environment";
+export async function parseJsonBody(req) {
+    const runtime = 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");
+    }
+}
+export async function parseTextBody(req) {
+    const runtime = 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");
+    }
+}
+export async function parseUrlEncodedBody(req) {
+    const runtime = 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");
+    }
+}
+export async function parseMultipartBody(req, boundary, options) {
+    const runtime = 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/utils/params.d.ts

@@ -0,0 +1,7 @@
+export declare function useParams({ path, urlPattern, }: {
+    path: string;
+    urlPattern: string;
+}): {
+    success: boolean;
+    params: Record<string, any>;
+};

package/utils/params.js

@@ -0,0 +1,91 @@
+export 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/utils/state.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A simple key-value storage class using Map.
+ */
+export declare class State {
+    private state;
+    constructor();
+    /**
+     * Store a value with a specific key.
+     * @param key - The key for the value.
+     * @param value - The value to be stored.
+     */
+    set(key: string, value: any): void;
+    /**
+     * Retrieve a value by key.
+     * @param key - The key of the value to retrieve.
+     * @returns The stored value or undefined if not found.
+     */
+    get(key: string): any | undefined;
+    /**
+     * Delete a key from storage.
+     * @param key - The key to remove.
+     * @returns True if the key was deleted, false otherwise.
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if a key exists in the storage.
+     * @param key - The key to check.
+     * @returns True if the key exists, false otherwise.
+     */
+    has(key: string): boolean;
+    /**
+     * Get an array of all stored keys.
+     * @returns An array of keys.
+     */
+    keys(): string[];
+    /**
+     * Get an array of all stored values.
+     * @returns An array of values.
+     */
+    values(): any[];
+    /**
+     * Get an array of all key-value pairs.
+     * @returns An array of [key, value] tuples.
+     */
+    entries(): [string, any][];
+    /**
+     * Remove all entries from storage.
+     */
+    clear(): void;
+}

package/utils/state.js

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,9 @@
+import { Router, StaticServeOption } from "../router";
+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/staticFile.js

@@ -0,0 +1,154 @@
+import { EnvironmentDetector } from "../environment";
+export const 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",
+};
+export const defaultMimeType = "application/octet-stream";
+export async function getFiles(dir, basePath = "/", ref, option) {
+    const files = [];
+    const runtime = 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 import("fs/promises");
+        const path = await import("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/utils/url.d.ts

@@ -0,0 +1,16 @@
+export type UrlRef = {
+    hash: string | undefined;
+    protocol: string | undefined;
+    origin: string | undefined;
+    username: string | undefined;
+    password: string | undefined;
+    hostname: string | undefined;
+    port: string | undefined;
+    href: string | undefined;
+    query: {
+        [key: string]: string;
+    };
+    pathname: string | undefined;
+};
+export declare function sanitizePathSplit(basePath: string, path: string): string[];
+export declare function urlParse(url: string): UrlRef;

package/utils/url.js

@@ -0,0 +1,55 @@
+export function sanitizePathSplit(basePath, path) {
+    const parts = `${basePath}/${path}`
+        .replace(/\\/g, "")
+        ?.split("/")
+        .filter(Boolean);
+    return parts;
+}
+export 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(),
+    };
+}