@modern-js/runtime 2.0.0-canary.0 → 2.0.0

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

@@ -1,13 +1,33 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "useLoader", {
-  enumerable: true,
-  get: function () {
-    return _useLoader.default;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  useLoader: () => import_useLoader.default
+});
+module.exports = __toCommonJS(loader_exports);
+var import_useLoader = __toESM(require("./useLoader"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLoader
 });
-var _useLoader = _interopRequireDefault(require("./useLoader"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

@@ -1,90 +1,121 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var loaderManager_exports = {};
+__export(loaderManager_exports, {
+  LoaderStatus: () => LoaderStatus,
+  createLoaderManager: () => createLoaderManager
 });
-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
- */
+module.exports = __toCommonJS(loaderManager_exports);
+var import_invariant = __toESM(require("invariant"));
 const createGetId = () => {
-  const idCache = new Map();
-  return objectId => {
+  const idCache = /* @__PURE__ */ 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');
+    (0, import_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 = {}));
+var LoaderStatus = /* @__PURE__ */ ((LoaderStatus2) => {
+  LoaderStatus2[LoaderStatus2["idle"] = 0] = "idle";
+  LoaderStatus2[LoaderStatus2["loading"] = 1] = "loading";
+  LoaderStatus2[LoaderStatus2["fulfilled"] = 2] = "fulfilled";
+  LoaderStatus2[LoaderStatus2["rejected"] = 3] = "rejected";
+  return LoaderStatus2;
+})(LoaderStatus || {});
 const createLoader = (id, initialData = {
   loading: false,
   reloading: false,
-  data: undefined,
-  error: undefined
+  data: void 0,
+  error: void 0
 }, loaderFn, skip = false) => {
   let promise;
-  let status = LoaderStatus.idle;
-  let {
-    data,
-    error
-  } = initialData;
+  let status = 0 /* idle */;
+  let { data, error } = initialData;
   let hasLoaded = false;
-  const handlers = new Set();
-  const load = async () => {
+  const handlers = /* @__PURE__ */ new Set();
+  const load = () => __async(void 0, null, function* () {
     if (skip) {
       return promise;
     }
-    if (status === LoaderStatus.loading) {
+    if (status === 1 /* loading */) {
       return promise;
     }
-    status = LoaderStatus.loading;
+    status = 1 /* loading */;
     notify();
-    promise = loaderFn().then(value => {
+    promise = loaderFn().then((value) => {
       data = value;
       error = null;
-      status = LoaderStatus.fulfilled;
-    }).catch(e => {
+      status = 2 /* fulfilled */;
+    }).catch((e) => {
       error = e;
       data = null;
-      status = LoaderStatus.rejected;
+      status = 3 /* rejected */;
     }).finally(() => {
       promise = null;
       hasLoaded = true;
       notify();
     });
     return promise;
-  };
+  });
   const getResult = () => ({
-    loading: !hasLoaded && status === LoaderStatus.loading,
-    reloading: hasLoaded && status === LoaderStatus.loading,
+    loading: !hasLoaded && status === 1 /* loading */,
+    reloading: hasLoaded && status === 1 /* 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 => {
+    [...handlers].forEach((handler) => {
       handler(status, getResult());
     });
   };
-  const onChange = handler => {
+  const onChange = (handler) => {
     handlers.add(handler);
     return () => {
       handlers.delete(handler);
@@ -101,71 +132,55 @@ const createLoader = (id, initialData = {
     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 { skipStatic = false, skipNonStatic = false } = managerOptions;
+  const loadersMap = /* @__PURE__ */ 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);
+      loader = createLoader(
+        id,
+        typeof initialDataMap[id] !== "undefined" ? initialDataMap[id] : { data: loaderOptions.initialData },
+        loaderFn,
+        skipExec
+      );
       loadersMap.set(id, loader);
     }
     return id;
   };
-  const get = id => loadersMap.get(id);
-
-  // check if there has pending loaders
+  const get = (id) => loadersMap.get(id);
   const hasPendingLoaders = () => {
     for (const loader of loadersMap.values()) {
-      const {
-        promise
-      } = loader;
+      const { promise } = loader;
       if (promise instanceof Promise) {
         return true;
       }
     }
     return false;
   };
-
-  // waiting for all pending loaders to be settled
-  const awaitPendingLoaders = async () => {
+  const awaitPendingLoaders = () => __async(void 0, null, function* () {
     const pendingLoaders = [];
     for (const [id, loader] of loadersMap) {
-      const {
-        promise
-      } = loader;
+      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;
-    }, {});
-  };
+    yield Promise.all(pendingLoaders.map((item) => item[1].promise));
+    return pendingLoaders.reduce(
+      (res, [id, loader]) => {
+        res[id] = loader.result;
+        return res;
+      },
+      {}
+    );
+  });
   return {
     hasPendingLoaders,
     awaitPendingLoaders,
@@ -173,4 +188,8 @@ const createLoaderManager = (initialDataMap, managerOptions = {}) => {
     get
   };
 };
-exports.createLoaderManager = createLoaderManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoaderStatus,
+  createLoaderManager
+});

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

@@ -1,95 +1,132 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLoader_exports = {};
+__export(useLoader_exports, {
+  default: () => useLoader_default
 });
-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);
+module.exports = __toCommonJS(useLoader_exports);
+var import_react = require("react");
+var import_invariant = __toESM(require("invariant"));
+var import_runtime_context = require("../../runtime-context");
+var import_loaderManager = require("./loaderManager");
+const useLoader = (loaderFn, options = { params: void 0 }) => {
+  const context = (0, import_react.useContext)(import_runtime_context.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')) {
+  const { loaderManager } = context;
+  const loaderRef = (0, import_react.useRef)();
+  const unlistenLoaderChangeRef = (0, import_react.useRef)(null);
+  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);
+  const load = (0, import_react.useCallback)(
+    (params) => {
+      var _a, _b, _c, _d, _e, _f;
+      if (typeof params === "undefined") {
+        return (_a = loaderRef.current) == null ? void 0 : _a.load();
       }
-    }, _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);
+      const id = loaderManager.add(
+        () => {
+          try {
+            const res2 = loaderFn(context, params);
+            if (res2 instanceof Promise) {
+              return res2;
+            }
+            return Promise.resolve(res2);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        },
+        __spreadProps(__spreadValues({}, options), {
+          params
+        })
+      );
+      loaderRef.current = loaderManager.get(id);
+      (_b = unlistenLoaderChangeRef.current) == null ? void 0 : _b.call(unlistenLoaderChangeRef);
+      if (isSSRRender) {
+        return void 0;
+      }
+      if (options.skip) {
+        return void 0;
       }
-      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);
+      if (context._hydration && ((_e = (_d = (_c = window == null ? void 0 : window._SSR_DATA) == null ? void 0 : _c.data) == null ? void 0 : _d.loadersData[id]) == null ? void 0 : _e.error) === null) {
+        return void 0;
       }
-    });
-    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');
+      const res = loaderRef.current.load();
+      unlistenLoaderChangeRef.current = (_f = loaderRef.current) == null ? void 0 : _f.onChange(
+        (_status, _result) => {
+          var _a2, _b2;
+          setResult(_result);
+          if (_status === import_loaderManager.LoaderStatus.fulfilled) {
+            (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, _result.data);
+          }
+          if (_status === import_loaderManager.LoaderStatus.rejected) {
+            (_b2 = options == null ? void 0 : options.onError) == null ? void 0 : _b2.call(options, _result.error);
+          }
+        }
+      );
+      return res;
+    },
+    [options.skip]
+  );
+  (0, import_react.useEffect)(
+    () => () => {
+      var _a;
+      (_a = unlistenLoaderChangeRef.current) == null ? void 0 : _a.call(unlistenLoaderChangeRef);
+    },
+    []
+  );
+  (0, import_react.useMemo)(() => {
+    var _a;
+    const p = (_a = options.params) != null ? _a : loaderFn.id;
+    (0, import_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), {}, {
+  const [result, setResult] = (0, import_react.useState)(loaderRef.current.result);
+  return __spreadProps(__spreadValues({}, result), {
     reload: load
   });
 };
-var _default = useLoader;
-exports.default = _default;
+var useLoader_default = useLoader;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -1,20 +1,56 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var plugin_exports = {};
+__export(plugin_exports, {
+  createPlugin: () => createPlugin,
+  createRuntime: () => createRuntime,
+  registerInit: () => registerInit,
+  runtime: () => runtime
 });
-exports.runtime = exports.registerInit = exports.createRuntime = exports.createPlugin = void 0;
-var _plugin = require("@modern-js/plugin");
-var _loaderManager = require("./loader/loaderManager");
-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)();
+module.exports = __toCommonJS(plugin_exports);
+var import_plugin = require("@modern-js/plugin");
+var import_loaderManager = require("./loader/loaderManager");
+const hoc = (0, import_plugin.createPipeline)();
+const provide = (0, import_plugin.createPipeline)();
+const client = (0, import_plugin.createAsyncPipeline)();
+const server = (0, import_plugin.createAsyncPipeline)();
+const init = (0, import_plugin.createAsyncPipeline)();
+const pickContext = (0, import_plugin.createPipeline)();
 const runtimeHooks = {
   hoc,
   provide,
@@ -23,28 +59,22 @@ const runtimeHooks = {
   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 createRuntime = () => (0, import_plugin.createManager)(runtimeHooks);
 const registerInit = (App, _init) => {
   const originalInit = App.init;
-  App.init = async context => {
+  App.init = (context) => __async(void 0, null, function* () {
     if (!context.loaderManager) {
-      context.loaderManager = (0, _loaderManager.createLoaderManager)({});
+      context.loaderManager = (0, import_loaderManager.createLoaderManager)({});
     }
-    await Promise.all([originalInit === null || originalInit === void 0 ? void 0 : originalInit(context), _init === null || _init === void 0 ? void 0 : _init(context)]);
-  };
+    yield Promise.all([originalInit == null ? void 0 : originalInit(context), _init == null ? void 0 : _init(context)]);
+  });
 };
-exports.registerInit = registerInit;
 const runtime = createRuntime();
-exports.runtime = runtime;
-const {
-  createPlugin
-} = runtime;
-exports.createPlugin = createPlugin;
+const { createPlugin } = runtime;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlugin,
+  createRuntime,
+  registerInit,
+  runtime
+});