@modern-js/runtime 1.4.4 → 1.16.0

package/dist/js/node/core/index.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createPlugin: true,
+  createRuntime: true,
+  runtime: true,
+  registerInit: true,
+  registerPrefetch: true,
+  defineConfig: true,
+  getConfig: true,
+  RuntimeReactContext: true
+};
+Object.defineProperty(exports, "RuntimeReactContext", {
+  enumerable: true,
+  get: function () {
+    return _runtimeContext.RuntimeReactContext;
+  }
+});
+Object.defineProperty(exports, "createPlugin", {
+  enumerable: true,
+  get: function () {
+    return _plugin.createPlugin;
+  }
+});
+Object.defineProperty(exports, "createRuntime", {
+  enumerable: true,
+  get: function () {
+    return _plugin.createRuntime;
+  }
+});
+Object.defineProperty(exports, "defineConfig", {
+  enumerable: true,
+  get: function () {
+    return _appConfig.defineConfig;
+  }
+});
+Object.defineProperty(exports, "getConfig", {
+  enumerable: true,
+  get: function () {
+    return _appConfig.getConfig;
+  }
+});
+Object.defineProperty(exports, "registerInit", {
+  enumerable: true,
+  get: function () {
+    return _plugin.registerInit;
+  }
+});
+Object.defineProperty(exports, "registerPrefetch", {
+  enumerable: true,
+  get: function () {
+    return _plugin.registerPrefetch;
+  }
+});
+Object.defineProperty(exports, "runtime", {
+  enumerable: true,
+  get: function () {
+    return _plugin.runtime;
+  }
+});
+
+var _plugin = require("./plugin");
+
+var _appConfig = require("./app-config");
+
+var _compatible = require("./compatible");
+
+Object.keys(_compatible).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _compatible[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _compatible[key];
+    }
+  });
+});
+
+var _runtimeContext = require("./runtime-context");
+
+var _loader = require("./loader");
+
+Object.keys(_loader).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _loader[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _loader[key];
+    }
+  });
+});
+
+var _plugin2 = require("@modern-js/plugin");
+
+Object.keys(_plugin2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _plugin2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _plugin2[key];
+    }
+  });
+});

