@modern-js/runtime 2.6.0 → 2.8.0

package/dist/esm/router/runtime/DeferredDataScripts.js

@@ -0,0 +1,166 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, useEffect, useRef, useMemo, useContext } from "react";
+import { Await, UNSAFE_DataRouterContext as DataRouterContext, useAsyncError } from "react-router-dom";
+import { serializeJson } from "@modern-js/utils/serialize";
+import { JSX_SHELL_STREAM_END_MARK } from "../../common";
+import { serializeErrors } from "./utils";
+var setupFnStr = "function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};";
+var resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+var preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resovle(e)};";
+var DeferredDataScripts = function() {
+    var context = useContext(DataRouterContext);
+    var staticContext = (context || {}).staticContext;
+    var hydratedRef = useRef(false);
+    useEffect(function() {
+        hydratedRef.current = true;
+    }, []);
+    var deferredScripts = useMemo(function() {
+        if (!staticContext) {
+            return null;
+        }
+        var activeDeferreds = staticContext.activeDeferreds || [];
+        var _ROUTER_DATA = {
+            loaderData: staticContext.loaderData,
+            errors: serializeErrors(staticContext.errors)
+        };
+        var initialScripts = [
+            "_ROUTER_DATA = ".concat(serializeJson(_ROUTER_DATA), ";"),
+            "_ROUTER_DATA.s = ".concat(setupFnStr),
+            "_ROUTER_DATA.r = ".concat(resolveFnStr),
+            "_ROUTER_DATA.p = ".concat(preResolvedFnStr)
+        ].join("\n");
+        var deferredDataScripts = [];
+        initialScripts += Object.entries(activeDeferreds).map(function(param) {
+            var _param = _slicedToArray(param, 2), routeId = _param[0], deferredData = _param[1];
+            var pendingKeys = new Set(deferredData.pendingKeys);
+            var deferredKeys = deferredData.deferredKeys;
+            var deferredKeyPromiseStr = deferredKeys.map(function(key) {
+                if (pendingKeys.has(key)) {
+                    deferredDataScripts.push(/* @__PURE__ */ jsx(DeferredDataScript, {
+                        data: deferredData.data[key],
+                        dataKey: key,
+                        routeId: routeId
+                    }, "".concat(routeId, " | ").concat(key)));
+                    return "".concat(JSON.stringify(key), ": _ROUTER_DATA.s(").concat(JSON.stringify(routeId), ",").concat(JSON.stringify(key), ") ");
+                } else {
+                    var trackedPromise = deferredData.data[key];
+                    if (typeof trackedPromise._error !== "undefined") {
+                        var error = {
+                            message: trackedPromise._error.message,
+                            stack: process.env.NODE_ENV !== "production" ? trackedPromise._error.stack : void 0
+                        };
+                        return "".concat(JSON.stringify(key), ": _ROUTER_DATA.p(").concat(void 0, ", ").concat(serializeJson(error), ")");
+                    } else {
+                        if (typeof trackedPromise._data === "undefined") {
+                            throw new Error("The deferred data for ".concat(key, " was not resolved, did you forget to return data from a deferred promise"));
+                        }
+                        return "".concat(JSON.stringify(key), ": _ROUTER_DATA.p(").concat(serializeJson(trackedPromise._data), ")");
+                    }
+                }
+            }).join(",\n");
+            return "Object.assign(_ROUTER_DATA.loaderData[".concat(JSON.stringify(routeId), "], {").concat(deferredKeyPromiseStr, "});");
+        }).join("\n");
+        return [
+            initialScripts,
+            deferredDataScripts
+        ];
+    }, []);
+    if (!deferredScripts) {
+        return null;
+    }
+    return /* @__PURE__ */ jsxs(Fragment, {
+        children: [
+            !hydratedRef.current && /* @__PURE__ */ jsx("script", {
+                async: true,
+                suppressHydrationWarning: true,
+                dangerouslySetInnerHTML: {
+                    __html: deferredScripts[0]
+                }
+            }),
+            !hydratedRef.current && deferredScripts[1],
+            JSX_SHELL_STREAM_END_MARK
+        ]
+    });
+};
+var DeferredDataScript = function(param) {
+    var data = param.data, routeId = param.routeId, dataKey = param.dataKey;
+    return /* @__PURE__ */ jsx(Suspense, {
+        children: typeof document === "undefined" && data && dataKey && routeId ? /* @__PURE__ */ jsx(Await, {
+            resolve: data,
+            errorElement: /* @__PURE__ */ jsx(ErrorDeferredDataScript, {
+                routeId: routeId,
+                dataKey: dataKey
+            }),
+            children: function(data2) {
+                return /* @__PURE__ */ jsx("script", {
+                    async: true,
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: "_ROUTER_DATA.r(".concat(JSON.stringify(routeId), ", ").concat(JSON.stringify(dataKey), ", ").concat(serializeJson(data2), ");")
+                    }
+                });
+            }
+        }) : null
+    });
+};
+var ErrorDeferredDataScript = function(param) {
+    var routeId = param.routeId, dataKey = param.dataKey;
+    var error = useAsyncError();
+    return /* @__PURE__ */ jsx("script", {
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: {
+            __html: "_ROUTER_DATA.r(".concat(JSON.stringify(routeId), ", ").concat(JSON.stringify(dataKey), ", ").concat(void 0, ", ").concat(serializeJson({
+                message: error.message,
+                stack: error.stack
+            }), ");")
+        }
+    });
+};
+var DeferredDataScripts_default = DeferredDataScripts;
+export { DeferredDataScripts_default as default };

