@rspack/core 0.5.7-canary-6007430-20240313111541 → 0.5.7-canary-9e2ce60-20240320055406

package/dist/Compilation.d.ts

@@ -36,12 +36,13 @@ export interface Asset {
 }
 export interface LogEntry {
     type: string;
-    args?: any[];
+    args: any[];
     time?: number;
     trace?: string[];
 }
 export interface CompilationParams {
     normalModuleFactory: NormalModuleFactory;
+    contextModuleFactory: ContextModuleFactory;
 }
 export interface KnownCreateStatsOptionsContext {
     forToString?: boolean;
@@ -101,9 +102,7 @@ export declare class Compilation {
     childrenCounters: Record<string, number>;
     startTime?: number;
     endTime?: number;
-    normalModuleFactory?: NormalModuleFactory;
     children: Compilation[];
-    contextModuleFactory?: ContextModuleFactory;
     chunkGraph: ChunkGraph;
     fileSystemInfo: {
         createSnapshot(): null;

package/dist/Compilation.js

@@ -473,12 +473,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             const logEntry = {
                 time: Date.now(),
                 type,
+                // @ts-expect-error
                 args,
+                // @ts-expect-error
                 trace
             };
             if (this.hooks.log.call(name, logEntry) === undefined) {
                 if (logEntry.type === Logger_1.LogType.profileEnd) {
-                    if (typeof console.profileEnd === "function" && logEntry.args) {
+                    if (typeof console.profileEnd === "function") {
                         console.profileEnd(`[${name}] ${logEntry.args[0]}`);
                     }
                 }
@@ -491,7 +493,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 }
                 logEntries.push(logEntry);
                 if (logEntry.type === Logger_1.LogType.profile) {
-                    if (typeof console.profile === "function" && logEntry.args) {
+                    if (typeof console.profile === "function") {
                         console.profile(`[${name}] ${logEntry.args[0]}`);
                     }
                 }

package/dist/Compiler.d.ts

@@ -12,7 +12,7 @@ import * as binding from "@rspack/binding";
 import * as tapable from "tapable";
 import * as liteTapable from "./lite-tapable";
 import { Callback } from "tapable";
-import { WatchOptions } from "./config";
+import type { WatchOptions } from "watchpack";
 import { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
 import { RuleSetCompiler } from "./RuleSetCompiler";
 import { Stats } from "./Stats";
@@ -32,7 +32,8 @@ declare class Compiler {
         rspack: typeof import("./rspack").rspack & typeof import("./exports") & any;
         webpack: typeof import("./rspack").rspack & typeof import("./exports") & any;
     };
-    compilation: Compilation;
+    compilation?: Compilation;
+    compilationParams?: CompilationParams;
     first: boolean;
     builtinPlugins: binding.BuiltinPlugin[];
     root: Compiler;
@@ -48,26 +49,26 @@ declare class Compiler {
     ruleSet: RuleSetCompiler;
     watchFileSystem: WatchFileSystem;
     intermediateFileSystem: any;
-    watchMode?: boolean;
+    watchMode: boolean;
     context: string;
-    modifiedFiles?: ReadonlySet<string>;
     cache: Cache;
     compilerPath: string;
+    modifiedFiles?: ReadonlySet<string>;
     removedFiles?: ReadonlySet<string>;
     fileTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>;
     contextTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>;
     hooks: {
         done: tapable.AsyncSeriesHook<Stats>;
         afterDone: tapable.SyncHook<Stats>;
+        thisCompilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
         compilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
-        thisCompilation: tapable.SyncHook<[Compilation, CompilationParams]>;
         invalid: tapable.SyncHook<[string | null, number]>;
-        compile: tapable.SyncHook<[any]>;
+        compile: tapable.SyncHook<[CompilationParams]>;
         normalModuleFactory: tapable.SyncHook<NormalModuleFactory>;
         contextModuleFactory: tapable.SyncHook<ContextModuleFactory>;
         initialize: tapable.SyncHook<[]>;
-        shouldEmit: tapable.SyncBailHook<[Compilation], boolean>;
-        infrastructureLog: tapable.SyncBailHook<[string, string, any[]?], true>;
+        shouldEmit: liteTapable.SyncBailHook<[Compilation], boolean>;
+        infrastructureLog: tapable.SyncBailHook<[string, string, any[]], true>;
         beforeRun: tapable.AsyncSeriesHook<[Compiler]>;
         run: tapable.AsyncSeriesHook<[Compiler]>;
         emit: tapable.AsyncSeriesHook<[Compilation]>;
@@ -82,7 +83,7 @@ declare class Compiler {
         afterPlugins: tapable.SyncHook<[Compiler]>;
         afterResolvers: tapable.SyncHook<[Compiler]>;
         make: liteTapable.AsyncParallelHook<[Compilation]>;
-        beforeCompile: tapable.AsyncSeriesHook<any>;
+        beforeCompile: tapable.AsyncSeriesHook<[CompilationParams]>;
         afterCompile: tapable.AsyncSeriesHook<[Compilation]>;
         finishModules: tapable.AsyncSeriesHook<[any]>;
         finishMake: tapable.AsyncSeriesHook<[Compilation]>;
@@ -111,7 +112,7 @@ declare class Compiler {
      */
     rebuild(modifiedFiles?: ReadonlySet<string>, removedFiles?: ReadonlySet<string>, callback?: (error: Error | null) => void): void;
     compile(callback: Callback<Error, Compilation>): void;
-    watch(watchOptions: WatchOptions, handler: (error?: Error, stats?: Stats) => void): Watching | void;
+    watch(watchOptions: WatchOptions, handler: Callback<Error, Stats>): Watching;
     purgeInputFileSystem(): void;
     close(callback: (error?: Error | null) => void): void;
     getAsset(name: string): Buffer | null;

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_buildModule, _Compiler_afterProcessAssets, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_chunkAsset, _Compiler_finishModules, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_succeedModule, _Compiler_stillValidModule, _Compiler_runtimeModule, _Compiler_executeModule, _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");
@@ -54,7 +54,6 @@ const ConcurrentCompilationError_1 = __importDefault(require("./error/Concurrent
 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");
@@ -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"
@@ -259,7 +255,9 @@ class Compiler {
                 }
             }
             else {
-                if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (
+                // @ts-expect-error
+                this.hooks.infrastructureLog.call(name, type, args) === undefined) {
                     if (this.infrastructureLogger !== undefined) {
                         this.infrastructureLogger(name, type, args);
                     }
@@ -268,7 +266,8 @@ class Compiler {
         }, (childName) => {
             if (typeof name === "function") {
                 if (typeof childName === "function") {
-                    return this.getInfrastructureLogger(() => {
+                    // @ts-expect-error
+                    return this.getInfrastructureLogger(_ => {
                         if (typeof name === "function") {
                             name = name();
                             if (!name) {
@@ -321,6 +320,7 @@ class Compiler {
         const startTime = Date.now();
         this.running = true;
         const doRun = () => {
+            // @ts-expect-error
             const finalCallback = (err, stats) => {
                 this.idle = true;
                 this.cache.beginIdle();
@@ -332,7 +332,7 @@ class Compiler {
                 if (callback) {
                     callback(err, stats);
                 }
-                stats && this.hooks.afterDone.call(stats);
+                this.hooks.afterDone.call(stats);
             };
             this.hooks.beforeRun.callAsync(this, err => {
                 if (err) {
@@ -342,7 +342,7 @@ class Compiler {
                     if (err) {
                         return finalCallback(err);
                     }
-                    this.build(err => {
+                    this.compile(err => {
                         if (err) {
                             return finalCallback(err);
                         }
@@ -382,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);
                     }
@@ -392,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);
                 }
@@ -410,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);
                 }
@@ -421,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);
@@ -443,10 +442,12 @@ class Compiler {
     }
     watch(watchOptions, handler) {
         if (this.running) {
+            // @ts-expect-error
             return handler(new ConcurrentCompilationError_1.default());
         }
         this.running = true;
         this.watchMode = true;
+        // @ts-expect-error
         this.watching = new Watching_1.Watching(this, watchOptions, handler);
         return this.watching;
     }
@@ -456,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(() => {
@@ -510,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),
@@ -531,7 +516,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         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),
@@ -541,19 +525,36 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         executeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_executeModule).bind(this),
         runtimeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_runtimeModule).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)),
+        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,
@@ -563,19 +564,15 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         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,
+        afterResolve: (_a = this.compilationParams) === null || _a === void 0 ? void 0 : _a.normalModuleFactory.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,
         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,
+        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,
         executeModule: undefined,
         runtimeModule: this.compilation.hooks.runtimeModule
     };
@@ -595,17 +592,10 @@ _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);
@@ -616,23 +606,8 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
 }, _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: {
@@ -641,29 +616,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,10 +658,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
 }, _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);
@@ -772,89 +739,65 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     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/MultiCompiler.js

@@ -240,8 +240,8 @@ class MultiCompiler {
             }, (compiler, watching, _done) => {
                 if (compiler.watching !== watching)
                     return;
-                if (!(watching === null || watching === void 0 ? void 0 : watching.running))
-                    watching === null || watching === void 0 ? void 0 : watching.invalidate();
+                if (!watching.running)
+                    watching.invalidate();
             }, handler);
             // @ts-expect-error
             return new MultiWatching_1.default(watchings, this);

package/dist/NormalModuleFactory.d.ts

@@ -1,4 +1,5 @@
 import { AsyncSeriesBailHook, HookMap } from "tapable";
+import * as liteTapable from "./lite-tapable";
 import type * as binding from "@rspack/binding";
 type ResourceData = {
     resource: string;
@@ -23,7 +24,7 @@ type CreateModuleData = binding.CreateModuleData & {
 export declare class NormalModuleFactory {
     hooks: {
         resolveForScheme: HookMap<AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
-        beforeResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
+        beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
         afterResolve: AsyncSeriesBailHook<[ResolveData], boolean | void>;
         createModule: AsyncSeriesBailHook<[CreateModuleData, {}], void>;
     };