umi 4.3.21 → 4.3.23

package/dist/cli/cli.d.ts

@@ -0,0 +1,5 @@
+interface IOpts {
+    presets?: string[];
+}
+export declare function run(opts?: IOpts): Promise<void>;
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,70 @@
+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);
+
+// 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);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): void;

package/dist/cli/dev.js

@@ -0,0 +1,52 @@
+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(
+  // 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, 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);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev
+});

package/dist/cli/fork.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+interface IOpts {
+    scriptPath: string;
+}
+export default function start({ scriptPath }: IOpts): import("child_process").ChildProcess;
+export {};

package/dist/cli/fork.js

@@ -0,0 +1,90 @@
+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);
+
+// src/cli/fork.ts
+var fork_exports = {};
+__export(fork_exports, {
+  default: () => start
+});
+module.exports = __toCommonJS(fork_exports);
+var import_child_process = require("child_process");
+var import_utils = require("@umijs/utils");
+var usedPorts = [];
+function start({ scriptPath }) {
+  const execArgv = process.execArgv.slice(0);
+  const inspectArgvIndex = execArgv.findIndex(
+    (argv) => argv.includes("--inspect-brk")
+  );
+  if (inspectArgvIndex > -1) {
+    const inspectArgv = execArgv[inspectArgvIndex];
+    execArgv.splice(
+      inspectArgvIndex,
+      1,
+      inspectArgv.replace(/--inspect-brk=(.*)/, (_match, s1) => {
+        let port;
+        try {
+          port = parseInt(s1) + 1;
+        } catch (e) {
+          port = 9230;
+        }
+        if (usedPorts.includes(port)) {
+          port += 1;
+        }
+        usedPorts.push(port);
+        return `--inspect-brk=${port}`;
+      })
+    );
+  }
+  const child = (0, import_child_process.fork)(scriptPath, process.argv.slice(2), { execArgv });
+  child.on("message", (data) => {
+    var _a;
+    const { type, payload } = data || {};
+    if (type === "RESTART") {
+      child.kill();
+      if (payload == null ? void 0 : payload.port) {
+        utilPortValid(payload.port, 20, () => {
+          process.env.PORT = payload.port;
+          start({ scriptPath });
+        });
+      } else {
+        start({ scriptPath });
+      }
+    }
+    (_a = process.send) == null ? void 0 : _a.call(process, data);
+  });
+  return child;
+}
+function utilPortValid(port, totalTry, callback) {
+  import_utils.portfinder.getPort({ startPort: port }, (err, findPort) => {
+    if (err)
+      callback(err);
+    else {
+      if (findPort === port) {
+        callback();
+      } else {
+        if (totalTry > 0) {
+          setTimeout(() => {
+            utilPortValid(port, totalTry - 1, callback);
+          }, 100);
+        } else {
+          callback(new Error(`Port ${port} is occupied`));
+        }
+      }
+    }
+  });
+}

package/dist/cli/forkedDev.d.ts

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

package/dist/cli/forkedDev.js

@@ -0,0 +1,36 @@
+// src/cli/forkedDev.ts
+var import_utils = require("@umijs/utils");
+var import_constants = require("../constants");
+var import_service = require("../service/service");
+(0, import_utils.setNodeTitle)(`${import_constants.FRAMEWORK_NAME}-dev`);
+(0, import_utils.setNoDeprecation)();
+(async () => {
+  try {
+    let onSignal = function(signal) {
+      if (closed)
+        return;
+      closed = true;
+      service.applyPlugins({
+        key: "onExit",
+        args: {
+          signal
+        }
+      });
+      process.exit(0);
+    };
+    const args = (0, import_utils.yParser)(process.argv.slice(2));
+    const service = new import_service.Service();
+    await service.run2({
+      name: import_constants.DEV_COMMAND,
+      args
+    });
+    let closed = false;
+    process.once("SIGINT", () => onSignal("SIGINT"));
+    process.once("SIGQUIT", () => onSignal("SIGQUIT"));
+    process.once("SIGTERM", () => onSignal("SIGTERM"));
+  } catch (e) {
+    import_utils.logger.fatal(e);
+    import_utils.printHelp.exit();
+    process.exit(1);
+  }
+})();

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MIN_NODE_VERSION = 14;
+export declare const DEV_COMMAND = "dev";
+export declare const FRAMEWORK_NAME: string;
+export declare const DEFAULT_CONFIG_FILES: string[];
+export declare const RUNTIME_TYPE_FILE_NAME = "runtimeConfig.d.ts";