package/dist/js/node/core/loader/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useLoader", {
+  enumerable: true,
+  get: function () {
+    return _useLoader.default;
+  }
+});
+
+var _useLoader = _interopRequireDefault(require("./useLoader"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLoaderManager = exports.LoaderStatus = void 0;
+
+var _invariant = _interopRequireDefault(require("invariant"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Calc id from string or object
+ */
+const createGetId = () => {
+  const idCache = new Map();
+  return objectId => {
+    const cachedId = idCache.get(objectId);
+
+    if (cachedId) {
+      return cachedId;
+    } // WARNING: id should be unique after serialize.
+
+
+    const id = JSON.stringify(objectId);
+    (0, _invariant.default)(id, 'params should be not null value');
+    idCache.set(objectId, id);
+    return id;
+  };
+};
+
+let LoaderStatus;
+exports.LoaderStatus = LoaderStatus;
+
+(function (LoaderStatus) {
+  LoaderStatus[LoaderStatus["idle"] = 0] = "idle";
+  LoaderStatus[LoaderStatus["loading"] = 1] = "loading";
+  LoaderStatus[LoaderStatus["fulfilled"] = 2] = "fulfilled";
+  LoaderStatus[LoaderStatus["rejected"] = 3] = "rejected";
+})(LoaderStatus || (exports.LoaderStatus = LoaderStatus = {}));
+
+const createLoader = (id, initialData = {
+  loading: false,
+  reloading: false,
+  data: undefined,
+  error: undefined
+}, loaderFn, skip = false) => {
+  let promise;
+  let status = LoaderStatus.idle;
+  let {
+    data,
+    error
+  } = initialData;
+  let hasLoaded = false;
+  const handlers = new Set();
+
+  const load = async () => {
+    if (skip) {
+      return promise;
+    }
+
+    if (status === LoaderStatus.loading) {
+      return promise;
+    }
+
+    status = LoaderStatus.loading;
+    notify();
+    promise = loaderFn().then(value => {
+      data = value;
+      error = null;
+      status = LoaderStatus.fulfilled;
+    }).catch(e => {
+      error = e;
+      data = null;
+      status = LoaderStatus.rejected;
+    }).finally(() => {
+      promise = null;
+      hasLoaded = true;
+      notify();
+    });
+    return promise;
+  };
+
+  const getResult = () => ({
+    loading: !hasLoaded && status === LoaderStatus.loading,
+    reloading: hasLoaded && status === LoaderStatus.loading,
+    data,
+    error: error instanceof Error ? `${error.message}` : error,
+    // redundant fields for ssr log
+    _error: error
+  });
+
+  const notify = () => {
+    // don't iterate handlers directly, since it could be modified during iteration
+    [...handlers].forEach(handler => {
+      handler(status, getResult());
+    });
+  };
+
+  const onChange = handler => {
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  };
+
+  return {
+    get result() {
+      return getResult();
+    },
+
+    get promise() {
+      return promise;
+    },
+
+    onChange,
+    load
+  };
+};
+
+/**
+ * Create loaders manager. It's returned instance will add to context
+ * @param initialDataMap used to initialing loader data
+ */
+const createLoaderManager = (initialDataMap, managerOptions = {}) => {
+  const {
+    skipStatic = false,
+    skipNonStatic = false
+  } = managerOptions;
+  const loadersMap = new Map();
+  const getId = createGetId();
+
+  const add = (loaderFn, loaderOptions) => {
+    const id = getId(loaderOptions.params);
+    let loader = loadersMap.get(id); // private property for opting out loader cache, maybe change in future
+
+    const cache = loaderOptions._cache;
+
+    if (!loader || cache === false) {
+      // ignore non-static loader on static phase
+      const ignoreNonStatic = skipNonStatic && !loaderOptions.static; // ignore static loader on non-static phase
+
+      const ignoreStatic = skipStatic && loaderOptions.static;
+      const 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;
+  };
+
+  const get = id => loadersMap.get(id); // check if there has pending loaders
+
+
+  const hasPendingLoaders = () => {
+    for (const loader of loadersMap.values()) {
+      const {
+        promise
+      } = loader;
+
+      if (promise instanceof Promise) {
+        return true;
+      }
+    }
+
+    return false;
+  }; // waiting for all pending loaders to be settled
+
+
+  const awaitPendingLoaders = async () => {
+    const pendingLoaders = [];
+
+    for (const [id, loader] of loadersMap) {
+      const {
+        promise
+      } = loader;
+
+      if (promise instanceof Promise) {
+        pendingLoaders.push([id, loader]);
+      }
+    }
+
+    await Promise.all(pendingLoaders.map(item => item[1].promise));
+    return pendingLoaders.reduce((res, [id, loader]) => {
+      res[id] = loader.result;
+      return res;
+    }, {});
+  };
+
+  return {
+    hasPendingLoaders,
+    awaitPendingLoaders,
+    add,
+    get
+  };
+};
+
+exports.createLoaderManager = createLoaderManager;

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

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = require("react");
+
+var _invariant = _interopRequireDefault(require("invariant"));
+
+var _runtimeContext = require("../runtime-context");
+
+var _loaderManager = require("./loaderManager");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const useLoader = (loaderFn, options = {
+  params: undefined
+}) => {
+  const context = (0, _react.useContext)(_runtimeContext.RuntimeReactContext);
+  const isSSRRender = Boolean(context.ssr);
+  const {
+    loaderManager
+  } = context;
+  const loaderRef = (0, _react.useRef)();
+  const unlistenLoaderChangeRef = (0, _react.useRef)(null); // SSR render should ignore `_cache` prop
+
+  if (isSSRRender && Object.prototype.hasOwnProperty.call(options, '_cache')) {
+    delete options._cache;
+  }
+
+  const load = (0, _react.useCallback)(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();
+    }
+
+    const id = loaderManager.add(() => {
+      try {
+        const res = loaderFn(context, params);
+
+        if (res instanceof Promise) {
+          return res;
+        }
+
+        return Promise.resolve(res);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }, _objectSpread(_objectSpread({}, options), {}, {
+      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;
+    }
+
+    const res = loaderRef.current.load();
+    unlistenLoaderChangeRef.current = (_loaderRef$current2 = loaderRef.current) === null || _loaderRef$current2 === void 0 ? void 0 : _loaderRef$current2.onChange((_status, _result) => {
+      setResult(_result);
+
+      if (_status === _loaderManager.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 === _loaderManager.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]);
+  (0, _react.useEffect)(() => () => {
+    var _unlistenLoaderChange2;
+
+    (_unlistenLoaderChange2 = unlistenLoaderChangeRef.current) === null || _unlistenLoaderChange2 === void 0 ? void 0 : _unlistenLoaderChange2.call(unlistenLoaderChangeRef);
+  }, []);
+  (0, _react.useMemo)(() => {
+    var _options$params;
+
+    const p = (_options$params = options.params) !== null && _options$params !== void 0 ? _options$params : loaderFn.id;
+    (0, _invariant.default)(typeof p !== 'undefined' && p !== null, 'Params is required in useLoader');
+    load(p);
+  }, [options.params]);
+  const [result, setResult] = (0, _react.useState)(loaderRef.current.result);
+  return _objectSpread(_objectSpread({}, result), {}, {
+    reload: load
+  });
+};
+
+var _default = useLoader;
+exports.default = _default;

package/dist/js/node/core/plugin.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runtime = exports.registerPrefetch = exports.registerInit = exports.createRuntime = exports.createPlugin = void 0;
+
+var _plugin = require("@modern-js/plugin");
+
+var _loaderManager = require("./loader/loaderManager");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const hoc = (0, _plugin.createPipeline)(); // eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+const provide = (0, _plugin.createPipeline)();
+const client = (0, _plugin.createAsyncPipeline)();
+const server = (0, _plugin.createAsyncPipeline)();
+const init = (0, _plugin.createAsyncPipeline)();
+const pickContext = (0, _plugin.createPipeline)();
+const runtimeHooks = {
+  hoc,
+  provide,
+  client,
+  server,
+  init,
+  pickContext
+};
+/** All hooks of runtime plugin. */
+
+const createRuntime = () => (0, _plugin.createManager)(runtimeHooks);
+/**
+ * register init hook. It would be revoked both ssr and csr.
+ */
+
+
+exports.createRuntime = createRuntime;
+
+const registerInit = (App, _init) => {
+  const originalInit = App.init;
+
+  App.init = async context => {
+    if (!context.loaderManager) {
+      context.loaderManager = (0, _loaderManager.createLoaderManager)({});
+    }
+
+    await Promise.all([originalInit === null || originalInit === void 0 ? void 0 : originalInit(context), _init === null || _init === void 0 ? void 0 : _init(context)]);
+  };
+};
+/**
+ * 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.
+ */
+
+
+exports.registerInit = registerInit;
+
+const registerPrefetch = (App, prefetch) => {
+  const originalPrefetch = App.prefetch;
+
+  App.prefetch = async context => {
+    const originResult = await (originalPrefetch === null || originalPrefetch === void 0 ? void 0 : originalPrefetch(context));
+    const result = await (prefetch === null || prefetch === void 0 ? void 0 : prefetch(context));
+    return _objectSpread(_objectSpread({}, originResult), result);
+  };
+};
+
+exports.registerPrefetch = registerPrefetch;
+const runtime = createRuntime();
+exports.runtime = runtime;
+const {
+  createPlugin
+} = runtime;
+exports.createPlugin = createPlugin;

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RuntimeReactContext = void 0;
+
+var _react = require("react");
+
+const RuntimeReactContext = /*#__PURE__*/(0, _react.createContext)({});
+exports.RuntimeReactContext = RuntimeReactContext;

package/dist/js/node/exports/styled.js

@@ -6,16 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 var _exportNames = {};
 exports.default = void 0;
 
-var _styled = _interopRequireWildcard(require("@modern-js/runtime-core/styled"));
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
 
-Object.keys(_styled).forEach(function (key) {
+Object.keys(_styledComponents).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _styled[key]) return;
+  if (key in exports && exports[key] === _styledComponents[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _styled[key];
+      return _styledComponents[key];
     }
   });
 });
@@ -24,5 +24,5 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-var _default = _styled.default;
+var _default = _styledComponents.default;
 exports.default = _default;

package/dist/js/node/index.js

@@ -6,56 +6,56 @@ Object.defineProperty(exports, "__esModule", {
 Object.defineProperty(exports, "RuntimeReactContext", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.RuntimeReactContext;
+    return _core.RuntimeReactContext;
   }
 });
 Object.defineProperty(exports, "bootstrap", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.bootstrap;
+    return _core.bootstrap;
   }
 });
 Object.defineProperty(exports, "createApp", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.createApp;
+    return _core.createApp;
   }
 });
 Object.defineProperty(exports, "createPlugin", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.createPlugin;
+    return _core.createPlugin;
   }
 });
 Object.defineProperty(exports, "defineConfig", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.defineConfig;
+    return _core.defineConfig;
   }
 });
 Object.defineProperty(exports, "registerInit", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.registerInit;
+    return _core.registerInit;
   }
 });
 Object.defineProperty(exports, "registerPrefetch", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.registerPrefetch;
+    return _core.registerPrefetch;
   }
 });
 Object.defineProperty(exports, "useLoader", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.useLoader;
+    return _core.useLoader;
   }
 });
 Object.defineProperty(exports, "useRuntimeContext", {
   enumerable: true,
   get: function () {
-    return _runtimeCore.useRuntimeContext;
+    return _core.useRuntimeContext;
   }
 });
 
