@umijs/core 4.0.5 → 4.0.8

package/dist/service/plugin.js

@@ -1,148 +1,145 @@
-"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.Plugin = void 0;
-const esbuild_1 = __importDefault(require("@umijs/bundler-utils/compiled/esbuild"));
-const utils_1 = require("@umijs/utils");
-const assert_1 = __importDefault(require("assert"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const types_1 = require("../types");
-const RE = {
-    plugin: /^(@umijs\/|umi-)plugin-/,
-    preset: /^(@umijs\/|umi-)preset-/,
+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;
 };
-class Plugin {
-    constructor(opts) {
-        this.config = {};
-        this.time = { hooks: {} };
-        this.enableBy = types_1.EnableBy.register;
-        this.type = opts.type;
-        this.path = (0, utils_1.winPath)(opts.path);
-        this.cwd = opts.cwd;
-        (0, assert_1.default)((0, fs_1.existsSync)(this.path), `Invalid ${this.type} ${this.path}, it's not exists.`);
-        let pkg = null;
-        // path is the package entry
-        let isPkgEntry = false;
-        const pkgJSONPath = utils_1.pkgUp.pkgUpSync({ cwd: this.path });
-        if (pkgJSONPath) {
-            pkg = require(pkgJSONPath);
-            isPkgEntry =
-                (0, utils_1.winPath)((0, path_1.join)((0, path_1.dirname)(pkgJSONPath), pkg.main || 'index.js')) ===
-                    (0, utils_1.winPath)(this.path);
-        }
-        this.id = this.getId({ pkg, isPkgEntry, pkgJSONPath });
-        this.key = this.getKey({ pkg, isPkgEntry });
-        this.apply = () => {
-            utils_1.register.register({
-                implementor: esbuild_1.default,
-                exts: ['.ts', '.mjs'],
-            });
-            utils_1.register.clearFiles();
-            let ret;
-            try {
-                ret = require(this.path);
-            }
-            catch (e) {
-                throw new Error(`Register ${this.type} ${this.path} failed, since ${e.message}`);
-            }
-            finally {
-                utils_1.register.restore();
-            }
-            // use the default member for es modules
-            return ret.__esModule ? ret.default : ret;
-        };
-    }
-    merge(opts) {
-        if (opts.key)
-            this.key = opts.key;
-        if (opts.config)
-            this.config = opts.config;
-        if (opts.enableBy)
-            this.enableBy = opts.enableBy;
-    }
-    getId(opts) {
-        let id;
-        if (opts.isPkgEntry) {
-            id = opts.pkg.name;
-        }
-        else if ((0, utils_1.winPath)(this.path).startsWith((0, utils_1.winPath)(this.cwd))) {
-            id = `./${(0, utils_1.winPath)((0, path_1.relative)(this.cwd, this.path))}`;
-        }
-        else if (opts.pkgJSONPath) {
-            id = (0, utils_1.winPath)((0, path_1.join)(opts.pkg.name, (0, path_1.relative)((0, path_1.dirname)(opts.pkgJSONPath), this.path)));
-        }
-        else {
-            id = (0, utils_1.winPath)(this.path);
-        }
-        id = id.replace('@umijs/preset-umi/lib/plugins', '@@');
-        id = id.replace(/\.js$/, '');
-        return id;
+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);
+
+// plugin.ts
+var plugin_exports = {};
+__export(plugin_exports, {
+  Plugin: () => Plugin
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_esbuild = __toESM(require("@umijs/bundler-utils/compiled/esbuild"));
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_types = require("../types");
+var RE = {
+  plugin: /^(@umijs\/|umi-)plugin-/,
+  preset: /^(@umijs\/|umi-)preset-/
+};
+var Plugin = class {
+  constructor(opts) {
+    this.config = {};
+    this.time = { hooks: {} };
+    this.enableBy = import_types.EnableBy.register;
+    this.type = opts.type;
+    this.path = (0, import_utils.winPath)(opts.path);
+    this.cwd = opts.cwd;
+    (0, import_assert.default)((0, import_fs.existsSync)(this.path), `Invalid ${this.type} ${this.path}, it's not exists.`);
+    let pkg = null;
+    let isPkgEntry = false;
+    const pkgJSONPath = import_utils.pkgUp.pkgUpSync({ cwd: this.path });
+    if (pkgJSONPath) {
+      pkg = require(pkgJSONPath);
+      isPkgEntry = (0, import_utils.winPath)((0, import_path.join)((0, import_path.dirname)(pkgJSONPath), pkg.main || "index.js")) === (0, import_utils.winPath)(this.path);
     }
-    getKey(opts) {
-        // e.g.
-        // initial-state -> initialState
-        // webpack.css-loader -> webpack.cssLoader
-        function nameToKey(name) {
-            return name
-                .split('.')
-                .map((part) => utils_1.lodash.camelCase(part))
-                .join('.');
-        }
-        return nameToKey(opts.isPkgEntry
-            ? Plugin.stripNoneUmiScope(opts.pkg.name).replace(RE[this.type], '')
-            : (0, path_1.basename)(this.path, (0, path_1.extname)(this.path)));
+    this.id = this.getId({ pkg, isPkgEntry, pkgJSONPath });
+    this.key = this.getKey({ pkg, isPkgEntry });
+    this.apply = () => {
+      import_utils.register.register({
+        implementor: import_esbuild.default,
+        exts: [".ts", ".mjs"]
+      });
+      import_utils.register.clearFiles();
+      let ret;
+      try {
+        ret = require(this.path);
+      } catch (e) {
+        throw new Error(`Register ${this.type} ${this.path} failed, since ${e.message}`);
+      } finally {
+        import_utils.register.restore();
+      }
+      return ret.__esModule ? ret.default : ret;
+    };
+  }
+  merge(opts) {
+    if (opts.key)
+      this.key = opts.key;
+    if (opts.config)
+      this.config = opts.config;
+    if (opts.enableBy)
+      this.enableBy = opts.enableBy;
+  }
+  getId(opts) {
+    let id;
+    if (opts.isPkgEntry) {
+      id = opts.pkg.name;
+    } else if ((0, import_utils.winPath)(this.path).startsWith((0, import_utils.winPath)(this.cwd))) {
+      id = `./${(0, import_utils.winPath)((0, import_path.relative)(this.cwd, this.path))}`;
+    } else if (opts.pkgJSONPath) {
+      id = (0, import_utils.winPath)((0, import_path.join)(opts.pkg.name, (0, import_path.relative)((0, import_path.dirname)(opts.pkgJSONPath), this.path)));
+    } else {
+      id = (0, import_utils.winPath)(this.path);
     }
-    static isPluginOrPreset(type, name) {
-        return RE[type].test(Plugin.stripNoneUmiScope(name));
+    id = id.replace("@umijs/preset-umi/lib/plugins", "@@");
+    id = id.replace(/\.js$/, "");
+    return id;
+  }
+  getKey(opts) {
+    function nameToKey(name) {
+      return name.split(".").map((part) => import_utils.lodash.camelCase(part)).join(".");
     }
-    static stripNoneUmiScope(name) {
-        if (name.charAt(0) === '@' && !name.startsWith('@umijs/')) {
-            name = name.split('/')[1];
-        }
-        return name;
+    return nameToKey(opts.isPkgEntry ? Plugin.stripNoneUmiScope(opts.pkg.name).replace(RE[this.type], "") : (0, import_path.basename)(this.path, (0, import_path.extname)(this.path)));
+  }
+  static isPluginOrPreset(type, name) {
+    return RE[type].test(Plugin.stripNoneUmiScope(name));
+  }
+  static stripNoneUmiScope(name) {
+    if (name.charAt(0) === "@" && !name.startsWith("@umijs/")) {
+      name = name.split("/")[1];
     }
-    static getPluginsAndPresets(opts) {
-        function get(type) {
-            const types = `${type}s`;
-            return [
-                // opts
-                ...(opts[types] || []),
-                // env
-                ...(process.env[`${opts.prefix}_${types}`.toUpperCase()] || '')
-                    .split(',')
-                    .filter(Boolean),
-                // dependencies
-                // ...Object.keys(opts.pkg.devDependencies || {})
-                //   .concat(Object.keys(opts.pkg.dependencies || {}))
-                //   .filter(Plugin.isPluginOrPreset.bind(null, type)),
-                // user config
-                ...(opts.userConfig[types] || []),
-            ].map((path) => {
-                (0, assert_1.default)(typeof path === 'string', `Invalid plugin ${path}, it must be string.`);
-                let resolved;
-                try {
-                    resolved = utils_1.resolve.sync(path, {
-                        basedir: opts.cwd,
-                        extensions: ['.tsx', '.ts', '.mjs', '.jsx', '.js'],
-                    });
-                }
-                catch (_e) {
-                    throw new Error(`Invalid plugin ${path}, can not be resolved.`);
-                }
-                return new Plugin({
-                    path: resolved,
-                    type,
-                    cwd: opts.cwd,
-                });
-            });
+    return name;
+  }
+  static getPluginsAndPresets(opts) {
+    function get(type) {
+      const types = `${type}s`;
+      return [
+        ...opts[types] || [],
+        ...(process.env[`${opts.prefix}_${types}`.toUpperCase()] || "").split(",").filter(Boolean),
+        ...opts.userConfig[types] || []
+      ].map((path) => {
+        (0, import_assert.default)(typeof path === "string", `Invalid plugin ${path}, it must be string.`);
+        let resolved;
+        try {
+          resolved = import_utils.resolve.sync(path, {
+            basedir: opts.cwd,
+            extensions: [".tsx", ".ts", ".mjs", ".jsx", ".js"]
+          });
+        } catch (_e) {
+          throw new Error(`Invalid plugin ${path}, can not be resolved.`);
         }
-        return {
-            presets: get('preset'),
-            plugins: get('plugin'),
-        };
+        return new Plugin({
+          path: resolved,
+          type,
+          cwd: opts.cwd
+        });
+      });
     }
-}
-exports.Plugin = Plugin;
+    return {
+      presets: get("preset"),
+      plugins: get("plugin")
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Plugin
+});

package/dist/service/pluginAPI.js

@@ -1,167 +1,190 @@
-"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 __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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginAPI = void 0;
-const utils_1 = require("@umijs/utils");
-const assert_1 = __importDefault(require("assert"));
-const types_1 = require("../types");
-const command_1 = require("./command");
-const generator_1 = require("./generator");
-const hook_1 = require("./hook");
-const plugin_1 = require("./plugin");
-const utils_2 = require("./utils");
-const resolveConfigModes = ['strict', 'loose'];
-class PluginAPI {
-    constructor(opts) {
-        this.service = opts.service;
-        this.plugin = opts.plugin;
-        // logger
-        const loggerKeys = [
-            'wait',
-            'error',
-            'warn',
-            'ready',
-            'info',
-            'event',
-        ];
-        // @ts-ignore
-        this.logger = loggerKeys.reduce((memo, key) => {
-            // @ts-ignore
-            memo[key] = (...message) => {
-                // @ts-ignore
-                utils_1.logger[key](utils_1.chalk.green(`[plugin: ${this.plugin.id}]`), ...message);
-            };
-            return memo;
-        }, {});
+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);
+
+// pluginAPI.ts
+var pluginAPI_exports = {};
+__export(pluginAPI_exports, {
+  PluginAPI: () => PluginAPI
+});
+module.exports = __toCommonJS(pluginAPI_exports);
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_types = require("../types");
+var import_command = require("./command");
+var import_generator = require("./generator");
+var import_hook = require("./hook");
+var import_plugin = require("./plugin");
+var import_utils2 = require("./utils");
+var resolveConfigModes = ["strict", "loose"];
+var PluginAPI = class {
+  constructor(opts) {
+    this.service = opts.service;
+    this.plugin = opts.plugin;
+    const loggerKeys = [
+      "wait",
+      "error",
+      "warn",
+      "ready",
+      "info",
+      "event",
+      "debug"
+    ];
+    this.logger = loggerKeys.reduce((memo, key) => {
+      memo[key] = (...message) => {
+        import_utils.logger[key](import_utils.chalk.green(`[plugin: ${this.plugin.id}]`), ...message);
+      };
+      return memo;
+    }, {});
+  }
+  describe(opts) {
+    var _a;
+    if (opts.enableBy === import_types.EnableBy.config && ((_a = opts.config) == null ? void 0 : _a.default)) {
+      throw new Error(`[plugin: ${this.plugin.id}] The config.default is not allowed when enableBy is EnableBy.config.`);
     }
-    describe(opts) {
-        var _a;
-        // default 值 + 配置开启冲突，会导致就算用户没有配 key，插件也会生效
-        if (opts.enableBy === types_1.EnableBy.config && ((_a = opts.config) === null || _a === void 0 ? void 0 : _a.default)) {
-            throw new Error(`[plugin: ${this.plugin.id}] The config.default is not allowed when enableBy is EnableBy.config.`);
-        }
-        this.plugin.merge(opts);
+    this.plugin.merge(opts);
+  }
+  registerCommand(opts) {
+    const { alias } = opts;
+    delete opts.alias;
+    const registerCommand = (commandOpts) => {
+      var _a;
+      const { name, configResolveMode } = commandOpts;
+      (0, import_assert.default)(!configResolveMode || resolveConfigModes.indexOf(configResolveMode) >= 0, `configResolveMode must be one of ${resolveConfigModes.join(",")}, but got ${configResolveMode}`);
+      (0, import_assert.default)(!this.service.commands[name], `api.registerCommand() failed, the command ${name} is exists from ${(_a = this.service.commands[name]) == null ? void 0 : _a.plugin.id}.`);
+      this.service.commands[name] = new import_command.Command(__spreadProps(__spreadValues({}, commandOpts), {
+        plugin: this.plugin
+      }));
+    };
+    registerCommand(opts);
+    if (alias) {
+      const aliases = (0, import_utils2.makeArray)(alias);
+      aliases.forEach((alias2) => {
+        registerCommand(__spreadProps(__spreadValues({}, opts), { name: alias2 }));
+      });
     }
-    registerCommand(opts) {
-        const { alias } = opts;
-        delete opts.alias;
-        const registerCommand = (commandOpts) => {
-            var _a;
-            const { name, configResolveMode } = commandOpts;
-            (0, assert_1.default)(!configResolveMode ||
-                resolveConfigModes.indexOf(configResolveMode) >= 0, `configResolveMode must be one of ${resolveConfigModes.join(',')}, but got ${configResolveMode}`);
-            (0, assert_1.default)(!this.service.commands[name], `api.registerCommand() failed, the command ${name} is exists from ${(_a = this.service.commands[name]) === null || _a === void 0 ? void 0 : _a.plugin.id}.`);
-            this.service.commands[name] = new command_1.Command({
-                ...commandOpts,
-                plugin: this.plugin,
-            });
-        };
-        registerCommand(opts);
-        if (alias) {
-            const aliases = (0, utils_2.makeArray)(alias);
-            aliases.forEach((alias) => {
-                registerCommand({ ...opts, name: alias });
-            });
-        }
-    }
-    registerGenerator(opts) {
-        var _a;
-        const { key } = opts;
-        (0, assert_1.default)(!this.service.generators[key], `api.registerGenerator() failed, the generator ${key} is exists from ${(_a = this.service.generators[key]) === null || _a === void 0 ? void 0 : _a.plugin.id}.`);
-        this.service.generators[key] = (0, generator_1.makeGenerator)({
-            ...opts,
-            plugin: this.plugin,
+  }
+  registerGenerator(opts) {
+    var _a;
+    const { key } = opts;
+    (0, import_assert.default)(!this.service.generators[key], `api.registerGenerator() failed, the generator ${key} is exists from ${(_a = this.service.generators[key]) == null ? void 0 : _a.plugin.id}.`);
+    this.service.generators[key] = (0, import_generator.makeGenerator)(__spreadProps(__spreadValues({}, opts), {
+      plugin: this.plugin
+    }));
+  }
+  register(opts) {
+    var _a, _b;
+    (0, import_assert.default)(this.service.stage <= import_types.ServiceStage.initPlugins, "api.register() should not be called after plugin register stage.");
+    (_a = this.service.hooks)[_b = opts.key] || (_a[_b] = []);
+    this.service.hooks[opts.key].push(new import_hook.Hook(__spreadProps(__spreadValues({}, opts), { plugin: this.plugin })));
+  }
+  registerMethod(opts) {
+    (0, import_assert.default)(!this.service.pluginMethods[opts.name], `api.registerMethod() failed, method ${opts.name} is already exist.`);
+    this.service.pluginMethods[opts.name] = {
+      plugin: this.plugin,
+      fn: opts.fn || function(fn) {
+        this.register(__spreadValues({
+          key: opts.name
+        }, import_utils.lodash.isPlainObject(fn) ? fn : { fn }));
+      }
+    };
+  }
+  registerPresets(source, presets) {
+    (0, import_assert.default)(this.service.stage === import_types.ServiceStage.initPresets, `api.registerPresets() failed, it should only used in presets.`);
+    source.splice(0, 0, ...presets.map((preset) => {
+      return new import_plugin.Plugin({
+        path: preset,
+        cwd: this.service.cwd,
+        type: import_types.PluginType.preset
+      });
+    }));
+  }
+  registerPlugins(source, plugins) {
+    (0, import_assert.default)(this.service.stage === import_types.ServiceStage.initPresets || this.service.stage === import_types.ServiceStage.initPlugins, `api.registerPlugins() failed, it should only be used in registering stage.`);
+    const mappedPlugins = plugins.map((plugin) => {
+      if (import_utils.lodash.isPlainObject(plugin)) {
+        (0, import_assert.default)(plugin.id && plugin.key, `Invalid plugin object, id and key must supplied.`);
+        plugin.type = import_types.PluginType.plugin;
+        plugin.enableBy = plugin.enableBy || import_types.EnableBy.register;
+        plugin.apply = plugin.apply || (() => () => {
         });
-    }
-    register(opts) {
-        var _a, _b;
-        (0, assert_1.default)(this.service.stage <= types_1.ServiceStage.initPlugins, 'api.register() should not be called after plugin register stage.');
-        (_a = this.service.hooks)[_b = opts.key] || (_a[_b] = []);
-        this.service.hooks[opts.key].push(new hook_1.Hook({ ...opts, plugin: this.plugin }));
-    }
-    registerMethod(opts) {
-        (0, assert_1.default)(!this.service.pluginMethods[opts.name], `api.registerMethod() failed, method ${opts.name} is already exist.`);
-        this.service.pluginMethods[opts.name] = {
-            plugin: this.plugin,
-            fn: opts.fn ||
-                // 这里不能用 arrow function，this 需指向执行此方法的 PluginAPI
-                // 否则 pluginId 会不会，导致不能正确 skip plugin
-                function (fn) {
-                    // @ts-ignore
-                    this.register({
-                        key: opts.name,
-                        ...(utils_1.lodash.isPlainObject(fn) ? fn : { fn }),
-                    });
-                },
-        };
-    }
-    registerPresets(source, presets) {
-        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets, `api.registerPresets() failed, it should only used in presets.`);
-        source.splice(0, 0, ...presets.map((preset) => {
-            return new plugin_1.Plugin({
-                path: preset,
-                cwd: this.service.cwd,
-                type: types_1.PluginType.preset,
-            });
-        }));
-    }
-    registerPlugins(source, plugins) {
-        (0, assert_1.default)(this.service.stage === types_1.ServiceStage.initPresets ||
-            this.service.stage === types_1.ServiceStage.initPlugins, `api.registerPlugins() failed, it should only be used in registering stage.`);
-        const mappedPlugins = plugins.map((plugin) => {
-            if (utils_1.lodash.isPlainObject(plugin)) {
-                (0, assert_1.default)(plugin.id && plugin.key, `Invalid plugin object, id and key must supplied.`);
-                plugin.type = types_1.PluginType.plugin;
-                plugin.enableBy = plugin.enableBy || types_1.EnableBy.register;
-                plugin.apply = plugin.apply || (() => () => { });
-                plugin.config = plugin.config || {};
-                plugin.time = { hooks: {} };
-                return plugin;
-            }
-            else {
-                return new plugin_1.Plugin({
-                    path: plugin,
-                    cwd: this.service.cwd,
-                    type: types_1.PluginType.plugin,
-                });
-            }
+        plugin.config = plugin.config || {};
+        plugin.time = { hooks: {} };
+        return plugin;
+      } else {
+        return new import_plugin.Plugin({
+          path: plugin,
+          cwd: this.service.cwd,
+          type: import_types.PluginType.plugin
         });
-        if (this.service.stage === types_1.ServiceStage.initPresets) {
-            source.push(...mappedPlugins);
+      }
+    });
+    if (this.service.stage === import_types.ServiceStage.initPresets) {
+      source.push(...mappedPlugins);
+    } else {
+      source.splice(0, 0, ...mappedPlugins);
+    }
+  }
+  skipPlugins(keys) {
+    keys.forEach((key) => {
+      (0, import_assert.default)(!(this.plugin.key === key), `plugin ${key} can't skip itself!`);
+      (0, import_assert.default)(this.service.keyToPluginMap[key], `key: ${key} is not be registered by any plugin. You can't skip it!`);
+      this.service.skipPluginIds.add(this.service.keyToPluginMap[key].id);
+    });
+  }
+  static proxyPluginAPI(opts) {
+    return new Proxy(opts.pluginAPI, {
+      get: (target, prop) => {
+        if (opts.service.pluginMethods[prop]) {
+          return opts.service.pluginMethods[prop].fn;
         }
-        else {
-            source.splice(0, 0, ...mappedPlugins);
+        if (opts.serviceProps.includes(prop)) {
+          const serviceProp = opts.service[prop];
+          return typeof serviceProp === "function" ? serviceProp.bind(opts.service) : serviceProp;
         }
-    }
-    skipPlugins(keys) {
-        keys.forEach((key) => {
-            (0, assert_1.default)(!(this.plugin.key === key), `plugin ${key} can't skip itself!`);
-            (0, assert_1.default)(this.service.keyToPluginMap[key], `key: ${key} is not be registered by any plugin. You can't skip it!`);
-            this.service.skipPluginIds.add(this.service.keyToPluginMap[key].id);
-        });
-    }
-    static proxyPluginAPI(opts) {
-        return new Proxy(opts.pluginAPI, {
-            get: (target, prop) => {
-                if (opts.service.pluginMethods[prop]) {
-                    return opts.service.pluginMethods[prop].fn;
-                }
-                if (opts.serviceProps.includes(prop)) {
-                    // @ts-ignore
-                    const serviceProp = opts.service[prop];
-                    return typeof serviceProp === 'function'
-                        ? serviceProp.bind(opts.service)
-                        : serviceProp;
-                }
-                if (prop in opts.staticProps) {
-                    return opts.staticProps[prop];
-                }
-                // @ts-ignore
-                return target[prop];
-            },
-        });
-    }
-}
-exports.PluginAPI = PluginAPI;
+        if (prop in opts.staticProps) {
+          return opts.staticProps[prop];
+        }
+        return target[prop];
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginAPI
+});