@modern-js/runtime 2.54.6 → 2.55.0

package/dist/esm-node/cli/ssr/index.js

@@ -0,0 +1,87 @@
+import path from "path";
+import { LOADABLE_STATS_FILE, isUseSSRBundle } from "@modern-js/utils";
+const hasStringSSREntry = (userConfig) => {
+  const isStreaming = (ssr) => ssr && typeof ssr === "object" && ssr.mode === "stream";
+  const { server, output } = userConfig;
+  if (((server === null || server === void 0 ? void 0 : server.ssr) || output.ssg) && !isStreaming(server.ssr)) {
+    return true;
+  }
+  if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+    for (const name of Object.keys(server.ssrByEntries)) {
+      if (server.ssrByEntries[name] && !isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const checkUseStringSSR = (config) => {
+  const { output } = config;
+  return Boolean(output === null || output === void 0 ? void 0 : output.ssg) || hasStringSSREntry(config);
+};
+const ssrPlugin = () => ({
+  name: "@modern-js/plugin-ssr",
+  required: [
+    "@modern-js/runtime"
+  ],
+  setup: (api) => {
+    return {
+      // for bundle
+      config() {
+        const { bundlerType = "webpack" } = api.useAppContext();
+        const babelHandler = (() => {
+          if (bundlerType === "webpack") {
+            return (config) => {
+              var _config_plugins;
+              const userConfig = api.useResolvedConfigContext();
+              (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(path.join(__dirname, "./babel-plugin-ssr-loader-id"));
+              if (isUseSSRBundle(userConfig) && checkUseStringSSR(userConfig)) {
+                var _config_plugins1;
+                (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push(require.resolve("@loadable/babel-plugin"));
+              }
+            };
+          } else if (bundlerType === "rspack") {
+            return (config) => {
+              const userConfig = api.useResolvedConfigContext();
+              if (isUseSSRBundle(userConfig) && checkUseStringSSR(userConfig)) {
+                var _config_plugins, _config_plugins1;
+                (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(path.join(__dirname, "./babel-plugin-ssr-loader-id"));
+                (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push(require.resolve("@loadable/babel-plugin"));
+              }
+            };
+          }
+        })();
+        return {
+          source: {
+            alias: {
+              // ensure that all packages use the same storage in @modern-js/runtime-utils/node
+              "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node")
+            },
+            globalVars: (values, { target }) => {
+              values["process.env.MODERN_TARGET"] = target === "node" || target === "service-worker" ? "node" : "browser";
+            }
+          },
+          tools: {
+            bundlerChain(chain, { isServer, isServiceWorker }) {
+              const userConfig = api.useResolvedConfigContext();
+              if (isUseSSRBundle(userConfig) && !isServer && !isServiceWorker && checkUseStringSSR(userConfig)) {
+                const LoadableBundlerPlugin = require("./loadable-bundler-plugin.js");
+                chain.plugin("loadable").use(LoadableBundlerPlugin, [
+                  {
+                    filename: LOADABLE_STATS_FILE
+                  }
+                ]);
+              }
+            },
+            babel: babelHandler
+          }
+        };
+      }
+    };
+  }
+});
+var ssr_default = ssrPlugin;
+export {
+  ssr_default as default,
+  ssrPlugin
+};

package/dist/esm-node/{ssr/cli → cli/ssr}/loadable-bundler-plugin.js

@@ -5,7 +5,7 @@ var __commonJS = (cb, mod) => function __require() {
 import path from "path";
 import { fs } from "@modern-js/utils";
 var require_loadable_bundler_plugin = __commonJS({
-  "src/ssr/cli/loadable-bundler-plugin.ts"(exports, module) {
+  "src/cli/ssr/loadable-bundler-plugin.ts"(exports, module) {
     class LoadablePlugin {
       apply(compiler) {
         this.compiler = compiler;

package/dist/esm-node/cli/template.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists, formatImportPath } from "@modern-js/utils";
+import { ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME } from "./constants";
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId }) => {
+  if (customEntry) {
+    return `import '${formatImportPath(entry.replace(srcDirectory, internalSrcAlias))}'`;
+  }
+  return `import { createRoot } from '@${metaName}/runtime/react';
+import { render } from '@${metaName}/runtime/browser';
+${customBootstrap ? `import customBootstrap from '${formatImportPath(customBootstrap.replace(srcDirectory, internalSrcAlias))}';` : ""}
+
+const ModernRoot = createRoot();
+
+${customBootstrap ? `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));` : `render(<ModernRoot />, '${mountId || "root"}');`}`;
+};
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId }) => `import '@${metaName}/runtime/registry/${entryName}';
+${genRenderCode({
+  srcDirectory,
+  internalSrcAlias,
+  metaName,
+  entry,
+  customEntry,
+  customBootstrap,
+  mountId
+})}
+`;
+const register = () => `import './${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';
+import './${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}';
+`;
+const getImportRuntimeConfigCode = (srcDirectory, internalSrcAlias, runtimeConfigFile) => {
+  if (runtimeConfigFile && findExists(JS_EXTENSIONS.map((ext) => path.resolve(srcDirectory, `${runtimeConfigFile}${ext}`)))) {
+    return `import runtimeConfig from '${internalSrcAlias}/${runtimeConfigFile}';`;
+  }
+  return `let runtimeConfig;`;
+};
+const getRegisterRuntimePluginCode = (entryName, name, config) => `plugins.push(${name}Plugin(mergeConfig(${JSON.stringify(config)}, (runtimeConfig || {})['${name}'], ((runtimeConfig || {})['${name}ByEntries'] || {})['${entryName}'], (getGlobalAppConfig() || {})['${name}'])));`;
+const runtimeRegister = ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins }) => `import { registerPlugin, mergeConfig } from '@${metaName}/runtime/plugin';
+import { getGlobalAppConfig, getGlobalLayoutApp } from '@${metaName}/runtime/context';
+${getImportRuntimeConfigCode(srcDirectory, internalSrcAlias, runtimeConfigFile)}
+
+const plugins = [];
+
+${runtimePlugins.map(({ name, path: path2, config }) => `import { ${name}Plugin } from '${path2}';
+
+${getRegisterRuntimePluginCode(entryName, name, config)}
+`).join("\n")}
+registerPlugin(plugins, runtimeConfig);
+`;
+const runtimeGlobalContext = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry }) => {
+  return `import { setGlobalContext } from '@${metaName}/runtime/context'
+
+import App from '${// We need to get the path of App.tsx here, but the entry is `src/entry.tsx`
+  formatImportPath(customEntry ? entry.replace("entry.tsx", "App.tsx").replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias))}';
+
+setGlobalContext({
+  App,
+});`;
+};
+export {
+  index,
+  register,
+  runtimeGlobalContext,
+  runtimeRegister
+};

package/dist/esm-node/cli/template.server.js

@@ -0,0 +1,47 @@
+import { formatImportPath } from "@modern-js/utils";
+const SERVER_ENTRY = `
+import {
+  #render,
+  createRequestHandler,
+} from '@#metaName/runtime/ssr/server';
+
+const handleRequest = async (request, ServerRoot, options) => {
+
+  const body = await #render(request, <ServerRoot />, options);
+
+  return new Response(body, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8',
+      #headers
+    },
+  })
+};
+
+export const requestHandler = createRequestHandler(handleRequest);
+`;
+const serverIndex = (options) => {
+  const { metaName = "modern-js", entryName } = options;
+  return `
+    import '@${metaName}/runtime/registry/${entryName}';
+    ${genHandlerCode(options)}
+  `;
+};
+function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, internalSrcAlias }) {
+  if (customServerEntry) {
+    return `export { default as requestHandler } from '${formatImportPath(customServerEntry.replace(srcDirectory, internalSrcAlias))}'`;
+  } else {
+    const serverEntry = transformServerEntry(SERVER_ENTRY, {
+      metaName: metaName || "modern-js",
+      mode
+    });
+    return serverEntry;
+  }
+}
+function transformServerEntry(source, options) {
+  const { metaName = "modern-js", mode } = options;
+  const output = source.replace(/#metaName/g, metaName).replace(/#render/g, mode === "string" ? "renderString" : "renderStreaming").replace(/#headers/g, mode === "string" ? "" : `'transfer-encoding': 'chunked',`);
+  return output;
+}
+export {
+  serverIndex
+};

package/dist/esm-node/core/browser/hydrate.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { normalizePathname } from "@modern-js/runtime-utils/url";
+import { loadableReady } from "@loadable/component";
+import React from "react";
+import { RenderLevel } from "../constants";
+import { WithCallback } from "./withCallback";
+const isReact18 = () => process.env.IS_REACT18 === "true";
+function hydrateRoot(App, context, ModernRender, ModernHydrate) {
+  var _window__SSR_DATA, _window, _window__SSR_DATA1, _window1;
+  const hydrateContext = {
+    ...context,
+    get routes() {
+      return context.routes;
+    },
+    _hydration: true
+  };
+  const { ssrContext } = hydrateContext;
+  const currentPathname = normalizePathname(window.location.pathname);
+  const initialPathname = normalizePathname(ssrContext.request.pathname);
+  if (initialPathname !== currentPathname && context.router) {
+    const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
+    console.error(errorMsg);
+    window.location.reload();
+  }
+  const callback = () => {
+    delete hydrateContext._hydration;
+  };
+  const renderLevel = ((_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.renderLevel) || RenderLevel.CLIENT_RENDER;
+  const renderMode = ((_window1 = window) === null || _window1 === void 0 ? void 0 : (_window__SSR_DATA1 = _window1._SSR_DATA) === null || _window__SSR_DATA1 === void 0 ? void 0 : _window__SSR_DATA1.mode) || "string";
+  if (isReact18() && renderMode === "stream") {
+    return streamSSRHydrate();
+  }
+  function streamSSRHydrate() {
+    if (renderLevel === RenderLevel.SERVER_RENDER) {
+      const SSRApp = () => /* @__PURE__ */ _jsx(WithCallback, {
+        callback,
+        children: /* @__PURE__ */ React.cloneElement(App, {
+          _internal_context: hydrateContext
+        })
+      });
+      return ModernHydrate(/* @__PURE__ */ _jsx(SSRApp, {}));
+    } else {
+      return ModernRender(App);
+    }
+  }
+  return stringSSRHydrate();
+  function stringSSRHydrate() {
+    if (renderLevel === RenderLevel.CLIENT_RENDER || renderLevel === RenderLevel.SERVER_PREFETCH) {
+      return ModernRender(App);
+    } else if (renderLevel === RenderLevel.SERVER_RENDER) {
+      return new Promise((resolve) => {
+        if (isReact18()) {
+          loadableReady(() => {
+            const SSRApp = () => /* @__PURE__ */ _jsx(WithCallback, {
+              callback,
+              children: /* @__PURE__ */ React.cloneElement(App, {
+                _internal_context: hydrateContext
+              })
+            });
+            ModernHydrate(/* @__PURE__ */ _jsx(SSRApp, {})).then((root) => {
+              resolve(root);
+            });
+          });
+        } else {
+          loadableReady(() => {
+            ModernHydrate(App, callback).then((root) => {
+              resolve(root);
+            });
+          });
+        }
+      });
+    } else {
+      console.warn(`unknow render level: ${renderLevel}, execute render()`);
+      return ModernRender(App);
+    }
+  }
+}
+export {
+  hydrateRoot,
+  isReact18
+};

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

@@ -0,0 +1,88 @@
+import React from "react";
+import { getGlobalAppInit } from "../context";
+import { getInitialContext } from "../context/runtime";
+import { createLoaderManager } from "../loader/loaderManager";
+import { getGlobalRunner } from "../plugin/runner";
+import { hydrateRoot } from "./hydrate";
+const IS_REACT18 = process.env.IS_REACT18 === "true";
+function isClientArgs(id) {
+  return typeof id === "undefined" || typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
+}
+async function render(App, id) {
+  const runner = getGlobalRunner();
+  const context = getInitialContext(runner);
+  const runInit = (_context) => runner.init({
+    context: _context
+  }, {
+    onLast: ({ context: context1 }) => {
+      const init = getGlobalAppInit();
+      return init === null || init === void 0 ? void 0 : init(context1);
+    }
+  });
+  if (isClientArgs(id)) {
+    var _ssrData_data, _ssrData_data1;
+    const ssrData = window._SSR_DATA;
+    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 === null || loaderData === void 0 ? void 0 : loaderData.loading) !== false) {
+        return res;
+      }
+      res[key] = loaderData;
+      return res;
+    }, {});
+    Object.assign(context, {
+      loaderManager: createLoaderManager(initialLoadersState, {
+        skipStatic: true
+      }),
+      ...ssrData ? {
+        ssrContext: ssrData === null || ssrData === void 0 ? void 0 : ssrData.context
+      } : {}
+    });
+    context.initialData = ssrData === null || ssrData === void 0 ? void 0 : (_ssrData_data1 = ssrData.data) === null || _ssrData_data1 === void 0 ? void 0 : _ssrData_data1.initialData;
+    const initialData = await runInit(context);
+    if (initialData) {
+      context.initialData = initialData;
+    }
+    const rootElement = id && typeof id !== "string" ? id : document.getElementById(id || "root");
+    async function ModernRender(App2) {
+      const renderFunc = IS_REACT18 ? renderWithReact18 : renderWithReact17;
+      return renderFunc(/* @__PURE__ */ React.cloneElement(App2, {
+        _internal_context: context
+      }), rootElement);
+    }
+    async function ModernHydrate(App2, callback) {
+      const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
+      return hydrateFunc(App2, rootElement, callback);
+    }
+    if (ssrData) {
+      return hydrateRoot(App, context, ModernRender, ModernHydrate);
+    }
+    return ModernRender(App);
+  }
+  throw Error("`render` function needs id in browser environment, it needs to be string or element");
+}
+async function renderWithReact18(App, rootElement) {
+  const ReactDOM = await import("react-dom/client");
+  const root = ReactDOM.createRoot(rootElement);
+  root.render(App);
+  return root;
+}
+async function renderWithReact17(App, rootElement) {
+  const ReactDOM = await import("react-dom");
+  ReactDOM.render(App, rootElement);
+  return rootElement;
+}
+async function hydrateWithReact18(App, rootElement) {
+  const ReactDOM = await import("react-dom/client");
+  const root = ReactDOM.hydrateRoot(rootElement, App);
+  return root;
+}
+async function hydrateWithReact17(App, rootElement, callback) {
+  const ReactDOM = await import("react-dom");
+  const root = ReactDOM.hydrate(App, rootElement, callback);
+  return root;
+}
+export {
+  render
+};

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);