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

package/dist/moduleGraph.d.ts

@@ -1,3 +1,4 @@
+import type { DepModule } from './depInfo';
 declare class ModuleNode {
     file: string;
     importers: Set<ModuleNode>;
@@ -15,10 +16,7 @@ interface IDep {
 export declare class ModuleGraph {
     fileToModules: Map<string, ModuleNode>;
     depToModules: Map<string, ModuleNode>;
-    depSnapshotModules: Record<string, {
-        file: string;
-        version: string;
-    }>;
+    depSnapshotModules: Record<string, DepModule>;
     rootModules: Set<ModuleNode>;
     constructor();
     restore(data: {
@@ -30,15 +28,13 @@ export declare class ModuleGraph {
     toJSON(): {
         roots: string[];
         fileModules: Record<string, {
-            importModules: string[];
+            importedModules: string[];
+            isRoot?: boolean | undefined;
         }>;
         depModules: Record<string, {
             version: string | null;
         }>;
-        depSnapshotModules: Record<string, {
-            file: string;
-            version: string;
-        }>;
+        depSnapshotModules: Record<string, DepModule>;
     };
     snapshotDeps(): void;
     getDepsInfo(mods: Map<string, ModuleNode>): Record<string, {
@@ -48,6 +44,7 @@ export declare class ModuleGraph {
     getDepInfo(mod: ModuleNode): {
         file: string;
         version: string;
+        importer: string;
     };
     hasDepChanged(): boolean;
     onFileChange(opts: {

package/dist/moduleGraph.js

@@ -1,189 +1,239 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleGraph = void 0;
-const utils_1 = require("@umijs/utils");
-class ModuleNode {
-    constructor(file) {
-        this.importers = new Set();
-        this.importedModules = new Set();
-        this.isDependency = false;
-        this.isRoot = false;
-        this.version = null;
-        this.file = file;
+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/moduleGraph.ts
+var moduleGraph_exports = {};
+__export(moduleGraph_exports, {
+  ModuleGraph: () => ModuleGraph
+});
+module.exports = __toCommonJS(moduleGraph_exports);
+var ModuleNode = class {
+  constructor(file) {
+    this.importers = /* @__PURE__ */ new Set();
+    this.importedModules = /* @__PURE__ */ new Set();
+    this.isDependency = false;
+    this.isRoot = false;
+    this.version = null;
+    this.file = file;
+  }
+};
+var ModuleGraph = class {
+  constructor() {
+    this.fileToModules = /* @__PURE__ */ new Map();
+    this.depToModules = /* @__PURE__ */ new Map();
+    this.depSnapshotModules = {};
+    this.rootModules = /* @__PURE__ */ new Set();
+  }
+  restore(data) {
+    const getModuleNode = (file) => {
+      if (this.fileToModules.has(file)) {
+        return this.fileToModules.get(file);
+      }
+      if (this.depToModules.has(file)) {
+        return this.depToModules.get(file);
+      }
+      const mod = new ModuleNode(file);
+      return mod;
+    };
+    const addNode = ({ file, importer }) => {
+      const mod = getModuleNode(file);
+      let isDependency = false;
+      let info;
+      if (data.fileModules[file]) {
+        info = data.fileModules[file];
+      } else if (data.depModules[file]) {
+        info = data.depModules[file];
+        isDependency = true;
+      }
+      if (info.isRoot)
+        mod.isRoot = true;
+      if (importer) {
+        mod.importers.add(importer);
+        if (!importer.importedModules.has(mod)) {
+          importer.importedModules.add(mod);
+        } else {
+          return;
+        }
+      }
+      mod.isDependency = isDependency;
+      if (info.version !== void 0) {
+        mod.version = info.version;
+      }
+      if (isDependency) {
+        this.depToModules.set(file, mod);
+      } else {
+        this.fileToModules.set(file, mod);
+        for (const importedModule of info.importedModules) {
+          addNode({ file: importedModule, importer: mod });
+        }
+      }
+    };
+    for (const root of data.roots) {
+      addNode({ file: root });
     }
-}
-class ModuleGraph {
-    constructor() {
-        this.fileToModules = new Map();
-        this.depToModules = new Map();
-        this.depSnapshotModules = {};
-        this.rootModules = new Set();
+    this.depSnapshotModules = data.depSnapshotModules;
+  }
+  toJSON() {
+    const roots = [];
+    const fileModules = {};
+    const depModules = {};
+    this.depToModules.forEach((value, key) => {
+      depModules[key] = {
+        version: value.version
+      };
+    });
+    this.fileToModules.forEach((value, key) => {
+      fileModules[key] = {
+        importedModules: Array.from(value.importedModules).map(
+          (item) => item.file
+        )
+      };
+      if (value.isRoot) {
+        fileModules[key].isRoot = true;
+        roots.push(key);
+      }
+    });
+    return {
+      roots,
+      fileModules,
+      depModules,
+      depSnapshotModules: this.depSnapshotModules
+    };
+  }
+  snapshotDeps() {
+    this.depSnapshotModules = this.getDepsInfo(this.depToModules);
+  }
+  getDepsInfo(mods) {
+    return Array.from(mods.keys()).reduce((memo, key) => {
+      memo[key] = this.getDepInfo(mods.get(key));
+      return memo;
+    }, {});
+  }
+  getDepInfo(mod) {
+    const [importer] = mod.importers;
+    return {
+      file: mod.file,
+      version: mod.version,
+      importer: importer == null ? void 0 : importer.file
+    };
+  }
+  hasDepChanged() {
+    const depModulesInfo = this.getDepsInfo(this.depToModules);
+    const depKeys = Object.keys(depModulesInfo);
+    const snapshotKeys = Object.keys(this.depSnapshotModules);
+    if (depKeys.length !== snapshotKeys.length) {
+      return true;
     }
-    restore(data) {
-        const addNode = ({ file, importer }) => {
-            const mod = new ModuleNode(file);
-            let isDependency = false;
-            let info;
-            if (data.fileModules[file]) {
-                info = data.fileModules[file];
-            }
-            else if (data.depModules[file]) {
-                info = data.depModules[file];
-                isDependency = true;
-            }
-            if (info.isRoot)
-                mod.isRoot = true;
-            if (importer)
-                mod.importers.add(importer);
-            mod.isDependency = isDependency;
-            if (info.version !== undefined) {
-                mod.version = info.version;
-            }
-            if (isDependency) {
-                this.depToModules.set(file, mod);
-            }
-            else {
-                for (const importedModule of info.importedModules) {
-                    addNode({ file: importedModule, importer: mod });
-                }
-                this.fileToModules.set(file, mod);
-            }
-        };
-        for (const root of data.roots) {
-            addNode({ file: root });
-        }
-        this.depSnapshotModules = data.depSnapshotModules;
+    for (const k of depKeys) {
+      const dep = depModulesInfo[k];
+      const snapshot = this.depSnapshotModules[k];
+      if (dep.file !== (snapshot == null ? void 0 : snapshot.file)) {
+        return true;
+      }
+      if (dep.version !== (snapshot == null ? void 0 : snapshot.version)) {
+        return true;
+      }
     }
-    toJSON() {
-        const roots = [];
-        const fileModules = {};
-        const depModules = {};
-        this.depToModules.forEach((value, key) => {
-            depModules[key] = {
-                version: value.version,
-            };
+    return false;
+  }
+  onFileChange(opts) {
+    if (this.fileToModules.has(opts.file)) {
+      const mod = this.fileToModules.get(opts.file);
+      this.updateModule({
+        mod,
+        deps: opts.deps
+      });
+    } else {
+      const mod = new ModuleNode(opts.file);
+      mod.isRoot = true;
+      this.fileToModules.set(opts.file, mod);
+      this.rootModules.add(mod);
+      opts.deps.forEach((dep) => {
+        this.addNode({
+          file: dep.file,
+          isDependency: dep.isDependency,
+          version: dep.version || null,
+          importer: mod
         });
-        this.fileToModules.forEach((value, key) => {
-            fileModules[key] = {
-                importModules: Array.from(value.importedModules).map((item) => item.file),
-            };
-            if (value.isRoot) {
-                roots.push(key);
-            }
-        });
-        return {
-            roots,
-            fileModules,
-            depModules,
-            depSnapshotModules: this.depSnapshotModules,
-        };
-    }
-    snapshotDeps() {
-        this.depSnapshotModules = this.getDepsInfo(this.depToModules);
+      });
     }
-    getDepsInfo(mods) {
-        return Array.from(mods.keys()).reduce((memo, key) => {
-            memo[key] = this.getDepInfo(mods.get(key));
-            return memo;
-        }, {});
+  }
+  updateModule(opts) {
+    const importedModulesMap = Array.from(opts.mod.importedModules).reduce((memo, mod) => {
+      memo[mod.file] = mod;
+      return memo;
+    }, {});
+    const newDeps = [];
+    for (const dep of opts.deps) {
+      if (importedModulesMap[dep.file]) {
+        if (dep.version !== void 0) {
+          importedModulesMap[dep.file].version = dep.version;
+        }
+        delete importedModulesMap[dep.file];
+      } else {
+        newDeps.push(dep);
+      }
     }
-    getDepInfo(mod) {
-        return {
-            file: mod.file,
-            version: mod.version,
-        };
+    Object.keys(importedModulesMap).forEach((key) => {
+      this.deleteNode({ mod: importedModulesMap[key], importer: opts.mod });
+    });
+    newDeps.forEach((dep) => {
+      this.addNode({ ...dep, importer: opts.mod });
+    });
+  }
+  addNode(opts) {
+    const modules = opts.isDependency ? this.depToModules : this.fileToModules;
+    let mod;
+    if (modules.has(opts.file)) {
+      mod = modules.get(opts.file);
+      if (opts.version !== void 0)
+        mod.version = opts.version;
+    } else {
+      mod = new ModuleNode(opts.file);
+      mod.isDependency = opts.isDependency;
+      if (opts.version !== void 0)
+        mod.version = opts.version;
+      modules.set(opts.file, mod);
     }
-    hasDepChanged() {
-        const depModulesInfo = this.getDepsInfo(this.depToModules);
-        return !utils_1.lodash.isEqual(depModulesInfo, this.depSnapshotModules);
+    if (!mod.importers.has(opts.importer)) {
+      mod.importers.add(opts.importer);
     }
-    onFileChange(opts) {
-        if (this.fileToModules.has(opts.file)) {
-            const mod = this.fileToModules.get(opts.file);
-            this.updateModule({
-                mod,
-                deps: opts.deps,
-            });
-        }
-        else {
-            const mod = new ModuleNode(opts.file);
-            mod.isRoot = true;
-            this.fileToModules.set(opts.file, mod);
-            this.rootModules.add(mod);
-            opts.deps.forEach((dep) => {
-                this.addNode({
-                    file: dep.file,
-                    isDependency: dep.isDependency,
-                    version: dep.version || null,
-                    importer: mod,
-                });
-            });
-        }
+    if (!opts.importer.importedModules.has(mod)) {
+      opts.importer.importedModules.add(mod);
     }
-    updateModule(opts) {
-        const importedModulesMap = Array.from(opts.mod.importedModules).reduce((memo, mod) => {
-            memo[mod.file] = mod;
-            return memo;
-        }, {});
-        const newDeps = [];
-        for (const dep of opts.deps) {
-            // update
-            if (importedModulesMap[dep.file]) {
-                if (dep.version !== undefined) {
-                    importedModulesMap[dep.file].version = dep.version;
-                }
-                delete importedModulesMap[dep.file];
-            }
-            // add
-            else {
-                newDeps.push(dep);
-            }
-        }
-        Object.keys(importedModulesMap).forEach((key) => {
-            this.deleteNode({ mod: importedModulesMap[key], importer: opts.mod });
+  }
+  deleteNode(opts) {
+    const modules = opts.mod.isDependency ? this.depToModules : this.fileToModules;
+    const { mod, importer } = opts;
+    mod.importers.delete(opts.importer);
+    importer.importedModules.delete(mod);
+    if (!mod.importers.size) {
+      modules.delete(opts.mod.file);
+      mod.importedModules.forEach((importedModule) => {
+        this.deleteNode({
+          mod: importedModule,
+          importer: mod
         });
-        newDeps.forEach((dep) => {
-            this.addNode(Object.assign(Object.assign({}, dep), { importer: opts.mod }));
-        });
-    }
-    addNode(opts) {
-        const modules = opts.isDependency ? this.depToModules : this.fileToModules;
-        let mod;
-        if (modules.has(opts.file)) {
-            mod = modules.get(opts.file);
-            if (opts.version !== undefined)
-                mod.version = opts.version;
-        }
-        else {
-            mod = new ModuleNode(opts.file);
-            mod.isDependency = opts.isDependency;
-            if (opts.version !== undefined)
-                mod.version = opts.version;
-            modules.set(opts.file, mod);
-        }
-        if (!mod.importers.has(opts.importer)) {
-            mod.importers.add(opts.importer);
-        }
-        if (!opts.importer.importedModules.has(mod)) {
-            opts.importer.importedModules.add(mod);
-        }
-    }
-    deleteNode(opts) {
-        const modules = opts.mod.isDependency
-            ? this.depToModules
-            : this.fileToModules;
-        const { mod, importer } = opts;
-        mod.importers.delete(opts.importer);
-        importer.importedModules.delete(mod);
-        if (!mod.importers.size) {
-            modules.delete(opts.mod.file);
-            mod.importedModules.forEach((importedModule) => {
-                this.deleteNode({
-                    mod: importedModule,
-                    importer: mod,
-                });
-            });
-        }
+      });
     }
-}
-exports.ModuleGraph = ModuleGraph;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleGraph
+});

package/dist/staticDepInfo/importParser.d.ts

@@ -0,0 +1,4 @@
+export default function parse(code: string): {
+    from: string;
+    imports: string[];
+}[];

package/dist/staticDepInfo/importParser.js

@@ -0,0 +1,28 @@
+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/staticDepInfo/importParser.ts
+var importParser_exports = {};
+__export(importParser_exports, {
+  default: () => parse
+});
+module.exports = __toCommonJS(importParser_exports);
+var import_importParser = require("../../vendors/importParser/_importParser.js");
+function parse(code) {
+  return (0, import_importParser.parse)(code);
+}

package/dist/staticDepInfo/simulations/babel-plugin-import.d.ts

@@ -0,0 +1,15 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+import type { Match } from '../staticDepInfo';
+export default function createHandle(importOptions: {
+    libraryName: string;
+    libraryDirectory: string;
+    style: boolean | string;
+    camel2UnderlineComponentName?: boolean;
+    camel2DashComponentName?: boolean;
+}): (opts: {
+    rawCode: string;
+    imports: ImportSpecifier[];
+    mfName: string;
+    alias: Record<string, string>;
+    pathToVersion(p: string): string;
+}) => Match[];

package/dist/staticDepInfo/simulations/babel-plugin-import.js

@@ -0,0 +1,118 @@
+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/simulations/babel-plugin-import.ts
+var babel_plugin_import_exports = {};
+__export(babel_plugin_import_exports, {
+  default: () => createHandle
+});
+module.exports = __toCommonJS(babel_plugin_import_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_getAliasedPath = require("../../babelPlugins/awaitImport/getAliasedPath");
+var import_importParser = __toESM(require("../importParser"));
+function createHandle(importOptions) {
+  const { libraryName, libraryDirectory } = importOptions;
+  const useUnderline = importOptions.camel2UnderlineComponentName;
+  const useDash = importOptions.camel2DashComponentName ?? true;
+  const transformName = useUnderline ? (n) => transCamel(n, "_") : useDash ? (n) => transCamel(n, "-") : (n) => n;
+  const stylePathFromCompPath = importOptions.style === "css" ? (compFsPath) => (0, import_utils.winPath)((0, import_path.join)(compFsPath, "style/css")) : (compFsPath) => (0, import_utils.winPath)((0, import_path.join)(compFsPath, "style"));
+  return function handleImports(opts) {
+    const { imports, rawCode } = opts;
+    if ((imports == null ? void 0 : imports.length) > 0) {
+      let addToMatches = function(moduleFsPath) {
+        const unAliasedModulePath = (0, import_getAliasedPath.getAliasedPathWithLoopDetect)({
+          value: (0, import_utils.winPath)(moduleFsPath),
+          alias: opts.alias
+        });
+        retMatched.push({
+          isMatch: true,
+          value: unAliasedModulePath,
+          replaceValue: `${mfName}/${(0, import_utils.winPath)(unAliasedModulePath)}`,
+          version
+        });
+        const unAliasedStylePath = (0, import_getAliasedPath.getAliasedPathWithLoopDetect)({
+          value: stylePathFromCompPath(moduleFsPath),
+          alias: opts.alias
+        });
+        retMatched.push({
+          isMatch: true,
+          value: unAliasedStylePath,
+          replaceValue: `${mfName}/${(0, import_utils.winPath)(unAliasedStylePath)}`,
+          version
+        });
+      };
+      const version = opts.pathToVersion(libraryName);
+      const importSnippets = imports.map(({ ss, se }) => {
+        return rawCode.slice(ss, se + 1);
+      }).join("\n");
+      const retMatched = [];
+      const parsedImports = (0, import_importParser.default)(importSnippets);
+      const importedVariable = /* @__PURE__ */ new Set();
+      for (const i of parsedImports) {
+        i.imports.forEach((v) => {
+          if (v === "*") {
+            errorLogForSpaceImport(libraryName);
+          }
+          importedVariable.add(v);
+        });
+      }
+      const mfName = opts.mfName;
+      for (const v of importedVariable.entries()) {
+        const importVariableName = v[0];
+        if (importVariableName === "default") {
+          addToMatches((0, import_path.join)(libraryName, libraryDirectory));
+          continue;
+        }
+        const transformedName = transformName(importVariableName);
+        const importFsPath = (0, import_path.join)(
+          libraryName,
+          libraryDirectory,
+          transformedName
+        );
+        addToMatches(importFsPath);
+      }
+      return retMatched;
+    }
+    return [];
+  };
+}
+function transCamel(_str, symbol) {
+  const str = _str[0].toLowerCase() + _str.substr(1);
+  return str.replace(/([A-Z])/g, ($1) => `${symbol}${$1.toLowerCase()}`);
+}
+function errorLogForSpaceImport(libraryName) {
+  import_utils.logger.error(
+    `"import * as ant from 'antd'" or "export * from '${libraryName}'" are not allowed in mfsu#strategy='eager'`
+  );
+  import_utils.logger.error(`solutions:`);
+  import_utils.logger.error(`  change to "import { Xxx } from '${libraryName}'" or`);
+  import_utils.logger.error(`            "export { Xxx } from '${libraryName}'" syntax`);
+  import_utils.logger.error(`  or use mfsu#strategy='normal' configuration`);
+  throw Error(`"import * as ant from 'antd'" not allowed in mfsu#version=4`);
+}