acrylblends 0.6.2 → 0.6.3

package/lib/basic-auth.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/basic-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/bearer-auth.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, _ as Env, t as Context } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler, _ as Env, t as Context } from "./context-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/body-limit.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.d.ts
 type OnError = (c: Context) => Response | Promise<Response>;

package/lib/cache.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
 import { c as StatusCode } from "./http-status-DaAwGAFL.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/cache/index.d.ts

package/lib/client.d.ts

@@ -1,3 +1,3 @@
-import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-Bd29gh2o.js";
-import { n as DetailedError, r as hc, t as parseResponse } from "./index-m12zcmph.js";
+import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-CQiGmsWW.js";
+import { n as DetailedError, r as hc, t as parseResponse } from "./index-CUTfU69R.js";
 export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, hc, parseResponse };

package/lib/combine.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/combine/index.d.ts
 type Condition = (c: Context) => boolean;

package/lib/common-D8Z4JRCw.d.ts

@@ -0,0 +1,46 @@
+//#region ../../plugins/acryl-router/src/core/helper/css/common.d.ts
+declare const SELECTOR: unique symbol;
+declare const CLASS_NAME: unique symbol;
+declare const STYLE_STRING: unique symbol;
+declare const SELECTORS: unique symbol;
+declare const EXTERNAL_CLASS_NAMES: unique symbol;
+declare const CSS_ESCAPED: unique symbol;
+interface CssClassName {
+  [SELECTOR]: string;
+  [CLASS_NAME]: string;
+  [STYLE_STRING]: string;
+  [SELECTORS]: CssClassName[];
+  [EXTERNAL_CLASS_NAMES]: string[];
+}
+interface CssEscapedString {
+  [CSS_ESCAPED]: string;
+}
+/**
+ * @experimental
+ * `rawCssString` is an experimental feature.
+ * The API might be changed.
+ */
+declare const rawCssString: (value: string) => CssEscapedString;
+type CssVariableBasicType = CssClassName | CssEscapedString | string | number | boolean | null | undefined;
+type CssVariableAsyncType = Promise<CssVariableBasicType>;
+type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[];
+type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType;
+/**
+ * A function that customizes generated CSS class names.
+ *
+ * @param hash - The default hash-based class name (e.g. `css-1234567890`)
+ * @param label - The comment label extracted from the CSS template, may be empty.
+ *   Whitespace is trimmed and inner spaces are replaced with hyphens.
+ * @param styleString - The minified CSS style string
+ * @returns The custom class name to use. Must be a safe CSS identifier;
+ *   otherwise, the default hash is used as a fallback.
+ */
+type ClassNameSlug = (hash: string, label: string, styleString: string) => string;
+/**
+ * A callback function called when an invalid slug is returned from ClassNameSlug.
+ *
+ * @param slug - The invalid slug
+ */
+type OnInvalidSlug = (slug: string) => void;
+//#endregion
+export { rawCssString as a, OnInvalidSlug as i, CssClassName as n, CssVariableType as r, ClassNameSlug as t };

package/lib/components-Ce5FRyHU.js

