acrylblends 0.4.0 → 0.5.0

package/lib/timing.d.ts

@@ -0,0 +1,130 @@
+import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/timing/timing.d.ts
+type TimingVariables = {
+  metric?: {
+    headers: string[];
+    timers: Map<string, Timer>;
+  };
+};
+interface Timer {
+  description?: string;
+  start: number;
+}
+interface TimingOptions {
+  total?: boolean;
+  enabled?: boolean | ((c: Context) => boolean);
+  totalDescription?: string;
+  autoEnd?: boolean;
+  crossOrigin?: boolean | string | ((c: Context) => boolean | string);
+}
+/**
+ * Server-Timing Middleware for Acryl.
+ *
+ *
+ * @param {TimingOptions} [config] - The options for the timing middleware.
+ * @param {boolean} [config.total=true] - Show the total response time.
+ * @param {boolean | ((c: Context) => boolean)} [config.enabled=true] - Whether timings should be added to the headers or not.
+ * @param {string} [config.totalDescription=Total Response Time] - Description for the total response time.
+ * @param {boolean} [config.autoEnd=true] - If `startTime()` should end automatically at the end of the request.
+ * @param {boolean | string | ((c: Context) => boolean | string)} [config.crossOrigin=false] - The origin this timings header should be readable.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * // add the middleware to your router
+ * app.use(timing());
+ *
+ * app.get('/', async (c) => {
+ *   // add custom metrics
+ *   setMetric(c, 'region', 'europe-west3')
+ *
+ *   // add custom metrics with timing, must be in milliseconds
+ *   setMetric(c, 'custom', 23.8, 'My custom Metric')
+ *
+ *   // start a new timer
+ *   startTime(c, 'db');
+ *
+ *   const data = await db.findMany(...);
+ *
+ *   // end the timer
+ *   endTime(c, 'db');
+ *
+ *   return c.json({ response: data });
+ * });
+ * ```
+ */
+declare const timing: (config?: TimingOptions) => MiddlewareHandler;
+interface SetMetric {
+  (c: Context, name: string, value: number, description?: string, precision?: number): void;
+  (c: Context, name: string, description?: string): void;
+}
+/**
+ * Set a metric for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the metric.
+ * @param {number | string} [valueDescription] - The value or description of the metric.
+ * @param {string} [description] - The description of the metric.
+ * @param {number} [precision] - The precision of the metric value.
+ *
+ * @example
+ * ```ts
+ * setMetric(c, 'region', 'europe-west3')
+ * setMetric(c, 'custom', 23.8, 'My custom Metric')
+ * ```
+ */
+declare const setMetric: SetMetric;
+/**
+ * Start a timer for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {string} [description] - The description of the timer.
+ *
+ * @example
+ * ```ts
+ * startTime(c, 'db')
+ * ```
+ */
+declare const startTime: (c: Context, name: string, description?: string) => void;
+/**
+ * End a timer for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {number} [precision] - The precision of the timer value.
+ *
+ * @example
+ * ```ts
+ * endTime(c, 'db')
+ * ```
+ */
+declare const endTime: (c: Context, name: string, precision?: number) => void;
+/**
+ * Wrap a Promise to capture its duration.
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {Promise<T>} callable - The Promise to time.
+ * @param {string} [description] - The description of the timer.
+ * @param {number} [precision] - The precision of the timer value.
+ *
+ * @example
+ * ```ts
+ *   // Instead of this:
+ *   const data = await db.findMany(...);
+ *
+ *   // do this:
+ *   const data = await wrapTime(c, 'query', db.findMany(...));
+ * ```
+ * */
+declare function wrapTime<T>(c: Context, name: string, callable: Promise<T>, description?: string, precision?: number): Promise<T>;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/middleware/timing/index.d.ts
+declare module '../../context.ts' {
+  interface ContextVariableMap extends TimingVariables {}
+}
+//#endregion
+export { type TimingVariables, endTime, setMetric, startTime, timing, wrapTime };

package/lib/timing.js

