@modern-js/runtime 2.54.6 → 2.56.0

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

@@ -1,11 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useContext, useMemo } from "react";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 import { RuntimeReactContext } from "./context/runtime";
 import { registerPlugin } from "./plugin";
 import { createLoaderManager } from "./loader/loaderManager";
 import { getGlobalRunner } from "./plugin/runner";
+import { getGlobalAppInit } from "./context";
+import { hydrateRoot as ModernHydrateRoot } from "./browser/hydrate";
 const IS_REACT18 = process.env.IS_REACT18 === "true";
 function isClientArgs(id) {
   return typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
@@ -29,24 +30,21 @@ const createApp = ({ plugins, runtime, props: globalProps }) => {
         ...props
       }) : child));
     };
-    if (App) {
-      hoistNonReactStatics(WrapperComponent, App);
-    }
     const HOCApp = runner.hoc({
       App: WrapperComponent,
       config: globalProps || {}
     }, {
       onLast: ({ App: App2 }) => {
-        const WrapComponent = ({ context, ...props }) => {
-          let contextValue = context;
+        const WrapComponent = ({ _internal_context, ...props }) => {
+          let contextValue = _internal_context;
           if (!(contextValue === null || contextValue === void 0 ? void 0 : contextValue.runner)) {
             contextValue = getInitialContext(runner);
             runner.init({
               context: contextValue
             }, {
               onLast: ({ context: context1 }) => {
-                var _App_init;
-                return App2 === null || App2 === void 0 ? void 0 : (_App_init = App2.init) === null || _App_init === void 0 ? void 0 : _App_init.call(App2, context1);
+                var _getGlobalAppInit;
+                return (_getGlobalAppInit = getGlobalAppInit()) === null || _getGlobalAppInit === void 0 ? void 0 : _getGlobalAppInit(context1);
               }
             });
           }
@@ -61,7 +59,7 @@ const createApp = ({ plugins, runtime, props: globalProps }) => {
             })
           });
         };
-        return hoistNonReactStatics(WrapComponent, App2);
+        return WrapComponent;
       }
     });
     return HOCApp;
@@ -75,13 +73,13 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
     context: _context
   }, {
     onLast: ({ context: context1 }) => {
-      var _App_init;
-      return App === null || App === void 0 ? void 0 : (_App_init = App.init) === null || _App_init === void 0 ? void 0 : _App_init.call(App, context1);
+      const init = getGlobalAppInit();
+      return init === null || init === void 0 ? void 0 : init(context1);
     }
   });
   if (!id) {
     return /* @__PURE__ */ React.createElement(App, {
-      context
+      _internal_context: context
     });
   }
   const isBrowser = typeof window !== "undefined" && window.name !== "nodejs";
@@ -92,7 +90,7 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
       const loadersData = (ssrData === null || ssrData === void 0 ? void 0 : (_ssrData_data = ssrData.data) === null || _ssrData_data === void 0 ? void 0 : _ssrData_data.loadersData) || {};
       const initialLoadersState = Object.keys(loadersData).reduce((res, key) => {
         const loaderData = loadersData[key];
-        if (loaderData.loading !== false) {
+        if ((loaderData === null || loaderData === void 0 ? void 0 : loaderData.loading) !== false) {
           return res;
         }
         res[key] = loaderData;
@@ -119,8 +117,12 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
         if (IS_REACT18) {
           if (root) {
             root.render(App2);
-          } else if (ReactDOM.createRoot) {
-            ReactDOM.createRoot(rootElement).render(App2);
+            return root;
+          }
+          if (ReactDOM.createRoot) {
+            const root2 = ReactDOM.createRoot(rootElement);
+            root2.render(App2);
+            return root2;
           } else {
             throw Error("The `bootstrap` `ReactDOM` parameter needs to provide the `createRoot` method");
           }
@@ -129,6 +131,7 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
             throw Error("The `bootstrap` `ReactDOM` parameter needs to provide the `render` method");
           }
           ReactDOM.render(App2, rootElement);
+          return rootElement;
         }
       };
       const ModernHydrate = (App2, callback) => {
@@ -137,78 +140,40 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
             throw Error("The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method");
           }
           ReactDOM.hydrateRoot(rootElement, App2);
-        } else {
-          if (!ReactDOM.hydrate) {
-            throw Error("The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method");
-          }
-          ReactDOM.hydrate(App2, rootElement, callback);
+          return rootElement;
         }
