@modern-js/runtime 2.6.0 → 2.8.0

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

@@ -1,54 +1,16 @@
 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) {
@@ -59,7 +21,9 @@ function getRouteComponents(routes, globalApp) {
   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(
@@ -76,7 +40,7 @@ function getRouteComponents(routes, globalApp) {
   routeElements.push(/* @__PURE__ */ jsx(Route, { path: "*", element: /* @__PURE__ */ jsx(DefaultNotFound, {}) }, "*"));
   return routeElements;
 }
-function renderRoutes(routesConfig) {
+function renderRoutes(routesConfig, ssrMode) {
   if (!routesConfig) {
     return null;
   }
@@ -84,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) {
@@ -118,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/ssr/cli/index.js

@@ -5,7 +5,7 @@ import {
   LOADABLE_STATS_FILE,
   isUseSSRBundle,
   createRuntimeExportsUtils,
-  isSingleEntry
+  isSSGEntry
 } from "@modern-js/utils";
 const PLUGIN_IDENTIFIER = "ssr";
 const hasStringSSREntry = (userConfig) => {
@@ -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()
             }
           },
@@ -111,8 +113,7 @@ var cli_default = () => ({
             );
           }
         }
-        const ssgConfig = userConfig.output.ssg;
-        const useSSG = isSingleEntry(entrypoints) ? Boolean(ssgConfig) : ssgConfig === true || typeof (ssgConfig == null ? void 0 : ssgConfig[0]) === "function" || Boolean(ssgConfig == null ? void 0 : ssgConfig[entryName]);
+        const useSSG = isSSGEntry(userConfig, entryName, entrypoints);
         ssrConfigMap.set(entryName, ssrConfig || useSSG);
         if (ssrConfig || useSSG) {
           imports.push({

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/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];
@@ -26,9 +26,7 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
         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

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

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 {

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

@@ -2,7 +2,7 @@ import { buildShellAfterTemplate } from "./buildTemplate.after";
 import { buildShellBeforeTemplate } from "./bulidTemplate.before";
 const HTML_SEPARATOR = "<!--<?- html ?>-->";
 const getTemplates = (context, renderLevel) => {
-  const { ssrContext } = context;
+  const { ssrContext, routerContext } = context;
   const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = ssrContext.template.split(HTML_SEPARATOR) || [];
   const builtBeforeTemplate = buildShellBeforeTemplate(
     beforeAppTemplate,
@@ -10,6 +10,7 @@ const getTemplates = (context, renderLevel) => {
   );
   const builtAfterTemplate = buildShellAfterTemplate(afterAppHtmlTemplate, {
     ssrContext,
+    routerContext,
     renderLevel
   });
   return {

package/dist/esm-node/ssr/serverRender/renderToString/entry.js

@@ -1,7 +1,8 @@
 import React from "react";
 import ReactDomServer from "react-dom/server";
-import serialize from "serialize-javascript";
+import { serializeJson } from "@modern-js/utils/serialize";
 import ReactHelmet from "react-helmet";
+import { serializeErrors } from "../../../router/runtime/utils";
 import helmetReplace from "../helmet";
 import {
   RenderLevel
@@ -72,13 +73,18 @@ class Entry {
     if ((_c = ssrContext.redirection) == null ? void 0 : _c.url) {
       return "";
     }
+    const { routerContext } = context;
+    const routerData = routerContext ? {
+      loaderData: routerContext.loaderData,
+      errors: serializeErrors(routerContext.errors)
+    } : void 0;
     let html = "";
     const templateData = buildTemplateData(
       ssrContext,
       prefetchData,
       this.result.renderLevel
     );
-    const SSRData = this.getSSRDataScript(templateData);
+    const SSRData = this.getSSRDataScript(templateData, routerData);
     for (const fragment of this.fragments) {
       if (fragment.isVariable && fragment.content === "SSRDataScript") {
         html += fragment.getValue(SSRData);
@@ -135,13 +141,18 @@ class Entry {
     }
     return html;
   }
-  getSSRDataScript(templateData) {
+  getSSRDataScript(templateData, routerData) {
+    let ssrDataScripts = `<script>window._SSR_DATA = ${serializeJson(
+      templateData
+    )}</script>`;
+    if (routerData) {
+      ssrDataScripts += `
+<script>window._ROUTER_DATA = ${serializeJson(
+        routerData
+      )}</script>`;
+    }
     return {
-      SSRDataScript: `
-        <script>window._SSR_DATA = ${serialize(templateData, {
-        isJSON: true
-      })}</script>
-      `
+      SSRDataScript: ssrDataScripts
     };
   }
 }

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

@@ -1,9 +1,6 @@
 export * from "@modern-js-reduck/react";
-import { model, createStore } from "@modern-js-reduck/store";
 import { default as default2 } from "./plugin";
 export * from "./plugin";
 export {
-  createStore,
-  default2 as default,
-  model
+  default2 as default
 };

package/dist/types/common.d.ts

@@ -3,4 +3,6 @@ export declare const isBrowser: () => boolean;
 export interface AppConfig {
   state?: StateConfig | boolean;
   [key: string]: any;
-}
+}
+export declare const JSX_SHELL_STREAM_END_MARK = "<!--<?- SHELL_STREAM_END ?>-->";
+export declare const ESCAPED_SHELL_STREAM_END_MARK = "&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;";

package/dist/types/core/compatible.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { Renderer } from 'react-dom';
 import type { hydrateRoot, createRoot } from 'react-dom/client';
-import { RuntimeContext, TRuntimeContext } from '../runtime-context';
+import { RuntimeContext, TRuntimeContext } from '../runtimeContext';
 import { Plugin } from './plugin';
 export type CreateAppOptions = {
   plugins: Plugin[];

package/dist/types/core/index.d.ts

@@ -1,8 +1,9 @@
 export { createPlugin, createRuntime, runtime, registerInit } from './plugin';
 export type { Plugin } from './plugin';
-export { defineConfig, getConfig } from './app-config';
+export { defineConfig, getConfig } from './appConfig';
 export * from './compatible';
-export type { TRuntimeContext, RuntimeContext } from '../runtime-context';
-export { RuntimeReactContext, ServerRouterContext } from '../runtime-context';
+export type { TRuntimeContext, RuntimeContext } from '../runtimeContext';
+export { RuntimeReactContext, ServerRouterContext } from '../runtimeContext';
 export * from './loader';
+export type { SSRData, SSRContainer } from './types';
 export * from '@modern-js/plugin';

package/dist/types/core/loader/index.d.ts

@@ -1,2 +1 @@
-export { default as useLoader } from './useLoader';
-export type { SSRData, SSRContainer } from './useLoader';
+export { default as useLoader } from './useLoader';

package/dist/types/core/loader/useLoader.d.ts

@@ -1,17 +1,4 @@
-import { LoaderResult } from './loaderManager';
-export interface SSRData {
-  loadersData: Record<string, LoaderResult | undefined>;
-  initialData?: Record<string, unknown>;
-  storeState?: any;
-}
-export interface SSRContainer {
-  data?: SSRData;
-}
-declare global {
-  interface Window {
-    _SSR_DATA?: SSRContainer;
-  }
-}
+type LoaderFn<P = any, T = any> = (context: any, params: P) => Promise<T>;
 export interface LoaderOptions<Params = any, TData = any, TError extends Error = any> {
   /**
    * Revoke when loader excuted successfully.
@@ -44,7 +31,6 @@ export interface LoaderOptions<Params = any, TData = any, TError extends Error =
 
   static?: boolean;
 }
-type LoaderFn<P = any, T = any> = (context: any, params: P) => Promise<T>;
 declare const useLoader: <TData = any, Params = any, E = any>(loaderFn: LoaderFn<Params, TData>, options?: LoaderOptions<Params, any, any>) => {
   reload: (params?: Params | undefined) => Promise<any> | undefined;
   loading: boolean;

package/dist/types/core/plugin.d.ts

@@ -1,6 +1,6 @@
 import type React from 'react';
 import { Setup, ToThreads, CommonAPI, PluginOptions } from '@modern-js/plugin';
-import type { RuntimeContext, TRuntimeContext } from '../runtime-context';
+import type { RuntimeContext, TRuntimeContext } from '../runtimeContext';
 export interface AppProps {}
 declare const runtimeHooks: {
   hoc: import("@modern-js/plugin").Pipeline<{
@@ -13,13 +13,13 @@ declare const runtimeHooks: {
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -52,13 +52,13 @@ export declare const createRuntime: () => import("@modern-js/plugin").Manager<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -84,13 +84,13 @@ export declare const runtime: import("@modern-js/plugin").Manager<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -111,13 +111,13 @@ export declare const createPlugin: (setup?: Setup<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -137,13 +137,13 @@ export declare const createPlugin: (setup?: Setup<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -163,13 +163,13 @@ export declare const createPlugin: (setup?: Setup<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;
@@ -189,13 +189,13 @@ export declare const createPlugin: (setup?: Setup<{
   }, JSX.Element>;
   client: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
     ModernRender: (App: React.ReactElement) => void;
     ModernHydrate: (App: React.ReactElement, callback?: () => void) => void;
   }, void>;
   server: import("@modern-js/plugin").AsyncPipeline<{
     App: React.ComponentType<any>;
-    readonly context?: RuntimeContext | undefined;
+    readonly context: RuntimeContext;
   }, string>;
   init: import("@modern-js/plugin").AsyncPipeline<{
     context: RuntimeContext;

package/dist/types/core/types.d.ts

@@ -0,0 +1,22 @@
+import type { LoaderResult } from './loader/loaderManager';
+declare global {
+  interface Window {
+    _SSR_DATA?: SSRContainer;
+    _ROUTER_DATA?: RouterSSRData;
+  }
+}
+export interface SSRData {
+  loadersData: Record<string, LoaderResult | undefined>;
+  initialData?: Record<string, unknown>;
+  storeState?: any;
+}
+export interface RouteData {
+  [routeId: string]: any;
+}
+export interface RouterSSRData {
+  loaderData: RouteData;
+  errors: RouteData | null;
+}
+export interface SSRContainer {
+  data?: SSRData;
+}

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import type { RouterConfig } from './router';
 export type { Plugin } from './core';
 export type { AppConfig } from './common';
 export { isBrowser } from './common';
-export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, TRuntimeContext } from './runtime-context';
+export type { BaseRuntimeContext, RuntimeContext, BaseTRuntimeContext, TRuntimeContext } from './runtimeContext';
 export type { RuntimeUserConfig } from './config';
 export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, defineConfig, registerInit, useRuntimeContext } from './core';
 export { StateConfig, RouterConfig };

package/dist/types/router/runtime/DeferredDataScripts.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+
+/**
+ * DeferredDataScripts only renders in server side,
+ * it doesn't need to be hydrated in client side.
+ */
+declare const DeferredDataScripts: () => JSX.Element | null;
+export default DeferredDataScripts;

package/dist/types/router/runtime/index.d.ts

@@ -3,5 +3,7 @@ import type { SingleRouteConfig, RouterConfig } from './types';
 export type { SingleRouteConfig, RouterConfig };
 export default routerPlugin;
 export { modifyRoutes } from './plugin';
-export * from 'react-router-dom';
-export * from './withRouter';
+export * from './withRouter';
+export type { FormEncType, FormMethod, GetScrollRestorationKeyFunction, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, FetcherWithComponents, ActionFunction, ActionFunctionArgs, AwaitProps, unstable_Blocker, unstable_BlockerFunction, DataRouteMatch, DataRouteObject, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LayoutRouteProps, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NavLinkProps, NonIndexRouteObject, OutletProps, Params, ParamParseKey, Path, PathMatch, Pathname, PathPattern, PathRouteProps, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, To } from 'react-router-dom';
+export { 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';
+export { defer, json, redirect } from '@modern-js/utils/remix-router';

package/dist/types/router/runtime/utils.d.ts

@@ -1,8 +1,27 @@
 import React from 'react';
-import type { NestedRoute, PageRoute } from '@modern-js/types';
+import { type NestedRoute, type PageRoute, type SSRMode } from '@modern-js/types';
+import { type Router, type StaticHandlerContext } from '@modern-js/utils/remix-router';
 import { RouterConfig } from './types';
-export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], globalApp?: React.ComponentType<any>): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-export declare function renderRoutes(routesConfig: RouterConfig['routesConfig']): React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | null;
+export declare function getRouteComponents(routes: (NestedRoute | PageRoute)[], {
+  globalApp,
+  ssrMode
+}: {
+  globalApp?: React.ComponentType<any>;
+  ssrMode?: SSRMode;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+export declare function renderRoutes(routesConfig: RouterConfig['routesConfig'], ssrMode?: SSRMode): React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | null;
 export declare function getLocation(serverContext: any): string;
 export declare const urlJoin: (...parts: string[]) => string;
-export declare function standardSlash(str: string): string;
+export declare function standardSlash(str: string): string;
+/**
+ * forked from https://github.com/remix-run/remix/blob/main/packages/remix-server-runtime/errors.ts
+ * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+
+export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
+/**
+ * forked from https://github.com/remix-run/remix/blob/main/packages/remix-react/errors.ts
+ * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
+ */
+
+export declare function deserializeErrors(errors: Router['state']['errors']): Router['state']['errors'];

package/dist/types/{runtime-context.d.ts → runtimeContext.d.ts}

@@ -1,5 +1,6 @@
 /// <reference types="react" />
 import { Store } from '@modern-js-reduck/store';
+import type { StaticHandlerContext } from '@modern-js/utils/remix-router';
 import { createLoaderManager } from './core/loader/loaderManager';
 import { runtime } from './core/plugin';
 import { SSRServerContext } from './ssr/serverRender/types';
@@ -9,6 +10,7 @@ export interface BaseRuntimeContext {
   runner: ReturnType<typeof runtime.init>;
   ssrContext?: SSRServerContext;
   store?: Store;
+  routerContext?: StaticHandlerContext;
 }
 export interface RuntimeContext extends BaseRuntimeContext {
   [key: string]: any;