@@ -0,0 +1,183 @@
+//#region ../../plugins/acryl-router/src/core/middleware/timing/timing.ts
+const getTime = () => {
+	try {
+		return performance.now();
+	} catch {}
+	return Date.now();
+};
+/**
+* Server-Timing Middleware for Acryl.
+*
+*
+* @param {TimingOptions} [config] - The options for the timing middleware.
+* @param {boolean} [config.total=true] - Show the total response time.
+* @param {boolean | ((c: Context) => boolean)} [config.enabled=true] - Whether timings should be added to the headers or not.
+* @param {string} [config.totalDescription=Total Response Time] - Description for the total response time.
+* @param {boolean} [config.autoEnd=true] - If `startTime()` should end automatically at the end of the request.
+* @param {boolean | string | ((c: Context) => boolean | string)} [config.crossOrigin=false] - The origin this timings header should be readable.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* // add the middleware to your router
+* app.use(timing());
+*
+* app.get('/', async (c) => {
+*   // add custom metrics
+*   setMetric(c, 'region', 'europe-west3')
+*
+*   // add custom metrics with timing, must be in milliseconds
+*   setMetric(c, 'custom', 23.8, 'My custom Metric')
+*
+*   // start a new timer
+*   startTime(c, 'db');
+*
+*   const data = await db.findMany(...);
+*
+*   // end the timer
+*   endTime(c, 'db');
+*
+*   return c.json({ response: data });
+* });
+* ```
+*/
+const timing = (config) => {
+	const options = {
+		total: true,
+		enabled: true,
+		totalDescription: "Total Response Time",
+		autoEnd: true,
+		crossOrigin: false,
+		...config
+	};
+	return async function timing(c, next) {
+		const headers = [];
+		const timers = /* @__PURE__ */ new Map();
+		if (c.get("metric")) return await next();
+		c.set("metric", {
+			headers,
+			timers
+		});
+		if (options.total) startTime(c, "total", options.totalDescription);
+		await next();
+		if (options.total) endTime(c, "total");
+		if (options.autoEnd) timers.forEach((_, key) => {
+			endTime(c, key);
+		});
+		if (typeof options.enabled === "function" ? options.enabled(c) : options.enabled) {
+			c.res.headers.append("Server-Timing", headers.join(","));
+			const crossOrigin = typeof options.crossOrigin === "function" ? options.crossOrigin(c) : options.crossOrigin;
+			if (crossOrigin) c.res.headers.append("Timing-Allow-Origin", typeof crossOrigin === "string" ? crossOrigin : "*");
+		}
+	};
+};
+/**
+* Set a metric for the timing middleware.
+*
+* @param {Context} c - The context of the request.
+* @param {string} name - The name of the metric.
+* @param {number | string} [valueDescription] - The value or description of the metric.
+* @param {string} [description] - The description of the metric.
+* @param {number} [precision] - The precision of the metric value.
+*
+* @example
+* ```ts
+* setMetric(c, 'region', 'europe-west3')
+* setMetric(c, 'custom', 23.8, 'My custom Metric')
+* ```
+*/
+const setMetric = (c, name, valueDescription, description, precision) => {
+	const metrics = c.get("metric");
+	if (!metrics) {
+		console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+		return;
+	}
+	if (typeof valueDescription === "number") {
+		const dur = valueDescription.toFixed(precision || 1);
+		const metric = description ? `${name};dur=${dur};desc="${description}"` : `${name};dur=${dur}`;
+		metrics.headers.push(metric);
+	} else {
+		const metric = valueDescription ? `${name};desc="${valueDescription}"` : `${name}`;
+		metrics.headers.push(metric);
+	}
+};
+/**
+* Start a timer for the timing middleware.
+*
+* @param {Context} c - The context of the request.
+* @param {string} name - The name of the timer.
+* @param {string} [description] - The description of the timer.
+*
+* @example
+* ```ts
+* startTime(c, 'db')
+* ```
+*/
+const startTime = (c, name, description) => {
+	const metrics = c.get("metric");
+	if (!metrics) {
+		console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+		return;
+	}
+	metrics.timers.set(name, {
+		description,
+		start: getTime()
+	});
+};
+/**
+* End a timer for the timing middleware.
+*
+* @param {Context} c - The context of the request.
+* @param {string} name - The name of the timer.
+* @param {number} [precision] - The precision of the timer value.
+*
+* @example
+* ```ts
+* endTime(c, 'db')
+* ```
+*/
+const endTime = (c, name, precision) => {
+	const metrics = c.get("metric");
+	if (!metrics) {
+		console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+		return;
+	}
+	const timer = metrics.timers.get(name);
+	if (!timer) {
+		console.warn(`Timer "${name}" does not exist!`);
+		return;
+	}
+	const { description, start } = timer;
+	const duration = getTime() - start;
+	setMetric(c, name, duration, description, precision);
+	metrics.timers.delete(name);
+};
+/**
+* Wrap a Promise to capture its duration.
+* @param {Context} c - The context of the request.
+* @param {string} name - The name of the timer.
+* @param {Promise<T>} callable - The Promise to time.
+* @param {string} [description] - The description of the timer.
+* @param {number} [precision] - The precision of the timer value.
+*
+* @example
+* ```ts
+*   // Instead of this:
+*   const data = await db.findMany(...);
+*
+*   // do this:
+*   const data = await wrapTime(c, 'query', db.findMany(...));
+* ```
+* */
+async function wrapTime(c, name, callable, description, precision) {
+	startTime(c, name, description);
+	try {
+		return await callable;
+	} finally {
+		endTime(c, name, precision);
+	}
+}
+//#endregion
+export { endTime, setMetric, startTime, timing, wrapTime };