package/dist/esm/router/runtime/index.js

@@ -1,6 +1,7 @@
 import { routerPlugin } from "./plugin";
 var runtime_default = routerPlugin;
 import { modifyRoutes } from "./plugin";
-export * from "react-router-dom";
 export * from "./withRouter";
-export { runtime_default as default, modifyRoutes };
+import { createBrowserRouter, createHashRouter, createMemoryRouter, RouterProvider, BrowserRouter, HashRouter, MemoryRouter, Router, Await, Form, Link, NavLink, Navigate, Outlet, Route, Routes, ScrollRestoration, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, isRouteErrorResponse, matchPath, matchRoutes, renderMatches, resolvePath } from "react-router-dom";
+import { defer, json, redirect } from "@modern-js/utils/remix-router";
+export { Await, BrowserRouter, Form, HashRouter, Link, MemoryRouter, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, createBrowserRouter, createHashRouter, createMemoryRouter, createRoutesFromChildren, createRoutesFromElements, createSearchParams, runtime_default as default, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, modifyRoutes, redirect, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit };

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

@@ -53,7 +53,7 @@ function _objectSpreadProps(target, source) {
 import { jsx } from "react/jsx-runtime";
 import { createBrowserRouter, createHashRouter, RouterProvider, createRoutesFromElements, useMatches, useLocation } from "react-router-dom";
 import hoistNonReactStatics from "hoist-non-react-statics";
-import { renderRoutes, urlJoin } from "./utils";
+import { deserializeErrors, renderRoutes, urlJoin } from "./utils";
 var finalRouteConfig = {
     routes: []
 };
@@ -103,10 +103,18 @@ var routerPlugin = function(param) {
                             var routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(finalRouteConfig));
                             var baseUrl = ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname);
                             var _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
