acrylblends 1.0.4 → 1.0.5

package/lib/request.js

@@ -1,323 +1,2 @@
-import { HTTPException } from "./http-exception.js";
-import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
-import { parseBody } from "./utils/body.js";
-import { getQueryParam, getQueryParams, tryDecodeURIComponent } from "./utils/url.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
+import { n as cloneRawRequest, t as AcrylRequest } from "./request-DvMgGtlW.js";
 export { AcrylRequest, cloneRawRequest };

package/lib/route-D8m-a2I1.js

@@ -0,0 +1,126 @@
+import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
+import { a as getPattern, d as splitRoutingPath } from "./url-BPh4d6j-.js";
+//#region ../../plugins/acryl-router/src/core/helper/route/index.ts
+/**
+* Get matched routes in the handler
+*
+* @param {Context} c - The context object
+* @returns An array of matched routes
+*
+* @example
+* ```ts
+* import { matchedRoutes } from 'acrylblends/route'
+*
+* app.use('*', async function logger(c, next) {
+*   await next()
+*   matchedRoutes(c).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' : ''
+*     )
+*   })
+* })
+* ```
+*/
+const matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
+/**
+* Get the route path registered within the handler
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The route path registered within the handler
+*
+* @example
+* ```ts
+* import { routePath } from 'acrylblends/route'
+*
+* app.use('*', (c, next) => {
+*   console.log(routePath(c)) // '*'
+*   console.log(routePath(c, -1)) // '/posts/:id'
+*   return next()
+* })
+*
+* app.get('/posts/:id', (c) => {
+*   return c.text(routePath(c)) // '/posts/:id'
+* })
+* ```
+*/
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+/**
+* Get the basePath of the as-is route specified by routing.
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath of the as-is route specified by routing.
+*
+* @example
+* ```ts
+* import { baseRoutePath } from 'acrylblends/route'
+*
+* const app = new Acryl()
+*
+* const subApp = new Acryl()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(baseRoutePath(c)) // '/:sub'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+/**
+* Get the basePath with embedded parameters
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath with embedded parameters.
+*
+* @example
+* ```ts
+* import { basePath } from 'acrylblends/route'
+*
+* const app = new Acryl()
+*
+* const subApp = new Acryl()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(basePath(c)) // '/requested-sub-app-path'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c, index) => {
+	index ??= c.req.routeIndex;
+	const cache = basePathCacheMap.get(c) || [];
+	if (typeof cache[index] === "string") return cache[index];
+	let result;
+	const rp = baseRoutePath(c, index);
+	if (!/[:*]/.test(rp)) result = rp;
+	else {
+		const paths = splitRoutingPath(rp);
+		const reqPath = c.req.path;
+		let basePathLength = 0;
+		for (let i = 0, len = paths.length; i < len; i++) {
+			const pattern = getPattern(paths[i], paths[i + 1]);
+			if (pattern) {
+				const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+				const restPath = reqPath.substring(basePathLength + 1);
+				const segment = restPath.split("/", 1)[0];
+				basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : "")).length;
+			} else basePathLength += paths[i].length;
+			basePathLength += 1;
+		}
+		result = reqPath.substring(0, basePathLength);
+	}
+	cache[index] = result;
+	basePathCacheMap.set(c, cache);
+	return result;
+};
+//#endregion
+export { routePath as i, baseRoutePath as n, matchedRoutes as r, basePath as t };

package/lib/route.js

@@ -1,126 +1,2 @@
-import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
-import { getPattern, splitRoutingPath } from "./utils/url.js";
-//#region ../../plugins/acryl-router/src/core/helper/route/index.ts
-/**
-* Get matched routes in the handler
-*
-* @param {Context} c - The context object
-* @returns An array of matched routes
-*
-* @example
-* ```ts
-* import { matchedRoutes } from 'acrylblends/route'
-*
-* app.use('*', async function logger(c, next) {
-*   await next()
-*   matchedRoutes(c).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' : ''
-*     )
-*   })
-* })
-* ```
-*/
-const matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
-/**
-* Get the route path registered within the handler
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The route path registered within the handler
-*
-* @example
-* ```ts
-* import { routePath } from 'acrylblends/route'
-*
-* app.use('*', (c, next) => {
-*   console.log(routePath(c)) // '*'
-*   console.log(routePath(c, -1)) // '/posts/:id'
-*   return next()
-* })
-*
-* app.get('/posts/:id', (c) => {
-*   return c.text(routePath(c)) // '/posts/:id'
-* })
-* ```
-*/
-const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
-/**
-* Get the basePath of the as-is route specified by routing.
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The basePath of the as-is route specified by routing.
-*
-* @example
-* ```ts
-* import { baseRoutePath } from 'acrylblends/route'
-*
-* const app = new Acryl()
-*
-* const subApp = new Acryl()
-* subApp.get('/posts/:id', (c) => {
-*   return c.text(baseRoutePath(c)) // '/:sub'
-* })
-*
-* app.route('/:sub', subApp)
-* ```
-*/
-const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
-/**
-* Get the basePath with embedded parameters
-*
-* @param {Context} c - The context object
-* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
-* @returns The basePath with embedded parameters.
-*
-* @example
-* ```ts
-* import { basePath } from 'acrylblends/route'
-*
-* const app = new Acryl()
-*
-* const subApp = new Acryl()
-* subApp.get('/posts/:id', (c) => {
-*   return c.text(basePath(c)) // '/requested-sub-app-path'
-* })
-*
-* app.route('/:sub', subApp)
-* ```
-*/
-const basePathCacheMap = /* @__PURE__ */ new WeakMap();
-const basePath = (c, index) => {
-	index ??= c.req.routeIndex;
-	const cache = basePathCacheMap.get(c) || [];
-	if (typeof cache[index] === "string") return cache[index];
-	let result;
-	const rp = baseRoutePath(c, index);
-	if (!/[:*]/.test(rp)) result = rp;
-	else {
-		const paths = splitRoutingPath(rp);
-		const reqPath = c.req.path;
-		let basePathLength = 0;
-		for (let i = 0, len = paths.length; i < len; i++) {
-			const pattern = getPattern(paths[i], paths[i + 1]);
-			if (pattern) {
-				const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
-				const restPath = reqPath.substring(basePathLength + 1);
-				const segment = restPath.split("/", 1)[0];
-				basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : "")).length;
-			} else basePathLength += paths[i].length;
-			basePathLength += 1;
-		}
-		result = reqPath.substring(0, basePathLength);
-	}
-	cache[index] = result;
-	basePathCacheMap.set(c, cache);
-	return result;
-};
-//#endregion
+import { i as routePath, n as baseRoutePath, r as matchedRoutes, t as basePath } from "./route-D8m-a2I1.js";
 export { basePath, baseRoutePath, matchedRoutes, routePath };