-var _runtimeCore = require("@modern-js/runtime-core");
+var _core = require("./core");

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

@@ -11,10 +11,10 @@ var _history = require("history");
 
 var _reactRouterDom = require("react-router-dom");
 
-var _runtimeCore = require("@modern-js/runtime-core");
-
 var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));
 
+var _core = require("../../core");
+
 var _common = require("../../common");
 
 var _utils = require("./utils");
@@ -67,7 +67,7 @@ const routerPlugin = ({
             }
 
             return props => {
-              const runtimeContext = (0, _react.useContext)(_runtimeCore.RuntimeReactContext);
+              const runtimeContext = (0, _react.useContext)(_core.RuntimeReactContext);
               const {
                 ssrContext
               } = runtimeContext;

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

@@ -83,11 +83,13 @@ function renderRoutes(routesConfig, extraProps = {}) {
 }
 
 function getLocation(serverContext) {
+  var _url$replace;
+
   const {
     pathname,
     url
   } = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {};
-  const cleanUrl = url.replace('http://', '').replace('https://', '');
+  const cleanUrl = url === null || url === void 0 ? void 0 : (_url$replace = url.replace('http://', '')) === null || _url$replace === void 0 ? void 0 : _url$replace.replace('https://', '');
   const index = (cleanUrl || '').indexOf(pathname);
 
   if (index === -1) {