@shuvi/toolpack 2.0.0-dev.12 → 2.0.0-dev.14

package/lib/webpack/dynamic-dll/bundler/rspack-bundler.d.ts

@@ -0,0 +1,22 @@
+import { Configuration } from '@rspack/core';
+import RspackChain from 'rspack-chain';
+import { ModuleSnapshot } from '../moduleCollector';
+export interface BuildOptions {
+    outputDir: string;
+    configRspack?: (chain: RspackChain) => RspackChain;
+    shared?: ShareConfig;
+    externals?: Configuration['externals'];
+    esmFullSpecific?: Boolean;
+    force?: boolean;
+}
+export type ShareConfig = Record<string, any>;
+type OnBuildComplete = (error?: null | Error) => void;
+export declare class RspackBundler {
+    private _nextBuild;
+    private _completeFns;
+    private _isBuilding;
+    build(snapshot: ModuleSnapshot, options: BuildOptions): Promise<void>;
+    private _buildDll;
+    onBuildComplete(fn: OnBuildComplete): void;
+}
+export {};

package/lib/webpack/dynamic-dll/bundler/rspack-bundler.js

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackBundler = void 0;
+const core_1 = require("@rspack/core");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const constants_1 = require("../constants");
+const dep_1 = require("../dep");
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const rspack_config_1 = require("./rspack-config");
+function getHash(text) {
+    return (0, crypto_1.createHash)('sha256').update(text).digest('hex').substring(0, 8);
+}
+/**
+ * hash everything that can change the build result
+ *
+ * @param {BuildOptions} options
+ * @returns {string}
+ */
+function getMainHash(options) {
+    let content = JSON.stringify({
+        shared: options.shared
+    });
+    return getHash([utils_1.version, content].join(''));
+}
+function getBuildHash(hash, snapshot) {
+    return getHash(hash + JSON.stringify(snapshot));
+}
+function getRspackConfigFromOptions({ deps, entry, outputDir, shared, externals, esmFullSpecific }) {
+    const exposes = deps.reduce((memo, dep) => {
+        memo[`./${dep.request}`] = dep.filename;
+        return memo;
+    }, {});
+    const chain = (0, rspack_config_1.getRspackConfig)({
+        name: constants_1.NAME,
+        entry,
+        filename: constants_1.DLL_FILENAME,
+        outputDir,
+        publicPath: constants_1.DEFAULT_PUBLIC_PATH,
+        shared,
+        externals,
+        esmFullSpecific,
+        exposes
+    });
+    return chain.toConfig();
+}
+function buildDeps(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ deps, dir }) {
+        (0, fs_extra_1.mkdirpSync)(dir);
+        // expose files
+        yield Promise.all(deps.map((dep) => __awaiter(this, void 0, void 0, function* () {
+            const content = yield dep.buildExposeContent();
+            yield (0, fs_extra_1.writeFile)(dep.filename, content, 'utf-8');
+        })));
+        // index file - export all modules using valid identifiers
+        const indexContent = deps
+            .map(dep => {
+            const moduleName = dep.request;
+            const filename = dep.filename;
+            // Convert module name to valid identifier
+            const validIdentifier = moduleName.replace(/[^a-zA-Z0-9_$]/g, '_');
+            return `export { default as ${validIdentifier} } from '${filename}';`;
+        })
+            .join('\n');
+        (0, fs_extra_1.writeFileSync)((0, path_1.join)(dir, 'index.js'), indexContent, 'utf-8');
+        return deps;
+    });
+}
+function rspackBuild(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const compiler = (0, core_1.rspack)(config);
+            compiler.run((err, stats) => {
+                if (err || (stats === null || stats === void 0 ? void 0 : stats.hasErrors())) {
+                    if (err) {
+                        reject(err);
+                    }
+                    if (stats) {
+                        const errorMsg = stats.toString('errors-only');
+                        reject(new Error(errorMsg));
+                    }
+                }
+                else {
+                    resolve(stats);
+                }
+                compiler.close(() => { });
+            });
+        });
+    });
+}
+function isSnapshotSame(pre, cur) {
+    const keys = Object.keys(cur);
+    for (let index = 0; index < keys.length; index++) {
+        const id = keys[index];
+        const preItem = pre[id];
+        const nextItem = cur[id];
+        if (!preItem) {
+            return false;
+        }
+        if (preItem.version !== nextItem.version) {
+            return false;
+        }
+    }
+    return true;
+}
+class RspackBundler {
+    constructor() {
+        this._nextBuild = null;
+        this._completeFns = [];
+        this._isBuilding = false;
+    }
+    build(snapshot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isBuilding) {
+                this._nextBuild = snapshot;
+                return;
+            }
+            let error = null;
+            this._isBuilding = true;
+            try {
+                yield this._buildDll(snapshot, options);
+            }
+            catch (err) {
+                error = err;
+            }
+            this._isBuilding = false;
+            if (error) {
+                console.error(`[@shuvi/dll]: Rspack Bundle Error`);
+                console.error(error);
+            }
+            this._completeFns.forEach(fn => fn(error));
+            this._completeFns = [];
+        });
+    }
+    _buildDll(snapshot, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { externals = {}, shared = {}, outputDir, force, esmFullSpecific = true } = options;
+            const mainHash = getMainHash(options);
+            const dllDir = (0, utils_1.getDllDir)(outputDir);
+            const preMetadata = (0, metadata_1.getMetadata)(outputDir);
+            const metadata = {
+                hash: mainHash,
+                buildHash: preMetadata.buildHash,
+                modules: snapshot
+            };
+            if (!force &&
+                preMetadata.hash === metadata.hash &&
+                isSnapshotSame(preMetadata.modules, snapshot)) {
+                return [false, preMetadata];
+            }
+            const dllPendingDir = (0, utils_1.getDllPendingDir)(outputDir);
+            // create a temporal dir to build. This avoids leaving the dll
+            // in a corrupted state if there is an error during the build
+            if ((0, fs_extra_1.existsSync)(dllPendingDir)) {
+                (0, fs_extra_1.emptyDirSync)(dllPendingDir);
+            }
+            const depsDir = (0, utils_1.getDepsDir)(dllPendingDir);
+            const deps = Object.entries(snapshot).map(([request, { version, libraryPath }]) => {
+                return new dep_1.Dep({
+                    request,
+                    libraryPath,
+                    version,
+                    outputPath: depsDir
+                });
+            });
+            yield buildDeps({
+                deps,
+                dir: depsDir
+            });
+            yield rspackBuild(getRspackConfigFromOptions({
+                deps,
+                entry: (0, path_1.join)(depsDir, 'index.js'),
+                shared,
+                externals,
+                esmFullSpecific,
+                outputDir: dllPendingDir
+            }));
+            if (this._nextBuild) {
+                const param = this._nextBuild;
+                this._nextBuild = null;
+                return yield this._buildDll(param, options);
+            }
+            metadata.buildHash = getBuildHash(metadata.hash, snapshot);
+            // finish build
+            (0, metadata_1.writeMetadata)(dllPendingDir, metadata);
+            (0, fs_extra_1.removeSync)(dllDir);
+            (0, fs_extra_1.renameSync)(dllPendingDir, dllDir);
+            return [true, metadata];
+        });
+    }
+    onBuildComplete(fn) {
+        if (this._isBuilding) {
+            this._completeFns.push(fn);
+        }
+        else {
+            fn();
+        }
+    }
+}
+exports.RspackBundler = RspackBundler;

