@shuvi/toolpack 1.0.63 → 2.0.0-dev.6

package/lib/webpack/plugins/module-replace-plugin/plugin.rspack.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynamic_loader_options_hack_1 = __importDefault(require("./dynamic-loader-options-hack"));
+const REPLACED = Symbol('replaced');
+const stubLoader = require.resolve('./stub-loader.rspack');
+const pitchLoader = stubLoader;
+const toString = Object.prototype.toString;
+function isRegExp(target) {
+    return toString.call(target) === `[object RegExp]`;
+}
+function isFunction(target) {
+    return toString.call(target) === `[object Function]`;
+}
+function getModuleId(wpModule) {
+    var _a;
+    return (wpModule.rawRequest ||
+        ((_a = wpModule === null || wpModule === void 0 ? void 0 : wpModule.createData) === null || _a === void 0 ? void 0 : _a.rawRequest) ||
+        /* rspack support */
+        wpModule.request);
+}
+/**
+ * extract the path, query and fragment from the resource path
+ *
+ * @param resource - the resource path with query and fragment
+ * @returns the path, query and fragment
+ */
+function extractResourceResolveData(resource) {
+    const [pathWithQuery, fragment] = resource.split('#');
+    const [path, query] = pathWithQuery.split('?');
+    return {
+        path,
+        query: query ? `?${query}` : '',
+        fragment
+    };
+}
+function isPitcher(loader) {
+    return loader.loader.startsWith(pitchLoader);
+}
+function findReplacedModule(configs, query) {
+    for (let index = 0; index < configs.length; index++) {
+        const { resourceQuery, module } = configs[index];
+        let isMatch = false;
+        if (isRegExp(resourceQuery)) {
+            isMatch = resourceQuery.test(query);
+        }
+        else if (isFunction(resourceQuery)) {
+            isMatch = resourceQuery(query);
+        }
+        if (isMatch) {
+            return module;
+        }
+    }
+    return null;
+}
+const ModuleAction = {
+    REPLACE: 'replace',
+    RESTORE: 'restore'
+};
+// const knownModules = new Map<string, ModuleInfo>();
+const moduleHandler = new Map();
+const compilerInfo = new Map();
+function getKnownModules(id) {
+    const res = [];
+    for (const compiler of compilerInfo.values()) {
+        const module = compiler.modules.get(id);
+        if (module) {
+            res.push(module);
+        }
+    }
+    return res;
+}
+// function forEachModule(id: string, cb: (mod: ModuleInfo) => void) {
+//   for (const compiler of compilerInfo.values()) {
+//     const mod = compiler.modules.get(id);
+//     if (mod) {
+//       cb(mod);
+//     }
+//   }
+// }
+class ModuleReplacePlugin {
+    static restoreModule(id) {
+        const moduleInfos = getKnownModules(id).filter(m => m.action === ModuleAction.REPLACE);
+        if (moduleInfos.length < 1) {
+            return false;
+        }
+        const handler = {
+            resolve: null,
+            pending: new Map()
+        };
+        moduleHandler.set(id, handler);
+        moduleInfos.forEach(moduleInfo => {
+            moduleInfo.action = ModuleAction.RESTORE;
+            handler.pending.set(moduleInfo.compiler, false);
+        });
+        return new Promise(resolve => {
+            handler.resolve = resolve;
+        });
+    }
+    static replaceModule(id) {
+        const moduleInfos = getKnownModules(id);
+        if (moduleInfos.length < 1) {
+            return false;
+        }
+        moduleInfos.forEach(moduleInfo => {
+            moduleInfo.action = ModuleAction.REPLACE;
+        });
+    }
+    constructor(options) {
+        this._options = Object.assign({ modules: [] }, options);
+    }
+    apply(compiler) {
+        var _a;
+        const { modules } = this._options;
+        // init compiler info
+        compilerInfo.set(compiler, {
+            modules: new Map()
+        });
+        const pitcher = {
+            resourceQuery(query) {
+                const find = findReplacedModule(modules, query);
+                return !!find;
+            },
+            use: [
+                {
+                    loader: pitchLoader
+                }
+            ]
+        };
+        // replace original rules
+        (_a = compiler.options.module.rules) === null || _a === void 0 ? void 0 : _a.unshift(pitcher);
+        compiler.hooks.done.tap('done', () => {
+            const finished = [];
+            for (const [id, handler] of moduleHandler) {
+                if (handler.pending.get(compiler)) {
+                    handler.pending.delete(compiler);
+                }
+                if (handler.pending.size <= 0) {
+                    handler.resolve();
+                    finished.push(id);
+                }
+            }
+            for (const id of finished) {
+                moduleHandler.delete(id);
+            }
+        });
+        compiler.hooks.beforeCompile.tapAsync('ModuleReplacePlugin', ({ normalModuleFactory }, callback) => {
+            normalModuleFactory.hooks.afterResolve.tap('ModuleReplacePlugin', wpModule => {
+                this._collectModules(compiler, wpModule);
+            });
+            callback();
+        });
+        compiler.hooks.compilation.tap('ModuleReplacePlugin', compilation => {
+            compilation.hooks.buildModule.tap('ModuleReplacePlugin', wpModule => this._handleBuildModule(compiler, wpModule));
+        });
+    }
+    _handleBuildModule(compiler, wpModule) {
+        const knownModules = compilerInfo.get(compiler).modules;
+        const id = getModuleId(wpModule);
+        if (!id) {
+            return;
+        }
+        const moduleInfo = knownModules.get(id);
+        if (!moduleInfo) {
+            return;
+        }
+        if (moduleInfo.action === ModuleAction.RESTORE) {
+            const handler = moduleHandler.get(id);
+            if (handler) {
+                handler.pending.set(compiler, true);
+            }
+            const pitcher = (wpModule.loaders || []).find(isPitcher);
+            if (pitcher) {
+                /**
+                 * rspack can't get the dynamic options from the loader, so we need to use the dynamicLoaderOptionsHack to get the options
+                 */
+                pitcher.options = {};
+                dynamic_loader_options_hack_1.default.setData(wpModule.resourceResolveData.path, {
+                    action: moduleInfo.action
+                });
+            }
+            return;
+        }
+        if (moduleInfo.action === ModuleAction.REPLACE) {
+            if (!wpModule.loaders || wpModule.loaders[REPLACED] !== true) {
+                wpModule.loaders[REPLACED] = true;
+                const pitcher = (wpModule.loaders || []).find(isPitcher);
+                if (pitcher) {
+                    /**
+                     * rspack can't get the dynamic options from the loader, so we need to use the dynamicLoaderOptionsHack to get the options
+                     */
+                    pitcher.options = {
+                        replacedModule: moduleInfo.replacedModule
+                    };
+                    dynamic_loader_options_hack_1.default.setData(wpModule.resourceResolveData.path, {
+                        replacedModule: moduleInfo.replacedModule,
+                        action: moduleInfo.action
+                    });
+                }
+            }
+        }
+    }
+    _collectModules(compiler, wpModule) {
+        const knownModules = compilerInfo.get(compiler).modules;
+        const id = getModuleId(wpModule);
+        const parsedResourceResolveData = extractResourceResolveData(wpModule.request);
+        const query = parsedResourceResolveData.query;
+        if (knownModules.has(id) || !id) {
+            return;
+        }
+        const replacedModule = findReplacedModule(this._options.modules, query);
+        if (replacedModule) {
+            knownModules.set(id, {
+                action: ModuleAction.REPLACE,
+                replacedModule,
+                compiler,
+                loaders: []
+            });
+        }
+    }
+}
+exports.default = ModuleReplacePlugin;

