252 lines
8.6 KiB
JavaScript
252 lines
8.6 KiB
JavaScript
import { createRenderer } from 'vue-bundle-renderer/runtime';
|
|
import { eventHandler, setResponseStatus, getQuery, createError } from 'h3';
|
|
import { stringify, uneval } from 'devalue';
|
|
import { renderToString } from 'vue/server-renderer';
|
|
import { u as useNitroApp, a as useRuntimeConfig, g as getRouteRules } from '../nitro/node-server.mjs';
|
|
import { joinURL } from 'ufo';
|
|
|
|
function defineRenderHandler(handler) {
|
|
return eventHandler(async (event) => {
|
|
if (event.node.req.url.endsWith("/favicon.ico")) {
|
|
event.node.res.setHeader("Content-Type", "image/x-icon");
|
|
event.node.res.end(
|
|
"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
|
|
);
|
|
return;
|
|
}
|
|
const response = await handler(event);
|
|
if (!response) {
|
|
if (!event.node.res.writableEnded) {
|
|
event.node.res.statusCode = event.node.res.statusCode === 200 ? 500 : event.node.res.statusCode;
|
|
event.node.res.end(
|
|
"No response returned from render handler: " + event.node.req.url
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
const nitroApp = useNitroApp();
|
|
await nitroApp.hooks.callHook("render:response", response, { event });
|
|
if (!event.node.res.headersSent && response.headers) {
|
|
for (const header in response.headers) {
|
|
event.node.res.setHeader(header, response.headers[header]);
|
|
}
|
|
setResponseStatus(event, response.statusCode, response.statusMessage);
|
|
}
|
|
return typeof response.body === "string" ? response.body : JSON.stringify(response.body);
|
|
});
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
const appRootId = "__nuxt";
|
|
|
|
const appRootTag = "div";
|
|
|
|
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 getStaticRenderedHead = () => import('../rollup/_virtual_head-static.mjs').then((r) => r.default || r);
|
|
const getServerEntry = () => import('../app/server.mjs').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 `<${appRootTag} id="${appRootId}">${html}</${appRootTag}>`;
|
|
}
|
|
return renderer;
|
|
});
|
|
const getSPARenderer = lazyCachedFunction(async () => {
|
|
const manifest = await getClientManifest();
|
|
const options = {
|
|
manifest,
|
|
renderToString: () => `<${appRootTag} id="${appRootId}"></${appRootTag}>`,
|
|
buildAssetsURL
|
|
};
|
|
const renderer = createRenderer(() => () => {
|
|
}, options);
|
|
const result = await renderer.renderToString({});
|
|
const renderToString = (ssrContext) => {
|
|
const config = useRuntimeConfig();
|
|
ssrContext.payload = {
|
|
_errors: {},
|
|
serverRendered: false,
|
|
config: {
|
|
public: config.public,
|
|
app: config.app
|
|
},
|
|
data: {},
|
|
state: {}
|
|
};
|
|
ssrContext.renderMeta = ssrContext.renderMeta ?? getStaticRenderedHead;
|
|
return Promise.resolve(result);
|
|
};
|
|
return {
|
|
rendererContext: renderer.rendererContext,
|
|
renderToString
|
|
};
|
|
});
|
|
const PAYLOAD_URL_RE = /\/_payload(\.[a-zA-Z0-9]+)?.json(\?.*)?$/ ;
|
|
const renderer = defineRenderHandler(async (event) => {
|
|
const nitroApp = useNitroApp();
|
|
const ssrError = event.node.req.url?.startsWith("/__nuxt_error") ? getQuery(event) : null;
|
|
if (ssrError && ssrError.statusCode) {
|
|
ssrError.statusCode = parseInt(ssrError.statusCode);
|
|
}
|
|
if (ssrError && event.node.req.socket.readyState !== "readOnly") {
|
|
throw createError("Cannot directly render error page!");
|
|
}
|
|
const islandContext = void 0;
|
|
let url = ssrError?.url || islandContext?.url || event.node.req.url;
|
|
const isRenderingPayload = PAYLOAD_URL_RE.test(url);
|
|
if (isRenderingPayload) {
|
|
url = url.substring(0, url.lastIndexOf("/")) || "/";
|
|
event.node.req.url = url;
|
|
}
|
|
const routeOptions = getRouteRules(event);
|
|
const ssrContext = {
|
|
url,
|
|
event,
|
|
runtimeConfig: useRuntimeConfig(),
|
|
noSSR: event.context.nuxt?.noSSR || routeOptions.ssr === false || (false),
|
|
error: !!ssrError,
|
|
nuxt: void 0,
|
|
/* NuxtApp */
|
|
payload: ssrError ? { error: ssrError } : {},
|
|
_payloadReducers: {},
|
|
islandContext
|
|
};
|
|
const renderer = ssrContext.noSSR ? await getSPARenderer() : await getSSRRenderer();
|
|
const _rendered = await renderer.renderToString(ssrContext).catch((error) => {
|
|
throw !ssrError && ssrContext.payload?.error || error;
|
|
});
|
|
await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext });
|
|
if (ssrContext.payload?.error && !ssrError) {
|
|
throw ssrContext.payload.error;
|
|
}
|
|
if (isRenderingPayload) {
|
|
const response2 = renderPayloadResponse(ssrContext);
|
|
return response2;
|
|
}
|
|
const renderedMeta = await ssrContext.renderMeta?.() ?? {};
|
|
const inlinedStyles = "";
|
|
const NO_SCRIPTS = routeOptions.experimentalNoScripts;
|
|
const htmlContext = {
|
|
island: Boolean(islandContext),
|
|
htmlAttrs: normalizeChunks([renderedMeta.htmlAttrs]),
|
|
head: normalizeChunks([
|
|
renderedMeta.headTags,
|
|
null ,
|
|
NO_SCRIPTS ? null : _rendered.renderResourceHints(),
|
|
_rendered.renderStyles(),
|
|
inlinedStyles,
|
|
ssrContext.styles
|
|
]),
|
|
bodyAttrs: normalizeChunks([renderedMeta.bodyAttrs]),
|
|
bodyPrepend: normalizeChunks([
|
|
renderedMeta.bodyScriptsPrepend,
|
|
ssrContext.teleports?.body
|
|
]),
|
|
body: [_rendered.html],
|
|
bodyAppend: normalizeChunks([
|
|
NO_SCRIPTS ? void 0 : renderPayloadJsonScript({ id: "__NUXT_DATA__", ssrContext, data: ssrContext.payload }) ,
|
|
routeOptions.experimentalNoScripts ? void 0 : _rendered.renderScripts(),
|
|
// Note: bodyScripts may contain tags other than <script>
|
|
renderedMeta.bodyScripts
|
|
])
|
|
};
|
|
await nitroApp.hooks.callHook("render:html", htmlContext, { event });
|
|
const response = {
|
|
body: renderHTMLDocument(htmlContext),
|
|
statusCode: event.node.res.statusCode,
|
|
statusMessage: event.node.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.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body>
|
|
</html>`;
|
|
}
|
|
function renderPayloadResponse(ssrContext) {
|
|
return {
|
|
body: stringify(splitPayload(ssrContext).payload, ssrContext._payloadReducers) ,
|
|
statusCode: ssrContext.event.node.res.statusCode,
|
|
statusMessage: ssrContext.event.node.res.statusMessage,
|
|
headers: {
|
|
"content-type": "application/json;charset=utf-8" ,
|
|
"x-powered-by": "Nuxt"
|
|
}
|
|
};
|
|
}
|
|
function renderPayloadJsonScript(opts) {
|
|
const attrs = [
|
|
'type="application/json"',
|
|
`id="${opts.id}"`,
|
|
`data-ssr="${!(opts.ssrContext.noSSR)}"`,
|
|
opts.src ? `data-src="${opts.src}"` : ""
|
|
].filter(Boolean);
|
|
const contents = opts.data ? stringify(opts.data, opts.ssrContext._payloadReducers) : "";
|
|
return `<script ${attrs.join(" ")}>${contents}<\/script><script>window.__NUXT__={};window.__NUXT__.config=${uneval(opts.ssrContext.config)}<\/script>`;
|
|
}
|
|
function splitPayload(ssrContext) {
|
|
const { data, prerenderedAt, ...initial } = ssrContext.payload;
|
|
return {
|
|
initial: { ...initial, prerenderedAt },
|
|
payload: { data, prerenderedAt }
|
|
};
|
|
}
|
|
|
|
const renderer$1 = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
default: renderer
|
|
});
|
|
|
|
export { publicAssetsURL as p, renderer$1 as r };
|
|
//# sourceMappingURL=renderer.mjs.map
|