@umijs/preset-umi 4.0.13 → 4.0.16

package/dist/commands/build.js

@@ -117,12 +117,16 @@ umi build --clean
           args
         });
       };
+      const entry = await api.applyPlugins({
+        key: "modifyEntry",
+        initialValue: {
+          umi: (0, import_path.join)(api.paths.absTmpPath, "umi.ts")
+        }
+      });
       const opts = __spreadProps(__spreadValues({
         config: api.config,
         cwd: api.cwd,
-        entry: {
-          umi: (0, import_path.join)(api.paths.absTmpPath, "umi.ts")
-        }
+        entry
       }, api.config.vite ? { modifyViteConfig } : { babelPreset, chainWebpack, modifyWebpackConfig }), {
         beforeBabelPlugins,
         beforeBabelPresets,
@@ -143,20 +147,22 @@ umi build --clean
       } else {
         stats = await bundlerWebpack.build(opts);
       }
-      const assetsMap = api.config.vite ? {} : (0, import_getAssetsMap.getAssetsMap)({
-        stats,
-        publicPath: api.config.publicPath
-      });
-      const { vite } = api.args;
-      const markupArgs = await (0, import_getMarkupArgs.getMarkupArgs)({ api });
-      const markup = await (0, import_server.getMarkup)(__spreadProps(__spreadValues({}, markupArgs), {
-        styles: markupArgs.styles.concat(api.config.vite ? [] : assetsMap["umi.css"] || []),
-        scripts: (api.config.vite ? [] : assetsMap["umi.js"] || []).concat(markupArgs.scripts),
-        esmScript: !!opts.config.esm || vite,
-        path: "/"
-      }));
-      (0, import_fs.writeFileSync)((0, import_path.join)(api.paths.absOutputPath, "index.html"), markup, "utf-8");
-      import_utils.logger.event("Build index.html");
+      if (!api.config.mpa) {
+        const assetsMap = api.config.vite ? {} : (0, import_getAssetsMap.getAssetsMap)({
+          stats,
+          publicPath: api.config.publicPath
+        });
+        const { vite } = api.args;
+        const markupArgs = await (0, import_getMarkupArgs.getMarkupArgs)({ api });
+        const markup = await (0, import_server.getMarkup)(__spreadProps(__spreadValues({}, markupArgs), {
+          styles: markupArgs.styles.concat(api.config.vite ? [] : assetsMap["umi.css"] || []),
+          scripts: (api.config.vite ? [] : assetsMap["umi.js"] || []).concat(markupArgs.scripts),
+          esmScript: !!opts.config.esm || vite,
+          path: "/"
+        }));
+        (0, import_fs.writeFileSync)((0, import_path.join)(api.paths.absOutputPath, "index.html"), markup, "utf-8");
+        import_utils.logger.event("Build index.html");
+      }
       await api.applyPlugins({
         key: "onBuildHtmlComplete",
         args: opts

package/dist/commands/dev/depBuildWorker/depBuildWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/dev/depBuildWorker/depBuildWorker.js

@@ -0,0 +1,107 @@
+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 __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));
+
+// src/commands/dev/depBuildWorker/depBuildWorker.ts
+var import_bundler_webpack = require("@umijs/bundler-webpack");
+var import_constants = require("@umijs/bundler-webpack/dist/constants");
+var import_types = require("@umijs/bundler-webpack/dist/types");
+var import_mfsu = require("@umijs/mfsu");
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_worker_threads = require("worker_threads");
+var import_depBuilder = require("./depBuilder");
+var import_getConfig = require("./getConfig");
+if (import_worker_threads.isMainThread) {
+  throw Error("MFSU-eager builder can only be called in a worker thread");
+}
+var bundlerWebpackPath = (0, import_path.dirname)(require.resolve("@umijs/bundler-webpack"));
+var bufferedRequest = [];
+async function start() {
+  var _a, _b, _c, _d, _e, _f, _g;
+  let builder = null;
+  function build(deps) {
+    import_utils.logger.info("[MFSU][eager] build worker start to build");
+    return builder.build({ deps }).catch((e) => {
+      import_utils.logger.error("[MFSU][eager] build worker failed", e);
+      import_worker_threads.parentPort.postMessage({ error: e });
+    });
+  }
+  function scheduleBuild() {
+    if (builder && !builder.isBuilding) {
+      const buildReq = bufferedRequest.shift();
+      if (buildReq) {
+        build(buildReq).finally(() => {
+          scheduleBuild();
+        });
+      }
+    }
+  }
+  import_worker_threads.parentPort.on("message", (buildReq) => {
+    bufferedRequest.push(buildReq);
+    scheduleBuild();
+  });
+  const start2 = Date.now();
+  const opts = await (0, import_getConfig.getDevConfig)();
+  const cacheDirectoryPath = (0, import_path.resolve)(opts.rootDir || opts.cwd, opts.config.cacheDirectoryPath || "node_modules/.cache");
+  const depConfig = await (0, import_bundler_webpack.getConfig)({
+    cwd: opts.cwd,
+    rootDir: opts.rootDir,
+    env: import_types.Env.development,
+    entry: opts.entry,
+    userConfig: opts.config,
+    hash: true,
+    staticPathPrefix: import_mfsu.MF_DEP_PREFIX,
+    name: import_constants.MFSU_NAME,
+    chainWebpack: (_a = opts.config.mfsu) == null ? void 0 : _a.chainWebpack,
+    extraBabelIncludes: opts.config.extraBabelIncludes,
+    cache: {
+      buildDependencies: (_b = opts.cache) == null ? void 0 : _b.buildDependencies,
+      cacheDirectory: (0, import_path.join)(cacheDirectoryPath, "mfsu-deps")
+    },
+    pkg: opts.pkg
+  });
+  (_c = depConfig.resolve).alias || (_c.alias = {});
+  ["@umijs/utils/compiled/strip-ansi", "react-error-overlay"].forEach((dep) => {
+    depConfig.resolve.alias[dep] = require.resolve(dep, {
+      paths: [bundlerWebpackPath]
+    });
+  });
+  const depEsBuildConfig = {
+    extraPostCSSPlugins: ((_d = opts.config) == null ? void 0 : _d.extraPostCSSPlugins) || []
+  };
+  const tmpBase = ((_e = opts.config.mfsu) == null ? void 0 : _e.cacheDirectory) || (0, import_path.join)(cacheDirectoryPath, "mfsu");
+  const externals = makeArray(opts.config.externals || []);
+  builder = new import_depBuilder.DepBuilderInWorker({
+    depConfig,
+    cwd: opts.cwd,
+    tmpBase,
+    mfName: ((_f = opts.config.mfsu) == null ? void 0 : _f.mfName) || import_mfsu.DEFAULT_MF_NAME,
+    shared: ((_g = opts.config.mfsu) == null ? void 0 : _g.shared) || {},
+    buildDepWithESBuild: false,
+    depEsBuildConfig,
+    externals
+  });
+  import_utils.logger.info("[MFSU][eager] worker init, takes", Date.now() - start2);
+  scheduleBuild();
+}
+start().catch((e) => {
+  import_utils.logger.error("[MFSU][eager] build worker start failed", e);
+});
+function makeArray(a) {
+  if (Array.isArray(a))
+    return a;
+  return [a];
+}

package/dist/commands/dev/depBuildWorker/depBuilder.d.ts

@@ -0,0 +1,37 @@
+import webpack from '@umijs/bundler-webpack/compiled/webpack';
+import { Dep } from '@umijs/mfsu/dist/dep/dep';
+declare type IOpts = {
+    depConfig: webpack.Configuration;
+    cwd: string;
+    tmpBase: string;
+    mfName: string;
+    shared: any;
+    buildDepWithESBuild: boolean;
+    depEsBuildConfig: any;
+    externals: any[];
+};
+export declare class DepBuilderInWorker {
+    completeFns: Function[];
+    isBuilding: boolean;
+    opts: IOpts;
+    constructor(opts: IOpts);
+    buildWithWebpack(opts: {
+        onBuildComplete: Function;
+        deps: Dep[];
+    }): Promise<unknown>;
+    buildWithESBuild(opts: {
+        onBuildComplete: Function;
+        deps: Dep[];
+    }): Promise<void>;
+    build(opts: {
+        deps: Dep[];
+    }): Promise<void>;
+    onBuildComplete(fn: Function): void;
+    writeMFFiles(opts: {
+        deps: Dep[];
+    }): Promise<void>;
+    getWebpackConfig(opts: {
+        deps: Dep[];
+    }): webpack.Configuration;
+}
+export {};

package/dist/commands/dev/depBuildWorker/depBuilder.js

@@ -0,0 +1,210 @@
+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);
+
+// src/commands/dev/depBuildWorker/depBuilder.ts
+var depBuilder_exports = {};
+__export(depBuilder_exports, {
+  DepBuilderInWorker: () => DepBuilderInWorker
+});
+module.exports = __toCommonJS(depBuilder_exports);
+var import_bundler_esbuild = require("@umijs/bundler-esbuild");
+var import_webpack = __toESM(require("@umijs/bundler-webpack/compiled/webpack"));
+var import_mfsu = require("@umijs/mfsu");
+var import_dep = require("@umijs/mfsu/dist/dep/dep");
+var import_getESBuildEntry = require("@umijs/mfsu/dist/depBuilder/getESBuildEntry");
+var import_depChunkIdPrefixPlugin = require("@umijs/mfsu/dist/webpackPlugins/depChunkIdPrefixPlugin");
+var import_stripSourceMapUrlPlugin = require("@umijs/mfsu/dist/webpackPlugins/stripSourceMapUrlPlugin");
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_worker_threads = require("worker_threads");
+var DepBuilderInWorker = class {
+  constructor(opts) {
+    this.completeFns = [];
+    this.isBuilding = false;
+    this.opts = opts;
+  }
+  async buildWithWebpack(opts) {
+    const config = this.getWebpackConfig({ deps: opts.deps });
+    return new Promise((resolve, reject) => {
+      const compiler = (0, import_webpack.default)(config);
+      compiler.run((err, stats) => {
+        opts.onBuildComplete();
+        if (err || (stats == null ? void 0 : stats.hasErrors())) {
+          if (err) {
+            reject(err);
+          }
+          if (stats) {
+            const errorMsg = stats.toString("errors-only");
+            reject(new Error(errorMsg));
+          }
+        } else {
+          resolve(stats);
+        }
+        compiler.close(() => {
+        });
+      });
+    });
+  }
+  async buildWithESBuild(opts) {
+    var _a;
+    const alias = __spreadValues({}, (_a = this.opts.depConfig.resolve) == null ? void 0 : _a.alias);
+    const externals = this.opts.depConfig.externals;
+    const entryContent = (0, import_getESBuildEntry.getESBuildEntry)({ deps: opts.deps });
+    const ENTRY_FILE = "esbuild-entry.js";
+    const tmpDir = this.opts.tmpBase;
+    const entryPath = (0, import_path.join)(tmpDir, ENTRY_FILE);
+    (0, import_fs.writeFileSync)(entryPath, entryContent, "utf-8");
+    const date = new Date().getTime();
+    await (0, import_bundler_esbuild.build)({
+      cwd: this.opts.cwd,
+      entry: {
+        [`${import_mfsu.MF_VA_PREFIX}remoteEntry`]: entryPath
+      },
+      config: __spreadProps(__spreadValues({}, this.opts.depEsBuildConfig), {
+        outputPath: tmpDir,
+        alias,
+        externals
+      }),
+      inlineStyle: true
+    });
+    import_utils.logger.event(`[mfsu] compiled with esbuild successfully in ${+new Date() - date} ms`);
+    opts.onBuildComplete();
+  }
+  async build(opts) {
+    this.isBuilding = true;
+    const onBuildComplete = () => {
+      this.isBuilding = false;
+      import_worker_threads.parentPort.postMessage({
+        done: true
+      });
+    };
+    try {
+      await this.writeMFFiles({ deps: opts.deps.map((d) => new import_dep.Dep(d)) });
+      const newOpts = __spreadProps(__spreadValues({}, opts), {
+        onBuildComplete
+      });
+      if (this.opts.buildDepWithESBuild) {
+        await this.buildWithESBuild(newOpts);
+      } else {
+        await this.buildWithWebpack(newOpts);
+      }
+    } catch (e) {
+      onBuildComplete();
+      import_worker_threads.parentPort.postMessage({
+        error: e
+      });
+      throw e;
+    }
+  }
+  onBuildComplete(fn) {
+    if (this.isBuilding) {
+      this.completeFns.push(fn);
+    } else {
+      fn();
+    }
+  }
+  async writeMFFiles(opts) {
+    const tmpBase = this.opts.tmpBase;
+    import_utils.fsExtra.mkdirpSync(tmpBase);
+    for (const dep of opts.deps) {
+      const content = await dep.buildExposeContent();
+      (0, import_fs.writeFileSync)((0, import_path.join)(tmpBase, dep.filePath), content, "utf-8");
+    }
+    (0, import_fs.writeFileSync)((0, import_path.join)(tmpBase, "index.js"), '"\u{1F61B}"', "utf-8");
+  }
+  getWebpackConfig(opts) {
+    var _a, _b;
+    const mfName = this.opts.mfName;
+    const depConfig = import_utils.lodash.cloneDeep(this.opts.depConfig);
+    depConfig.entry = (0, import_path.join)(this.opts.tmpBase, "index.js");
+    depConfig.output.path = this.opts.tmpBase;
+    depConfig.output.publicPath = "auto";
+    depConfig.devtool = false;
+    if ((_a = depConfig.output) == null ? void 0 : _a.library)
+      delete depConfig.output.library;
+    if ((_b = depConfig.output) == null ? void 0 : _b.libraryTarget)
+      delete depConfig.output.libraryTarget;
+    depConfig.optimization || (depConfig.optimization = {});
+    depConfig.optimization.splitChunks = {
+      chunks: (chunk) => {
+        const hasShared = chunk.getModules().some((m) => {
+          return m.type === "consume-shared-module" || m.type === "provide-module" || m.type === "provide-shared-module";
+        });
+        return !hasShared;
+      },
+      maxInitialRequests: Infinity,
+      minSize: 0,
+      cacheGroups: {
+        vendor: {
+          test: /.+/,
+          name(_module, _chunks, cacheGroupKey) {
+            return `${import_mfsu.MF_DEP_PREFIX}___${cacheGroupKey}`;
+          }
+        }
+      }
+    };
+    depConfig.plugins = depConfig.plugins || [];
+    depConfig.plugins.push(new import_depChunkIdPrefixPlugin.DepChunkIdPrefixPlugin());
+    depConfig.plugins.push(new import_stripSourceMapUrlPlugin.StripSourceMapUrlPlugin({
+      webpack: import_webpack.default
+    }));
+    depConfig.plugins.push(new import_webpack.default.ProgressPlugin((percent, msg) => {
+      import_worker_threads.parentPort.postMessage({ progress: { percent, status: msg } });
+    }));
+    const exposes = opts.deps.reduce((memo, dep) => {
+      memo[`./${dep.file}`] = (0, import_path.join)(this.opts.tmpBase, dep.filePath);
+      return memo;
+    }, {});
+    depConfig.plugins.push(new import_webpack.default.container.ModuleFederationPlugin({
+      library: {
+        type: "global",
+        name: mfName
+      },
+      name: mfName,
+      filename: import_mfsu.REMOTE_FILE_FULL,
+      exposes,
+      shared: this.opts.shared || {}
+    }));
+    return depConfig;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DepBuilderInWorker
+});

