@rspack/core 0.5.7 → 0.5.8

package/dist/Compilation.d.ts

@@ -42,6 +42,7 @@ export interface LogEntry {
 }
 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/Compiler.d.ts

@@ -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;
@@ -50,23 +51,23 @@ declare class Compiler {
     intermediateFileSystem: any;
     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>;
+        shouldEmit: liteTapable.SyncBailHook<[Compilation], boolean>;
         infrastructureLog: tapable.SyncBailHook<[string, string, any[]], true>;
         beforeRun: tapable.AsyncSeriesHook<[Compiler]>;
         run: tapable.AsyncSeriesHook<[Compiler]>;
@@ -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]>;

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"
@@ -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),
@@ -537,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),
@@ -547,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,
@@ -569,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
     };
@@ -601,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);
@@ -622,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: {
@@ -647,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,
@@ -693,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);
@@ -778,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/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>;
     };

package/dist/NormalModuleFactory.js

@@ -1,7 +1,31 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NormalModuleFactory = void 0;
 const tapable_1 = require("tapable");
+const liteTapable = __importStar(require("./lite-tapable"));
 class NormalModuleFactory {
     constructor() {
         this.hooks = {
@@ -16,7 +40,7 @@ class NormalModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
             // factorize: new AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            beforeResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
+            beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             afterResolve: new tapable_1.AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */

package/dist/Watching.js

@@ -254,13 +254,13 @@ _Watching_invalidReported = new WeakMap(), _Watching_closeCallbacks = new WeakMa
         if (err)
             return this._done(err, null);
         const canRebuild = !__classPrivateFieldGet(this, _Watching_initial, "f") && ((modifiedFiles === null || modifiedFiles === void 0 ? void 0 : modifiedFiles.size) || (deleteFiles === null || deleteFiles === void 0 ? void 0 : deleteFiles.size));
-        const onBuild = (err) => {
+        const onCompile = (err) => {
             if (err)
                 return this._done(err, null);
             // if (this.invalid) return this._done(null);
             this._done(null, this.compiler.compilation);
         };
-        this.compiler.build(onBuild);
+        this.compiler.compile(onCompile);
         if (!canRebuild) {
             __classPrivateFieldSet(this, _Watching_initial, false, "f");
         }

package/dist/builtin-plugin/JsLoaderRspackPlugin.d.ts

@@ -0,0 +1,11 @@
+import { BuiltinPluginName } from "@rspack/binding";
+import { Compiler } from "../Compiler";
+export declare const JsLoaderRspackPlugin: {
+    new (compiler: Compiler): {
+        name: BuiltinPluginName;
+        _options: (rawContext: import("@rspack/binding").JsLoaderContext) => Promise<import("@rspack/binding").JsLoaderResult>;
+        affectedHooks: "emit" | "done" | "compilation" | "make" | "compile" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishModules" | "finishMake" | "entryOption" | undefined;
+        raw(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};

package/dist/builtin-plugin/JsLoaderRspackPlugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsLoaderRspackPlugin = void 0;
+const binding_1 = require("@rspack/binding");
+const base_1 = require("./base");
+const loader_runner_1 = require("../loader-runner");
+exports.JsLoaderRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.JsLoaderRspackPlugin, (compiler) => loader_runner_1.runLoaders.bind(null, compiler), "compilation");

package/dist/builtin-plugin/index.d.ts

@@ -50,6 +50,7 @@ export * from "./HtmlRspackPlugin";
 export * from "./CopyRspackPlugin";
 export * from "./SwcJsMinimizerPlugin";
 export * from "./SwcCssMinimizerPlugin";
+export * from "./JsLoaderRspackPlugin";
 import { RawBuiltins, RawCssModulesConfig } from "@rspack/binding";
 import { RspackOptionsNormalized } from "..";
 type BuiltinsCssConfig = {

package/dist/builtin-plugin/index.js

@@ -68,6 +68,7 @@ __exportStar(require("./HtmlRspackPlugin"), exports);
 __exportStar(require("./CopyRspackPlugin"), exports);
 __exportStar(require("./SwcJsMinimizerPlugin"), exports);
 __exportStar(require("./SwcCssMinimizerPlugin"), exports);
+__exportStar(require("./JsLoaderRspackPlugin"), exports);
 function resolveTreeShaking(treeShaking, production) {
     return treeShaking !== undefined
         ? treeShaking.toString()