+                            var hydrationData = window._ROUTER_DATA;
+                            if (hydrationData === null || hydrationData === void 0 ? void 0 : hydrationData.errors) {
+                                hydrationData = _objectSpreadProps(_objectSpread({}, hydrationData), {
+                                    errors: deserializeErrors(hydrationData.errors)
+                                });
+                            }
                             var router = supportHtml5History ? createBrowserRouter(routes, {
-                                basename: _basename
+                                basename: _basename,
+                                hydrationData: hydrationData
                             }) : createHashRouter(routes, {
-                                basename: _basename
+                                basename: _basename,
+                                hydrationData: hydrationData
                             });
                             return /* @__PURE__ */ jsx(App, _objectSpreadProps(_objectSpread({}, props), {
                                 children: /* @__PURE__ */ jsx(RouterProvider, {

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

@@ -227,10 +227,9 @@ var __generator = this && this.__generator || function(thisArg, body) {
         };
     }
 };
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 import { useContext } from "react";
-import serialize from "serialize-javascript";
-import { createStaticHandler, isRouteErrorResponse } from "@remix-run/router";
+import { createStaticHandler } from "@modern-js/utils/remix-router";
 import { createStaticRouter, StaticRouterProvider } from "react-router-dom/server";
 import hoistNonReactStatics from "hoist-non-react-statics";
 import { createRoutesFromElements } from "react-router-dom";
@@ -298,45 +297,6 @@ function createFetchHeaders(requestHeaders) {
     }
     return headers;
 }
-function serializeErrors(errors) {
-    if (!errors) {
-        return null;
-    }
-    var entries = Object.entries(errors);
-    var serialized = {};
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], val = _step_value[1];
-            if (isRouteErrorResponse(val)) {
-                serialized[key] = _objectSpreadProps(_objectSpread({}, val), {
-                    __type: "RouteErrorResponse"
-                });
-            } else if (_instanceof(val, Error)) {
-                serialized[key] = {
-                    message: val.message,
-                    __type: "Error"
-                };
-            } else {
-                serialized[key] = val;
-            }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    return serialized;
-}
 var routerPlugin = function(param) {
     var _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
     return {
@@ -346,7 +306,7 @@ var routerPlugin = function(param) {
                 init: function init(param, next) {
                     var context = param.context;
                     return _asyncToGenerator(function() {
-                        var request, baseUrl, _basename, routes, query, remixRequest, routerContext, router;
+                        var _context_ssrContext, request, ssrMode, baseUrl, _basename, routes, query, remixRequest, routerContext, router;
                         return __generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
@@ -358,10 +318,10 @@ var routerPlugin = function(param) {
                                             })
                                         ];
                                     }
-                                    request = context.ssrContext.request;
+                                    _context_ssrContext = context.ssrContext, request = _context_ssrContext.request, ssrMode = _context_ssrContext.mode;
                                     baseUrl = request.baseUrl;
                                     _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-                                    routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(routesConfig));
+                                    routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(routesConfig, ssrMode));
                                     query = createStaticHandler(routes, {
                                         basename: _basename
                                     }).query;
@@ -403,29 +363,12 @@ var routerPlugin = function(param) {
                     var getRouteApp = function() {
                         return function(props) {
                             var _useContext = useContext(RuntimeReactContext), router = _useContext.router, routerContext = _useContext.routerContext;
-                            var data = {
-                                loaderData: routerContext.loaderData,
-                                actionData: routerContext.actionData,
-                                errors: serializeErrors(routerContext.errors)
-                            };
-                            var hydrateScript = "window.__staticRouterHydrationData = ".concat(serialize(data, {
-                                isJSON: true
-                            }), ";");
-                            return /* @__PURE__ */ jsxs(App, _objectSpreadProps(_objectSpread({}, props), {
-                                children: [
-                                    /* @__PURE__ */ jsx(StaticRouterProvider, {
-                                        router: router,
-                                        context: routerContext,
-                                        hydrate: false
-                                    }),
-                                    /* @__PURE__ */ jsx("script", {
-                                        suppressHydrationWarning: true,
-                                        id: "the-nonce",
-                                        dangerouslySetInnerHTML: {
-                                            __html: hydrateScript
-                                        }
-                                    })
-                                ]
+                            return /* @__PURE__ */ jsx(App, _objectSpreadProps(_objectSpread({}, props), {
+                                children: /* @__PURE__ */ jsx(StaticRouterProvider, {
+                                    router: router,
+                                    context: routerContext,
+                                    hydrate: false
+                                })
                             }));
                         };
                     };

package/dist/esm/router/runtime/utils.js

@@ -1,3 +1,11 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function _defineProperty(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -11,6 +19,40 @@ function _defineProperty(obj, key, value) {
     }
     return obj;
 }
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _objectSpread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -77,70 +119,25 @@ function _objectWithoutPropertiesLoose(source, excluded) {
     }
     return target;
 }
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
 import { jsx } from "react/jsx-runtime";
-import { Suspense } from "react";
 import { Route } from "react-router-dom";
+import { renderNestedRoute } from "@modern-js/utils/nestedRoutes";
+import { ErrorResponse, isRouteErrorResponse } from "@modern-js/utils/remix-router";
 import { DefaultNotFound } from "./DefaultNotFound";
-var renderNestedRoute = function(nestedRoute, parent) {
-    var children = nestedRoute.children, index = nestedRoute.index, id = nestedRoute.id, component = nestedRoute.component, isRoot = nestedRoute.isRoot;
-    var Component = component;
-    var routeProps = {
-        caseSensitive: nestedRoute.caseSensitive,
-        path: nestedRoute.path,
-        id: nestedRoute.id,
-        loader: createLoader(nestedRoute),
-        action: nestedRoute.action,
-        hasErrorBoundary: nestedRoute.hasErrorBoundary,
-        shouldRevalidate: nestedRoute.shouldRevalidate,
-        handle: nestedRoute.handle,
-        index: nestedRoute.index,
-        element: nestedRoute.element,
-        errorElement: nestedRoute.errorElement
-    };
-    if (nestedRoute.error) {
-        var errorElement = /* @__PURE__ */ jsx(nestedRoute.error, {});
-        routeProps.errorElement = errorElement;
-    }
-    var element;
-    if (Component) {
-        if (parent === null || parent === void 0 ? void 0 : parent.loading) {
-            var Loading = parent.loading;
-            if (isLoadableComponent(Component)) {
-                element = /* @__PURE__ */ jsx(Component, {
-                    fallback: /* @__PURE__ */ jsx(Loading, {})
-                });
-            } else {
-                element = /* @__PURE__ */ jsx(Suspense, {
-                    fallback: /* @__PURE__ */ jsx(Loading, {}),
-                    children: /* @__PURE__ */ jsx(Component, {})
-                });
-            }
-        } else if (isLoadableComponent(Component) || isRoot) {
-            element = /* @__PURE__ */ jsx(Component, {});
-        } else {
-            element = /* @__PURE__ */ jsx(Suspense, {
-                fallback: null,
-                children: /* @__PURE__ */ jsx(Component, {})
-            });
-        }
-    } else {
-        nestedRoute.loading = parent === null || parent === void 0 ? void 0 : parent.loading;
-    }
-    if (element) {
-        routeProps.element = element;
-    }
-    var childElements = children === null || children === void 0 ? void 0 : children.map(function(childRoute) {
-        return renderNestedRoute(childRoute, nestedRoute);
-    });
-    var routeElement = index ? /* @__PURE__ */ jsx(Route, _objectSpreadProps(_objectSpread({}, routeProps), {
-        index: true
-    }), id) : /* @__PURE__ */ jsx(Route, _objectSpreadProps(_objectSpread({}, routeProps), {
-        index: false,
-        children: childElements
-    }), id);
-    return routeElement;
-};
-function getRouteComponents(routes, globalApp) {
+import DeferredDataScripts from "./DeferredDataScripts";
+function getRouteComponents(routes, param) {
+    var globalApp = param.globalApp, ssrMode = param.ssrMode;
     var Layout = function(_param) {
         var Component = _param.Component, props = _objectWithoutProperties(_param, [
             "Component"
@@ -159,7 +156,9 @@ function getRouteComponents(routes, globalApp) {
         for(var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var route = _step.value;
             if (route.type === "nested") {
-                var routeElement = renderNestedRoute(route);
+                var routeElement = renderNestedRoute(route, {
+                    DeferredDataComponent: ssrMode === "stream" ? DeferredDataScripts : void 0
+                });
                 routeElements.push(routeElement);
             } else {
                 var routeElement1 = /* @__PURE__ */ jsx(Route, {
@@ -191,7 +190,7 @@ function getRouteComponents(routes, globalApp) {
     }, "*"));
     return routeElements;
 }
-function renderRoutes(routesConfig) {
+function renderRoutes(routesConfig, ssrMode) {
     if (!routesConfig) {
         return null;
     }
@@ -199,7 +198,10 @@ function renderRoutes(routesConfig) {
     if (!routes) {
         return null;
     }
-    var routeElements = getRouteComponents(routes, globalApp);
+    var routeElements = getRouteComponents(routes, {
+        globalApp: globalApp,
+        ssrMode: ssrMode
+    });
     return routeElements;
 }
 function getLocation(serverContext) {
@@ -236,25 +238,80 @@ function standardSlash(str) {
     }
     return addr;
 }
-function createLoader(route) {
-    var loader = route.loader;
-    if (loader) {
-        return function(args) {
-            if (typeof route.lazyImport === "function") {
-                route.lazyImport();
+function serializeErrors(errors) {
+    if (!errors) {
+        return null;
+    }
+    var entries = Object.entries(errors);
+    var serialized = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], val = _step_value[1];
+            if (isRouteErrorResponse(val)) {
+                serialized[key] = _objectSpreadProps(_objectSpread({}, val), {
+                    __type: "RouteErrorResponse"
+                });
+            } else if (_instanceof(val, Error)) {
+                serialized[key] = {
+                    message: val.message,
+                    stack: val.stack,
+                    __type: "Error"
+                };
+            } else {
+                serialized[key] = val;
             }
-            return loader(args);
-        };
-    } else {
-        return function() {
-            if (typeof route.lazyImport === "function") {
-                route.lazyImport();
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
-            return null;
-        };
+        }
     }
+    return serialized;
 }
-function isLoadableComponent(component) {
-    return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+function deserializeErrors(errors) {
+    if (!errors) {
+        return null;
+    }
+    var entries = Object.entries(errors);
+    var serialized = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], val = _step_value[1];
+            if (val && val.__type === "RouteErrorResponse") {
+                serialized[key] = new ErrorResponse(val.status, val.statusText, val.data, val.internal === true);
+            } else if (val && val.__type === "Error") {
+                var error = new Error(val.message);
+                error.stack = val.stack;
+                serialized[key] = error;
+            } else {
+                serialized[key] = val;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return serialized;
 }
-export { getLocation, getRouteComponents, renderRoutes, standardSlash, urlJoin };
+export { deserializeErrors, getLocation, getRouteComponents, renderRoutes, serializeErrors, standardSlash, urlJoin };

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

@@ -61,7 +61,7 @@ function _unsupportedIterableToArray(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
 import path from "path";
-import { getEntryOptions, SERVER_RENDER_FUNCTION_NAME, LOADABLE_STATS_FILE, isUseSSRBundle, createRuntimeExportsUtils, isSingleEntry } from "@modern-js/utils";
+import { getEntryOptions, SERVER_RENDER_FUNCTION_NAME, LOADABLE_STATS_FILE, isUseSSRBundle, createRuntimeExportsUtils, isSSGEntry } from "@modern-js/utils";
 var PLUGIN_IDENTIFIER = "ssr";
 var hasStringSSREntry = function(userConfig) {
     var isStreaming = function(ssr) {
@@ -113,6 +113,8 @@ var cli_default = function() {
                     return {
                         source: {
                             alias: {
+                                // ensure that all packages use the same storage in @modern-js/utils/ssr
+                                "@modern-js/utils/ssr": require.resolve("@modern-js/utils/ssr"),
                                 "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
                             }
                         },
@@ -163,8 +165,7 @@ var cli_default = function() {
                             throw new Error("You should switch to file-system based router to support streaming SSR.");
                         }
                     }
-                    var ssgConfig = userConfig.output.ssg;
-                    var useSSG = isSingleEntry(entrypoints) ? Boolean(ssgConfig) : ssgConfig === true || typeof (ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[0]) === "function" || Boolean(ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[entryName]);
+                    var useSSG = isSSGEntry(userConfig, entryName, entrypoints);
                     ssrConfigMap.set(entryName, ssrConfig || useSSG);
                     if (ssrConfig || useSSG) {
                         imports.push({

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

@@ -214,6 +214,7 @@ var ssr = function() {
                     var context = param.context;
                     var request = context.ssrContext.request;
                     context.ssrContext.request = formatServer(request);
+                    context.ssrContext.mode = config.mode;
                     return next({
                         context: context
                     });

package/dist/esm/ssr/serverRender/renderToStream/buildTemplate.after.js

@@ -26,7 +26,7 @@ function _objectSpread(target) {
     }
     return target;
 }
-import serialize from "serialize-javascript";
+import { serializeJson } from "@modern-js/utils/serialize";
 import { buildTemplate } from "./buildTemplate.share";
 function buildShellAfterTemplate(afterAppTemplate, options) {
     var injectSSRDataScript = function injectSSRDataScript(template) {
@@ -50,9 +50,7 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
                 },
                 renderLevel: renderLevel
             };
-            return "\n      <script>window._SSR_DATA = ".concat(serialize(SSRData, {
-                isJSON: true
-            }), "</script>\n      ");
+            return "\n      <script>window._SSR_DATA = ".concat(serializeJson(SSRData), "</script>\n      ");
         }
     };
     var callbacks = [

package/dist/esm/ssr/serverRender/renderToStream/bulidTemplate.before.js

@@ -71,7 +71,7 @@ function getHeadTemplate(beforeEntryTemplate, context) {
             }
             var routeAssets = routeManifest.routeAssets;
             var cssChunks = [];
-            var matches = matchRoutes(routes, routerContext.location);
+            var matches = matchRoutes(routes, routerContext.location, routerContext.basename);
             matches === null || matches === void 0 ? void 0 : matches.forEach(function(match, index) {
                 if (!index) {
                     return;