@@ -0,0 +1,268 @@
+import { C as captureRenderContext, E as useContext, d as renderUntrustedObject, i as isUntrustedObject, n as JSXNode, o as jsx, t as Fragment, u as renderChildren, w as createContext } from "./base-ddiVmiE7.js";
+import { HtmlEscapedCallbackPhase, raw, resolveCallback } from "./utils/html.js";
+import { a as DOM_STASH, i as DOM_RENDERER } from "./constants-BR9jM9BC.js";
+import { x as buildDataStack } from "./hooks-Bq5q9IMl.js";
+import { n as Suspense$1, t as ErrorBoundary$1 } from "./components-DYZdxJIJ.js";
+//#region ../../plugins/acryl-router/src/core/jsx/streaming.ts
+/**
+* @module
+* This module enables JSX to supports streaming Response.
+*/
+/**
+* Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+*
+* @example
+* ```tsx
+* <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+*   <Suspense fallback={<p>Loading...</p>}>
+*     <Content />
+*   </Suspense>
+* </StreamingContext.Provider>
+* ```
+*/
+const StreamingContext = createContext(null);
+let suspenseCounter = 0;
+const serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
+/**
+* @experimental
+* `Suspense` is an experimental feature.
+* The API might be changed.
+*/
+const Suspense = async ({ children, fallback }) => {
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resArray = [];
+	const stackNode = { [DOM_STASH]: [0, []] };
+	const popNodeStack = () => {
+		buildDataStack.pop();
+	};
+	try {
+		stackNode[DOM_STASH][0] = 0;
+		buildDataStack.push([[], stackNode]);
+		resArray = children.map(serializeBoundaryChild);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			resArray = [e.then(() => resume(() => {
+				stackNode[DOM_STASH][0] = 0;
+				buildDataStack.push([[], stackNode]);
+				return childrenToString(children).finally(popNodeStack);
+			}))];
+		} else throw e;
+	} finally {
+		popNodeStack();
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		const index = suspenseCounter++;
+		const fallbackStr = await (typeof fallback === "string" || Array.isArray(fallback) ? renderChildren([fallback]) : isUntrustedObject(fallback) ? renderUntrustedObject(fallback) : fallback.toString());
+		return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [...fallbackStr.callbacks || [], ({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return Promise.all(resArray).then(async (htmlArray) => {
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				if (buffer) buffer[0] = buffer[0].replace(new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`, "s"), () => content);
+				let html = buffer ? "" : `<template data-acryl-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+<\/script>`;
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (!callbacks.length) return html;
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				return raw(html, callbacks);
+			});
+		}]);
+	} else return raw(resArray.join(""));
+};
+Suspense[DOM_RENDERER] = Suspense$1;
+const textEncoder = new TextEncoder();
+/**
+* @experimental
+* `renderToReadableStream()` is an experimental feature.
+* The API might be changed.
+*/
+const renderToReadableStream = (content, onError = console.trace) => {
+	let cancelled = false;
+	return new ReadableStream({
+		async start(controller) {
+			try {
+				if (content instanceof JSXNode) content = content.toString();
+				const context = typeof content === "object" ? content : {};
+				const resolved = await resolveCallback(content, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				if (!cancelled) controller.enqueue(textEncoder.encode(resolved));
+				let resolvedCount = 0;
+				const callbacks = [];
+				const then = (promise) => {
+					callbacks.push(promise.catch((err) => {
+						console.log(err);
+						onError(err);
+						return "";
+					}).then(async (res) => {
+						res = await resolveCallback(res, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+						res.callbacks?.map((c) => c({
+							phase: HtmlEscapedCallbackPhase.Stream,
+							context
+						})).filter(Boolean).forEach(then);
+						resolvedCount++;
+						if (!cancelled) controller.enqueue(textEncoder.encode(res));
+					}));
+				};
+				resolved.callbacks?.map((c) => c({
+					phase: HtmlEscapedCallbackPhase.Stream,
+					context
+				})).filter(Boolean).forEach(then);
+				while (resolvedCount !== callbacks.length) await Promise.all(callbacks);
+			} catch (e) {
+				onError(e);
+			}
+			if (!cancelled) controller.close();
+		},
+		cancel() {
+			cancelled = true;
+		}
+	});
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/jsx/components.ts
+let errorBoundaryCounter = 0;
+const childrenToString = async (children) => {
+	try {
+		return children.flat().map(resolveChildEarly);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			await e;
+			return resume(() => childrenToString(children));
+		} else throw e;
+	}
+};
+const resolveChildEarly = (child) => {
+	if (child == null || typeof child === "boolean") return "";
+	else if (typeof child === "string" || Array.isArray(child)) return renderChildren([child]);
+	else if (isUntrustedObject(child)) return renderUntrustedObject(child);
+	else {
+		const str = child.toString();
+		return str instanceof Promise ? str : raw(str);
+	}
+};
+/**
+* @experimental
+* `ErrorBoundary` is an experimental feature.
+* The API might be changed.
+*/
+const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
+	if (!children) return raw("");
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resume;
+	const getResume = () => resume ||= captureRenderContext();
+	let fallbackStrPromise;
+	const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
+		const awaitedFallback = await fallback;
+		if (awaitedFallback === null || awaitedFallback === void 0) return;
+		if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) return getResume()(() => renderChildren([awaitedFallback]));
+		if (isUntrustedObject(awaitedFallback)) return getResume()(() => renderUntrustedObject(awaitedFallback));
+		const fallbackResult = await getResume()(() => awaitedFallback.toString());
+		return raw(fallbackResult, fallbackResult.callbacks || awaitedFallback.callbacks);
+	})();
+	const renderFallback = async (error) => {
+		const fallbackStr = await resolveFallbackStr();
+		return getResume()(async () => {
+			onError?.(error);
+			const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+			const fallbackResString = await Fragment({ children: fallbackRes }).toString();
+			return raw(fallbackResString, fallbackResString.callbacks || fallbackRes.callbacks);
+		});
+	};
+	let resArray = [];
+	try {
+		resArray = children.map(resolveChildEarly);
+	} catch (e) {
+		const resume = getResume();
+		if (e instanceof Promise) resArray = [e.then(() => resume(() => childrenToString(children))).catch((e) => renderFallback(e))];
+		else resArray = [await renderFallback(e)];
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		getResume();
+		const index = errorBoundaryCounter++;
+		const replaceRe = RegExp(`(<template id="E:${index}"></template>)(.*?)(<!--E:${index}-->)`, "s");
+		let caught = false;
+		const catchCallback = async ({ error, buffer }) => {
+			if (caught) return "";
+			caught = true;
+			const fallbackResString = await renderFallback(error);
+			const fallbackCallbacks = fallbackResString.callbacks;
+			if (buffer) {
+				buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
+				return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
+			}
+			return raw(`<template data-acryl-target="E:${index}">${fallbackResString}</template><script>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
+d.replaceWith(c.content)
+})(document)
+<\/script>`, fallbackCallbacks);
+		};
+		let error;
+		const promiseAll = Promise.all(resArray).catch((e) => error = e);
+		return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return promiseAll.then(async (htmlArray) => {
+				if (error) throw error;
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				let html = buffer ? "" : `<template data-acryl-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+d.parentElement.insertBefore(c.content,d.nextSibling)
+})(document)
+<\/script>`;
+				if (htmlArray.every((html) => !html.callbacks?.length)) {
+					if (buffer) buffer[0] = buffer[0].replace(replaceRe, () => content);
+					return html;
+				}
+				if (buffer) buffer[0] = buffer[0].replace(replaceRe, (_all, pre, _, post) => `${pre}${content}${post}`);
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				let resolvedCount = 0;
+				const promises = callbacks.map((c) => (...args) => c(...args)?.then((content) => {
+					resolvedCount++;
+					if (buffer) {
+						if (resolvedCount === callbacks.length) buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content) => content);
+						buffer[0] += content;
+						return raw("", content.callbacks);
+					}
+					return raw(content + (resolvedCount !== callbacks.length ? "" : `<script>
+((d,c,n) => {
+d=d.getElementById('E:${index}')
+if(!d)return
+n=d.nextSibling
+while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
+n.remove()
+d.remove()
+})(document)
+<\/script>`), content.callbacks);
+				}).catch((error) => catchCallback({
+					error,
+					buffer
+				})));
+				return raw(html, promises);
+			}).catch((error) => catchCallback({
+				error,
+				buffer
+			}));
+		}]);
+	} else return Fragment({ children: resArray });
+};
+ErrorBoundary[DOM_RENDERER] = ErrorBoundary$1;
+//#endregion
+export { renderToReadableStream as i, StreamingContext as n, Suspense as r, ErrorBoundary as t };

package/lib/components-DYZdxJIJ.js

@@ -0,0 +1,24 @@
+import { t as DOM_ERROR_HANDLER } from "./constants-BR9jM9BC.js";
+import { t as Fragment } from "./jsx-dev-runtime-kAhR_4C7.js";
+import "./jsx/dom/jsx-runtime.js";
+//#region ../../plugins/acryl-router/src/core/jsx/dom/components.ts
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err) => {
+		if (err instanceof Promise) throw err;
+		onError?.(err);
+		return fallbackRender?.(err) || fallback;
+	};
+	return res;
+});
+const Suspense = (({ children, fallback }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err, retry) => {
+		if (!(err instanceof Promise)) throw err;
+		err.finally(retry);
+		return fallback;
+	};
+	return res;
+});
+//#endregion
+export { Suspense as n, ErrorBoundary as t };

package/lib/compress.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-B5Y1lLha.js";
+import { I as MiddlewareHandler } from "./context-DVQBjuns.js";
 import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/compress/index.d.ts

package/lib/conninfo.d.ts

@@ -1,5 +1,5 @@
-import { t as Context } from "./context-B5Y1lLha.js";
-import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-ZM9gIiKh.js";
+import { t as Context } from "./context-DVQBjuns.js";
+import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-nEL8VPDC.js";
 
 //#region ../../plugins/acryl-router/src/connection.d.ts
 /** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */

package/lib/constants-BR9jM9BC.js

@@ -0,0 +1,9 @@
+//#region ../../plugins/acryl-router/src/core/jsx/constants.ts
+const DOM_RENDERER = Symbol("RENDERER");
+const DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
+const DOM_STASH = Symbol("STASH");
+const DOM_INTERNAL_TAG = Symbol("INTERNAL");
+const DOM_MEMO = Symbol("MEMO");
+const PERMALINK = Symbol("PERMALINK");
+//#endregion
+export { DOM_STASH as a, DOM_RENDERER as i, DOM_INTERNAL_TAG as n, PERMALINK as o, DOM_MEMO as r, DOM_ERROR_HANDLER as t };

package/lib/{context-B5Y1lLha.d.ts → context-DVQBjuns.d.ts}

@@ -1,7 +1,7 @@
 import { c as Result, l as Router } from "./router-CvUxUTOq.js";
 import { i as ResponseHeader, n as CustomHeader, r as RequestHeader } from "./headers-tu2YYN8T.js";
 import { c as StatusCode, n as ContentfulStatusCode, o as RedirectStatusCode } from "./http-status-DaAwGAFL.js";
-import { C as Simplify, E as UnionToIntersection, _ as JSONValue, d as InvalidJSONValue, f as IsAny, h as JSONParsed, l as IfAnyThenEmptyObject, x as RemoveBlankRecord } from "./types-D9DEXMjE.js";
+import { D as UnionToIntersection, S as RemoveBlankRecord, f as InvalidJSONValue, g as JSONParsed, p as IsAny, u as IfAnyThenEmptyObject, v as JSONValue, w as Simplify } from "./types-Lqx5BxQF.js";
 import { t as BaseMime } from "./mime-BQOYHl-l.js";
 
 //#region ../../plugins/acryl-router/src/core/request/constants.d.ts