@module-federation/manifest 2.0.0 → 2.0.1

package/dist/StatsManager.mjs

@@ -0,0 +1,456 @@
+import fs from "fs";
+import path from "path";
+import { MFPrefetchCommon, composeKeyWithSeparator, encodeName, getManifestFileName } from "@module-federation/sdk";
+import { assert, findChunk, getAssetsByChunk, getAssetsByChunkIDs, getFileNameWithOutExt, getSharedModules, getTypesMetaInfo } from "./utils.mjs";
+import logger from "./logger.mjs";
+import { ContainerManager, PKGJsonManager, RemoteManager, SharedManager, UNKNOWN_MODULE_NAME, utils } from "@module-federation/managers";
+import { HOT_UPDATE_SUFFIX } from "./constants.mjs";
+import { ModuleHandler, getExposeItem, getExposeName, getShareItem } from "./ModuleHandler.mjs";
+
+;// CONCATENATED MODULE: external "fs"
+
+;// CONCATENATED MODULE: external "path"
+
+;// CONCATENATED MODULE: external "@module-federation/sdk"
+
+;// CONCATENATED MODULE: external "./utils.mjs"
+
+;// CONCATENATED MODULE: external "./logger.mjs"
+
+;// CONCATENATED MODULE: external "@module-federation/managers"
+
+;// CONCATENATED MODULE: external "./constants.mjs"
+
+;// CONCATENATED MODULE: external "./ModuleHandler.mjs"
+
+;// CONCATENATED MODULE: ./src/StatsManager.ts
+/* eslint-disable max-lines-per-function */ /* eslint-disable @typescript-eslint/member-ordering */ /* eslint-disable max-depth */ 
+
+
+
+
+
+
+
+class StatsManager {
+    getBuildInfo(context, target) {
+        const rootPath = context || process.cwd();
+        const pkg = this._pkgJsonManager.readPKGJson(rootPath);
+        const statsBuildInfo = {
+            buildVersion: utils.getBuildVersion(rootPath),
+            buildName: utils.getBuildName() || pkg['name']
+        };
+        if (this._sharedManager.enableTreeShaking) {
+            statsBuildInfo.target = target ? Array.isArray(target) ? target : [
+                target
+            ] : [];
+            statsBuildInfo.plugins = this._options.treeShakingSharedPlugins || [];
+            statsBuildInfo.excludePlugins = this._options.treeShakingSharedExcludePlugins || [];
+        }
+        return statsBuildInfo;
+    }
+    get fileName() {
+        return getManifestFileName(this._options.manifest).statsFileName;
+    }
+    setMetaDataPublicPath(metaData, compiler) {
+        if (this._options.getPublicPath) {
+            if ('publicPath' in metaData) {
+                // @ts-ignore
+                delete metaData.publicPath;
+            }
+            metaData.getPublicPath = this._options.getPublicPath;
+        } else {
+            metaData.publicPath = this.getPublicPath(compiler);
+        }
+        return metaData;
+    }
+    _getMetaData(compiler, compilation, extraOptions) {
+        var _this__options_library, _this__options;
+        const { context } = compiler.options;
+        const { _options: { name } } = this;
+        const buildInfo = this.getBuildInfo(context, compilation.options.target || '');
+        const type = this._pkgJsonManager.getExposeGarfishModuleType(context || process.cwd());
+        const getRemoteEntryName = ()=>{
+            if (!this._containerManager.enable) {
+                return '';
+            }
+            assert(name, 'name is required');
+            const remoteEntryPoint = compilation.entrypoints.get(name);
+            assert(remoteEntryPoint, 'Can not get remoteEntry entryPoint!');
+            const remoteEntryNameChunk = compilation.namedChunks.get(name);
+            assert(remoteEntryNameChunk, 'Can not get remoteEntry chunk!');
+            const files = Array.from(remoteEntryNameChunk.files).filter((f)=>!f.includes(HOT_UPDATE_SUFFIX) && !f.endsWith('.css'));
+            assert(files.length > 0, 'no files found for remoteEntry chunk');
+            assert(files.length === 1, `remoteEntry chunk should not have multiple files!, current files: ${files.join(',')}`);
+            const remoteEntryName = files[0];
+            return remoteEntryName;
+        };
+        const globalName = this._containerManager.globalEntryName;
+        assert(globalName, 'Can not get library.name, please ensure you have set library.name and the type is "string" !');
+        assert(this._pluginVersion, 'Can not get pluginVersion, please ensure you have set pluginVersion !');
+        const metaData = {
+            name: name,
+            type,
+            buildInfo,
+            remoteEntry: {
+                name: getRemoteEntryName(),
+                path: '',
+                // same as the types supported by runtime, currently only global/var/script is supported
+                type: ((_this__options = this._options) === null || _this__options === void 0 ? void 0 : (_this__options_library = _this__options.library) === null || _this__options_library === void 0 ? void 0 : _this__options_library.type) || 'global'
+            },
+            types: getTypesMetaInfo(this._options, compiler.context),
+            globalName: globalName,
+            pluginVersion: this._pluginVersion
+        };
+        let prefetchInterface = false;
+        const prefetchFilePath = path.resolve(compiler.options.context || process.cwd(), `node_modules/.mf/${encodeName(name)}/${MFPrefetchCommon.fileName}`);
+        const existPrefetch = fs.existsSync(prefetchFilePath);
+        if (existPrefetch) {
+            const content = fs.readFileSync(prefetchFilePath).toString();
+            if (content) {
+                prefetchInterface = true;
+            }
+        }
+        metaData.prefetchInterface = prefetchInterface;
+        return this.setMetaDataPublicPath(metaData, compiler);
+    }
+    _getFilteredModules(stats) {
+        const filteredModules = stats.modules.filter((module)=>{
+            if (!module || !module.name) {
+                return false;
+            }
+            const array = [
+                module.name.includes('container entry'),
+                module.name.includes('remote '),
+                module.name.includes('shared module '),
+                module.name.includes('provide module ')
+            ];
+            return array.some((item)=>item);
+        });
+        return filteredModules;
+    }
+    _getModuleAssets(compilation, entryPointNames) {
+        const { chunks } = compilation;
+        const { exposeFileNameImportMap } = this._containerManager;
+        const assets = {};
+        chunks.forEach((chunk)=>{
+            if (typeof chunk.name === 'string' && exposeFileNameImportMap[chunk.name]) {
+                // TODO: support multiple import
+                const exposeKey = exposeFileNameImportMap[chunk.name][0];
+                assets[getFileNameWithOutExt(exposeKey)] = getAssetsByChunk(chunk, entryPointNames);
+            }
+        });
+        return assets;
+    }
+    _getProvideSharedAssets(compilation, stats, entryPointNames) {
+        const sharedModules = stats.modules.filter((module)=>{
+            if (!module || !module.name) {
+                return false;
+            }
+            const array = [
+                module.name.includes('consume shared module ')
+            ];
+            return array.some((item)=>item);
+        });
+        const manifestOverrideChunkIDMap = {};
+        const effectiveSharedModules = getSharedModules(stats, sharedModules);
+        effectiveSharedModules.forEach((item)=>{
+            const [sharedModuleName, sharedModule] = item;
+            if (!manifestOverrideChunkIDMap[sharedModuleName]) {
+                manifestOverrideChunkIDMap[sharedModuleName] = {
+                    async: new Set(),
+                    sync: new Set()
+                };
+            }
+            sharedModule.chunks.forEach((chunkID)=>{
+                const chunk = findChunk(chunkID, compilation.chunks);
+                manifestOverrideChunkIDMap[sharedModuleName].sync.add(chunkID);
+                if (!chunk) {
+                    return;
+                }
+                [
+                    ...chunk.groupsIterable
+                ].forEach((group)=>{
+                    if (group.name && !entryPointNames.includes(group.name)) {
+                        manifestOverrideChunkIDMap[sharedModuleName].sync.add(group.id);
+                    }
+                });
+            });
+        });
+        const assets = {
+            js: {
+                async: [],
+                sync: []
+            },
+            css: {
+                async: [],
+                sync: []
+            }
+        };
+        Object.keys(manifestOverrideChunkIDMap).forEach((override)=>{
+            const asyncAssets = getAssetsByChunkIDs(compilation, {
+                [override]: manifestOverrideChunkIDMap[override].async
+            });
+            const syncAssets = getAssetsByChunkIDs(compilation, {
+                [override]: manifestOverrideChunkIDMap[override].sync
+            });
+            assets[override] = {
+                js: {
+                    async: asyncAssets[override].js,
+                    sync: syncAssets[override].js
+                },
+                css: {
+                    async: asyncAssets[override].css,
+                    sync: syncAssets[override].css
+                }
+            };
+        });
+        return assets;
+    }
+    async _generateStats(compiler, compilation, extraOptions) {
+        try {
+            const { name, manifest: manifestOptions = {}, exposes = {} } = this._options;
+            const metaData = this._getMetaData(compiler, compilation, extraOptions);
+            const stats = {
+                id: name,
+                name: name,
+                metaData,
+                shared: [],
+                remotes: [],
+                exposes: []
+            };
+            if (typeof manifestOptions === 'object' && manifestOptions.disableAssetsAnalyze) {
+                const remotes = this._remoteManager.statsRemoteWithEmptyUsedIn;
+                stats.remotes = remotes;
+                stats.exposes = Object.keys(exposes).map((exposeKey)=>{
+                    return getExposeItem({
+                        exposeKey,
+                        name: name,
+                        file: {
+                            import: exposes[exposeKey].import
+                        }
+                    });
+                });
+                stats.shared = Object.entries(this._sharedManager.normalizedOptions).reduce((sum, cur)=>{
+                    const [pkgName, normalizedShareOptions] = cur;
+                    sum.push(getShareItem({
+                        pkgName,
+                        normalizedShareOptions,
+                        pkgVersion: normalizedShareOptions.version || UNKNOWN_MODULE_NAME,
+                        hostName: name
+                    }));
+                    return sum;
+                }, []);
+                return stats;
+            }
+            const liveStats = compilation.getStats();
+            const statsOptions = {
+                all: false,
+                modules: true,
+                builtAt: true,
+                hash: true,
+                ids: true,
+                version: true,
+                entrypoints: true,
+                assets: false,
+                chunks: false,
+                reasons: true
+            };
+            if (this._bundler === 'webpack') {
+                statsOptions['cached'] = true;
+            }
+            statsOptions['cachedModules'] = true;
+            const webpackStats = liveStats.toJson(statsOptions);
+            const filteredModules = this._getFilteredModules(webpackStats);
+            const moduleHandler = new ModuleHandler(this._options, filteredModules, {
+                bundler: this._bundler
+            });
+            const { remotes, exposesMap, sharedMap } = moduleHandler.collect();
+            const entryPointNames = [
+                ...compilation.entrypoints.values()
+            ].map((e)=>e.name).filter((v)=>!!v);
+            await Promise.all([
+                new Promise((resolve)=>{
+                    const sharedAssets = this._getProvideSharedAssets(compilation, webpackStats, entryPointNames);
+                    Object.keys(sharedMap).forEach((sharedKey)=>{
+                        const assets = sharedAssets[sharedKey];
+                        if (assets) {
+                            sharedMap[sharedKey].assets = assets;
+                        }
+                    });
+                    resolve();
+                }),
+                new Promise((resolve)=>{
+                    const moduleAssets = this._getModuleAssets(compilation, entryPointNames);
+                    Object.keys(exposesMap).forEach((exposeKey)=>{
+                        const assets = moduleAssets[exposeKey];
+                        if (assets) {
+                            exposesMap[exposeKey].assets = assets;
+                        }
+                        exposesMap[exposeKey].requires = Array.from(new Set(exposesMap[exposeKey].requires));
+                    });
+                    resolve();
+                })
+            ]);
+            await Promise.all([
+                new Promise((resolve)=>{
+                    const remoteMemo = new Set();
+                    stats.remotes = remotes.map((remote)=>{
+                        remoteMemo.add(remote.federationContainerName);
+                        return {
+                            ...remote,
+                            usedIn: Array.from(remote.usedIn.values())
+                        };
+                    });
+                    const statsRemoteWithEmptyUsedIn = this._remoteManager.statsRemoteWithEmptyUsedIn;
+                    statsRemoteWithEmptyUsedIn.forEach((remoteInfo)=>{
+                        if (!remoteMemo.has(remoteInfo.federationContainerName)) {
+                            stats.remotes.push(remoteInfo);
+                        }
+                    });
+                    resolve();
+                }),
+                new Promise((resolve)=>{
+                    stats.shared = Object.values(sharedMap).map((shared)=>({
+                            ...shared,
+                            usedIn: Array.from(shared.usedIn)
+                        }));
+                    resolve();
+                })
+            ]);
+            await new Promise((resolve)=>{
+                const sharedAssets = stats.shared.reduce((sum, shared)=>{
+                    const { js, css } = shared.assets;
+                    [
+                        ...js.sync,
+                        ...js.async,
+                        ...css.async,
+                        css.sync
+                    ].forEach((asset)=>{
+                        sum.add(asset);
+                    });
+                    return sum;
+                }, new Set());
+                const { fileExposeKeyMap } = this._containerManager;
+                stats.exposes = [];
+                Object.entries(fileExposeKeyMap).forEach(([exposeFileWithoutExt, exposeKeySet])=>{
+                    const expose = exposesMap[exposeFileWithoutExt] || {
+                        assets: {
+                            js: {
+                                sync: [],
+                                async: []
+                            },
+                            css: {
+                                sync: [],
+                                async: []
+                            }
+                        }
+                    };
+                    exposeKeySet.forEach((exposeKey)=>{
+                        const { js, css } = expose.assets;
+                        const exposeModuleName = getExposeName(exposeKey);
+                        stats.exposes.push({
+                            ...expose,
+                            path: exposeKey,
+                            id: composeKeyWithSeparator(this._options.name, exposeModuleName),
+                            name: exposeModuleName,
+                            assets: {
+                                js: {
+                                    sync: js.sync.filter((asset)=>!sharedAssets.has(asset)),
+                                    async: js.async.filter((asset)=>!sharedAssets.has(asset))
+                                },
+                                css: {
+                                    sync: css.sync.filter((asset)=>!sharedAssets.has(asset)),
+                                    async: css.async.filter((asset)=>!sharedAssets.has(asset))
+                                }
+                            }
+                        });
+                    });
+                });
+                Object.values(exposesMap).map((expose)=>{
+                    const { js, css } = expose.assets;
+                    return {
+                        ...expose,
+                        assets: {
+                            js: {
+                                sync: js.sync.filter((asset)=>!sharedAssets.has(asset)),
+                                async: js.async.filter((asset)=>!sharedAssets.has(asset))
+                            },
+                            css: {
+                                sync: css.sync.filter((asset)=>!sharedAssets.has(asset)),
+                                async: css.async.filter((asset)=>!sharedAssets.has(asset))
+                            }
+                        }
+                    };
+                });
+                resolve();
+            });
+            return stats;
+        } catch (err) {
+            throw err;
+        }
+    }
+    getPublicPath(compiler) {
+        if (this._publicPath) {
+            return this._publicPath;
+        }
+        const { output: { publicPath: originalPublicPath } } = compiler.options;
+        let publicPath = originalPublicPath;
+        this._publicPath = publicPath;
+        return publicPath;
+    }
+    init(options, { pluginVersion, bundler }) {
+        this._options = options;
+        this._pluginVersion = pluginVersion;
+        this._bundler = bundler;
+        this._containerManager = new ContainerManager();
+        this._containerManager.init(options);
+        this._remoteManager = new RemoteManager();
+        this._remoteManager.init(options);
+        this._sharedManager = new SharedManager();
+        this._sharedManager.init(options);
+    }
+    updateStats(stats, compiler) {
+        const { metaData } = stats;
+        if (!metaData.types) {
+            metaData.types = getTypesMetaInfo(this._options, compiler.context);
+        }
+        if (!metaData.pluginVersion) {
+            metaData.pluginVersion = this._pluginVersion;
+        }
+        this.setMetaDataPublicPath(metaData, compiler);
+        // rspack not support legacy prefetch, and this field should be removed in the future
+        metaData.prefetchInterface = false;
+        return stats;
+    }
+    async generateStats(compiler, compilation) {
+        try {
+            const stats = await this._generateStats(compiler, compilation);
+            return stats;
+        } catch (err) {
+            throw err;
+        }
+    }
+    validate(compiler) {
+        const { output: { publicPath } } = compiler.options;
+        if (typeof publicPath !== 'string') {
+            logger.warn(`Manifest will not generate, because publicPath can only be string, but got '${publicPath}'`);
+            return false;
+        } else if (publicPath === 'auto') {
+            logger.warn(`Manifest will use absolute path resolution via its host at runtime, reason: publicPath='${publicPath}'`);
+            return true;
+        }
+        return true;
+    }
+    constructor(){
+        this._options = {};
+        this._bundler = 'webpack';
+        this._containerManager = new ContainerManager();
+        this._remoteManager = new RemoteManager();
+        this._sharedManager = new SharedManager();
+        this._pkgJsonManager = new PKGJsonManager();
+    }
+}
+
+
+export { StatsManager };

