@modern-js/runtime 2.54.5 → 2.55.0

package/dist/esm-node/core/plugin/index.js

@@ -1,3 +1,4 @@
+import { merge } from "@modern-js/utils/lodash";
 import { runtime } from "./base";
 import { setGlobalRunner } from "./runner";
 export * from "./base";
@@ -8,6 +9,10 @@ function registerPlugin(internalPlugins, runtimeConfig, customRuntime) {
   setGlobalRunner(runner);
   return runner;
 }
+function mergeConfig(config, ...otherConfig) {
+  return merge(config, ...otherConfig);
+}
 export {
+  mergeConfig,
   registerPlugin
 };

package/dist/esm-node/core/react/index.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RuntimeReactContext, getGlobalApp } from "../context";
+import { getGlobalRunner } from "../plugin/runner";
+function createRoot(UserApp, config) {
+  const App = UserApp || getGlobalApp();
+  const runner = getGlobalRunner();
+  const HOCApp = runner.hoc({
+    App,
+    config: config || {}
+  }, {
+    onLast: ({ App: App2 }) => {
+      const WrapComponent = ({ _internal_context, ...props }) => {
+        return /* @__PURE__ */ _jsx(RuntimeReactContext.Provider, {
+          value: _internal_context,
+          children: /* @__PURE__ */ _jsx(App2, {
+            ...props
+          })
+        });
+      };
+      return WrapComponent;
+    }
+  });
+  return HOCApp;
+}
+export {
+  createRoot
+};

package/dist/esm-node/{ssr/serverRender → core/server}/helmet.js

@@ -5,7 +5,10 @@ const RE_BODY_ATTR = /<body[^>]*>/;
 const RE_LAST_IN_HEAD = /<\/head>/;
 const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
 const TEST_TITLE_CONTENT = RegExp("(?<=<title[^>]*>)([\\s\\S\\n\\r]*?)([.|\\S])([\\s\\S\\n\\r]*?)(?=<\\/title>)");
