@rspack/core 0.5.7 → 0.5.8-canary-6b6429d-20240321010409

package/dist/Compiler.js

@@ -36,7 +36,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_beforeCompile, _Compiler_afterCompile, _Compiler_finishMake, _Compiler_buildModule, _Compiler_afterProcessAssets, _Compiler_beforeResolve, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_chunkAsset, _Compiler_finishModules, _Compiler_shouldEmit, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_succeedModule, _Compiler_stillValidModule, _Compiler_runtimeModule, _Compiler_executeModule, _Compiler_decorateUpdateDisabledHooks, _Compiler_registerCompilerCompilationTaps, _Compiler_registerCompilerMakeTaps, _Compiler_registerCompilationProcessAssetsTaps, _Compiler_newCompilation;
+var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_finishMake, _Compiler_afterProcessAssets, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_finishModules, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_decorateUpdateDisabledHooks, _Compiler_createRegisterTaps, _Compiler_createCompilation, _Compiler_resetThisCompilation, _Compiler_newCompilationParams;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
 const index_1 = require("./index");
@@ -44,23 +44,21 @@ const fs_1 = __importDefault(require("fs"));
 const tapable = __importStar(require("tapable"));
 const liteTapable = __importStar(require("./lite-tapable"));
 const tapable_1 = require("tapable");
+const config_1 = require("./config");
 const RuleSetCompiler_1 = require("./RuleSetCompiler");
 const Stats_1 = require("./Stats");
 const Compilation_1 = require("./Compilation");
 const ContextModuleFactory_1 = require("./ContextModuleFactory");
 const ResolverFactory_1 = __importDefault(require("./ResolverFactory"));
-const config_1 = require("./config");
 const ConcurrentCompilationError_1 = __importDefault(require("./error/ConcurrentCompilationError"));
 const fileSystem_1 = require("./fileSystem");
 const Cache_1 = __importDefault(require("./lib/Cache"));
 const CacheFacade_1 = __importDefault(require("./lib/CacheFacade"));
-const loader_runner_1 = require("./loader-runner");
 const Logger_1 = require("./logging/Logger");
 const NormalModuleFactory_1 = require("./NormalModuleFactory");
 const bindingVersionCheck_1 = require("./util/bindingVersionCheck");
 const Watching_1 = require("./Watching");
 const NormalModule_1 = require("./NormalModule");
-const normalization_1 = require("./util/normalization");
 const builtin_plugin_1 = require("./builtin-plugin");
 const rspackOptionsApply_1 = require("./rspackOptionsApply");
 const defaults_1 = require("./config/defaults");
@@ -70,6 +68,7 @@ const HookWebpackError_1 = require("./lib/HookWebpackError");
 const Module_1 = require("./Module");
 const base_1 = require("./builtin-plugin/base");
 const ExecuteModulePlugin_1 = __importDefault(require("./ExecuteModulePlugin"));
