mirror of
https://github.com/ArthurDanjou/trpc-nuxt.git
synced 2026-01-29 03:10:40 +01:00
521 lines
16 KiB
JavaScript
521 lines
16 KiB
JavaScript
import { renderResourceHeaders, createRenderer } from 'vue-bundle-renderer/runtime';
|
|
import { eventHandler, getQuery, writeEarlyHints } from 'h3';
|
|
import { renderToString } from 'vue/server-renderer';
|
|
import { joinURL } from 'ufo';
|
|
import { u as useNitroApp, a as useRuntimeConfig, g as getRouteRules } from '../nitro/vercel.mjs';
|
|
import 'node-fetch-native/polyfill';
|
|
import 'ohmyfetch';
|
|
import 'destr';
|
|
import 'unenv/runtime/fetch/index';
|
|
import 'hookable';
|
|
import 'scule';
|
|
import 'ohash';
|
|
import 'unstorage';
|
|
import 'unstorage/drivers/overlay';
|
|
import 'unstorage/drivers/memory';
|
|
import 'defu';
|
|
import 'radix3';
|
|
import 'pathe';
|
|
import 'unified';
|
|
import 'mdast-util-to-string';
|
|
import 'micromark/lib/preprocess.js';
|
|
import 'micromark/lib/postprocess.js';
|
|
import 'unist-util-stringify-position';
|
|
import 'micromark-util-character';
|
|
import 'micromark-util-chunked';
|
|
import 'micromark-util-resolve-all';
|
|
import 'remark-emoji';
|
|
import 'rehype-slug';
|
|
import 'remark-squeeze-paragraphs';
|
|
import 'rehype-external-links';
|
|
import 'remark-gfm';
|
|
import 'rehype-sort-attribute-values';
|
|
import 'rehype-sort-attributes';
|
|
import 'rehype-raw';
|
|
import 'remark-mdc';
|
|
import 'remark-parse';
|
|
import 'remark-rehype';
|
|
import 'mdast-util-to-hast';
|
|
import 'detab';
|
|
import 'unist-builder';
|
|
import 'mdurl';
|
|
import 'slugify';
|
|
import 'unist-util-position';
|
|
import 'html-tags';
|
|
import 'unist-util-visit';
|
|
import 'shiki-es';
|
|
import 'unenv/runtime/npm/consola';
|
|
|
|
function defineRenderHandler(handler) {
|
|
return eventHandler(async (event) => {
|
|
if (event.req.url.endsWith("/favicon.ico")) {
|
|
event.res.setHeader("Content-Type", "image/x-icon");
|
|
event.res.end("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7");
|
|
return;
|
|
}
|
|
const response = await handler(event);
|
|
if (!response) {
|
|
if (!event.res.writableEnded) {
|
|
event.res.statusCode = event.res.statusCode === 200 ? 500 : event.res.statusCode;
|
|
event.res.end("No response returned from render handler: " + event.req.url);
|
|
}
|
|
return;
|
|
}
|
|
const nitroApp = useNitroApp();
|
|
await nitroApp.hooks.callHook("render:response", response, { event });
|
|
if (!event.res.headersSent && response.headers) {
|
|
for (const header in response.headers) {
|
|
event.res.setHeader(header, response.headers[header]);
|
|
}
|
|
if (response.statusCode) {
|
|
event.res.statusCode = response.statusCode;
|
|
}
|
|
if (response.statusMessage) {
|
|
event.res.statusMessage = response.statusMessage;
|
|
}
|
|
}
|
|
return typeof response.body === "string" ? response.body : JSON.stringify(response.body);
|
|
});
|
|
}
|
|
|
|
const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
|
|
const unsafeChars = /[<>\b\f\n\r\t\0\u2028\u2029]/g;
|
|
const reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
|
|
const escaped = {
|
|
"<": "\\u003C",
|
|
">": "\\u003E",
|
|
"/": "\\u002F",
|
|
"\\": "\\\\",
|
|
"\b": "\\b",
|
|
"\f": "\\f",
|
|
"\n": "\\n",
|
|
"\r": "\\r",
|
|
" ": "\\t",
|
|
"\0": "\\0",
|
|
"\u2028": "\\u2028",
|
|
"\u2029": "\\u2029"
|
|
};
|
|
const objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
|
|
function devalue(value) {
|
|
const counts = new Map();
|
|
let logNum = 0;
|
|
function log(message) {
|
|
if (logNum < 100) {
|
|
console.warn(message);
|
|
logNum += 1;
|
|
}
|
|
}
|
|
function walk(thing) {
|
|
if (typeof thing === "function") {
|
|
log(`Cannot stringify a function ${thing.name}`);
|
|
return;
|
|
}
|
|
if (counts.has(thing)) {
|
|
counts.set(thing, counts.get(thing) + 1);
|
|
return;
|
|
}
|
|
counts.set(thing, 1);
|
|
if (!isPrimitive(thing)) {
|
|
const type = getType(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
case "Date":
|
|
case "RegExp":
|
|
return;
|
|
case "Array":
|
|
thing.forEach(walk);
|
|
break;
|
|
case "Set":
|
|
case "Map":
|
|
Array.from(thing).forEach(walk);
|
|
break;
|
|
default:
|
|
const proto = Object.getPrototypeOf(thing);
|
|
if (proto !== Object.prototype && proto !== null && Object.getOwnPropertyNames(proto).sort().join("\0") !== objectProtoOwnPropertyNames) {
|
|
if (typeof thing.toJSON !== "function") {
|
|
log(`Cannot stringify arbitrary non-POJOs ${thing.constructor.name}`);
|
|
}
|
|
} else if (Object.getOwnPropertySymbols(thing).length > 0) {
|
|
log(`Cannot stringify POJOs with symbolic keys ${Object.getOwnPropertySymbols(thing).map((symbol) => symbol.toString())}`);
|
|
} else {
|
|
Object.keys(thing).forEach((key) => walk(thing[key]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
walk(value);
|
|
const names = new Map();
|
|
Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
|
|
names.set(entry[0], getName(i));
|
|
});
|
|
function stringify(thing) {
|
|
if (names.has(thing)) {
|
|
return names.get(thing);
|
|
}
|
|
if (isPrimitive(thing)) {
|
|
return stringifyPrimitive(thing);
|
|
}
|
|
const type = getType(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
return `Object(${stringify(thing.valueOf())})`;
|
|
case "RegExp":
|
|
return thing.toString();
|
|
case "Date":
|
|
return `new Date(${thing.getTime()})`;
|
|
case "Array":
|
|
const members = thing.map((v, i) => i in thing ? stringify(v) : "");
|
|
const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
|
|
return `[${members.join(",")}${tail}]`;
|
|
case "Set":
|
|
case "Map":
|
|
return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
|
|
default:
|
|
if (thing.toJSON) {
|
|
let json = thing.toJSON();
|
|
if (getType(json) === "String") {
|
|
try {
|
|
json = JSON.parse(json);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
return stringify(json);
|
|
}
|
|
if (Object.getPrototypeOf(thing) === null) {
|
|
if (Object.keys(thing).length === 0) {
|
|
return "Object.create(null)";
|
|
}
|
|
return `Object.create(null,{${Object.keys(thing).map((key) => `${safeKey(key)}:{writable:true,enumerable:true,value:${stringify(thing[key])}}`).join(",")}})`;
|
|
}
|
|
return `{${Object.keys(thing).map((key) => `${safeKey(key)}:${stringify(thing[key])}`).join(",")}}`;
|
|
}
|
|
}
|
|
const str = stringify(value);
|
|
if (names.size) {
|
|
const params = [];
|
|
const statements = [];
|
|
const values = [];
|
|
names.forEach((name, thing) => {
|
|
params.push(name);
|
|
if (isPrimitive(thing)) {
|
|
values.push(stringifyPrimitive(thing));
|
|
return;
|
|
}
|
|
const type = getType(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
values.push(`Object(${stringify(thing.valueOf())})`);
|
|
break;
|
|
case "RegExp":
|
|
values.push(thing.toString());
|
|
break;
|
|
case "Date":
|
|
values.push(`new Date(${thing.getTime()})`);
|
|
break;
|
|
case "Array":
|
|
values.push(`Array(${thing.length})`);
|
|
thing.forEach((v, i) => {
|
|
statements.push(`${name}[${i}]=${stringify(v)}`);
|
|
});
|
|
break;
|
|
case "Set":
|
|
values.push("new Set");
|
|
statements.push(`${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`);
|
|
break;
|
|
case "Map":
|
|
values.push("new Map");
|
|
statements.push(`${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`);
|
|
break;
|
|
default:
|
|
values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
|
|
Object.keys(thing).forEach((key) => {
|
|
statements.push(`${name}${safeProp(key)}=${stringify(thing[key])}`);
|
|
});
|
|
}
|
|
});
|
|
statements.push(`return ${str}`);
|
|
return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
function getName(num) {
|
|
let name = "";
|
|
do {
|
|
name = chars[num % chars.length] + name;
|
|
num = ~~(num / chars.length) - 1;
|
|
} while (num >= 0);
|
|
return reserved.test(name) ? `${name}0` : name;
|
|
}
|
|
function isPrimitive(thing) {
|
|
return Object(thing) !== thing;
|
|
}
|
|
function stringifyPrimitive(thing) {
|
|
if (typeof thing === "string") {
|
|
return stringifyString(thing);
|
|
}
|
|
if (thing === void 0) {
|
|
return "void 0";
|
|
}
|
|
if (thing === 0 && 1 / thing < 0) {
|
|
return "-0";
|
|
}
|
|
const str = String(thing);
|
|
if (typeof thing === "number") {
|
|
return str.replace(/^(-)?0\./, "$1.");
|
|
}
|
|
return str;
|
|
}
|
|
function getType(thing) {
|
|
return Object.prototype.toString.call(thing).slice(8, -1);
|
|
}
|
|
function escapeUnsafeChar(c) {
|
|
return escaped[c] || c;
|
|
}
|
|
function escapeUnsafeChars(str) {
|
|
return str.replace(unsafeChars, escapeUnsafeChar);
|
|
}
|
|
function safeKey(key) {
|
|
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
|
|
}
|
|
function safeProp(key) {
|
|
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escapeUnsafeChars(JSON.stringify(key))}]`;
|
|
}
|
|
function stringifyString(str) {
|
|
let result = '"';
|
|
for (let i = 0; i < str.length; i += 1) {
|
|
const char = str.charAt(i);
|
|
const code = char.charCodeAt(0);
|
|
if (char === '"') {
|
|
result += '\\"';
|
|
} else if (char in escaped) {
|
|
result += escaped[char];
|
|
} else if (code >= 55296 && code <= 57343) {
|
|
const next = str.charCodeAt(i + 1);
|
|
if (code <= 56319 && (next >= 56320 && next <= 57343)) {
|
|
result += char + str[++i];
|
|
} else {
|
|
result += `\\u${code.toString(16).toUpperCase()}`;
|
|
}
|
|
} else {
|
|
result += char;
|
|
}
|
|
}
|
|
result += '"';
|
|
return result;
|
|
}
|
|
|
|
function buildAssetsURL(...path) {
|
|
return joinURL(publicAssetsURL(), useRuntimeConfig().app.buildAssetsDir, ...path);
|
|
}
|
|
function publicAssetsURL(...path) {
|
|
const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
|
|
return path.length ? joinURL(publicBase, ...path) : publicBase;
|
|
}
|
|
|
|
globalThis.__buildAssetsURL = buildAssetsURL;
|
|
globalThis.__publicAssetsURL = publicAssetsURL;
|
|
const getClientManifest = () => import('../app/client.manifest.mjs').then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
|
|
const getServerEntry = () => import('../app/server.mjs').then((r) => r.default || r);
|
|
const getSSRStyles = () => import('../app/styles.mjs').then(function (n) { return n.s; }).then((r) => r.default || r);
|
|
const getSSRRenderer = lazyCachedFunction(async () => {
|
|
const manifest = await getClientManifest();
|
|
if (!manifest) {
|
|
throw new Error("client.manifest is not available");
|
|
}
|
|
const createSSRApp = await getServerEntry();
|
|
if (!createSSRApp) {
|
|
throw new Error("Server bundle is not available");
|
|
}
|
|
const options = {
|
|
manifest,
|
|
renderToString: renderToString$1,
|
|
buildAssetsURL
|
|
};
|
|
const renderer = createRenderer(createSSRApp, options);
|
|
async function renderToString$1(input, context) {
|
|
const html = await renderToString(input, context);
|
|
return `<div id="__nuxt">${html}</div>`;
|
|
}
|
|
return renderer;
|
|
});
|
|
const getSPARenderer = lazyCachedFunction(async () => {
|
|
const manifest = await getClientManifest();
|
|
const options = {
|
|
manifest,
|
|
renderToString: () => '<div id="__nuxt"></div>',
|
|
buildAssetsURL
|
|
};
|
|
const renderer = createRenderer(() => () => {
|
|
}, options);
|
|
const result = await renderer.renderToString({});
|
|
const renderToString = (ssrContext) => {
|
|
const config = useRuntimeConfig();
|
|
ssrContext.payload = {
|
|
serverRendered: false,
|
|
config: {
|
|
public: config.public,
|
|
app: config.app
|
|
},
|
|
data: {},
|
|
state: {}
|
|
};
|
|
ssrContext.renderMeta = ssrContext.renderMeta ?? (() => ({}));
|
|
return Promise.resolve(result);
|
|
};
|
|
return {
|
|
rendererContext: renderer.rendererContext,
|
|
renderToString
|
|
};
|
|
});
|
|
const PAYLOAD_URL_RE = /\/_payload(\.[a-zA-Z0-9]+)?.js(\?.*)?$/;
|
|
const renderer = defineRenderHandler(async (event) => {
|
|
const ssrError = event.req.url?.startsWith("/__nuxt_error") ? getQuery(event) : null;
|
|
let url = ssrError?.url || event.req.url;
|
|
const isRenderingPayload = PAYLOAD_URL_RE.test(url);
|
|
if (isRenderingPayload) {
|
|
url = url.substring(0, url.lastIndexOf("/")) || "/";
|
|
event.req.url = url;
|
|
}
|
|
const routeOptions = getRouteRules(event);
|
|
const ssrContext = {
|
|
url,
|
|
event,
|
|
runtimeConfig: useRuntimeConfig(),
|
|
noSSR: !!event.req.headers["x-nuxt-no-ssr"] || routeOptions.ssr === false || (false),
|
|
error: !!ssrError,
|
|
nuxt: void 0,
|
|
payload: ssrError ? { error: ssrError } : {}
|
|
};
|
|
const renderer = ssrContext.noSSR ? await getSPARenderer() : await getSSRRenderer();
|
|
if (!isRenderingPayload && !false) {
|
|
const { link } = renderResourceHeaders({}, renderer.rendererContext);
|
|
writeEarlyHints(event, link);
|
|
}
|
|
const _rendered = await renderer.renderToString(ssrContext).catch((err) => {
|
|
if (!ssrError) {
|
|
throw ssrContext.payload?.error || err;
|
|
}
|
|
});
|
|
await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext });
|
|
if (!_rendered) {
|
|
return void 0;
|
|
}
|
|
if (ssrContext.payload?.error && !ssrError) {
|
|
throw ssrContext.payload.error;
|
|
}
|
|
if (isRenderingPayload) {
|
|
const response2 = renderPayloadResponse(ssrContext);
|
|
return response2;
|
|
}
|
|
const renderedMeta = await ssrContext.renderMeta?.() ?? {};
|
|
const inlinedStyles = await renderInlineStyles(ssrContext.modules ?? ssrContext._registeredComponents ?? []) ;
|
|
const htmlContext = {
|
|
htmlAttrs: normalizeChunks([renderedMeta.htmlAttrs]),
|
|
head: normalizeChunks([
|
|
renderedMeta.headTags,
|
|
null,
|
|
_rendered.renderResourceHints(),
|
|
_rendered.renderStyles(),
|
|
inlinedStyles,
|
|
ssrContext.styles
|
|
]),
|
|
bodyAttrs: normalizeChunks([renderedMeta.bodyAttrs]),
|
|
bodyPreprend: normalizeChunks([
|
|
renderedMeta.bodyScriptsPrepend,
|
|
ssrContext.teleports?.body
|
|
]),
|
|
body: [
|
|
_rendered.html
|
|
],
|
|
bodyAppend: normalizeChunks([
|
|
`<script>window.__NUXT__=${devalue(ssrContext.payload)}<\/script>`,
|
|
_rendered.renderScripts(),
|
|
renderedMeta.bodyScripts
|
|
])
|
|
};
|
|
const nitroApp = useNitroApp();
|
|
await nitroApp.hooks.callHook("render:html", htmlContext, { event });
|
|
const response = {
|
|
body: renderHTMLDocument(htmlContext),
|
|
statusCode: event.res.statusCode,
|
|
statusMessage: event.res.statusMessage,
|
|
headers: {
|
|
"Content-Type": "text/html;charset=UTF-8",
|
|
"X-Powered-By": "Nuxt"
|
|
}
|
|
};
|
|
return response;
|
|
});
|
|
function lazyCachedFunction(fn) {
|
|
let res = null;
|
|
return () => {
|
|
if (res === null) {
|
|
res = fn().catch((err) => {
|
|
res = null;
|
|
throw err;
|
|
});
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
function normalizeChunks(chunks) {
|
|
return chunks.filter(Boolean).map((i) => i.trim());
|
|
}
|
|
function joinTags(tags) {
|
|
return tags.join("");
|
|
}
|
|
function joinAttrs(chunks) {
|
|
return chunks.join(" ");
|
|
}
|
|
function renderHTMLDocument(html) {
|
|
return `<!DOCTYPE html>
|
|
<html ${joinAttrs(html.htmlAttrs)}>
|
|
<head>${joinTags(html.head)}</head>
|
|
<body ${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPreprend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body>
|
|
</html>`;
|
|
}
|
|
async function renderInlineStyles(usedModules) {
|
|
const { entryCSS } = await getClientManifest();
|
|
const styleMap = await getSSRStyles();
|
|
const inlinedStyles = /* @__PURE__ */ new Set();
|
|
for (const mod of ["entry", ...usedModules]) {
|
|
if (mod in styleMap) {
|
|
for (const style of await styleMap[mod]()) {
|
|
inlinedStyles.add(`<style>${style}</style>`);
|
|
}
|
|
}
|
|
}
|
|
for (const css of entryCSS?.css || []) {
|
|
inlinedStyles.add(`<link rel="stylesheet" href=${JSON.stringify(buildAssetsURL(css))} media="print" onload="this.media='all'; this.onload=null;">`);
|
|
}
|
|
return Array.from(inlinedStyles).join("");
|
|
}
|
|
function renderPayloadResponse(ssrContext) {
|
|
return {
|
|
body: `export default ${devalue(splitPayload(ssrContext).payload)}`,
|
|
statusCode: ssrContext.event.res.statusCode,
|
|
statusMessage: ssrContext.event.res.statusMessage,
|
|
headers: {
|
|
"content-type": "text/javascript;charset=UTF-8",
|
|
"x-powered-by": "Nuxt"
|
|
}
|
|
};
|
|
}
|
|
function splitPayload(ssrContext) {
|
|
const { data, prerenderedAt, ...initial } = ssrContext.payload;
|
|
return {
|
|
initial: { ...initial, prerenderedAt },
|
|
payload: { data, prerenderedAt }
|
|
};
|
|
}
|
|
|
|
export { renderer as default };
|
|
//# sourceMappingURL=renderer.mjs.map
|