@modern-js/runtime 2.60.6-alpha.0 → 2.61.0

package/dist/cjs/core/compatible.js

@@ -171,8 +171,16 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
 const useRuntimeContext = () => {
   var _context_ssrContext, _context_ssrContext1;
   const context = (0, import_react.useContext)(import_runtime.RuntimeReactContext);
+  const baseSSRContext = context.ssrContext;
+  const tSSRContext = baseSSRContext ? {
+    isBrowser: context.isBrowser,
+    request: baseSSRContext.request || {},
+    response: baseSSRContext.response || {},
+    logger: baseSSRContext.logger || {}
+  } : {};
   const pickedContext = {
     ...context,
+    context: tSSRContext,
     request: (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.request,
     response: (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : _context_ssrContext1.response
   };

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

@@ -25,10 +25,8 @@ var import_jsx_runtime = require("react/jsx-runtime");
 var import_node = require("@modern-js/runtime-utils/node");
 var import_router = require("@modern-js/runtime-utils/router");
 var import_react = require("react");
+var import_constants = require("./constants");
 var import_utils = require("./utils");
-const setupFnStr = `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}}))};`;
-const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
-const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
 const DeferredDataScripts = (props) => {
   const staticContext = props === null || props === void 0 ? void 0 : props.context;
   const hydratedRef = (0, import_react.useRef)(false);
@@ -44,17 +42,18 @@ const DeferredDataScripts = (props) => {
       loaderData: staticContext.loaderData,
       errors: (0, import_utils.serializeErrors)(staticContext.errors)
     };
-    let initialScripts = [
-      `_ROUTER_DATA = ${(0, import_node.serializeJson)(_ROUTER_DATA)};`,
-      `_ROUTER_DATA.s = ${setupFnStr}`,
-      `_ROUTER_DATA.r = ${resolveFnStr}`,
-      `_ROUTER_DATA.p = ${preResolvedFnStr}`
+    const initialScript0 = `_ROUTER_DATA = ${(0, import_node.serializeJson)(_ROUTER_DATA)};`;
+    const initialScript1 = [
+      `_ROUTER_DATA.s = ${import_constants.setupFnStr}`,
+      `_ROUTER_DATA.r = ${import_constants.resolveFnStr}`,
+      `_ROUTER_DATA.p = ${import_constants.preResolvedFnStr}`,
+      import_constants.mergeLoaderDataStr
     ].join("\n");
     const deferredDataScripts = [];
-    initialScripts += Object.entries(activeDeferreds).map(([routeId, deferredData]) => {
+    const initialScripts = Object.entries(activeDeferreds).map(([routeId, deferredData]) => {
       const pendingKeys = new Set(deferredData.pendingKeys);
       const { deferredKeys } = deferredData;
-      const deferredKeyPromiseStr = deferredKeys.map((key) => {
+      const deferredKeyPromiseManifests = deferredKeys.map((key) => {
         if (pendingKeys.has(key)) {
           deferredDataScripts.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(DeferredDataScript, {
             nonce: props === null || props === void 0 ? void 0 : props.nonce,
@@ -62,7 +61,14 @@ const DeferredDataScripts = (props) => {
             dataKey: key,
             routeId
           }, `${routeId} | ${key}`));
-          return `${JSON.stringify(key)}: _ROUTER_DATA.s(${JSON.stringify(routeId)},${JSON.stringify(key)}) `;
+          return {
+            key,
+            routerDataFnName: "s",
+            routerDataFnArgs: [
+              (0, import_node.serializeJson)(routeId),
+              (0, import_node.serializeJson)(key)
+            ]
+          };
         } else {
           const trackedPromise = deferredData.data[key];
           if (typeof trackedPromise._error !== "undefined") {
@@ -70,18 +76,39 @@ const DeferredDataScripts = (props) => {
               message: trackedPromise._error.message,
               stack: process.env.NODE_ENV !== "production" ? trackedPromise._error.stack : void 0
             };
-            return `${JSON.stringify(key)}: _ROUTER_DATA.p(${void 0}, ${(0, import_node.serializeJson)(error)})`;
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                (0, import_node.serializeJson)(void 0),
+                (0, import_node.serializeJson)(error)
+              ]
+            };
           } else {
             if (typeof trackedPromise._data === "undefined") {
               throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
             }
-            return `${JSON.stringify(key)}: _ROUTER_DATA.p(${(0, import_node.serializeJson)(trackedPromise._data)})`;
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                (0, import_node.serializeJson)(trackedPromise._data)
+              ]
+            };
           }
         }
-      }).join(",\n");
-      return `Object.assign(_ROUTER_DATA.loaderData[${JSON.stringify(routeId)}], {${deferredKeyPromiseStr}});`;
-    }).join("\n");
+      });
+      return {
+        fnName: `mergeLoaderData`,
+        fnArgs: [
+          routeId,
+          deferredKeyPromiseManifests
+        ]
+      };
+    });
     return [
+      initialScript0,
+      initialScript1,
       initialScripts,
       deferredDataScripts
     ];
@@ -91,15 +118,35 @@ const DeferredDataScripts = (props) => {
   }
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
     children: [
-      !hydratedRef.current && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
-        async: true,
-        nonce: props === null || props === void 0 ? void 0 : props.nonce,
-        suppressHydrationWarning: true,
-        dangerouslySetInnerHTML: {
-          __html: deferredScripts[0]
-        }
+      !hydratedRef.current && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[0]
+            }
+          }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[1]
+            }
+          }),
+          deferredScripts[2].map(({ fnName, fnArgs }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: `${fnName}(${fnArgs.map((argv) => `${JSON.stringify(argv)}`).join(",")})`
+            }
+          }, fnName))
+        ]
       }),
