umi 4.0.7 → 4.0.8

package/client/client/plugin.js

@@ -1,197 +1,270 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { assert, compose, isPromiseLike } from './utils';
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/createForOfIteratorHelper";
+import _toArray from "@babel/runtime/helpers/toArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { assert, compose, isPromiseLike } from "./utils";
 export var ApplyPluginsType;
+
 (function (ApplyPluginsType) {
-    ApplyPluginsType["compose"] = "compose";
-    ApplyPluginsType["modify"] = "modify";
-    ApplyPluginsType["event"] = "event";
+  ApplyPluginsType["compose"] = "compose";
+  ApplyPluginsType["modify"] = "modify";
+  ApplyPluginsType["event"] = "event";
 })(ApplyPluginsType || (ApplyPluginsType = {}));
-var PluginManager = /** @class */ (function () {
-    function PluginManager(opts) {
-        this.hooks = {};
-        this.opts = opts;
+
+export var PluginManager = /*#__PURE__*/function () {
+  function PluginManager(opts) {
+    _classCallCheck(this, PluginManager);
+
+    _defineProperty(this, "opts", void 0);
+
+    _defineProperty(this, "hooks", {});
+
+    this.opts = opts;
+  }
+
+  _createClass(PluginManager, [{
+    key: "register",
+    value: function register(plugin) {
+      var _this = this;
+
+      assert(plugin.apply, "plugin register failed, apply must supplied");
+      Object.keys(plugin.apply).forEach(function (key) {
+        assert(_this.opts.validKeys.indexOf(key) > -1, "register failed, invalid key ".concat(key, " ").concat(plugin.path ? "from plugin ".concat(plugin.path) : '', "."));
+        _this.hooks[key] = (_this.hooks[key] || []).concat(plugin.apply[key]);
+      });
     }
-    PluginManager.prototype.register = function (plugin) {
-        var _this = this;
-        assert(plugin.apply, "plugin register failed, apply must supplied");
-        Object.keys(plugin.apply).forEach(function (key) {
-            assert(_this.opts.validKeys.indexOf(key) > -1, "register failed, invalid key ".concat(key, " ").concat(plugin.path ? "from plugin ".concat(plugin.path) : '', "."));
-            _this.hooks[key] = (_this.hooks[key] || []).concat(plugin.apply[key]);
-        });
-    };
-    PluginManager.prototype.getHooks = function (keyWithDot) {
-        var _a = keyWithDot.split('.'), key = _a[0], memberKeys = _a.slice(1);
-        var hooks = this.hooks[key] || [];
-        if (memberKeys.length) {
-            hooks = hooks
-                .map(function (hook) {
-                try {
-                    var ret = hook;
-                    for (var _i = 0, memberKeys_1 = memberKeys; _i < memberKeys_1.length; _i++) {
-                        var memberKey = memberKeys_1[_i];
-                        ret = ret[memberKey];
-                    }
-                    return ret;
-                }
-                catch (e) {
-                    return null;
-                }
-            })
-                .filter(Boolean);
-        }
-        return hooks;
-    };
-    PluginManager.prototype.applyPlugins = function (_a) {
-        var _this = this;
-        var key = _a.key, type = _a.type, initialValue = _a.initialValue, args = _a.args, async = _a.async;
-        var hooks = this.getHooks(key) || [];
-        if (args) {
-            assert(typeof args === 'object', "applyPlugins failed, args must be plain object.");
-        }
-        if (async) {
-            assert(type === ApplyPluginsType.modify || type === ApplyPluginsType.event, "async only works with modify and event type.");
-        }
-        switch (type) {
-            case ApplyPluginsType.modify:
-                if (async) {
-                    return hooks.reduce(function (memo, hook) { return __awaiter(_this, void 0, void 0, function () {
-                        var ret;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    assert(typeof hook === 'function' ||
-                                        typeof hook === 'object' ||
-                                        isPromiseLike(hook), "applyPlugins failed, all hooks for key ".concat(key, " must be function, plain object or Promise."));
-                                    if (!isPromiseLike(memo)) return [3 /*break*/, 2];
-                                    return [4 /*yield*/, memo];
-                                case 1:
-                                    memo = _a.sent();
-                                    _a.label = 2;
-                                case 2:
-                                    if (!(typeof hook === 'function')) return [3 /*break*/, 6];
-                                    ret = hook(memo, args);
-                                    if (!isPromiseLike(ret)) return [3 /*break*/, 4];
-                                    return [4 /*yield*/, ret];
-                                case 3: return [2 /*return*/, _a.sent()];
-                                case 4: return [2 /*return*/, ret];
-                                case 5: return [3 /*break*/, 9];
-                                case 6:
-                                    if (!isPromiseLike(hook)) return [3 /*break*/, 8];
-                                    return [4 /*yield*/, hook];
-                                case 7:
-                                    hook = _a.sent();
-                                    _a.label = 8;
-                                case 8: return [2 /*return*/, __assign(__assign({}, memo), hook)];
-                                case 9: return [2 /*return*/];
-                            }
-                        });
-                    }); }, isPromiseLike(initialValue)
-                        ? initialValue
-                        : Promise.resolve(initialValue));
-                }
-                else {
-                    return hooks.reduce(function (memo, hook) {
-                        assert(typeof hook === 'function' || typeof hook === 'object', "applyPlugins failed, all hooks for key ".concat(key, " must be function or plain object."));
-                        if (typeof hook === 'function') {
-                            return hook(memo, args);
+  }, {
+    key: "getHooks",
+    value: function getHooks(keyWithDot) {
+      var _keyWithDot$split = keyWithDot.split('.'),
+          _keyWithDot$split2 = _toArray(_keyWithDot$split),
+          key = _keyWithDot$split2[0],
+          memberKeys = _keyWithDot$split2.slice(1);
+
+      var hooks = this.hooks[key] || [];
+
+      if (memberKeys.length) {
+        hooks = hooks.map(function (hook) {
+          try {
+            var ret = hook;
+
+            var _iterator = _createForOfIteratorHelper(memberKeys),
+                _step;
+
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var memberKey = _step.value;
+                ret = ret[memberKey];
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+
+            return ret;
+          } catch (e) {
+            return null;
+          }
+        }).filter(Boolean);
+      }
+
+      return hooks;
+    }
+  }, {
+    key: "applyPlugins",
+    value: function applyPlugins(_ref) {
+      var key = _ref.key,
+          type = _ref.type,
+          initialValue = _ref.initialValue,
+          args = _ref.args,
+          async = _ref.async;
+      var hooks = this.getHooks(key) || [];
+
+      if (args) {
+        assert(_typeof(args) === 'object', "applyPlugins failed, args must be plain object.");
+      }
+
+      if (async) {
+        assert(type === ApplyPluginsType.modify || type === ApplyPluginsType.event, "async only works with modify and event type.");
+      }
+
+      switch (type) {
+        case ApplyPluginsType.modify:
+          if (async) {
+            return hooks.reduce( /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(memo, hook) {
+                var ret;
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        assert(typeof hook === 'function' || _typeof(hook) === 'object' || isPromiseLike(hook), "applyPlugins failed, all hooks for key ".concat(key, " must be function, plain object or Promise."));
+
+                        if (!isPromiseLike(memo)) {
+                          _context.next = 5;
+                          break;
                         }
-                        else {
-                            // TODO: deepmerge?
-                            return __assign(__assign({}, memo), hook);
+
+                        _context.next = 4;
+                        return memo;
+
+                      case 4:
+                        memo = _context.sent;
+
+                      case 5:
+                        if (!(typeof hook === 'function')) {
+                          _context.next = 16;
+                          break;
                         }
-                    }, initialValue);
-                }
-            case ApplyPluginsType.event:
-                return (function () { return __awaiter(_this, void 0, void 0, function () {
-                    var _i, hooks_1, hook, ret;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                _i = 0, hooks_1 = hooks;
-                                _a.label = 1;
-                            case 1:
-                                if (!(_i < hooks_1.length)) return [3 /*break*/, 4];
-                                hook = hooks_1[_i];
-                                assert(typeof hook === 'function', "applyPlugins failed, all hooks for key ".concat(key, " must be function."));
-                                ret = hook(args);
-                                if (!(async && isPromiseLike(ret))) return [3 /*break*/, 3];
-                                return [4 /*yield*/, ret];
-                            case 2:
-                                _a.sent();
-                                _a.label = 3;
-                            case 3:
-                                _i++;
-                                return [3 /*break*/, 1];
-                            case 4: return [2 /*return*/];
+
+                        ret = hook(memo, args);
+
+                        if (!isPromiseLike(ret)) {
+                          _context.next = 13;
+                          break;
+                        }
+
+                        _context.next = 10;
+                        return ret;
+
+                      case 10:
+                        return _context.abrupt("return", _context.sent);
+
+                      case 13:
+                        return _context.abrupt("return", ret);
+
+                      case 14:
+                        _context.next = 21;
+                        break;
+
+                      case 16:
+                        if (!isPromiseLike(hook)) {
+                          _context.next = 20;
+                          break;
                         }
-                    });
-                }); })();
-            case ApplyPluginsType.compose:
-                return function () {
-                    return compose({
-                        fns: hooks.concat(initialValue),
-                        args: args,
-                    })();
-                };
-        }
-    };
-    PluginManager.create = function (opts) {
-        var pluginManager = new PluginManager({
-            validKeys: opts.validKeys,
-        });
-        opts.plugins.forEach(function (plugin) {
-            pluginManager.register(plugin);
-        });
-        return pluginManager;
-    };
-    return PluginManager;
-}());
-export { PluginManager };
-// plugins meta info (in tmp file)
-// hooks api: usePlugin
+
+                        _context.next = 19;
+                        return hook;
+
+                      case 19:
+                        hook = _context.sent;
+
+                      case 20:
+                        return _context.abrupt("return", _objectSpread(_objectSpread({}, memo), hook));
+
+                      case 21:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x, _x2) {
+                return _ref2.apply(this, arguments);
+              };
+            }(), isPromiseLike(initialValue) ? initialValue : Promise.resolve(initialValue));
+          } else {
+            return hooks.reduce(function (memo, hook) {
+              assert(typeof hook === 'function' || _typeof(hook) === 'object', "applyPlugins failed, all hooks for key ".concat(key, " must be function or plain object."));
+
+              if (typeof hook === 'function') {
+                return hook(memo, args);
+              } else {
+                // TODO: deepmerge?
+                return _objectSpread(_objectSpread({}, memo), hook);
+              }
+            }, initialValue);
+          }
+
+        case ApplyPluginsType.event:
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+            var _iterator2, _step2, hook, ret;
+
+            return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _iterator2 = _createForOfIteratorHelper(hooks);
+                    _context2.prev = 1;
+
+                    _iterator2.s();
+
+                  case 3:
+                    if ((_step2 = _iterator2.n()).done) {
+                      _context2.next = 12;
+                      break;
+                    }
+
+                    hook = _step2.value;
+                    assert(typeof hook === 'function', "applyPlugins failed, all hooks for key ".concat(key, " must be function."));
+                    ret = hook(args);
+
+                    if (!(async && isPromiseLike(ret))) {
+                      _context2.next = 10;
+                      break;
+                    }
+
+                    _context2.next = 10;
+                    return ret;
+
+                  case 10:
+                    _context2.next = 3;
+                    break;
+
+                  case 12:
+                    _context2.next = 17;
+                    break;
+
+                  case 14:
+                    _context2.prev = 14;
+                    _context2.t0 = _context2["catch"](1);
+
+                    _iterator2.e(_context2.t0);
+
+                  case 17:
+                    _context2.prev = 17;
+
+                    _iterator2.f();
+
+                    return _context2.finish(17);
+
+                  case 20:
+                  case "end":
+                    return _context2.stop();
+                }
+              }
+            }, _callee2, null, [[1, 14, 17, 20]]);
+          }))();
+
+        case ApplyPluginsType.compose:
+          return function () {
+            return compose({
+              fns: hooks.concat(initialValue),
+              args: args
+            })();
+          };
+      }
+    }
+  }], [{
+    key: "create",
+    value: function create(opts) {
+      var pluginManager = new PluginManager({
+        validKeys: opts.validKeys
+      });
+      opts.plugins.forEach(function (plugin) {
+        pluginManager.register(plugin);
+      });
+      return pluginManager;
+    }
+  }]);
+
+  return PluginManager;
+}(); // plugins meta info (in tmp file)
+// hooks api: usePlugin

