@modern-js/runtime 2.67.11 → 2.68.1

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

@@ -0,0 +1,284 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { ElementsContext, createFromReadableStream } from "@modern-js/render/client";
+import { StaticRouterProvider, createStaticRouter } from "@modern-js/runtime-utils/node/router";
+import { createBrowserRouter, redirect } from "@modern-js/runtime-utils/router";
+import React from "react";
+const safeUse = (promise) => {
+  if (typeof React.use === "function") {
+    return React.use(promise);
+  }
+  return null;
+};
+const createServerPayload = (routerContext, routes) => {
+  return {
+    type: "render",
+    actionData: routerContext.actionData,
+    errors: routerContext.errors,
+    loaderData: routerContext.loaderData,
+    location: routerContext.location,
+    routes: routerContext.matches.map((match, index, matches) => {
+      const element = match.route.element;
+      const parentMatch = index > 0 ? matches[index - 1] : void 0;
+      let processedElement;
+      if (element) {
+        var _routerContext_loaderData, _routerContext_actionData;
+        const ElementComponent = element.type;
+        processedElement = /* @__PURE__ */ React.createElement(ElementComponent, {
+          loaderData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData = routerContext.loaderData) === null || _routerContext_loaderData === void 0 ? void 0 : _routerContext_loaderData[match.route.id],
+          actionData: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_actionData = routerContext.actionData) === null || _routerContext_actionData === void 0 ? void 0 : _routerContext_actionData[match.route.id],
+          params: match.params,
+          matches: routerContext.matches.map((m) => {
+            var _routerContext_loaderData2;
+            const { route, pathname, params } = m;
+            return {
+              id: route.id,
+              pathname,
+              params,
+              data: routerContext === null || routerContext === void 0 ? void 0 : (_routerContext_loaderData2 = routerContext.loaderData) === null || _routerContext_loaderData2 === void 0 ? void 0 : _routerContext_loaderData2[route.id],
+              handle: route.handle
+            };
+          })
+        });
+      }
+      return {
+        element: processedElement,
+        errorElement: match.route.errorElement,
+        handle: match.route.handle,
+        hasAction: !!match.route.action,
+        hasErrorBoundary: !!match.route.hasErrorBoundary,
+        hasLoader: !!match.route.loader,
+        hasClientLoader: !!match.route.hasClientLoader,
+        id: match.route.id,
+        index: match.route.index,
+        params: match.params,
+        parentId: (parentMatch === null || parentMatch === void 0 ? void 0 : parentMatch.route.id) || match.route.parentId,
+        path: match.route.path,
+        pathname: match.pathname,
+        pathnameBase: match.pathnameBase
+      };
+    })
+  };
+};
+const handleRSCRedirect = (headers, basename, status) => {
+  const newHeaders = new Headers(headers);
+  let redirectUrl = headers.get("Location");
+  if (basename !== "/") {
+    redirectUrl = redirectUrl.replace(basename, "");
+  }
+  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
+  newHeaders.set("X-Modernjs-BaseUrl", basename);
+  newHeaders.delete("Location");
+  return new Response(null, {
+    status,
+    headers: newHeaders
+  });
+};
+const prepareRSCRoutes = async (routes) => {
+  const isLazyComponent = (component) => {
+    return component && typeof component === "object" && component._init !== void 0 && component._payload !== void 0;
+  };
+  const processRoutes = async (routesList) => {
+    await Promise.all(routesList.map(async (route) => {
+      if ("lazyImport" in route && isLazyComponent(route.component)) {
+        route.component = (await route.lazyImport()).default;
+      }
+      if (route.children && Array.isArray(route.children)) {
+        await processRoutes(route.children);
+      }
+    }));
+  };
+  await processRoutes(routes);
+};
+const mergeRoutes = (routes, originalRoutes) => {
+  if (!originalRoutes || !Array.isArray(originalRoutes)) {
+    return routes;
+  }
+  const routesMap = /* @__PURE__ */ new Map();
+  const buildRoutesMap = (routesList) => {
+    routesList.forEach((route) => {
+      if (route.id) {
+        routesMap.set(route.id, route);
+      }
+      if ("children" in route && route.children && Array.isArray(route.children)) {
+        buildRoutesMap(route.children);
+      }
+    });
+  };
+  buildRoutesMap(routes);
+  const mergeRoutesRecursive = (origRoutes) => {
+    return origRoutes.map((origRoute) => {
+      if (origRoute.id && routesMap.has(origRoute.id)) {
+        const matchedRoute = routesMap.get(origRoute.id);
+        const result = {
+          loader: origRoute.hasClientLoader ? origRoute.loader : void 0,
+          ...matchedRoute
+        };
+        if (origRoute.children && Array.isArray(origRoute.children)) {
+          result.children = mergeRoutesRecursive(origRoute.children);
+        }
+        return result;
+      }
+      return origRoute;
+    });
+  };
+  return mergeRoutesRecursive(originalRoutes);
+};
+const findRouteInTree = (routes, routeId) => {
+  for (const route of routes) {
+    if (route.id === routeId) {
+      return route;
+    }
+    if (route.children && Array.isArray(route.children)) {
+      const found = findRouteInTree(route.children, routeId);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+const createClientRouterFromPayload = (payload, originalRoutes, basename = "") => {
+  const processedRoutes = payload.routes.reduceRight((previous, route) => {
+    if (previous.length > 0) {
+      return [
+        {
+          ...route,
+          children: previous
+        }
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+  const router = createBrowserRouter(mergedRoutes, {
+    //@ts-ignore
+    hydrationData: payload,
+    basename,
+    dataStrategy: async (context) => {
+      const { request, matches } = context;
+      const results = {};
+      const clientMatches = matches.filter((match) => match.route.hasClientLoader);
+      const fetchPromise = fetch(request.url, {
+        headers: {
+          "x-rsc-tree": "true"
+        }
+      });
+      const clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(async (clientMatch) => {
+        const foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+        clientMatch.route.loader = foundRoute === null || foundRoute === void 0 ? void 0 : foundRoute.loader;
+        const res2 = await clientMatch.resolve();
+        return {
+          routeId: clientMatch.route.id,
+          result: res2
+        };
+      })) : Promise.resolve([]);
+      const res = await fetchPromise;
+      const redirectLocation = res.headers.get("X-Modernjs-Redirect");
+      if (redirectLocation) {
+        matches.forEach((match) => {
+          const routeId = match.route.id;
+          if (routeId) {
+            results[routeId] = {
+              type: "redirect",
+              result: redirect(redirectLocation)
+            };
+          }
+        });
+        return results;
+      }
+      const [clientLoaderResults] = await Promise.all([
+        clientLoadersPromise
+      ]);
+      clientLoaderResults.forEach(({ routeId, result }) => {
+        results[routeId] = result;
+      });
+      const payload2 = await createFromReadableStream(res.body);
+      if (typeof payload2.type === "undefined" || payload2.type !== "render") {
+        throw new Error("Unexpected payload type");
+      }
+      matches.forEach((match) => {
+        var _payload_loaderData;
+        const routeId = match.route.id;
+        const matchedRoute = payload2.routes.find((route) => route.id === routeId);
+        if (matchedRoute) {
+          router.patchRoutes(matchedRoute.parentId, [
+            matchedRoute
+          ], true);
+        }
+        if ((_payload_loaderData = payload2.loaderData) === null || _payload_loaderData === void 0 ? void 0 : _payload_loaderData[routeId]) {
+          results[routeId] = {
+            type: "data",
+            result: payload2.loaderData[routeId]
+          };
+        }
+      });
+      return results;
+    }
+  });
+  return router;
+};
+const createRSCStaticRouterComponent = (payload, basename) => {
+  const routerContext = {
+    actionData: payload.actionData,
+    actionHeaders: {},
+    activeDeferreds: {},
+    basename: basename || "",
+    errors: payload.errors,
+    loaderData: payload.loaderData,
+    loaderHeaders: {},
+    location: payload.location,
+    statusCode: 200,
+    matches: payload.routes.map((match) => ({
+      params: match.params,
+      pathname: match.pathname,
+      pathnameBase: match.pathnameBase,
+      route: {
+        id: match.id,
+        action: match.hasAction || !!match.clientAction,
+        handle: match.handle,
+        hasErrorBoundary: match.hasErrorBoundary,
+        loader: match.hasLoader || !!match.clientLoader,
+        index: match.index,
+        path: match.path,
+        shouldRevalidate: match.shouldRevalidate
+      }
+    }))
+  };
+  const processedRoutes = payload.routes.reduceRight((previous, route) => {
+    if (previous.length > 0) {
+      return [
+        {
+          ...route,
+          children: previous
+        }
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  const router = createStaticRouter(processedRoutes, routerContext);
+  return /* @__PURE__ */ _jsx(StaticRouterProvider, {
+    context: routerContext,
+    router,
+    hydrate: false
+  });
+};
+const RSCStaticRouter = ({ basename }) => {
+  const payload = safeUse(safeUse(ElementsContext));
+  if (!payload || payload.type !== "render") {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx(_Fragment, {
+    children: createRSCStaticRouterComponent(payload, basename)
+  });
+};
+export {
+  RSCStaticRouter,
+  createClientRouterFromPayload,
+  createServerPayload,
+  handleRSCRedirect,
+  prepareRSCRoutes
+};

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

@@ -2,6 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { renderNestedRoute } from "@modern-js/runtime-utils/browser";
 import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from "@modern-js/runtime-utils/remix-router";
 import { Route, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import React from "react";
 import { DefaultNotFound } from "./DefaultNotFound";
 import DeferredDataScripts from "./DeferredDataScripts";
 function getRouteComponents(routes, { globalApp, ssrMode, props }) {
@@ -41,6 +42,76 @@ function getRouteComponents(routes, { globalApp, ssrMode, props }) {
   }, "*"));
   return routeElements;
 }
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+  const createLayoutElement = (Component) => {
+    const GlobalLayout = globalApp;
+    if (!GlobalLayout) {
+      return Component;
+    }
+    const LayoutWrapper = (props2) => {
+      const LayoutComponent = GlobalLayout;
+      return /* @__PURE__ */ _jsx(LayoutComponent, {
+        Component,
+        ...props2
+      });
+    };
+    return LayoutWrapper;
+  };
+  const routeObjects = [];
+  for (const route of routes) {
+    if (route.type === "nested") {
+      const nestedRouteObject = {
+        path: route.path,
+        id: route.id,
+        loader: route.loader,
+        action: route.action,
+        hasErrorBoundary: route.hasErrorBoundary,
+        shouldRevalidate: route.shouldRevalidate,
+        handle: route.handle,
+        index: route.index,
+        hasClientLoader: !!route.clientData,
+        Component: route.component ? route.component : void 0,
+        errorElement: route.error ? /* @__PURE__ */ _jsx(route.error, {}) : void 0,
+        children: route.children ? route.children.map((child) => getRouteObjects([
+          child
+        ], {
+          globalApp,
+          ssrMode,
+          props
+        })[0]) : void 0
+      };
+      routeObjects.push(nestedRouteObject);
+    } else {
+      if (typeof route.component === "function" || typeof route.component === "object") {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+          path: route.path,
+          element: /* @__PURE__ */ React.createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+      }
+    }
+  }
+  routeObjects.push({
+    path: "*",
+    element: /* @__PURE__ */ _jsx(DefaultNotFound, {})
+  });
+  return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+  if (!routesConfig) {
+    return null;
+  }
+  const { routes, globalApp } = routesConfig;
+  if (!routes) {
+    return null;
+  }
+  return getRouteObjects(routes, {
+    globalApp,
+    ssrMode,
+    props
+  });
+}
 function renderRoutes({ routesConfig, props, ssrMode }) {
   if (!routesConfig) {
     return null;
@@ -58,7 +129,7 @@ function renderRoutes({ routesConfig, props, ssrMode }) {
 }
 function getLocation(serverContext) {
   var _url_replace;
-  const { pathname, url } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
+  const { pathname = "", url = "" } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
   const cleanUrl = url === null || url === void 0 ? void 0 : (_url_replace = url.replace("http://", "")) === null || _url_replace === void 0 ? void 0 : _url_replace.replace("https://", "");
   const index = (cleanUrl || "").indexOf(pathname);
   if (index === -1) {
@@ -131,9 +202,11 @@ function deserializeErrors(errors) {
   return serialized;
 }
 export {
+  createRouteObjectsFromConfig,
   deserializeErrors,
   getLocation,
   getRouteComponents,
+  getRouteObjects,
   renderRoutes,
   serializeErrors,
   standardSlash,

package/dist/esm-node/rsc/client.js

@@ -1 +1,7 @@
 export * from "@modern-js/render/client";
+const isRedirectResponse = (res) => {
+  return res.headers.get("X-Modernjs-Redirect") != null;
+};
+export {
+  isRedirectResponse
+};

package/dist/esm-node/rsc/server.js

@@ -1 +1,36 @@
 export * from "@modern-js/render/rsc";
+async function processRSCStream(rscStream, controller, encoder) {
+  try {
+    const reader = rscStream.getReader();
+    const decoder = new TextDecoder("utf-8", {
+      fatal: true
+    });
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      try {
+        const chunk = JSON.stringify(decoder.decode(value, {
+          stream: true
+        }));
+        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${chunk})</script>`;
+        controller.enqueue(encoder.encode(scriptTag));
+      } catch (err) {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...value)));
+        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(${base64}), m => m.codePointAt(0)))</script>`;
+        controller.enqueue(encoder.encode(scriptTag));
+      }
+    }
+    const remaining = decoder.decode();
+    if (remaining.length) {
+      const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${JSON.stringify(remaining)})</script>`;
+      controller.enqueue(encoder.encode(scriptTag));
+    }
+    controller.close();
+  } catch (error) {
+    controller.error(error);
+  }
+}
+export {
+  processRSCStream
+};

package/dist/types/cli/template.d.ts

@@ -1,11 +1,12 @@
 import type { RuntimePluginConfig } from '@modern-js/app-tools';
-export declare const entryForCSRWithRSC: ({ metaName, entryName, urlPath, mountId, }: {
+export declare const entryForCSRWithRSC: ({ metaName, entryName, urlPath, mountId, isNestedRouter, }: {
     metaName: string;
     entryName: string;
     urlPath?: string;
     mountId?: string;
+    isNestedRouter?: string;
 }) => string;
-export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc, }: {
+export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId, enableRsc, isNestedRouter, }: {
     srcDirectory: string;
     internalSrcAlias: string;
     metaName: string;
@@ -15,6 +16,7 @@ export declare const index: ({ srcDirectory, internalSrcAlias, metaName, entry,
     customBootstrap?: string | false;
     mountId?: string;
     enableRsc?: boolean;
+    isNestedRouter?: boolean;
 }) => string;
 export declare const register: () => string;
 export declare const runtimeRegister: ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins, }: {

package/dist/types/cli/template.server.d.ts

@@ -2,8 +2,9 @@ type ServerIndexOptinos = GenHandlerCodeOptions & {
     entryName: string;
 };
 export declare const serverIndex: (options: ServerIndexOptinos) => string;
-export declare const entryForCSRWithRSC: ({ metaName, }: {
+export declare const entryForCSRWithRSC: ({ metaName, entryName, }: {
     metaName: string;
+    entryName: string;
 }) => string;
 type GenHandlerCodeOptions = {
     customServerEntry?: string | false;

package/dist/types/common.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin, RuntimePluginFuture } from './core/plugin';
-import type { RouterConfig } from './router';
+import type { RouterConfig } from './router/internal';
 export declare const isBrowser: () => boolean;
 export interface AppConfig {
     router?: Pick<RouterConfig, 'future' | 'basename'>;

package/dist/types/config.d.ts

@@ -1,4 +1,4 @@
-import type { RouterConfig } from './router';
+import type { RouterConfig } from './router/internal';
 export interface RuntimeUserConfig {
     runtime?: {
         router?: boolean | RouterConfig;

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

@@ -1,8 +1,37 @@
 import type { InternalRuntimeContext } from '@modern-js/plugin-v2';
+import type { RouterState } from '@modern-js/runtime-utils/remix-router';
 import type { NestedRoute, PageRoute } from '@modern-js/types';
+import type React from 'react';
 import type { AppConfig } from '../../common';
 import type { RuntimeExtends } from '../plugin/types';
 export { type RuntimeContext, RuntimeReactContext, getInitialContext, } from './runtime';
+export type PayloadRoute = {
+    clientAction?: any;
+    clientLoader?: any;
+    element?: React.ReactNode;
+    errorElement?: React.ReactNode;
+    handle?: any;
+    hasAction: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    id: string;
+    index?: boolean;
+    params: Record<string, string>;
+    parentId?: string;
+    path?: string;
+    pathname: string;
+    pathnameBase: string;
+    shouldRevalidate?: any;
+};
+export type ServerPayload = {
+    type: 'render';
+    actionData: RouterState['actionData'];
+    errors: RouterState['errors'];
+    loaderData: RouterState['loaderData'];
+    location: RouterState['location'];
+    routes: PayloadRoute[];
+    originalRoutes?: PayloadRoute[];
+};
 interface GlobalContext {
     entryName?: string;
     /**
@@ -30,16 +59,22 @@ interface GlobalContext {
      * RSCRoot
      */
     RSCRoot?: React.ComponentType;
+    isRscClient?: boolean;
+    serverPayload?: ServerPayload;
+    enableRsc?: boolean;
 }
+export { getServerPayload, setServerPayload } from './serverPayload.server';
+export declare function getGlobalIsRscClient(): boolean | undefined;
+export declare function getGlobalEnableRsc(): boolean | undefined;
 export declare function setGlobalContext(context: Omit<GlobalContext, 'appConfig' | 'internalRuntimeContext'> & {
     appConfig?: () => AppConfig;
 }): void;
 export declare function getCurrentEntryName(): string | undefined;
-export declare function getGlobalRSCRoot(): import("react").ComponentType<{}> | undefined;
+export declare function getGlobalRSCRoot(): React.ComponentType<{}> | undefined;
 export declare function setGlobalInternalRuntimeContext(context: InternalRuntimeContext<RuntimeExtends>): void;
 export declare function getGlobalInternalRuntimeContext(): InternalRuntimeContext<Required<import("@modern-js/plugin-v2").RuntimePluginExtends<import("../plugin/types").RuntimeConfig, import("./runtime").RuntimeContext, {}, {}>>>;
-export declare function getGlobalApp(): import("react").ComponentType<{}> | undefined;
+export declare function getGlobalApp(): React.ComponentType<{}> | undefined;
 export declare function getGlobalRoutes(): undefined | (NestedRoute | PageRoute)[];
 export declare function getGlobalAppInit(): any;
 export declare function getGlobalAppConfig(): any;
-export declare function getGlobalLayoutApp(): import("react").ComponentType<{}> | undefined;
+export declare function getGlobalLayoutApp(): React.ComponentType<{}> | undefined;

package/dist/types/core/context/serverPayload.server.d.ts

@@ -0,0 +1,3 @@
+import type { ServerPayload } from './index';
+export declare const getServerPayload: () => ServerPayload | undefined;
+export declare const setServerPayload: (payload: ServerPayload) => void;

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

@@ -8,6 +8,6 @@ export type HandleRequestOptions = Exclude<RequestHandlerOptions, 'staticGenerat
 export type HandleRequest = (request: Request, ServerRoot: React.ComponentType, // App, routes,
 options: HandleRequestOptions) => Promise<Response>;
 export type CreateRequestHandler = (handleRequest: HandleRequest, options?: {
-    enableRsc: boolean;
+    enableRsc?: boolean;
 }) => Promise<RequestHandler>;
 export declare const createRequestHandler: CreateRequestHandler;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import type { RouterConfig } from './router';
+import type { RouterConfig } from './router/internal';
 export type { Plugin, RuntimePluginFuture } from './core';
 export type { AppConfig, RuntimeConfig } from './common';
 export { isBrowser } from './common';

package/dist/types/router/cli/code/index.d.ts

@@ -3,3 +3,4 @@ import type { CLIPluginAPI } from '@modern-js/plugin-v2';
 import type { Entrypoint } from '@modern-js/types';
 export declare const generateCode: (appContext: AppToolsContext<"shared">, config: AppNormalizedConfig<"shared">, entrypoints: Entrypoint[], api: CLIPluginAPI<AppTools<"shared">>, isRouterV5: boolean) => Promise<void>;
 export declare function generatorRegisterCode(internalDirectory: string, entryName: string, code: string): void;
+export declare function generatorServerRegisterCode(internalDirectory: string, entryName: string, code: string): void;

package/dist/types/router/cli/code/templates.d.ts

@@ -3,7 +3,7 @@ import type { Entrypoint, NestedRouteForCli, PageRoute, RouteLegacy, SSRMode } f
 export declare const routesForServer: ({ routesForServerLoaderMatches, }: {
     routesForServerLoaderMatches: (NestedRouteForCli | PageRoute)[];
 }) => string;
-export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, }: {
+export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoutesEntry, entryName, internalDirectory, splitRouteChunks, isRscClient, }: {
     metaName: string;
     routes: RouteLegacy[] | (NestedRouteForCli | PageRoute)[];
     ssrMode?: SSRMode;
@@ -11,13 +11,15 @@ export declare const fileSystemRoutes: ({ metaName, routes, ssrMode, nestedRoute
     entryName: string;
     internalDirectory: string;
     splitRouteChunks?: boolean;
+    isRscClient?: boolean;
 }) => Promise<string>;
 export declare function ssrLoaderCombinedModule(entrypoints: Entrypoint[], entrypoint: Entrypoint, config: AppNormalizedConfig<'shared'>, appContext: AppToolsContext<'shared'>): string | null;
-export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, }: {
+export declare const runtimeGlobalContext: ({ entryName, metaName, srcDirectory, nestedRoutesEntry, internalSrcAlias, globalApp, rscType, }: {
     entryName: string;
     metaName: string;
     srcDirectory: string;
     nestedRoutesEntry?: string;
     internalSrcAlias: string;
     globalApp?: string | false;
+    rscType?: "server" | "client" | false;
 }) => Promise<string>;

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

@@ -1,3 +1 @@
-export { default as router } from './runtime';
-export { default } from './runtime';
 export * from './runtime';

package/dist/types/router/internal.d.ts

@@ -0,0 +1,2 @@
+export * from './runtime/internal';
+export { routerPlugin as default } from './runtime/internal';

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

@@ -1,6 +1,5 @@
 import { type LinkProps as RouterLinkProps, type NavLinkProps as RouterNavLinkProps } from '@modern-js/runtime-utils/router';
 import React from 'react';
-export declare function composeEventHandlers<EventType extends React.SyntheticEvent | Event>(theirHandler: ((event: EventType) => any) | undefined, ourHandler: (event: EventType) => any): (event: EventType) => any;
 /**
  * Modified from https://github.com/remix-run/remix/blob/9a0601bd704d2f3ee622e0ddacab9b611eb0c5bc/packages/remix-react/components.tsx#L218
  *

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

@@ -109,7 +109,7 @@ export declare const preResolvedFnStr = "function p(e,r){return void 0!==r?Promi
       Object.assign(_ROUTER_DATA.loaderData[routeIdJsonStr], source);
     };
  */
-export declare const mergeLoaderDataStr = "function mergeLoaderData(e,n){const r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){const t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+export declare const mergeLoaderDataStr = "function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
 /**
    * This original string is: ${setupFnStr};${resolveFnStr};${preResolvedFnStr};
    * function mergeData (routeIdJsonStr, deferredKeyPromiseManifests) {
@@ -119,7 +119,7 @@ export declare const mergeLoaderDataStr = "function mergeLoaderData(e,n){const r
       Object.assign(_ROUTER_DATA.loaderData[routeIdJsonStr], source);
     };
    */
-export declare const initRouterDataAttrs = "_ROUTER_DATA.s = 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}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){const r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){const t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+export declare const initRouterDataAttrs = "_ROUTER_DATA.s = 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}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
 /**
   function runWindowFn() {
     window[document.currentScript.getAttribute('data-fn-name')](...JSON.parse(document.currentScript.getAttribute('data-fn-args')))
@@ -141,6 +141,6 @@ export declare const initRouterDataAttrs = "_ROUTER_DATA.s = function s(r,e){_RO
   initRouterData();
   ${initRouterDataAttrs}
 */
-export declare const modernInline = "function runWindowFn(){window[document.currentScript.getAttribute(\"data-fn-name\")](...JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute(\"data-fn-name\")](...JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error(\"parse \".concat(e,\" error\"),t),_ROUTER_DATA={}}};initRouterData('__MODERN_ROUTER_DATA__');_ROUTER_DATA.s = 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}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){const r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){const t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
+export declare const modernInline = "function runWindowFn(){window[document.currentScript.getAttribute(\"data-fn-name\")].apply(window,JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute(\"data-fn-name\")].apply(_ROUTER_DATA,JSON.parse(document.currentScript.getAttribute(\"data-fn-args\")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error(\"parse \".concat(e,\" error\"),t),_ROUTER_DATA={}}};initRouterData('__MODERN_ROUTER_DATA__');_ROUTER_DATA.s = 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}}))};_ROUTER_DATA.r = function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};_ROUTER_DATA.p = function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if(\"undefined\"!==e&&null!==e)return JSON.parse(e)}));return console.info(\"args\",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}";
 export declare const runRouterDataFnStr = "runRouterDataFn();";
 export declare const runWindowFnStr = "runWindowFn();";