acrylblends 1.0.4 → 1.0.5

package/lib/proxy-C2w_mH7k.js

@@ -0,0 +1,121 @@
+import { t as HTTPException } from "./http-exception-MjWkT89V.js";
+//#region ../../plugins/acryl-router/src/core/helper/proxy/index.ts
+/**
+* @module
+* Proxy Helper for Acryl.
+*/
+const hopByHopHeaders = [
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+	if (!request) return {};
+	const headers = new Headers(request.headers);
+	if (strictConnectionProcessing) {
+		const connectionValue = headers.get("connection");
+		if (connectionValue) {
+			const headerNames = connectionValue.split(",").map((h) => h.trim());
+			const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+			if (invalidHeaders.length > 0) throw new HTTPException(400, { message: `Invalid Connection header value: ${invalidHeaders.join(", ")}` });
+			headerNames.forEach((headerName) => {
+				headers.delete(headerName);
+			});
+		}
+	}
+	hopByHopHeaders.forEach((header) => {
+		headers.delete(header);
+	});
+	return {
+		method: request.method,
+		body: request.body,
+		duplex: request.body ? "half" : void 0,
+		headers,
+		signal: request.signal
+	};
+};
+const preprocessRequestInit = (requestInit) => {
+	if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) return requestInit;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(requestInit.headers)) if (value == null) headers.delete(key);
+	else headers.set(key, value);
+	requestInit.headers = headers;
+	return requestInit;
+};
+/**
+* Fetch API wrapper for proxy.
+* The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+*
+* The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
+* Unnecessary response headers are deleted and a Response object is returned that can be returned
+* as is as a response from the handler.
+*
+* @example
+* ```ts
+* app.get('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     headers: {
+*       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   }).then((res) => {
+*     res.headers.delete('Set-Cookie')
+*     return res
+*   })
+* })
+*
+* app.all('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*     headers: {
+*       ...c.req.header(),
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   })
+* })
+*
+* // Strict RFC compliance mode (use only in trusted environments)
+* app.get('/internal-proxy/:path', (c) => {
+*   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+*     ...c.req,
+*     strictConnectionProcessing: true,
+*   })
+* })
+* ```
+*/
+const proxy = async (input, proxyInit) => {
+	const { raw, customFetch, strictConnectionProcessing = false, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+	const req = new Request(input, {
+		...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+		...preprocessRequestInit(requestInit)
+	});
+	req.headers.delete("accept-encoding");
+	const res = await (customFetch || fetch)(req);
+	const resHeaders = new Headers(res.headers);
+	const connectionValue = resHeaders.get("connection");
+	if (connectionValue) connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
+	hopByHopHeaders.forEach((header) => {
+		resHeaders.delete(header);
+	});
+	if (resHeaders.has("content-encoding")) {
+		resHeaders.delete("content-encoding");
+		resHeaders.delete("content-length");
+	}
+	return new Response(res.body, {
+		status: res.status,
+		statusText: res.statusText,
+		headers: resHeaders
+	});
+};
+//#endregion
+export { proxy as t };

package/lib/proxy.js

@@ -1,121 +1,2 @@
-import { HTTPException } from "./http-exception.js";
-//#region ../../plugins/acryl-router/src/core/helper/proxy/index.ts
-/**
-* @module
-* Proxy Helper for Acryl.
-*/
-const hopByHopHeaders = [
-	"connection",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade"
-];
-const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
-const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
-	if (!request) return {};
-	const headers = new Headers(request.headers);
-	if (strictConnectionProcessing) {
-		const connectionValue = headers.get("connection");
-		if (connectionValue) {
-			const headerNames = connectionValue.split(",").map((h) => h.trim());
-			const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
-			if (invalidHeaders.length > 0) throw new HTTPException(400, { message: `Invalid Connection header value: ${invalidHeaders.join(", ")}` });
-			headerNames.forEach((headerName) => {
-				headers.delete(headerName);
-			});
-		}
-	}
-	hopByHopHeaders.forEach((header) => {
-		headers.delete(header);
-	});
-	return {
-		method: request.method,
-		body: request.body,
-		duplex: request.body ? "half" : void 0,
-		headers,
-		signal: request.signal
-	};
-};
-const preprocessRequestInit = (requestInit) => {
-	if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) return requestInit;
-	const headers = new Headers();
-	for (const [key, value] of Object.entries(requestInit.headers)) if (value == null) headers.delete(key);
-	else headers.set(key, value);
-	requestInit.headers = headers;
-	return requestInit;
-};
-/**
-* Fetch API wrapper for proxy.
-* The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
-*
-* The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
-* Unnecessary response headers are deleted and a Response object is returned that can be returned
-* as is as a response from the handler.
-*
-* @example
-* ```ts
-* app.get('/proxy/:path', (c) => {
-*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
-*     headers: {
-*       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
-*       'X-Forwarded-For': '127.0.0.1',
-*       'X-Forwarded-Host': c.req.header('host'),
-*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
-*     },
-*   }).then((res) => {
-*     res.headers.delete('Set-Cookie')
-*     return res
-*   })
-* })
-*
-* app.all('/proxy/:path', (c) => {
-*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
-*     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
-*     headers: {
-*       ...c.req.header(),
-*       'X-Forwarded-For': '127.0.0.1',
-*       'X-Forwarded-Host': c.req.header('host'),
-*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
-*     },
-*   })
-* })
-*
-* // Strict RFC compliance mode (use only in trusted environments)
-* app.get('/internal-proxy/:path', (c) => {
-*   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
-*     ...c.req,
-*     strictConnectionProcessing: true,
-*   })
-* })
-* ```
-*/
-const proxy = async (input, proxyInit) => {
-	const { raw, customFetch, strictConnectionProcessing = false, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
-	const req = new Request(input, {
-		...buildRequestInitFromRequest(raw, strictConnectionProcessing),
-		...preprocessRequestInit(requestInit)
-	});
-	req.headers.delete("accept-encoding");
-	const res = await (customFetch || fetch)(req);
-	const resHeaders = new Headers(res.headers);
-	const connectionValue = resHeaders.get("connection");
-	if (connectionValue) connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
-	hopByHopHeaders.forEach((header) => {
-		resHeaders.delete(header);
-	});
-	if (resHeaders.has("content-encoding")) {
-		resHeaders.delete("content-encoding");
-		resHeaders.delete("content-length");
-	}
-	return new Response(res.body, {
-		status: res.status,
-		statusText: res.statusText,
-		headers: resHeaders
-	});
-};
-//#endregion
+import { t as proxy } from "./proxy-C2w_mH7k.js";
 export { proxy };

package/lib/quick.js

@@ -1,7 +1,7 @@
-import { AcrylBase as Acryl$1 } from "./acryl-base.js";
-import { t as SmartRouter } from "./smart-router-C5CZ5XSM.js";
-import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
-import { t as LinearRouter } from "./linear-router-C3FPib6h.js";
+import { t as Acryl$1 } from "./app-base-CpRMZL4v.js";
+import { t as SmartRouter } from "./smart-router-BjxkDQCE.js";
+import { t as TrieRouter } from "./trie-router-JydLKUa2.js";
+import { t as LinearRouter } from "./linear-router-CmZn_JLV.js";
 //#region ../../plugins/acryl-router/src/core/preset/quick.ts
 /**
 * @module

package/lib/{reg-exp-router-DC1R3qoY.js → reg-exp-router-C_WV84eV.js}

@@ -1,5 +1,5 @@
-import { checkOptionalParameter } from "./utils/url.js";
-import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "./router.js";
+import { t as checkOptionalParameter } from "./url-BPh4d6j-.js";
+import { a as UnsupportedPathError, t as MESSAGE_MATCHER_IS_ALREADY_BUILT } from "./router-Be_o6nFu.js";
 import { t as createNullObject } from "./utils-dw8lxqjL.js";
 //#region ../../plugins/acryl-router/src/core/router/reg-exp-router/matcher.ts
 const emptyParam = [];

package/lib/request-DvMgGtlW.js

@@ -0,0 +1,323 @@
+import { t as HTTPException } from "./http-exception-MjWkT89V.js";
+import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
+import { t as parseBody } from "./body-D7f4e7w_.js";
+import { m as tryDecodeURIComponent, o as getQueryParam, s as getQueryParams } from "./url-BPh4d6j-.js";
+//#region ../../plugins/acryl-router/src/core/request.ts
+var AcrylRequest = class {
+	/**
+	* `.raw` can get the raw Request object.
+	*
+	*
+	* @example
+	* ```ts
+	* // For Cloudflare Workers
+	* app.post('/', async (c) => {
+	*   const metadata = c.req.raw.cf?.hostMetadata?
+	*   ...
+	* })
+	* ```
+	*/
+	raw;
+	#validatedData;
+	#matchResult;
+	routeIndex = 0;
+	/**
+	* `.path` can get the pathname of the request.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const pathname = c.req.path // `/about/me`
+	* })
+	* ```
+	*/
+	path;
+	bodyCache = {};
+	constructor(request, path = "/", matchResult = [[]]) {
+		this.raw = request;
+		this.path = path;
+		this.#matchResult = matchResult;
+	}
+	param(key) {
+		return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+	}
+	#getDecodedParam(key) {
+		const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+		const param = this.#getParamValue(paramKey);
+		return param && tryDecodeURIComponent(param);
+	}
+	#getAllDecodedParams() {
+		const decoded = {};
+		const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+		for (const key of keys) {
+			const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+			if (value !== void 0) decoded[key] = tryDecodeURIComponent(value);
+		}
+		return decoded;
+	}
+	#getParamValue(paramKey) {
+		return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+	}
+	query(key) {
+		return getQueryParam(this.url, key);
+	}
+	queries(key) {
+		return getQueryParams(this.url, key);
+	}
+	header(name) {
+		if (name) return this.raw.headers.get(name) ?? void 0;
+		const headerData = Object.create(null);
+		this.raw.headers.forEach((value, key) => {
+			headerData[key] = value;
+		});
+		return headerData;
+	}
+	async parseBody(options) {
+		return parseBody(this, options);
+	}
+	#cachedBody = (key) => {
+		const { bodyCache, raw } = this;
+		const cachedBody = bodyCache[key];
+		if (cachedBody) return cachedBody;
+		for (const anyCachedKey in bodyCache) return bodyCache[anyCachedKey].then((body) => {
+			if (anyCachedKey === "json") body = JSON.stringify(body);
+			const contentType = anyCachedKey === "formData" ? void 0 : raw.headers.get("content-type");
+			return new Response(body, { headers: contentType ? { "Content-Type": contentType } : void 0 })[key]();
+		});
+		return bodyCache[key] = raw[key]();
+	};
+	/**
+	* `.json()` can parse Request body of type `application/json`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.json()
+	* })
+	* ```
+	*/
+	json() {
+		return this.#cachedBody("text").then((text) => JSON.parse(text));
+	}
+	/**
+	* `.text()` can parse Request body of type `text/plain`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.text()
+	* })
+	* ```
+	*/
+	text() {
+		return this.#cachedBody("text");
+	}
+	/**
+	* `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.arrayBuffer()
+	* })
+	* ```
+	*/
+	arrayBuffer() {
+		return this.#cachedBody("arrayBuffer");
+	}
+	/**
+	* `.bytes()` parses the request body as a `Uint8Array`.
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.bytes()
+	* })
+	* ```
+	*/
+	bytes() {
+		return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+	}
+	/**
+	* Parses the request body as a `Blob`.
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.blob();
+	* });
+	* ```
+	*/
+	blob() {
+		return this.#cachedBody("blob");
+	}
+	/**
+	* Parses the request body as `FormData`.
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.formData();
+	* });
+	* ```
+	*/
+	formData() {
+		return this.#cachedBody("formData");
+	}
+	/**
+	* Adds validated data to the request.
+	*
+	* @param target - The target of the validation.
+	* @param data - The validated data to add.
+	*/
+	addValidatedData(target, data) {
+		(this.#validatedData ??= {})[target] = data;
+	}
+	valid(target) {
+		return this.#validatedData?.[target];
+	}
+	/**
+	* `.url` can get the request url strings.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const url = c.req.url // `http://localhost:8787/about/me`
+	*   ...
+	* })
+	* ```
+	*/
+	get url() {
+		return this.raw.url;
+	}
+	/**
+	* `.method` can get the method name of the request.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const method = c.req.method // `GET`
+	* })
+	* ```
+	*/
+	get method() {
+		return this.raw.method;
+	}
+	get [GET_MATCH_RESULT]() {
+		return this.#matchResult;
+	}
+	/**
+	* `.matchedRoutes` can return a matched route in the handler
+	*
+	* @deprecated
+	*
+	* Use matchedRoutes helper defined in "acryl-router/route" instead.
+	*
+	*
+	* @example
+	* ```ts
+	* app.use('*', async function logger(c, next) {
+	*   await next()
+	*   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+	*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+	*     console.log(
+	*       method,
+	*       ' ',
+	*       path,
+	*       ' '.repeat(Math.max(10 - path.length, 0)),
+	*       name,
+	*       i === c.req.routeIndex ? '<- respond from here' : ''
+	*     )
+	*   })
+	* })
+	* ```
+	*/
+	get matchedRoutes() {
+		return this.#matchResult[0].map(([[, route]]) => route);
+	}
+	/**
+	* `.routePath` can retrieve the path registered within the handler
+	*
+	* @deprecated
+	*
+	* Use routePath helper defined in "acryl-router/route" instead.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/posts/:id', (c) => {
+	*   return c.json({ path: c.req.routePath })
+	* })
+	* ```
+	*/
+	get routePath() {
+		return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+	}
+};
+/**
+* Clones a AcrylRequest's underlying raw Request object.
+*
+* This utility handles both consumed and unconsumed request bodies:
+* - If the request body hasn't been consumed, it uses the native `clone()` method
+* - If the request body has been consumed, it reconstructs a new Request using cached body data
+*
+* This is particularly useful when you need to:
+* - Process the same request body multiple times
+* - Pass requests to external services after validation
+*
+* @param req - The AcrylRequest object to clone
+* @returns A Promise that resolves to a new Request object with the same properties
+* @throws {HTTPException} If the request body was consumed directly via `req.raw`
+*   without using AcrylRequest methods (e.g., `req.json()`, `req.text()`), making it
+*   impossible to reconstruct the body from cache
+*
+* @example
+* ```ts
+* // Clone after consuming the body (e.g., after validation)
+* app.post('/forward',
+*   validator('json', (data) => data),
+*   async (c) => {
+*     const validated = c.req.valid('json')
+*     // Body has been consumed, but cloneRawRequest still works
+*     const clonedReq = await cloneRawRequest(c.req)
+*     return fetch('http://backend-service.com', clonedReq)
+*   }
+* )
+* ```
+*/
+const cloneRawRequest = async (req) => {
+	if (!req.raw.bodyUsed) return req.raw.clone();
+	const cacheKey = Object.keys(req.bodyCache)[0];
+	if (!cacheKey) throw new HTTPException(500, { message: "Cannot clone request: body was already consumed and not cached. Please use AcrylRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly." });
+	let body = await req[cacheKey]();
+	const headers = req.header();
+	if (cacheKey === "json") {
+		body = JSON.stringify(body);
+		delete headers["content-length"];
+	} else if (body instanceof FormData) {
+		delete headers["content-type"];
+		delete headers["content-length"];
+	}
+	const requestInit = {
+		body,
+		cache: req.raw.cache,
+		credentials: req.raw.credentials,
+		headers,
+		integrity: req.raw.integrity,
+		keepalive: req.raw.keepalive,
+		method: req.method,
+		mode: req.raw.mode,
+		redirect: req.raw.redirect,
+		referrer: req.raw.referrer,
+		referrerPolicy: req.raw.referrerPolicy,
+		signal: req.raw.signal
+	};
+	return new Request(req.url, requestInit);
+};
+//#endregion
+export { cloneRawRequest as n, AcrylRequest as t };