@umijs/mfsu 4.0.2 → 4.0.3

package/dist/babelPlugins/awaitImport/MFImport.d.ts

@@ -0,0 +1,24 @@
+import * as Babel from '@umijs/bundler-utils/compiled/babel/core';
+import * as t from '@umijs/bundler-utils/compiled/babel/types';
+export interface IOpts {
+    resolveImportSource: (importSource: string) => string;
+    exportAllMembers?: Record<string, string[]>;
+    unMatchLibs?: string[];
+    remoteName?: string;
+    alias?: Record<string, string>;
+    externals?: any;
+}
+export default function (): {
+    visitor: {
+        Program: {
+            exit(path: Babel.NodePath<t.Program>, { opts }: {
+                opts: IOpts;
+            }): void;
+        };
+        CallExpression: {
+            exit(path: Babel.NodePath<t.CallExpression>, { opts }: {
+                opts: IOpts;
+            }): void;
+        };
+    };
+};

package/dist/babelPlugins/awaitImport/MFImport.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const t = __importStar(require("@umijs/bundler-utils/compiled/babel/types"));
+function default_1() {
+    return {
+        visitor: {
+            Program: {
+                exit(path, { opts }) {
+                    let index = path.node.body.length - 1;
+                    while (index >= 0) {
+                        const node = path.node.body[index];
+                        // import x from 'x';
+                        // import * as x from 'x';
+                        // import x, * as xx from 'x';
+                        // import { x } from 'x';
+                        if (t.isImportDeclaration(node)) {
+                            node.source.value = opts.resolveImportSource(node.source.value);
+                        }
+                        // export * from 'x';
+                        else if (t.isExportAllDeclaration(node)) {
+                            node.source.value = opts.resolveImportSource(node.source.value);
+                        }
+                        // export { x } from 'x';
+                        else if (t.isExportNamedDeclaration(node) && node.source) {
+                            node.source.value = opts.resolveImportSource(node.source.value);
+                        }
+                        index -= 1;
+                    }
+                },
+            },
+            CallExpression: {
+                exit(path, { opts }) {
+                    const { node } = path;
+                    if (t.isImport(node.callee) &&
+                        node.arguments.length === 1 &&
+                        node.arguments[0].type === 'StringLiteral') {
+                        const newValue = opts.resolveImportSource(node.arguments[0].value);
+                        node.arguments[0] = t.stringLiteral(newValue);
+                    }
+                },
+            },
+        },
+    };
+}
+exports.default = default_1;

package/dist/babelPlugins/awaitImport/checkMatch.d.ts