-      };
-      return runner.client({
-        App,
-        context,
-        ModernRender,
-        ModernHydrate
-      }, {
-        onLast: ({ App: App2 }) => {
-          ModernRender(/* @__PURE__ */ React.createElement(App2, {
-            context
-          }));
+        if (!ReactDOM.hydrate) {
+          throw Error("The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method");
         }
-      });
+        ReactDOM.hydrate(App2, rootElement, callback);
+        return rootElement;
+      };
+      if (ssrData) {
+        return ModernHydrateRoot(/* @__PURE__ */ _jsx(App, {}), context, ModernRender, ModernHydrate);
+      }
+      return ModernRender(/* @__PURE__ */ React.createElement(App, {
+        _internal_context: context
+      }));
     } else {
       throw Error("`bootstrap` needs id in browser environment, it needs to be string or element");
     }
   } else {
-    Object.assign(context, {
-      ssrContext: id,
-      isBrowser: false,
-      loaderManager: createLoaderManager({}, {
-        skipNonStatic: id.staticGenerate,
-        // if not static generate, only non-static loader can exec on prod env
-        skipStatic: process.env.NODE_ENV === "production" && !id.staticGenerate
-      })
-    });
-    const isRedirectResponse = (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 } = context;
-        if (ssrContext) {
-          var _ssrContext_res;
-          ssrContext.res && (ssrContext.res.statusCode = status);
-          (_ssrContext_res = ssrContext.res) === null || _ssrContext_res === void 0 ? void 0 : _ssrContext_res.setHeader("Location", redirectUrl);
-          ssrContext.redirection = ssrContext.redirection || {};
-          ssrContext.redirection.status = status;
-          ssrContext.redirection.url = redirectUrl;
-        }
-        return true;
-      }
-      return false;
-    };
-    const initialData = await runInit(context);
-    if (!isRedirectResponse(initialData)) {
-      var _context_routerContext, _context_routerContext1;
-      context.initialData = initialData;
-      if (((_context_routerContext = context.routerContext) === null || _context_routerContext === void 0 ? void 0 : _context_routerContext.statusCode) && ((_context_routerContext1 = context.routerContext) === null || _context_routerContext1 === void 0 ? void 0 : _context_routerContext1.statusCode) !== 200) {
-        var _context_routerContext2, _context_ssrContext;
-        (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.response.status((_context_routerContext2 = context.routerContext) === null || _context_routerContext2 === void 0 ? void 0 : _context_routerContext2.statusCode);
-      }
-      return runner.server({
-        App,
-        context
-      });
-    }
+    throw Error("Bootstrap function not support ssr render");
   }
 };
 const useRuntimeContext = () => {
+  var _context_ssrContext, _context_ssrContext1;
   const context = useContext(RuntimeReactContext);
+  const pickedContext = {
+    initialData: context.initialData,
+    request: (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.request,
+    response: (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : _context_ssrContext1.response
+  };
   const memoizedContext = useMemo(() => context.runner.pickContext({
     context,
-    pickedContext: {}
+    pickedContext
   }, {
-    onLast: ({ pickedContext }) => pickedContext
+    onLast: ({ pickedContext: pickedContext2 }) => pickedContext2
   }), [
     context
   ]);

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

@@ -1,4 +1,35 @@
 import { RuntimeReactContext } from "./runtime";
+const globalContext = {};
+function setGlobalContext(context) {
+  globalContext.App = context.App;
+  globalContext.routes = context.routes;
+  globalContext.appInit = context.appInit;
+  globalContext.appConfig = typeof context.appConfig === "function" ? context.appConfig() : context.appConfig;
+  globalContext.layoutApp = context.layoutApp;
+}
+function getGlobalApp() {
+  return globalContext.App;
+}
+function getGlobalRoutes() {
+  return globalContext.routes;
+}
+function getGlobalAppInit() {
+  var _getGlobalApp, _getGlobalLayoutApp;
+  return globalContext.appInit || ((_getGlobalApp = getGlobalApp()) === null || _getGlobalApp === void 0 ? void 0 : _getGlobalApp.init) || ((_getGlobalLayoutApp = getGlobalLayoutApp()) === null || _getGlobalLayoutApp === void 0 ? void 0 : _getGlobalLayoutApp.init);
+}
+function getGlobalAppConfig() {
+  var _getGlobalApp, _getGlobalLayoutApp;
+  return globalContext.appConfig || ((_getGlobalApp = getGlobalApp()) === null || _getGlobalApp === void 0 ? void 0 : _getGlobalApp.config) || ((_getGlobalLayoutApp = getGlobalLayoutApp()) === null || _getGlobalLayoutApp === void 0 ? void 0 : _getGlobalLayoutApp.config);
+}
+function getGlobalLayoutApp() {
+  return globalContext.layoutApp;
+}
 export {
-  RuntimeReactContext
+  RuntimeReactContext,
+  getGlobalApp,
+  getGlobalAppConfig,
+  getGlobalAppInit,
+  getGlobalLayoutApp,
+  getGlobalRoutes,
+  setGlobalContext
 };

package/dist/esm-node/core/context/runtime.js

@@ -3,11 +3,11 @@ import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 import { createLoaderManager } from "../loader/loaderManager";
 const RuntimeReactContext = createContext({});
 const ServerRouterContext = createContext({});
-const getInitialContext = (runner) => ({
+const getInitialContext = (runner, isBrowser = true, routeManifest) => ({
   loaderManager: createLoaderManager({}),
   runner,
-  isBrowser: true,
-  routeManifest: typeof window !== "undefined" && window[ROUTE_MANIFEST]
+  isBrowser,
+  routeManifest: routeManifest || typeof window !== "undefined" && window[ROUTE_MANIFEST]
 });
 export {
   RuntimeReactContext,

package/dist/esm-node/core/loader/useLoader.js

@@ -14,7 +14,7 @@ const useLoader = (loaderFn, options = {
     delete options._cache;
   }
   const load = useCallback((params) => {
-    var _unlistenLoaderChangeRef_current, _window__SSR_DATA_data_loadersData_id, _window__SSR_DATA_data, _window__SSR_DATA, _window, _loaderRef_current;
+    var _unlistenLoaderChangeRef_current, _window__SSR_DATA_data_loadersData_id, _window__SSR_DATA_data_loadersData, _window__SSR_DATA_data, _window__SSR_DATA, _window, _loaderRef_current;
     if (typeof params === "undefined") {
       var _loaderRef_current1;
       return (_loaderRef_current1 = loaderRef.current) === null || _loaderRef_current1 === void 0 ? void 0 : _loaderRef_current1.load();
@@ -41,7 +41,7 @@ const useLoader = (loaderFn, options = {
     if (options.skip) {
       return void 0;
     }
-    if (context._hydration && ((_window = window) === null || _window === void 0 ? void 0 : (_window__SSR_DATA = _window._SSR_DATA) === null || _window__SSR_DATA === void 0 ? void 0 : (_window__SSR_DATA_data = _window__SSR_DATA.data) === null || _window__SSR_DATA_data === void 0 ? void 0 : (_window__SSR_DATA_data_loadersData_id = _window__SSR_DATA_data.loadersData[id]) === null || _window__SSR_DATA_data_loadersData_id === void 0 ? void 0 : _window__SSR_DATA_data_loadersData_id.error) === null) {
+    if (context._hydration && ((_window = window) === null || _window === void 0 ? void 0 : (_window__SSR_DATA = _window._SSR_DATA) === null || _window__SSR_DATA === void 0 ? void 0 : (_window__SSR_DATA_data = _window__SSR_DATA.data) === null || _window__SSR_DATA_data === void 0 ? void 0 : (_window__SSR_DATA_data_loadersData = _window__SSR_DATA_data.loadersData) === null || _window__SSR_DATA_data_loadersData === void 0 ? void 0 : (_window__SSR_DATA_data_loadersData_id = _window__SSR_DATA_data_loadersData[id]) === null || _window__SSR_DATA_data_loadersData_id === void 0 ? void 0 : _window__SSR_DATA_data_loadersData_id.error) === null) {
       return void 0;
     }
     const res = loaderRef.current.load();

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

@@ -1,14 +1,10 @@
 import { createManager, createPipeline, createAsyncPipeline } from "@modern-js/plugin";
-const client = createAsyncPipeline();
-const server = createAsyncPipeline();
 const hoc = createPipeline();
 const init = createAsyncPipeline();
 const pickContext = createPipeline();
 const runtimeHooks = {
   hoc,
   init,
-  client,
-  server,
   pickContext
 };
 const createRuntime = () => createManager(runtimeHooks);

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

@@ -1,3 +1,4 @@
+import { merge } from "../utils/merge";
 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)) {