+const Chunk_1 = require("./Chunk");
 class Compiler {
     constructor(context, options) {
         _Compiler_instances.add(this);
@@ -94,7 +93,7 @@ class Compiler {
         this.removedFiles = undefined;
         this.hooks = {
             initialize: new tapable_1.SyncHook([]),
-            shouldEmit: new tapable.SyncBailHook(["compilation"]),
+            shouldEmit: new liteTapable.SyncBailHook(["compilation"]),
             done: new tapable.AsyncSeriesHook(["stats"]),
             afterDone: new tapable.SyncHook(["stats"]),
             beforeRun: new tapable.AsyncSeriesHook(["compiler"]),
@@ -102,10 +101,7 @@ class Compiler {
             emit: new tapable.AsyncSeriesHook(["compilation"]),
             assetEmitted: new tapable.AsyncSeriesHook(["file", "info"]),
             afterEmit: new tapable.AsyncSeriesHook(["compilation"]),
-            thisCompilation: new tapable.SyncHook([
-                "compilation",
-                "params"
-            ]),
+            thisCompilation: new liteTapable.SyncHook(["compilation", "params"]),
             compilation: new liteTapable.SyncHook([
                 "compilation",
                 "params"
@@ -346,7 +342,7 @@ class Compiler {
                     if (err) {
                         return finalCallback(err);
                     }
-                    this.build(err => {
+                    this.compile(err => {
                         if (err) {
                             return finalCallback(err);
                         }
@@ -386,8 +382,7 @@ class Compiler {
                 return callback === null || callback === void 0 ? void 0 : callback(error);
             }
             if (!this.first) {
-                const rebuild = instance.unsafe_rebuild.bind(instance);
-                rebuild(Array.from(this.modifiedFiles || []), Array.from(this.removedFiles || []), error => {
+                instance.rebuild(Array.from(this.modifiedFiles || []), Array.from(this.removedFiles || []), error => {
                     if (error) {
                         return callback === null || callback === void 0 ? void 0 : callback(error);
                     }
@@ -396,8 +391,7 @@ class Compiler {
                 return;
             }
             this.first = false;
-            const build = instance.unsafe_build.bind(instance);
-            build(error => {
+            instance.build(error => {
                 if (error) {
                     return callback === null || callback === void 0 ? void 0 : callback(error);
                 }
@@ -414,8 +408,7 @@ class Compiler {
             if (error) {
                 return callback === null || callback === void 0 ? void 0 : callback(error);
             }
-            const rebuild = instance.unsafe_rebuild.bind(instance);
-            rebuild(Array.from(modifiedFiles || []), Array.from(removedFiles || []), error => {
+            instance.rebuild(Array.from(modifiedFiles || []), Array.from(removedFiles || []), error => {
                 if (error) {
                     return callback === null || callback === void 0 ? void 0 : callback(error);
                 }
@@ -425,11 +418,13 @@ class Compiler {
     }
     compile(callback) {
         const startTime = Date.now();
-        this.hooks.beforeCompile.callAsync(void 0, (err) => {
+        const params = __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_newCompilationParams).call(this);
+        this.hooks.beforeCompile.callAsync(params, (err) => {
             if (err) {
                 return callback(err);
             }
-            this.hooks.compile.call([]);
+            this.hooks.compile.call(params);
+            __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_resetThisCompilation).call(this);
             this.build(err => {
                 if (err) {
                     return callback(err);
@@ -462,14 +457,6 @@ class Compiler {
         }
     }
     close(callback) {
-        // WARNING: Arbitrarily dropping the instance is not safe, as it may still be in use by the background thread.
-        // A hint is necessary for the compiler to know when it is safe to drop the instance.
-        // For example: register a callback to the background thread, and drop the instance when the callback is called (calling the `close` method queues the signal)
-        // See: https://github.com/webpack/webpack/blob/4ba225225b1348c8776ca5b5fe53468519413bc0/lib/Compiler.js#L1218
-        if (!this.running) {
-            // Manually drop the instance.
-            // this.#instance = undefined;
-        }
         if (this.watching) {
             // When there is still an active watching, close this first
             this.watching.close(() => {
@@ -516,19 +503,11 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     const rawOptions = (0, config_1.getRawOptions)(options, this);
     const instanceBinding = require("@rspack/binding");
     __classPrivateFieldSet(this, _Compiler_instance, new instanceBinding.Rspack(rawOptions, this.builtinPlugins, {
-        beforeCompile: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_beforeCompile).bind(this),
-        afterCompile: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterCompile).bind(this),
         finishMake: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_finishMake).bind(this),
-        shouldEmit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_shouldEmit).bind(this),
         emit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_emit).bind(this),
         assetEmitted: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_assetEmitted).bind(this),
         afterEmit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterEmit).bind(this),
         afterProcessAssets: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterProcessAssets).bind(this),
-        // `Compilation` should be created with hook `thisCompilation`, and here is the reason:
-        // We know that the hook `thisCompilation` will not be called from a child compiler(it doesn't matter whether the child compiler is created on the Rust or the Node side).
-        // See webpack's API: https://webpack.js.org/api/compiler-hooks/#thiscompilation
-        // So it is safe to create a new compilation here.
-        thisCompilation: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_newCompilation).bind(this),
         optimizeModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_optimizeModules).bind(this),
         afterOptimizeModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterOptimizeModules).bind(this),
         optimizeTree: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_optimizeTree).bind(this),
@@ -536,30 +515,92 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         finishModules: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_finishModules).bind(this),
         normalModuleFactoryCreateModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryCreateModule).bind(this),
         normalModuleFactoryResolveForScheme: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_normalModuleFactoryResolveForScheme).bind(this),
-        chunkAsset: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_chunkAsset).bind(this),
-        beforeResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_beforeResolve).bind(this),
         afterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterResolve).bind(this),
         contextModuleFactoryBeforeResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryBeforeResolve).bind(this),
-        contextModuleFactoryAfterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryAfterResolve).bind(this),
-        succeedModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_succeedModule).bind(this),
-        stillValidModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_stillValidModule).bind(this),
-        buildModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_buildModule).bind(this),
-        executeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_executeModule).bind(this),
-        runtimeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_runtimeModule).bind(this)
+        contextModuleFactoryAfterResolve: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_contextModuleFactoryAfterResolve).bind(this)
     }, {
-        registerCompilerCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilerCompilationTaps).bind(this),
-        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilerMakeTaps).bind(this),
-        registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilationProcessAssetsTaps).bind(this)
-    }, (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem), loader_runner_1.runLoaders.bind(undefined, this)), "f");
+        registerCompilerThisCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.thisCompilation, queried => (native) => {
+            if (this.compilation === undefined) {
+                __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createCompilation).call(this, native);
+            }
+            queried.call(this.compilation, this.compilationParams);
+        }),
+        registerCompilerCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.compilation, queried => () => queried.call(this.compilation, this.compilationParams)),
+        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.make, queried => async () => await queried.promise(this.compilation)),
+        registerCompilerShouldEmitTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.hooks.shouldEmit, queried => () => queried.call(this.compilation)),
+        registerCompilationRuntimeModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.runtimeModule, queried => ({ module, chunk }) => {
+            var _a, _b;
+            const originSource = (_a = module.source) === null || _a === void 0 ? void 0 : _a.source;
+            queried.call(module, Chunk_1.Chunk.__from_binding(chunk, this.compilation));
+            const newSource = (_b = module.source) === null || _b === void 0 ? void 0 : _b.source;
+            if (newSource && newSource !== originSource) {
+                return module;
+            }
+            return;
+        }),
+        registerCompilationBuildModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.buildModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationStillValidModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.stillValidModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationSucceedModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.succeedModule, queired => (m) => queired.call(Module_1.Module.__from_binding(m))),
+        registerCompilationExecuteModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.executeModule, queried => ({ entry, id, codegenResults, runtimeModules }) => {
+            const __webpack_require__ = (id) => {
+                const cached = moduleCache[id];
+                if (cached !== undefined) {
+                    if (cached.error)
+                        throw cached.error;
+                    return cached.exports;
+                }
+                var execOptions = {
+                    id,
+                    module: {
+                        id,
+                        exports: {},
+                        loaded: false,
+                        error: undefined
+                    },
+                    require: __webpack_require__
+                };
+                interceptModuleExecution.forEach((handler) => handler(execOptions));
+                const result = codegenResults.map[id]["build time"];
+                const moduleObject = execOptions.module;
+                if (id)
+                    moduleCache[id] = moduleObject;
+                (0, HookWebpackError_1.tryRunOrWebpackError)(() => queried.call({
+                    codeGenerationResult: new Module_1.CodeGenerationResult(result),
+                    moduleObject
+                }, { __webpack_require__ }), "Compilation.hooks.executeModule");
+                moduleObject.loaded = true;
+                return moduleObject.exports;
+            };
+            const moduleCache = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.moduleCache.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = {});
+            const interceptModuleExecution = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.interceptModuleExecution.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = []);
+            for (const runtimeModule of runtimeModules) {
+                __webpack_require__(runtimeModule);
+            }
+            const executeResult = __webpack_require__(entry);
+            __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
+        }),
+        registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, this.compilation), filename)),
+        registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilation.hooks.processAssets, queried => async () => await queried.promise(this.compilation.assets)),
+        registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createRegisterTaps).call(this, () => this.compilationParams.normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
+            const normalizedResolveData = {
+                request: resolveData.request,
+                context: resolveData.context,
+                fileDependencies: [],
+                missingDependencies: [],
+                contextDependencies: []
+            };
+            const ret = await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return [ret, resolveData];
+        })
+    }, (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem)), "f");
     callback(null, __classPrivateFieldGet(this, _Compiler_instance, "f"));
 }, _Compiler_updateDisabledHooks = function _Compiler_updateDisabledHooks(callback) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e;
     const disabledHooks = [];
     const hookMap = {
-        beforeCompile: this.hooks.beforeCompile,
-        afterCompile: this.hooks.afterCompile,
         finishMake: this.hooks.finishMake,
-        shouldEmit: this.hooks.shouldEmit,
         emit: this.hooks.emit,
         assetEmitted: this.hooks.assetEmitted,
         afterEmit: this.hooks.afterEmit,
@@ -568,22 +609,12 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         finishModules: this.compilation.hooks.finishModules,
         optimizeModules: this.compilation.hooks.optimizeModules,
         afterOptimizeModules: this.compilation.hooks.afterOptimizeModules,
-        chunkAsset: this.compilation.hooks.chunkAsset,
-        beforeResolve: (_a = this.compilation.normalModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.beforeResolve,
-        afterResolve: (_b = this.compilation.normalModuleFactory) === null || _b === void 0 ? void 0 : _b.hooks.afterResolve,
-        succeedModule: this.compilation.hooks.succeedModule,
-        stillValidModule: this.compilation.hooks.stillValidModule,
-        buildModule: this.compilation.hooks.buildModule,
-        // various of hooks are called inside `#newCompilation`, we shouldn't prevent `#newCompilation` from calling even when `thisCompilation` is not tapped.
-        // issue: https://github.com/web-infra-dev/rspack/issues/5398
-        thisCompilation: undefined,
+        afterResolve: (_a = this.compilationParams) === null || _a === void 0 ? void 0 : _a.normalModuleFactory.hooks.afterResolve,
         optimizeChunkModules: this.compilation.hooks.optimizeChunkModules,
-        contextModuleFactoryBeforeResolve: (_c = this.compilation.contextModuleFactory) === null || _c === void 0 ? void 0 : _c.hooks.beforeResolve,
-        contextModuleFactoryAfterResolve: (_d = this.compilation.contextModuleFactory) === null || _d === void 0 ? void 0 : _d.hooks.afterResolve,
-        normalModuleFactoryCreateModule: (_e = this.compilation.normalModuleFactory) === null || _e === void 0 ? void 0 : _e.hooks.createModule,
-        normalModuleFactoryResolveForScheme: (_f = this.compilation.normalModuleFactory) === null || _f === void 0 ? void 0 : _f.hooks.resolveForScheme,
-        executeModule: undefined,
-        runtimeModule: this.compilation.hooks.runtimeModule
+        contextModuleFactoryBeforeResolve: (_b = this.compilationParams) === null || _b === void 0 ? void 0 : _b.contextModuleFactory.hooks.beforeResolve,
+        contextModuleFactoryAfterResolve: (_c = this.compilationParams) === null || _c === void 0 ? void 0 : _c.contextModuleFactory.hooks.afterResolve,
+        normalModuleFactoryCreateModule: (_d = this.compilationParams) === null || _d === void 0 ? void 0 : _d.normalModuleFactory.hooks.createModule,
+        normalModuleFactoryResolveForScheme: (_e = this.compilationParams) === null || _e === void 0 ? void 0 : _e.normalModuleFactory.hooks.resolveForScheme
     };
     for (const [name, hook] of Object.entries(hookMap)) {
         if (typeof hook !== "undefined" &&
@@ -601,44 +632,18 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
             if (error) {
                 return callback === null || callback === void 0 ? void 0 : callback(error);
             }
-            instance.unsafe_set_disabled_hooks(disabledHooks);
+            instance.setDisabledHooks(disabledHooks);
             __classPrivateFieldSet(this, _Compiler_disabledHooks, disabledHooks, "f");
         });
     }
