acrylblends 0.4.1 → 0.5.1

package/lib/context-DDO0cfuP.js

@@ -0,0 +1,365 @@
+import { AcrylRequest } from "./request.js";
+import { HtmlEscapedCallbackPhase, resolveCallback } from "./utils/html.js";
+//#region ../../plugins/acryl-router/src/core/context.ts
+const TEXT_PLAIN = "text/plain; charset=UTF-8";
+const setDefaultContentType = (contentType, headers) => {
+	return {
+		"Content-Type": contentType,
+		...headers
+	};
+};
+const createResponseInstance = (body, init) => new Response(body, init);
+var Context = class {
+	#rawRequest;
+	#req;
+	/**
+	* `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+	*
+	*
+	* @example
+	* ```ts
+	* // Environment object for Cloudflare Workers
+	* app.get('*', async c => {
+	*   const counter = c.env.COUNTER
+	* })
+	* ```
+	*/
+	env = {};
+	#var;
+	finalized = false;
+	/**
+	* `.error` can get the error object from the middleware if the Handler throws an error.
+	*
+	*
+	* @example
+	* ```ts
+	* app.use('*', async (c, next) => {
+	*   await next()
+	*   if (c.error) {
+	*     // do something...
+	*   }
+	* })
+	* ```
+	*/
+	error;
+	#status;
+	#executionCtx;
+	#res;
+	#layout;
+	#renderer;
+	#notFoundHandler;
+	#preparedHeaders;
+	#matchResult;
+	#path;
+	/**
+	* Creates an instance of the Context class.
+	*
+	* @param req - The Request object.
+	* @param options - Optional configuration options for the context.
+	*/
+	constructor(req, options) {
+		this.#rawRequest = req;
+		if (options) {
+			this.#executionCtx = options.executionCtx;
+			this.env = options.env;
+			this.#notFoundHandler = options.notFoundHandler;
+			this.#path = options.path;
+			this.#matchResult = options.matchResult;
+		}
+	}
+	/**
+	* `.req` is the instance of {@link AcrylRequest}.
+	*/
+	get req() {
+		this.#req ??= new AcrylRequest(this.#rawRequest, this.#path, this.#matchResult);
+		return this.#req;
+	}
+	/**
+	* The FetchEvent associated with the current request.
+	*
+	* @throws Will throw an error if the context does not have a FetchEvent.
+	*/
+	get event() {
+		if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
+		else throw Error("This context has no FetchEvent");
+	}
+	/**
+	* The ExecutionContext associated with the current request.
+	*
+	* @throws Will throw an error if the context does not have an ExecutionContext.
+	*/
+	get executionCtx() {
+		if (this.#executionCtx) return this.#executionCtx;
+		else throw Error("This context has no ExecutionContext");
+	}
+	/**
+	* The Response object for the current request.
+	*/
+	get res() {
+		return this.#res ||= createResponseInstance(null, { headers: this.#preparedHeaders ??= new Headers() });
+	}
+	/**
+	* Sets the Response object for the current request.
+	*
+	* @param _res - The Response object to set.
+	*/
+	set res(_res) {
+		if (this.#res && _res) {
+			_res = createResponseInstance(_res.body, _res);
+			for (const [k, v] of this.#res.headers.entries()) {
+				if (k === "content-type") continue;
+				if (k === "set-cookie") {
+					const cookies = this.#res.headers.getSetCookie();
+					_res.headers.delete("set-cookie");
+					for (const cookie of cookies) _res.headers.append("set-cookie", cookie);
+				} else _res.headers.set(k, v);
+			}
+		}
+		this.#res = _res;
+		this.finalized = true;
+	}
+	/**
+	* `.render()` can create a response within a layout.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/', (c) => {
+	*   return c.render('Hello!')
+	* })
+	* ```
+	*/
+	render = (...args) => {
+		this.#renderer ??= (content) => this.html(content);
+		return this.#renderer(...args);
+	};
+	/**
+	* Sets the layout for the response.
+	*
+	* @param layout - The layout to set.
+	* @returns The layout function.
+	*/
+	setLayout = (layout) => this.#layout = layout;
+	/**
+	* Gets the current layout for the response.
+	*
+	* @returns The current layout function.
+	*/
+	getLayout = () => this.#layout;
+	/**
+	* `.setRenderer()` can set the layout in the custom middleware.
+	*
+	*
+	* @example
+	* ```tsx
+	* app.use('*', async (c, next) => {
+	*   c.setRenderer((content) => {
+	*     return c.html(
+	*       <html>
+	*         <body>
+	*           <p>{content}</p>
+	*         </body>
+	*       </html>
+	*     )
+	*   })
+	*   await next()
+	* })
+	* ```
+	*/
+	setRenderer = (renderer) => {
+		this.#renderer = renderer;
+	};
+	/**
+	* `.header()` can set headers.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/welcome', (c) => {
+	*   // Set headers
+	*   c.header('X-Message', 'Hello!')
+	*   c.header('Content-Type', 'text/plain')
+	*
+	*   // Append multiple headers using the append option (e.g. Vary)
+	*   c.header('Vary', 'Accept-Encoding', { append: true })
+	*   c.header('Vary', 'User-Agent', { append: true })
+	*
+	*   return c.body('Thank you for coming')
+	* })
+	* ```
+	*/
+	header = (name, value, options) => {
+		if (this.finalized) this.#res = createResponseInstance(this.#res.body, this.#res);
+		const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+		if (value === void 0) headers.delete(name);
+		else if (options?.append) headers.append(name, value);
+		else headers.set(name, value);
+	};
+	status = (status) => {
+		this.#status = status;
+	};
+	/**
+	* `.set()` can set the value specified by the key.
+	*
+	*
+	* @example
+	* ```ts
+	* app.use('*', async (c, next) => {
+	*   c.set('message', 'Acryl is hot!!')
+	*   await next()
+	* })
+	* ```
+	*/
+	set = (key, value) => {
+		this.#var ??= /* @__PURE__ */ new Map();
+		this.#var.set(key, value);
+	};
+	/**
+	* `.get()` can use the value specified by the key.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/', (c) => {
+	*   const message = c.get('message')
+	*   return c.text(`The message is "${message}"`)
+	* })
+	* ```
+	*/
+	get = (key) => {
+		return this.#var ? this.#var.get(key) : void 0;
+	};
+	/**
+	* `.var` can access the value of a variable.
+	*
+	*
+	* @example
+	* ```ts
+	* const result = c.var.client.oneMethod()
+	* ```
+	*/
+	get var() {
+		if (!this.#var) return {};
+		return Object.fromEntries(this.#var);
+	}
+	#newResponse(data, arg, headers) {
+		let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+		if (typeof arg === "object" && arg.headers) {
+			responseHeaders ??= new Headers();
+			for (const [key, value] of new Headers(arg.headers)) if (key === "set-cookie") responseHeaders.append(key, value);
+			else responseHeaders.set(key, value);
+		}
+		if (headers) {
+			if (!responseHeaders) {
+				let count = 0;
+				for (const k in headers) if (++count > 1 || typeof headers[k] !== "string") {
+					responseHeaders = new Headers();
+					break;
+				}
+			}
+			if (responseHeaders) for (const k in headers) {
+				const v = headers[k];
+				if (typeof v === "string") responseHeaders.set(k, v);
+				else {
+					responseHeaders.delete(k);
+					for (const v2 of v) responseHeaders.append(k, v2);
+				}
+			}
+		}
+		const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+		return createResponseInstance(data, {
+			status,
+			headers: responseHeaders ?? headers
+		});
+	}
+	newResponse = (...args) => this.#newResponse(...args);
+	/**
+	* `.body()` can return the HTTP response.
+	* You can set headers with `.header()` and set HTTP status code with `.status`.
+	* This can also be set in `.text()`, `.json()` and so on.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/welcome', (c) => {
+	*   // Set headers
+	*   c.header('X-Message', 'Hello!')
+	*   c.header('Content-Type', 'text/plain')
+	*   // Set HTTP status code
+	*   c.status(201)
+	*
+	*   // Return the response body
+	*   return c.body('Thank you for coming')
+	* })
+	* ```
+	*/
+	body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+	/**
+	* `.text()` can render text as `Content-Type:text/plain`.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/say', (c) => {
+	*   return c.text('Hello!')
+	* })
+	* ```
+	*/
+	text = (text, arg, headers) => {
+		return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+	};
+	/**
+	* `.json()` can render JSON as `Content-Type:application/json`.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/api', (c) => {
+	*   return c.json({ message: 'Hello!' })
+	* })
+	* ```
+	*/
+	json = (object, arg, headers) => {
+		return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+	};
+	html = (html, arg, headers) => {
+		const res = (html) => this.#newResponse(html, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+		return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+	};
+	/**
+	* `.redirect()` can Redirect, default status code is 302.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/redirect', (c) => {
+	*   return c.redirect('/')
+	* })
+	* app.get('/redirect-permanently', (c) => {
+	*   return c.redirect('/', 301)
+	* })
+	* ```
+	*/
+	redirect = (location, status) => {
+		const locationString = String(location);
+		this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+		return this.newResponse(null, status ?? 302);
+	};
+	/**
+	* `.notFound()` can return the Not Found Response.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/notfound', (c) => {
+	*   return c.notFound()
+	* })
+	* ```
+	*/
+	notFound = () => {
+		this.#notFoundHandler ??= () => createResponseInstance();
+		return this.#notFoundHandler(this);
+	};
+};
+//#endregion
+export { TEXT_PLAIN as n, Context as t };

package/lib/context-storage.d.ts

@@ -0,0 +1,38 @@
+import { I as MiddlewareHandler, _ as Env, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/context-storage/index.d.ts
+/**
+ * Context Storage Middleware for Acryl.
+ *
+ *
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * type Env = {
+ *   Variables: {
+ *     message: string
+ *   }
+ * }
+ *
+ * const app = new Acryl<Env>()
+ *
+ * app.use(contextStorage())
+ *
+ * app.use(async (c, next) => {
+ *   c.set('message', 'Acryl is hot!!')
+ *   await next()
+ * })
+ *
+ * app.get('/', async (c) => c.text(getMessage()))
+ *
+ * const getMessage = () => {
+ *   return getContext<Env>().var.message
+ * }
+ * ```
+ */
+declare const contextStorage: () => MiddlewareHandler;
+declare const tryGetContext: <E extends Env = Env>() => Context<E> | undefined;
+declare const getContext: <E extends Env = Env>() => Context<E>;
+//#endregion
+export { contextStorage, getContext, tryGetContext };

package/lib/context-storage.js

@@ -0,0 +1,52 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../../plugins/acryl-router/src/core/middleware/context-storage/index.ts
+/**
+* @module
+* Context Storage Middleware for Acryl.
+*/
+const asyncLocalStorage = new AsyncLocalStorage();
+/**
+* Context Storage Middleware for Acryl.
+*
+*
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* type Env = {
+*   Variables: {
+*     message: string
+*   }
+* }
+*
+* const app = new Acryl<Env>()
+*
+* app.use(contextStorage())
+*
+* app.use(async (c, next) => {
+*   c.set('message', 'Acryl is hot!!')
+*   await next()
+* })
+*
+* app.get('/', async (c) => c.text(getMessage()))
+*
+* const getMessage = () => {
+*   return getContext<Env>().var.message
+* }
+* ```
+*/
+const contextStorage = () => {
+	return async function contextStorage(c, next) {
+		await asyncLocalStorage.run(c, next);
+	};
+};
+const tryGetContext = () => {
+	return asyncLocalStorage.getStore();
+};
+const getContext = () => {
+	const context = tryGetContext();
+	if (!context) throw new Error("Context is not available");
+	return context;
+};
+//#endregion
+export { contextStorage, getContext, tryGetContext };

package/lib/cookie-ClMaKDQf.d.ts

@@ -0,0 +1,40 @@
+import { n as BufferSource } from "./types-CwrQjlaM.js";
+
+//#region ../../plugins/acryl-router/src/core/utils/cookie.d.ts
+type Cookie = Record<string, string>;
+type SignedCookie = Record<string, string | false>;
+type PartitionedCookieConstraint = {
+  partitioned: true;
+  secure: true;
+} | {
+  partitioned?: boolean;
+  secure?: boolean;
+};
+type SecureCookieConstraint = {
+  secure: true;
+};
+type HostCookieConstraint = {
+  secure: true;
+  path: '/';
+  domain?: undefined;
+};
+type CookieOptions = {
+  domain?: string;
+  expires?: Date;
+  httpOnly?: boolean;
+  maxAge?: number;
+  path?: string;
+  secure?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None' | 'strict' | 'lax' | 'none';
+  partitioned?: boolean;
+  priority?: 'Low' | 'Medium' | 'High' | 'low' | 'medium' | 'high';
+  prefix?: CookiePrefixOptions;
+} & PartitionedCookieConstraint;
+type CookiePrefixOptions = 'host' | 'secure';
+type CookieConstraint<Name> = Name extends `__Secure-${string}` ? CookieOptions & SecureCookieConstraint : Name extends `__Host-${string}` ? CookieOptions & HostCookieConstraint : CookieOptions;
+declare const parse: (cookie: string, name?: string) => Cookie;
+declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
+declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name>) => string;
+declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
+//#endregion
+export { SignedCookie as a, serialize as c, CookiePrefixOptions as i, serializeSigned as l, CookieConstraint as n, parse as o, CookieOptions as r, parseSigned as s, Cookie as t };

package/lib/cookie.d.ts

@@ -0,0 +1,24 @@
+import { t as Context } from "./context-Bm7rI-oK.js";
+import { n as BufferSource } from "./types-CwrQjlaM.js";
+import { a as SignedCookie, i as CookiePrefixOptions, r as CookieOptions, t as Cookie } from "./cookie-ClMaKDQf.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/cookie/index.d.ts
+interface GetCookie {
+  (c: Context, key: string): string | undefined;
+  (c: Context): Cookie;
+  (c: Context, key: string, prefixOptions?: CookiePrefixOptions): string | undefined;
+}
+interface GetSignedCookie {
+  (c: Context, secret: string | BufferSource, key: string): Promise<string | undefined | false>;
+  (c: Context, secret: string | BufferSource): Promise<SignedCookie>;
+  (c: Context, secret: string | BufferSource, key: string, prefixOptions?: CookiePrefixOptions): Promise<string | undefined | false>;
+}
+declare const getCookie: GetCookie;
+declare const getSignedCookie: GetSignedCookie;
+declare const generateCookie: (name: string, value: string, opt?: CookieOptions) => string;
+declare const setCookie: (c: Context, name: string, value: string, opt?: CookieOptions) => void;
+declare const generateSignedCookie: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
+declare const setSignedCookie: (c: Context, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
+declare const deleteCookie: (c: Context, name: string, opt?: CookieOptions) => string | undefined;
+//#endregion
+export { deleteCookie, generateCookie, generateSignedCookie, getCookie, getSignedCookie, setCookie, setSignedCookie };

package/lib/cookie.js

@@ -0,0 +1,82 @@
+import { parse, parseSigned, serialize, serializeSigned } from "./utils/cookie.js";
+//#region ../../plugins/acryl-router/src/core/helper/cookie/index.ts
+const getCookie = (c, key, prefix) => {
+	const cookie = c.req.raw.headers.get("Cookie");
+	if (typeof key === "string") {
+		if (!cookie) return;
+		let finalKey = key;
+		if (prefix === "secure") finalKey = "__Secure-" + key;
+		else if (prefix === "host") finalKey = "__Host-" + key;
+		return parse(cookie, finalKey)[finalKey];
+	}
+	if (!cookie) return {};
+	return parse(cookie);
+};
+const getSignedCookie = async (c, secret, key, prefix) => {
+	const cookie = c.req.raw.headers.get("Cookie");
+	if (typeof key === "string") {
+		if (!cookie) return;
+		let finalKey = key;
+		if (prefix === "secure") finalKey = "__Secure-" + key;
+		else if (prefix === "host") finalKey = "__Host-" + key;
+		return (await parseSigned(cookie, secret, finalKey))[finalKey];
+	}
+	if (!cookie) return {};
+	return await parseSigned(cookie, secret);
+};
+const generateCookie = (name, value, opt) => {
+	let cookie;
+	if (opt?.prefix === "secure") cookie = serialize("__Secure-" + name, value, {
+		path: "/",
+		...opt,
+		secure: true
+	});
+	else if (opt?.prefix === "host") cookie = serialize("__Host-" + name, value, {
+		...opt,
+		path: "/",
+		secure: true,
+		domain: void 0
+	});
+	else cookie = serialize(name, value, {
+		path: "/",
+		...opt
+	});
+	return cookie;
+};
+const setCookie = (c, name, value, opt) => {
+	const cookie = generateCookie(name, value, opt);
+	c.header("Set-Cookie", cookie, { append: true });
+};
+const generateSignedCookie = async (name, value, secret, opt) => {
+	let cookie;
+	if (opt?.prefix === "secure") cookie = await serializeSigned("__Secure-" + name, value, secret, {
+		path: "/",
+		...opt,
+		secure: true
+	});
+	else if (opt?.prefix === "host") cookie = await serializeSigned("__Host-" + name, value, secret, {
+		...opt,
+		path: "/",
+		secure: true,
+		domain: void 0
+	});
+	else cookie = await serializeSigned(name, value, secret, {
+		path: "/",
+		...opt
+	});
+	return cookie;
+};
+const setSignedCookie = async (c, name, value, secret, opt) => {
+	const cookie = await generateSignedCookie(name, value, secret, opt);
+	c.header("set-cookie", cookie, { append: true });
+};
+const deleteCookie = (c, name, opt) => {
+	const deletedCookie = getCookie(c, name, opt?.prefix);
+	setCookie(c, name, "", {
+		...opt,
+		maxAge: 0
+	});
+	return deletedCookie;
+};
+//#endregion
+export { deleteCookie, generateCookie, generateSignedCookie, getCookie, getSignedCookie, setCookie, setSignedCookie };

package/lib/cors.d.ts

@@ -0,0 +1,52 @@
+import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/cors/index.d.ts
+type CORSOptions = {
+  origin?: string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null);
+  allowMethods?: string[] | ((origin: string, c: Context) => Promise<string[]> | string[]);
+  allowHeaders?: string[];
+  maxAge?: number;
+  credentials?: boolean;
+  exposeHeaders?: string[];
+};
+/**
+ * CORS Middleware for Acryl.
+ *
+ *
+ * @param {CORSOptions} [options] - The options for the CORS middleware.
+ * @param {string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
+ * @param {string[] | ((origin: string, c: Context) => Promise<string[]> | string[])} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH', 'QUERY']] - The value of "Access-Control-Allow-Methods" CORS header.
+ * @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
+ * @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
+ * @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
+ * @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.use('/api/*', cors())
+ * app.use(
+ *   '/api2/*',
+ *   cors({
+ *     origin: 'http://example.com',
+ *     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
+ *     allowMethods: ['POST', 'GET', 'OPTIONS'],
+ *     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+ *     maxAge: 600,
+ *     credentials: true,
+ *   })
+ * )
+ *
+ * app.all('/api/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * app.all('/api2/abc', (c) => {
+ *   return c.json({ success: true })
+ * })
+ * ```
+ */
+declare const cors: (options?: CORSOptions) => MiddlewareHandler;
+//#endregion
+export { cors };