@modern-js/runtime 2.5.0-alpha.0 → 2.6.0

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

@@ -1,58 +1,9 @@
 import { routerPlugin } from "./plugin";
 var runtime_default = routerPlugin;
 import { modifyRoutes } from "./plugin";
+export * from "react-router-dom";
 export * from "./withRouter";
-import {
-  Form,
-  Outlet,
-  useAsyncError,
-  useAsyncValue,
-  isRouteErrorResponse,
-  useBeforeUnload,
-  useFormAction,
-  useHref,
-  useLocation,
-  useNavigate,
-  useNavigation,
-  useNavigationType,
-  useOutlet,
-  useOutletContext,
-  useParams,
-  useResolvedPath,
-  useRevalidator,
-  useRouteError,
-  useRouteLoaderData,
-  useSearchParams,
-  useSubmit,
-  unstable_useBlocker,
-  unstable_usePrompt
-} from "react-router-dom";
-import { defer } from "@modern-js/utils/remix-router";
 export {
-  Form,
-  Outlet,
   runtime_default as default,
-  defer,
-  isRouteErrorResponse,
-  modifyRoutes,
-  unstable_useBlocker,
-  unstable_usePrompt,
-  useAsyncError,
-  useAsyncValue,
-  useBeforeUnload,
-  useFormAction,
-  useHref,
-  useLocation,
-  useNavigate,
-  useNavigation,
-  useNavigationType,
-  useOutlet,
-  useOutletContext,
-  useParams,
-  useResolvedPath,
-  useRevalidator,
-  useRouteError,
-  useRouteLoaderData,
-  useSearchParams,
-  useSubmit
+  modifyRoutes
 };

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

@@ -55,20 +55,8 @@ 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 hydrationData = window._ROUTER_DATA;
-              const router = supportHtml5History ? createBrowserRouter(routes, {
-                basename: _basename,
-                hydrationData
-              }) : createHashRouter(routes, {
-                basename: _basename,
-                hydrationData
-              });
-              return /* @__PURE__ */ jsx(App, {
-                ...props,
-                children: /* @__PURE__ */ jsx(RouterProvider, {
-                  router
-                })
-              });
+              const router = supportHtml5History ? createBrowserRouter(routes, { basename: _basename }) : createHashRouter(routes, { basename: _basename });
+              return /* @__PURE__ */ jsx(App, { ...props, children: /* @__PURE__ */ jsx(RouterProvider, { router }) });
             };
           };
           const RouteApp = getRouteApp();

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

@@ -1,6 +1,10 @@
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { useContext } from "react";
-import { createStaticHandler } from "@modern-js/utils/remix-router";
+import serialize from "serialize-javascript";
+import {
+  createStaticHandler,
+  isRouteErrorResponse
+} from "@remix-run/router";
 import {
   createStaticRouter,
   StaticRouterProvider
@@ -37,6 +41,26 @@ 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,
@@ -76,14 +100,33 @@ const routerPlugin = ({
           const getRouteApp = () => {
             return (props) => {
               const { router, routerContext } = useContext(RuntimeReactContext);
-              return /* @__PURE__ */ jsx(App, {
-                ...props,
-                children: /* @__PURE__ */ jsx(StaticRouterProvider, {
-                  router,
-                  context: routerContext,
-                  hydrate: false
-                })
-              });
+              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 }
+                  }
+                )
+              ] });
             };
           };
           const RouteApp = getRouteApp();

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

@@ -1,42 +1,79 @@
 import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
 import { Route } from "react-router-dom";
-import { renderNestedRoute } from "@modern-js/utils/nestedRoutes";
 import { DefaultNotFound } from "./DefaultNotFound";