-}, _Compiler_beforeCompile = async function _Compiler_beforeCompile() {
-    await this.hooks.beforeCompile.promise();
-    // compilation is not created yet, so this will fail
-    // this.#updateDisabledHooks();
-}, _Compiler_afterCompile = async function _Compiler_afterCompile() {
-    await this.hooks.afterCompile.promise(this.compilation);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
 }, _Compiler_finishMake = async function _Compiler_finishMake() {
     await this.hooks.finishMake.promise(this.compilation);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_buildModule = async function _Compiler_buildModule(module) {
-    const normalized = (0, normalization_1.normalizeJsModule)(module);
-    this.compilation.hooks.buildModule.call(normalized);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
 }, _Compiler_afterProcessAssets = async function _Compiler_afterProcessAssets() {
     await this.compilation.hooks.afterProcessAssets.promise(this.compilation.assets);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_beforeResolve = async function _Compiler_beforeResolve(resolveData) {
-    var _a;
-    const normalizedResolveData = {
-        request: resolveData.request,
-        context: resolveData.context,
-        fileDependencies: [],
-        missingDependencies: [],
-        contextDependencies: []
-    };
-    let ret = await ((_a = this.compilation.normalModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.beforeResolve.promise(normalizedResolveData));
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    resolveData.request = normalizedResolveData.request;
-    resolveData.context = normalizedResolveData.context;
-    return [ret, resolveData];
 }, _Compiler_afterResolve = async function _Compiler_afterResolve(resolveData) {
-    var _a;
-    let res = await ((_a = this.compilation.normalModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.afterResolve.promise(resolveData));
+    let res = await this.compilationParams.normalModuleFactory.hooks.afterResolve.promise(resolveData);
     NormalModule_1.NormalModule.getCompilationHooks(this.compilation).loader.tap("sideEffectFreePropPlugin", (loaderContext) => {
         loaderContext._module = {
             factoryMeta: {
@@ -647,29 +652,25 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         };
     });
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    return res;
+    return [res, resolveData.createData];
 }, _Compiler_contextModuleFactoryBeforeResolve = async function _Compiler_contextModuleFactoryBeforeResolve(resourceData) {
-    var _a;
-    let res = await ((_a = this.compilation.contextModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.beforeResolve.promise(resourceData));
+    let res = await this.compilationParams.contextModuleFactory.hooks.beforeResolve.promise(resourceData);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
     return res;
 }, _Compiler_contextModuleFactoryAfterResolve = async function _Compiler_contextModuleFactoryAfterResolve(resourceData) {
-    var _a;
-    let res = await ((_a = this.compilation.contextModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.afterResolve.promise(resourceData));
+    let res = await this.compilationParams.contextModuleFactory.hooks.afterResolve.promise(resourceData);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
     return res;
 }, _Compiler_normalModuleFactoryCreateModule = async function _Compiler_normalModuleFactoryCreateModule(createData) {
-    var _a;
     const data = Object.assign({}, createData, {
         settings: {},
         matchResource: createData.resourceResolveData.resource
     });
-    const nmfHooks = (_a = this.compilation.normalModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks;
+    const nmfHooks = this.compilationParams.normalModuleFactory.hooks;
     await (nmfHooks === null || nmfHooks === void 0 ? void 0 : nmfHooks.createModule.promise(data, {}));
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
 }, _Compiler_normalModuleFactoryResolveForScheme = async function _Compiler_normalModuleFactoryResolveForScheme(input) {
-    var _a;
-    let stop = await ((_a = this.compilation.normalModuleFactory) === null || _a === void 0 ? void 0 : _a.hooks.resolveForScheme.for(input.scheme).promise(input.resourceData));
+    let stop = await this.compilationParams.normalModuleFactory.hooks.resolveForScheme.for(input.scheme).promise(input.resourceData);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
     return {
         resourceData: input.resourceData,
@@ -687,16 +688,9 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
 }, _Compiler_afterOptimizeModules = async function _Compiler_afterOptimizeModules() {
     await this.compilation.hooks.afterOptimizeModules.promise(this.compilation.modules);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_chunkAsset = function _Compiler_chunkAsset(assetArg) {
-    this.compilation.hooks.chunkAsset.call(assetArg.chunk, assetArg.filename);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
 }, _Compiler_finishModules = async function _Compiler_finishModules() {
     await this.compilation.hooks.finishModules.promise(this.compilation.modules);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_shouldEmit = async function _Compiler_shouldEmit() {
-    const res = this.hooks.shouldEmit.call(this.compilation);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    return Promise.resolve(res);
 }, _Compiler_emit = async function _Compiler_emit() {
     await this.hooks.emit.promise(this.compilation);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
@@ -720,147 +714,69 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
 }, _Compiler_afterEmit = async function _Compiler_afterEmit() {
     await this.hooks.afterEmit.promise(this.compilation);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_succeedModule = function _Compiler_succeedModule(module) {
-    this.compilation.hooks.succeedModule.call(module);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_stillValidModule = function _Compiler_stillValidModule(module) {
-    this.compilation.hooks.stillValidModule.call(module);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_runtimeModule = function _Compiler_runtimeModule(arg) {
-    var _a, _b;
-    let { module, chunk } = arg;
-    const originSource = (_a = module.source) === null || _a === void 0 ? void 0 : _a.source;
-    this.compilation.hooks.runtimeModule.call(module, chunk);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-    const newSource = (_b = module.source) === null || _b === void 0 ? void 0 : _b.source;
-    if (newSource && newSource !== originSource) {
-        return module;
-    }
-    return;
-}, _Compiler_executeModule = async function _Compiler_executeModule({ entry, request, options, runtimeModules, codegenResults, id }) {
-    const __webpack_require__ = (id) => {
-        const cached = moduleCache[id];
-        if (cached !== undefined) {
-            if (cached.error)
-                throw cached.error;
-            return cached.exports;
-        }
-        var execOptions = {
-            id,
-            module: {
-                id,
-                exports: {},
-                loaded: false,
-                error: undefined
-            },
-            require: __webpack_require__
-        };
-        interceptModuleExecution.forEach((handler) => handler(execOptions));
-        const result = codegenResults.map[id]["build time"];
-        const moduleObject = execOptions.module;
-        if (id)
-            moduleCache[id] = moduleObject;
-        (0, HookWebpackError_1.tryRunOrWebpackError)(() => this.compilation.hooks.executeModule.call({
-            codeGenerationResult: new Module_1.CodeGenerationResult(result),
-            moduleObject
-        }, { __webpack_require__ }), "Compilation.hooks.executeModule");
-        moduleObject.loaded = true;
-        return moduleObject.exports;
-    };
-    const moduleCache = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.moduleCache.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = {});
-    const interceptModuleExecution = (__webpack_require__[RuntimeGlobals_1.RuntimeGlobals.interceptModuleExecution.replace(`${RuntimeGlobals_1.RuntimeGlobals.require}.`, "")] = []);
-    for (const runtimeModule of runtimeModules) {
-        __webpack_require__(runtimeModule);
-    }
-    const executeResult = __webpack_require__(entry);
-    __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
 }, _Compiler_decorateUpdateDisabledHooks = function _Compiler_decorateUpdateDisabledHooks(jsTaps) {
     if (jsTaps.length > 0) {
         const last = jsTaps[jsTaps.length - 1];
         const old = last.function;
-        last.function = async () => {
-            await old();
+        last.function = (...args) => {
+            const result = old(...args);
+            if (result && typeof result.then === "function") {
+                return result.then((r) => {
+                    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+                    return r;
+                });
+            }
             __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+            return result;
         };
     }
-}, _Compiler_registerCompilerCompilationTaps = function _Compiler_registerCompilerCompilationTaps(stages) {
-    if (!this.hooks.compilation.isUsed())
-        return [];
-    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
-    const jsTaps = [];
-    for (let i = 0; i < breakpoints.length - 1; i++) {
-        const from = breakpoints[i];
-        const to = breakpoints[i + 1];
-        const stageRange = [from, to];
-        const queried = this.hooks.compilation.queryStageRange(stageRange);
-        if (!queried.isUsed())
-            continue;
-        jsTaps.push({
-            function: () => {
-                queried.call(this.compilation, {
-                    normalModuleFactory: this.compilation.normalModuleFactory
-                });
-            },
-            stage: liteTapable.safeStage(from + 1)
-        });
-    }
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
-    return jsTaps;
-}, _Compiler_registerCompilerMakeTaps = function _Compiler_registerCompilerMakeTaps(stages) {
-    if (!this.hooks.make.isUsed())
-        return [];
-    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
-    const jsTaps = [];
-    for (let i = 0; i < breakpoints.length - 1; i++) {
-        const from = breakpoints[i];
-        const to = breakpoints[i + 1];
-        const stageRange = [from, to];
-        const queried = this.hooks.make.queryStageRange(stageRange);
-        if (!queried.isUsed())
-            continue;
-        jsTaps.push({
-            function: async () => {
-                await queried.promise(this.compilation);
-            },
-            stage: liteTapable.safeStage(from + 1)
-        });
-    }
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
-    return jsTaps;
-}, _Compiler_registerCompilationProcessAssetsTaps = function _Compiler_registerCompilationProcessAssetsTaps(stages) {
-    if (!this.compilation.hooks.processAssets.isUsed())
-        return [];
-    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
-    const jsTaps = [];
-    for (let i = 0; i < breakpoints.length - 1; i++) {
-        const from = breakpoints[i];
-        const to = breakpoints[i + 1];
-        const stageRange = [from, to];
-        const queried = this.compilation.hooks.processAssets.queryStageRange(stageRange);
-        if (!queried.isUsed())
-            continue;
-        jsTaps.push({
-            function: async () => {
-                await queried.promise(this.compilation.assets);
-            },
-            stage: liteTapable.safeStage(from + 1)
-        });
-    }
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
-    return jsTaps;
-}, _Compiler_newCompilation = function _Compiler_newCompilation(native) {
+}, _Compiler_createRegisterTaps = function _Compiler_createRegisterTaps(getHook, createTap) {
+    return stages => {
+        const hook = getHook();
+        if (!hook.isUsed())
+            return [];
+        const breakpoints = [
+            liteTapable.minStage,
+            ...stages,
+            liteTapable.maxStage
+        ];
+        const jsTaps = [];
+        for (let i = 0; i < breakpoints.length - 1; i++) {
+            const from = breakpoints[i];
+            const to = breakpoints[i + 1];
+            const stageRange = [from, to];
+            const queried = hook.queryStageRange(stageRange);
+            if (!queried.isUsed())
+                continue;
+            jsTaps.push({
+                function: createTap(queried),
+                stage: liteTapable.safeStage(from + 1)
+            });
+        }
+        __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
+        return jsTaps;
+    };
+}, _Compiler_createCompilation = function _Compiler_createCompilation(native) {
     const compilation = new Compilation_1.Compilation(this, native);
     compilation.name = this.name;
     this.compilation = compilation;
-    // reset normalModuleFactory when create new compilation
-    let normalModuleFactory = new NormalModuleFactory_1.NormalModuleFactory();
-    let contextModuleFactory = new ContextModuleFactory_1.ContextModuleFactory();
-    this.compilation.normalModuleFactory = normalModuleFactory;
+    return compilation;
+}, _Compiler_resetThisCompilation = function _Compiler_resetThisCompilation() {
+    // reassign new compilation in thisCompilation
+    this.compilation = undefined;
+    // ensure thisCompilation must call
+    this.hooks.thisCompilation.intercept({
+        call: () => { }
+    });
+}, _Compiler_newCompilationParams = function _Compiler_newCompilationParams() {
+    const normalModuleFactory = new NormalModuleFactory_1.NormalModuleFactory();
     this.hooks.normalModuleFactory.call(normalModuleFactory);
-    this.compilation.contextModuleFactory = contextModuleFactory;
+    const contextModuleFactory = new ContextModuleFactory_1.ContextModuleFactory();
     this.hooks.contextModuleFactory.call(contextModuleFactory);
-    this.hooks.thisCompilation.call(this.compilation, {
-        normalModuleFactory: normalModuleFactory
-    });
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+    const params = {
+        normalModuleFactory,
+        contextModuleFactory
+    };
+    this.compilationParams = params;
+    return params;
 };

package/dist/Module.d.ts

@@ -1,10 +1,13 @@
 import { JsCodegenerationResult, JsCodegenerationResults, JsModule } from "@rspack/binding";
+import { Source } from "webpack-sources";
 export declare class Module {
     #private;
+    _originalSource?: Source;
     static __from_binding(module: JsModule): Module;
     constructor(module: JsModule);
     get context(): string | undefined;
     get resource(): string | undefined;
+    get originalSource(): Source | null;
     identifier(): string;
     nameForCondition(): string | null;
 }

package/dist/Module.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Module_inner, _CodeGenerationResult_inner, _CodeGenerationResults_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = void 0;
+const createSource_1 = require("./util/createSource");
 class Module {
     static __from_binding(module) {
         return new Module(module);
@@ -27,6 +28,17 @@ class Module {
     get resource() {
         return __classPrivateFieldGet(this, _Module_inner, "f").resource;
     }
+    get originalSource() {
+        if (this._originalSource)
+            return this._originalSource;
+        if (__classPrivateFieldGet(this, _Module_inner, "f").originalSource) {
+            this._originalSource = (0, createSource_1.createSourceFromRaw)(__classPrivateFieldGet(this, _Module_inner, "f").originalSource);
+            return this._originalSource;
+        }
+        else {
+            return null;
+        }
+    }
     identifier() {
         return __classPrivateFieldGet(this, _Module_inner, "f").moduleIdentifier;
     }