package/lib/webpack/dynamic-dll/bundler/rspack-config.d.ts

@@ -0,0 +1,16 @@
+import RspackChain from 'rspack-chain';
+import type { Configuration } from '@rspack/core';
+type ShareConfig = Record<string, any>;
+export interface ConfigOptions {
+    name: string;
+    entry: string;
+    filename: string;
+    outputDir: string;
+    publicPath: string;
+    shared?: ShareConfig;
+    externals: Configuration['externals'];
+    esmFullSpecific: Boolean;
+    exposes: Record<string, string>;
+}
+export declare function getRspackConfig({ name, entry, filename, outputDir, publicPath, shared, externals, esmFullSpecific, exposes }: ConfigOptions): RspackChain;
+export {};

package/lib/webpack/dynamic-dll/bundler/rspack-config.js

@@ -0,0 +1,140 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRspackConfig = getRspackConfig;
+const rspack = __importStar(require("@rspack/core"));
+const rspack_chain_1 = __importDefault(require("rspack-chain"));
+const moduleFileExtensions = [
+    '.web.mjs',
+    '.mjs',
+    '.web.js',
+    '.js',
+    '.json',
+    '.web.jsx',
+    '.jsx'
+];
+function getRspackConfig({ name, entry, filename, outputDir, publicPath, shared, externals, esmFullSpecific, exposes }) {
+    const config = new rspack_chain_1.default();
+    config.mode('development');
+    config.entry('main').add(entry);
+    config.devtool('cheap-module-source-map');
+    config.bail(true);
+    config.watch(false);
+    config.set('infrastructureLogging', {
+        level: 'none'
+    });
+    config.output.merge({
+        pathinfo: false,
+        path: outputDir,
+        filename: filename,
+        chunkFilename: '[name].js',
+        publicPath,
+        uniqueName: name
+    });
+    config.performance.hints(false);
+    config.optimization.merge({
+        emitOnErrors: true,
+        // need to use DefinePlugin to set process.env.NODE_ENV
+        nodeEnv: false,
+        runtimeChunk: false,
+        minimize: false,
+        realContentHash: false
+    });
+    // Disable splitChunks to avoid chunk naming conflicts
+    config.optimization.splitChunks(false);
+    config.resolve.extensions.merge(moduleFileExtensions);
+    // 添加 Node.js polyfills for browser environment
+    config.resolve.fallback.merge({
+        stream: false,
+        util: false,
+        buffer: false,
+        process: false,
+        assert: false,
+        crypto: false,
+        fs: false,
+        path: false,
+        os: false,
+        http: false,
+        https: false,
+        zlib: false,
+        url: false,
+        querystring: false,
+        events: false,
+        tty: false,
+        net: false,
+        child_process: false
+    });
+    // config.module.set('strictExportPresence', true); // Not supported in Rspack
+    // x-ref: https://github.com/webpack/webpack/issues/11467
+    if (!esmFullSpecific) {
+        config.module
+            .rule('rspackPatch')
+            .test(/\.m?js/)
+            .resolve.set('fullySpecified', false);
+    }
+    config.module
+        .rule('js')
+        .test(/\.(js|mjs|cjs|jsx)$/)
+        .use('esbuild-loader')
+        .loader(require.resolve('esbuild-loader'))
+        .options({
+        loader: 'jsx', // Remove this if you're not using JSX
+        target: 'es2015' // Syntax to compile to (see options below for possible values)
+    });
+    // Rspack cache configuration - simplified for now
+    // TODO: Implement proper cache configuration when Rspack supports it
+    config.cache(false);
+    config.plugin('private/ignore-plugin').use(rspack.IgnorePlugin, [
+        {
+            resourceRegExp: /^\.\/locale$/,
+            contextRegExp: /moment$/
+        }
+    ]);
+    config.plugin('define').use(rspack.DefinePlugin, [
+        {
+            'process.env.NODE_ENV': JSON.stringify('development')
+        }
+    ]);
+    // 使用 ModuleFederationPlugin 来暴露模块
+    config
+        .plugin('module-federation')
+        .use(rspack.container.ModuleFederationPlugin, [
+        {
+            name: name,
+            filename: 'remoteEntry.js',
+            exposes: exposes,
+            shared: {
+            // 共享依赖配置
+            }
+        }
+    ]);
+    if (externals) {
+        config.externals(externals);
+    }
+    return config;
+}