-      !hydratedRef.current && deferredScripts[1]
+      !hydratedRef.current && deferredScripts[3]
     ]
   });
 };

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

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  mergeLoaderDataStr: () => mergeLoaderDataStr,
+  preResolvedFnStr: () => preResolvedFnStr,
+  resolveFnStr: () => resolveFnStr,
+  setupFnStr: () => setupFnStr
+});
+module.exports = __toCommonJS(constants_exports);
+const setupFnStr = `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}}))};`;
+const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
+const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
+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)}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeLoaderDataStr,
+  preResolvedFnStr,
+  resolveFnStr,
+  setupFnStr
+});

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

@@ -160,23 +160,6 @@ const routerPlugin = (userConfig = {}) => {
             };
           };
           return getRouteApp();
-        },
-        pickContext: (pickedContext) => {
-          const { remixRouter } = pickedContext;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          const router = {
-            ...pickedContext.router,
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          };
-          return {
-            ...pickedContext,
-            router
-          };
         }
       };
     }

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

@@ -149,22 +149,6 @@ const routerPlugin = (userConfig = {}) => {
             };
           };
           return getRouteApp();
-        },
-        pickContext: (pickedContext) => {
-          const { remixRouter } = pickedContext;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          const router = {
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          };
-          return {
-            ...pickedContext,
-            router
-          };
         }
       };
     }

package/dist/esm/core/compatible.js

