@modern-js/runtime 1.4.3 → 1.15.0

package/dist/js/treeshaking/core/app-config.js

@@ -0,0 +1,13 @@
+var APP_CONFIG_SYMBOL = 'config';
+export var getConfig = function getConfig(Component) {
+  return (// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    Component[APP_CONFIG_SYMBOL]
+  );
+};
+export var defineConfig = function defineConfig(Component, config) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  Component[APP_CONFIG_SYMBOL] = config;
+  return Component;
+};

package/dist/js/treeshaking/core/compatible.js

@@ -0,0 +1,255 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+var _excluded = ["context"];
+import React, { useContext, useMemo } from 'react';
+import ReactDOM from 'react-dom';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import { runtime } from "./plugin";
+import { RuntimeReactContext } from "./runtime-context";
+import { createLoaderManager } from "./loader/loaderManager";
+import { jsx as _jsx } from "react/jsx-runtime";
+
+function isClientArgs(id) {
+  return typeof id === 'string' || typeof HTMLElement !== 'undefined' && id instanceof HTMLElement;
+}
+
+var runnerMap = new WeakMap();
+
+var getInitialContext = function getInitialContext(runner) {
+  return {
+    loaderManager: createLoaderManager({}),
+    runner: runner,
+    isBrowser: true
+  };
+};
+
+export var createApp = function createApp(_ref) {
+  var plugins = _ref.plugins;
+  var appRuntime = runtime.clone();
+  appRuntime.usePlugin.apply(appRuntime, _toConsumableArray(plugins));
+  return function (App) {
+    var runner = appRuntime.init();
+
+    var WrapperComponent = function WrapperComponent(props) {
+      var element = /*#__PURE__*/React.createElement(App || React.Fragment, _objectSpread({}, props), props.children);
+      var context = useContext(RuntimeReactContext);
+      return runner.provide({
+        element: element,
+        props: _objectSpread({}, props),
+        context: context
+      }, {
+        onLast: function onLast(_ref2) {
+          var element = _ref2.element;
+          return element;
+        }
+      });
+    };
+
+    if (App) {
+      hoistNonReactStatics(WrapperComponent, App);
+    }
+
+    var HOCApp = runner.hoc({
+      App: WrapperComponent
+    }, {
+      onLast: function onLast(_ref3) {
+        var App = _ref3.App;
+
+        var WrapComponent = function WrapComponent(_ref4) {
+          var _contextValue;
+
+          var context = _ref4.context,
+              props = _objectWithoutProperties(_ref4, _excluded);
+
+          var contextValue = context; // We should construct the context, when root component is not passed into `bootstrap`.
+
+          if (!((_contextValue = contextValue) !== null && _contextValue !== void 0 && _contextValue.runner)) {
+            contextValue = getInitialContext(runner);
+            runner.init({
+              context: contextValue
+            }, {
+              onLast: function onLast(_ref5) {
+                var _App$init;
+
+                var context1 = _ref5.context;
+                return App === null || App === void 0 ? void 0 : (_App$init = App.init) === null || _App$init === void 0 ? void 0 : _App$init.call(App, context1);
+              }
+            });
+          }
+
+          return /*#__PURE__*/_jsx(RuntimeReactContext.Provider, {
+            value: contextValue,
+            children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
+          });
+        };
+
+        return hoistNonReactStatics(WrapComponent, App);
+      }
+    });
+    runnerMap.set(HOCApp, runner);
+    return HOCApp;
+  };
+};
+export var bootstrap = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(BootApp,
+  /**
+   * When csr, id is root id.
+   * When ssr, id is serverContext
+   */
+  id) {
+    var App, runner, context, runInit, isBrowser, _ssrData$data, _ssrData$data2, ssrData, loadersData, initialLoadersState, initialData, _initialData;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            App = BootApp;
+            runner = runnerMap.get(App); // ensure Component used is created by `createApp`
+
+            if (!runner) {
+              App = createApp({
+                plugins: []
+              })(App);
+              runner = runnerMap.get(App);
+            }
+
+            context = getInitialContext(runner);
+
+            runInit = function runInit(_context) {
+              return runner.init({
+                context: _context
+              }, {
+                onLast: function onLast(_ref7) {
+                  var _App, _App$init2;
+
+                  var context1 = _ref7.context;
+                  return (_App = App) === null || _App === void 0 ? void 0 : (_App$init2 = _App.init) === null || _App$init2 === void 0 ? void 0 : _App$init2.call(_App, context1);
+                }
+              });
+            }; // don't mount the App, let user in charge of it.
+
+
+            if (id) {
+              _context2.next = 7;
+              break;
+            }
+
+            return _context2.abrupt("return", /*#__PURE__*/React.createElement(App, {
+              context: context
+            }));
+
+          case 7:
+            isBrowser = typeof window !== 'undefined' && window.name !== 'nodejs';
+
+            if (!isBrowser) {
+              _context2.next = 25;
+              break;
+            }
+
+            if (!isClientArgs(id)) {
+              _context2.next = 22;
+              break;
+            }
+
+            ssrData = window._SSR_DATA;
+            loadersData = (ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data = ssrData.data) === null || _ssrData$data === void 0 ? void 0 : _ssrData$data.loadersData) || {};
+            initialLoadersState = Object.keys(loadersData).reduce(function (res, key) {
+              var loaderData = loadersData[key];
+
+              if (loaderData.loading !== false) {
+                return res;
+              }
+
+              res[key] = loaderData;
+              return res;
+            }, {});
+            Object.assign(context, _objectSpread({
+              loaderManager: createLoaderManager(initialLoadersState, {
+                skipStatic: true
+              })
+            }, ssrData ? {
+              ssrContext: ssrData === null || ssrData === void 0 ? void 0 : ssrData.context
+            } : {}));
+            context.initialData = ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data2 = ssrData.data) === null || _ssrData$data2 === void 0 ? void 0 : _ssrData$data2.initialData;
+            _context2.next = 17;
+            return runInit(context);
+
+          case 17:
+            initialData = _context2.sent;
+
+            if (initialData) {
+              context.initialData = initialData;
+            }
+
+            return _context2.abrupt("return", runner.client({
+              App: App,
+              context: context,
+              rootElement: typeof id !== 'string' ? id : document.getElementById(id || 'root')
+            }, {
+              onLast: function onLast(_ref8) {
+                var App = _ref8.App,
+                    rootElement = _ref8.rootElement;
+                ReactDOM.render( /*#__PURE__*/React.createElement(App, {
+                  context: context
+                }), rootElement);
+              }
+            }));
+
+          case 22:
+            throw Error('`bootstrap` needs id in browser environment, it needs to be string or element');
+
+          case 23:
+            _context2.next = 31;
+            break;
+
+          case 25:
+            Object.assign(context, {
+              ssrContext: id,
+              isBrowser: false,
+              loaderManager: createLoaderManager({}, {
+                skipNonStatic: id.staticGenerate,
+                // if not static generate, only non-static loader can exec on prod env
+                skipStatic: process.env.NODE_ENV === 'production' && !id.staticGenerate
+              })
+            });
+            _context2.next = 28;
+            return runInit(context);
+
+          case 28:
+            _initialData = _context2.sent;
+            context.initialData = _initialData;
+            return _context2.abrupt("return", runner.server({
+              App: App,
+              context: context
+            }));
+
+          case 31:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function bootstrap(_x, _x2) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+export var useRuntimeContext = function useRuntimeContext() {
+  var context = useContext(RuntimeReactContext);
+  var memoizedContext = useMemo(function () {
+    return context.runner.pickContext({
+      context: context,
+      pickedContext: {}
+    }, {
+      onLast: function onLast(_ref9) {
+        var pickedContext = _ref9.pickedContext;
+        return pickedContext;
+      }
+    });
+  }, [context]);
+  return memoizedContext;
+};

package/dist/js/treeshaking/core/index.js

@@ -0,0 +1,7 @@
+export { createPlugin, createRuntime, runtime, registerInit, registerPrefetch } from "./plugin";
+export { defineConfig, getConfig } from "./app-config";
+// compatible
+export * from "./compatible";
+export { RuntimeReactContext } from "./runtime-context";
+export * from "./loader";
+export * from '@modern-js/plugin';

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

@@ -0,0 +1 @@
+export { default as useLoader } from "./useLoader";

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;