-function helmet(content, helmetData) {
+function createReplaceHelemt(helmetData) {
+  return helmetData ? (template) => helmetReplace(template, helmetData) : (tempalte) => tempalte;
+}
+function helmetReplace(content, helmetData) {
   let result = content;
   const bodyAttributes = helmetData.bodyAttributes.toString();
   if (bodyAttributes) {
@@ -41,5 +44,6 @@ function helmet(content, helmetData) {
   return safeReplace(result, RE_LAST_IN_HEAD, `${helmetStr}</head>`);
 }
 export {
-  helmet as default
+  createReplaceHelemt,
+  helmetReplace
 };

package/dist/esm-node/core/server/index.js

@@ -0,0 +1,12 @@
+import { PreRender, NoSSR } from "./react";
+const ssr = (_config) => ({
+  name: "@modern-js/plugin-ssr",
+  setup: () => ({})
+});
+var server_default = ssr;
+export {
+  NoSSR,
+  PreRender,
+  server_default as default,
+  ssr
+};

package/dist/esm-node/core/server/requestHandler.js

@@ -0,0 +1,132 @@
+import { getPathname, parseCookie, parseHeaders, parseQuery } from "@modern-js/runtime-utils/universal/request";
+import { createRoot } from "../react";
+import { getGlobalAppInit } from "../context";
+import { getGlobalRunner } from "../plugin/runner";
+import { getInitialContext } from "../context/runtime";
+import { createLoaderManager } from "../loader/loaderManager";
+import { getSSRConfigByEntry, getSSRMode } from "./utils";
+import { CHUNK_CSS_PLACEHOLDER } from "./constants";
+function createSSRContext(request, options) {
+  const { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, staticGenerate, logger, metrics, reporter } = options;
+  const { nonce } = config;
+  const { entryName, route } = resource;
+  const cookie = request.headers.get("cookie");
+  const cookieMap = parseCookie(request);
+  const pathname = getPathname(request);
+  const query = parseQuery(request);
+  const headersData = parseHeaders(request);
+  const url = new URL(request.url);
+  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+  const ssrMode = getSSRMode(ssrConfig);
+  const loaderFailureMode = typeof ssrConfig === "object" ? ssrConfig.loaderFailureMode : void 0;
+  return {
+    nonce,
+    loaderContext,
+    redirection: {},
+    htmlModifiers: [],
+    logger,
+    metrics,
+    request: {
+      baseUrl: route.urlPath,
+      userAgent: request.headers.get("user-agent"),
+      cookie,
+      cookieMap,
+      pathname,
+      query,
+      params,
+      headers: headersData,
+      host: url.host,
+      raw: request
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers[key] = value;
+      },
+      status(code) {
+        responseProxy.code = code;
+      },
+      locals: locals || {}
+    },
+    reporter,
+    mode: ssrMode,
+    onError,
+    onTiming,
+    loaderFailureMode
+  };
+}
+const createRequestHandler = async (handleRequest) => {
+  const requestHandler = async (request, options) => {
+    const Root = createRoot();
+    const runner = getGlobalRunner();
+    const { routeManifest } = options.resource;
+    const context = getInitialContext(runner, false, routeManifest);
+    const runInit = (_context) => runner.init({
+      context: _context
+    }, {
+      onLast: ({ context: context1 }) => {
+        const init = getGlobalAppInit();
+        return init === null || init === void 0 ? void 0 : init(context1);
+      }
+    });
+    const responseProxy = {
+      headers: {},
+      code: -1
+    };
+    const ssrContext = createSSRContext(request, {
+      ...options,
+      responseProxy
+    });
+    Object.assign(context, {
+      ssrContext,
+      isBrowser: false,
+      loaderManager: createLoaderManager({}, {
+        skipNonStatic: options.staticGenerate,
+        // if not static generate, only non-static loader can exec on prod env
+        skipStatic: process.env.NODE_ENV === "production" && !options.staticGenerate
+      })
+    });
+    const getRedirectResponse = (result) => {
+      if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
+      result instanceof Response && result.status >= 300 && result.status <= 399) {
+        const { status } = result;
+        const redirectUrl = result.headers.get("Location") || "/";
+        const { ssrContext: ssrContext2 } = context;
+        if (ssrContext2) {
+          return new Response(null, {
+            status,
+            headers: {
+              Location: redirectUrl
+            }
+          });
+        }
+      }
+      return void 0;
+    };
+    const initialData = await runInit(context);
+    context.initialData = initialData;
+    const redirectResponse = getRedirectResponse(initialData);
+    if (redirectResponse) {
+      return redirectResponse;
+    }
+    const { htmlTemplate } = options.resource;
+    options.resource.htmlTemplate = htmlTemplate.replace("</head>", `${CHUNK_CSS_PLACEHOLDER}</head>`);
+    const response = await handleRequest(request, Root, {
+      ...options,
+      runtimeContext: context
+    });
+    Object.entries(responseProxy.headers).forEach(([key, value]) => {
+      response.headers.set(key, value);
+    });
+    if (responseProxy.code !== -1) {
+      return new Response(response.body, {
+        status: responseProxy.code,
+        headers: response.headers
+      });
+    }
+    return response;
+  };
+  return requestHandler;
+};
+export {
+  createRequestHandler
+};

package/dist/esm-node/core/server/server.js

@@ -0,0 +1,8 @@
+import { renderString } from "./string";
+import { renderStreaming } from "./stream";
+import { createRequestHandler } from "./requestHandler";
+export {
+  createRequestHandler,
+  renderStreaming,
+  renderString
+};

package/dist/esm-node/core/server/shared.js

@@ -0,0 +1,6 @@
+function buildHtml(template, callbacks) {
+  return callbacks.reduce((promise, buildHtmlCb) => promise.then((template2) => buildHtmlCb(template2)), Promise.resolve(template));
+}
+export {
+  buildHtml
+};

package/dist/esm-node/core/server/stream/afterTemplate.js

@@ -0,0 +1,56 @@
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString, safeReplace } from "../utils";
+import { SSR_DATA_PLACEHOLDER } from "../constants";
+import { buildHtml } from "../shared";
+function buildShellAfterTemplate(afterAppTemplate, options) {
+  const { request, config, ssrConfig, runtimeContext, renderLevel } = options;
+  const callbacks = [
+    createReplaceSSRData({
+      request,
+      ssrConfig,
+      nonce: config.nonce,
+      runtimeContext,
+      renderLevel
+    })
+  ];
+  return buildHtml(afterAppTemplate, callbacks);
+}
+function createReplaceSSRData(options) {
+  const { runtimeContext, nonce, renderLevel, ssrConfig } = options;
+  const { request, reporter } = runtimeContext.ssrContext;
+  const headers = typeof ssrConfig === "object" && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _]) => {
+    var _ssrConfig_unsafeHeaders_map, _ssrConfig_unsafeHeaders;
+    return (_ssrConfig_unsafeHeaders = ssrConfig.unsafeHeaders) === null || _ssrConfig_unsafeHeaders === void 0 ? void 0 : (_ssrConfig_unsafeHeaders_map = _ssrConfig_unsafeHeaders.map((header) => header.toLowerCase())) === null || _ssrConfig_unsafeHeaders_map === void 0 ? void 0 : _ssrConfig_unsafeHeaders_map.includes(key.toLowerCase());
+  })) : void 0;
+  const ssrData = {
+    data: {
+      initialData: runtimeContext.initialData,
+      i18nData: runtimeContext.__i18nData__
+    },
+    context: {
+      reporter: {
+        sessionId: reporter === null || reporter === void 0 ? void 0 : reporter.sessionId
+      },
+      request: {
+        query: request.query,
+        params: request.params,
+        pathname: request.pathname,
+        host: request.host,
+        url: request.raw.url,
+        headers
+      }
+    },
+    mode: "stream",
+    renderLevel
+  };
+  const attrsStr = attributesToString({
+    nonce
+  });
+  const ssrDataScript = `
+    <script${attrsStr}>window._SSR_DATA = ${serializeJson(ssrData)}</script>
+    `;
+  return (template) => safeReplace(template, SSR_DATA_PLACEHOLDER, ssrDataScript);
+}
+export {
+  buildShellAfterTemplate
+};