@@ -193,7 +193,15 @@ var bootstrap = function() {
 var useRuntimeContext = function() {
   var _context_ssrContext, _context_ssrContext1;
   var context = useContext(RuntimeReactContext);
+  var baseSSRContext = context.ssrContext;
+  var tSSRContext = baseSSRContext ? {
+    isBrowser: context.isBrowser,
+    request: baseSSRContext.request || {},
+    response: baseSSRContext.response || {},
+    logger: baseSSRContext.logger || {}
+  } : {};
   var pickedContext = _object_spread_props(_object_spread({}, context), {
+    context: tSSRContext,
     request: (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.request,
     response: (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : _context_ssrContext1.response
   });

package/dist/esm/router/runtime/DeferredDataScripts.node.js

@@ -3,10 +3,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { serializeJson } from "@modern-js/runtime-utils/node";
 import { Await, useAsyncError } from "@modern-js/runtime-utils/router";
 import { Suspense, useEffect, useMemo, useRef } from "react";
+import { mergeLoaderDataStr, preResolvedFnStr, resolveFnStr, setupFnStr } from "./constants";
 import { serializeErrors } from "./utils";
-var setupFnStr = "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}}))};";
-var resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
-var preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
 var DeferredDataScripts = function(props) {
   var staticContext = props === null || props === void 0 ? void 0 : props.context;
   var hydratedRef = useRef(false);
@@ -22,18 +20,19 @@ var DeferredDataScripts = function(props) {
       loaderData: staticContext.loaderData,
       errors: serializeErrors(staticContext.errors)
     };
-    var initialScripts = [
-      "_ROUTER_DATA = ".concat(serializeJson(_ROUTER_DATA), ";"),
+    var initialScript0 = "_ROUTER_DATA = ".concat(serializeJson(_ROUTER_DATA), ";");
+    var initialScript1 = [
       "_ROUTER_DATA.s = ".concat(setupFnStr),
       "_ROUTER_DATA.r = ".concat(resolveFnStr),
-      "_ROUTER_DATA.p = ".concat(preResolvedFnStr)
+      "_ROUTER_DATA.p = ".concat(preResolvedFnStr),
+      mergeLoaderDataStr
     ].join("\n");
     var deferredDataScripts = [];
-    initialScripts += Object.entries(activeDeferreds).map(function(param) {
+    var initialScripts = Object.entries(activeDeferreds).map(function(param) {
       var _param = _sliced_to_array(param, 2), routeId = _param[0], deferredData = _param[1];
       var pendingKeys = new Set(deferredData.pendingKeys);
       var deferredKeys = deferredData.deferredKeys;
-      var deferredKeyPromiseStr = deferredKeys.map(function(key) {
+      var deferredKeyPromiseManifests = deferredKeys.map(function(key) {
         if (pendingKeys.has(key)) {
           deferredDataScripts.push(/* @__PURE__ */ _jsx(DeferredDataScript, {
             nonce: props === null || props === void 0 ? void 0 : props.nonce,
@@ -41,7 +40,14 @@ var DeferredDataScripts = function(props) {
             dataKey: key,
             routeId
           }, "".concat(routeId, " | ").concat(key)));
-          return "".concat(JSON.stringify(key), ": _ROUTER_DATA.s(").concat(JSON.stringify(routeId), ",").concat(JSON.stringify(key), ") ");
+          return {
+            key,
+            routerDataFnName: "s",
+            routerDataFnArgs: [
+              serializeJson(routeId),
+              serializeJson(key)
+            ]
+          };
         } else {
           var trackedPromise = deferredData.data[key];
           if (typeof trackedPromise._error !== "undefined") {
@@ -49,18 +55,39 @@ var DeferredDataScripts = function(props) {
               message: trackedPromise._error.message,
               stack: process.env.NODE_ENV !== "production" ? trackedPromise._error.stack : void 0
             };
-            return "".concat(JSON.stringify(key), ": _ROUTER_DATA.p(").concat(void 0, ", ").concat(serializeJson(error), ")");
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                serializeJson(void 0),
+                serializeJson(error)
+              ]
+            };
           } else {
             if (typeof trackedPromise._data === "undefined") {
               throw new Error("The deferred data for ".concat(key, " was not resolved, did you forget to return data from a deferred promise"));
             }
-            return "".concat(JSON.stringify(key), ": _ROUTER_DATA.p(").concat(serializeJson(trackedPromise._data), ")");
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                serializeJson(trackedPromise._data)
+              ]
+            };
           }
         }
-      }).join(",\n");
-      return "Object.assign(_ROUTER_DATA.loaderData[".concat(JSON.stringify(routeId), "], {").concat(deferredKeyPromiseStr, "});");
-    }).join("\n");
+      });
+      return {
+        fnName: "mergeLoaderData",
+        fnArgs: [
+          routeId,
+          deferredKeyPromiseManifests
+        ]
+      };
+    });
     return [
+      initialScript0,
+      initialScript1,
       initialScripts,
       deferredDataScripts
     ];
@@ -70,15 +97,40 @@ var DeferredDataScripts = function(props) {
   }
   return /* @__PURE__ */ _jsxs(_Fragment, {
     children: [
-      !hydratedRef.current && /* @__PURE__ */ _jsx("script", {
-        async: true,
-        nonce: props === null || props === void 0 ? void 0 : props.nonce,
-        suppressHydrationWarning: true,
-        dangerouslySetInnerHTML: {
-          __html: deferredScripts[0]
-        }
+      !hydratedRef.current && /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          /* @__PURE__ */ _jsx("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[0]
+            }
+          }),
+          /* @__PURE__ */ _jsx("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[1]
+            }
+          }),
+          deferredScripts[2].map(function(param) {
+            var fnName = param.fnName, fnArgs = param.fnArgs;
+            return /* @__PURE__ */ _jsx("script", {
+              async: true,
+              nonce: props === null || props === void 0 ? void 0 : props.nonce,
+              suppressHydrationWarning: true,
+              dangerouslySetInnerHTML: {
+                __html: "".concat(fnName, "(").concat(fnArgs.map(function(argv) {
+                  return "".concat(JSON.stringify(argv));
+                }).join(","), ")")
+              }
+            }, fnName);
+          })
+        ]
       }),
-      !hydratedRef.current && deferredScripts[1]
+      !hydratedRef.current && deferredScripts[3]
     ]
   });
 };