package/lib/router/linear-router.js

@@ -1,2 +1,2 @@
-import { t as LinearRouter } from "../linear-router-C3FPib6h.js";
+import { t as LinearRouter } from "../linear-router-CmZn_JLV.js";
 export { LinearRouter };

package/lib/router/pattern-router.js

@@ -1,2 +1,2 @@
-import { t as PatternRouter } from "../pattern-router-HZxjDGEQ.js";
+import { t as PatternRouter } from "../pattern-router-CJBecJBd.js";
 export { PatternRouter };

package/lib/router/reg-exp-router.js

@@ -1,2 +1,2 @@
-import { i as RegExpRouter, n as buildInitParams, r as serializeInitParams, t as PreparedRegExpRouter } from "../reg-exp-router-DC1R3qoY.js";
+import { i as RegExpRouter, n as buildInitParams, r as serializeInitParams, t as PreparedRegExpRouter } from "../reg-exp-router-C_WV84eV.js";
 export { PreparedRegExpRouter, RegExpRouter, buildInitParams, serializeInitParams };

package/lib/router/smart-router.js

@@ -1,2 +1,2 @@
-import { t as SmartRouter } from "../smart-router-C5CZ5XSM.js";
+import { t as SmartRouter } from "../smart-router-BjxkDQCE.js";
 export { SmartRouter };