package/lib/webpack/plugins/module-replace-plugin/stub-loader.d.ts

@@ -1,5 +1,31 @@
 import { PitchLoaderDefinitionFunction } from 'webpack';
+/**
+ * Options passed to the stub loader from the ModuleReplacePlugin
+ */
 export interface ModuleReplaceOption {
+    /** Path of the module to replace the original with */
     replacedModule: string;
 }
+/**
+ * Pitch loader function for module replacement
+ *
+ * This loader runs in the "pitch" phase of webpack's loader pipeline,
+ * which means it executes before the actual module content is processed.
+ * It's responsible for:
+ * - Intercepting module requests
+ * - Replacing the module source with a different module
+ * - Maintaining proper exports from the replacement module
+ *
+ * The pitch function returns a string that becomes the new module source,
+ * effectively replacing the original module content.
+ *
+ * @example
+ * ```javascript
+ * // When replacing './api.js' with './mock-api.js'
+ * // This loader will generate:
+ * // import mod from './mock-api.js';
+ * // export * from './mock-api.js';
+ * // export default mod;
+ * ```
+ */
 export declare const pitch: PitchLoaderDefinitionFunction<ModuleReplaceOption>;

package/lib/webpack/plugins/module-replace-plugin/stub-loader.js

@@ -1,7 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pitch = void 0;
+/**
+ * Filter function to remove the stub loader itself from the loader chain
+ * This prevents infinite recursion when the loader processes itself
+ *
+ * @param l - Loader object to check
+ * @returns True if the loader is not the stub loader itself
+ */
 const isSelfLoader = (l) => l.path !== __filename;
