@modern-js/runtime 2.67.11 → 2.68.1

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

@@ -0,0 +1,437 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+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";
+var safeUse = function(promise) {
+  if (typeof React.use === "function") {
+    return React.use(promise);
+  }
+  return null;
+};
+var createServerPayload = function(routerContext, routes) {
+  return {
+    type: "render",
+    actionData: routerContext.actionData,
+    errors: routerContext.errors,
+    loaderData: routerContext.loaderData,
+    location: routerContext.location,
+    routes: routerContext.matches.map(function(match, index, matches) {
+      var element = match.route.element;
+      var parentMatch = index > 0 ? matches[index - 1] : void 0;
+      var processedElement;
+      if (element) {
+        var _routerContext_loaderData, _routerContext_actionData;
+        var 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(function(m) {
+            var _routerContext_loaderData2;
+            var route = m.route, pathname = m.pathname, params = m.params;
+            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
+      };
+    })
+  };
+};
+var handleRSCRedirect = function(headers, basename, status) {
+  var newHeaders = new Headers(headers);
+  var 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
+  });
+};
+var prepareRSCRoutes = function() {
+  var _ref = _async_to_generator(function(routes) {
+    var isLazyComponent, processRoutes;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          isLazyComponent = function(component) {
+            return component && (typeof component === "undefined" ? "undefined" : _type_of(component)) === "object" && component._init !== void 0 && component._payload !== void 0;
+          };
+          processRoutes = function() {
+            var _ref2 = _async_to_generator(function(routesList) {
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    return [
+                      4,
+                      Promise.all(routesList.map(function() {
+                        var _ref3 = _async_to_generator(function(route) {
+                          return _ts_generator(this, function(_state3) {
+                            switch (_state3.label) {
+                              case 0:
+                                if (!("lazyImport" in route && isLazyComponent(route.component)))
+                                  return [
+                                    3,
+                                    2
+                                  ];
+                                return [
+                                  4,
+                                  route.lazyImport()
+                                ];
+                              case 1:
+                                route.component = _state3.sent().default;
+                                _state3.label = 2;
+                              case 2:
+                                if (!(route.children && Array.isArray(route.children)))
+                                  return [
+                                    3,
+                                    4
+                                  ];
+                                return [
+                                  4,
+                                  processRoutes(route.children)
+                                ];
+                              case 3:
+                                _state3.sent();
+                                _state3.label = 4;
+                              case 4:
+                                return [
+                                  2
+                                ];
+                            }
+                          });
+                        });
+                        return function(route) {
+                          return _ref3.apply(this, arguments);
+                        };
+                      }()))
+                    ];
+                  case 1:
+                    _state2.sent();
+                    return [
+                      2
+                    ];
+                }
+              });
+            });
+            return function processRoutes2(routesList) {
+              return _ref2.apply(this, arguments);
+            };
+          }();
+          return [
+            4,
+            processRoutes(routes)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function prepareRSCRoutes2(routes) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var mergeRoutes = function(routes, originalRoutes) {
+  if (!originalRoutes || !Array.isArray(originalRoutes)) {
+    return routes;
+  }
+  var routesMap = /* @__PURE__ */ new Map();
+  var buildRoutesMap = function(routesList) {
+    routesList.forEach(function(route) {
+      if (route.id) {
+        routesMap.set(route.id, route);
+      }
+      if ("children" in route && route.children && Array.isArray(route.children)) {
+        buildRoutesMap(route.children);
+      }
+    });
+  };
+  buildRoutesMap(routes);
+  var mergeRoutesRecursive = function(origRoutes) {
+    return origRoutes.map(function(origRoute) {
+      if (origRoute.id && routesMap.has(origRoute.id)) {
+        var matchedRoute = routesMap.get(origRoute.id);
+        var result = _object_spread({
+          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);
+};
+var findRouteInTree = function(routes, routeId) {
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      if (route.id === routeId) {
+        return route;
+      }
+      if (route.children && Array.isArray(route.children)) {
+        var found = findRouteInTree(route.children, routeId);
+        if (found) {
+          return found;
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return null;
+};
+var createClientRouterFromPayload = function(payload, originalRoutes) {
+  var basename = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
+  var processedRoutes = payload.routes.reduceRight(function(previous, route) {
+    if (previous.length > 0) {
+      return [
+        _object_spread_props(_object_spread({}, route), {
+          children: previous
+        })
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  var mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+  var router = createBrowserRouter(mergedRoutes, {
+    //@ts-ignore
+    hydrationData: payload,
+    basename,
+    dataStrategy: function() {
+      var _ref = _async_to_generator(function(context) {
+        var request, matches, results, clientMatches, fetchPromise, clientLoadersPromise, res, redirectLocation, _ref2, clientLoaderResults, _$payload;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              request = context.request, matches = context.matches;
+              results = {};
+              clientMatches = matches.filter(function(match) {
+                return match.route.hasClientLoader;
+              });
+              fetchPromise = fetch(request.url, {
+                headers: {
+                  "x-rsc-tree": "true"
+                }
+              });
+              clientLoadersPromise = clientMatches.length > 0 ? Promise.all(clientMatches.map(function() {
+                var _ref3 = _async_to_generator(function(clientMatch) {
+                  var foundRoute, res2;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        foundRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+                        clientMatch.route.loader = foundRoute === null || foundRoute === void 0 ? void 0 : foundRoute.loader;
+                        return [
+                          4,
+                          clientMatch.resolve()
+                        ];
+                      case 1:
+                        res2 = _state2.sent();
+                        return [
+                          2,
+                          {
+                            routeId: clientMatch.route.id,
+                            result: res2
+                          }
+                        ];
+                    }
+                  });
+                });
+                return function(clientMatch) {
+                  return _ref3.apply(this, arguments);
+                };
+              }())) : Promise.resolve([]);
+              return [
+                4,
+                fetchPromise
+              ];
+            case 1:
+              res = _state.sent();
+              redirectLocation = res.headers.get("X-Modernjs-Redirect");
+              if (redirectLocation) {
+                matches.forEach(function(match) {
+                  var routeId = match.route.id;
+                  if (routeId) {
+                    results[routeId] = {
+                      type: "redirect",
+                      result: redirect(redirectLocation)
+                    };
+                  }
+                });
+                return [
+                  2,
+                  results
+                ];
+              }
+              return [
+                4,
+                Promise.all([
+                  clientLoadersPromise
+                ])
+              ];
+            case 2:
+              _ref2 = _sliced_to_array.apply(void 0, [
+                _state.sent(),
+                1
+              ]), clientLoaderResults = _ref2[0];
+              clientLoaderResults.forEach(function(param) {
+                var routeId = param.routeId, result = param.result;
+                results[routeId] = result;
+              });
+              return [
+                4,
+                createFromReadableStream(res.body)
+              ];
+            case 3:
+              _$payload = _state.sent();
+              if (typeof _$payload.type === "undefined" || _$payload.type !== "render") {
+                throw new Error("Unexpected payload type");
+              }
+              matches.forEach(function(match) {
+                var _payload_loaderData;
+                var routeId = match.route.id;
+                var matchedRoute = _$payload.routes.find(function(route) {
+                  return route.id === routeId;
+                });
+                if (matchedRoute) {
+                  router.patchRoutes(matchedRoute.parentId, [
+                    matchedRoute
+                  ], true);
+                }
+                if ((_payload_loaderData = _$payload.loaderData) === null || _payload_loaderData === void 0 ? void 0 : _payload_loaderData[routeId]) {
+                  results[routeId] = {
+                    type: "data",
+                    result: _$payload.loaderData[routeId]
+                  };
+                }
+              });
+              return [
+                2,
+                results
+              ];
+          }
+        });
+      });
+      return function(context) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  });
+  return router;
+};
+var createRSCStaticRouterComponent = function(payload, basename) {
+  var routerContext = {
+    actionData: payload.actionData,
+    actionHeaders: {},
+    activeDeferreds: {},
+    basename: basename || "",
+    errors: payload.errors,
+    loaderData: payload.loaderData,
+    loaderHeaders: {},
+    location: payload.location,
+    statusCode: 200,
+    matches: payload.routes.map(function(match) {
+      return {
+        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
+        }
+      };
+    })
+  };
+  var processedRoutes = payload.routes.reduceRight(function(previous, route) {
+    if (previous.length > 0) {
+      return [
+        _object_spread_props(_object_spread({}, route), {
+          children: previous
+        })
+      ];
+    }
+    return [
+      route
+    ];
+  }, []);
+  var router = createStaticRouter(processedRoutes, routerContext);
+  return /* @__PURE__ */ _jsx(StaticRouterProvider, {
+    context: routerContext,
+    router,
+    hydrate: false
+  });
+};
+var RSCStaticRouter = function(param) {
+  var basename = param.basename;
+  var 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/router/runtime/utils.js

@@ -3,10 +3,12 @@ import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
 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, param) {
@@ -64,6 +66,96 @@ function getRouteComponents(routes, param) {
   }, "*"));
   return routeElements;
 }
+function getRouteObjects(routes, param) {
+  var globalApp = param.globalApp, ssrMode = param.ssrMode, props = param.props;
+  var createLayoutElement = function(Component) {
+    var GlobalLayout = globalApp;
+    if (!GlobalLayout) {
+      return Component;
+    }
+    var LayoutWrapper = function(props2) {
+      var LayoutComponent2 = GlobalLayout;
+      return /* @__PURE__ */ _jsx(LayoutComponent2, _object_spread({
+        Component
+      }, props2));
+    };
+    return LayoutWrapper;
+  };
+  var routeObjects = [];
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      if (route.type === "nested") {
+        var 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(function(child) {
+            return getRouteObjects([
+              child
+            ], {
+              globalApp,
+              ssrMode,
+              props
+            })[0];
+          }) : void 0
+        };
+        routeObjects.push(nestedRouteObject);
+      } else {
+        if (typeof route.component === "function" || _type_of(route.component) === "object") {
+          var LayoutComponent = createLayoutElement(route.component);
+          var routeObject = {
+            path: route.path,
+            element: /* @__PURE__ */ React.createElement(LayoutComponent)
+          };
+          routeObjects.push(routeObject);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  routeObjects.push({
+    path: "*",
+    element: /* @__PURE__ */ _jsx(DefaultNotFound, {})
+  });
+  return routeObjects;
+}
+function createRouteObjectsFromConfig(param) {
+  var routesConfig = param.routesConfig, props = param.props, ssrMode = param.ssrMode;
+  if (!routesConfig) {
+    return null;
+  }
+  var routes = routesConfig.routes, globalApp = routesConfig.globalApp;
+  if (!routes) {
+    return null;
+  }
+  return getRouteObjects(routes, {
+    globalApp,
+    ssrMode,
+    props
+  });
+}
 function renderRoutes(param) {
   var routesConfig = param.routesConfig, props = param.props, ssrMode = param.ssrMode;
   if (!routesConfig) {
@@ -82,7 +174,7 @@ function renderRoutes(param) {
 }
 function getLocation(serverContext) {
   var _url_replace;
-  var _ref = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {}, pathname = _ref.pathname, url = _ref.url;
+  var _ref = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {}, _ref_pathname = _ref.pathname, pathname = _ref_pathname === void 0 ? "" : _ref_pathname, _ref_url = _ref.url, url = _ref_url === void 0 ? "" : _ref_url;
   var cleanUrl = url === null || url === void 0 ? void 0 : (_url_replace = url.replace("http://", "")) === null || _url_replace === void 0 ? void 0 : _url_replace.replace("https://", "");
   var index = (cleanUrl || "").indexOf(pathname);
   if (index === -1) {
@@ -191,9 +283,11 @@ function deserializeErrors(errors) {
   return serialized;
 }
 export {
+  createRouteObjectsFromConfig,
   deserializeErrors,
   getLocation,
   getRouteComponents,
+  getRouteObjects,
   renderRoutes,
   serializeErrors,
   standardSlash,

package/dist/esm/rsc/client.js

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

package/dist/esm/rsc/server.js

@@ -1 +1,87 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 export * from "@modern-js/render/rsc";
+function processRSCStream(rscStream, controller, encoder) {
+  return _processRSCStream.apply(this, arguments);
+}
+function _processRSCStream() {
+  _processRSCStream = _async_to_generator(function(rscStream, controller, encoder) {
+    var reader, decoder, _ref, done, value, chunk, scriptTag, _String, base64, scriptTag1, remaining, scriptTag2, error;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            4,
+            ,
+            5
+          ]);
+          reader = rscStream.getReader();
+          decoder = new TextDecoder("utf-8", {
+            fatal: true
+          });
+          _state.label = 1;
+        case 1:
+          if (false)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            reader.read()
+          ];
+        case 2:
+          _ref = _state.sent(), done = _ref.done, value = _ref.value;
+          if (done)
+            return [
+              3,
+              3
+            ];
+          try {
+            chunk = JSON.stringify(decoder.decode(value, {
+              stream: true
+            }));
+            scriptTag = "<script>(self.__FLIGHT_DATA||=[]).push(".concat(chunk, ")</script>");
+            controller.enqueue(encoder.encode(scriptTag));
+          } catch (err) {
+            ;
+            base64 = JSON.stringify(btoa((_String = String).fromCodePoint.apply(_String, _to_consumable_array(value))));
+            scriptTag1 = "<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(".concat(base64, "), m => m.codePointAt(0)))</script>");
+            controller.enqueue(encoder.encode(scriptTag1));
+          }
+          return [
+            3,
+            1
+          ];
+        case 3:
+          remaining = decoder.decode();
+          if (remaining.length) {
+            scriptTag2 = "<script>(self.__FLIGHT_DATA||=[]).push(".concat(JSON.stringify(remaining), ")</script>");
+            controller.enqueue(encoder.encode(scriptTag2));
+          }
+          controller.close();
+          return [
+            3,
+            5
+          ];
+        case 4:
+          error = _state.sent();
+          controller.error(error);
+          return [
+            3,
+            5
+          ];
+        case 5:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _processRSCStream.apply(this, arguments);
+}
+export {
+  processRSCStream
+};

package/dist/esm-node/cli/alias.js

@@ -13,7 +13,7 @@ const builderPluginAlias = ({ entrypoints, internalDirectory, metaName }) => ({
         }
       });
       return mergeRsbuildConfig(userConfig, {
-        source: {
+        resolve: {
           alias: {
             ...entrypointsAlias,
             ...mainEntrypointsAlias