package/lib/router/trie-router.js

@@ -1,2 +1,2 @@
-import { t as TrieRouter } from "../trie-router-CfFbapzL.js";
+import { t as TrieRouter } from "../trie-router-JydLKUa2.js";
 export { TrieRouter };

package/lib/router-Be_o6nFu.js

@@ -0,0 +1,35 @@
+//#region ../../plugins/acryl-router/src/core/router.ts
+/**
+* @module
+* This module provides types definitions and variables for the routers.
+*/
+/**
+* Constant representing all HTTP methods in uppercase.
+*/
+const METHOD_NAME_ALL = "ALL";
+/**
+* Constant representing all HTTP methods in lowercase.
+*/
+const METHOD_NAME_ALL_LOWERCASE = "all";
+/**
+* Array of supported HTTP methods.
+*/
+const METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"options",
+	"patch",
+	"query"
+];
+/**
+* Error message indicating that a route cannot be added because the matcher is already built.
+*/
+const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+/**
+* Error class representing an unsupported path error.
+*/
+var UnsupportedPathError = class extends Error {};
+//#endregion
+export { UnsupportedPathError as a, METHOD_NAME_ALL_LOWERCASE as i, METHODS as n, METHOD_NAME_ALL as r, MESSAGE_MATCHER_IS_ALREADY_BUILT as t };

package/lib/router.js

@@ -1,35 +1,2 @@
-//#region ../../plugins/acryl-router/src/core/router.ts
-/**
-* @module
-* This module provides types definitions and variables for the routers.
-*/
-/**
-* Constant representing all HTTP methods in uppercase.
-*/
-const METHOD_NAME_ALL = "ALL";
-/**
-* Constant representing all HTTP methods in lowercase.
-*/
-const METHOD_NAME_ALL_LOWERCASE = "all";
-/**
-* Array of supported HTTP methods.
-*/
-const METHODS = [
-	"get",
-	"post",
-	"put",
-	"delete",
-	"options",
-	"patch",
-	"query"
-];
-/**
-* Error message indicating that a route cannot be added because the matcher is already built.
-*/
-const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-/**
-* Error class representing an unsupported path error.
-*/
-var UnsupportedPathError = class extends Error {};
-//#endregion
+import { a as UnsupportedPathError, i as METHOD_NAME_ALL_LOWERCASE, n as METHODS, r as METHOD_NAME_ALL, t as MESSAGE_MATCHER_IS_ALREADY_BUILT } from "./router-Be_o6nFu.js";
 export { MESSAGE_MATCHER_IS_ALREADY_BUILT, METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, UnsupportedPathError };

package/lib/schema-validator-EK3cUUCt.js

@@ -0,0 +1,22 @@
+import { t as validator } from "./validator-Btiyt5VJ.js";
+//#region ../../plugins/acryl-router/src/helpers/schema-validator.ts
+const pathOf = (path) => (path ?? []).map((part) => String(typeof part === "object" ? part.key : part)).join(".");
+/**
+* The core `validator` driven by a Standard Schema. A failure answers 400 with `{ error, issues }`; success makes the parsed value the
+* handler's `c.req.valid(target)`, typed by the schema's output.
+*/
+function schemaValidator(target, schema) {
+	return validator(target, async (value, c) => {
+		const result = await schema["~standard"].validate(value);
+		if (result.issues !== void 0) return c.json({
+			error: `invalid ${target}`,
+			issues: result.issues.map((issue) => ({
+				message: issue.message,
+				path: pathOf(issue.path)
+			}))
+		}, 400);
+		return result.value;
+	});
+}
+//#endregion
+export { schemaValidator as t };