@umijs/plugins 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/unocss.js

@@ -0,0 +1,71 @@
+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/unocss.ts
+var unocss_exports = {};
+__export(unocss_exports, {
+  default: () => unocss_default
+});
+module.exports = __toCommonJS(unocss_exports);
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_plugin_utils = require("umi/plugin-utils");
+var unocss_default = (api) => {
+  api.describe({
+    key: "unocss",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          watch: zod.array(zod.any())
+        });
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  const outputPath = "uno.css";
+  api.onBeforeCompiler(async () => {
+    if (process.env.IS_UMI_BUILD_WORKER)
+      return;
+    if (!(0, import_fs.existsSync)((0, import_path.join)(api.paths.cwd, "unocss.config.ts")))
+      api.logger.warn(
+        "请在项目目录中添加 unocss.config.ts 文件，并配置需要的 unocss presets，否则插件将没有效果！"
+      );
+    const generatedPath = (0, import_path.join)(api.paths.absTmpPath, outputPath);
+    const binPath = (0, import_path.join)(api.cwd, "node_modules/.bin/unocss");
+    const watchDirs = api.config.unocss.watch || [];
+    const isDev = api.env === "development";
+    const args = [
+      ...watchDirs,
+      "--out-file",
+      generatedPath,
+      isDev ? "--watch" : ""
+    ].filter(Boolean);
+    const execaRes = import_utils.execa.execa(binPath, args, {
+      cwd: api.cwd,
+      stdio: isDev ? "pipe" : "inherit"
+    });
+    if (!isDev) {
+      await execaRes;
+    }
+  });
+  api.addEntryImports(() => {
+    const generatedPath = (0, import_plugin_utils.winPath)((0, import_path.join)(api.paths.absTmpPath, outputPath));
+    return [{ source: generatedPath }];
+  });
+};

package/dist/utils/astUtils.d.ts

@@ -0,0 +1,3 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+export declare function getIdentifierDeclaration(node: t.Node, path: Babel.NodePath): Babel.types.Node;

package/dist/utils/astUtils.js

@@ -0,0 +1,49 @@
+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/utils/astUtils.ts
+var astUtils_exports = {};
+__export(astUtils_exports, {
+  getIdentifierDeclaration: () => getIdentifierDeclaration
+});
+module.exports = __toCommonJS(astUtils_exports);
+var t = __toESM(require("@umijs/bundler-utils/compiled/babel/types"));
+function getIdentifierDeclaration(node, path) {
+  if (t.isIdentifier(node) && path.scope.hasBinding(node.name)) {
+    let bindingNode = path.scope.getBinding(node.name).path.node;
+    if (t.isVariableDeclarator(bindingNode)) {
+      bindingNode = bindingNode.init;
+    }
+    return bindingNode;
+  }
+  return node;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIdentifierDeclaration
+});

package/dist/utils/localeUtils.d.ts

@@ -0,0 +1,33 @@
+export declare type IAddAntdLocales = (args: {
+    lang: string;
+    country: string;
+}) => Promise<string[]>;
+export interface IGetLocaleFileListOpts {
+    localeFolder: string;
+    separator?: string;
+    absSrcPath?: string;
+    absPagesPath?: string;
+    addAntdLocales: IAddAntdLocales;
+    resolveKey: string;
+}
+/**
+ * 获取 moment 包的 locale 名称
+ * @param lang 语言
+ * @param country 国家
+ * @param resolveKey 用来resolve的key，moment 或者 dayjs，为了使 dayjs 可以替换 moment
+ */
+export declare const getMomentLocale: (lang: string, country: string, resolveKey: string) => {
+    momentLocale: string;
+};
+export declare const getAntdLocale: (lang: string, country: string) => string;
+export interface IGetLocaleFileListResult {
+    lang: string;
+    country: string;
+    name: string;
+    paths: string[];
+    antdLocale: string[];
+    momentLocale: string;
+}
+export declare const getLocaleList: (opts: IGetLocaleFileListOpts) => Promise<IGetLocaleFileListResult[]>;
+export declare const exactLocalePaths: (data: IGetLocaleFileListResult[]) => string[];
+export declare function isNeedPolyfill(targets?: {}): boolean;

package/dist/utils/localeUtils.js

