umi 4.0.0-beta.9 → 4.0.0-canary-20240513.3

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present ChenCheng (sorrycc@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/bin/forkedDev.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 
-require('v8-compile-cache');
+// require('v8-compile-cache');
 require('../dist/cli/forkedDev');

package/bin/umi.js

@@ -1,6 +1,25 @@
 #!/usr/bin/env node
 
-require('v8-compile-cache');
+// disable since it's conflicted with typescript cjs + dynamic import
+// require('v8-compile-cache');
+
+// patch console for debug
+// ref: https://remysharp.com/2014/05/23/where-is-that-console-log
+if (process.env.DEBUG_CONSOLE) {
+  ['log', 'warn', 'error'].forEach((method) => {
+    const old = console[method];
+    console[method] = function () {
+      let stack = new Error().stack.split(/\n/);
+      // Chrome includes a single "Error" line, FF doesn't.
+      if (stack[0].indexOf('Error') === 0) {
+        stack = stack.slice(1);
+      }
+      const args = [].slice.apply(arguments).concat([stack[1].trim()]);
+      return old.apply(console, args);
+    };
+  });
+}
+
 require('../dist/cli/cli')
   .run()
   .catch((e) => {

package/client/client/plugin.js

@@ -1,121 +1,218 @@
-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());
-    });
-};
-import { assert, compose, isPromiseLike } from './utils';
-export var ApplyPluginsType;
-(function (ApplyPluginsType) {
-    ApplyPluginsType["compose"] = "compose";
-    ApplyPluginsType["modify"] = "modify";
-    ApplyPluginsType["event"] = "event";
-})(ApplyPluginsType || (ApplyPluginsType = {}));
-export class PluginManager {
-    constructor(opts) {
-        this.hooks = {};
-        this.opts = opts;
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toArray from "@babel/runtime/helpers/esm/toArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { assert, compose, isPromiseLike } from "./utils";
+export var ApplyPluginsType = /*#__PURE__*/function (ApplyPluginsType) {
+  ApplyPluginsType["compose"] = "compose";
+  ApplyPluginsType["modify"] = "modify";
+  ApplyPluginsType["event"] = "event";
+  return ApplyPluginsType;
+}({});
+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]);
+      });
     }
-    register(plugin) {
-        assert(plugin.apply && plugin.path, `plugin register failed, apply and path must supplied`);
-        Object.keys(plugin.apply).forEach((key) => {
-            assert(this.opts.validKeys.indexOf(key) > -1, `register failed, invalid key ${key} from plugin ${plugin.path}.`);
-            this.hooks[key] = (this.hooks[key] || []).concat(plugin.apply[key]);
-        });
+  }, {
+    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;
     }
-    getHooks(keyWithDot) {
-        const [key, ...memberKeys] = keyWithDot.split('.');
-        let hooks = this.hooks[key] || [];
-        if (memberKeys.length) {
-            hooks = hooks
-                .map((hook) => {
-                try {
-                    let ret = hook;
-                    for (const memberKey of memberKeys) {
-                        ret = ret[memberKey];
-                    }
-                    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;
+                      }
+                      _context.next = 4;
+                      return memo;
+                    case 4:
+                      memo = _context.sent;
+                    case 5:
+                      if (!(typeof hook === 'function')) {
+                        _context.next = 16;
+                        break;
+                      }
+                      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;
+                      }
+                      _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
+            })();
+          };
+      }
     }
