@modern-js/runtime 1.4.4 → 1.16.0

package/dist/js/treeshaking/core/loader/loaderManager.js

@@ -0,0 +1,267 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import invariant from 'invariant';
+
+/**
+ * Calc id from string or object
+ */
+var createGetId = function createGetId() {
+  var idCache = new Map();
+  return function (objectId) {
+    var cachedId = idCache.get(objectId);
+
+    if (cachedId) {
+      return cachedId;
+    } // WARNING: id should be unique after serialize.
+
+
+    var id = JSON.stringify(objectId);
+    invariant(id, 'params should be not null value');
+    idCache.set(objectId, id);
+    return id;
+  };
+};
+
+export var LoaderStatus;
+
+(function (LoaderStatus) {
+  LoaderStatus[LoaderStatus["idle"] = 0] = "idle";
+  LoaderStatus[LoaderStatus["loading"] = 1] = "loading";
+  LoaderStatus[LoaderStatus["fulfilled"] = 2] = "fulfilled";
+  LoaderStatus[LoaderStatus["rejected"] = 3] = "rejected";
+})(LoaderStatus || (LoaderStatus = {}));
+
+var createLoader = function createLoader(id) {
+  var initialData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    loading: false,
+    reloading: false,
+    data: undefined,
+    error: undefined
+  };
+  var loaderFn = arguments.length > 2 ? arguments[2] : undefined;
+  var skip = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var promise;
+  var status = LoaderStatus.idle;
+  var data = initialData.data,
+      error = initialData.error;
+  var hasLoaded = false;
+  var handlers = new Set();
+
+  var load = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!skip) {
+                _context.next = 2;
+                break;
+              }
+
+              return _context.abrupt("return", promise);
+
+            case 2:
+              if (!(status === LoaderStatus.loading)) {
+                _context.next = 4;
+                break;
+              }
+
+              return _context.abrupt("return", promise);
+
+            case 4:
+              status = LoaderStatus.loading;
+              notify();
+              promise = loaderFn().then(function (value) {
+                data = value;
+                error = null;
+                status = LoaderStatus.fulfilled;
+              })["catch"](function (e) {
+                error = e;
+                data = null;
+                status = LoaderStatus.rejected;
+              })["finally"](function () {
+                promise = null;
+                hasLoaded = true;
+                notify();
+              });
+              return _context.abrupt("return", promise);
+
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function load() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var getResult = function getResult() {
+    return {
+      loading: !hasLoaded && status === LoaderStatus.loading,
+      reloading: hasLoaded && status === LoaderStatus.loading,
+      data: data,
+      error: error instanceof Error ? "".concat(error.message) : error,
+      // redundant fields for ssr log
+      _error: error
+    };
+  };
+
+  var notify = function notify() {
+    // don't iterate handlers directly, since it could be modified during iteration
+    _toConsumableArray(handlers).forEach(function (handler) {
+      handler(status, getResult());
+    });
+  };
+
+  var onChange = function onChange(handler) {
+    handlers.add(handler);
+    return function () {
+      handlers["delete"](handler);
+    };
+  };
+
+  return {
+    get result() {
+      return getResult();
+    },
+
+    get promise() {
+      return promise;
+    },
+
+    onChange: onChange,
+    load: load
+  };
+};
+
+/**
+ * Create loaders manager. It's returned instance will add to context
+ * @param initialDataMap used to initialing loader data
+ */
+export var createLoaderManager = function createLoaderManager(initialDataMap) {
+  var managerOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _managerOptions$skipS = managerOptions.skipStatic,
+      skipStatic = _managerOptions$skipS === void 0 ? false : _managerOptions$skipS,
+      _managerOptions$skipN = managerOptions.skipNonStatic,
+      skipNonStatic = _managerOptions$skipN === void 0 ? false : _managerOptions$skipN;
+  var loadersMap = new Map();
+  var getId = createGetId();
+
+  var add = function add(loaderFn, loaderOptions) {
+    var id = getId(loaderOptions.params);
+    var loader = loadersMap.get(id); // private property for opting out loader cache, maybe change in future
+
+    var cache = loaderOptions._cache;
+
+    if (!loader || cache === false) {
+      // ignore non-static loader on static phase
+      var ignoreNonStatic = skipNonStatic && !loaderOptions["static"]; // ignore static loader on non-static phase
+
+      var ignoreStatic = skipStatic && loaderOptions["static"];
+      var skipExec = ignoreNonStatic || ignoreStatic;
+      loader = createLoader(id, typeof initialDataMap[id] !== 'undefined' ? initialDataMap[id] : {
+        data: loaderOptions.initialData
+      }, loaderFn, // Todo whether static loader is exec when CSR
+      skipExec);
+      loadersMap.set(id, loader);
+    }
+
+    return id;
+  };
+
+  var get = function get(id) {
+    return loadersMap.get(id);
+  }; // check if there has pending loaders
+
+
+  var hasPendingLoaders = function hasPendingLoaders() {
+    var _iterator = _createForOfIteratorHelper(loadersMap.values()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var loader = _step.value;
+        var promise = loader.promise;
+
+        if (promise instanceof Promise) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return false;
+  }; // waiting for all pending loaders to be settled
+
+
+  var awaitPendingLoaders = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var pendingLoaders, _iterator2, _step2, _step2$value, id, loader, promise;
+
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              pendingLoaders = [];
+              _iterator2 = _createForOfIteratorHelper(loadersMap);
+
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  _step2$value = _slicedToArray(_step2.value, 2), id = _step2$value[0], loader = _step2$value[1];
+                  promise = loader.promise;
+
+                  if (promise instanceof Promise) {
+                    pendingLoaders.push([id, loader]);
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+
+              _context2.next = 5;
+              return Promise.all(pendingLoaders.map(function (item) {
+                return item[1].promise;
+              }));
+
+            case 5:
+              return _context2.abrupt("return", pendingLoaders.reduce(function (res, _ref3) {
+                var _ref4 = _slicedToArray(_ref3, 2),
+                    id = _ref4[0],
+                    loader = _ref4[1];
+
+                res[id] = loader.result;
+                return res;
+              }, {}));
+
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function awaitPendingLoaders() {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  return {
+    hasPendingLoaders: hasPendingLoaders,
+    awaitPendingLoaders: awaitPendingLoaders,
+    add: add,
+    get: get
+  };
+};

package/dist/js/treeshaking/core/loader/useLoader.js

@@ -0,0 +1,107 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { useContext, useRef, useMemo, useState, useCallback, useEffect } from 'react';
+import invariant from 'invariant';
+import { RuntimeReactContext } from "../runtime-context";
+import { LoaderStatus } from "./loaderManager";
+
+var useLoader = function useLoader(loaderFn) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    params: undefined
+  };
+  var context = useContext(RuntimeReactContext);
+  var isSSRRender = Boolean(context.ssr);
+  var loaderManager = context.loaderManager;
+  var loaderRef = useRef();
+  var unlistenLoaderChangeRef = useRef(null); // SSR render should ignore `_cache` prop
+
+  if (isSSRRender && Object.prototype.hasOwnProperty.call(options, '_cache')) {
+    delete options._cache;
+  }
+
+  var load = useCallback(function (params) {
+    var _unlistenLoaderChange, _window, _window$_SSR_DATA, _window$_SSR_DATA$dat, _window$_SSR_DATA$dat2, _loaderRef$current2;
+
+    if (typeof params === 'undefined') {
+      var _loaderRef$current;
+
+      return (_loaderRef$current = loaderRef.current) === null || _loaderRef$current === void 0 ? void 0 : _loaderRef$current.load();
+    }
+
+    var id = loaderManager.add(function () {
+      try {
+        var _res = loaderFn(context, params);
+
+        if (_res instanceof Promise) {
+          return _res;
+        }
+
+        return Promise.resolve(_res);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }, _objectSpread(_objectSpread({}, options), {}, {
+      params: params
+    }));
+    loaderRef.current = loaderManager.get(id); // unsubscribe old loader onChange event
+
+    (_unlistenLoaderChange = unlistenLoaderChangeRef.current) === null || _unlistenLoaderChange === void 0 ? void 0 : _unlistenLoaderChange.call(unlistenLoaderChangeRef);
+
+    if (isSSRRender) {
+      return undefined;
+    } // skip this loader, then try to unlisten loader change
+
+
+    if (options.skip) {
+      return undefined;
+    } // do not load data again in CSR hydrate stage if SSR data exists
+
+
+    if (context._hydration && ((_window = window) === null || _window === void 0 ? void 0 : (_window$_SSR_DATA = _window._SSR_DATA) === null || _window$_SSR_DATA === void 0 ? void 0 : (_window$_SSR_DATA$dat = _window$_SSR_DATA.data) === null || _window$_SSR_DATA$dat === void 0 ? void 0 : (_window$_SSR_DATA$dat2 = _window$_SSR_DATA$dat.loadersData[id]) === null || _window$_SSR_DATA$dat2 === void 0 ? void 0 : _window$_SSR_DATA$dat2.error) === null) {
+      return undefined;
+    }
+
+    var res = loaderRef.current.load();
+    unlistenLoaderChangeRef.current = (_loaderRef$current2 = loaderRef.current) === null || _loaderRef$current2 === void 0 ? void 0 : _loaderRef$current2.onChange(function (_status, _result) {
+      setResult(_result);
+
+      if (_status === LoaderStatus.fulfilled) {
+        var _options$onSuccess;
+
+        options === null || options === void 0 ? void 0 : (_options$onSuccess = options.onSuccess) === null || _options$onSuccess === void 0 ? void 0 : _options$onSuccess.call(options, _result.data);
+      }
+
+      if (_status === LoaderStatus.rejected) {
+        var _options$onError;
+
+        options === null || options === void 0 ? void 0 : (_options$onError = options.onError) === null || _options$onError === void 0 ? void 0 : _options$onError.call(options, _result.error);
+      }
+    });
+    return res;
+  }, [options.skip]);
+  useEffect(function () {
+    return function () {
+      var _unlistenLoaderChange2;
+
+      (_unlistenLoaderChange2 = unlistenLoaderChangeRef.current) === null || _unlistenLoaderChange2 === void 0 ? void 0 : _unlistenLoaderChange2.call(unlistenLoaderChangeRef);
+    };
+  }, []);
+  useMemo(function () {
+    var _options$params;
+
+    var p = (_options$params = options.params) !== null && _options$params !== void 0 ? _options$params : loaderFn.id;
+    invariant(typeof p !== 'undefined' && p !== null, 'Params is required in useLoader');
+    load(p);
+  }, [options.params]);
+
+  var _useState = useState(loaderRef.current.result),
+      _useState2 = _slicedToArray(_useState, 2),
+      result = _useState2[0],
+      setResult = _useState2[1];
+
+  return _objectSpread(_objectSpread({}, result), {}, {
+    reload: load
+  });
+};
+
+export default useLoader;

package/dist/js/treeshaking/core/plugin.js

@@ -0,0 +1,105 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createManager, createPipeline, createAsyncPipeline } from '@modern-js/plugin';
+import { createLoaderManager } from "./loader/loaderManager";
+var hoc = createPipeline(); // eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+var provide = createPipeline();
+var client = createAsyncPipeline();
+var server = createAsyncPipeline();
+var init = createAsyncPipeline();
+var pickContext = createPipeline();
+var runtimeHooks = {
+  hoc: hoc,
+  provide: provide,
+  client: client,
+  server: server,
+  init: init,
+  pickContext: pickContext
+};
+/** All hooks of runtime plugin. */
+
+export var createRuntime = function createRuntime() {
+  return createManager(runtimeHooks);
+};
+/**
+ * register init hook. It would be revoked both ssr and csr.
+ */
+
+var registerInit = function registerInit(App, _init) {
+  var originalInit = App.init;
+
+  App.init = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!context.loaderManager) {
+                context.loaderManager = createLoaderManager({});
+              }
+
+              _context.next = 3;
+              return Promise.all([originalInit === null || originalInit === void 0 ? void 0 : originalInit(context), _init === null || _init === void 0 ? void 0 : _init(context)]);
+
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+/**
+ * register prefetch hook. It would be revoked both ssr and csr.
+ * But if ssr success, It wont exec in csr again.
+ * If ssr prefetch failed, It will fallback to exec in csr.
+ */
+
+
+var registerPrefetch = function registerPrefetch(App, prefetch) {
+  var originalPrefetch = App.prefetch;
+
+  App.prefetch = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+      var originResult, result;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return originalPrefetch === null || originalPrefetch === void 0 ? void 0 : originalPrefetch(context);
+
+            case 2:
+              originResult = _context2.sent;
+              _context2.next = 5;
+              return prefetch === null || prefetch === void 0 ? void 0 : prefetch(context);
+
+            case 5:
+              result = _context2.sent;
+              return _context2.abrupt("return", _objectSpread(_objectSpread({}, originResult), result));
+
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};
+
+export var runtime = createRuntime();
+var createPlugin = runtime.createPlugin;
+export { createPlugin };
+export { registerInit, registerPrefetch };

package/dist/js/treeshaking/core/runtime-context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export var RuntimeReactContext = /*#__PURE__*/createContext({});

package/dist/js/treeshaking/exports/styled.js

@@ -1,3 +1,3 @@
-import styled from '@modern-js/runtime-core/styled';
+import styled from 'styled-components';
 export default styled;
-export * from '@modern-js/runtime-core/styled';
+export * from 'styled-components';

package/dist/js/treeshaking/index.js

@@ -1 +1 @@
-export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, registerPrefetch, defineConfig, registerInit, useRuntimeContext } from '@modern-js/runtime-core';
+export { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, registerPrefetch, defineConfig, registerInit, useRuntimeContext } from "./core";

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