package/dist/esm-node/{ssr/serverRender/renderToStream/bulidTemplate.before.js → core/server/stream/beforeTemplate.js}

@@ -1,9 +1,9 @@
 import ReactHelmet from "react-helmet";
 import { matchRoutes } from "@modern-js/runtime-utils/router";
-import helmetReplace from "../helmet";
+import { createReplaceHelemt } from "../helmet";
 import { CHUNK_CSS_PLACEHOLDER } from "../constants";
 import { checkIsNode, safeReplace } from "../utils";
-import { buildTemplate } from "./buildTemplate.share";
+import { buildHtml } from "../shared";
 const readAsset = async (chunk) => {
   const fs = await import("fs/promises");
   const path = await import("path");
@@ -21,16 +21,15 @@ const checkIsInline = (chunk, enableInline) => {
     return false;
   }
 };
-async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig, styledComponentsStyleTags) {
+async function buildShellBeforeTemplate(beforeAppTemplate, options) {
+  const { config, runtimeContext, styledComponentsStyleTags } = options;
   const helmetData = ReactHelmet.renderStatic();
   const callbacks = [
-    (headTemplate) => {
-      return helmetData ? helmetReplace(headTemplate, helmetData) : headTemplate;
-    },
+    createReplaceHelemt(helmetData),
     // @TODO: prefetch scripts of lazy component
     (template) => injectCss(template, styledComponentsStyleTags)
   ];
-  return buildTemplate(beforeAppTemplate, callbacks);
+  return buildHtml(beforeAppTemplate, callbacks);
   async function injectCss(template, styledComponentsStyleTags2) {
     let css = await getCssChunks();
     if (styledComponentsStyleTags2) {
@@ -38,7 +37,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig
     }
     return safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);
     async function getCssChunks() {
-      const { routeManifest, routerContext, routes } = context;
+      const { routeManifest, routerContext, routes } = runtimeContext;
       if (!routeManifest || !routerContext || !routes) {
         return "";
       }
@@ -59,7 +58,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, context, pluginConfig
           }
         }
       });
