@modern-js/runtime 2.56.2 → 2.57.0

package/dist/esm/router/runtime/plugin.node.js

@@ -11,6 +11,7 @@ import { createRoutesFromElements } from "@modern-js/runtime-utils/router";
 import { reporterCtx, createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { merge } from "@modern-js/runtime-utils/merge";
 import { JSX_SHELL_STREAM_END_MARK } from "../../common";
 import { RuntimeReactContext } from "../../core";
 import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
@@ -27,32 +28,31 @@ function createRemixReuqest(request) {
     signal: controller.signal
   });
 }
-var routerPlugin = function(param) {
-  var _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
+var routerPlugin = function() {
+  var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
       modifyRoutes: modifyRoutesHook
     },
     setup: function(api) {
-      var finalRouteConfig = _object_spread({
-        routes: getGlobalRoutes(),
-        globalApp: getGlobalLayoutApp()
-      }, routesConfig);
+      var finalRouteConfig = {};
       return {
-        init: function init(param2, next) {
-          var context = param2.context;
+        beforeRender: function beforeRender(context, interrupt) {
           return _async_to_generator(function() {
-            var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1, _context_ssrContext2, request, ssrMode, nonce, _context_ssrContext_loaderFailureMode, loaderFailureMode, baseUrl, _basename, reporter, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
+            var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1, pluginConfig, _merge, _merge_basename, basename, routesConfig, createRoutes, _context_ssrContext2, request, ssrMode, nonce, _context_ssrContext_loaderFailureMode, loaderFailureMode, baseUrl, _basename, reporter, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
+                  pluginConfig = api.useRuntimeConfigContext();
+                  _merge = merge(pluginConfig.router || {}, userConfig), _merge_basename = _merge.basename, basename = _merge_basename === void 0 ? "" : _merge_basename, routesConfig = _merge.routesConfig, createRoutes = _merge.createRoutes;
+                  finalRouteConfig = _object_spread({
+                    routes: getGlobalRoutes(),
+                    globalApp: getGlobalLayoutApp()
+                  }, routesConfig);
                   if (!finalRouteConfig.routes && !createRoutes) {
                     return [
-                      2,
-                      next({
-                        context
-                      })
+                      2
                     ];
                   }
                   _context_ssrContext2 = context.ssrContext, request = _context_ssrContext2.request, ssrMode = _context_ssrContext2.mode, nonce = _context_ssrContext2.nonce, _context_ssrContext_loaderFailureMode = _context_ssrContext2.loaderFailureMode, loaderFailureMode = _context_ssrContext_loaderFailureMode === void 0 ? "errorBoundary" : _context_ssrContext_loaderFailureMode;
@@ -89,7 +89,7 @@ var routerPlugin = function(param) {
                   if (_instanceof(routerContext, Response)) {
                     return [
                       2,
-                      routerContext
+                      interrupt(routerContext)
                     ];
                   }
                   if (routerContext.statusCode >= 500 && routerContext.statusCode < 600 && loaderFailureMode === "clientRender") {
@@ -101,26 +101,20 @@ var routerPlugin = function(param) {
                   context.routerContext = routerContext;
                   context.routes = routes;
                   return [
-                    2,
-                    next({
-                      context
-                    })
+                    2
                   ];
               }
             });
           })();
         },
-        hoc: function(param2, next) {
-          var App = param2.App, config = param2.config;
+        wrapRoot: function(App) {
           if (!finalRouteConfig) {
-            return next({
-              App,
-              config
-            });
+            return App;
           }
           var getRouteApp = function() {
             return function() {
-              var _useContext = useContext(RuntimeReactContext), remixRouter = _useContext.remixRouter, routerContext = _useContext.routerContext, ssrContext = _useContext.ssrContext;
+              var context = useContext(RuntimeReactContext);
+              var remixRouter = context.remixRouter, routerContext = context.routerContext, ssrContext = context.ssrContext;
               var nonce = ssrContext.nonce, mode = ssrContext.mode;
               return /* @__PURE__ */ _jsxs(_Fragment, {
                 children: [
@@ -129,6 +123,8 @@ var routerPlugin = function(param) {
                     context: routerContext,
                     hydrate: false
                   }),
+                  mode === "stream" && // ROUTER_DATA will inject in `packages/runtime/plugin-runtime/src/core/server/string/ssrData.ts` in string ssr
+                  // So we can inject it only when streaming ssr
                   /* @__PURE__ */ _jsx(DeferredDataScripts, {
                     nonce,
                     context: routerContext
@@ -138,20 +134,12 @@ var routerPlugin = function(param) {
               });
             };
           };
-          var RouteApp = getRouteApp();
-          return next({
-            App: RouteApp,
-            config
-          });
+          return getRouteApp();
         },
-        pickContext: function(param2, next) {
-          var context = param2.context, pickedContext = param2.pickedContext;
-          var remixRouter = context.remixRouter;
+        pickContext: function(pickedContext) {
+          var remixRouter = pickedContext.remixRouter;
           if (!remixRouter) {
-            return next({
-              context,
-              pickedContext
-            });
+            return pickedContext;
           }
           var router = {
             navigate: remixRouter.navigate,
@@ -159,11 +147,8 @@ var routerPlugin = function(param) {
               return remixRouter.state.location;
             }
           };
-          return next({
-            context,
-            pickedContext: _object_spread_props(_object_spread({}, pickedContext), {
-              router
-            })
+          return _object_spread_props(_object_spread({}, pickedContext), {
+            router
           });
         }
       };

package/dist/esm/state/runtime/plugin.js

@@ -1,10 +1,10 @@
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext } from "react";
 import { createStore } from "@modern-js-reduck/store";
 import { Provider } from "@modern-js-reduck/react";
+import { merge } from "@modern-js/runtime-utils/merge";
 import { immer, effects, autoActions, devtools } from "../plugins";
 import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
@@ -53,14 +53,14 @@ var getStoreConfig = function(config) {
   storeConfig.plugins = plugins;
   return storeConfig;
 };
-var statePlugin = function(config) {
+var statePlugin = function() {
+  var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   return {
     name: "@modern-js/plugin-state",
-    setup: function() {
-      var storeConfig = getStoreConfig(config);
+    setup: function(api) {
+      var storeConfig;
       return {
-        hoc: function hoc(param, next) {
-          var App = param.App, _$config = param.config;
+        wrapRoot: function wrapRoot(App) {
           var getStateApp = function(props) {
             var context = useContext(RuntimeReactContext);
             return /* @__PURE__ */ _jsx(Provider, {
@@ -69,30 +69,17 @@ var statePlugin = function(config) {
               children: /* @__PURE__ */ _jsx(App, _object_spread({}, props))
             });
           };
-          return next({
-            App: getStateApp,
-            config: _$config
-          });
+          return getStateApp;
         },
-        init: function init(param, next) {
-          var context = param.context;
+        beforeRender: function beforeRender(context) {
+          var pluginConfig = api.useRuntimeConfigContext();
+          var config = merge(pluginConfig.state || {}, userConfig);
+          storeConfig = getStoreConfig(config);
           if (isBrowser()) {
             var _window__SSR_DATA_data, _window__SSR_DATA, _window;
             storeConfig.initialState = storeConfig.initialState || ((_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.storeState) || {};
           }
           context.store = createStore(storeConfig);
-          return next({
-            context
-          });
-        },
-        pickContext: function pickContext(param, next) {
-          var context = param.context, pickedContext = param.pickedContext;
-          return next({
-            context,
-            pickedContext: _object_spread_props(_object_spread({}, pickedContext), {
-              store: context.store
-            })
-          });
         }
       };
     }

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

@@ -85,7 +85,11 @@ const runtimePlugin = (params) => ({
               /**
               * Compatible with the reference path of the old version of the plugin.
               */
-              [`@${metaName}/runtime/plugins`]: pluginsExportsUtils.getPath()
+              [`@${metaName}/runtime/plugins`]: pluginsExportsUtils.getPath(),
+              "@meta/runtime/browser": "@modern-js/runtime/browser",
+              "@meta/runtime/react": "@modern-js/runtime/react",
+              "@meta/runtime/context": "@modern-js/runtime/context",
+              "@meta/runtime": "@modern-js/runtime"
             },
             globalVars: {
               "process.env.IS_REACT18": process.env.IS_REACT18

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

@@ -63,7 +63,9 @@ function hydrateRoot(App, context, ModernRender, ModernHydrate) {
           });
         } else {
           loadableReady(() => {
-            ModernHydrate(App, callback).then((root) => {
+            ModernHydrate(/* @__PURE__ */ React.cloneElement(App, {
+              _internal_context: hydrateContext
+            }), callback).then((root) => {
               resolve(root);
             });
           });

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

@@ -31,14 +31,11 @@ function isClientArgs(id) {
 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);
-    }
-  });
+  const runBeforeRender = async (context2) => {
+    await runner.beforeRender(context2);
+    const init = getGlobalAppInit();
+    return init === null || init === void 0 ? void 0 : init(context2);
+  };
   if (isClientArgs(id)) {
     var _ssrData_data, _ssrData_data1;
     const ssrData = getSSRData();
@@ -55,12 +52,14 @@ async function render(App, id) {
       loaderManager: createLoaderManager(initialLoadersState, {
         skipStatic: true
       }),
+      // garfish plugin params
+      _internalRouterBaseName: App.props.basename,
       ...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);
+    const initialData = await runBeforeRender(context);
     if (initialData) {
       context.initialData = initialData;
     }

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

@@ -30,53 +30,38 @@ const createApp = ({ plugins, runtime, props: globalProps }) => {
         ...props
       }) : child));
     };
-    const HOCApp = runner.hoc({
-      App: WrapperComponent,
-      config: globalProps || {}
-    }, {
-      onLast: ({ App: App2 }) => {
-        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 _getGlobalAppInit;
-                return (_getGlobalAppInit = getGlobalAppInit()) === null || _getGlobalAppInit === void 0 ? void 0 : _getGlobalAppInit(context1);
-              }
-            });
-          }
-          const mergedProps = {
-            ...props,
-            ...globalProps
-          };
-          return /* @__PURE__ */ _jsx(RuntimeReactContext.Provider, {
-            value: contextValue,
-            children: /* @__PURE__ */ _jsx(App2, {
-              ...mergedProps
-            })
-          });
-        };
-        return WrapComponent;
+    const WrapperApp = runner.wrapRoot(WrapperComponent);
+    const WrapComponent = ({ _internal_context, ...props }) => {
+      let contextValue = _internal_context;
+      if (!(contextValue === null || contextValue === void 0 ? void 0 : contextValue.runner)) {
+        var _getGlobalAppInit;
+        contextValue = getInitialContext(runner);
+        runner === null || runner === void 0 ? void 0 : runner.beforeRender(contextValue);
+        (_getGlobalAppInit = getGlobalAppInit()) === null || _getGlobalAppInit === void 0 ? void 0 : _getGlobalAppInit(contextValue);
       }
-    });
-    return HOCApp;
+      const mergedProps = {
+        ...props,
+        ...globalProps
+      };
+      return /* @__PURE__ */ _jsx(RuntimeReactContext.Provider, {
+        value: contextValue,
+        children: /* @__PURE__ */ _jsx(WrapperApp, {
+          ...mergedProps
+        })
+      });
+    };
+    return WrapComponent;
   };
 };
 const bootstrap = async (BootApp, id, root, ReactDOM) => {
   const App = BootApp;
   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);
-    }
-  });
+  const runBeforeRender = async (context2) => {
+    await runner.beforeRender(context2);
+    const init = getGlobalAppInit();
+    return init === null || init === void 0 ? void 0 : init(context2);
+  };
   if (!id) {
     return /* @__PURE__ */ React.createElement(App, {
       _internal_context: context
@@ -105,7 +90,7 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
         } : {}
       });
       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);
+      const initialData = await runBeforeRender(context);
       if (initialData) {
         context.initialData = initialData;
       }
@@ -165,16 +150,11 @@ const useRuntimeContext = () => {
   var _context_ssrContext, _context_ssrContext1;
   const context = useContext(RuntimeReactContext);
   const pickedContext = {
-    initialData: context.initialData,
+    ...context,
     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
-  }, {
-    onLast: ({ pickedContext: pickedContext2 }) => pickedContext2
-  }), [
+  const memoizedContext = useMemo(() => context.runner.pickContext(pickedContext), [
     context
   ]);
   return memoizedContext;

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

@@ -1,15 +1,24 @@
-import { createManager, createPipeline, createAsyncPipeline } from "@modern-js/plugin";
-const hoc = createPipeline();
-const init = createAsyncPipeline();
-const pickContext = createPipeline();
+import { createManager, createWaterfall, createAsyncInterruptWorkflow, createSyncParallelWorkflow, createContext } from "@modern-js/plugin";
+const RuntimeConfigContext = createContext({});
+const useRuntimeConfigContext = () => RuntimeConfigContext.use().value;
+const wrapRoot = createWaterfall();
+const beforeRender = createAsyncInterruptWorkflow();
+const pickContext = createWaterfall();
+const modifyRuntimeConfig = createSyncParallelWorkflow();
 const runtimeHooks = {
-  hoc,
-  init,
-  pickContext
+  beforeRender,
+  wrapRoot,
+  pickContext,
+  modifyRuntimeConfig
 };
-const createRuntime = () => createManager(runtimeHooks);
+const runtimePluginAPI = {
+  useRuntimeConfigContext
+};
+const createRuntime = () => createManager(runtimeHooks, runtimePluginAPI);
 const runtime = createRuntime();
 export {
+  RuntimeConfigContext,
   createRuntime,
-  runtime
+  runtime,
+  useRuntimeConfigContext
 };

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

@@ -1,16 +1,22 @@
-import { merge } from "../utils/merge";
-import { runtime } from "./base";
-import { setGlobalRunner } from "./runner";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { runtime, RuntimeConfigContext } from "./base";
+import { getGlobalRunner, setGlobalRunner } from "./runner";
 export * from "./base";
+function setupConfigContext() {
+  const runner = getGlobalRunner();
+  const configs = runner.modifyRuntimeConfig();
+  RuntimeConfigContext.set(merge({}, ...configs));
+}
 function registerPlugin(internalPlugins, runtimeConfig, customRuntime) {
   const { plugins = [] } = runtimeConfig || {};
   (customRuntime || runtime).usePlugin(...internalPlugins, ...plugins);
   const runner = (customRuntime || runtime).init();
   setGlobalRunner(runner);
+  setupConfigContext();
   return runner;
 }
 function mergeConfig(config, ...otherConfig) {
-  return merge(config, ...otherConfig);
+  return merge({}, config, ...otherConfig);
 }
 export {
   mergeConfig,

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

@@ -1,26 +1,19 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { RuntimeReactContext, getGlobalApp } from "../context";
 import { getGlobalRunner } from "../plugin/runner";
-function createRoot(UserApp, config) {
+function createRoot(UserApp) {
   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;
+  const WrapperApp = runner.wrapRoot(App);
+  const WrapComponent = ({ _internal_context, ...props }) => {
+    return /* @__PURE__ */ _jsx(RuntimeReactContext.Provider, {
+      value: _internal_context,
+      children: /* @__PURE__ */ _jsx(WrapperApp, {
+        ...props
+      })
+    });
+  };
+  return WrapComponent;
 }
 export {
   createRoot

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

@@ -7,7 +7,7 @@ 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 { config, loaderContext, onError, onTiming, locals, resource, params, responseProxy, logger, metrics, reporter } = options;
   const { nonce } = config;
   const { entryName, route } = resource;
   const cookie = request.headers.get("cookie");
@@ -16,7 +16,7 @@ function createSSRContext(request, options) {
   const query = parseQuery(request);
   const headersData = parseHeaders(request);
   const url = new URL(request.url);
-  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+  const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
   const ssrMode = getSSRMode(ssrConfig);
   const loaderFailureMode = typeof ssrConfig === "object" ? ssrConfig.loaderFailureMode : void 0;
   return {
@@ -60,14 +60,14 @@ const createRequestHandler = async (handleRequest) => {
     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 runBeforeRender = async (context2) => {
+      const result = await runner.beforeRender(context2);
+      if (typeof Response !== "undefined" && result instanceof Response) {
+        return result;
       }
-    });
+      const init = getGlobalAppInit();
+      return init === null || init === void 0 ? void 0 : init(context2);
+    };
     const responseProxy = {
       headers: {},
       code: -1
@@ -102,7 +102,7 @@ const createRequestHandler = async (handleRequest) => {
       }
       return void 0;
     };
-    const initialData = await runInit(context);
+    const initialData = await runBeforeRender(context);
     context.initialData = initialData;
     const redirectResponse = getRedirectResponse(initialData);
     if (redirectResponse) {

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

@@ -33,11 +33,11 @@ function createRenderStreaming(createReadableStreamFromElement) {
     const headersData = parseHeaders(request);
     return run(headersData, async () => {
       const end = time();
-      const { runtimeContext, config, resource, staticGenerate } = options;
+      const { runtimeContext, config, resource } = 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 ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
       const rootElement = React.cloneElement(serverRoot, {
         _internal_context: Object.assign(runtimeContext, {
           ssr: true

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

@@ -18,14 +18,14 @@ const renderString = async (request, serverRoot, options) => {
   const headersData = parseHeaders(request);
   return run(headersData, async () => {
     var _runtimeContext_ssrContext;
-    const { resource, runtimeContext, config, onError, onTiming, staticGenerate } = options;
+    const { resource, runtimeContext, config, onError, onTiming } = options;
     const tracer = {
       onError: createOnError(onError),
       onTiming: createOnTiming(onTiming)
     };
     const routerContext = runtimeContext.routerContext;
     const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
-    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries, staticGenerate);
+    const ssrConfig = getSSRConfigByEntry(entryName, config.ssr, config.ssrByEntries);
     const chunkSet = {
       renderLevel: RenderLevel.CLIENT_RENDER,
       ssrScripts: "",
@@ -38,6 +38,7 @@ const renderString = async (request, serverRoot, options) => {
       chunkSet.renderLevel = RenderLevel.SERVER_PREFETCH;
     } catch (e) {
       chunkSet.renderLevel = RenderLevel.CLIENT_RENDER;
+      tracer.onError(SSRErrors.PRERENDER, e);
     }
     const collectors = [
       new StyledCollector(chunkSet),

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

@@ -35,14 +35,11 @@ function serializeErrors(errors) {
   }
   return serialized;
 }
-function getSSRConfigByEntry(entryName, ssr, ssrByEntries, staticGenerate) {
-  if (staticGenerate) {
-    return true;
-  }
+function getSSRConfigByEntry(entryName, ssr, ssrByEntries) {
   if (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[entryName]) {
     return ssrByEntries[entryName];
   }
-  return ssr;
+  return ssr || true;
 }
 function getSSRMode(ssrConfig) {
   if (typeof ssrConfig === "boolean") {