@@ -2,8 +2,8 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import React, { useContext } from 'react';
 import { createBrowserHistory, createHashHistory } from 'history';
 import { Router, StaticRouter } from 'react-router-dom';
-import { RuntimeReactContext } from '@modern-js/runtime-core';
 import hoistNonReactStatics from 'hoist-non-react-statics';
+import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
 import { renderRoutes, getLocation, urlJoin } from "./utils";
 import { jsx as _jsx } from "react/jsx-runtime";

package/dist/js/treeshaking/router/runtime/utils.js

@@ -60,11 +60,13 @@ export function renderRoutes(routesConfig) {
   });
 }
 export function getLocation(serverContext) {
+  var _url$replace;
+
   var _ref2 = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {},
       pathname = _ref2.pathname,
       url = _ref2.url;
 
-  var cleanUrl = url.replace('http://', '').replace('https://', '');
+  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) {

package/dist/js/treeshaking/ssr/index.js

@@ -1,11 +1,13 @@
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import ReactDOM from 'react-dom';
 import { loadableReady } from '@loadable/component';
+import hoistNonReactStatics from 'hoist-non-react-statics';
 import { RenderLevel } from "./serverRender/type";
+import { WithCallback } from "./react/withCallback";
 import { formatClient, mockResponse } from "./utils";
 import { jsx as _jsx } from "react/jsx-runtime";
+var IS_REACT18 = process.env.IS_REACT18 === 'true';
 
 var ssr = function ssr() {
   return {
@@ -17,52 +19,58 @@ var ssr = function ssr() {
           var _client = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
             var _window, _window$_SSR_DATA;
 
-            var App, context, rootElement, renderLevel, _prefetch, _ref2;
-
+            var App, context, ModernRender, ModernHydrate, renderLevel;
             return _regeneratorRuntime().wrap(function _callee$(_context) {
               while (1) {
                 switch (_context.prev = _context.next) {
                   case 0:
-                    App = _ref.App, context = _ref.context, rootElement = _ref.rootElement;
+                    App = _ref.App, context = _ref.context, ModernRender = _ref.ModernRender, ModernHydrate = _ref.ModernHydrate;
                     renderLevel = (_window = window) === null || _window === void 0 ? void 0 : (_window$_SSR_DATA = _window._SSR_DATA) === null || _window$_SSR_DATA === void 0 ? void 0 : _window$_SSR_DATA.renderLevel;
 
-                    if (!(renderLevel === RenderLevel.CLIENT_RENDER)) {
-                      _context.next = 8;
-                      break;
-                    }
-
-                    _context.next = 5;
-                    return App === null || App === void 0 ? void 0 : (_prefetch = (_ref2 = App).prefetch) === null || _prefetch === void 0 ? void 0 : _prefetch.call(_ref2, context);
-
-                  case 5:
-                    ReactDOM.render( /*#__PURE__*/_jsx(App, {
-                      context: context
-                    }), rootElement);
-                    _context.next = 9;
-                    break;
-
-                  case 8:
-                    if (renderLevel === RenderLevel.SERVER_RENDER) {
+                    if (renderLevel === RenderLevel.CLIENT_RENDER) {
+                      // prefetch block render while csr
+                      //   await (App as any)?.prefetch?.(context);
+                      ModernRender( /*#__PURE__*/_jsx(App, {
+                        context: context
+                      }));
+                    } else if (renderLevel === RenderLevel.SERVER_RENDER) {
                       loadableReady(function () {
                         var hydrateContext = _objectSpread(_objectSpread({}, context), {}, {
                           _hydration: true
                         });
 
-                        ReactDOM.hydrate( /*#__PURE__*/_jsx(App, {
-                          context: hydrateContext
-                        }), rootElement, function () {
+                        var callback = function callback() {
                           // won't cause component re-render because context's reference identity doesn't change
                           delete hydrateContext._hydration;
-                        });
+                        }; // callback: https://github.com/reactwg/react-18/discussions/5
+
+
+                        if (IS_REACT18) {
+                          var SSRApp = function SSRApp() {
+                            return /*#__PURE__*/_jsx(WithCallback, {
+                              callback: callback,
+                              children: /*#__PURE__*/_jsx(App, {
+                                context: hydrateContext
+                              })
+                            });
+                          };
+
+                          SSRApp = hoistNonReactStatics(SSRApp, App);
+                          ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
+                        } else {
+                          ModernHydrate( /*#__PURE__*/_jsx(App, {
+                            context: hydrateContext
+                          }), callback);
+                        }
                       });
                     } else {
                       // unknown renderlevel or renderlevel is server prefetch.
-                      ReactDOM.render( /*#__PURE__*/_jsx(App, {
+                      ModernHydrate( /*#__PURE__*/_jsx(App, {
                         context: context
-                      }), rootElement);
+                      }));
                     }
 
-                  case 9:
+                  case 3:
                   case "end":
                     return _context.stop();
                 }
@@ -76,13 +84,17 @@ var ssr = function ssr() {
 
           return client;
         }(),
-        init: function init(_ref3, next) {
+        init: function init(_ref2, next) {
           var _window2, _window2$_SSR_DATA, _window2$_SSR_DATA$co;
 
-          var context = _ref3.context;
+          var context = _ref2.context;
           var request = (_window2 = window) === null || _window2 === void 0 ? void 0 : (_window2$_SSR_DATA = _window2._SSR_DATA) === null || _window2$_SSR_DATA === void 0 ? void 0 : (_window2$_SSR_DATA$co = _window2$_SSR_DATA.context) === null || _window2$_SSR_DATA$co === void 0 ? void 0 : _window2$_SSR_DATA$co.request;
 
           if (!request) {
+            context.ssrContext = _objectSpread(_objectSpread({}, context.ssrContext), {}, {
+              response: mockResp,
+              request: formatClient({})
+            });
             return next({
               context: context
             });
@@ -94,11 +106,11 @@ var ssr = function ssr() {
             context: context
           });
         },
-        pickContext: function pickContext(_ref4, next) {
+        pickContext: function pickContext(_ref3, next) {
           var _window3, _window3$_SSR_DATA, _window3$_SSR_DATA$co;
 
-          var context = _ref4.context,
-              pickedContext = _ref4.pickedContext;
+          var context = _ref3.context,
+              pickedContext = _ref3.pickedContext;
           var request = (_window3 = window) === null || _window3 === void 0 ? void 0 : (_window3$_SSR_DATA = _window3._SSR_DATA) === null || _window3$_SSR_DATA === void 0 ? void 0 : (_window3$_SSR_DATA$co = _window3$_SSR_DATA.context) === null || _window3$_SSR_DATA$co === void 0 ? void 0 : _window3$_SSR_DATA$co.request;
           var initialData = context.initialData;
 

package/dist/js/treeshaking/ssr/index.node.js

@@ -6,7 +6,7 @@ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 
 /* eslint-disable @typescript-eslint/no-require-imports */
 import path from 'path';
-import { registerPrefetch } from '@modern-js/runtime-core';
+import { registerPrefetch } from "../core";
 import { isBrowser } from "../common";
 import prefetch from "./prefetch";
 import { formatServer } from "./utils";

package/dist/js/treeshaking/ssr/prefetch.js

@@ -5,10 +5,10 @@ import fs from 'fs';
 import { renderToStaticMarkup } from 'react-dom/server';
 import { run } from '@modern-js/utils/ssr';
 import { LOADABLE_STATS_FILE } from '@modern-js/utils/constants';
-import { ChunkExtractor } from '@loadable/server'; // todo: SSRContext
-
+import { ChunkExtractor } from '@loadable/server';
 import { jsx as _jsx } from "react/jsx-runtime";
 
+// todo: SSRContext
 var prefetch = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(App, context) {
     return _regeneratorRuntime().wrap(function _callee2$(_context2) {