@@ -0,0 +1,139 @@
+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/utils/localeUtils.ts
+var localeUtils_exports = {};
+__export(localeUtils_exports, {
+  exactLocalePaths: () => exactLocalePaths,
+  getAntdLocale: () => getAntdLocale,
+  getLocaleList: () => getLocaleList,
+  getMomentLocale: () => getMomentLocale,
+  isNeedPolyfill: () => isNeedPolyfill
+});
+module.exports = __toCommonJS(localeUtils_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_plugin_utils = require("umi/plugin-utils");
+var getMomentLocale = (lang, country, resolveKey) => {
+  var _a, _b;
+  const momentLocation = require.resolve(`${resolveKey}/locale/zh-cn`).replace(/zh\-cn\.js$/, "");
+  if ((0, import_fs.existsSync)(
+    (0, import_path.join)(momentLocation, `${lang}-${(_a = country == null ? void 0 : country.toLocaleLowerCase) == null ? void 0 : _a.call(country)}.js`)
+  )) {
+    const momentLocale = `${lang}-${(_b = country == null ? void 0 : country.toLocaleLowerCase) == null ? void 0 : _b.call(country)}`;
+    return {
+      momentLocale
+    };
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(momentLocation, `${lang}.js`))) {
+    return {
+      momentLocale: lang
+    };
+  }
+  return { momentLocale: "" };
+};
+var getAntdLocale = (lang, country) => `${lang}_${(country || lang).toLocaleUpperCase()}`;
+var modulesHasLocale = (localePath) => {
+  try {
+    require.resolve(localePath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+var getLocaleList = async (opts) => {
+  const {
+    localeFolder,
+    separator = "-",
+    absSrcPath = "",
+    absPagesPath = "",
+    addAntdLocales,
+    resolveKey = "moment"
+  } = opts;
+  const localeFileMath = new RegExp(
+    `^([a-z]{2})${separator}?([A-Z]{2})?.(js|json|ts)$`
+  );
+  const localeFiles = import_plugin_utils.glob.sync("*.{ts,js,json}", {
+    cwd: (0, import_plugin_utils.winPath)((0, import_path.join)(absSrcPath, localeFolder))
+  }).map((name) => (0, import_plugin_utils.winPath)((0, import_path.join)(absSrcPath, localeFolder, name))).concat(
+    import_plugin_utils.glob.sync(`**/${localeFolder}/*.{ts,js,json}`, {
+      cwd: absPagesPath
+    }).map((name) => (0, import_plugin_utils.winPath)((0, import_path.join)(absPagesPath, name)))
+  ).filter((p) => localeFileMath.test((0, import_path.basename)(p)) && (0, import_fs.existsSync)(p)).map((fullName) => {
+    var _a, _b;
+    const fileName = (0, import_path.basename)(fullName);
+    const fileInfo = (_b = (_a = localeFileMath.exec(fileName)) == null ? void 0 : _a.slice(1, 3)) == null ? void 0 : _b.filter(Boolean);
+    return {
+      name: (fileInfo || []).join(separator),
+      path: fullName
+    };
+  });
+  const groups = import_plugin_utils.lodash.groupBy(localeFiles, "name");
+  const promises = Object.keys(groups).map(async (name) => {
+    const [lang, country = ""] = name.split(separator);
+    const { momentLocale } = getMomentLocale(lang, country, resolveKey);
+    const antdLocale = import_plugin_utils.lodash.uniq(await addAntdLocales({ lang, country })).filter((localePath) => modulesHasLocale(localePath));
+    return {
+      lang,
+      name,
+      // react-intl Function.supportedLocalesOf
+      // Uncaught RangeError: Incorrect locale information provided
+      locale: name.split(separator).join("-"),
+      country,
+      antdLocale,
+      paths: groups[name].map((item) => (0, import_plugin_utils.winPath)(item.path)),
+      momentLocale
+    };
+  });
+  return Promise.all(promises);
+};
+var exactLocalePaths = (data) => {
+  return import_plugin_utils.lodash.flatten(data.map((item) => item.paths));
+};
+function isNeedPolyfill(targets = {}) {
+  const polyfillTargets = {
+    ie: 10,
+    firefox: 28,
+    chrome: 23,
+    safari: 9.1,
+    opera: 12.1,
+    ios: 9.3,
+    ios_saf: 9.3,
+    operamini: Infinity,
+    op_mini: Infinity,
+    android: 4.3,
+    blackberry: Infinity,
+    operamobile: 12.1,
+    op_mob: 12.1,
+    explorermobil: 10,
+    ie_mob: 10,
+    ucandroid: Infinity
+  };
+  return Object.keys(targets).find((key) => {
+    const lowKey = key.toLocaleLowerCase();
+    return polyfillTargets[lowKey] && polyfillTargets[lowKey] >= targets[key];
+  }) !== void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exactLocalePaths,
+  getAntdLocale,
+  getLocaleList,
+  getMomentLocale,
+  isNeedPolyfill
+});

package/dist/utils/mfUtils.d.ts

@@ -0,0 +1,14 @@
+declare type SimpleRemote = {
+    entry: string;
+    name: string;
+    aliasName?: string;
+};
+declare type RemoteEntries = {
+    name: string;
+    entries: object;
+    keyResolver: string;
+    aliasName?: string;
+};
+declare type Remote = SimpleRemote | RemoteEntries;
+export declare function toRemotesCodeString(remotes: Remote[]): string;
+export {};

package/dist/utils/mfUtils.js

@@ -0,0 +1,56 @@
+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/utils/mfUtils.ts
+var mfUtils_exports = {};
+__export(mfUtils_exports, {
+  toRemotesCodeString: () => toRemotesCodeString
+});
+module.exports = __toCommonJS(mfUtils_exports);
+function isSimpleRemote(r) {
+  return r.entry;
+}
+function isRemoteEntries(r) {
+  return r.entries && r.keyResolver;
+}
+function toRemotesCodeString(remotes) {
+  const res = [];
+  for (const r of remotes) {
+    const aliasName = r.aliasName || r.name;
+    const remoteName = r.name;
+    if (isSimpleRemote(r)) {
+      res.push(`${aliasName}: {
+  aliasName: "${aliasName}",
+  remoteName: "${remoteName}",        
+  entry: "${r.entry}"
+}`);
+    }
+    if (isRemoteEntries(r)) {
+      res.push(`${aliasName}: {
+  aliasName: "${aliasName}",
+  remoteName: "${remoteName}",        
+  entry: (${JSON.stringify(r.entries)})[${r.keyResolver}]
+}`);
+    }
+  }
+  return res.join(",\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toRemotesCodeString
+});

package/dist/utils/modelUtils.d.ts

@@ -0,0 +1,40 @@
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+import { IApi } from 'umi';
+interface IOpts {
+    contentTest?: (content: string) => Boolean;
+    astTest?: (opts: {
+        node: t.Node;
+        content: string;
+    }) => Boolean;
+}
+export declare function getNamespace(absFilePath: string, absSrcPath: string): string;
+export declare class Model {
+    file: string;
+    namespace: string;
+    id: string;
+    exportName: string;
+    deps: string[];
+    constructor(file: string, absSrcPath: string, sort: {} | undefined, id: number);
+    findDeps(sort: object): string[];
+}
+export declare class ModelUtils {
+    api: IApi;
+    opts: IOpts;
+    count: number;
+    constructor(api: IApi | null, opts: IOpts);
+    getAllModels(opts: {
+        sort?: object;
+        extraModels: string[];
+    }): Model[];
+    getModels(opts: {
+        base: string;
+        pattern?: string;
+    }): string[];
+    isModelValid(opts: {
+        content: string;
+        file: string;
+    }): boolean;
+    static topologicalSort: (models: Model[]) => string[];
+    static getModelsContent(models: Model[]): string;
+}
+export {};

package/dist/utils/modelUtils.js

@@ -0,0 +1,286 @@
+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/utils/modelUtils.ts
+var modelUtils_exports = {};
+__export(modelUtils_exports, {
+  Model: () => Model,
+  ModelUtils: () => ModelUtils,
+  getNamespace: () => getNamespace
+});
+module.exports = __toCommonJS(modelUtils_exports);
+var import_bundler_utils = require("@umijs/bundler-utils");
+var parser = __toESM(require("@umijs/bundler-utils/compiled/babel/parser"));
+var import_traverse = __toESM(require("@umijs/bundler-utils/compiled/babel/traverse"));
+var t = __toESM(require("@umijs/bundler-utils/compiled/babel/types"));
+var import_esbuild = require("@umijs/bundler-utils/compiled/esbuild");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_plugin_utils = require("umi/plugin-utils");
+var import_astUtils = require("./astUtils");
+function getNamespace(absFilePath, absSrcPath) {
+  const relPath = (0, import_plugin_utils.winPath)((0, import_path.relative)((0, import_plugin_utils.winPath)(absSrcPath), (0, import_plugin_utils.winPath)(absFilePath)));
+  const parts = relPath.split("/");
+  const dirs = parts.slice(0, -1);
+  const file = parts[parts.length - 1];
+  const validDirs = dirs.filter(
+    (dir) => !["src", "pages", "models"].includes(dir)
+  );
+  let normalizedFile = file;
+  normalizedFile = (0, import_path.basename)(file, (0, import_path.extname)(file));
+  if (normalizedFile.endsWith(".model")) {
+    normalizedFile = normalizedFile.split(".").slice(0, -1).join(".");
+  }
+  return [...validDirs, normalizedFile].join(".");
+}
+var Model = class {
+  constructor(file, absSrcPath, sort, id) {
+    let namespace;
+    let exportName;
+    const [_file, meta] = file.split("#");
+    if (meta) {
+      const metaObj = JSON.parse(meta);
+      namespace = metaObj.namespace;
+      exportName = metaObj.exportName;
+    }
+    this.file = _file;
+    this.id = `model_${id}`;
+    this.namespace = namespace || getNamespace(_file, absSrcPath);
+    this.exportName = exportName || "default";
+    this.deps = sort ? this.findDeps(sort) : [];
+  }
+  findDeps(sort) {
+    const content = (0, import_fs.readFileSync)(this.file, "utf-8");
+    const loader = (0, import_path.extname)(this.file).slice(1);
+    const result = (0, import_esbuild.transformSync)(content, {
+      loader,
+      sourcemap: false,
+      minify: false
+    });
+    const deps = /* @__PURE__ */ new Set();
+    const ast = parser.parse(result.code, {
+      sourceType: "module",
+      sourceFilename: this.file,
+      plugins: []
+    });
+    sort;
+    (0, import_traverse.default)(ast, {
+      CallExpression: (path) => {
+        if (t.isIdentifier(path.node.callee, { name: "useModel" }) && t.isStringLiteral(path.node.arguments[0])) {
+          deps.add(path.node.arguments[0].value);
+        }
+      }
+    });
+    return [...deps];
+  }
+};
+var _ModelUtils = class {
+  constructor(api, opts) {
+    this.opts = {};
+    this.count = 1;
+    this.api = api;
+    this.opts = opts;
+  }
+  getAllModels(opts) {
+    this.count = 1;
+    const models = [
+      ...this.getModels({
+        base: (0, import_path.join)(this.api.paths.absSrcPath, "models"),
+        pattern: "**/*.{ts,tsx,js,jsx}"
+      }),
+      ...this.getModels({
+        base: (0, import_path.join)(this.api.paths.absPagesPath),
+        pattern: "**/models/**/*.{ts,tsx,js,jsx}"
+      }),
+      ...this.getModels({
+        base: (0, import_path.join)(this.api.paths.absPagesPath),
+        pattern: "**/model.{ts,tsx,js,jsx}"
+      }),
+      ...opts.extraModels
+    ].map((file) => {
+      return new Model(
+        file,
+        this.api.paths.absSrcPath,
+        opts.sort,
+        this.count++
+      );
+    });
+    const namespaces = models.map((model) => model.namespace);
+    if (new Set(namespaces).size !== namespaces.length) {
+      throw new Error(
+        `Duplicate namespace in models: ${namespaces.sort().join(", ")}`
+      );
+    }
+    if (opts.sort) {
+      const namespaces2 = _ModelUtils.topologicalSort(models);
+      models.sort(
+        (a, b) => namespaces2.indexOf(a.namespace) - namespaces2.indexOf(b.namespace)
+      );
+    }
+    return models;
+  }
+  getModels(opts) {
+    return import_plugin_utils.glob.sync(opts.pattern || "**/*.{ts,js}", {
+      cwd: opts.base,
+      absolute: true
+    }).map(import_plugin_utils.winPath).filter((file) => {
+      if (/\.d.ts$/.test(file))
+        return false;
+      if (/\.(test|e2e|spec).([jt])sx?$/.test(file))
+        return false;
+      const content = (0, import_fs.readFileSync)(file, "utf-8");
+      return this.isModelValid({ content, file });
+    });
+  }
+  isModelValid(opts) {
+    var _a;
+    const { file, content } = opts;
+    if (this.opts.contentTest && this.opts.contentTest(content)) {
+      return true;
+    }
+    let result = null;
+    try {
+      const ext = (0, import_path.extname)(file).slice(1);
+      const loader = ext === "js" ? "jsx" : ext;
+      result = (0, import_esbuild.transformSync)(content, {
+        loader,
+        sourcemap: false,
+        minify: false,
+        sourcefile: file
+      });
+    } catch (e) {
+      if ((_a = e.errors) == null ? void 0 : _a.length) {
+        (0, import_bundler_utils.prettyPrintEsBuildErrors)(e.errors, { path: file, content });
+        delete e.errors;
+      }
+      throw e;
+    }
+    let ret = false;
+    const ast = parser.parse(result.code, {
+      sourceType: "module",
+      sourceFilename: file,
+      plugins: []
+    });
+    (0, import_traverse.default)(ast, {
+      ExportDefaultDeclaration: (path) => {
+        let node = path.node.declaration;
+        node = (0, import_astUtils.getIdentifierDeclaration)(node, path);
+        if (this.opts.astTest && this.opts.astTest({ node, content })) {
+          ret = true;
+        }
+      }
+    });
+    return ret;
+  }
+  static getModelsContent(models) {
+    const imports = [];
+    const modelProps = [];
+    models.forEach((model) => {
+      const fileWithoutExt = (0, import_plugin_utils.winPath)(
+        (0, import_path.format)({
+          dir: (0, import_path.dirname)(model.file),
+          base: (0, import_path.basename)(model.file, (0, import_path.extname)(model.file))
+        })
+      );
+      if (model.exportName !== "default") {
+        imports.push(
+          `import { ${model.exportName} as ${model.id} } from '${fileWithoutExt}';`
+        );
+      } else {
+        imports.push(`import ${model.id} from '${fileWithoutExt}';`);
+      }
+      modelProps.push(
+        `${model.id}: { namespace: '${model.namespace}', model: ${model.id} },`
+      );
+    });
+    return `
+${imports.join("\n")}
+
+export const models = {
+${modelProps.join("\n")}
+} as const`;
+  }
+};
+var ModelUtils = _ModelUtils;
+// https://github.com/umijs/umi/issues/9837
+ModelUtils.topologicalSort = (models) => {
+  const graph = [];
+  const namespaceToNode = {};
+  models.forEach((model, index) => {
+    const node = {
+      namespace: model.namespace,
+      deps: model.deps,
+      index,
+      in: 0,
+      childs: []
+    };
+    if (namespaceToNode[model.namespace]) {
+      throw new Error(`Duplicate namespace in models: ${model.namespace}`);
+    }
+    namespaceToNode[model.namespace] = node;
+    graph.push(node);
+  });
+  graph.forEach((node) => {
+    node.deps.forEach((dep) => {
+      const depNode = namespaceToNode[dep];
+      if (!depNode) {
+        throw new Error(`Model namespace not found: ${dep}`);
+      }
+      depNode.childs.push(node);
+      node.in++;
+    });
+  });
+  const queue = [];
+  while (true) {
+    const zeronode = graph.find((n) => {
+      return n && n.in === 0;
+    });
+    if (!zeronode) {
+      break;
+    }
+    queue.push(zeronode.namespace);
+    zeronode.childs.forEach((child) => {
+      child.in--;
+    });
+    zeronode.childs = [];
+    delete graph[zeronode.index];
+  }
+  const leftNodes = graph.filter(Boolean);
+  if (leftNodes.length > 0) {
+    throw new Error(
+      `Circle dependency detected in models: ${leftNodes.map((m) => import_plugin_utils.chalk.red(m.namespace)).join(", ")}`
+    );
+  }
+  return queue;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Model,
+  ModelUtils,
+  getNamespace
+});