package/dist/esm/router/runtime/constants.js

@@ -0,0 +1,10 @@
+var setupFnStr = "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}}))};";
+var resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+var preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+var 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 {
+  mergeLoaderDataStr,
+  preResolvedFnStr,
+  resolveFnStr,
+  setupFnStr
+};

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

@@ -145,21 +145,6 @@ var routerPlugin = function() {
             };
           };
           return getRouteApp();
-        },
-        pickContext: function(pickedContext) {
-          var remixRouter = pickedContext.remixRouter;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          var router = _object_spread_props(_object_spread({}, pickedContext.router), {
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          });
-          return _object_spread_props(_object_spread({}, pickedContext), {
-            router
-          });
         }
       };
     }

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

@@ -1,7 +1,6 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { merge } from "@modern-js/runtime-utils/merge";
@@ -145,21 +144,6 @@ var routerPlugin = function() {
             };
           };
           return getRouteApp();
-        },
-        pickContext: function(pickedContext) {
-          var remixRouter = pickedContext.remixRouter;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          var router = {
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          };
-          return _object_spread_props(_object_spread({}, pickedContext), {
-            router
-          });
         }
       };
     }

package/dist/esm-node/core/compatible.js

@@ -136,8 +136,16 @@ const bootstrap = async (BootApp, id, root, ReactDOM) => {
 const useRuntimeContext = () => {
   var _context_ssrContext, _context_ssrContext1;
   const context = useContext(RuntimeReactContext);
+  const baseSSRContext = context.ssrContext;
+  const tSSRContext = baseSSRContext ? {
+    isBrowser: context.isBrowser,
+    request: baseSSRContext.request || {},
+    response: baseSSRContext.response || {},
+    logger: baseSSRContext.logger || {}
+  } : {};
   const pickedContext = {
     ...context,
+    context: tSSRContext,
     request: (_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.request,
     response: (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : _context_ssrContext1.response
   };

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

@@ -2,10 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { serializeJson } from "@modern-js/runtime-utils/node";
 import { Await, useAsyncError } from "@modern-js/runtime-utils/router";
 import { Suspense, useEffect, useMemo, useRef } from "react";
+import { mergeLoaderDataStr, preResolvedFnStr, resolveFnStr, setupFnStr } from "./constants";
 import { serializeErrors } from "./utils";
-const setupFnStr = `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}}))};`;
-const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
-const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
 const DeferredDataScripts = (props) => {
   const staticContext = props === null || props === void 0 ? void 0 : props.context;
   const hydratedRef = useRef(false);
@@ -21,17 +19,18 @@ const DeferredDataScripts = (props) => {
       loaderData: staticContext.loaderData,
       errors: serializeErrors(staticContext.errors)
     };
-    let initialScripts = [
-      `_ROUTER_DATA = ${serializeJson(_ROUTER_DATA)};`,
+    const initialScript0 = `_ROUTER_DATA = ${serializeJson(_ROUTER_DATA)};`;
+    const initialScript1 = [
       `_ROUTER_DATA.s = ${setupFnStr}`,
       `_ROUTER_DATA.r = ${resolveFnStr}`,
-      `_ROUTER_DATA.p = ${preResolvedFnStr}`
+      `_ROUTER_DATA.p = ${preResolvedFnStr}`,
+      mergeLoaderDataStr
     ].join("\n");
     const deferredDataScripts = [];
-    initialScripts += Object.entries(activeDeferreds).map(([routeId, deferredData]) => {
+    const initialScripts = Object.entries(activeDeferreds).map(([routeId, deferredData]) => {
       const pendingKeys = new Set(deferredData.pendingKeys);
       const { deferredKeys } = deferredData;
-      const deferredKeyPromiseStr = deferredKeys.map((key) => {
+      const deferredKeyPromiseManifests = deferredKeys.map((key) => {
         if (pendingKeys.has(key)) {
           deferredDataScripts.push(/* @__PURE__ */ _jsx(DeferredDataScript, {
             nonce: props === null || props === void 0 ? void 0 : props.nonce,
@@ -39,7 +38,14 @@ const DeferredDataScripts = (props) => {
             dataKey: key,
             routeId
           }, `${routeId} | ${key}`));
-          return `${JSON.stringify(key)}: _ROUTER_DATA.s(${JSON.stringify(routeId)},${JSON.stringify(key)}) `;
+          return {
+            key,
+            routerDataFnName: "s",
+            routerDataFnArgs: [
+              serializeJson(routeId),
+              serializeJson(key)
+            ]
+          };
         } else {
           const trackedPromise = deferredData.data[key];
           if (typeof trackedPromise._error !== "undefined") {
@@ -47,18 +53,39 @@ const DeferredDataScripts = (props) => {
               message: trackedPromise._error.message,
               stack: process.env.NODE_ENV !== "production" ? trackedPromise._error.stack : void 0
             };
-            return `${JSON.stringify(key)}: _ROUTER_DATA.p(${void 0}, ${serializeJson(error)})`;
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                serializeJson(void 0),
+                serializeJson(error)
+              ]
+            };
           } else {
             if (typeof trackedPromise._data === "undefined") {
               throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
             }
-            return `${JSON.stringify(key)}: _ROUTER_DATA.p(${serializeJson(trackedPromise._data)})`;
+            return {
+              key,
+              routerDataFnName: "p",
+              routerDataFnArgs: [
+                serializeJson(trackedPromise._data)
+              ]
+            };
           }
         }
-      }).join(",\n");
-      return `Object.assign(_ROUTER_DATA.loaderData[${JSON.stringify(routeId)}], {${deferredKeyPromiseStr}});`;
-    }).join("\n");
+      });
+      return {
+        fnName: `mergeLoaderData`,
+        fnArgs: [
+          routeId,
+          deferredKeyPromiseManifests
+        ]
+      };
+    });
     return [
+      initialScript0,
+      initialScript1,
       initialScripts,
       deferredDataScripts
     ];
@@ -68,15 +95,35 @@ const DeferredDataScripts = (props) => {
   }
   return /* @__PURE__ */ _jsxs(_Fragment, {
     children: [
-      !hydratedRef.current && /* @__PURE__ */ _jsx("script", {
-        async: true,
-        nonce: props === null || props === void 0 ? void 0 : props.nonce,
-        suppressHydrationWarning: true,
-        dangerouslySetInnerHTML: {
-          __html: deferredScripts[0]
-        }
+      !hydratedRef.current && /* @__PURE__ */ _jsxs(_Fragment, {
+        children: [
+          /* @__PURE__ */ _jsx("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[0]
+            }
+          }),
+          /* @__PURE__ */ _jsx("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: deferredScripts[1]
+            }
+          }),
+          deferredScripts[2].map(({ fnName, fnArgs }) => /* @__PURE__ */ _jsx("script", {
+            async: true,
+            nonce: props === null || props === void 0 ? void 0 : props.nonce,
+            suppressHydrationWarning: true,
+            dangerouslySetInnerHTML: {
+              __html: `${fnName}(${fnArgs.map((argv) => `${JSON.stringify(argv)}`).join(",")})`
+            }
+          }, fnName))
+        ]
       }),
-      !hydratedRef.current && deferredScripts[1]
+      !hydratedRef.current && deferredScripts[3]
     ]
   });
 };

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

@@ -0,0 +1,10 @@
+const setupFnStr = `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}}))};`;
+const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
+const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
+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 {
+  mergeLoaderDataStr,
+  preResolvedFnStr,
+  resolveFnStr,
+  setupFnStr
+};

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

@@ -134,23 +134,6 @@ const routerPlugin = (userConfig = {}) => {
             };
           };
           return getRouteApp();
-        },
-        pickContext: (pickedContext) => {
-          const { remixRouter } = pickedContext;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          const router = {
-            ...pickedContext.router,
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          };
-          return {
-            ...pickedContext,
-            router
-          };
         }
       };
     }

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

