tezx 2.0.11 → 3.0.0

package/cjs/utils/formData.js

@@ -1,13 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitized = sanitized;
-function sanitized(title) {
-    const base = title
-        .toLowerCase()
-        .trim()
-        .replace(/[_\s]+/g, "-")
-        .replace(/[^a-z0-9-.]+/g, "")
-        .replace(/--+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return base;
+exports.useFormData = useFormData;
+exports.processFile = processFile;
+const low_level_js_1 = require("./low-level.js");
+async function useFormData(ctx, options) {
+    const fd = await ctx.req.formData();
+    const result = {};
+    let totalFileBytes = 0;
+    for (const [key, originalVal] of fd.entries()) {
+        let val = originalVal;
+        if (val instanceof File && options) {
+            val = await processFile(val, key, options, () => totalFileBytes);
+            totalFileBytes += val.size;
+            if (typeof options.maxTotalSize === "number" &&
+                totalFileBytes > options.maxTotalSize) {
+                throw new Error(`Total file bytes exceeded maxTotalSize=${options.maxTotalSize}`);
+            }
+        }
+        else if (typeof val === "string" &&
+            options?.maxFieldSize &&
+            val.length > options.maxFieldSize) {
+            throw new Error(`Field "${key}" length ${val.length} exceeds maxFieldSize=${options.maxFieldSize}`);
+        }
+        if (key in result) {
+            if (!Array.isArray(result[key])) {
+                result[key] = [result[key]];
+            }
+            result[key].push(val);
+        }
+        else {
+            result[key] = val;
+        }
+        if (val instanceof File && typeof options?.maxFiles === "number") {
+            const filesForKey = Array.isArray(result[key])
+                ? result[key].filter((v) => v instanceof File).length
+                : result[key] instanceof File
+                    ? 1
+                    : 0;
+            if (filesForKey > options.maxFiles) {
+                throw new Error(`Field "${key}" exceeds maxFiles (${options.maxFiles})`);
+            }
+        }
+    }
+    return result;
+}
+async function processFile(file, key, options, totalGetter) {
+    let name = file.name;
+    if (options.sanitized) {
+        name = `${Date.now()}-${(0, low_level_js_1.sanitized)(name)}`;
+    }
+    if (Array.isArray(options.allowedTypes) &&
+        !options.allowedTypes.includes(file.type)) {
+        throw new Error(`Field "${key}": invalid file type "${file.type}". Allowed: ${options.allowedTypes.join(", ")}`);
+    }
+    if (typeof options.maxSize === "number" && file.size > options.maxSize) {
+        throw new Error(`Field "${key}": file size ${file.size} > maxSize ${options.maxSize}`);
+    }
+    if (name !== file.name) {
+        return new File([await file.arrayBuffer()], name, { type: file.type });
+    }
+    return file;
 }

package/cjs/utils/generateID.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateID = generateID;
+exports.generateUUID = generateUUID;
+exports.generateRandomBase64 = generateRandomBase64;
+function generateID() {
+    const timestamp = Date.now().toString(16);
+    let randomHex = "";
+    if (typeof crypto !== "undefined" &&
+        typeof crypto.getRandomValues === "function") {
+        const array = new Uint8Array(6);
+        crypto.getRandomValues(array);
+        for (let i = 0; i < array.length; i++) {
+            randomHex += array[i].toString(16).padStart(2, "0");
+        }
+    }
+    else {
+        randomHex = Math.floor(Math.random() * 0xffffffffffff)
+            .toString(16)
+            .padStart(12, "0");
+    }
+    return `${timestamp}-${randomHex}`;
+}
+function generateUUID() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
+        return crypto.randomUUID();
+    return generateID();
+}
+function generateRandomBase64(length = 16) {
+    let result = "";
+    const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (let i = 0; i < length; i++) {
+        const idx = Math.floor(Math.random() * 64);
+        result += BASE64[idx];
+    }
+    return result;
+}

package/cjs/utils/low-level.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaderKey = normalizeHeaderKey;
+exports.extensionExtract = extensionExtract;
+exports.sanitizePathSplitBasePath = sanitizePathSplitBasePath;
+exports.sanitizePathSplit = sanitizePathSplit;
+exports.sanitized = sanitized;
+function normalizeHeaderKey(key) {
+    let result = "";
+    let upperNext = true;
+    for (let i = 0; i < key.length; i++) {
+        const ch = key.charCodeAt(i);
+        if (ch === 45) {
+            result += "-";
+            upperNext = true;
+        }
+        else {
+            result += upperNext
+                ? String.fromCharCode(ch >= 97 && ch <= 122 ? ch - 32 : ch)
+                : String.fromCharCode(ch >= 65 && ch <= 90 ? ch + 32 : ch);
+            upperNext = false;
+        }
+    }
+    return result;
+}
+function extensionExtract(filePath) {
+    let lastDot = -1;
+    for (let i = filePath.length - 1; i >= 0; i--) {
+        if (filePath[i] === ".") {
+            lastDot = i;
+            break;
+        }
+    }
+    if (lastDot === -1 || lastDot === filePath.length - 1)
+        return "";
+    let ext = "";
+    for (let i = lastDot + 1; i < filePath.length; i++) {
+        let c = filePath.charCodeAt(i);
+        if (c >= 65 && c <= 90) {
+            c += 32;
+        }
+        ext += String.fromCharCode(c);
+    }
+    return ext;
+}
+function sanitizePathSplitBasePath(basePath, path, out) {
+    const combined = `${basePath}/${path}`;
+    const parts = out ?? [];
+    let segStart = 0;
+    let i = 0;
+    const len = combined.length;
+    while (i < len) {
+        const code = combined.charCodeAt(i);
+        if (code === 47 || code === 92) {
+            if (segStart < i) {
+                const seg = combined.slice(segStart, i);
+                if (seg !== "..")
+                    parts.push(seg);
+            }
+            segStart = i + 1;
+        }
+        i++;
+    }
+    if (segStart < len) {
+        const seg = combined.slice(segStart, len);
+        if (seg !== "..")
+            parts.push(seg);
+    }
+    return parts;
+}
+function sanitizePathSplit(path, out) {
+    const parts = out ?? [];
+    let segStart = 0;
+    let i = 0;
+    const len = path.length;
+    while (i < len) {
+        const code = path.charCodeAt(i);
+        if (code === 47 || code === 92) {
+            if (segStart < i) {
+                const seg = path.slice(segStart, i);
+                if (seg !== "..")
+                    parts.push(seg);
+            }
+            segStart = i + 1;
+        }
+        i++;
+    }
+    if (segStart < len) {
+        const seg = path.slice(segStart, len);
+        if (seg !== "..")
+            parts.push(seg);
+    }
+    return parts;
+}
+function sanitized(title) {
+    const len = title.length;
+    let result = "";
+    let dash = false;
+    for (let i = 0; i < len; i++) {
+        let ch = title.charCodeAt(i);
+        if (ch >= 65 && ch <= 90)
+            ch += 32;
+        if ((ch >= 97 && ch <= 122) || (ch >= 48 && ch <= 57) || ch === 46) {
+            result += String.fromCharCode(ch);
+            dash = false;
+        }
+        else if (ch === 32 || ch === 95 || ch === 45) {
+            if (!dash && result.length > 0) {
+                result += "-";
+                dash = true;
+            }
+        }
+    }
+    return result.endsWith("-") ? result.slice(0, -1) : result;
+}

package/cjs/utils/{staticFile.js → mimeTypes.js}

@@ -1,41 +1,6 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultMimeType = exports.mimeTypes = void 0;
-exports.getFiles = getFiles;
-const environment_js_1 = require("../core/environment.js");
 exports.mimeTypes = {
     html: "text/html",
     htm: "text/html",
@@ -140,55 +105,3 @@ exports.mimeTypes = {
     gcode: "text/x.gcode",
 };
 exports.defaultMimeType = "application/octet-stream";
-async function getFiles(dir, basePath = "/", ref, option) {
-    const files = [];
-    const runtime = environment_js_1.Environment.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(() => __importStar(require("node:fs/promises")));
-        const path = await Promise.resolve().then(() => __importStar(require("node: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) {
-                for (const key in option.headers) {
-                    let value = option.headers?.[key];
-                    ctx.headers.set(key, value);
-                }
-            }
-            return ctx.sendFile(r.file);
-        });
-    });
-    return files;
-}