package/lib/webpack/dynamic-dll/plugin/rspack-dynamic-dll-plugin.d.ts

@@ -0,0 +1,20 @@
+import type { Compiler } from '@rspack/core';
+import { ModuleCollectorOptions, ModuleSnapshot } from '../moduleCollector';
+export type SnapshotListener = (snapshot: ModuleSnapshot) => void;
+export interface RspackDynamicDLLPluginOptions {
+    resolveRspackModule: (s: string) => ReturnType<typeof require>;
+    dllName: string;
+    onSnapshot: SnapshotListener;
+    shareScope?: string;
+}
+export declare class RspackDynamicDLLPlugin {
+    private _collector;
+    private _dllName;
+    private _timer;
+    private _matchCache;
+    private _onSnapshot;
+    private _disabled;
+    constructor(opts: RspackDynamicDLLPluginOptions & ModuleCollectorOptions);
+    disableDllReference(): void;
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/dynamic-dll/plugin/rspack-dynamic-dll-plugin.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackDynamicDLLPlugin = void 0;
+const moduleCollector_1 = require("../moduleCollector");
+const PLUGIN_NAME = 'RspackDLLBuildDeps';
+class RspackDynamicDLLPlugin {
+    constructor(opts) {
+        this._dllName = opts.dllName;
+        this._onSnapshot = opts.onSnapshot;
+        this._collector = (0, moduleCollector_1.getModuleCollector)({
+            include: opts.include,
+            exclude: opts.exclude
+        });
+        this._matchCache = new Map();
+        this._timer = null;
+        this._disabled = false;
+    }
+    disableDllReference() {
+        this._disabled = true;
+    }
+    apply(compiler) {
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, nmf => {
+            nmf.hooks.beforeResolve.tap(PLUGIN_NAME, resolveData => {
+                const { request } = resolveData;
+                // Check cache first
+                const replaceValue = this._matchCache.get(request);
+                if (replaceValue) {
+                    resolveData.request = replaceValue;
+                    return;
+                }
+                // For beforeResolve, we can't use full ModuleCollector logic since we don't have resource yet
+                // So we'll do a basic check for node_modules requests and let createModule handle the rest
+                if (!this._disabled &&
+                    request &&
+                    !request.startsWith('.') &&
+                    !request.startsWith('/')) {
+                    // Basic check: if it looks like a node_modules request, we'll redirect it
+                    // The actual filtering will happen in createModule
+                    const name = this._dllName;
+                    const dllRequest = `${name}/${request}`;
+                    resolveData.request = dllRequest;
+                    this._matchCache.set(request, dllRequest);
+                }
+            });
+            nmf.hooks.createModule.tap(PLUGIN_NAME, (_createData, resolveData) => {
+                const createData = (resolveData === null || resolveData === void 0 ? void 0 : resolveData.createData) || {};
+                const request = (resolveData === null || resolveData === void 0 ? void 0 : resolveData.request) || '';
+                const resource = (createData === null || createData === void 0 ? void 0 : createData.resource) || '';
+                const context = (resolveData === null || resolveData === void 0 ? void 0 : resolveData.context) || '';
+                if (!this._collector.shouldCollect({
+                    request,
+                    context,
+                    resource
+                })) {
+                    return;
+                }
+                const resourceResolveData = (createData === null || createData === void 0 ? void 0 : createData.resourceResolveData) || {};
+                const descriptionFileData = (resourceResolveData === null || resourceResolveData === void 0 ? void 0 : resourceResolveData.descriptionFileData) || {};
+                const version = (descriptionFileData === null || descriptionFileData === void 0 ? void 0 : descriptionFileData.version) || null;
+                this._collector.add(request, {
+                    libraryPath: resource,
+                    version
+                });
+                if (this._disabled) {
+                    return;
+                }
+                const name = this._dllName;
+                const replaceValue = `${name}/${request}`;
+                if ((resolveData === null || resolveData === void 0 ? void 0 : resolveData.request) !== undefined) {
+                    resolveData.request = replaceValue;
+                }
+                this._matchCache.set(request, replaceValue);
+                // For Rspack, we'll use Module Federation approach rather than RemoteModule
+                // The actual module federation is handled by the MF plugin in the config
+                return undefined; // Let Rspack handle the module creation
+            });
+        });
+        compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
+            if (!stats.hasErrors()) {
+                if (this._timer) {
+                    clearTimeout(this._timer);
+                }
+                this._timer = setTimeout(() => {
+                    this._onSnapshot(this._collector.snapshot());
+                }, 500);
+            }
+        });
+    }
+}
+exports.RspackDynamicDLLPlugin = RspackDynamicDLLPlugin;

