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

package/dist/depInfo.js

@@ -1,43 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DepInfo = void 0;
-const utils_1 = require("@umijs/utils");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const moduleGraph_1 = require("./moduleGraph");
-class DepInfo {
-    constructor(opts) {
-        this.moduleGraph = new moduleGraph_1.ModuleGraph();
-        this.cacheDependency = {};
-        this.opts = opts;
-        this.cacheFilePath = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'MFSU_CACHE.json');
+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/depInfo.ts
+var depInfo_exports = {};
+__export(depInfo_exports, {
+  DepInfo: () => DepInfo
+});
+module.exports = __toCommonJS(depInfo_exports);
+var import_utils = require("@umijs/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_moduleGraph = require("./moduleGraph");
+var DepInfo = class {
+  constructor(opts) {
+    this.moduleGraph = new import_moduleGraph.ModuleGraph();
+    this.cacheDependency = {};
+    this.opts = opts;
+    this.cacheFilePath = (0, import_path.join)(this.opts.mfsu.opts.tmpBase, "MFSU_CACHE.json");
+  }
+  shouldBuild() {
+    if (!import_utils.lodash.isEqual(
+      this.cacheDependency,
+      this.opts.mfsu.opts.getCacheDependency()
+    )) {
+      return "cacheDependency has changed";
     }
-    shouldBuild() {
-        if (!utils_1.lodash.isEqual(this.cacheDependency, this.opts.mfsu.opts.getCacheDependency())) {
-            return true;
-        }
-        if (this.moduleGraph.hasDepChanged()) {
-            return true;
-        }
-        return false;
+    if (this.moduleGraph.hasDepChanged()) {
+      return "moduleGraph has changed";
     }
-    snapshot() {
-        this.cacheDependency = this.opts.mfsu.opts.getCacheDependency();
-        this.moduleGraph.snapshotDeps();
+    return false;
+  }
+  snapshot() {
+    this.cacheDependency = this.opts.mfsu.opts.getCacheDependency();
+    this.moduleGraph.snapshotDeps();
+  }
+  loadCache() {
+    if ((0, import_fs.existsSync)(this.cacheFilePath)) {
+      import_utils.logger.info("[MFSU] restore cache");
+      try {
+        const { cacheDependency, moduleGraph } = JSON.parse(
+          (0, import_fs.readFileSync)(this.cacheFilePath, "utf-8")
+        );
+        this.cacheDependency = cacheDependency;
+        this.moduleGraph.restore(moduleGraph);
+      } catch (e) {
+        import_utils.logger.error("[MFSU] restore cache failed", e);
+        import_utils.logger.error("please `rm -rf  node_modules/.cache`, and try again");
+        throw e;
+      }
     }
-    loadCache() {
-        if ((0, fs_1.existsSync)(this.cacheFilePath)) {
-            const { cacheDependency, moduleGraph } = JSON.parse((0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8'));
-            this.cacheDependency = cacheDependency;
-            this.moduleGraph.restore(moduleGraph);
-        }
+  }
+  writeCache() {
+    import_utils.fsExtra.mkdirpSync((0, import_path.dirname)(this.cacheFilePath));
+    const newContent = JSON.stringify(
+      {
+        cacheDependency: this.cacheDependency,
+        moduleGraph: this.moduleGraph.toJSON()
+      },
+      null,
+      2
+    );
+    if ((0, import_fs.existsSync)(this.cacheFilePath) && (0, import_fs.readFileSync)(this.cacheFilePath, "utf-8") === newContent) {
+      return;
     }
-    writeCache() {
-        utils_1.fsExtra.mkdirpSync((0, path_1.dirname)(this.cacheFilePath));
-        (0, fs_1.writeFileSync)(this.cacheFilePath, JSON.stringify({
-            cacheDependency: this.cacheDependency,
-            moduleGraph: this.moduleGraph.toJSON(),
-        }, null, 2), 'utf-8');
-    }
-}
-exports.DepInfo = DepInfo;
+    import_utils.logger.info("[MFSU] write cache");
+    (0, import_fs.writeFileSync)(this.cacheFilePath, newContent, "utf-8");
+  }
+  getDepModules() {
+    return this.moduleGraph.depSnapshotModules;
+  }
+  getCacheFilePath() {
+    return this.cacheFilePath;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DepInfo
+});

package/dist/esbuildHandlers/autoCssModules.d.ts

@@ -0,0 +1,2 @@
+import { IEsbuildLoaderHandlerParams } from '../types';
+export declare function autoCssModulesHandler(opts: IEsbuildLoaderHandlerParams): string;

package/dist/esbuildHandlers/autoCssModules.js

@@ -0,0 +1,48 @@
+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/esbuildHandlers/autoCssModules.ts
+var autoCssModules_exports = {};
+__export(autoCssModules_exports, {
+  autoCssModulesHandler: () => autoCssModulesHandler
+});
+module.exports = __toCommonJS(autoCssModules_exports);
+var import_utils = require("@umijs/utils");
+var CSS_MODULES_QUERY = "?modules";
+var QUERY_LENGTH = CSS_MODULES_QUERY.length;
+function autoCssModulesHandler(opts) {
+  let { code } = opts;
+  let offset = 0;
+  opts.imports.forEach((i) => {
+    if (i.d < 0 && (0, import_utils.isStyleFile)({ filename: i.n })) {
+      const importSegment = code.substring(i.ss + offset, i.s + offset);
+      if (~importSegment.indexOf(" from")) {
+        code = `${code.substring(
+          0,
+          i.e + offset
+        )}${CSS_MODULES_QUERY}${code.substring(i.e + offset)}`;
+        offset += QUERY_LENGTH;
+      }
+    }
+  });
+  return code;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoCssModulesHandler
+});

package/dist/esbuildHandlers/awaitImport/index.d.ts

@@ -0,0 +1,15 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+interface IParams {
+    cache: Map<string, any>;
+    opts: any;
+}
+interface IOpts {
+    code: string;
+    imports: ImportSpecifier[];
+    filePath: string;
+}
+export declare function getImportHandlerV4(params: {
+    resolveImportSource: (source: string) => string;
+}): (opts: IOpts) => string;
+export default function getAwaitImportHandler(params: IParams): (opts: IOpts) => string;
+export {};

package/dist/esbuildHandlers/awaitImport/index.js

@@ -0,0 +1,86 @@
+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/esbuildHandlers/awaitImport/index.ts
+var awaitImport_exports = {};
+__export(awaitImport_exports, {
+  default: () => getAwaitImportHandler,
+  getImportHandlerV4: () => getImportHandlerV4
+});
+module.exports = __toCommonJS(awaitImport_exports);
+var import_checkMatch = require("../../babelPlugins/awaitImport/checkMatch");
+function getImportHandlerV4(params) {
+  return function awaitImportHandler(opts) {
+    let offset = 0;
+    let { code } = opts;
+    const { imports } = opts;
+    imports.forEach((i) => {
+      if (!i.n)
+        return;
+      const isLazyImport = i.d > 0;
+      const from = i.n;
+      const replaceValue = params.resolveImportSource(from);
+      if (replaceValue !== from) {
+        const preSeg = code.substring(0, i.s + offset);
+        const tailSeg = code.substring(i.e + offset);
+        const quote = isLazyImport ? '"' : "";
+        code = `${preSeg}${quote}${replaceValue}${quote}${tailSeg}`;
+        offset += replaceValue.length - from.length;
+      }
+    });
+    return code;
+  };
+}
+function getAwaitImportHandler(params) {
+  return function awaitImportHandler(opts) {
+    var _a, _b;
+    let offset = 0;
+    let { code } = opts;
+    const { filePath, imports } = opts;
+    imports.forEach((i) => {
+      if (!i.n)
+        return;
+      const isLazyImport = i.d > 0;
+      const from = i.n;
+      const { isMatch, replaceValue } = (0, import_checkMatch.checkMatch)({
+        cache: params.cache,
+        value: from,
+        opts: params.opts,
+        filename: filePath
+      });
+      if (isMatch) {
+        const preSeg = code.substring(0, i.s + offset);
+        const tailSeg = code.substring(i.e + offset);
+        const quote = isLazyImport ? '"' : "";
+        code = `${preSeg}${quote}${replaceValue}${quote}${tailSeg}`;
+        offset += replaceValue.length - from.length;
+      }
+    });
+    if (params.cache.has(filePath)) {
+      (_b = (_a = params.opts).onCollect) == null ? void 0 : _b.call(_a, {
+        file: filePath,
+        data: params.cache.get(filePath)
+      });
+    }
+    return code;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getImportHandlerV4
+});

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './constants';
-export * from './mfsu';
-//# sourceMappingURL=index.d.ts.map
+export * from './esbuildHandlers/autoCssModules';
+export { esbuildLoader } from './loader/esbuild';
+export * from './mfsu/mfsu';

package/dist/index.js

@@ -1,14 +1,36 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./constants"), exports);
-__exportStar(require("./mfsu"), exports);
+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, {
+  esbuildLoader: () => import_esbuild.esbuildLoader
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./constants"), module.exports);
+__reExport(src_exports, require("./esbuildHandlers/autoCssModules"), module.exports);
+var import_esbuild = require("./loader/esbuild");
+__reExport(src_exports, require("./mfsu/mfsu"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  esbuildLoader,
+  ...require("./constants"),
+  ...require("./esbuildHandlers/autoCssModules"),
+  ...require("./mfsu/mfsu")
+});

package/dist/loader/esbuild.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from 'webpack';
+import type { IEsbuildLoaderOpts } from '../types';
+declare function esbuildTranspiler(this: LoaderContext<IEsbuildLoaderOpts>, source: string): Promise<void>;
+export default esbuildTranspiler;
+export declare const esbuildLoader: string;

package/dist/loader/esbuild.js

@@ -0,0 +1,79 @@
+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/loader/esbuild.ts
+var esbuild_exports = {};
+__export(esbuild_exports, {
+  default: () => esbuild_default,
+  esbuildLoader: () => esbuildLoader
+});
+module.exports = __toCommonJS(esbuild_exports);
+var import_es_module_lexer = require("@umijs/bundler-utils/compiled/es-module-lexer");
+var import_esbuild = require("@umijs/bundler-utils/compiled/esbuild");
+var import_path = require("path");
+var LOADER_MAP = {
+  // js
+  js: "js",
+  cjs: "js",
+  mjs: "js",
+  jsx: "jsx",
+  cjsx: "jsx",
+  mjsx: "jsx",
+  // ts
+  ts: "ts",
+  cts: "ts",
+  mts: "ts",
+  tsx: "tsx",
+  ctsx: "tsx",
+  mtsx: "tsx"
+};
+async function esbuildTranspiler(source) {
+  const done = this.async();
+  const options = this.getOptions();
+  const { handler = [], implementation, ...otherOptions } = options;
+  const transform = (implementation == null ? void 0 : implementation.transform) || import_esbuild.transform;
+  const filePath = this.resourcePath;
+  const ext = (0, import_path.extname)(filePath).slice(1);
+  const loader = LOADER_MAP[ext] ?? "default";
+  const transformOptions = {
+    ...otherOptions,
+    target: options.target ?? "es2015",
+    loader,
+    sourcemap: this.sourceMap,
+    sourcefile: filePath
+  };
+  try {
+    let { code, map } = await transform(source, transformOptions);
+    if (handler.length) {
+      await import_es_module_lexer.init;
+      handler.forEach((handle) => {
+        const [imports, exports] = (0, import_es_module_lexer.parse)(code);
+        code = handle({ code, imports, exports, filePath });
+      });
+    }
+    done(null, code, map && JSON.parse(map));
+  } catch (error) {
+    done(error);
+  }
+}
+var esbuild_default = esbuildTranspiler;
+var esbuildLoader = __filename;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  esbuildLoader
+});

package/dist/mfsu/mfsu.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import type { NextFunction, Request, Response } from '@umijs/bundler-utils/compiled/express';
+import webpack, { Configuration } from 'webpack';
+import type { Worker } from 'worker_threads';
+import { DepBuilder } from '../depBuilder/depBuilder';
+import { DepModule } from '../depInfo';
+import { Mode } from '../types';
+import { IBuildDepPluginOpts } from '../webpackPlugins/buildDepPlugin';
+interface IOpts {
+    cwd?: string;
+    excludeNodeNatives?: boolean;
+    exportAllMembers?: Record<string, string[]>;
+    getCacheDependency?: Function;
+    onMFSUProgress?: Function;
+    mfName?: string;
+    mode?: Mode;
+    tmpBase?: string;
+    unMatchLibs?: Array<string | RegExp>;
+    runtimePublicPath?: boolean | string;
+    implementor: typeof webpack;
+    buildDepWithESBuild?: boolean;
+    depBuildConfig: any;
+    strategy?: 'eager' | 'normal';
+    include?: string[];
+    srcCodeCache?: any;
+    shared?: any;
+    remoteName?: string;
+    remoteAliases?: string[];
+    startBuildWorker: (dep: any[]) => Worker;
+}
+export declare class MFSU {
+    opts: IOpts;
+    alias: Record<string, string>;
+    externals: (Record<string, string> | Function)[];
+    depBuilder: DepBuilder;
+    depConfig: Configuration | null;
+    buildDepsAgain: boolean;
+    progress: any;
+    onProgress: Function;
+    publicPath: string;
+    private strategy;
+    private lastBuildError;
+    constructor(opts: IOpts);
+    asyncImport(content: string): string;
+    setWebpackConfig(opts: {
+        config: Configuration;
+        depConfig: Configuration;
+    }): Promise<void>;
+    buildDeps(opts?: {
+        useWorker: boolean;
+    }): Promise<void>;
+    getMiddlewares(): (((req: Request, res: Response, next: NextFunction) => void) | import("@umijs/bundler-utils/compiled/express/serve-static").RequestHandler<Response<any, Record<string, any>>>)[];
+    getBabelPlugins(): any[][];
+    getEsbuildLoaderHandler(): any[];
+    getCacheFilePath(): string;
+}
+export declare function resolvePublicPath(config: Configuration): string;
+export interface IMFSUStrategy {
+    init(webpackConfig: Configuration): void;
+    shouldBuild(): string | boolean;
+    getBabelPlugin(): any[];
+    getBuildDepPlugConfig(): IBuildDepPluginOpts;
+    loadCache(): void;
+    getCacheFilePath(): string;
+    getDepModules(): Record<string, DepModule>;
+    refresh(): void;
+    writeCache(): void;
+}
+export {};