@umijs/mfsu 4.0.0-canary.20220429.3 → 4.0.0-canary.20220506.2

package/dist/moduleGraph.js

@@ -0,0 +1,197 @@
+"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;
+    }
+}
+class ModuleGraph {
+    constructor() {
+        this.fileToModules = new Map();
+        this.depToModules = new Map();
+        this.depSnapshotModules = {};
+        this.rootModules = new Set();
+    }
+    restore(data) {
+        let fileMap = new Map();
+        const addNode = ({ file, importer }) => {
+            // fix circular dependency
+            if (fileMap.has(file))
+                return;
+            fileMap.set(file, true);
+            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);
+                importer.importedModules.add(mod);
+            }
+            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;
+    }
+    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) {
+        return {
+            file: mod.file,
+            version: mod.version,
+        };
+    }
+    hasDepChanged() {
+        const depModulesInfo = this.getDepsInfo(this.depToModules);
+        return !utils_1.lodash.isEqual(depModulesInfo, this.depSnapshotModules);
+    }
+    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,
+                });
+            });
+        }
+    }
+    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 });
+        });
+        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 !== 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;

package/dist/types.d.ts

@@ -0,0 +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

@@ -0,0 +1,8 @@
+"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 = {}));

package/dist/utils/makeArray.d.ts

@@ -0,0 +1 @@
+export declare function makeArray(item: any): any[];

package/dist/utils/makeArray.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeArray = void 0;
+function makeArray(item) {
+    return Array.isArray(item) ? item : [item];
+}
+exports.makeArray = makeArray;

package/dist/utils/trimFileContent.d.ts

@@ -0,0 +1 @@
+export declare function trimFileContent(content: string): string;

package/dist/utils/trimFileContent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimFileContent = void 0;
+function trimFileContent(content) {
+    return content.trim() + '\n';
+}
+exports.trimFileContent = trimFileContent;

package/dist/webpackPlugins/buildDepPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler } from 'webpack';
+interface IOpts {
+    onCompileDone: Function;
+}
+export declare class BuildDepPlugin {
+    private opts;
+    constructor(opts: IOpts);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/webpackPlugins/buildDepPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildDepPlugin = void 0;
+const PLUGIN_NAME = 'MFSUBuildDeps';
+class BuildDepPlugin {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    apply(compiler) {
+        compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+            if (!stats.hasErrors()) {
+                this.opts.onCompileDone();
+            }
+        });
+    }
+}
+exports.BuildDepPlugin = BuildDepPlugin;

package/dist/webpackPlugins/depChunkIdPrefixPlugin.d.ts

@@ -0,0 +1,5 @@
+import { Compiler } from 'webpack';
+export declare class DepChunkIdPrefixPlugin {
+    constructor();
+    apply(compiler: Compiler): void;
+}

package/dist/webpackPlugins/depChunkIdPrefixPlugin.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepChunkIdPrefixPlugin = void 0;
+const constants_1 = require("../constants");
+const pluginId = 'MFSUDepChunkIdPrefix';
+class DepChunkIdPrefixPlugin {
+    constructor() { }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(pluginId, (compilation) => {
+            compilation.hooks.afterOptimizeChunkIds.tap(pluginId, (chunks) => {
+                for (const chunk of chunks) {
+                    chunk.id = constants_1.MF_DEP_PREFIX + chunk.id;
+                    chunk.ids = [chunk.id];
+                }
+            });
+        });
+    }
+}
+exports.DepChunkIdPrefixPlugin = DepChunkIdPrefixPlugin;

package/dist/webpackPlugins/stripSourceMapUrlPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler } from 'webpack';
+interface IOpts {
+    webpack: any;
+}
+export declare class StripSourceMapUrlPlugin {
+    opts: IOpts;
+    constructor(opts: IOpts);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/webpackPlugins/stripSourceMapUrlPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripSourceMapUrlPlugin = void 0;
+class StripSourceMapUrlPlugin {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('StripSourceMapUrlPlugin', (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: 'StripSourceMapUrlPlugin',
+                stage: this.opts.webpack.Compilation.PROCESS_ASSETS_STAGE_DERIVE,
+            }, (assets) => {
+                Object.keys(assets)
+                    .filter((filename) => /\.js$/.test(filename))
+                    .forEach((filename) => {
+                    const asset = assets[filename];
+                    const source = asset
+                        .source()
+                        .toString()
+                        .replace(/# sourceMappingURL=(.+?\.map)/g, '# $1');
+                    compilation.updateAsset(filename, new this.opts.webpack.sources.RawSource(source));
+                });
+            });
+        });
+    }
+}
+exports.StripSourceMapUrlPlugin = StripSourceMapUrlPlugin;

package/dist/webpackPlugins/writeCachePlugin.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler } from 'webpack';
+interface IOpts {
+    onWriteCache: Function;
+}
+export declare class WriteCachePlugin {
+    private opts;
+    constructor(opts: IOpts);
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/webpackPlugins/writeCachePlugin.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteCachePlugin = void 0;
+const PLUGIN_NAME = 'MFSUWriteCache';
+class WriteCachePlugin {
+    constructor(opts) {
+        this.opts = opts;
+    }
+    apply(compiler) {
+        compiler.cache.hooks.store.tap({ name: PLUGIN_NAME, stage: /*Cache.STAGE_DISK*/ 10 }, () => {
+            this.opts.onWriteCache();
+        });
+    }
+}
+exports.WriteCachePlugin = WriteCachePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/mfsu",
-  "version": "4.0.0-canary.20220429.3",
+  "version": "4.0.0-canary.20220506.2",
   "description": "@umijs/mfsu",
   "homepage": "https://github.com/umijs/umi-next/tree/master/packages/mfsu#readme",
   "bugs": "https://github.com/umijs/umi-next/issues",
@@ -22,9 +22,9 @@
     "test": "umi-scripts jest-turbo"
   },
   "dependencies": {
-    "@umijs/bundler-esbuild": "4.0.0-canary.20220429.3",
-    "@umijs/bundler-utils": "4.0.0-canary.20220429.3",
-    "@umijs/utils": "4.0.0-canary.20220429.3",
+    "@umijs/bundler-esbuild": "4.0.0-canary.20220506.2",
+    "@umijs/bundler-utils": "4.0.0-canary.20220506.2",
+    "@umijs/utils": "4.0.0-canary.20220506.2",
     "enhanced-resolve": "5.9.2"
   },
   "devDependencies": {