-import DeferredDataScripts from "./DeferredDataScripts";
+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) {
   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, {
-        DeferredDataComponent: DeferredDataScripts
-      });
+      const routeElement = renderNestedRoute(route);
       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) {
@@ -81,6 +118,27 @@ 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 isLoadableComponent(component) {
+  return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+}
 export {
   getLocation,
   getRouteComponents,

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/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/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 { serializeJson } from "@modern-js/utils/serialize";
+import serialize from "serialize-javascript";
 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,14 +20,15 @@ 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 = ${serializeJson(SSRData)}<\/script>
+      <script>window._SSR_DATA = ${serialize(SSRData, {
+        isJSON: true
+      })}</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,15 +1,8 @@
 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 shellChunkStatus = 0 /* IDLE */;
+  let isShellStream = true;
   const { ssrContext } = context;
   const forUserPipe = (stream) => {
     return new Promise((resolve) => {
@@ -30,20 +23,9 @@ function renderToPipe(rootElement, context, options) {
           const injectableTransform = new Transform({
             transform(chunk, _encoding, callback) {
               try {
-                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);
+                if (isShellStream) {
+                  this.push(joinChunk(shellBefore, chunk, shellAfter));
+                  isShellStream = false;
                 } else {
                   this.push(chunk);
                 }
@@ -86,6 +68,9 @@ 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, routerContext } = context;
+  const { ssrContext } = context;
   const [beforeAppTemplate = "", afterAppHtmlTemplate = ""] = ssrContext.template.split(HTML_SEPARATOR) || [];
   const builtBeforeTemplate = buildShellBeforeTemplate(
     beforeAppTemplate,
@@ -10,7 +10,6 @@ const getTemplates = (context, renderLevel) => {
   );
   const builtAfterTemplate = buildShellAfterTemplate(afterAppHtmlTemplate, {
     ssrContext,
-    routerContext,
     renderLevel
   });
   return {

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

@@ -1,6 +1,6 @@
 import React from "react";
 import ReactDomServer from "react-dom/server";
-import { serializeJson } from "@modern-js/utils/serialize";
+import serialize from "serialize-javascript";
 import ReactHelmet from "react-helmet";
 import helmetReplace from "../helmet";
 import {
@@ -12,11 +12,13 @@ import { toFragments } from "./template";
 import { reduce } from "./reduce";
 import * as loadableRenderer from "./loadable";
 import * as styledComponentRenderer from "./styledComponent";
-const buildTemplateData = (context, data, routerData, renderLevel) => {
-  const { request } = context;
+const buildTemplateData = (context, data, renderLevel) => {
+  const { request, enableUnsafeCtx } = context;
+  const unsafeContext = {
+    headers: request.headers
+  };
   return {
     data,
-    routerData,
     context: {
       request: {
         params: request.params,
@@ -24,8 +26,7 @@ const buildTemplateData = (context, data, routerData, renderLevel) => {
         pathname: request.pathname,
         host: request.host,
         url: request.url,
-        headers: request.headers,
-        cookieMap: request.cookieMap
+        ...enableUnsafeCtx ? unsafeContext : {}
       }
     },
     renderLevel
@@ -71,15 +72,10 @@ class Entry {
     if ((_c = ssrContext.redirection) == null ? void 0 : _c.url) {
       return "";
     }
-    const { routerContext } = context;
-    const routerData = routerContext != null ? routerContext : {
-      loaderData: routerContext.loaderData
-    };
     let html = "";
     const templateData = buildTemplateData(
       ssrContext,
       prefetchData,
-      routerData,
       this.result.renderLevel
     );
     const SSRData = this.getSSRDataScript(templateData);
@@ -142,7 +138,9 @@ class Entry {
   getSSRDataScript(templateData) {
     return {
       SSRDataScript: `
-        <script>window._SSR_DATA = ${serializeJson(templateData)}<\/script>
+        <script>window._SSR_DATA = ${serialize(templateData, {
+        isJSON: true
+      })}</script>
       `
     };
   }

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

@@ -36,7 +36,7 @@ const toHtml = (jsx, renderer, next) => {
       }
       chunksMap[fileType] += `<script src="${v.url}" ${props.join(
         " "
-      )}><\/script>`;
+      )}></script>`;
     } else if (fileType === "css") {
       chunksMap[fileType] += `<link href="${v.url}" rel="stylesheet" />`;
     }

package/dist/esm-node/ssr/serverRender/time.worker.js

@@ -1,5 +1,5 @@
 function processHrtime(previousTimestamp) {
-  const now = new Date().getTime();
+  const now = (/* @__PURE__ */ new Date()).getTime();
   const clocktime = now * 1e-3;
   let seconds = Math.floor(clocktime);
   let nanoseconds = Math.floor(clocktime % 1 * 1e9);

package/dist/esm-node/ssr/serverRender/utils.js

@@ -4,7 +4,7 @@ function getLoadableScripts(extractor) {
   if (!check(scripts)) {
     return "";
   }
-  return scripts.split("<\/script>").slice(0, 2).map((i) => `${i}<\/script>`).join("");
+  return scripts.split("</script>").slice(0, 2).map((i) => `${i}</script>`).join("");
 }
 export {
   getLoadableScripts

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

@@ -1,3 +1,4 @@
+import cookieTool from "cookie";
 const isReact18 = () => process.env.IS_REACT18 === "true";
 const formatServer = (request) => {
   const {
@@ -7,6 +8,7 @@ const formatServer = (request) => {
   } = request.headers || {};
   return {
     cookie,
+    cookieMap: cookieTool.parse(cookie || "") || {},
     userAgent,
     referer,
     ...request
@@ -20,15 +22,15 @@ const getQuery = () => window.location.search.substring(1).split("&").reduce((re
   return res;
 }, {});
 const formatClient = (request) => {
-  var _a, _b;
+  var _a;
   return {
     params: request.params || {},
     host: request.host || location.host,
     pathname: request.pathname || location.pathname,
     headers: request.headers || {},
-    cookieMap: request.cookieMap || {},
-    cookie: ((_a = request.headers) == null ? void 0 : _a.cookie) || document.cookie,
-    userAgent: ((_b = request.headers) == null ? void 0 : _b["user-agent"]) || navigator.userAgent,
+    cookieMap: cookieTool.parse(document.cookie || "") || {},
+    cookie: document.cookie || "",
+    userAgent: ((_a = request.headers) == null ? void 0 : _a["user-agent"]) || navigator.userAgent,
     referer: request.referer || document.referrer,
     query: request.query || getQuery(),
     url: location.href

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

@@ -42,13 +42,7 @@ const state = (config) => ({
       hoc({ App }, next) {
         const getStateApp = (props) => {
           const context = useContext(RuntimeReactContext);
-          return /* @__PURE__ */ jsx(Provider, {
-            store: context.store,
-            config: storeConfig,
-            children: /* @__PURE__ */ jsx(App, {
-              ...props
-            })
-          });
+          return /* @__PURE__ */ jsx(Provider, { store: context.store, config: storeConfig, children: /* @__PURE__ */ jsx(App, { ...props }) });
         };
         return next({
           App: hoistNonReactStatics(getStateApp, App)

package/dist/types/common.d.ts

@@ -3,6 +3,4 @@ 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/index.d.ts

@@ -5,5 +5,4 @@ export * from './compatible';
 export type { TRuntimeContext, RuntimeContext } from '../runtime-context';
 export { RuntimeReactContext, ServerRouterContext } from '../runtime-context';
 export * from './loader';
-export type { SSRData, SSRContainer } from './types';
 export * from '@modern-js/plugin';