package/client/client/utils.js

@@ -1,15 +1,22 @@
+import _typeof from "@babel/runtime/helpers/typeof";
 export function assert(value, message) {
-    if (!value)
-        throw new Error(message);
+  if (!value) throw new Error(message);
 }
-export function compose(_a) {
-    var fns = _a.fns, args = _a.args;
-    if (fns.length === 1) {
-        return fns[0];
-    }
-    var last = fns.pop();
-    return fns.reduce(function (a, b) { return function () { return b(a, args); }; }, last);
+export function compose(_ref) {
+  var fns = _ref.fns,
+      args = _ref.args;
+
+  if (fns.length === 1) {
+    return fns[0];
+  }
+
+  var last = fns.pop();
+  return fns.reduce(function (a, b) {
+    return function () {
+      return b(a, args);
+    };
+  }, last);
 }
 export function isPromiseLike(obj) {
-    return !!obj && typeof obj === 'object' && typeof obj.then === 'function';
-}
+  return !!obj && _typeof(obj) === 'object' && typeof obj.then === 'function';
+}

package/dist/cli/cli.js

@@ -1,48 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const utils_1 = require("@umijs/utils");
-const constants_1 = require("../constants");
-const service_1 = require("../service/service");
-const dev_1 = require("./dev");
-const node_1 = require("./node");
+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);
+
+// cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+var import_utils = require("@umijs/utils");
+var import_constants = require("../constants");
+var import_service = require("../service/service");
+var import_dev = require("./dev");
+var import_node = require("./node");
 async function run(opts) {
-    (0, node_1.checkVersion)();
-    (0, node_1.checkLocal)();
-    (0, node_1.setNodeTitle)();
-    (0, node_1.setNoDeprecation)();
-    const args = (0, utils_1.yParser)(process.argv.slice(2), {
-        alias: {
-            version: ['v'],
-            help: ['h'],
-        },
-        boolean: ['version'],
-    });
-    const command = args._[0];
-    if ([constants_1.DEV_COMMAND, 'setup'].includes(command)) {
-        process.env.NODE_ENV = 'development';
-    }
-    else if (command === 'build') {
-        process.env.NODE_ENV = 'production';
-    }
-    if (opts === null || opts === void 0 ? void 0 : opts.presets) {
-        process.env.UMI_PRESETS = opts.presets.join(',');
-    }
-    if (command === constants_1.DEV_COMMAND) {
-        (0, dev_1.dev)();
-    }
-    else {
-        try {
-            await new service_1.Service().run2({
-                name: args._[0],
-                args,
-            });
-        }
-        catch (e) {
-            utils_1.logger.fatal(e);
-            utils_1.printHelp.exit();
-            process.exit(1);
-        }
+  (0, import_node.checkVersion)();
+  (0, import_node.checkLocal)();
+  (0, import_node.setNodeTitle)();
+  (0, import_node.setNoDeprecation)();
+  const args = (0, import_utils.yParser)(process.argv.slice(2), {
+    alias: {
+      version: ["v"],
+      help: ["h"]
+    },
+    boolean: ["version"]
+  });
+  const command = args._[0];
+  if ([import_constants.DEV_COMMAND, "setup"].includes(command)) {
+    process.env.NODE_ENV = "development";
+  } else if (command === "build") {
+    process.env.NODE_ENV = "production";
+  }
+  if (opts == null ? void 0 : opts.presets) {
+    process.env.UMI_PRESETS = opts.presets.join(",");
+  }
+  if (command === import_constants.DEV_COMMAND) {
+    (0, import_dev.dev)();
+  } else {
+    try {
+      await new import_service.Service().run2({
+        name: args._[0],
+        args
+      });
+    } catch (e) {
+      import_utils.logger.fatal(e);
+      import_utils.printHelp.exit();
+      process.exit(1);
     }
+  }
 }
-exports.run = run;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});