@@ -11,6 +11,7 @@ export declare function checkMatch({ value, path, opts, isExportAll, depth, cach
 }): {
     isMatch: boolean;
     replaceValue: string;
+    value: string;
 };
 export declare function getPath({ value, opts }: {
     value: string;

package/dist/babelPlugins/awaitImport/checkMatch.js

@@ -113,6 +113,7 @@ function checkMatch({ value, path, opts, isExportAll, depth, cache, filename, })
     return {
         isMatch,
         replaceValue,
+        value,
     };
 }
 exports.checkMatch = checkMatch;

package/dist/babelPlugins/awaitImport/getAliasedPath.d.ts

@@ -1,4 +1,7 @@
-export declare function getAliasedPath({ value, alias, }: {
+declare type Opts = {
     value: string;
     alias: Record<string, string>;
-}): string | undefined;
+};
+export declare function getAliasedPath({ value, alias }: Opts): string | undefined;
+export declare function getAliasedPathWithLoopDetect({ value, alias }: Opts): string;
+export {};

package/dist/babelPlugins/awaitImport/getAliasedPath.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAliasedPath = void 0;
-function getAliasedPath({ value, alias, }) {
+exports.getAliasedPathWithLoopDetect = exports.getAliasedPath = void 0;
+function getAliasedPath({ value, alias }) {
     const importValue = value;
     // equal alias
     if (alias[value]) {
@@ -28,3 +28,17 @@ exports.getAliasedPath = getAliasedPath;
 function addLastSlash(path) {
     return path.endsWith('/') ? path : `${path}/`;
 }
+function getAliasedPathWithLoopDetect({ value, alias }) {
+    let needUnAlias = value;
+    for (let i = 0; i < 10; i++) {
+        let unAliased = getAliasedPath({ value: needUnAlias, alias });
+        if (unAliased) {
+            needUnAlias = unAliased;
+        }
+        else {
+            return needUnAlias;
+        }
+    }
+    throw Error(`endless loop detected in resolve alias for '${value}', please check your alias config.`);
+}
+exports.getAliasedPathWithLoopDetect = getAliasedPathWithLoopDetect;

package/dist/dep/dep.d.ts

@@ -1,4 +1,4 @@
-import { MFSU } from '../mfsu';
+import { MFSU } from '../mfsu/mfsu';
 export declare class Dep {
     file: string;
     version: string;

package/dist/dep/dep.js

@@ -90,7 +90,7 @@ export * from '${this.file}';
             cwd: dep,
         });
         (0, assert_1.default)(pkg, `package.json not found for ${opts.dep}`);
-        return require(pkg).version;
+        return require(pkg).version || null;
     }
 }
 exports.Dep = Dep;

package/dist/depBuilder/depBuilder.d.ts

@@ -1,5 +1,5 @@
 import { Dep } from '../dep/dep';
-import { MFSU } from '../mfsu';
+import { MFSU } from '../mfsu/mfsu';
 interface IOpts {
     mfsu: MFSU;
 }

package/dist/depInfo.d.ts

@@ -1,17 +1,31 @@
-import { MFSU } from './mfsu';
+import { MFSU } from './mfsu/mfsu';
 import { ModuleGraph } from './moduleGraph';
 interface IOpts {
     mfsu: MFSU;
 }
-export declare class DepInfo {
+export declare type DepModule = {
+    file: string;
+    version: string;
+};
+export interface IDepInfo {
+    shouldBuild(): string | boolean;
+    snapshot(): void;
+    loadCache(): void;
+    writeCache(): void;
+    getCacheFilePath(): string;
+    getDepModules(): Record<string, DepModule>;
+}
+export declare class DepInfo implements IDepInfo {
     private opts;
-    cacheFilePath: string;
+    private readonly cacheFilePath;
     moduleGraph: ModuleGraph;
-    cacheDependency: object;
+    private cacheDependency;
     constructor(opts: IOpts);
     shouldBuild(): false | "cacheDependency has changed" | "moduleGraph has changed";
     snapshot(): void;
     loadCache(): void;
     writeCache(): void;
+    getDepModules(): Record<string, DepModule>;
+    getCacheFilePath(): string;
 }
 export {};

package/dist/depInfo.js

@@ -19,6 +19,7 @@ class DepInfo {
         if (this.moduleGraph.hasDepChanged()) {
             return 'moduleGraph has changed';
         }
+        // fixme always rebuild in dev
         return false;
     }
     snapshot() {
@@ -46,5 +47,11 @@ class DepInfo {
         utils_1.logger.info('[MFSU] write cache');
         (0, fs_1.writeFileSync)(this.cacheFilePath, newContent, 'utf-8');
     }
+    getDepModules() {
+        return this.moduleGraph.depSnapshotModules;
+    }
+    getCacheFilePath() {
+        return this.cacheFilePath;
+    }
 }
 exports.DepInfo = DepInfo;

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

@@ -8,5 +8,8 @@ interface IOpts {
     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

@@ -1,6 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportHandlerV4 = void 0;
 const checkMatch_1 = 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) {
+                // case: import x from './index.ts';
+                //       import('./index.ts');
+                // import x from '
+                // import(
+                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;
+    };
+}
+exports.getImportHandlerV4 = getImportHandlerV4;
 function getAwaitImportHandler(params) {
     return function awaitImportHandler(opts) {
         var _a, _b;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export * from './constants';
 export * from './esbuildHandlers/autoCssModules';
 export { esbuildLoader } from './loader/esbuild';
-export * from './mfsu';
+export * from './mfsu/mfsu';

package/dist/index.js

@@ -20,4 +20,4 @@ __exportStar(require("./esbuildHandlers/autoCssModules"), exports);
 // for independent use `esbuild-loader`
 var esbuild_1 = require("./loader/esbuild");
 Object.defineProperty(exports, "esbuildLoader", { enumerable: true, get: function () { return esbuild_1.esbuildLoader; } });
-__exportStar(require("./mfsu"), exports);
+__exportStar(require("./mfsu/mfsu"), exports);

package/dist/{mfsu.d.ts → mfsu/mfsu.d.ts}

@@ -1,9 +1,10 @@
 import type { NextFunction, Request, Response } from '@umijs/bundler-utils/compiled/express';
+import type { AutoUpdateSrcCodeCache } from '@umijs/utils';
 import webpack, { Configuration } from 'webpack';
-import awaitImport from './babelPlugins/awaitImport/awaitImport';
-import { DepBuilder } from './depBuilder/depBuilder';
-import { DepInfo } from './depInfo';
-import { Mode } from './types';
+import { DepBuilder } from '../depBuilder/depBuilder';
+import { DepModule } from '../depInfo';
+import { Mode } from '../types';
+import { IBuildDepPluginOpts } from '../webpackPlugins/buildDepPlugin';
 interface IOpts {
     cwd?: string;
     excludeNodeNatives?: boolean;
@@ -18,18 +19,21 @@ interface IOpts {
     implementor: typeof webpack;
     buildDepWithESBuild?: boolean;
     depBuildConfig: any;
+    strategy?: 'eager' | 'normal';
+    include?: string[];
+    srcCodeCache?: AutoUpdateSrcCodeCache;
 }
 export declare class MFSU {
     opts: IOpts;
     alias: Record<string, string>;
     externals: (Record<string, string> | Function)[];
-    depInfo: DepInfo;
     depBuilder: DepBuilder;
     depConfig: Configuration | null;
     buildDepsAgain: boolean;
     progress: any;
     onProgress: Function;
     publicPath: string;
+    private strategy;
     constructor(opts: IOpts);
     asyncImport(content: string): string;
     setWebpackConfig(opts: {
@@ -38,26 +42,19 @@ export declare class MFSU {
     }): Promise<void>;
     buildDeps(): Promise<void>;
     getMiddlewares(): ((req: Request, res: Response, next: NextFunction) => void)[];
-    private getAwaitImportCollectOpts;
-    getBabelPlugins(): ({
-        onTransformDeps: () => void;
-        onCollect: ({ file, data, }: {
-            file: string;
-            data: {
-                unMatched: Set<{
-                    sourceValue: string;
-                }>;
-                matched: Set<{
-                    sourceValue: string;
-                }>;
-            };
-        }) => void;
-        exportAllMembers: Record<string, string[]> | undefined;
-        unMatchLibs: string[] | undefined;
-        remoteName: string | undefined;
-        alias: Record<string, string>;
-        externals: (Function | Record<string, string>)[];
-    } | typeof awaitImport)[][];
+    getBabelPlugins(): any[][];
     getEsbuildLoaderHandler(): any[];
+    getCacheFilePath(): string;
+}
+export interface IMFSUStrategy {
+    init(): void;
+    shouldBuild(): string | boolean;
+    getBabelPlugin(): any[];
+    getBuildDepPlugConfig(): IBuildDepPluginOpts;
+    loadCache(): void;
+    getCacheFilePath(): string;
+    getDepModules(): Record<string, DepModule>;
+    refresh(): void;
+    writeCache(): void;
 }
 export {};

package/dist/{mfsu.js → mfsu/mfsu.js}

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,19 +32,18 @@ const utils_1 = require("@umijs/utils");
 const assert_1 = __importDefault(require("assert"));
 const fs_1 = require("fs");
 const path_1 = require("path");
-const mrmime_1 = require("../compiled/mrmime");
+const mrmime_1 = require("../../compiled/mrmime");
 // @ts-ignore
-const webpack_virtual_modules_1 = __importDefault(require("../compiled/webpack-virtual-modules"));
-const awaitImport_1 = __importDefault(require("./babelPlugins/awaitImport/awaitImport"));
-const getRealPath_1 = require("./babelPlugins/awaitImport/getRealPath");
-const constants_1 = require("./constants");
-const dep_1 = require("./dep/dep");
-const depBuilder_1 = require("./depBuilder/depBuilder");
-const depInfo_1 = require("./depInfo");
-const awaitImport_2 = __importDefault(require("./esbuildHandlers/awaitImport"));
-const types_1 = require("./types");
-const makeArray_1 = require("./utils/makeArray");
-const buildDepPlugin_1 = require("./webpackPlugins/buildDepPlugin");
+const webpack_virtual_modules_1 = __importDefault(require("../../compiled/webpack-virtual-modules"));
+const constants_1 = require("../constants");
+const dep_1 = require("../dep/dep");
+const depBuilder_1 = require("../depBuilder/depBuilder");
+const awaitImport_1 = __importStar(require("../esbuildHandlers/awaitImport"));
+const types_1 = require("../types");
+const makeArray_1 = require("../utils/makeArray");
+const buildDepPlugin_1 = require("../webpackPlugins/buildDepPlugin");
+const strategyCompileTime_1 = require("./strategyCompileTime");
+const strategyStaticAnalyze_1 = require("./strategyStaticAnalyze");
 class MFSU {
     constructor(opts) {
         this.alias = {};
@@ -45,9 +67,24 @@ class MFSU {
             (_b = (_a = this.opts).onMFSUProgress) === null || _b === void 0 ? void 0 : _b.call(_a, this.progress);
         };
         this.opts.cwd = this.opts.cwd || process.cwd();
-        this.depInfo = new depInfo_1.DepInfo({ mfsu: this });
+        if (this.opts.strategy === 'eager') {
+            if (opts.srcCodeCache) {
+                utils_1.logger.info('MFSU eager strategy enabled');
+                this.strategy = new strategyStaticAnalyze_1.StaticAnalyzeStrategy({
+                    mfsu: this,
+                    srcCodeCache: opts.srcCodeCache,
+                });
+            }
+            else {
+                utils_1.logger.warn('fallback to MFSU normal strategy, due to srcCache is not provided');
+                this.strategy = new strategyCompileTime_1.StrategyCompileTime({ mfsu: this });
+            }
+        }
+        else {
+            this.strategy = new strategyCompileTime_1.StrategyCompileTime({ mfsu: this });
+        }
+        this.strategy.loadCache();
         this.depBuilder = new depBuilder_1.DepBuilder({ mfsu: this });
-        this.depInfo.loadCache();
     }
     // swc don't support top-level await
     // ref: https://github.com/vercel/next.js/issues/31054
@@ -161,27 +198,7 @@ promise new Promise(resolve => {
                         : `${mfName}@${publicPath}${constants_1.REMOTE_FILE_FULL}`,
                 },
             }),
-            new buildDepPlugin_1.BuildDepPlugin({
-                onCompileDone: () => {
-                    if (this.depBuilder.isBuilding) {
-                        this.buildDepsAgain = true;
-                    }
-                    else {
-                        this.buildDeps()
-                            .then(() => {
-                            this.onProgress({
-                                done: true,
-                            });
-                        })
-                            .catch((e) => {
-                            utils_1.logger.error(e);
-                            this.onProgress({
-                                done: true,
-                            });
-                        });
-                    }
-                },
-            }),
+            new buildDepPlugin_1.BuildDepPlugin(this.strategy.getBuildDepPlugConfig()),
             // new WriteCachePlugin({
             //   onWriteCache: lodash.debounce(() => {
             //     this.depInfo.writeCache();
@@ -194,16 +211,19 @@ promise new Promise(resolve => {
          * depConfig
          */
         this.depConfig = opts.depConfig;
+        this.strategy.init();
     }
     async buildDeps() {
-        const shouldBuild = this.depInfo.shouldBuild();
+        const shouldBuild = this.strategy.shouldBuild();
         if (!shouldBuild) {
             utils_1.logger.info('[MFSU] skip buildDeps');
             return;
         }
-        this.depInfo.snapshot();
+        // Snapshot after compiled success
+        this.strategy.refresh();
+        const staticDeps = this.strategy.getDepModules();
         const deps = dep_1.Dep.buildDeps({
-            deps: this.depInfo.moduleGraph.depSnapshotModules,
+            deps: staticDeps,
             cwd: this.opts.cwd,
             mfsu: this,
         });
@@ -213,7 +233,7 @@ promise new Promise(resolve => {
             deps,
         });
         // Write cache
-        this.depInfo.writeCache();
+        this.strategy.writeCache();
         if (this.buildDepsAgain) {
             utils_1.logger.info('[MFSU] buildDepsAgain');
             this.buildDepsAgain = false;
@@ -246,51 +266,25 @@ promise new Promise(resolve => {
             },
         ];
     }
-    getAwaitImportCollectOpts() {
-        return {
-            onTransformDeps: () => { },
-            onCollect: ({ file, data, }) => {
-                this.depInfo.moduleGraph.onFileChange({
-                    file,
-                    // @ts-ignore
-                    deps: [
-                        ...Array.from(data.matched).map((item) => ({
-                            file: item.sourceValue,
-                            isDependency: true,
-                            version: dep_1.Dep.getDepVersion({
-                                dep: item.sourceValue,
-                                cwd: this.opts.cwd,
-                            }),
-                        })),
-                        ...Array.from(data.unMatched).map((item) => ({
-                            file: (0, getRealPath_1.getRealPath)({
-                                file,
-                                dep: item.sourceValue,
-                            }),
-                            isDependency: false,
-                        })),
-                    ],
-                });
-            },
-            exportAllMembers: this.opts.exportAllMembers,
-            unMatchLibs: this.opts.unMatchLibs,
-            remoteName: this.opts.mfName,
-            alias: this.alias,
-            externals: this.externals,
-        };
-    }
     getBabelPlugins() {
-        return [[awaitImport_1.default, this.getAwaitImportCollectOpts()]];
+        return [this.strategy.getBabelPlugin()];
     }
     getEsbuildLoaderHandler() {
+        if (this.opts.strategy === 'eager') {
+            const opts = this.strategy.getBabelPlugin()[1];
+            return [(0, awaitImport_1.getImportHandlerV4)(opts)];
+        }
         const cache = new Map();
-        const checkOpts = this.getAwaitImportCollectOpts();
+        const checkOpts = this.strategy.getBabelPlugin()[1];
         return [
-            (0, awaitImport_2.default)({
+            (0, awaitImport_1.default)({
                 cache,
                 opts: checkOpts,
             }),
         ];
     }
+    getCacheFilePath() {
+        return this.strategy.getCacheFilePath();
+    }
 }
 exports.MFSU = MFSU;

package/dist/mfsu/strategyCompileTime.d.ts

@@ -0,0 +1,20 @@
+import { DepModule } from '../depInfo';
+import { IBuildDepPluginOpts } from '../webpackPlugins/buildDepPlugin';
+import type { IMFSUStrategy, MFSU } from './mfsu';
+export declare class StrategyCompileTime implements IMFSUStrategy {
+    private readonly mfsu;
+    private depInfo;
+    constructor({ mfsu }: {
+        mfsu: MFSU;
+    });
+    getDepModules(): Record<string, DepModule>;
+    getCacheFilePath(): string;
+    init(): void;
+    shouldBuild(): false | "cacheDependency has changed" | "moduleGraph has changed";
+    loadCache(): void;
+    writeCache(): void;
+    refresh(): void;
+    getBabelPlugin(): any[];
+    getBuildDepPlugConfig(): IBuildDepPluginOpts;
+    private getAwaitImportCollectOpts;
+}