package/cjs/utils/rateLimit.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRateLimitDefaultStorage = createRateLimitDefaultStorage;
+exports.isRateLimit = isRateLimit;
+function createRateLimitDefaultStorage() {
+    const store = new Map();
+    return {
+        get: (key) => store.get(key),
+        set: (key, value) => store.set(key, value),
+        clearExpired: () => {
+            const now = Date.now();
+            for (const [key, entry] of store.entries()) {
+                if (now >= entry.resetTime) {
+                    store.delete(key);
+                }
+            }
+        },
+    };
+}
+function isRateLimit(key, store, maxRequests, windowMs) {
+    store?.clearExpired();
+    const now = Date.now();
+    let entry = store.get(key) || { count: 0, resetTime: now + windowMs };
+    if (now < entry.resetTime) {
+        entry.count++;
+        if (entry.count > maxRequests) {
+            return {
+                check: true,
+                entry: entry,
+            };
+        }
+    }
+    else {
+        entry = { count: 1, resetTime: now + windowMs };
+    }
+    store.set(key, entry);
+    return {
+        check: false,
+        entry: entry,
+    };
+}

package/cjs/utils/response.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundResponse = void 0;
+exports.handleErrorResponse = handleErrorResponse;
+exports.toString = toString;
+exports.determineContentTypeBody = determineContentTypeBody;
+const config_js_1 = require("../core/config.js");
+const error_js_1 = require("../core/error.js");
+let notFoundResponse = (ctx) => {
+    const { method, pathname } = ctx;
+    return ctx.text(`${method}: '${pathname}' could not find\n`, {
+        status: 404,
+    });
+};
+exports.notFoundResponse = notFoundResponse;
+async function handleErrorResponse(err = error_js_1.TezXError.internal(), ctx) {
+    if (err instanceof error_js_1.TezXError) {
+        config_js_1.GlobalConfig.debugging.error(err.details ?? err?.message);
+        return ctx
+            .status(err.statusCode ?? 500)
+            .send(err.details ?? err?.message ?? "Internal Server Error");
+    }
+    return await handleErrorResponse(error_js_1.TezXError.internal(), ctx);
+}
+function toString(input, values) {
+    if (typeof input === "string") {
+        return input;
+    }
+    let result = "";
+    for (let i = 0; i < input.length; i++) {
+        result += input[i];
+        if (i < values.length)
+            result += values[i];
+    }
+    return result;
+}
+function determineContentTypeBody(body) {
+    if (typeof body === "string" ||
+        typeof body === "number" ||
+        typeof body === "boolean") {
+        return { type: "text/plain; charset=utf-8", body: String(body) };
+    }
+    if (body instanceof Uint8Array || body instanceof ArrayBuffer) {
+        return { type: "application/octet-stream", body };
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) {
+        return { type: "application/octet-stream", body };
+    }
+    if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+        return { type: "application/octet-stream", body };
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+        return { type: body.type || "application/octet-stream", body };
+    }
+    if (typeof body === "object" && typeof body?.pipe === "function") {
+        return { type: "application/octet-stream", body };
+    }
+    if (typeof body === "object") {
+        return {
+            type: "application/json; charset=utf-8",
+            body: JSON.stringify(body),
+        };
+    }
+    return { type: "text/plain; charset=utf-8", body: String(body ?? "") };
+}