package/dist/StatsPlugin.js

@@ -0,0 +1,171 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+/************************************************************************/
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  StatsPlugin: () => (/* binding */ StatsPlugin)
+});
+
+;// CONCATENATED MODULE: external "@module-federation/sdk"
+const sdk_namespaceObject = require("@module-federation/sdk");
+;// CONCATENATED MODULE: external "./ManifestManager.js"
+const external_ManifestManager_js_namespaceObject = require("./ManifestManager.js");
+;// CONCATENATED MODULE: external "./StatsManager.js"
+const external_StatsManager_js_namespaceObject = require("./StatsManager.js");
+;// CONCATENATED MODULE: external "./constants.js"
+const external_constants_js_namespaceObject = require("./constants.js");
+;// CONCATENATED MODULE: external "./logger.js"
+const external_logger_js_namespaceObject = require("./logger.js");
+var external_logger_js_default = /*#__PURE__*/__webpack_require__.n(external_logger_js_namespaceObject);
+;// CONCATENATED MODULE: ./src/StatsPlugin.ts
+
+
+
+
+
+class StatsPlugin {
+    apply(compiler) {
+        (0,sdk_namespaceObject.bindLoggerToCompiler)((external_logger_js_default()), compiler, external_constants_js_namespaceObject.PLUGIN_IDENTIFIER);
+        if (!this._enable) {
+            return;
+        }
+        const res = this._statsManager.validate(compiler);
+        if (!res) {
+            return;
+        }
+        compiler.hooks.thisCompilation.tap('generateStats', (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: 'generateStats',
+                // @ts-ignore use runtime variable in case peer dep not installed
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+            }, async ()=>{
+                if (this._options.manifest !== false) {
+                    const existedStats = compilation.getAsset(this._statsManager.fileName);
+                    // new rspack should hit
+                    if (existedStats) {
+                        let updatedStats = this._statsManager.updateStats(JSON.parse(existedStats.source.source().toString()), compiler);
+                        if (typeof this._options.manifest === 'object' && this._options.manifest.additionalData) {
+                            updatedStats = await this._options.manifest.additionalData({
+                                stats: updatedStats,
+                                compiler,
+                                compilation,
+                                bundler: this._bundler
+                            }) || updatedStats;
+                        }
+                        compilation.updateAsset(this._statsManager.fileName, new compiler.webpack.sources.RawSource(JSON.stringify(updatedStats, null, 2)));
+                        const updatedManifest = this._manifestManager.updateManifest({
+                            compilation,
+                            stats: updatedStats,
+                            publicPath: this._statsManager.getPublicPath(compiler),
+                            compiler,
+                            bundler: this._bundler
+                        });
+                        const source = new compiler.webpack.sources.RawSource(JSON.stringify(updatedManifest, null, 2));
+                        compilation.updateAsset(this._manifestManager.fileName, source);
+                        return;
+                    }
+                    // webpack + legacy rspack
+                    let stats = await this._statsManager.generateStats(compiler, compilation);
+                    if (typeof this._options.manifest === 'object' && this._options.manifest.additionalData) {
+                        stats = await this._options.manifest.additionalData({
+                            stats,
+                            compiler,
+                            compilation,
+                            bundler: this._bundler
+                        }) || stats;
+                    }
+                    const manifest = await this._manifestManager.generateManifest({
+                        compilation,
+                        stats: stats,
+                        publicPath: this._statsManager.getPublicPath(compiler),
+                        compiler,
+                        bundler: this._bundler
+                    });
+                    compilation.emitAsset(this._statsManager.fileName, new compiler.webpack.sources.RawSource(JSON.stringify(stats, null, 2)));
+                    compilation.emitAsset(this._manifestManager.fileName, new compiler.webpack.sources.RawSource(JSON.stringify(manifest, null, 2)));
+                }
+            });
+        });
+    }
+    constructor(options, { pluginVersion, bundler }){
+        this.name = 'StatsPlugin';
+        this._options = {};
+        this._statsManager = new external_StatsManager_js_namespaceObject.StatsManager();
+        this._manifestManager = new external_ManifestManager_js_namespaceObject.ManifestManager();
+        this._enable = true;
+        this._bundler = 'webpack';
+        try {
+            this._options = options;
+            this._bundler = bundler;
+            this._statsManager.init(this._options, {
+                pluginVersion,
+                bundler
+            });
+            this._manifestManager.init(this._options);
+        } catch (err) {
+            if (err instanceof Error) {
+                err.message = `[ ${external_constants_js_namespaceObject.PLUGIN_IDENTIFIER} ]: Manifest will not generate, because: ${err.message}`;
+            }
+            external_logger_js_default().error(err);
+            this._enable = false;
+        }
+    }
+}
+
+exports.StatsPlugin = __webpack_exports__.StatsPlugin;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["StatsPlugin"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });