dtwo 2.17.0 → 3.0.0-rc.14

package/dist/core/runtime/hole/paths.mjs

@@ -0,0 +1,15 @@
+import { joinURL } from "ufo";
+import { useRuntimeConfig } from "#internal/hole";
+export function baseURL() {
+  return useRuntimeConfig().app.baseURL;
+}
+export function buildAssetsDir() {
+  return useRuntimeConfig().app.buildAssetsDir;
+}
+export function buildAssetsURL(...path) {
+  return joinURL(publicAssetsURL(), useRuntimeConfig().app.buildAssetsDir, ...path);
+}
+export function publicAssetsURL(...path) {
+  const publicBase = useRuntimeConfig().app.cdnURL || useRuntimeConfig().app.baseURL;
+  return path.length ? joinURL(publicBase, ...path) : publicBase;
+}

package/dist/core/runtime/hole/renderer.d.ts

@@ -0,0 +1,16 @@
+export interface DtwoRenderHTMLContext {
+    htmlAttrs: string[];
+    head: string[];
+    bodyAttrs: string[];
+    bodyPrepend: string[];
+    body: string[];
+    bodyAppend: string[];
+}
+export interface DtwoRenderResponse {
+    body: string;
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string>;
+}
+declare const _default: any;
+export default _default;

package/dist/core/runtime/hole/renderer.mjs

