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

package/dist/staticDepInfo/staticDepInfo.d.ts

@@ -0,0 +1,61 @@
+import { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+import { checkMatch } from '../babelPlugins/awaitImport/checkMatch';
+import { MFSU } from '../mfsu/mfsu';
+declare type FileChangeEvent = {
+    event: 'unlink' | 'change' | 'add';
+    path: string;
+};
+declare type MergedCodeInfo = {
+    imports: readonly ImportSpecifier[];
+    code: string;
+    events: FileChangeEvent[];
+};
+declare type AutoUpdateSrcCodeCache = {
+    register(listener: (info: MergedCodeInfo) => void): void;
+    getMergedCode(): MergedCodeInfo;
+    handleFileChangeEvents(events: FileChangeEvent[]): void;
+    replayChangeEvents(): FileChangeEvent[];
+    getSrcPath(): string;
+};
+interface IOpts {
+    mfsu: MFSU;
+    srcCodeCache: AutoUpdateSrcCodeCache;
+    safeList?: string[];
+}
+export declare type Match = ReturnType<typeof checkMatch> & {
+    version: string;
+};
+export declare class StaticDepInfo {
+    opts: IOpts;
+    private readonly cacheFilePath;
+    private mfsu;
+    private readonly include;
+    private currentDep;
+    private builtWithDep;
+    private cacheDependency;
+    private produced;
+    private readonly cwd;
+    private readonly runtimeSimulations;
+    constructor(opts: IOpts);
+    getProducedEvent(): {
+        changes: unknown[];
+    }[];
+    consumeAllProducedEvents(): void;
+    shouldBuild(): false | "cacheDependency has changed" | "dependencies changed";
+    getDepModules(): Record<string, {
+        file: string;
+        version: string;
+    }>;
+    snapshot(): void;
+    loadCache(): void;
+    writeCache(): void;
+    getCacheFilePath(): string;
+    getDependencies(): Record<string, Match>;
+    init(): void;
+    private _getDependencies;
+    private simulateRuntimeTransform;
+    private appendIncludeList;
+    allRuntimeHelpers(): Promise<void>;
+    setBabelPluginImportConfig(config: Map<string, any>): void;
+}
+export {};

package/dist/staticDepInfo/staticDepInfo.js

@@ -0,0 +1,274 @@
+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/staticDepInfo/staticDepInfo.ts
+var staticDepInfo_exports = {};
+__export(staticDepInfo_exports, {
+  StaticDepInfo: () => StaticDepInfo
+});
+module.exports = __toCommonJS(staticDepInfo_exports);
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_why = __toESM(require("is-equal/why"));
+var import_path = require("path");
+var import_checkMatch = require("../babelPlugins/awaitImport/checkMatch");
+var import_dep = require("../dep/dep");
+var import_babel_plugin_import = __toESM(require("./simulations/babel-plugin-import"));
+var StaticDepInfo = class {
+  constructor(opts) {
+    this.currentDep = {};
+    this.builtWithDep = {};
+    this.cacheDependency = {};
+    this.produced = [];
+    this.mfsu = opts.mfsu;
+    this.include = this.mfsu.opts.include || [];
+    this.opts = opts;
+    this.cacheFilePath = (0, import_path.join)(
+      this.opts.mfsu.opts.tmpBase,
+      "MFSU_CACHE_v4.json"
+    );
+    this.cwd = this.mfsu.opts.cwd;
+    opts.srcCodeCache.register((info) => {
+      this.currentDep = this._getDependencies(info.code, info.imports);
+    });
+    this.runtimeSimulations = [];
+  }
+  getProducedEvent() {
+    return this.produced;
+  }
+  consumeAllProducedEvents() {
+    this.produced = [];
+  }
+  shouldBuild() {
+    const currentCacheDep = this.opts.mfsu.opts.getCacheDependency();
+    if (!import_utils.lodash.isEqual(this.cacheDependency, currentCacheDep)) {
+      if (process.env.DEBUG_UMI) {
+        const reason = (0, import_why.default)(this.cacheDependency, currentCacheDep);
+        import_utils.logger.info(
+          "[MFSU][eager]: isEqual(cacheDependency,currentCacheDep) === false, because ",
+          reason
+        );
+      }
+      return "cacheDependency has changed";
+    }
+    if (import_utils.lodash.isEqual(this.builtWithDep, this.currentDep)) {
+      return false;
+    } else {
+      if (process.env.DEBUG_UMI) {
+        const reason = (0, import_why.default)(this.builtWithDep, this.currentDep);
+        import_utils.logger.info(
+          "[MFSU][eager]: isEqual(oldDep,newDep) === false, because ",
+          reason
+        );
+      }
+      return "dependencies changed";
+    }
+  }
+  getDepModules() {
+    const map = this.getDependencies();
+    const staticDeps = {};
+    const keys = Object.keys(map);
+    for (const k of keys) {
+      staticDeps[k] = {
+        file: k,
+        version: map[k].version
+      };
+    }
+    return staticDeps;
+  }
+  snapshot() {
+    this.builtWithDep = this.currentDep;
+    this.cacheDependency = this.mfsu.opts.getCacheDependency();
+  }
+  loadCache() {
+    if ((0, import_fs.existsSync)(this.cacheFilePath)) {
+      try {
+        const { dep = {}, cacheDependency = {} } = JSON.parse(
+          (0, import_fs.readFileSync)(this.cacheFilePath, "utf-8")
+        );
+        this.builtWithDep = dep;
+        this.cacheDependency = cacheDependency;
+        import_utils.logger.info("[MFSU][eager] restored cache");
+      } catch (e) {
+        import_utils.logger.warn(
+          "[MFSU][eager] restore cache failed, fallback to Empty dependency",
+          e
+        );
+      }
+    }
+  }
+  writeCache() {
+    import_utils.fsExtra.mkdirpSync((0, import_path.dirname)(this.cacheFilePath));
+    const newContent = JSON.stringify(
+      {
+        dep: this.builtWithDep,
+        cacheDependency: this.cacheDependency
+      },
+      null,
+      2
+    );
+    if ((0, import_fs.existsSync)(this.cacheFilePath) && (0, import_fs.readFileSync)(this.cacheFilePath, "utf-8") === newContent) {
+      return;
+    }
+    import_utils.logger.info("[MFSU][eager] write cache");
+    (0, import_fs.writeFileSync)(this.cacheFilePath, newContent, "utf-8");
+  }
+  getCacheFilePath() {
+    return this.cacheFilePath;
+  }
+  getDependencies() {
+    return this.currentDep;
+  }
+  init() {
+    const merged = this.opts.srcCodeCache.getMergedCode();
+    this.currentDep = this._getDependencies(merged.code, merged.imports);
+  }
+  _getDependencies(bigCodeString, imports) {
+    const start = Date.now();
+    const cwd = this.mfsu.opts.cwd;
+    const mfsuOpts = this.mfsu.opts;
+    const userUnMatches = mfsuOpts.unMatchLibs || [];
+    const sharedUnMatches = Object.keys(mfsuOpts.shared || {});
+    const remoteAliasUnMatches = (mfsuOpts.remoteAliases || []).map(
+      (str) => new RegExp(`^${str}`)
+    );
+    const unMatches = [
+      ...userUnMatches,
+      ...sharedUnMatches,
+      ...remoteAliasUnMatches
+    ];
+    const opts = {
+      exportAllMembers: this.mfsu.opts.exportAllMembers,
+      unMatchLibs: unMatches,
+      remoteName: this.mfsu.opts.mfName,
+      alias: this.mfsu.alias,
+      externals: this.mfsu.externals
+    };
+    const matched = {};
+    const unMatched = /* @__PURE__ */ new Set();
+    const pkgNames = this.runtimeSimulations.map(
+      ({ packageName }) => packageName
+    );
+    const groupedMockImports = {};
+    for (const imp of imports) {
+      if (!imp.n) {
+        continue;
+      }
+      if (pkgNames.indexOf(imp.n) >= 0) {
+        const name = imp.n;
+        if (groupedMockImports[name]) {
+          groupedMockImports[name].push(imp);
+        } else {
+          groupedMockImports[name] = [imp];
+        }
+        continue;
+      }
+      if (unMatched.has(imp.n)) {
+        continue;
+      }
+      if (matched[imp.n]) {
+        continue;
+      }
+      const match = (0, import_checkMatch.checkMatch)({
+        value: imp.n,
+        depth: 1,
+        filename: "_.js",
+        opts
+      });
+      if (match.isMatch) {
+        matched[match.value] = {
+          ...match,
+          version: import_dep.Dep.getDepVersion({
+            dep: match.value,
+            cwd
+          })
+        };
+      } else {
+        unMatched.add(imp.n);
+      }
+    }
+    this.simulateRuntimeTransform(matched, groupedMockImports, bigCodeString);
+    this.appendIncludeList(matched, opts);
+    import_utils.logger.debug("[MFSU][eager] _getDependencies costs", Date.now() - start);
+    return matched;
+  }
+  simulateRuntimeTransform(matched, groupedImports, rawCode) {
+    for (const mock of this.runtimeSimulations) {
+      const name = mock.packageName;
+      const pathToVersion = (dep) => {
+        return import_dep.Dep.getDepVersion({
+          dep,
+          cwd: this.cwd
+        });
+      };
+      const ms = mock.handleImports({
+        imports: groupedImports[name],
+        rawCode,
+        alias: this.mfsu.alias,
+        mfName: this.mfsu.opts.mfName,
+        pathToVersion
+      });
+      for (const m of ms) {
+        matched[m.value] = m;
+      }
+    }
+  }
+  appendIncludeList(matched, opts) {
+    for (const p of this.include) {
+      const match = (0, import_checkMatch.checkMatch)({
+        value: p,
+        depth: 1,
+        filename: "_.js",
+        opts
+      });
+      if (match.isMatch) {
+        matched[match.value] = {
+          ...match,
+          version: import_dep.Dep.getDepVersion({
+            dep: match.value,
+            cwd: this.cwd
+          })
+        };
+      }
+    }
+  }
+  async allRuntimeHelpers() {
+  }
+  setBabelPluginImportConfig(config) {
+    for (const [key, c] of config.entries()) {
+      this.runtimeSimulations.push({
+        packageName: key,
+        handleImports: (0, import_babel_plugin_import.default)(c)
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StaticDepInfo
+});

package/dist/types.d.ts

@@ -1,4 +1,16 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+import type { TransformOptions } from '@umijs/bundler-utils/compiled/esbuild';
 export declare enum Mode {
     development = "development",
     production = "production"
 }
+export interface IEsbuildLoaderHandlerParams {
+    code: string;
+    filePath: string;
+    imports: readonly ImportSpecifier[];
+    exports: readonly string[];
+}
+export interface IEsbuildLoaderOpts extends Partial<TransformOptions> {
+    handler?: Array<(opts: IEsbuildLoaderHandlerParams) => string>;
+    implementation?: typeof import('@umijs/bundler-utils/compiled/esbuild');
+}

package/dist/types.js

@@ -1,8 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mode = void 0;
-var Mode;
-(function (Mode) {
-    Mode["development"] = "development";
-    Mode["production"] = "production";
-})(Mode = exports.Mode || (exports.Mode = {}));
+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/types.ts
+var types_exports = {};
+__export(types_exports, {
+  Mode: () => Mode
+});
+module.exports = __toCommonJS(types_exports);
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2["development"] = "development";
+  Mode2["production"] = "production";
+  return Mode2;
+})(Mode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Mode
+});

package/dist/utils/makeArray.js

@@ -1,7 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeArray = void 0;
+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/makeArray.ts
+var makeArray_exports = {};
+__export(makeArray_exports, {
+  makeArray: () => makeArray
+});
+module.exports = __toCommonJS(makeArray_exports);
 function makeArray(item) {
-    return Array.isArray(item) ? item : [item];
+  return Array.isArray(item) ? item : [item];
 }
-exports.makeArray = makeArray;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeArray
+});