package/dist/constants.js

@@ -0,0 +1,46 @@
+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);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_CONFIG_FILES: () => DEFAULT_CONFIG_FILES,
+  DEV_COMMAND: () => DEV_COMMAND,
+  FRAMEWORK_NAME: () => FRAMEWORK_NAME,
+  MIN_NODE_VERSION: () => MIN_NODE_VERSION,
+  RUNTIME_TYPE_FILE_NAME: () => RUNTIME_TYPE_FILE_NAME
+});
+module.exports = __toCommonJS(constants_exports);
+var MIN_NODE_VERSION = 14;
+var DEV_COMMAND = "dev";
+var FRAMEWORK_NAME = process.env.FRAMEWORK_NAME || "umi";
+var DEFAULT_CONFIG_FILES = [
+  `.${FRAMEWORK_NAME}rc.ts`,
+  `.${FRAMEWORK_NAME}rc.js`,
+  "config/config.ts",
+  "config/config.js"
+];
+var RUNTIME_TYPE_FILE_NAME = "runtimeConfig.d.ts";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG_FILES,
+  DEV_COMMAND,
+  FRAMEWORK_NAME,
+  MIN_NODE_VERSION,
+  RUNTIME_TYPE_FILE_NAME
+});

package/dist/defineConfig.d.ts

@@ -0,0 +1,10 @@
+import { IConfigFromPlugins } from '@@/core/pluginConfig';
+import type { IConfig } from '@umijs/preset-umi';
+declare type ConfigType = IConfigFromPlugins & IConfig;
+/**
+ * 通过方法的方式配置umi，能带来更好的 typescript 体验
+ * @param  {ConfigType} config
+ * @returns ConfigType
+ */
+export declare function defineConfig(config: ConfigType): ConfigType;
+export {};

package/dist/defineConfig.js

@@ -0,0 +1,31 @@
+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);
+
+// src/defineConfig.ts
+var defineConfig_exports = {};
+__export(defineConfig_exports, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(defineConfig_exports);
+function defineConfig(config) {
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig
+});

package/dist/defineMock.d.ts

@@ -0,0 +1,8 @@
+import type { RequestHandler } from '@umijs/bundler-webpack/compiled/express';
+declare type MockDeclare = string | number | null | undefined | boolean | Record<string, any> | RequestHandler;
+export declare function defineMock(mockData: {
+    [key: string]: MockDeclare;
+}): {
+    [key: string]: MockDeclare;
+};
+export {};

package/dist/defineMock.js

@@ -0,0 +1,31 @@
+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);
+
+// src/defineMock.ts
+var defineMock_exports = {};
+__export(defineMock_exports, {
+  defineMock: () => defineMock
+});
+module.exports = __toCommonJS(defineMock_exports);
+function defineMock(mockData) {
+  return mockData;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineMock
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { IServicePluginAPI, PluginAPI } from '@umijs/core';
+export { run } from './cli/cli';
+export { RUNTIME_TYPE_FILE_NAME } from './constants';
+export { defineConfig } from './defineConfig';
+export { defineMock } from './defineMock';
+export * from './service/service';
+export declare type IApi = PluginAPI & IServicePluginAPI;

package/dist/index.js

@@ -0,0 +1,41 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RUNTIME_TYPE_FILE_NAME: () => import_constants.RUNTIME_TYPE_FILE_NAME,
+  defineConfig: () => import_defineConfig.defineConfig,
+  defineMock: () => import_defineMock.defineMock,
+  run: () => import_cli.run
+});
+module.exports = __toCommonJS(src_exports);
+var import_cli = require("./cli/cli");
+var import_constants = require("./constants");
+var import_defineConfig = require("./defineConfig");
+var import_defineMock = require("./defineMock");
+__reExport(src_exports, require("./service/service"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNTIME_TYPE_FILE_NAME,
+  defineConfig,
+  defineMock,
+  run,
+  ...require("./service/service")
+});

package/dist/pluginUtils.d.ts