package/lib/trailing-slash.d.ts

@@ -0,0 +1,91 @@
+import { I as MiddlewareHandler } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/trailing-slash/index.d.ts
+type TrimTrailingSlashOptions = {
+  /**
+   * If `true`, the middleware will always redirect requests with a trailing slash
+   * before executing handlers.
+   * This is useful for routes with wildcards (`*`).
+   * If `false` (default), it will only redirect when the route is not found (404).
+   * @default false
+   */
+  alwaysRedirect?: boolean;
+};
+/**
+ * Trailing Slash Middleware for Acryl.
+ *
+ *
+ * @param {TrimTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.use(trimTrailingSlash())
+ * app.get('/about/me/', (c) => c.text('With Trailing Slash'))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new Acryl()
+ *
+ * app.use(trimTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+declare const trimTrailingSlash: (options?: TrimTrailingSlashOptions) => MiddlewareHandler;
+type AppendTrailingSlashOptions = {
+  /**
+   * If `true`, the middleware will always redirect requests without a trailing slash
+   * before executing handlers.
+   * This is useful for routes with wildcards (`*`).
+   * If `false` (default), it will only redirect when the route is not found (404).
+   * @default false
+   */
+  alwaysRedirect?: boolean;
+  /**
+   * A function that determines whether to skip the redirect for a given path.
+   * If the function returns `true`, the redirect will be skipped.
+   * @param path - The request path
+   * @returns `true` to skip the redirect
+   *
+   * @example
+   * ```ts
+   * // Skip redirect for paths with file extensions
+   * app.use(appendTrailingSlash({
+   *   alwaysRedirect: true,
+   *   skip: (path) => /\.\w+$/.test(path),
+   * }))
+   * ```
+   */
+  skip?: (path: string) => boolean;
+};
+/**
+ * Append trailing slash middleware for Acryl.
+ * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
+ *
+ *
+ * @param {AppendTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.use(appendTrailingSlash())
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new Acryl()
+ *
+ * app.use(appendTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+declare const appendTrailingSlash: (options?: AppendTrailingSlashOptions) => MiddlewareHandler;
+//#endregion
+export { appendTrailingSlash, trimTrailingSlash };

package/lib/trailing-slash.js

@@ -0,0 +1,85 @@
+//#region ../../plugins/acryl-router/src/core/middleware/trailing-slash/index.ts
+/**
+* Trailing Slash Middleware for Acryl.
+*
+*
+* @param {TrimTrailingSlashOptions} options - The options for the middleware.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(trimTrailingSlash())
+* app.get('/about/me/', (c) => c.text('With Trailing Slash'))
+* ```
+*
+* @example
+* ```ts
+* // With alwaysRedirect option for wildcard routes
+* const app = new Acryl()
+*
+* app.use(trimTrailingSlash({ alwaysRedirect: true }))
+* app.get('/my-path/*', (c) => c.text('Wildcard route'))
+* ```
+*/
+const trimTrailingSlash = (options) => {
+	return async function trimTrailingSlash(c, next) {
+		if (options?.alwaysRedirect) {
+			if ((c.req.method === "GET" || c.req.method === "HEAD") && c.req.path !== "/" && c.req.path.at(-1) === "/") {
+				const url = new URL(c.req.url);
+				url.pathname = url.pathname.substring(0, url.pathname.length - 1);
+				return c.redirect(url.toString(), 301);
+			}
+		}
+		await next();
+		if (!options?.alwaysRedirect && c.res.status === 404 && (c.req.method === "GET" || c.req.method === "HEAD") && c.req.path !== "/" && c.req.path.at(-1) === "/") {
+			const url = new URL(c.req.url);
+			url.pathname = url.pathname.substring(0, url.pathname.length - 1);
+			c.res = c.redirect(url.toString(), 301);
+		}
+	};
+};
+/**
+* Append trailing slash middleware for Acryl.
+* Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
+*
+*
+* @param {AppendTrailingSlashOptions} options - The options for the middleware.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(appendTrailingSlash())
+* ```
+*
+* @example
+* ```ts
+* // With alwaysRedirect option for wildcard routes
+* const app = new Acryl()
+*
+* app.use(appendTrailingSlash({ alwaysRedirect: true }))
+* app.get('/my-path/*', (c) => c.text('Wildcard route'))
+* ```
+*/
+const appendTrailingSlash = (options) => {
+	return async function appendTrailingSlash(c, next) {
+		if (options?.alwaysRedirect) {
+			if ((c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/" && !options.skip?.(c.req.path)) {
+				const url = new URL(c.req.url);
+				url.pathname += "/";
+				return c.redirect(url.toString(), 301);
+			}
+		}
+		await next();
+		if (!options?.alwaysRedirect && c.res.status === 404 && (c.req.method === "GET" || c.req.method === "HEAD") && c.req.path.at(-1) !== "/" && !options?.skip?.(c.req.path)) {
+			const url = new URL(c.req.url);
+			url.pathname += "/";
+			c.res = c.redirect(url.toString(), 301);
+		}
+	};
+};
+//#endregion
+export { appendTrailingSlash, trimTrailingSlash };

package/lib/trie-router-CfFbapzL.js

@@ -0,0 +1,146 @@
+import { checkOptionalParameter, getPattern, splitPath, splitRoutingPath } from "./utils/url.js";
+import "./router.js";
+import { t as createNullObject } from "./utils-dw8lxqjL.js";
+//#region ../../plugins/acryl-router/src/core/router/trie-router/node.ts
+const emptyParams = createNullObject();
+let order = 0;
+var Node = class Node {
+	#methods = [];
+	#children = createNullObject();
+	#patterns = [];
+	#pattern;
+	#params = emptyParams;
+	insert(method, path, handler) {
+		let curNode = this;
+		const parts = splitRoutingPath(path);
+		const possibleKeys = /* @__PURE__ */ new Set();
+		let i = 0;
+		for (const p of parts) {
+			const nextP = parts[++i];
+			const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+			const isParam = Array.isArray(pattern);
+			const key = isParam ? pattern[0] : pattern || p;
+			const child = curNode.#children[key] ||= new Node();
+			if (pattern && !child.#pattern) {
+				child.#pattern = pattern;
+				curNode.#patterns.push(child);
+			}
+			curNode = child;
+			if (isParam) possibleKeys.add(pattern[1]);
+		}
+		curNode.#methods.push({ [method]: {
+			handler,
+			possibleKeys: [...possibleKeys],
+			score: ++order
+		} });
+	}
+	#pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+		for (let i = 0, len = node.#methods.length; i < len; i++) {
+			const m = node.#methods[i];
+			const handlerSet = m[method] || m["ALL"];
+			if (handlerSet) {
+				handlerSet.params = createNullObject();
+				handlerSets.push(handlerSet);
+				for (let i = 0, len = handlerSet.possibleKeys.length; i < len; i++) {
+					const key = handlerSet.possibleKeys[i];
+					handlerSet.params[key] = params?.[key] && !i ? params[key] : nodeParams[key] ?? params?.[key];
+				}
+			}
+		}
+	}
+	search(method, path) {
+		const handlerSets = [];
+		this.#params = emptyParams;
+		let curNodes = [this];
+		const parts = splitPath(path);
+		const curNodesQueue = [];
+		const len = parts.length;
+		let partOffsets = null;
+		for (let i = 0; i < len; i++) {
+			const part = parts[i];
+			const isLast = i === len - 1;
+			const tempNodes = [];
+			for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+				const node = curNodes[j];
+				const nextNode = node.#children[part];
+				if (nextNode) {
+					nextNode.#params = node.#params;
+					if (isLast) {
+						if (nextNode.#children["*"]) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+						this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+					} else tempNodes.push(nextNode);
+				}
+				for (const child of node.#patterns) {
+					const pattern = child.#pattern;
+					const params = node.#params === emptyParams ? {} : { ...node.#params };
+					if (typeof pattern === "string") {
+						if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+							this.#pushHandlerSets(handlerSets, child, method, node.#params);
+							if (pattern === "*") {
+								child.#params = params;
+								tempNodes.push(child);
+							}
+						}
+						continue;
+					}
+					const [, name, matcher] = pattern;
+					if (!part && matcher === true) continue;
+					if (matcher !== true) {
+						if (!partOffsets) {
+							partOffsets = [];
+							let offset = path[0] === "/" ? 1 : 0;
+							for (let p = 0; p < len; p++) {
+								partOffsets[p] = offset;
+								offset += parts[p].length + 1;
+							}
+						}
+						const restPathString = path.slice(partOffsets[i]);
+						const m = matcher.exec(restPathString);
+						if (m) {
+							if (!Object.hasOwn(params, name)) params[name] = m[0];
+							this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+							if (m[0].length === restPathString.length && child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+							for (const _ in child.#children) {
+								child.#params = params;
+								const componentCount = m[0].match(/\//g)?.length ?? 0;
+								(curNodesQueue[componentCount] ||= []).push(child);
+								break;
+							}
+							continue;
+						}
+					}
+					if (matcher === true || matcher.test(part)) {
+						if (!Object.hasOwn(params, name)) params[name] = part;
+						if (isLast) {
+							this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+							if (child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+						} else {
+							child.#params = params;
+							tempNodes.push(child);
+						}
+					}
+				}
+			}
+			const shifted = curNodesQueue.shift();
+			curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+		}
+		if (handlerSets[1]) handlerSets.sort((a, b) => {
+			return a.score - b.score;
+		});
+		return [handlerSets.map(({ handler, params }) => [handler, params])];
+	}
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/router/trie-router/router.ts
+var TrieRouter = class {
+	name = "TrieRouter";
+	#node = new Node();
+	add(method, path, handler) {
+		for (const result of checkOptionalParameter(path) || [path]) this.#node.insert(method, result, handler);
+	}
+	match(method, path) {
+		return this.#node.search(method, path);
+	}
+};
+//#endregion
+export { TrieRouter as t };

package/lib/types-CDO6I3B0.d.ts

@@ -0,0 +1,40 @@
+import { t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/conninfo/types.d.ts
+type AddressType = 'IPv6' | 'IPv4' | undefined;
+type NetAddrInfo = {
+  /**
+   * Transport protocol type
+   */
+  transport?: 'tcp' | 'udp';
+  /**
+   * Transport port number
+   */
+  port?: number;
+  address?: string;
+  addressType?: AddressType;
+} & ({
+  /**
+   * Host name such as IP Addr
+   */
+  address: string;
+  /**
+   * Host name type
+   */
+  addressType: AddressType;
+} | {});
+/**
+ * HTTP Connection information
+ */
+interface ConnInfo {
+  /**
+   * Remote information
+   */
+  remote: NetAddrInfo;
+}
+/**
+ * Helper type
+ */
+type GetConnInfo = (c: Context) => ConnInfo;
+//#endregion
+export { NetAddrInfo as i, ConnInfo as n, GetConnInfo as r, AddressType as t };