package/lib/webpack/dynamic-dll/rspack-dynamic-dll.d.ts

@@ -0,0 +1,35 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import type * as rspackType from '@rspack/core';
+import type { Configuration } from '@rspack/core';
+import type RspackChain from 'rspack-chain';
+import { ShareConfig } from './bundler/rspack-bundler';
+type IResolveRspackModule = <T extends string>(path: T) => T extends `@rspack/core` ? typeof rspackType : T extends `@rspack/core/${infer R}` ? any : never;
+interface IOpts {
+    cwd?: string;
+    rootDir: string;
+    cacheDir: string;
+    resolveRspackModule?: IResolveRspackModule;
+    include?: RegExp[];
+    exclude?: RegExp[];
+    shared?: ShareConfig;
+    externals?: Configuration['externals'];
+    esmFullSpecific?: Boolean;
+}
+export declare class RspackDynamicDll {
+    private _opts;
+    private _bundler;
+    private _rootDir;
+    private _cacheDir;
+    private _resolveRspackModule;
+    private _dllPlugin;
+    private _hasBuilt;
+    constructor(opts: IOpts);
+    private getRemovedModules;
+    private handleSnapshot;
+    middleware: (req: IncomingMessage, res: ServerResponse, next: (...args: any[]) => any) => Promise<any>;
+    modifyRspackChain: (chain: RspackChain) => RspackChain;
+    modifyRspack: (config: Configuration) => Configuration;
+    private _buildDLL;
+    private _getMFconfig;
+}
+export {};