-    applyPlugins({ key, type, initialValue, args, async, }) {
-        const hooks = this.getHooks(key) || [];
-        if (args) {
-            assert(typeof args === 'object', `applyPlugins failed, args must be plain object.`);
-        }
-        switch (type) {
-            case ApplyPluginsType.modify:
-                if (async) {
-                    return hooks.reduce((memo, hook) => __awaiter(this, void 0, void 0, function* () {
-                        assert(typeof hook === 'function' ||
-                            typeof hook === 'object' ||
-                            isPromiseLike(hook), `applyPlugins failed, all hooks for key ${key} must be function, plain object or Promise.`);
-                        if (isPromiseLike(memo)) {
-                            memo = yield memo;
-                        }
-                        if (typeof hook === 'function') {
-                            const ret = hook(memo, args);
-                            if (isPromiseLike(ret)) {
-                                return yield ret;
-                            }
-                            else {
-                                return ret;
-                            }
-                        }
-                        else {
-                            if (isPromiseLike(hook)) {
-                                hook = yield hook;
-                            }
-                            return Object.assign(Object.assign({}, memo), hook);
-                        }
-                    }), isPromiseLike(initialValue)
-                        ? initialValue
-                        : Promise.resolve(initialValue));
-                }
-                else {
-                    return hooks.reduce((memo, hook) => {
-                        assert(typeof hook === 'function' || typeof hook === 'object', `applyPlugins failed, all hooks for key ${key} must be function or plain object.`);
-                        if (typeof hook === 'function') {
-                            return hook(memo, args);
-                        }
-                        else {
-                            // TODO: deepmerge?
-                            return Object.assign(Object.assign({}, memo), hook);
-                        }
-                    }, initialValue);
-                }
-            case ApplyPluginsType.event:
-                return hooks.forEach((hook) => {
-                    assert(typeof hook === 'function', `applyPlugins failed, all hooks for key ${key} must be function.`);
-                    hook(args);
-                });
-            case ApplyPluginsType.compose:
-                return () => {
-                    return compose({
-                        fns: hooks.concat(initialValue),
-                        args,
-                    })();
-                };
-        }
+  }], [{
+    key: "create",
+    value: function create(opts) {
+      var pluginManager = new PluginManager({
+        validKeys: opts.validKeys
+      });
+      opts.plugins.forEach(function (plugin) {
+        pluginManager.register(plugin);
+      });
+      return pluginManager;
     }
-    static create(opts) {
-        const pluginManager = new PluginManager({
-            validKeys: opts.validKeys,
-        });
-        opts.plugins.forEach((plugin) => {
-            pluginManager.register(plugin);
-        });
-        return pluginManager;
-    }
-}
+  }]);
+  return PluginManager;
+}();
+
 // plugins meta info (in tmp file)
-// hooks api: usePlugin
+// hooks api: usePlugin

package/client/client/utils.js

@@ -1,14 +1,20 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
 export function assert(value, message) {
-    if (!value)
-        throw new Error(message);
+  if (!value) throw new Error(message);
 }
-export function compose({ fns, args, }) {
-    if (fns.length === 1) {
-        return fns[0];
-    }
-    const last = fns.pop();
-    return fns.reduce((a, b) => () => 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,58 +1,70 @@
-"use strict";
-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 __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 });
 };
-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");
-function run(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        (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 {
-                yield new service_1.Service().run2({
-                    name: args._[0],
-                    args,
-                });
-            }
-            catch (e) {
-                utils_1.logger.error(e);
-                process.exit(1);
-            }
-        }
-    });
+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);
+
+// src/cli/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");
+(0, import_utils.catchUnhandledRejection)();
+async function run(opts) {
+  (0, import_utils.checkVersion)(import_constants.MIN_NODE_VERSION);
+  (0, import_utils.checkLocal)();
+  (0, import_utils.setNodeTitle)(import_constants.FRAMEWORK_NAME);
+  (0, import_utils.setNoDeprecation)();
+  const args = (0, import_utils.yParser)(process.argv.slice(2), {
+    alias: {
+      version: ["v"],
+      help: ["h"]
+    },
+    boolean: ["version"]
+  });
+  const command = args._[0];
+  const FEATURE_COMMANDS = ["mfsu", "setup", "deadcode"];
+  if ([import_constants.DEV_COMMAND, ...FEATURE_COMMANDS].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[`${import_constants.FRAMEWORK_NAME}_PRESETS`.toUpperCase()] = 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
+});

package/dist/cli/dev.js

@@ -1,26 +1,52 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dev = void 0;
-const fork_1 = __importDefault(require("./fork"));
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev
+});
+module.exports = __toCommonJS(dev_exports);
+var import_fork = __toESM(require("./fork"));
 function dev() {
-    const child = (0, fork_1.default)({
-        scriptPath: require.resolve('../../bin/forkedDev'),
-    });
-    // ref:
-    // http://nodejs.cn/api/process/signal_events.html
-    // https://lisk.io/blog/development/why-we-stopped-using-npm-start-child-processes
-    process.on('SIGINT', () => {
-        child.kill('SIGINT');
-        // ref:
-        // https://github.com/umijs/umi/issues/6009
-        process.exit(0);
-    });
-    process.on('SIGTERM', () => {
-        child.kill('SIGTERM');
-        process.exit(1);
-    });
+  const child = (0, import_fork.default)({
+    scriptPath: require.resolve("../../bin/forkedDev")
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM");
+    process.exit(1);
+  });
 }
-exports.dev = dev;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev
+});