@@ -115,22 +115,6 @@ const routerPlugin = (userConfig = {}) => {
             };
           };
           return getRouteApp();
-        },
-        pickContext: (pickedContext) => {
-          const { remixRouter } = pickedContext;
-          if (!remixRouter) {
-            return pickedContext;
-          }
-          const router = {
-            navigate: remixRouter.navigate,
-            get location() {
-              return remixRouter.state.location;
-            }
-          };
-          return {
-            ...pickedContext,
-            router
-          };
         }
       };
     }

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

@@ -1,13 +1,14 @@
 /// <reference types="react" />
 import type { Store } from '@modern-js-reduck/store';
-import type { Router, RouterState, StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import type { Router, StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
 import type { RouteManifest } from '../../router/runtime/types';
 import { createLoaderManager } from '../loader/loaderManager';
 import type { PluginRunner, runtime } from '../plugin';
-import type { SSRServerContext } from '../types';
-export interface BaseRuntimeContext {
+import type { SSRServerContext, TSSRContext } from '../types';
+interface BaseRuntimeContext {
     initialData?: Record<string, unknown>;
     loaderManager: ReturnType<typeof createLoaderManager>;
+    isBrowser: boolean;
     runner: ReturnType<typeof runtime.init>;
     ssrContext?: SSRServerContext;
     store?: Store;
@@ -27,17 +28,16 @@ export interface RuntimeContext extends BaseRuntimeContext {
 }
 export declare const RuntimeReactContext: import("react").Context<RuntimeContext>;
 export declare const ServerRouterContext: import("react").Context<any>;
-export interface BaseTRuntimeContext extends Partial<BaseRuntimeContext> {
+export interface TRuntimeContext extends Partial<BaseRuntimeContext> {
     initialData?: Record<string, unknown>;
+    isBrowser: boolean;
+    context: TSSRContext;
+    /** @deprecated use context.request field instead */
     request?: SSRServerContext['request'];
+    /** @deprecated use context.response field instead */
     response?: SSRServerContext['response'];
     store?: Store;
-    router?: {
-        navigate: Router['navigate'];
-        location: RouterState['location'];
-    };
-}
-export interface TRuntimeContext extends BaseTRuntimeContext {
     [key: string]: any;
 }
 export declare const getInitialContext: (runner: PluginRunner, isBrowser?: boolean, routeManifest?: RouteManifest) => RuntimeContext;
+export {};

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

@@ -53,4 +53,20 @@ export type SSRServerContext = Pick<BaseSSRServerContext, 'redirection' | 'respo
     onError?: (e: unknown) => void;
     onTiming?: (name: string, dur: number) => void;
 };
+interface TSSRBaseContext {
+    request: BaseSSRServerContext['request'] & {
+        userAgent: string;
+        cookie: string;
+    };
+    [propName: string]: any;
+}
+interface ServerContext extends TSSRBaseContext {
+    isBrowser: false;
+    response: BaseSSRServerContext['response'];
+    logger: BaseSSRServerContext['logger'];
+}
+interface ClientContext extends TSSRBaseContext {
+    isBrowser: true;
+}
+export declare type TSSRContext = ServerContext | ClientContext;
 export {};

package/dist/types/index.d.ts

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

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

@@ -0,0 +1,112 @@
+/**
+ * setup promises for deferred data
+ * original function:
+  function setupDeferredPromise(routeId, key) {
+    _ROUTER_DATA.r  = _ROUTER_DATA.r || {};
+    _ROUTER_DATA.r[routeId] = _ROUTER_DATA.r[routeId] || {};
+    const promise = new Promise(function (resolve, reject) {
+      _ROUTER_DATA.r[routeId][key] = {
+        resolve,
+        reject,
+      };
+    });
+    return promise;
+  };
+ *
+ */
+export declare const setupFnStr = "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}}))};";
+/**
+   * resolve promises for deferred data
+   * original function:
+    function resolveDeferredPromise(routeId, key, data, error) {
+      if (error) {
+        _ROUTER_DATA.r[routeId][key].reject(error);
+      } else {
+        _ROUTER_DATA.r[routeId][key].resolve(data);
+      }
+    };
+   */
+export declare const resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+/**
+   * update data for pre resolved promises
+   * original function:
+   * function preResovledDeferredPromise(data, error) {
+    if(typeof error !== 'undefined'){
+      return Promise.reject(new Error(error.message));
+    }else{
+      return Promise.resolve(data);
+    }
+  }
+   */
+export declare const preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+/**
+ * let initialScripts = '...';
+ * initialScripts += Object.entries(activeDeferreds)
+      .map(([routeId, deferredData]) => {
+        const pendingKeys = new Set(deferredData.pendingKeys);
+        const { deferredKeys } = deferredData;
+        const deferredKeyPromiseStr = deferredKeys
+          .map(key => {
+            if (pendingKeys.has(key)) {
+              deferredDataScripts.push(
+                <DeferredDataScript
+                  nonce={props?.nonce}
+                  key={`${routeId} | ${key}`}
+                  data={deferredData.data[key]}
+                  dataKey={key}
+                  routeId={routeId}
+                />,
+              );
+
+              return `${JSON.stringify(key)}: _ROUTER_DATA.s(${JSON.stringify(
+                routeId,
+              )},${JSON.stringify(key)}) `;
+            } else {
+              const trackedPromise = deferredData.data[key] as TrackedPromise;
+              if (typeof trackedPromise._error !== 'undefined') {
+                const error = {
+                  message: trackedPromise._error.message,
+                  stack:
+                    process.env.NODE_ENV !== 'production'
+                      ? trackedPromise._error.stack
+                      : undefined,
+                };
+                return `${JSON.stringify(
+                  key,
+                )}: _ROUTER_DATA.p(${undefined}, ${serializeJson(error)})`;
+              } else {
+                if (typeof trackedPromise._data === 'undefined') {
+                  throw new Error(
+                    `The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`,
+                  );
+                }
+                return `${JSON.stringify(key)}: _ROUTER_DATA.p(${serializeJson(
+                  trackedPromise._data,
+                )})`;
+              }
+            }
+          })
+          .join(',\n');
+
+        return `Object.assign(_ROUTER_DATA.loaderData[${JSON.stringify(
+          routeId,
+        )}], {${deferredKeyPromiseStr}});`;
+      })
+      .join('\n');
+ */
+/**
+ * Abstracting the above logic to `mergeLoaderData`:
+ *  function mergeLoaderData (routeIdJsonStr, deferredKeyPromiseManifests) {
+      const source = deferredKeyPromiseManifests.reduce(function(o, {key, routerDataFnName, routerDataFnArgs }) {
+        const args = routerDataFnArgs.map(arg => {
+          if (arg === 'undefined' || arg === null) {
+            return undefined;
+          }
+          return JSON.parse(arg);
+        });
+        return {...o, [key]: _ROUTER_DATA[routerDataFnName](...args)};
+      }, {});
+      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)}";

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.60.6-alpha.0",
+  "version": "2.61.0",
   "engines": {
     "node": ">=14.17.6"
   },
@@ -175,8 +175,8 @@
     }
   },
   "dependencies": {
-    "@babel/core": "^7.24.7",
-    "@babel/types": "^7.24.7",
+    "@babel/core": "^7.26.0",
+    "@babel/types": "^7.26.0",
     "@loadable/babel-plugin": "5.15.3",
     "@loadable/component": "5.15.3",
     "@loadable/server": "5.15.3",
@@ -199,11 +199,11 @@
     "react-is": "^18",
     "react-side-effect": "^2.1.1",
     "styled-components": "^5.3.1",
-    "@modern-js/plugin": "2.60.5",
-    "@modern-js/types": "2.60.5",
-    "@modern-js/plugin-data-loader": "2.60.5",
-    "@modern-js/runtime-utils": "2.60.5",
-    "@modern-js/utils": "2.60.5"
+    "@modern-js/plugin": "2.61.0",
+    "@modern-js/plugin-data-loader": "2.61.0",
+    "@modern-js/types": "2.61.0",
+    "@modern-js/runtime-utils": "2.61.0",
+    "@modern-js/utils": "2.61.0"
   },
   "peerDependencies": {
     "react": ">=17",
@@ -211,7 +211,7 @@
   },
   "devDependencies": {
     "@remix-run/web-fetch": "^4.1.3",
-    "@rsbuild/core": "~1.0.11",
+    "@rsbuild/core": "~1.1.0-beta.1",
     "@testing-library/react": "^13.4.0",
     "@types/cookie": "0.6.0",
     "@types/invariant": "^2.2.30",
@@ -225,11 +225,11 @@
     "react-dom": "^18.3.1",
     "ts-jest": "^29.1.0",
     "typescript": "^5",
-    "webpack": "^5.95.0",
-    "@modern-js/core": "2.60.5",
-    "@modern-js/app-tools": "2.60.5",
-    "@scripts/build": "2.60.5",
-    "@scripts/jest-config": "2.60.5"
+    "webpack": "^5.96.1",
+    "@modern-js/app-tools": "2.61.0",
+    "@modern-js/core": "2.61.0",
+    "@scripts/build": "2.61.0",
+    "@scripts/jest-config": "2.61.0"
   },
   "sideEffects": false,
   "publishConfig": {