package/cjs/{core/environment.js → utils/runtime.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Environment = void 0;
+exports.runtime = exports.Environment = void 0;
 class Environment {
     static get getEnvironment() {
         if (typeof Bun !== "undefined")
@@ -13,3 +13,4 @@ class Environment {
     }
 }
 exports.Environment = Environment;
+exports.runtime = Environment.getEnvironment;

package/cjs/utils/url.js

@@ -1,35 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wildcardOrOptionalParamRegex = void 0;
-exports.sanitizePathSplit = sanitizePathSplit;
-exports.urlParse = urlParse;
-function normalizePath(path) {
-    return ("/" + path.replace(/\\/g, "").replace(/\/+/g, "/").replace(/^\/+/, ""));
-}
-function sanitizePathSplit(basePath, path) {
-    const parts = `${basePath}/${path}`
-        .replace(/\\/g, "")
-        .replace(/\/+/g, "/")
-        ?.split("/")
-        .filter(Boolean);
-    return parts;
+exports.getPathname = void 0;
+exports.queryParser = queryParser;
+exports.url2query = url2query;
+let getPathname = (url) => {
+    const len = url.length;
+    if (len === 0)
+        return "/";
+    const start = url.indexOf("/", url.charCodeAt(9) === 58 ? 13 : 8);
+    if (start === -1)
+        return "/";
+    let end = url.indexOf("?", start);
+    if (end === -1)
+        end = url.indexOf("#", start);
+    if (end === -1)
+        end = len;
+    return start === end ? "/" : url.slice(start, end);
+};
+exports.getPathname = getPathname;
+function queryParser(qs) {
+    if (!qs?.length)
+        return {};
+    const startPos = qs.charCodeAt(0) === 63 ? 1 : 0;
+    const len = qs.length;
+    const query = {};
+    let keyStart = startPos, valStart = -1;
+    let i = startPos;
+    const reuseArray = [];
+    for (; i <= len; i++) {
+        const ch = i < len ? qs.charCodeAt(i) : 38;
+        if (ch === 61 && valStart === -1) {
+            valStart = i + 1;
+        }
+        else if (ch === 38 || i === len) {
+            const keyEnd = valStart === -1 ? i : valStart - 1;
+            const key = qs.slice(keyStart, keyEnd);
+            const val = valStart === -1 ? "" : qs.slice(valStart, i);
+            const existing = query[key];
+            if (existing !== undefined) {
+                if (Array.isArray(existing)) {
+                    existing.push(val);
+                }
+                else {
+                    reuseArray.length = 0;
+                    reuseArray[0] = existing;
+                    reuseArray[1] = val;
+                    query[key] = reuseArray.slice();
+                }
+            }
+            else {
+                query[key] = val;
+            }
+            keyStart = i + 1;
+            valStart = -1;
+        }
+    }
+    return query;
 }
-exports.wildcardOrOptionalParamRegex = /\/\*|:[^/]+[?*]/;
-function urlParse(url) {
-    let u = URL.parse(url);
-    let query = {};
-    if (u?.search) {
-        new URLSearchParams(u?.search).forEach((value, key) => {
-            query[key] = value;
-        });
+function url2query(url) {
+    let pathStart = url.indexOf("/", url.charCodeAt(9) === 58 ? 13 : 8);
+    if (pathStart === -1)
+        pathStart = url.length;
+    let queryStart = url.indexOf("?", pathStart);
+    if (queryStart === -1) {
+        return {};
     }
-    return {
-        pathname: u?.pathname,
-        query: query,
-        protocol: u?.protocol,
-        origin: u?.origin,
-        hostname: u?.hostname,
-        href: url,
-        port: u?.port,
-    };
+    let qs = url.slice(queryStart + 1);
+    return queryParser(qs);
 }

package/core/config.d.ts

@@ -1,13 +1,8 @@
-import { AdapterType, Callback, ctx } from "../types/index.js";
+import { Runtime } from "../types/index.js";
 export declare let GlobalConfig: {
     new (): {};
-    notFound: Callback;
-    onError: <T extends Record<string, any> = {}>(err: string, ctx: ctx<T>) => Response;
-    allowDuplicateMw?: boolean;
-    overwriteMethod?: boolean;
     debugMode?: boolean;
-    server: any;
-    adapter: AdapterType;
+    adapter: Runtime;
     readonly debugging: {
         info: (msg: string, ...args: unknown[]) => void;
         warn: (msg: string, ...args: unknown[]) => void;

package/core/config.js

@@ -1,18 +1,8 @@
 import { loggerOutput } from "../utils/debugging.js";
-import { Environment } from "./environment.js";
+import { runtime } from "../utils/runtime.js";
 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 server;
-    static adapter = Environment.getEnvironment;
+    static adapter = runtime;
     static get debugging() {
         return this.debugMode
             ? {