-      const { enableInlineStyles } = pluginConfig;
+      const { enableInlineStyles } = config;
       const styles = await Promise.all(cssChunks.map(async (chunk) => {
         const link = `<link href="${chunk}" rel="stylesheet" />`;
         if (checkIsNode() && checkIsInline(chunk, enableInlineStyles)) {

package/dist/esm-node/{ssr/serverRender/renderToStream/renderToPipe.js → core/server/stream/createReadableStream.js}

@@ -1,46 +1,46 @@
 import { Transform } from "stream";
+import { renderToPipeableStream } from "react-dom/server";
+import { createReadableStreamFromReadable } from "@modern-js/runtime-utils/node";
 import { ServerStyleSheet } from "styled-components";
-import { RenderLevel } from "../types";
+import checkIsBot from "isbot";
 import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { RenderLevel } from "../../constants";
 import { getTemplates } from "./template";
-var ShellChunkStatus;
-(function(ShellChunkStatus2) {
-  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
-  ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 1] = "FINIESH";
-})(ShellChunkStatus || (ShellChunkStatus = {}));
-function renderToPipe(rootElement, context, pluginConfig, options) {
-  var _context_ssrContext;
-  let shellChunkStatus = 0;
+import { ShellChunkStatus, getReadableStreamFromString } from "./shared";
+const createReadableStreamFromElement = (request, rootElement, options) => {
+  const { runtimeContext, htmlTemplate, config, ssrConfig } = options;
+  let shellChunkStatus = ShellChunkStatus.START;
+  let renderLevel = RenderLevel.SERVER_RENDER;
   const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
-  const onReady = ((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.isSpider) || forceStream2String ? "onAllReady" : "onShellReady";
+  const isbot = checkIsBot(request.headers.get("user-agent"));
+  const onReady = isbot || forceStream2String ? "onAllReady" : "onShellReady";
   const sheet = new ServerStyleSheet();
-  const { ssrContext } = context;
   const chunkVec = [];
-  const forUserPipe = new Promise((resolve) => {
-    let renderToPipeableStream;
-    try {
-      ({ renderToPipeableStream } = require("react-dom/server"));
-    } catch (e) {
-    }
-    const root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
-    let renderLevel = RenderLevel.SERVER_RENDER;
+  const root = forceStream2String ? sheet.collectStyles(rootElement) : rootElement;
+  return new Promise((resolve) => {
     const { pipe } = renderToPipeableStream(root, {
-      ...options,
-      nonce: ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.nonce,
+      nonce: config.nonce,
       [onReady]() {
+        var _options_onReady;
         const styledComponentsStyleTags = forceStream2String ? sheet.getStyleTags() : "";
-        getTemplates(context, renderLevel, pluginConfig, styledComponentsStyleTags).then(({ shellAfter, shellBefore }) => {
-          var _options_onReady;
-          options === null || options === void 0 ? void 0 : (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
-          const injectableTransform = new Transform({
+        (_options_onReady = options[onReady]) === null || _options_onReady === void 0 ? void 0 : _options_onReady.call(options);
+        getTemplates(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config,
+          styledComponentsStyleTags
+        }).then(({ shellAfter, shellBefore }) => {
+          const body = new Transform({
             transform(chunk, _encoding, callback) {
               try {
-                if (shellChunkStatus !== 1) {
+                if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                   chunkVec.push(chunk.toString());
                   let concatedChunk = chunkVec.join("");
                   if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
                     concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
-                    shellChunkStatus = 1;
+                    shellChunkStatus = ShellChunkStatus.FINISH;
                     this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
                   }
                 } else {
@@ -56,16 +56,24 @@ function renderToPipe(rootElement, context, pluginConfig, options) {
               }
             }
           });
-          pipe(injectableTransform);
-          resolve(injectableTransform);
+          const stream = createReadableStreamFromReadable(body);
+          resolve(stream);
+          pipe(body);
         });
       },
       onShellError(error) {
         renderLevel = RenderLevel.CLIENT_RENDER;
-        getTemplates(context, renderLevel, pluginConfig).then(({ shellAfter, shellBefore }) => {
+        getTemplates(htmlTemplate, {
+          request,
+          ssrConfig,
+          renderLevel,
+          runtimeContext,
+          config
+        }).then(({ shellAfter, shellBefore }) => {
           var _options_onShellError;
           const fallbackHtml = `${shellBefore}${shellAfter}`;
-          resolve(fallbackHtml);
+          const readableStream = getReadableStreamFromString(fallbackHtml);
+          resolve(readableStream);
           options === null || options === void 0 ? void 0 : (_options_onShellError = options.onShellError) === null || _options_onShellError === void 0 ? void 0 : _options_onShellError.call(options, error);
         });
       },
@@ -76,9 +84,7 @@ function renderToPipe(rootElement, context, pluginConfig, options) {
       }
     });
   });
-  return forUserPipe;
-}
-var renderToPipe_default = renderToPipe;
+};
 export {
-  renderToPipe_default as default
+  createReadableStreamFromElement
 };

package/dist/esm-node/core/server/stream/createReadableStream.worker.js

@@ -0,0 +1,71 @@
+import { renderToReadableStream } from "react-dom/server";
+import checkIsBot from "isbot";
+import { RenderLevel } from "../../constants";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
+import { ShellChunkStatus, encodeForWebStream, getReadableStreamFromString } from "./shared";
+import { getTemplates } from "./template";
+const createReadableStreamFromElement = async (request, rootElement, options) => {
+  let shellChunkStatus = ShellChunkStatus.START;
+  const chunkVec = [];
+  const { htmlTemplate, runtimeContext, config, ssrConfig } = options;
+  const { shellBefore, shellAfter } = await getTemplates(htmlTemplate, {
+    renderLevel: RenderLevel.SERVER_RENDER,
+    runtimeContext,
+    ssrConfig,
+    request,
+    config
+  });
+  try {
+    var _options_onShellReady;
+    const readableOriginal = await renderToReadableStream(rootElement, {
+      nonce: config.nonce,
+      onError(error) {
+        var _options_onError;
+        (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, error);
+      }
+    });
+    (_options_onShellReady = options.onShellReady) === null || _options_onShellReady === void 0 ? void 0 : _options_onShellReady.call(options);
+    readableOriginal.allReady.then(() => {
+      var _options_onAllReady;
+      options === null || options === void 0 ? void 0 : (_options_onAllReady = options.onAllReady) === null || _options_onAllReady === void 0 ? void 0 : _options_onAllReady.call(options);
+    });
+    const isbot = checkIsBot(request.headers.get("user-agent"));
+    if (isbot) {
+      await readableOriginal.allReady;
+    }
+    const reader = readableOriginal.getReader();
+    const stream = new ReadableStream({
+      start(controller) {
+        async function push() {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (shellChunkStatus !== ShellChunkStatus.FINISH) {
+            const chunk = new TextDecoder().decode(value);
+            chunkVec.push(chunk);
+            let concatedChunk = chunkVec.join("");
+            if (concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
+              concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, "");
+              shellChunkStatus = ShellChunkStatus.FINISH;
+              controller.enqueue(encodeForWebStream(`${shellBefore}${concatedChunk}${shellAfter}`));
+            }
+          } else {
+            controller.enqueue(value);
+          }
+          push();
+        }
+        push();
+      }
+    });
+    return stream;
+  } catch (e) {
+    const fallbackHtml = `${shellBefore}${shellAfter}`;
+    const stream = getReadableStreamFromString(fallbackHtml);
+    return stream;
+  }
+};
+export {
+  createReadableStreamFromElement
+};

package/dist/esm-node/core/server/stream/index.js

@@ -0,0 +1,6 @@
+import { createReadableStreamFromElement } from "./createReadableStream";
+import { createRenderStreaming } from "./shared";
+const renderStreaming = createRenderStreaming(createReadableStreamFromElement);
+export {
+  renderStreaming
+};

package/dist/esm-node/core/server/stream/shared.js

@@ -0,0 +1,75 @@
+import { time } from "@modern-js/runtime-utils/time";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { run } from "@modern-js/runtime-utils/node";
+import React from "react";
+import { SSRErrors, SSRTimings, createOnError, createOnTiming } from "../tracer";
+import { getSSRConfigByEntry } from "../utils";
+var ShellChunkStatus;
+(function(ShellChunkStatus2) {
+  ShellChunkStatus2[ShellChunkStatus2["START"] = 0] = "START";
+  ShellChunkStatus2[ShellChunkStatus2["FINISH"] = 1] = "FINISH";
+})(ShellChunkStatus || (ShellChunkStatus = {}));
+let encoder;
+function encodeForWebStream(thing) {
+  if (!encoder) {
+    encoder = new TextEncoder();
+  }
+  if (typeof thing === "string") {
+    return encoder.encode(thing);
+  }
+  return thing;
+}
+function getReadableStreamFromString(content) {
+  const readableStream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encodeForWebStream(content));
+      controller.close();
+    }
+  });
+  return readableStream;
+}
+function createRenderStreaming(createReadableStreamFromElement) {
+  return async (request, serverRoot, options) => {
+    const headersData = parseHeaders(request);
+    return run(headersData, async () => {
+      const end = time();
+      const { runtimeContext, config, resource, staticGenerate } = options;
+      const onError = createOnError(options.onError);
+      const onTiming = createOnTiming(options.onTiming);
+      const { htmlTemplate, entryName } = resource;
+      const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+      const rootElement = React.cloneElement(serverRoot, {
+        _internal_context: Object.assign(runtimeContext, {
+          ssr: true
+        })
+      });
+      const stream = await createReadableStreamFromElement(request, rootElement, {
+        config,
+        htmlTemplate,
+        runtimeContext,
+        ssrConfig,
+        onShellReady() {
+          const cost = end();
+          onTiming(SSRTimings.RENDER_SHELL, cost);
+        },
+        onAllReady() {
+          const cost = end();
+          onTiming(SSRTimings.RENDER_HTML, cost);
+        },
+        onShellError(error) {
+          onError(SSRErrors.RENDER_SHELL, error);
+        },
+        onError(error) {
+          onError(SSRErrors.RENDER_STREAM, error);
+        }
+      });
+      return stream;
+    });
+  };
+}
+export {
+  ShellChunkStatus,
+  createRenderStreaming,
+  encodeForWebStream,
+  getReadableStreamFromString
+};

package/dist/esm-node/core/server/stream/template.js

@@ -0,0 +1,15 @@
+import { buildShellBeforeTemplate } from "./beforeTemplate";
+import { buildShellAfterTemplate } from "./afterTemplate";
+const HTML_SEPARATOR = "<!--<?- html ?>-->";
+const getTemplates = async (htmlTemplate, options) => {
+  const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = htmlTemplate.split(HTML_SEPARATOR) || [];
+  const builtBeforeTemplate = await buildShellBeforeTemplate(beforeAppTemplate, options);
+  const builtAfterTemplate = await buildShellAfterTemplate(afterAppHtmlTemplate, options);
+  return {
+    shellBefore: builtBeforeTemplate,
+    shellAfter: builtAfterTemplate
+  };
+};
+export {
+  getTemplates
+};