297 lines
9.7 KiB
JavaScript
297 lines
9.7 KiB
JavaScript
import { createRenderer } from 'vue-bundle-renderer/runtime';
|
|
import { eventHandler, setResponseStatus, getQuery, createError } from 'h3';
|
|
import { stringify, uneval } from 'devalue';
|
|
import { u as useNitroApp, a as useRuntimeConfig, g as getRouteRules } from '../nitro/node-server.mjs';
|
|
import { joinURL } from 'ufo';
|
|
import 'node-fetch-native/polyfill';
|
|
import 'node:http';
|
|
import 'node:https';
|
|
import 'destr';
|
|
import 'ofetch';
|
|
import 'unenv/runtime/fetch/index';
|
|
import 'hookable';
|
|
import 'scule';
|
|
import 'klona';
|
|
import 'defu';
|
|
import 'ohash';
|
|
import 'unstorage';
|
|
import 'unstorage/drivers/fs';
|
|
import 'unstorage/drivers/overlay';
|
|
import 'unstorage/drivers/memory';
|
|
import 'radix3';
|
|
import 'node:fs';
|
|
import 'node:url';
|
|
import 'pathe';
|
|
import '@intlify/bundle-utils';
|
|
import 'ipx';
|
|
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 'unist-util-visit';
|
|
import 'shiki-es';
|
|
import 'unenv/runtime/npm/consola';
|
|
|
|
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 getSSRStyles = lazyCachedFunction(() => import('../app/styles.mjs').then((r) => r.default || r));
|
|
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,
|
|
data: {},
|
|
state: {}
|
|
};
|
|
ssrContext.config = {
|
|
public: config.public,
|
|
app: config.app
|
|
};
|
|
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({
|
|
statusCode: 404,
|
|
statusMessage: "Page Not Found: /__nuxt_error"
|
|
});
|
|
}
|
|
const islandContext = void 0;
|
|
let url = ssrError?.url || islandContext?.url || event.node.req.url;
|
|
const isRenderingPayload = PAYLOAD_URL_RE.test(url) && !islandContext;
|
|
if (isRenderingPayload) {
|
|
url = url.substring(0, url.lastIndexOf("/")) || "/";
|
|
event.node.req.url = url;
|
|
}
|
|
const routeOptions = getRouteRules(event);
|
|
const ssrContext = {
|
|
url,
|
|
event,
|
|
runtimeConfig: useRuntimeConfig(),
|
|
noSSR: !!true ,
|
|
error: !!ssrError,
|
|
nuxt: void 0,
|
|
/* NuxtApp */
|
|
payload: ssrError ? { error: ssrError } : {},
|
|
_payloadReducers: {},
|
|
islandContext
|
|
};
|
|
const renderer = await getSPARenderer() ;
|
|
const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
|
|
const _err = !ssrError && ssrContext.payload?.error || error;
|
|
await ssrContext.nuxt?.hooks.callHook("app:error", _err);
|
|
throw _err;
|
|
});
|
|
await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext });
|
|
if (ssrContext._renderResponse) {
|
|
return ssrContext._renderResponse;
|
|
}
|
|
if (event.node.res.headersSent || event.node.res.writableEnded) {
|
|
return;
|
|
}
|
|
if (ssrContext.payload?.error && !ssrError) {
|
|
throw ssrContext.payload.error;
|
|
}
|
|
if (isRenderingPayload) {
|
|
const response2 = renderPayloadResponse(ssrContext);
|
|
return response2;
|
|
}
|
|
const renderedMeta = await ssrContext.renderMeta?.() ?? {};
|
|
const inlinedStyles = Boolean(islandContext) ? await renderInlineStyles(ssrContext.modules ?? ssrContext._registeredComponents ?? []) : "";
|
|
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>`;
|
|
}
|
|
async function renderInlineStyles(usedModules) {
|
|
const styleMap = await getSSRStyles();
|
|
const inlinedStyles = /* @__PURE__ */ new Set();
|
|
for (const mod of usedModules) {
|
|
if (mod in styleMap) {
|
|
for (const style of await styleMap[mod]()) {
|
|
inlinedStyles.add(`<style>${style}</style>`);
|
|
}
|
|
}
|
|
}
|
|
return Array.from(inlinedStyles).join("");
|
|
}
|
|
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="${!(true )}"`,
|
|
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 }
|
|
};
|
|
}
|
|
|
|
export { renderer as default };
|
|
//# sourceMappingURL=renderer.mjs.map
|