148 lines
6.5 KiB
Plaintext
148 lines
6.5 KiB
Plaintext
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
const require_utils_html = require("../utils/html.js");
|
|
const require_jsx_constants = require("./constants.js");
|
|
const require_jsx_context = require("./context.js");
|
|
const require_jsx_base = require("./base.js");
|
|
const require_jsx_dom_components = require("./dom/components.js");
|
|
const require_jsx_streaming = require("./streaming.js");
|
|
//#region src/jsx/components.ts
|
|
let errorBoundaryCounter = 0;
|
|
const childrenToString = async (children) => {
|
|
try {
|
|
return children.flat().map(resolveChildEarly);
|
|
} catch (e) {
|
|
if (e instanceof Promise) {
|
|
const resume = require_jsx_context.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 require_jsx_base.renderChildren([child]);
|
|
else if (require_jsx_base.isUntrustedObject(child)) return require_jsx_base.renderUntrustedObject(child);
|
|
else {
|
|
const str = child.toString();
|
|
return str instanceof Promise ? str : require_utils_html.raw(str);
|
|
}
|
|
};
|
|
/**
|
|
* @experimental
|
|
* `ErrorBoundary` is an experimental feature.
|
|
* The API might be changed.
|
|
*/
|
|
const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
|
|
if (!children) return require_utils_html.raw("");
|
|
if (!Array.isArray(children)) children = [children];
|
|
const nonce = require_jsx_context.useContext(require_jsx_streaming.StreamingContext)?.scriptNonce;
|
|
let resume;
|
|
const getResume = () => resume ||= require_jsx_context.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()(() => require_jsx_base.renderChildren([awaitedFallback]));
|
|
if (require_jsx_base.isUntrustedObject(awaitedFallback)) return getResume()(() => require_jsx_base.renderUntrustedObject(awaitedFallback));
|
|
const fallbackResult = await getResume()(() => awaitedFallback.toString());
|
|
return require_utils_html.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 && require_jsx_base.jsx(require_jsx_base.Fragment, {}, fallbackRender(error)) || "";
|
|
const fallbackResString = await require_jsx_base.Fragment({ children: fallbackRes }).toString();
|
|
return require_utils_html.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 ? require_utils_html.raw("", fallbackCallbacks) : "";
|
|
}
|
|
return require_utils_html.raw(`<template data-hono-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 require_utils_html.raw(`<template id="E:${index}"></template><!--E:${index}-->`, [({ phase, buffer, context }) => {
|
|
if (phase === require_utils_html.HtmlEscapedCallbackPhase.BeforeStream) return;
|
|
return promiseAll.then(async (htmlArray) => {
|
|
if (error) throw error;
|
|
htmlArray = htmlArray.flat();
|
|
const content = htmlArray.join("");
|
|
let html = buffer ? "" : `<template data-hono-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 === require_utils_html.HtmlEscapedCallbackPhase.Stream) html = await require_utils_html.resolveCallback(html, require_utils_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 require_utils_html.raw("", content.callbacks);
|
|
}
|
|
return require_utils_html.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 require_utils_html.raw(html, promises);
|
|
}).catch((error) => catchCallback({
|
|
error,
|
|
buffer
|
|
}));
|
|
}]);
|
|
} else return require_jsx_base.Fragment({ children: resArray });
|
|
};
|
|
ErrorBoundary[require_jsx_constants.DOM_RENDERER] = require_jsx_dom_components.ErrorBoundary;
|
|
//#endregion
|
|
exports.ErrorBoundary = ErrorBoundary;
|
|
exports.childrenToString = childrenToString;
|