@@ -0,0 +1,5 @@
+import express from '@umijs/bundler-utils/compiled/express';
+import * as httpProxyMiddleware from '@umijs/bundler-utils/compiled/http-proxy-middleware';
+export { createServerRoutes } from '@umijs/server';
+export * from '@umijs/utils';
+export { httpProxyMiddleware, express };

package/dist/pluginUtils.js

@@ -0,0 +1,48 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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/pluginUtils.ts
+var pluginUtils_exports = {};
+__export(pluginUtils_exports, {
+  createServerRoutes: () => import_server.createServerRoutes,
+  express: () => import_express.default,
+  httpProxyMiddleware: () => httpProxyMiddleware
+});
+module.exports = __toCommonJS(pluginUtils_exports);
+var import_express = __toESM(require("@umijs/bundler-utils/compiled/express"));
+var httpProxyMiddleware = __toESM(require("@umijs/bundler-utils/compiled/http-proxy-middleware"));
+var import_server = require("@umijs/server");
+__reExport(pluginUtils_exports, require("@umijs/utils"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerRoutes,
+  express,
+  httpProxyMiddleware,
+  ...require("@umijs/utils")
+});

package/dist/service/cwd.d.ts

@@ -0,0 +1 @@
+export declare function getCwd(): string;

package/dist/service/cwd.js

@@ -0,0 +1,37 @@
+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);
+
+// src/service/cwd.ts
+var cwd_exports = {};
+__export(cwd_exports, {
+  getCwd: () => getCwd
+});
+module.exports = __toCommonJS(cwd_exports);
+var import_path = require("path");
+function getCwd() {
+  const cwd = process.cwd();
+  const appRoot = process.env.APP_ROOT;
+  if (appRoot) {
+    return (0, import_path.isAbsolute)(appRoot) ? appRoot : (0, import_path.join)(cwd, appRoot);
+  }
+  return cwd;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCwd
+});

package/dist/service/requireHook.d.ts

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

package/dist/service/requireHook.js

@@ -0,0 +1,14 @@
+// src/service/requireHook.ts
+var import_path = require("path");
+var hookPropertyMap = /* @__PURE__ */ new Map([
+  ["umi", (0, import_path.join)(__dirname, "../index.js")],
+  ["umi/plugin-utils", (0, import_path.join)(__dirname, "../../plugin-utils.js")]
+]);
+var mod = require("module");
+var resolveFilename = mod._resolveFilename;
+mod._resolveFilename = function(request, parent, isMain, options) {
+  const hookResolved = hookPropertyMap.get(request);
+  if (hookResolved)
+    request = hookResolved;
+  return resolveFilename.call(mod, request, parent, isMain, options);
+};

package/dist/service/service.d.ts

@@ -0,0 +1,8 @@
+import { Service as CoreService } from '@umijs/core';
+export declare class Service extends CoreService {
+    constructor(opts?: any);
+    run2(opts: {
+        name: string;
+        args?: any;
+    }): Promise<void>;
+}

package/dist/service/service.js