+/**
+ * Generate a webpack request string from an array of loaders
+ * This creates the proper format for webpack's loader resolution
+ *
+ * @param loaderCtx - Webpack loader context
+ * @param loaders - Array of loader configurations
+ * @returns Formatted request string for webpack
+ */
 const genRequest = (loaderCtx, loaders) => {
     const loaderStrings = [];
     loaders.forEach(loader => {
@@ -16,15 +31,46 @@ const genRequest = (loaderCtx, loaders) => {
             loaderCtx.resourcePath + loaderCtx.resourceQuery
         ].join('!')));
 };
+/**
+ * Pitch loader function for module replacement
+ *
+ * This loader runs in the "pitch" phase of webpack's loader pipeline,
+ * which means it executes before the actual module content is processed.
+ * It's responsible for:
+ * - Intercepting module requests
+ * - Replacing the module source with a different module
+ * - Maintaining proper exports from the replacement module
+ *
+ * The pitch function returns a string that becomes the new module source,
+ * effectively replacing the original module content.
+ *
+ * @example
+ * ```javascript
+ * // When replacing './api.js' with './mock-api.js'
+ * // This loader will generate:
+ * // import mod from './mock-api.js';
+ * // export * from './mock-api.js';
+ * // export default mod;
+ * ```
+ */
 const pitch = function () {
+    // Disable caching to ensure fresh module replacement
     this.cacheable(false);
+    // Get the replacement module path from loader options
     const { replacedModule } = this.getOptions() || {};
     let loaders = this.loaders;
-    // remove self
+    // Remove the stub loader itself from the loader chain
+    // This prevents the loader from processing its own output
     loaders = loaders.filter(isSelfLoader);
+    // Determine the request path based on whether we're replacing or using original
     const request = replacedModule
         ? JSON.stringify(this.utils.contextify(this.context || this.rootContext, replacedModule))
         : genRequest(this, loaders);
+    // Generate the new module source
+    // This creates a module that:
+    // 1. Imports the replacement module as default export
+    // 2. Re-exports all named exports from the replacement module
+    // 3. Provides the default export from the replacement module
     return `
 import mod from ${request}; 
 export * from ${request}

package/lib/webpack/plugins/module-replace-plugin/stub-loader.rspack.d.ts

@@ -0,0 +1,31 @@
+import { PitchLoaderDefinitionFunction } from 'webpack';
+/**
+ * Options passed to the stub loader from the ModuleReplacePlugin
+ */
+export interface ModuleReplaceOption {
+    /** Path of the module to replace the original with */
+    replacedModule: string;
+}
+/**
+ * Pitch loader function for module replacement
+ *
+ * This loader runs in the "pitch" phase of webpack's loader pipeline,
+ * which means it executes before the actual module content is processed.
+ * It's responsible for:
+ * - Intercepting module requests
+ * - Replacing the module source with a different module
+ * - Maintaining proper exports from the replacement module
+ *
+ * The pitch function returns a string that becomes the new module source,
+ * effectively replacing the original module content.
+ *
+ * @example
+ * ```javascript
+ * // When replacing './api.js' with './mock-api.js'
+ * // This loader will generate:
+ * // import mod from './mock-api.js';
+ * // export * from './mock-api.js';
+ * // export default mod;
+ * ```
+ */
+export declare const pitch: PitchLoaderDefinitionFunction<ModuleReplaceOption>;

package/lib/webpack/plugins/module-replace-plugin/stub-loader.rspack.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pitch = void 0;
+const dynamic_loader_options_hack_1 = __importDefault(require("./dynamic-loader-options-hack"));
+/**
+ * Filter function to remove the stub loader itself from the loader chain
+ * This prevents infinite recursion when the loader processes itself
+ *
+ * @param l - Loader object to check
+ * @returns True if the loader is not the stub loader itself
+ */
+const isSelfLoader = (l) => l.path !== __filename;
+/**
+ * Generate a webpack request string from an array of loaders
+ * This creates the proper format for webpack's loader resolution
+ *
+ * @param loaderCtx - Webpack loader context
+ * @param loaders - Array of loader configurations
+ * @returns Formatted request string for webpack
+ */
+const genRequest = (loaderCtx, loaders) => {
+    const loaderStrings = [];
+    loaders.forEach(loader => {
+        const request = typeof loader === 'string' ? loader : loader.request;
+        // loader.request contains both the resolved loader path and its options
+        // query (e.g. ??ref-0)
+        loaderStrings.push(request);
+    });
+    return JSON.stringify(loaderCtx.utils.contextify(loaderCtx.context || loaderCtx.rootContext, '-!' +
+        [
+            ...loaderStrings,
+            loaderCtx.resourcePath + loaderCtx.resourceQuery
+        ].join('!')));
+};
+/**
+ * Pitch loader function for module replacement
+ *
+ * This loader runs in the "pitch" phase of webpack's loader pipeline,
+ * which means it executes before the actual module content is processed.
+ * It's responsible for:
+ * - Intercepting module requests
+ * - Replacing the module source with a different module
+ * - Maintaining proper exports from the replacement module
+ *
+ * The pitch function returns a string that becomes the new module source,
+ * effectively replacing the original module content.
+ *
+ * @example
+ * ```javascript
+ * // When replacing './api.js' with './mock-api.js'
+ * // This loader will generate:
+ * // import mod from './mock-api.js';
+ * // export * from './mock-api.js';
+ * // export default mod;
+ * ```
+ */
+const pitch = function () {
+    // Disable caching to ensure fresh module replacement
+    this.cacheable(false);
+    const dynamicOptions = dynamic_loader_options_hack_1.default.pop(this.resourcePath);
+    // Get the replacement module path from loader options
+    /**
+     * rspack can't get the dynamic options from the loader, so we need to use the dynamicLoaderOptionsHack to get the options
+     */
+    // const { replacedModule } = this.getOptions() || {};
+    const { replacedModule } = dynamicOptions || {};
+    let loaders = this.loaders;
+    // Remove the stub loader itself from the loader chain
+    // This prevents the loader from processing its own output
+    loaders = loaders.filter(isSelfLoader);
+    // Determine the request path based on whether we're replacing or using original
+    const request = replacedModule
+        ? JSON.stringify(this.utils.contextify(this.context || this.rootContext, replacedModule))
+        : genRequest(this, loaders);
+    // Generate the new module source
+    // This creates a module that:
+    // 1. Imports the replacement module as default export
+    // 2. Re-exports all named exports from the replacement module
+    // 3. Provides the default export from the replacement module
+    return `
+import mod from ${request}; 
+export * from ${request}
+export default mod;
+`.trim();
+};
+exports.pitch = pitch;

package/lib/webpack/plugins/require-cache-hot-reloader-plugin.rspack.d.ts

@@ -0,0 +1,13 @@
+import * as Rspack from '../../webpack';
+/**
+ * Rspack plugin interface
+ */
+interface RspackPlugin {
+    apply(compiler: Rspack.Compiler): void;
+}
+export default class RequireCacheHotReloader implements RspackPlugin {
+    previousOutputPathsWebpack5: Set<string>;
+    currentOutputPathsWebpack5: Set<string>;
+    apply(compiler: Rspack.Compiler): void;
+}
+export {};

package/lib/webpack/plugins/require-cache-hot-reloader-plugin.rspack.js

@@ -0,0 +1,47 @@
+"use strict";
+// ref: https://github.com/vercel/next.js/blob/canary/packages/next/build/webpack/plugins/nextjs-require-cache-hot-reloader.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+function deleteCache(filePath) {
+    try {
+        delete require.cache[(0, fs_1.realpathSync)(filePath)];
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    finally {
+        delete require.cache[filePath];
+    }
+}
+const PLUGIN_NAME = 'RequireCacheHotReloader';
+// This plugin flushes require.cache after emitting the files. Providing 'hot reloading' of server files.
+class RequireCacheHotReloader {
+    constructor() {
+        this.previousOutputPathsWebpack5 = new Set();
+        this.currentOutputPathsWebpack5 = new Set();
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_chunk, runtimeRequirements) => {
+                // add this so that the server.js would be emitted after every compilation
+                // @ts-ignore webpack typing bug
+                runtimeRequirements.add(RuntimeGlobals.getFullHash);
+            });
+        });
+        compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => {
+            this.currentOutputPathsWebpack5.add(targetPath);
+            deleteCache(targetPath);
+        });
+        compiler.hooks.afterEmit.tap(PLUGIN_NAME, compilation => {
+            for (const outputPath of this.previousOutputPathsWebpack5) {
+                if (!this.currentOutputPathsWebpack5.has(outputPath)) {
+                    deleteCache(outputPath);
+                }
+            }
+            this.previousOutputPathsWebpack5 = new Set(this.currentOutputPathsWebpack5);
+            this.currentOutputPathsWebpack5.clear();
+        });
+    }
+}
+exports.default = RequireCacheHotReloader;