package/dist/utils/resolveUtils.d.ts

@@ -0,0 +1 @@
+export declare function resolveFromContexts(contexts: string[], path: string): Promise<string>;

package/dist/utils/resolveUtils.js

@@ -0,0 +1,104 @@
+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/resolveUtils.ts
+var resolveUtils_exports = {};
+__export(resolveUtils_exports, {
+  resolveFromContexts: () => resolveFromContexts
+});
+module.exports = __toCommonJS(resolveUtils_exports);
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+var ORDERED_MAIN_FIELDS = ["browser", "module", "main"];
+var SUPPORTED_EXTS = [".wasm", ".mjs", ".js", ".jsx", ".ts", ".tsx", ".json"];
+var EXPORTS_FIELDS = ["exports"];
+var browserResolver = import_enhanced_resolve.default.create({
+  mainFields: ORDERED_MAIN_FIELDS,
+  extensions: SUPPORTED_EXTS,
+  exportsFields: EXPORTS_FIELDS,
+  conditionNames: ["browser", "import"],
+  symlinks: false
+});
+var esmResolver = import_enhanced_resolve.default.create({
+  mainFields: ORDERED_MAIN_FIELDS,
+  extensions: SUPPORTED_EXTS,
+  exportsFields: EXPORTS_FIELDS,
+  conditionNames: ["module"],
+  symlinks: false
+});
+var cjsResolver = import_enhanced_resolve.default.create({
+  mainFields: ORDERED_MAIN_FIELDS,
+  extensions: SUPPORTED_EXTS,
+  exportsFields: EXPORTS_FIELDS,
+  conditionNames: ["require", "node"],
+  symlinks: false
+});
+async function resolveWith(resolver, context, path) {
+  return new Promise((resolve2, reject) => {
+    resolver(
+      context,
+      path,
+      (err, result) => err ? reject(err) : resolve2(result)
+    );
+  });
+}
+async function tryResolvers(rs, context, path) {
+  let result = "";
+  let lastError = null;
+  for (const r of rs) {
+    try {
+      result = await resolveWith(r, context, path);
+      return result;
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  if (!result) {
+    throw lastError || Error(`can't resolve ${path} from ${context}`);
+  }
+  return result;
+}
+async function resolve(context, path) {
+  return await tryResolvers(
+    [browserResolver, esmResolver, cjsResolver],
+    context,
+    path
+  );
+}
+async function resolveFromContexts(contexts, path) {
+  for (const context of contexts) {
+    try {
+      return await resolve(context, path);
+    } catch (e) {
+    }
+  }
+  throw new Error(`Can't resolve ${path} from ${contexts.join(", ")}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveFromContexts
+});

package/dist/utils/trimFileContent.js

@@ -1,7 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimFileContent = void 0;
+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/trimFileContent.ts
+var trimFileContent_exports = {};
+__export(trimFileContent_exports, {
+  trimFileContent: () => trimFileContent
+});
+module.exports = __toCommonJS(trimFileContent_exports);
 function trimFileContent(content) {
-    return content.trim() + '\n';
+  return content.trim() + "\n";
 }
-exports.trimFileContent = trimFileContent;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  trimFileContent
+});

package/dist/utils/webpackUtils.d.ts

@@ -0,0 +1,3 @@
+import { Configuration } from 'webpack';
+export declare function extractBabelPluginImportOptions(webpackConfig: Configuration): Map<string, any>;
+export declare function getResolver(opts: Configuration): (path: string) => string | false;

package/dist/utils/webpackUtils.js

@@ -0,0 +1,80 @@
+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/webpackUtils.ts
+var webpackUtils_exports = {};
+__export(webpackUtils_exports, {
+  extractBabelPluginImportOptions: () => extractBabelPluginImportOptions,
+  getResolver: () => getResolver
+});
+module.exports = __toCommonJS(webpackUtils_exports);
+var import_webpack = require("webpack");
+var import_utils = require("@umijs/utils");
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+var { property, compact, flatMap } = import_utils.lodash;
+function extractBabelPluginImportOptions(webpackConfig) {
+  var _a;
+  const rules = ((_a = webpackConfig.module) == null ? void 0 : _a.rules) || [];
+  const uses = compact(flatMap(rules, property(["use"]))).filter(
+    (u) => {
+      var _a2;
+      return ((_a2 = u == null ? void 0 : u.loader) == null ? void 0 : _a2.indexOf("babel-loader")) >= 0;
+    }
+  );
+  const pluginConfigs = compact(
+    flatMap(uses, property(["options", "plugins"]))
+  ).filter(
+    (p) => {
+      var _a2, _b;
+      return Array.isArray(p) && ((_b = (_a2 = p[0]) == null ? void 0 : _a2.indexOf) == null ? void 0 : _b.call(_a2, "babel-plugin-import")) >= 0;
+    }
+  );
+  const configs = /* @__PURE__ */ new Map();
+  for (const c of pluginConfigs) {
+    !configs.has(c[1].libraryName) && configs.set(c[1].libraryName, c[1]);
+  }
+  return configs;
+}
+function getResolver(opts) {
+  const context = opts.context ?? process.cwd();
+  const resolveDefaults = {
+    extensions: [".tsx", ".ts", ".jsx", ".js"],
+    // keep same with previous mfsu version
+    roots: [context]
+  };
+  const mergedResolve = import_webpack.util.cleverMerge(resolveDefaults, opts.resolve);
+  const resolver = import_enhanced_resolve.default.create.sync(mergedResolve);
+  return (path) => {
+    return resolver(context, path);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractBabelPluginImportOptions,
+  getResolver
+});

package/dist/webpackPlugins/buildDepPlugin.d.ts

@@ -1,10 +1,11 @@
 import type { Compiler } from 'webpack';
-interface IOpts {
+export interface IBuildDepPluginOpts {
     onCompileDone: Function;
+    onFileChange?: (c: Compiler) => Promise<any>;
+    beforeCompile?: () => Promise<any>;
 }
 export declare class BuildDepPlugin {
     private opts;
-    constructor(opts: IOpts);
+    constructor(opts: IBuildDepPluginOpts);
     apply(compiler: Compiler): void;
 }
-export {};