@modern-js/runtime 2.5.0 → 2.7.0

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

@@ -1,9 +1,120 @@
 import { routerPlugin } from "./plugin";
 var runtime_default = routerPlugin;
 import { modifyRoutes } from "./plugin";
-export * from "react-router-dom";
 export * from "./withRouter";
+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,
-  modifyRoutes
+  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-node/router/runtime/plugin.js

@@ -8,7 +8,7 @@ import {
   useLocation
 } from "react-router-dom";
 import hoistNonReactStatics from "hoist-non-react-statics";
-import { renderRoutes, urlJoin } from "./utils";
+import { deserializeErrors, renderRoutes, urlJoin } from "./utils";
 let finalRouteConfig = {
   routes: []
 };
@@ -55,13 +55,21 @@ const routerPlugin = ({
               const routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(finalRouteConfig));
               const baseUrl = ((_a = window._SERVER_DATA) == null ? void 0 : _a.router.baseUrl) || select(location.pathname);
               const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-              const router = supportHtml5History ? createBrowserRouter(routes, { basename: _basename }) : createHashRouter(routes, { basename: _basename });
-              return /* @__PURE__ */ jsx(App, {
-                ...props,
-                children: /* @__PURE__ */ jsx(RouterProvider, {
-                  router
-                })
+              let hydrationData = window._ROUTER_DATA;
+              if (hydrationData == null ? void 0 : hydrationData.errors) {
+                hydrationData = {
+                  ...hydrationData,
+                  errors: deserializeErrors(hydrationData.errors)
+                };
+              }
+              const router = supportHtml5History ? createBrowserRouter(routes, {
+                basename: _basename,
+                hydrationData
+              }) : createHashRouter(routes, {
+                basename: _basename,
+                hydrationData
               });
+              return /* @__PURE__ */ jsx(App, { ...props, children: /* @__PURE__ */ jsx(RouterProvider, { router }) });
             };
           };
           const RouteApp = getRouteApp();

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

@@ -1,10 +1,6 @@
-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
@@ -41,26 +37,6 @@ function createFetchHeaders(requestHeaders) {
   }
   return headers;
 }