@@ -0,0 +1,219 @@
+import { createRenderer, renderResourceHeaders } from "kdu-bundle-renderer/runtime";
+import { appendHeader, createError, getQuery, writeEarlyHints } from "h3";
+import devalue from "@d2js/devalue";
+import { joinURL } from "ufo";
+import { renderToString as _renderToString } from "kdu/server-renderer";
+import { useRuntimeConfig, useHoleApp, defineRenderHandler, getRouteRules } from "#internal/hole";
+import { appRootId, appRootTag } from "#internal/dtwo.config.mjs";
+import { buildAssetsURL, publicAssetsURL } from "#paths";
+globalThis.__buildAssetsURL = buildAssetsURL;
+globalThis.__publicAssetsURL = publicAssetsURL;
+const getClientManifest = () => import("#build/dist/server/client.manifest.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
+const getStaticRenderedHead = () => import("#head-static").then((r) => r.default || r);
+const getServerEntry = () => import("#build/dist/server/server.mjs").then((r) => r.default || r);
+const getSSRStyles = () => import("#build/dist/server/styles.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,
+    buildAssetsURL
+  };
+  const renderer = createRenderer(createSSRApp, options);
+  async function renderToString(input, context) {
+    const html = await _renderToString(input, context);
+    if (process.dev && process.env.DTWO_WITE_NODE_OPTIONS) {
+      renderer.rendererContext.updateManifest(await getClientManifest());
+    }
+    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 = {
+      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_CACHE = process.env.DTWO_PAYLOAD_EXTRACTION && process.env.prerender ? /* @__PURE__ */ new Map() : null;
+const PAYLOAD_URL_RE = /\/_payload(\.[a-zA-Z0-9]+)?.js(\?.*)?$/;
+const PRERENDER_NO_SSR_ROUTES = /* @__PURE__ */ new Set(["/index.html", "/200.html", "/404.html"]);
+export default defineRenderHandler(async (event) => {
+  const ssrError = event.node.req.url?.startsWith("/__dtwo_error") ? getQuery(event) : null;
+  if (ssrError && event.node.req.socket.readyState !== "readOnly") {
+    throw createError("Cannot directly render error page!");
+  }
+  let url = ssrError?.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;
+    if (process.env.prerender && PAYLOAD_CACHE.has(url)) {
+      return PAYLOAD_CACHE.get(url);
+    }
+  }
+  const routeOptions = getRouteRules(event);
+  const ssrContext = {
+    url,
+    event,
+    runtimeConfig: useRuntimeConfig(),
+    noSSR: !!process.env.DTWO_NO_SSR || !!event.node.req.headers["x-dtwo-no-ssr"] || routeOptions.ssr === false || (process.env.prerender ? PRERENDER_NO_SSR_ROUTES.has(url) : false),
+    error: !!ssrError,
+    dtwo: void 0,
+    payload: ssrError ? { error: ssrError } : {}
+  };
+  const _PAYLOAD_EXTRACTION = process.env.prerender && process.env.DTWO_PAYLOAD_EXTRACTION && !ssrContext.noSSR;
+  const payloadURL = _PAYLOAD_EXTRACTION ? joinURL(useRuntimeConfig().app.baseURL, url, "_payload.js") : void 0;
+  if (process.env.prerender) {
+    ssrContext.payload.prerenderedAt = Date.now();
+  }
+  const renderer = process.env.DTWO_NO_SSR || ssrContext.noSSR ? await getSPARenderer() : await getSSRRenderer();
+  if (process.env.DTWO_EARLY_HINTS && !isRenderingPayload && !process.env.prerender) {
+    const { link } = renderResourceHeaders({}, renderer.rendererContext);
+    writeEarlyHints(event, link);
+  }
+  const _rendered = await renderer.renderToString(ssrContext).catch((error) => {
+    throw !ssrError && ssrContext.payload?.error || error;
+  });
+  await ssrContext.dtwo?.hooks.callHook("app:rendered", { ssrContext });
+  if (ssrContext.payload?.error && !ssrError) {
+    throw ssrContext.payload.error;
+  }
+  if (isRenderingPayload) {
+    const response2 = renderPayloadResponse(ssrContext);
+    if (process.env.prerender) {
+      PAYLOAD_CACHE.set(url, response2);
+    }
+    return response2;
+  }
+  if (_PAYLOAD_EXTRACTION) {
+    appendHeader(event, "x-hole-prerender", joinURL(url, "_payload.js"));
+    PAYLOAD_CACHE.set(url, renderPayloadResponse(ssrContext));
+  }
+  const renderedMeta = await ssrContext.renderMeta?.() ?? {};
+  const inlinedStyles = process.env.DTWO_INLINE_STYLES ? await renderInlineStyles(ssrContext.modules ?? ssrContext._registeredComponents ?? []) : "";
+  const htmlContext = {
+    htmlAttrs: normalizeChunks([renderedMeta.htmlAttrs]),
+    head: normalizeChunks([
+      renderedMeta.headTags,
+      _PAYLOAD_EXTRACTION ? `<link rel="modulepreload" href="${payloadURL}">` : null,
+      _rendered.renderResourceHints(),
+      _rendered.renderStyles(),
+      inlinedStyles,
+      ssrContext.styles
+    ]),
+    bodyAttrs: normalizeChunks([renderedMeta.bodyAttrs]),
+    bodyPrepend: normalizeChunks([
+      renderedMeta.bodyScriptsPrepend,
+      ssrContext.teleports?.body
+    ]),
+    body: [
+      _rendered.html
+    ],
+    bodyAppend: normalizeChunks([
+      process.env.DTWO_NO_SCRIPTS ? void 0 : _PAYLOAD_EXTRACTION ? `<script type="module">import p from "${payloadURL}";window.__DTWO__={...p,...(${devalue(splitPayload(ssrContext).initial)})}<\/script>` : `<script>window.__DTWO__=${devalue(ssrContext.payload)}<\/script>`,
+      _rendered.renderScripts(),
+      renderedMeta.bodyScripts
+    ])
+  };
+  const holeApp = useHoleApp();
+  await holeApp.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": "Dtwo"
+    }
+  };
+  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: `export default ${devalue(splitPayload(ssrContext).payload)}`,
+    statusCode: ssrContext.event.node.res.statusCode,
+    statusMessage: ssrContext.event.node.res.statusMessage,
+    headers: {
+      "content-type": "text/javascript;charset=UTF-8",
+      "x-powered-by": "Dtwo"
+    }
+  };
+}
+function splitPayload(ssrContext) {
+  const { data, prerenderedAt, ...initial } = ssrContext.payload;
+  return {
+    initial: { ...initial, prerenderedAt },
+    payload: { data, prerenderedAt }
+  };
+}