@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/router/runtime/plugin.node.js

@@ -1,211 +1,185 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var plugin_node_exports = {};
-__export(plugin_node_exports, {
-  modifyRoutes: () => modifyRoutes,
-  routerPlugin: () => routerPlugin
-});
-module.exports = __toCommonJS(plugin_node_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_merge = require("@modern-js/runtime-utils/merge");
-var import_node = require("@modern-js/runtime-utils/node");
-var import_router = require("@modern-js/runtime-utils/node/router");
-var import_remix_router = require("@modern-js/runtime-utils/remix-router");
-var import_router2 = require("@modern-js/runtime-utils/router");
-var import_time = require("@modern-js/runtime-utils/time");
-var import_constants = require("@modern-js/utils/universal/constants");
-var import_react = require("react");
-var import_common = require("../../common");
-var import_core = require("../../core");
-var import_context = require("../../core/context");
-var import_serverPayload = require("../../core/context/serverPayload/index.server");
-var import_DeferredDataScripts = __toESM(require("./DeferredDataScripts.node"));
-var import_hooks = require("./hooks");
-var import_rsc_router = require("./rsc-router");
-var import_utils = require("./utils");
-function createRemixReuqest(request) {
-  const method = "GET";
-  const { headers } = request;
-  const controller = new AbortController();
-  return new Request(request.url, {
-    method,
-    headers,
-    signal: controller.signal
-  });
-}
-const routerPlugin = (userConfig = {}) => {
-  return {
-    name: "@modern-js/plugin-router",
-    registryHooks: {
-      modifyRoutes: import_hooks.modifyRoutes,
-      onBeforeCreateRoutes: import_hooks.onBeforeCreateRoutes
-    },
-    setup: (api) => {
-      let finalRouteConfig = {};
-      api.onBeforeRender(async (context, interrupt) => {
-        var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1;
-        const pluginConfig = api.getRuntimeConfig();
-        const { basename = "", routesConfig, createRoutes } = (0, import_merge.merge)(pluginConfig.router || {}, userConfig);
-        finalRouteConfig = {
-          routes: (0, import_context.getGlobalRoutes)(),
-          globalApp: (0, import_context.getGlobalLayoutApp)(),
-          ...routesConfig
-        };
-        if (!finalRouteConfig.routes && !createRoutes) {
-          return;
-        }
-        const enableRsc = (0, import_context.getGlobalEnableRsc)();
-        if (enableRsc) {
-          await (0, import_rsc_router.prepareRSCRoutes)(finalRouteConfig.routes);
-        }
-        const { request, mode: ssrMode, nonce, loaderFailureMode = "errorBoundary" } = context.ssrContext;
-        const { baseUrl } = request;
-        const _basename = baseUrl === "/" ? (0, import_utils.urlJoin)(baseUrl, basename) : baseUrl;
-        const { reporter } = context.ssrContext;
-        const requestContext = (0, import_node.createRequestContext)((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.loaderContext);
-        requestContext.set(import_node.reporterCtx, reporter);
-        const hooks = api.getHooks();
-        await hooks.onBeforeCreateRoutes.call(context);
-        let routes = [];
-        if (enableRsc) {
-          routes = createRoutes ? createRoutes() : (0, import_utils.createRouteObjectsFromConfig)({
-            routesConfig: finalRouteConfig
-          });
-        } else {
-          routes = createRoutes ? createRoutes() : (0, import_router2.createRoutesFromElements)((0, import_utils.renderRoutes)({
-            routesConfig: finalRouteConfig,
-            ssrMode,
-            props: {
-              nonce
-            }
-          }));
-        }
-        routes = hooks.modifyRoutes.call(routes);
-        const { query } = (0, import_remix_router.createStaticHandler)(routes, {
-          basename: _basename
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
         });
-        const remixRequest = createRemixReuqest(context.ssrContext.request.raw);
-        const end = (0, import_time.time)();
-        const routerContext = await query(remixRequest, {
-          requestContext
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
         });
-        const cost = end();
-        (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : (_context_ssrContext_onTiming = _context_ssrContext1.onTiming) === null || _context_ssrContext_onTiming === void 0 ? void 0 : _context_ssrContext_onTiming.call(_context_ssrContext1, import_constants.LOADER_REPORTER_NAME, cost);
-        const isRSCNavigation = remixRequest.headers.get("x-rsc-tree") === "true";
-        if (routerContext instanceof Response) {
-          if (enableRsc && isRSCNavigation) {
-            return interrupt((0, import_rsc_router.handleRSCRedirect)(routerContext.headers, _basename, routerContext.status));
-          } else {
-            return interrupt(routerContext);
-          }
-        }
-        const errors = Object.values(routerContext.errors || {});
-        if (
-          // TODO: if loaderFailureMode is not 'errroBoundary', error log will not be printed.
-          errors.length > 0 && loaderFailureMode === "clientRender"
-        ) {
-          routerContext.statusCode = 200;
-          throw errors[0];
-        }
-        context.routerContext = routerContext;
-        let payload;
-        if (enableRsc) {
-          if (isRSCNavigation) {
-            for (const match of routerContext.matches) {
-              if (match.route.hasClientLoader) {
-                delete routerContext.loaderData[match.route.id];
-              }
-            }
-          }
-          payload = (0, import_rsc_router.createServerPayload)(routerContext, routes);
-          (0, import_serverPayload.setServerPayload)(payload);
-        }
-        Object.defineProperty(context, "routes", {
-          get() {
-            return routes;
-          },
-          enumerable: true
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
         });
-      });
-      api.wrapRoot((App) => {
-        if (!finalRouteConfig) {
-          return App;
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    modifyRoutes: ()=>modifyRoutes,
+    routerPlugin: ()=>routerPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_react_namespaceObject = require("react");
+const external_common_js_namespaceObject = require("../../common.js");
+const index_js_namespaceObject = require("../../core/context/index.js");
+const index_server_js_namespaceObject = require("../../core/context/serverPayload/index.server.js");
+const external_DeferredDataScripts_node_js_namespaceObject = require("./DeferredDataScripts.node.js");
+var external_DeferredDataScripts_node_js_default = /*#__PURE__*/ __webpack_require__.n(external_DeferredDataScripts_node_js_namespaceObject);
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_rsc_router_js_namespaceObject = require("./rsc-router.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function createRemixReuqest(request) {
+    const method = 'GET';
+    const { headers } = request;
+    const controller = new AbortController();
+    return new Request(request.url, {
+        method,
+        headers,
+        signal: controller.signal
+    });
+}
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes
+        },
+        setup: (api)=>{
+            let finalRouteConfig = {};
+            api.onBeforeRender(async (context, interrupt)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const { basename = '', routesConfig, createRoutes } = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+                finalRouteConfig = {
+                    routes: (0, index_js_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, index_js_namespaceObject.getGlobalLayoutApp)(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return;
+                const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                if (enableRsc) await (0, external_rsc_router_js_namespaceObject.prepareRSCRoutes)(finalRouteConfig.routes);
+                const { request, mode: ssrMode, nonce, loaderFailureMode = 'errorBoundary', baseUrl } = context.ssrContext;
+                const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename) : baseUrl;
+                const requestContext = (0, node_namespaceObject.createRequestContext)(context.ssrContext?.loaderContext);
+                const hooks = api.getHooks();
+                await hooks.onBeforeCreateRoutes.call(context);
+                let routes = [];
+                routes = enableRsc ? createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+                    routesConfig: finalRouteConfig
+                }) : createRoutes ? createRoutes() : (0, router_namespaceObject.createRoutesFromElements)((0, external_utils_js_namespaceObject.renderRoutes)({
+                    routesConfig: finalRouteConfig,
+                    ssrMode,
+                    props: {
+                        nonce
+                    }
+                }));
+                routes = hooks.modifyRoutes.call(routes);
+                const { query } = (0, router_namespaceObject.createStaticHandler)(routes, {
+                    basename: _basename
+                });
+                const remixRequest = createRemixReuqest(context.ssrContext.request.raw);
+                const end = (0, time_namespaceObject.time)();
+                const routerContext = await query(remixRequest, {
+                    requestContext
+                });
+                const cost = end();
+                context.ssrContext?.onTiming?.(constants_namespaceObject.LOADER_REPORTER_NAME, cost);
+                const isRSCNavigation = 'true' === remixRequest.headers.get('x-rsc-tree');
+                if (routerContext instanceof Response) if (enableRsc && isRSCNavigation) return interrupt((0, external_rsc_router_js_namespaceObject.handleRSCRedirect)(routerContext.headers, _basename, routerContext.status));
+                else return interrupt(routerContext);
+                const errors = Object.values(routerContext.errors || {});
+                if (errors.length > 0 && 'clientRender' === loaderFailureMode) {
+                    routerContext.statusCode = 200;
+                    throw errors[0];
+                }
+                context.routerContext = routerContext;
+                let payload;
+                if (enableRsc) {
+                    if (isRSCNavigation) {
+                        for (const match of routerContext.matches)if (match.route.hasClientLoader) delete routerContext.loaderData[match.route.id];
+                    }
+                    payload = (0, external_rsc_router_js_namespaceObject.createServerPayload)(routerContext, routes);
+                    (0, index_server_js_namespaceObject.setServerPayload)(payload);
+                }
+                Object.defineProperty(context, 'routes', {
+                    get () {
+                        return routes;
+                    },
+                    enumerable: true
+                });
+            });
+            api.wrapRoot((App)=>{
+                if (!finalRouteConfig) return App;
+                const getRouteApp = ()=>{
+                    const enableRsc = (0, index_js_namespaceObject.getGlobalEnableRsc)();
+                    return (props)=>{
+                        const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+                        const { routerContext, ssrContext, routes } = context;
+                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { basename } = routerContext;
+                        const remixRouter = (0, router_namespaceObject.createStaticRouter)(routes, routerContext);
+                        if (enableRsc) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
+                                basename: basename
+                            })
+                        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_rsc_router_js_namespaceObject.RSCStaticRouter, {
+                            basename: basename
+                        });
+                        {
+                            const routerWrapper = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                                children: [
+                                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(router_namespaceObject.StaticRouterProvider, {
+                                        router: remixRouter,
+                                        context: routerContext,
+                                        hydrate: false
+                                    }),
+                                    'stream' === mode && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DeferredDataScripts_node_js_default(), {
+                                        nonce: nonce,
+                                        context: routerContext,
+                                        useJsonScript: useJsonScript
+                                    }),
+                                    'stream' === mode && external_common_js_namespaceObject.JSX_SHELL_STREAM_END_MARK
+                                ]
+                            });
+                            return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                                children: routerWrapper
+                            }) : routerWrapper;
+                        }
+                    };
+                };
+                return getRouteApp();
+            });
         }