-function serializeErrors(errors) {
-  if (!errors) {
-    return null;
-  }
-  const entries = Object.entries(errors);
-  const serialized = {};
-  for (const [key, val] of entries) {
-    if (isRouteErrorResponse(val)) {
-      serialized[key] = { ...val, __type: "RouteErrorResponse" };
-    } else if (val instanceof Error) {
-      serialized[key] = {
-        message: val.message,
-        __type: "Error"
-      };
-    } else {
-      serialized[key] = val;
-    }
-  }
-  return serialized;
-}
 const routerPlugin = ({
   basename = "",
   routesConfig,
@@ -74,10 +50,10 @@ const routerPlugin = ({
           if (!routesConfig && !createRoutes) {
             return next({ context });
           }
-          const { request } = context.ssrContext;
+          const { request, mode: ssrMode } = context.ssrContext;
           const baseUrl = request.baseUrl;
           const _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-          const routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(routesConfig));
+          const routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes(routesConfig, ssrMode));
           const { query } = createStaticHandler(routes, {
             basename: _basename
           });
@@ -100,30 +76,14 @@ const routerPlugin = ({
           const getRouteApp = () => {
             return (props) => {
               const { router, routerContext } = useContext(RuntimeReactContext);
-              const data = {
-                loaderData: routerContext.loaderData,
-                actionData: routerContext.actionData,
-                errors: serializeErrors(routerContext.errors)
-              };
-              const hydrateScript = `window.__staticRouterHydrationData = ${serialize(
-                data,
-                { isJSON: true }
-              )};`;
-              return /* @__PURE__ */ jsxs(App, {
-                ...props,
-                children: [
-                  /* @__PURE__ */ jsx(StaticRouterProvider, {
-                    router,
-                    context: routerContext,
-                    hydrate: false
-                  }),
-                  /* @__PURE__ */ jsx("script", {
-                    suppressHydrationWarning: true,
-                    id: "the-nonce",
-                    dangerouslySetInnerHTML: { __html: hydrateScript }
-                  })
-                ]
-              });
+              return /* @__PURE__ */ jsx(App, { ...props, children: /* @__PURE__ */ jsx(
+                StaticRouterProvider,
+                {
+                  router,
+                  context: routerContext,
+                  hydrate: false
+                }
+              ) });
             };
           };
           const RouteApp = getRouteApp();

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

@@ -1,103 +1,46 @@
 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";
-const renderNestedRoute = (nestedRoute, parent) => {
-  const { children, index, id, component, isRoot } = nestedRoute;
-  const Component = component;
-  const 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) {
-    const errorElement = /* @__PURE__ */ jsx(nestedRoute.error, {});
-    routeProps.errorElement = errorElement;
-  }
-  let element;
-  if (Component) {
-    if (parent == null ? void 0 : parent.loading) {
-      const 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 ? void 0 : parent.loading;
-  }
-  if (element) {
-    routeProps.element = element;
-  }
-  const childElements = children == null ? void 0 : children.map((childRoute) => {
-    return renderNestedRoute(childRoute, nestedRoute);
-  });
-  const routeElement = index ? /* @__PURE__ */ jsx(Route, {
-    ...routeProps,
-    index: true
-  }, id) : /* @__PURE__ */ jsx(Route, {
-    ...routeProps,
-    index: false,
-    children: childElements
-  }, id);
-  return routeElement;
-};
-function getRouteComponents(routes, globalApp) {
+import DeferredDataScripts from "./DeferredDataScripts";
+function getRouteComponents(routes, {
+  globalApp,
+  ssrMode
+}) {
   const Layout = ({ Component, ...props }) => {
     const GlobalLayout = globalApp;
     if (!GlobalLayout) {
-      return /* @__PURE__ */ jsx(Component, {
-        ...props
-      });
+      return /* @__PURE__ */ jsx(Component, { ...props });
     }
-    return /* @__PURE__ */ jsx(GlobalLayout, {
-      Component,
-      ...props
-    });
+    return /* @__PURE__ */ jsx(GlobalLayout, { Component, ...props });
   };
   const routeElements = [];
   for (const route of routes) {
     if (route.type === "nested") {
-      const routeElement = renderNestedRoute(route);
+      const routeElement = renderNestedRoute(route, {
+        DeferredDataComponent: ssrMode === "stream" ? DeferredDataScripts : void 0
+      });
       routeElements.push(routeElement);
     } else {
-      const routeElement = /* @__PURE__ */ jsx(Route, {
-        path: route.path,
-        element: /* @__PURE__ */ jsx(Layout, {
-          Component: route.component
-        })
-      }, route.path);
+      const routeElement = /* @__PURE__ */ jsx(
+        Route,
+        {
+          path: route.path,
+          element: /* @__PURE__ */ jsx(Layout, { Component: route.component })
+        },
+        route.path
+      );
       routeElements.push(routeElement);
     }
   }
-  routeElements.push(/* @__PURE__ */ jsx(Route, {
-    path: "*",
-    element: /* @__PURE__ */ jsx(DefaultNotFound, {})
-  }, "*"));
+  routeElements.push(/* @__PURE__ */ jsx(Route, { path: "*", element: /* @__PURE__ */ jsx(DefaultNotFound, {}) }, "*"));
   return routeElements;
 }
-function renderRoutes(routesConfig) {
+function renderRoutes(routesConfig, ssrMode) {
   if (!routesConfig) {
     return null;
   }
@@ -105,7 +48,7 @@ function renderRoutes(routesConfig) {
   if (!routes) {
     return null;
   }
-  const routeElements = getRouteComponents(routes, globalApp);
+  const routeElements = getRouteComponents(routes, { globalApp, ssrMode });
   return routeElements;
 }
 function getLocation(serverContext) {
@@ -139,31 +82,57 @@ function standardSlash(str) {
   }
   return addr;
 }
-function createLoader(route) {
-  const { loader } = route;
-  if (loader) {
-    return (args) => {
-      if (typeof route.lazyImport === "function") {
-        route.lazyImport();
-      }
-      return loader(args);
-    };
-  } else {
-    return () => {
-      if (typeof route.lazyImport === "function") {
-        route.lazyImport();
-      }
-      return null;
-    };
+function serializeErrors(errors) {
+  if (!errors) {
+    return null;
   }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if (isRouteErrorResponse(val)) {
+      serialized[key] = { ...val, __type: "RouteErrorResponse" };
+    } else if (val instanceof Error) {
+      serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: "Error"
+      };
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
 }
-function isLoadableComponent(component) {
-  return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+function deserializeErrors(errors) {
+  if (!errors) {
+    return null;
+  }
+  const entries = Object.entries(errors);
+  const serialized = {};
+  for (const [key, val] of entries) {
+    if (val && val.__type === "RouteErrorResponse") {
+      serialized[key] = new ErrorResponse(
+        val.status,
+        val.statusText,
+        val.data,
+        val.internal === true
+      );
+    } else if (val && val.__type === "Error") {
+      const error = new Error(val.message);
+      error.stack = val.stack;
+      serialized[key] = error;
+    } else {
+      serialized[key] = val;
+    }
+  }
+  return serialized;
 }
 export {
+  deserializeErrors,
   getLocation,
   getRouteComponents,
   renderRoutes,
+  serializeErrors,
   standardSlash,
   urlJoin
 };

package/dist/esm-node/router/runtime/withRouter.js

@@ -5,12 +5,15 @@ const withRouter = (Component) => {
     const location = useLocation();
     const params = useParams();
     const navigate = useNavigate();
-    return /* @__PURE__ */ jsx(Component, {
-      ...props,
-      location,
-      params,
-      navigate
-    });
+    return /* @__PURE__ */ jsx(
+      Component,
+      {
+        ...props,
+        location,
+        params,
+        navigate
+      }
+    );
   };
 };
 export {

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

@@ -39,6 +39,8 @@ var cli_default = () => ({
         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()
             }
           },

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

@@ -27,51 +27,33 @@ const ssr = (config) => ({
         return stringSSRHydrate();
         function stringSSRHydrate() {
           if (renderLevel === RenderLevel.CLIENT_RENDER || renderLevel === RenderLevel.SERVER_PREFETCH) {
-            ModernRender(/* @__PURE__ */ jsx(App, {
-              context
-            }));
+            ModernRender(/* @__PURE__ */ jsx(App, { context }));
           } else if (renderLevel === RenderLevel.SERVER_RENDER) {
             if (isReact18()) {
               loadableReady(() => {
-                let SSRApp = () => /* @__PURE__ */ jsx(WithCallback, {
-                  callback,
-                  children: /* @__PURE__ */ jsx(App, {
-                    context: hydrateContext
-                  })
-                });
+                let SSRApp = () => /* @__PURE__ */ jsx(WithCallback, { callback, children: /* @__PURE__ */ jsx(App, { context: hydrateContext }) });
                 SSRApp = hoistNonReactStatics(SSRApp, App);
                 ModernHydrate(/* @__PURE__ */ jsx(SSRApp, {}));
               });
             } else {
               loadableReady(() => {
-                ModernHydrate(/* @__PURE__ */ jsx(App, {
-                  context: hydrateContext
-                }), callback);
+                ModernHydrate(/* @__PURE__ */ jsx(App, { context: hydrateContext }), callback);
               });
             }
           } else {
             console.warn(
               `unknow render level: ${renderLevel}, execute render()`
             );
-            ModernRender(/* @__PURE__ */ jsx(App, {
-              context
-            }));
+            ModernRender(/* @__PURE__ */ jsx(App, { context }));
           }
         }
         function streamSSRHydrate() {
           if (renderLevel === RenderLevel.SERVER_RENDER) {
-            let SSRApp = () => /* @__PURE__ */ jsx(WithCallback, {
-              callback,
-              children: /* @__PURE__ */ jsx(App, {
-                context: hydrateContext
-              })
-            });
+            let SSRApp = () => /* @__PURE__ */ jsx(WithCallback, { callback, children: /* @__PURE__ */ jsx(App, { context: hydrateContext }) });
             SSRApp = hoistNonReactStatics(SSRApp, App);
             ModernHydrate(/* @__PURE__ */ jsx(SSRApp, {}));
           } else {
-            ModernRender(/* @__PURE__ */ jsx(App, {
-              context
-            }));
+            ModernRender(/* @__PURE__ */ jsx(App, { context }));
           }
         }
       },

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

@@ -15,6 +15,7 @@ const ssr = (config = {}) => ({
       init({ context }, next) {
         const { request } = context.ssrContext;
         context.ssrContext.request = formatServer(request);
+        context.ssrContext.mode = config.mode;
         return next({ context });
       },
       pickContext: ({ context, pickedContext }, next) => {

package/dist/esm-node/ssr/prefetch.js

@@ -11,13 +11,9 @@ const prefetch = async (App, context) => run(context.ssrContext.request.headers,
       stats: loadableStats,
       entrypoints: [ssrContext.entryName].filter(Boolean)
     });
-    renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ jsx(App, {
-      context
-    })));
+    renderToStaticMarkup(extractor.collectChunks(/* @__PURE__ */ jsx(App, { context })));
   } else {
-    renderToStaticMarkup(/* @__PURE__ */ jsx(App, {
-      context
-    }));
+    renderToStaticMarkup(/* @__PURE__ */ jsx(App, { context }));
   }
   if (!context.loaderManager.hasPendingLoaders()) {
     return {
@@ -38,6 +34,7 @@ const prefetch = async (App, context) => run(context.ssrContext.request.headers,
     loadersData,
     initialData: context.initialData,
     i18nData: context.__i18nData__,
+    // todo: move to plugin state
     storeState: (_a = context == null ? void 0 : context.store) == null ? void 0 : _a.getState()
   };
 });

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

@@ -1,4 +1,4 @@
-import serialize from "serialize-javascript";
+import { serializeJson } from "@modern-js/utils/serialize";
 import { buildTemplate } from "./buildTemplate.share";
 function buildShellAfterTemplate(afterAppTemplate, options) {
   const callbacks = [injectSSRDataScript];
@@ -8,7 +8,10 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
     return template.replace("<!--<?- SSRDataScript ?>-->", ssrDataScript);
     function buildSSRDataScript() {
       const { ssrContext, renderLevel } = options;
-      const { request } = ssrContext;
+      const { request, enableUnsafeCtx } = ssrContext;
+      const unsafeContext = {
+        headers: request.headers
+      };
       const SSRData = {
         context: {
           request: {
@@ -17,16 +20,13 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
             pathname: request.pathname,
             host: request.host,
             url: request.url,
-            headers: request.headers,
-            cookieMap: request.cookieMap
+            ...enableUnsafeCtx ? unsafeContext : {}
           }
         },
         renderLevel
       };
       return `
-      <script>window._SSR_DATA = ${serialize(SSRData, {
-        isJSON: true
-      })}<\/script>
+      <script>window._SSR_DATA = ${serializeJson(SSRData)}</script>
       `;
     }
   }

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

@@ -12,6 +12,7 @@ function getHeadTemplate(beforeEntryTemplate, context) {
       const helmetData = ReactHelmet.renderStatic();
       return helmetData ? helmetReplace(headTemplate2, helmetData) : headTemplate2;
     },
+    // @TODO: prefetch scripts of lazy component
     injectCss
   ];
   const [headTemplate = ""] = beforeEntryTemplate.match(HEAD_REG_EXP) || [];

package/dist/esm-node/ssr/serverRender/renderToStream/renderToPipe.js

@@ -1,8 +1,15 @@
 import { Transform } from "stream";
 import { RenderLevel } from "../types";
+import { ESCAPED_SHELL_STREAM_END_MARK } from "../../../common";
 import { getTemplates } from "./template";
+var ShellChunkStatus = /* @__PURE__ */ ((ShellChunkStatus2) => {
+  ShellChunkStatus2[ShellChunkStatus2["IDLE"] = 0] = "IDLE";
+  ShellChunkStatus2[ShellChunkStatus2["START"] = 1] = "START";
+  ShellChunkStatus2[ShellChunkStatus2["FINIESH"] = 2] = "FINIESH";
+  return ShellChunkStatus2;
+})(ShellChunkStatus || {});
 function renderToPipe(rootElement, context, options) {
-  let isShellStream = true;
+  let shellChunkStatus = 0 /* IDLE */;
   const { ssrContext } = context;
   const forUserPipe = (stream) => {
     return new Promise((resolve) => {
@@ -23,9 +30,20 @@ function renderToPipe(rootElement, context, options) {
           const injectableTransform = new Transform({
             transform(chunk, _encoding, callback) {
               try {
-                if (isShellStream) {
-                  this.push(joinChunk(shellBefore, chunk, shellAfter));
-                  isShellStream = false;
+                if (shellChunkStatus !== 2 /* FINIESH */) {
+                  let concatedChunk = chunk.toString();
+                  if (shellChunkStatus === 0 /* IDLE */) {
+                    concatedChunk = `${shellBefore}${concatedChunk}`;
+                    shellChunkStatus = 1 /* START */;
+                  }
+                  if (shellChunkStatus === 1 /* START */ && concatedChunk.endsWith(ESCAPED_SHELL_STREAM_END_MARK)) {
+                    concatedChunk = concatedChunk.replace(
+                      ESCAPED_SHELL_STREAM_END_MARK,
+                      shellAfter
+                    );
+                    shellChunkStatus = 2 /* FINIESH */;
+                  }
+                  this.push(concatedChunk);
                 } else {
                   this.push(chunk);
                 }
@@ -68,9 +86,6 @@ function renderToPipe(rootElement, context, options) {
     });
   };
   return forUserPipe;
-  function joinChunk(before = "", chunk, after = "") {
-    return `${before}${chunk.toString()}${after}`;
-  }
 }
 var renderToPipe_default = renderToPipe;
 export {