package/dist/commands/dev/depBuildWorker/dev-config.d.ts

@@ -0,0 +1,3 @@
+import { IApi } from '../../../types';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/commands/dev/depBuildWorker/dev-config.js

@@ -0,0 +1,124 @@
+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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/dev/depBuildWorker/dev-config.ts
+var dev_config_exports = {};
+__export(dev_config_exports, {
+  default: () => dev_config_default
+});
+module.exports = __toCommonJS(dev_config_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_getBabelOpts = require("../getBabelOpts");
+var MFSU_EAGER_DEFAULT_INCLUDE = [
+  "react",
+  "react-error-overlay",
+  "react/jsx-dev-runtime",
+  "@umijs/utils/compiled/strip-ansi"
+];
+var dev_config_default = (api) => {
+  api.describe({
+    enableBy() {
+      return api.name === "dev-config";
+    },
+    key: "dev-config"
+  });
+  api.registerCommand({
+    name: "dev-config",
+    description: "dev server for development",
+    details: ``,
+    async fn() {
+      var _a, _b, _c;
+      const {
+        babelPreset,
+        beforeBabelPlugins,
+        beforeBabelPresets,
+        extraBabelPlugins,
+        extraBabelPresets
+      } = await (0, import_getBabelOpts.getBabelOpts)({ api });
+      const chainWebpack = async (memo, args) => {
+        await api.applyPlugins({
+          key: "chainWebpack",
+          type: api.ApplyPluginsType.modify,
+          initialValue: memo,
+          args
+        });
+      };
+      const modifyWebpackConfig = async (memo, args) => {
+        return await api.applyPlugins({
+          key: "modifyWebpackConfig",
+          initialValue: memo,
+          args
+        });
+      };
+      const entry = await api.applyPlugins({
+        key: "modifyEntry",
+        initialValue: {
+          umi: (0, import_path.join)(api.paths.absTmpPath, "umi.ts")
+        }
+      });
+      const opts = __spreadProps(__spreadValues({
+        config: api.config,
+        pkg: api.pkg,
+        cwd: api.cwd,
+        rootDir: process.cwd(),
+        entry,
+        port: api.appData.port,
+        host: api.appData.host,
+        ip: api.appData.ip
+      }, { babelPreset, chainWebpack, modifyWebpackConfig }), {
+        beforeBabelPlugins,
+        beforeBabelPresets,
+        extraBabelPlugins,
+        extraBabelPresets,
+        mfsuWithESBuild: (_a = api.config.mfsu) == null ? void 0 : _a.esbuild,
+        mfsuStrategy: (_b = api.config.mfsu) == null ? void 0 : _b.strategy,
+        cache: {
+          buildDependencies: [
+            api.pkgPath,
+            api.service.configManager.mainConfigFile || ""
+          ].filter(Boolean)
+        },
+        mfsuInclude: import_utils.lodash.union([
+          ...MFSU_EAGER_DEFAULT_INCLUDE,
+          ...((_c = api.config.mfsu) == null ? void 0 : _c.include) || []
+        ])
+      });
+      return opts;
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/commands/dev/depBuildWorker/getConfig.d.ts

@@ -0,0 +1 @@
+export declare function getDevConfig(): Promise<any>;

package/dist/commands/dev/depBuildWorker/getConfig.js

@@ -0,0 +1,42 @@
+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);
+
+// src/commands/dev/depBuildWorker/getConfig.ts
+var getConfig_exports = {};
+__export(getConfig_exports, {
+  getDevConfig: () => getDevConfig
+});
+module.exports = __toCommonJS(getConfig_exports);
+var import_service = require("umi/dist/service/service");
+async function getDevConfig() {
+  const service = new import_service.Service({
+    presets: [require.resolve("./workerPreset")]
+  });
+  const opts = await service.run({
+    name: "dev-config",
+    args: []
+  });
+  return opts;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDevConfig
+});

package/dist/commands/dev/depBuildWorker/workerPreset.d.ts

@@ -0,0 +1,4 @@
+declare const _default: () => {
+    plugins: string[];
+};
+export default _default;

package/dist/commands/dev/depBuildWorker/workerPreset.js

@@ -0,0 +1,34 @@
+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);
+
+// src/commands/dev/depBuildWorker/workerPreset.ts
+var workerPreset_exports = {};
+__export(workerPreset_exports, {
+  default: () => workerPreset_default
+});
+module.exports = __toCommonJS(workerPreset_exports);
+var workerPreset_default = () => {
+  return {
+    plugins: [require.resolve("./dev-config")]
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});