package/lib/webpack/dynamic-dll/rspack-dynamic-dll.js

@@ -0,0 +1,158 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RspackDynamicDll = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const mrmime_1 = require("mrmime");
+const core_1 = __importDefault(require("@rspack/core"));
+const constants_1 = require("./constants");
+const rspack_bundler_1 = require("./bundler/rspack-bundler");
+const rspack_dynamic_dll_plugin_1 = require("./plugin/rspack-dynamic-dll-plugin");
+const metadata_1 = require("./metadata");
+const utils_1 = require("./utils");
+const check_not_in_node_modules_1 = require("./helper/check-not-in-node-modules");
+class RspackDynamicDll {
+    constructor(opts) {
+        this._hasBuilt = false;
+        this.handleSnapshot = (snapshot) => __awaiter(this, void 0, void 0, function* () {
+            if (this._hasBuilt) {
+                (0, metadata_1.writeUpdate)(this._cacheDir, snapshot);
+                return;
+            }
+            const originModules = (0, metadata_1.getMetadata)(this._cacheDir).modules;
+            const diffNames = this.getRemovedModules(snapshot, originModules);
+            const requiredSnapshot = Object.assign(Object.assign({}, originModules), snapshot);
+            diffNames.forEach(lib => {
+                delete requiredSnapshot[lib];
+            });
+            yield this._buildDLL(requiredSnapshot);
+            this._dllPlugin.disableDllReference();
+            this._hasBuilt = true;
+        });
+        this.middleware = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const url = req.url || '';
+            const shouldServe = url.startsWith(constants_1.DEFAULT_PUBLIC_PATH);
+            if (!shouldServe) {
+                return next();
+            }
+            this._bundler.onBuildComplete(() => {
+                const relativePath = url.replace(new RegExp(`^${constants_1.DEFAULT_PUBLIC_PATH}`), '/');
+                const filePath = (0, path_1.join)((0, utils_1.getDllDir)(this._cacheDir), relativePath);
+                const { mtime } = (0, fs_extra_1.statSync)(filePath);
+                // Get the last modification time of the file and convert the time into a world time string
+                let lastModified = mtime.toUTCString();
+                const ifModifiedSince = req.headers['if-modified-since'];
+                // Tell the browser what time to use the browser cache without asking the server directly, but it seems that it is not effective, and needs to learn why.
+                res.setHeader('cache-control', 'no-cache');
+                if (ifModifiedSince && lastModified <= ifModifiedSince) {
+                    // If the request header contains the request ifModifiedSince and the file is not modified, it returns 304
+                    res.writeHead(304, 'Not Modified');
+                    res.end();
+                    return;
+                }
+                // Return the header Last-Modified for the last modification time of the current request file
+                res.setHeader('Last-Modified', lastModified);
+                // Return file
+                res.setHeader('content-type', (0, mrmime_1.lookup)((0, path_1.extname)(url)) || 'text/plain');
+                const content = (0, fs_extra_1.readFileSync)(filePath);
+                res.statusCode = 200;
+                res.end(content);
+            });
+        });
+        this.modifyRspackChain = (chain) => {
+            // Keep entries as-is for Rspack since we don't have virtual modules support
+            chain
+                .plugin('dynamic-dll-mf')
+                .use(core_1.default.container.ModuleFederationPlugin, [this._getMFconfig()]);
+            chain.plugin('dynamic-dll-plugin').use(this._dllPlugin);
+            return chain;
+        };
+        this.modifyRspack = (config) => {
+            // Keep config.entry as-is for Rspack since we don't have virtual modules support
+            if (!config.plugins) {
+                config.plugins = [];
+            }
+            config.plugins.push(new core_1.default.container.ModuleFederationPlugin(this._getMFconfig()), this._dllPlugin);
+            return config;
+        };
+        this._opts = opts;
+        this._cacheDir = opts.cacheDir;
+        this._rootDir = opts.rootDir;
+        this._resolveRspackModule = opts.resolveRspackModule || require;
+        this._bundler = new rspack_bundler_1.RspackBundler();
+        this._dllPlugin = new rspack_dynamic_dll_plugin_1.RspackDynamicDLLPlugin({
+            include: opts.include,
+            exclude: opts.exclude,
+            dllName: constants_1.NAME,
+            resolveRspackModule: this._resolveRspackModule, // Type compatibility
+            onSnapshot: this.handleSnapshot
+        });
+    }
+    getRemovedModules(snapshot, originModules) {
+        return Object.keys(originModules).filter(key => {
+            if (snapshot[key]) {
+                return false;
+            }
+            return (0, check_not_in_node_modules_1.checkNotInNodeModules)(key, this._rootDir);
+        });
+    }
+    _buildDLL(snapshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._bundler.build(snapshot, {
+                outputDir: this._cacheDir,
+                shared: this._opts.shared,
+                externals: this._opts.externals,
+                esmFullSpecific: this._opts.esmFullSpecific,
+                force: process.env.DLL_FORCE_BUILD === 'true'
+            });
+        });
+    }
+    _getMFconfig() {
+        return {
+            name: '__',
+            remotes: {
+                // [NAME]: `${NAME}@${DEFAULT_PUBLIC_PATH}${DLL_FILENAME}`,
+                // https://webpack.js.org/concepts/module-federation/#promise-based-dynamic-remotes
+                [constants_1.NAME]: `
+promise new Promise(resolve => {
+  const remoteUrl = '${constants_1.DEFAULT_PUBLIC_PATH}${constants_1.DLL_FILENAME}';
+  const script = document.createElement('script');
+  script.src = remoteUrl;
+  script.onload = () => {
+    // the injected script has loaded and is available on window
+    // we can now resolve this Promise
+    const proxy = {
+      get: (request) => {
+        const promise = window['${constants_1.NAME}'].get(request);
+        return promise;
+      },
+      init: (arg) => {
+        try {
+          return window['${constants_1.NAME}'].init(arg);
+        } catch(e) {
+          // remote container already initialized
+        }
+      }
+    }
+    resolve(proxy);
+  }
+  // inject this script with the src set to the versioned remoteEntry.js
+  document.head.appendChild(script);
+})`.trim()
+            }
+        };
+    }
+}
+exports.RspackDynamicDll = RspackDynamicDll;