-        const getRouteApp = () => {
-          const enableRsc = (0, import_context.getGlobalEnableRsc)();
-          return (props) => {
-            const context = (0, import_react.useContext)(import_core.RuntimeReactContext);
-            const { routerContext, ssrContext, routes } = context;
-            const { nonce, mode, useJsonScript } = ssrContext;
-            const { basename } = routerContext;
-            const remixRouter = (0, import_router.createStaticRouter)(routes, routerContext);
-            if (!enableRsc) {
-              const routerWrapper = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
-                children: [
-                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_router.StaticRouterProvider, {
-                    router: remixRouter,
-                    context: routerContext,
-                    hydrate: false
-                  }),
-                  mode === "stream" && // ROUTER_DATA will inject in `packages/runtime/plugin-runtime/src/core/server/string/ssrData.ts` in string ssr
-                  // So we can inject it only when streaming ssr
-                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_DeferredDataScripts.default, {
-                    nonce,
-                    context: routerContext,
-                    useJsonScript
-                  }),
-                  mode === "stream" && import_common.JSX_SHELL_STREAM_END_MARK
-                ]
-              });
-              return App ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
-                children: routerWrapper
-              }) : routerWrapper;
-            } else {
-              return App ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App, {
-                children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_rsc_router.RSCStaticRouter, {
-                  basename
-                })
-              }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_rsc_router.RSCStaticRouter, {
-                basename
-              });
-            }
-          };
-        };
-        return getRouteApp();
-      });
-    }
-  };
-};
-const modifyRoutes = () => {
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  modifyRoutes,
-  routerPlugin
+    });
+const modifyRoutes = ()=>{};
+exports.modifyRoutes = __webpack_exports__.modifyRoutes;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "modifyRoutes",
+    "routerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/router/runtime/routerHelper.js

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createShouldRevalidate: ()=>createShouldRevalidate,
+    handleRouteModule: ()=>handleRouteModule,
+    handleRouteModuleError: ()=>handleRouteModuleError
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const createShouldRevalidate = (routeId)=>(arg)=>{
+        const routeModule = window?.[constants_namespaceObject.ROUTE_MODULES]?.[routeId];
+        if (routeModule && 'function' == typeof routeModule.shouldRevalidate) return routeModule.shouldRevalidate(arg);
+        return arg.defaultShouldRevalidate;
+    };
+const handleRouteModule = (routeModule, routeId)=>{
+    if ("u" > typeof document) window[constants_namespaceObject.ROUTE_MODULES][routeId] = routeModule;
+    return routeModule;
+};
+const handleRouteModuleError = (error)=>{
+    console.error(error);
+    return null;
+};
+exports.createShouldRevalidate = __webpack_exports__.createShouldRevalidate;
+exports.handleRouteModule = __webpack_exports__.handleRouteModule;
+exports.handleRouteModuleError = __webpack_exports__.handleRouteModuleError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createShouldRevalidate",
+    "handleRouteModule",
+    "handleRouteModuleError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});