@@ -0,0 +1,71 @@
+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(
+  // 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/service/service.ts
+var service_exports = {};
+__export(service_exports, {
+  Service: () => Service
+});
+module.exports = __toCommonJS(service_exports);
+var import_core = require("@umijs/core");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../constants");
+var import_cwd = require("./cwd");
+var Service = class extends import_core.Service {
+  constructor(opts) {
+    process.env.UMI_DIR = (0, import_path.dirname)(require.resolve("../../package"));
+    const cwd = (0, import_cwd.getCwd)();
+    require("./requireHook");
+    super({
+      ...opts,
+      env: process.env.NODE_ENV,
+      cwd,
+      defaultConfigFiles: (opts == null ? void 0 : opts.defaultConfigFiles) || import_constants.DEFAULT_CONFIG_FILES,
+      frameworkName: (opts == null ? void 0 : opts.frameworkName) || import_constants.FRAMEWORK_NAME,
+      presets: [require.resolve("@umijs/preset-umi"), ...(opts == null ? void 0 : opts.presets) || []],
+      plugins: [
+        (0, import_fs.existsSync)((0, import_path.join)(cwd, "plugin.ts")) && (0, import_path.join)(cwd, "plugin.ts"),
+        (0, import_fs.existsSync)((0, import_path.join)(cwd, "plugin.js")) && (0, import_path.join)(cwd, "plugin.js")
+      ].filter(Boolean)
+    });
+  }
+  async run2(opts) {
+    let name = opts.name;
+    if ((opts == null ? void 0 : opts.args.version) || name === "v") {
+      name = "version";
+    } else if ((opts == null ? void 0 : opts.args.help) || !name || name === "h") {
+      name = "help";
+    }
+    return await this.run({ ...opts, name });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Service
+});

package/dist/test-setup.d.ts

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

package/dist/test-setup.js

@@ -0,0 +1,3 @@
+// src/test-setup.ts
+var import_plugin = require("@@/core/plugin");
+(0, import_plugin.createPluginManager)();

package/dist/test.d.ts

@@ -0,0 +1,119 @@
+import { Config } from '@umijs/test';
+export * from '@umijs/test';
+export declare function getAliasPathWithKey(alias: Record<string, string>, key: string): string;
+export declare function getUmiAlias(): Promise<any>;
+export declare function configUmiAlias(config: Config.InitialOptions): Promise<Partial<{
+    automock: boolean;
+    bail: number | boolean;
+    cache: boolean;
+    cacheDirectory: string;
+    ci: boolean;
+    clearMocks: boolean;
+    changedFilesWithAncestor: boolean;
+    changedSince: string;
+    collectCoverage: boolean;
+    collectCoverageFrom: string[];
+    collectCoverageOnlyFrom: {
+        [key: string]: boolean;
+    };
+    coverageDirectory: string;
+    coveragePathIgnorePatterns: string[];
+    coverageProvider: "babel" | "v8";
+    coverageReporters: Config.CoverageReporters;
+    coverageThreshold: {
+        [path: string]: Config.CoverageThresholdValue;
+        global: Config.CoverageThresholdValue;
+    };
+    dependencyExtractor: string;
+    detectLeaks: boolean;
+    detectOpenHandles: boolean;
+    displayName: string | Config.DisplayName;
+    expand: boolean;
+    extensionsToTreatAsEsm: string[];
+    extraGlobals: string[];
+    filter: string;
+    findRelatedTests: boolean;
+    forceCoverageMatch: string[];
+    forceExit: boolean;
+    json: boolean;
+    globals: Config.ConfigGlobals;
+    globalSetup: string | null | undefined;
+    globalTeardown: string | null | undefined;
+    haste: Config.HasteConfig;
+    injectGlobals: boolean;
+    reporters: (string | Config.ReporterConfig)[];
+    logHeapUsage: boolean;
+    lastCommit: boolean;
+    listTests: boolean;
+    maxConcurrency: number;
+    maxWorkers: string | number;
+    moduleDirectories: string[];
+    moduleFileExtensions: string[];
+    moduleLoader: string;
+    moduleNameMapper: {
+        [key: string]: string | string[];
+    };
+    modulePathIgnorePatterns: string[];
+    modulePaths: string[];
+    name: string;
+    noStackTrace: boolean;
+    notify: boolean;
+    notifyMode: string;
+    onlyChanged: boolean;
+    onlyFailures: boolean;
+    outputFile: string;
+    passWithNoTests: boolean;
+    preprocessorIgnorePatterns: string[];
+    preset: string | null | undefined;
+    prettierPath: string | null | undefined;
+    projects: (string | Config.InitialProjectOptions)[];
+    replname: string | null | undefined;
+    resetMocks: boolean;
+    resetModules: boolean;
+    resolver: string | null | undefined;
+    restoreMocks: boolean;
+    rootDir: string;
+    roots: string[];
+    runner: string;
+    runTestsByPath: boolean;
+    scriptPreprocessor: string;
+    setupFiles: string[];
+    setupTestFrameworkScriptFile: string;
+    setupFilesAfterEnv: string[];
+    silent: boolean;
+    skipFilter: boolean;
+    skipNodeResolution: boolean;
+    slowTestThreshold: number;
+    snapshotResolver: string;
+    snapshotSerializers: string[];
+    snapshotFormat: Config.PrettyFormatOptions;
+    errorOnDeprecated: boolean;
+    testEnvironment: string;
+    testEnvironmentOptions: Record<string, unknown>;
+    testFailureExitCode: string | number;
+    testLocationInResults: boolean;
+    testMatch: string[];
+    testNamePattern: string;
+    testPathDirs: string[];
+    testPathIgnorePatterns: string[];
+    testRegex: string | string[];
+    testResultsProcessor: string;
+    testRunner: string;
+    testSequencer: string;
+    testURL: string;
+    testTimeout: number;
+    timers: "real" | "fake" | "modern" | "legacy";
+    transform: {
+        [regex: string]: string | Config.TransformerConfig;
+    };
+    transformIgnorePatterns: string[];
+    watchPathIgnorePatterns: string[];
+    unmockedModulePathPatterns: string[];
+    updateSnapshot: boolean;
+    useStderr: boolean;
+    verbose?: boolean | undefined;
+    watch: boolean;
+    watchAll: boolean;
+    watchman: boolean;
+    watchPlugins: (string | [string, Record<string, unknown>])[];
+}>>;

package/dist/test.js

@@ -0,0 +1,82 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/test.ts
+var test_exports = {};
+__export(test_exports, {
+  configUmiAlias: () => configUmiAlias,
+  getAliasPathWithKey: () => getAliasPathWithKey,
+  getUmiAlias: () => getUmiAlias
+});
+module.exports = __toCommonJS(test_exports);
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_service = require("./service/service");
+__reExport(test_exports, require("@umijs/test"), module.exports);
+function getAliasPathWithKey(alias, key) {
+  if (alias[key]) {
+    return getAliasPathWithKey(alias, alias[key]);
+  }
+  const aliasKeys = Object.keys(alias);
+  const keyStartedWith = aliasKeys.find(
+    (k) => !k.endsWith("$") && key.startsWith(`${k}/`)
+  );
+  if (keyStartedWith) {
+    const realPath = alias[keyStartedWith];
+    const newKey = realPath + key.slice(keyStartedWith.length);
+    return getAliasPathWithKey(alias, newKey);
+  } else {
+    return key;
+  }
+}
+var service;
+async function getUmiAlias() {
+  if (!service) {
+    service = new import_service.Service();
+    await service.run2({
+      name: "setup",
+      args: { quiet: true }
+    });
+  }
+  return service.config.alias;
+}
+async function configUmiAlias(config) {
+  (0, import_utils.setNoDeprecation)();
+  config.moduleNameMapper || (config.moduleNameMapper = {});
+  const alias = await getUmiAlias();
+  for (const key of Object.keys(alias)) {
+    const aliasPath = getAliasPathWithKey(alias, key);
+    if (key.endsWith("$")) {
+      config.moduleNameMapper[`^${key}`] = aliasPath;
+    } else if ((0, import_fs.existsSync)(aliasPath) && (0, import_fs.statSync)(aliasPath).isDirectory()) {
+      config.moduleNameMapper[`^${key}/(.*)$`] = `${aliasPath}/$1`;
+      config.moduleNameMapper[`^${key}$`] = aliasPath;
+    } else {
+      config.moduleNameMapper[`^${key}$`] = aliasPath;
+    }
+  }
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configUmiAlias,
+  getAliasPathWithKey,
+  getUmiAlias,
+  ...require("@umijs/test")
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umi",
-  "version": "4.3.21",
+  "version": "4.3.23",
   "description": "umi",
   "homepage": "https://github.com/umijs/umi/tree/master/packages/umi#readme",
   "bugs": "https://github.com/umijs/umi/issues",
@@ -34,15 +34,15 @@
     "@babel/runtime": "7.23.6",
     "prettier-plugin-organize-imports": "^3.2.2",
     "prettier-plugin-packagejson": "2.4.3",
-    "@umijs/core": "4.3.21",
-    "@umijs/bundler-webpack": "4.3.21",
-    "@umijs/lint": "4.3.21",
-    "@umijs/bundler-utils": "4.3.21",
-    "@umijs/preset-umi": "4.3.21",
-    "@umijs/renderer-react": "4.3.21",
-    "@umijs/server": "4.3.21",
-    "@umijs/utils": "4.3.21",
-    "@umijs/test": "4.3.21"
+    "@umijs/bundler-utils": "4.3.23",
+    "@umijs/lint": "4.3.23",
+    "@umijs/renderer-react": "4.3.23",
+    "@umijs/core": "4.3.23",
+    "@umijs/bundler-webpack": "4.3.23",
+    "@umijs/preset-umi": "4.3.23",
+    "@umijs/server": "4.3.23",
+    "@umijs/utils": "4.3.23",
+    "@umijs/test": "4.3.23"
   },
   "engines": {
     "node": ">=14"