package/lib/webpack/rspack.d.ts

@@ -1,8 +1,6 @@
 import { rspack, ChunkGroup } from '@rspack/core';
 export { RspackChain } from './config/base.rspack';
-/**
- * @todo back to DLL topic later
- */
+export { RspackDynamicDll } from './dynamic-dll/rspack-dynamic-dll';
 export { rspack, ChunkGroup };
 /**
  * re-export for shuvi plugin
@@ -172,12 +170,10 @@ StatsCompilation, StatsError,
  * @unsupported Rspack does not export StatsLoggingEntry.
  * TODO: Remove or replace after Rspack support is available.
  */
-StatsModule
-/**
+StatsModule } from /**
  * @unsupported Rspack does not export StatsModuleIssuer.
  * TODO: Remove or replace after Rspack support is available.
- */
- } from 
+ */ 
 /**
  * @unsupported Rspack does not export StatsModuleReason.
  * TODO: Remove or replace after Rspack support is available.

package/lib/webpack/rspack.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleEntryPlugin = exports.RuntimeModule = exports.ProvidePlugin = exports.ProgressPlugin = exports.MultiCompiler = exports.NormalModuleReplacementPlugin = exports.NormalModule = exports.NoEmitOnErrorsPlugin = exports.Module = exports.LoaderTargetPlugin = exports.LoaderOptionsPlugin = exports.IgnorePlugin = exports.HotModuleReplacementPlugin = exports.ExternalsPlugin = exports.ExternalModule = exports.EvalSourceMapDevToolPlugin = exports.EvalDevToolModulePlugin = exports.EnvironmentPlugin = exports.EntryPlugin = exports.EntryOptionPlugin = exports.DynamicEntryPlugin = exports.DllReferencePlugin = exports.DllPlugin = exports.Dependency = exports.DefinePlugin = exports.ContextReplacementPlugin = exports.Compiler = exports.Compilation = exports.BannerPlugin = exports.AsyncDependenciesBlock = exports.experiments = exports.sources = exports.util = exports.sharing = exports.container = exports.library = exports.wasm = exports.electron = exports.node = exports.webworker = exports.web = exports.optimize = exports.javascript = exports.config = exports.ValidationError = exports.RuntimeGlobals = exports.ModuleFilenameHelpers = exports.version = exports.rspack = exports.RspackChain = void 0;
-exports.MultiStats = exports.WebpackOptionsApply = exports.WebpackError = exports.Template = exports.Stats = exports.SourceMapDevToolPlugin = void 0;
+exports.RuntimeModule = exports.ProvidePlugin = exports.ProgressPlugin = exports.MultiCompiler = exports.NormalModuleReplacementPlugin = exports.NormalModule = exports.NoEmitOnErrorsPlugin = exports.Module = exports.LoaderTargetPlugin = exports.LoaderOptionsPlugin = exports.IgnorePlugin = exports.HotModuleReplacementPlugin = exports.ExternalsPlugin = exports.ExternalModule = exports.EvalSourceMapDevToolPlugin = exports.EvalDevToolModulePlugin = exports.EnvironmentPlugin = exports.EntryPlugin = exports.EntryOptionPlugin = exports.DynamicEntryPlugin = exports.DllReferencePlugin = exports.DllPlugin = exports.Dependency = exports.DefinePlugin = exports.ContextReplacementPlugin = exports.Compiler = exports.Compilation = exports.BannerPlugin = exports.AsyncDependenciesBlock = exports.experiments = exports.sources = exports.util = exports.sharing = exports.container = exports.library = exports.wasm = exports.electron = exports.node = exports.webworker = exports.web = exports.optimize = exports.javascript = exports.config = exports.ValidationError = exports.RuntimeGlobals = exports.ModuleFilenameHelpers = exports.version = exports.rspack = exports.RspackDynamicDll = exports.RspackChain = void 0;
+exports.MultiStats = exports.WebpackOptionsApply = exports.WebpackError = exports.Template = exports.Stats = exports.SourceMapDevToolPlugin = exports.SingleEntryPlugin = void 0;
 const core_1 = require("@rspack/core");
 Object.defineProperty(exports, "rspack", { enumerable: true, get: function () { return core_1.rspack; } });
 var base_rspack_1 = require("./config/base.rspack");
 Object.defineProperty(exports, "RspackChain", { enumerable: true, get: function () { return base_rspack_1.RspackChain; } });
+var rspack_dynamic_dll_1 = require("./dynamic-dll/rspack-dynamic-dll");
+Object.defineProperty(exports, "RspackDynamicDll", { enumerable: true, get: function () { return rspack_dynamic_dll_1.RspackDynamicDll; } });
 /**
  * re-export for shuvi plugin
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/toolpack",
-  "version": "2.0.0-dev.12",
+  "version": "2.0.0-dev.14",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",
@@ -36,9 +36,9 @@
     "@rspack/cli": "^1.4.2",
     "@rspack/core": "^1.4.2",
     "@rspack/plugin-html": "^0.5.8",
-    "@shuvi/compiler": "2.0.0-dev.12",
-    "@shuvi/shared": "2.0.0-dev.12",
-    "@shuvi/utils": "2.0.0-dev.12",
+    "@shuvi/compiler": "2.0.0-dev.14",
+    "@shuvi/shared": "2.0.0-dev.14",
+    "@shuvi/utils": "2.0.0-dev.14",
     "@swc/helpers": "0.4.3",
     "babel-loader": "8.2.2",
     "babel-plugin-syntax-jsx": "6.18.0",