@rspack/core 0.7.6-canary-1a0d77d-20240627143904 → 1.0.0-alpha.1

package/dist/Compiler.d.ts

@@ -9,8 +9,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import * as binding from "@rspack/binding";
-import * as tapable from "tapable";
-import { Callback } from "tapable";
+import * as liteTapable from "@rspack/lite-tapable";
 import type Watchpack from "../compiled/watchpack";
 import { Compilation, CompilationParams } from "./Compilation";
 import { ContextModuleFactory } from "./ContextModuleFactory";
@@ -18,11 +17,10 @@ import { RuleSetCompiler } from "./RuleSetCompiler";
 import { Stats } from "./Stats";
 import { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
 import { rspack } from "./index";
-import * as liteTapable from "./lite-tapable";
 import ResolverFactory = require("./ResolverFactory");
 import Cache = require("./lib/Cache");
 import CacheFacade = require("./lib/CacheFacade");
-import { Source } from "webpack-sources";
+import { Source } from "../compiled/webpack-sources";
 import { Chunk } from "./Chunk";
 import { FileSystemInfoEntry } from "./FileSystemInfo";
 import { NormalModuleFactory } from "./NormalModuleFactory";
@@ -39,35 +37,35 @@ export interface AssetEmittedInfo {
 declare class Compiler {
     #private;
     hooks: {
-        done: tapable.AsyncSeriesHook<Stats>;
-        afterDone: tapable.SyncHook<Stats>;
+        done: liteTapable.AsyncSeriesHook<Stats>;
+        afterDone: liteTapable.SyncHook<Stats>;
         thisCompilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
         compilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
-        invalid: tapable.SyncHook<[string | null, number]>;
-        compile: tapable.SyncHook<[CompilationParams]>;
-        normalModuleFactory: tapable.SyncHook<NormalModuleFactory>;
-        contextModuleFactory: tapable.SyncHook<ContextModuleFactory>;
-        initialize: tapable.SyncHook<[]>;
+        invalid: liteTapable.SyncHook<[string | null, number]>;
+        compile: liteTapable.SyncHook<[CompilationParams]>;
+        normalModuleFactory: liteTapable.SyncHook<NormalModuleFactory>;
+        contextModuleFactory: liteTapable.SyncHook<ContextModuleFactory>;
+        initialize: liteTapable.SyncHook<[]>;
         shouldEmit: liteTapable.SyncBailHook<[Compilation], boolean>;
-        infrastructureLog: tapable.SyncBailHook<[string, string, any[]], true>;
-        beforeRun: tapable.AsyncSeriesHook<[Compiler]>;
-        run: tapable.AsyncSeriesHook<[Compiler]>;
+        infrastructureLog: liteTapable.SyncBailHook<[string, string, any[]], true>;
+        beforeRun: liteTapable.AsyncSeriesHook<[Compiler]>;
+        run: liteTapable.AsyncSeriesHook<[Compiler]>;
         emit: liteTapable.AsyncSeriesHook<[Compilation]>;
         assetEmitted: liteTapable.AsyncSeriesHook<[string, AssetEmittedInfo]>;
         afterEmit: liteTapable.AsyncSeriesHook<[Compilation]>;
-        failed: tapable.SyncHook<[Error]>;
-        shutdown: tapable.AsyncSeriesHook<[]>;
-        watchRun: tapable.AsyncSeriesHook<[Compiler]>;
-        watchClose: tapable.SyncHook<[]>;
-        environment: tapable.SyncHook<[]>;
-        afterEnvironment: tapable.SyncHook<[]>;
-        afterPlugins: tapable.SyncHook<[Compiler]>;
-        afterResolvers: tapable.SyncHook<[Compiler]>;
+        failed: liteTapable.SyncHook<[Error]>;
+        shutdown: liteTapable.AsyncSeriesHook<[]>;
+        watchRun: liteTapable.AsyncSeriesHook<[Compiler]>;
+        watchClose: liteTapable.SyncHook<[]>;
+        environment: liteTapable.SyncHook<[]>;
+        afterEnvironment: liteTapable.SyncHook<[]>;
+        afterPlugins: liteTapable.SyncHook<[Compiler]>;
+        afterResolvers: liteTapable.SyncHook<[Compiler]>;
         make: liteTapable.AsyncParallelHook<[Compilation]>;
-        beforeCompile: tapable.AsyncSeriesHook<[CompilationParams]>;
-        afterCompile: tapable.AsyncSeriesHook<[Compilation]>;
+        beforeCompile: liteTapable.AsyncSeriesHook<[CompilationParams]>;
+        afterCompile: liteTapable.AsyncSeriesHook<[Compilation]>;
         finishMake: liteTapable.AsyncSeriesHook<[Compilation]>;
-        entryOption: tapable.SyncBailHook<[string, EntryNormalized], any>;
+        entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
     };
     webpack: typeof rspack;
     name?: string;
@@ -125,11 +123,11 @@ declare class Compiler {
      * @param handler - signals when the call finishes
      * @returns a compiler watcher
      */
-    watch(watchOptions: Watchpack.WatchOptions, handler: Callback<Error, Stats>): Watching;
+    watch(watchOptions: Watchpack.WatchOptions, handler: liteTapable.Callback<Error, Stats>): Watching;
     /**
      * @param callback - signals when the call finishes
      */
-    run(callback: Callback<Error, Stats>): void;
+    run(callback: liteTapable.Callback<Error, Stats>): void;
     runAsChild(callback: (err?: null | Error, entries?: Chunk[], compilation?: Compilation) => any): void;
     purgeInputFileSystem(): void;
     /**
@@ -142,7 +140,7 @@ declare class Compiler {
      */
     createChildCompiler(compilation: Compilation, compilerName: string, compilerIndex: number, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
     isChild(): boolean;
-    compile(callback: Callback<Error, Compilation>): void;
+    compile(callback: liteTapable.Callback<Error, Compilation>): void;
     close(callback: (error?: Error | null) => void): void;
     /**
      * Note: This is not a webpack public API, maybe removed in future.

package/dist/Compiler.js

@@ -49,15 +49,13 @@ exports.Compiler = void 0;
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 const binding = __importStar(require("@rspack/binding"));
-const tapable = __importStar(require("tapable"));
-const tapable_1 = require("tapable");
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Compilation_1 = require("./Compilation");
 const ContextModuleFactory_1 = require("./ContextModuleFactory");
 const RuleSetCompiler_1 = require("./RuleSetCompiler");
 const Stats_1 = require("./Stats");
 const config_1 = require("./config");
 const index_1 = require("./index");
-const liteTapable = __importStar(require("./lite-tapable"));
 const ResolverFactory = require("./ResolverFactory");
 const FileSystem_1 = require("./FileSystem");
 const ConcurrentCompilationError_1 = __importDefault(require("./error/ConcurrentCompilationError"));
@@ -97,12 +95,12 @@ class Compiler {
         __classPrivateFieldSet(this, _Compiler_moduleExecutionResultsMap, new Map(), "f");
         __classPrivateFieldSet(this, _Compiler_ruleSet, new RuleSetCompiler_1.RuleSetCompiler(), "f");
         this.hooks = {
-            initialize: new tapable_1.SyncHook([]),
+            initialize: new liteTapable.SyncHook([]),
             shouldEmit: new liteTapable.SyncBailHook(["compilation"]),
-            done: new tapable.AsyncSeriesHook(["stats"]),
-            afterDone: new tapable.SyncHook(["stats"]),
-            beforeRun: new tapable.AsyncSeriesHook(["compiler"]),
-            run: new tapable.AsyncSeriesHook(["compiler"]),
+            done: new liteTapable.AsyncSeriesHook(["stats"]),
+            afterDone: new liteTapable.SyncHook(["stats"]),
+            beforeRun: new liteTapable.AsyncSeriesHook(["compiler"]),
+            run: new liteTapable.AsyncSeriesHook(["compiler"]),
             emit: new liteTapable.AsyncSeriesHook(["compilation"]),
             assetEmitted: new liteTapable.AsyncSeriesHook(["file", "info"]),
             afterEmit: new liteTapable.AsyncSeriesHook(["compilation"]),
@@ -111,28 +109,32 @@ class Compiler {
                 "compilation",
                 "params"
             ]),
-            invalid: new tapable_1.SyncHook(["filename", "changeTime"]),
-            compile: new tapable_1.SyncHook(["params"]),
-            infrastructureLog: new tapable_1.SyncBailHook(["origin", "type", "args"]),
-            failed: new tapable_1.SyncHook(["error"]),
-            shutdown: new tapable.AsyncSeriesHook([]),
-            normalModuleFactory: new tapable.SyncHook([
+            invalid: new liteTapable.SyncHook(["filename", "changeTime"]),
+            compile: new liteTapable.SyncHook(["params"]),
+            infrastructureLog: new liteTapable.SyncBailHook([
+                "origin",
+                "type",
+                "args"
+            ]),
+            failed: new liteTapable.SyncHook(["error"]),
+            shutdown: new liteTapable.AsyncSeriesHook([]),
+            normalModuleFactory: new liteTapable.SyncHook([
                 "normalModuleFactory"
             ]),
-            contextModuleFactory: new tapable.SyncHook([
+            contextModuleFactory: new liteTapable.SyncHook([
                 "contextModuleFactory"
             ]),
-            watchRun: new tapable.AsyncSeriesHook(["compiler"]),
-            watchClose: new tapable.SyncHook([]),
-            environment: new tapable.SyncHook([]),
-            afterEnvironment: new tapable.SyncHook([]),
-            afterPlugins: new tapable.SyncHook(["compiler"]),
-            afterResolvers: new tapable.SyncHook(["compiler"]),
+            watchRun: new liteTapable.AsyncSeriesHook(["compiler"]),
+            watchClose: new liteTapable.SyncHook([]),
+            environment: new liteTapable.SyncHook([]),
+            afterEnvironment: new liteTapable.SyncHook([]),
+            afterPlugins: new liteTapable.SyncHook(["compiler"]),
+            afterResolvers: new liteTapable.SyncHook(["compiler"]),
             make: new liteTapable.AsyncParallelHook(["compilation"]),
-            beforeCompile: new tapable.AsyncSeriesHook(["params"]),
-            afterCompile: new tapable.AsyncSeriesHook(["compilation"]),
+            beforeCompile: new liteTapable.AsyncSeriesHook(["params"]),
+            afterCompile: new liteTapable.AsyncSeriesHook(["compilation"]),
             finishMake: new liteTapable.AsyncSeriesHook(["compilation"]),
-            entryOption: new tapable.SyncBailHook(["context", "entry"])
+            entryOption: new liteTapable.SyncBailHook(["context", "entry"])
         };
         this.webpack = index_1.rspack;
         this.root = this;
@@ -652,16 +654,27 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
         }),
         registerCompilationFinishModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationFinishModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.finishModules, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
-        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
-        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterOptimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
+        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules.values())),
+        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterOptimizeModules, queried => () => {
+            queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules.values());
+        }),
         registerCompilationOptimizeTreeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeTree, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeTree, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").chunks, __classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
         registerCompilationOptimizeChunkModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeChunkModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeChunkModules, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").chunks, __classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
+        registerCompilationChunkHashTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkHash, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkHash, queried => (chunk) => {
+            const hash = (0, createHash_1.createHash)(this.options.output.hashFunction);
+            queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), hash);
+            const digestResult = hash.digest(this.options.output.hashDigest);
+            return Buffer.from(digestResult);
+        }),
         registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkAsset, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), filename)),
         registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.processAssets, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterProcessAssets, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterSeal, queried => async () => await queried.promise()),
         registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryBeforeResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {
+                contextInfo: {
+                    issuer: resolveData.issuer
+                },
                 request: resolveData.request,
                 context: resolveData.context,
                 fileDependencies: [],
@@ -673,6 +686,38 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             resolveData.context = normalizedResolveData.context;
             return [ret, resolveData];
         }),
+        registerNormalModuleFactoryFactorizeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryFactorize, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.factorize, queried => async (resolveData) => {
+            const normalizedResolveData = {
+                contextInfo: {
+                    issuer: resolveData.issuer
+                },
+                request: resolveData.request,
+                context: resolveData.context,
+                fileDependencies: [],
+                missingDependencies: [],
+                contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
+        }),
+        registerNormalModuleFactoryResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.resolve, queried => async (resolveData) => {
+            const normalizedResolveData = {
+                contextInfo: {
+                    issuer: resolveData.issuer
+                },
+                request: resolveData.request,
+                context: resolveData.context,
+                fileDependencies: [],
+                missingDependencies: [],
+                contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
+        }),
         registerNormalModuleFactoryResolveForSchemeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookMapRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryResolveForScheme, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.resolveForScheme, queried => async (args) => {
             const ret = await queried
                 .for(args.scheme)
@@ -681,6 +726,9 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         }),
         registerNormalModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryAfterResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.afterResolve, queried => async (arg) => {
             const data = {
+                contextInfo: {
+                    issuer: arg.issuer
+                },
                 request: arg.request,
                 context: arg.context,
                 fileDependencies: arg.fileDependencies,

package/dist/ContextModuleFactory.d.ts

@@ -1,5 +1,5 @@
+import * as liteTapable from "@rspack/lite-tapable";
 import { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from "./Module";
-import * as liteTapable from "./lite-tapable";
 export declare class ContextModuleFactory {
     hooks: {
         beforeResolve: liteTapable.AsyncSeriesWaterfallHook<[

package/dist/ContextModuleFactory.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextModuleFactory = void 0;
-const liteTapable = __importStar(require("./lite-tapable"));
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 class ContextModuleFactory {
     constructor() {
         this.hooks = {

package/dist/Entrypoint.d.ts

@@ -4,5 +4,5 @@ import { ChunkGroup } from "./ChunkGroup";
 export declare class Entrypoint extends ChunkGroup {
     static __from_binding(chunk: JsChunkGroup, compilation: JsCompilation): Entrypoint;
     protected constructor(inner: JsChunkGroup, compilation: JsCompilation);
-    getRuntimeChunk(): Chunk | null;
+    getRuntimeChunk(): Readonly<Chunk | null>;
 }

package/dist/Entrypoint.js

@@ -12,9 +12,9 @@ class Entrypoint extends ChunkGroup_1.ChunkGroup {
         super(inner, compilation);
     }
     getRuntimeChunk() {
-        const c = (0, binding_1.__entrypoint_inner_get_runtime_chunk)(this.__internal_innerUkey(), this.__internal_innerCompilation());
+        const c = (0, binding_1.__entrypoint_inner_get_runtime_chunk)(this.__internal__innerUkey(), this.__internal__innerCompilation());
         if (c)
-            return Chunk_1.Chunk.__from_binding(c, this.__internal_innerCompilation());
+            return Chunk_1.Chunk.__from_binding(c, this.__internal__innerCompilation());
         return null;
     }
 }

package/dist/Module.d.ts

@@ -1,5 +1,5 @@
-import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsModule } from "@rspack/binding";
-import { Source } from "webpack-sources";
+import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import { Source } from "../compiled/webpack-sources";
 import { Compilation } from "./Compilation";
 export type ResourceData = {
     resource: string;
@@ -11,7 +11,11 @@ export type ResourceDataWithData = ResourceData & {
     data?: Record<string, any>;
 };
 export type CreateData = Partial<JsCreateData>;
+export type ContextInfo = {
+    issuer: string;
+};
 export type ResolveData = {
+    contextInfo: ContextInfo;
     context: string;
     request: string;
     fileDependencies: string[];
@@ -32,11 +36,12 @@ export type ContextModuleFactoryAfterResolveResult = false | {
 };
 export declare class Module {
     #private;
-    context?: string;
-    resource?: string;
-    request?: string;
-    userRequest?: string;
-    rawRequest?: string;
+    context?: Readonly<string>;
+    resource?: Readonly<string>;
+    request?: Readonly<string>;
+    userRequest?: Readonly<string>;
+    rawRequest?: Readonly<string>;
+    factoryMeta?: Readonly<JsFactoryMeta>;
     /**
      * Records the dynamically added fields for Module on the JavaScript side.
      * These fields are generally used within a plugin, so they do not need to be passed back to the Rust side.

package/dist/Module.js

@@ -27,6 +27,7 @@ class Module {
         this.request = module.request;
         this.userRequest = module.userRequest;
         this.rawRequest = module.rawRequest;
+        this.factoryMeta = module.factoryMeta;
         const customModule = compilation?.__internal__getCustomModule(module.moduleIdentifier);
         this.buildInfo = customModule?.buildInfo || {};
         this.buildMeta = customModule?.buildMeta || {};

package/dist/MultiCompiler.d.ts

@@ -7,7 +7,7 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import { AsyncSeriesHook, Callback, MultiHook, SyncBailHook, SyncHook } from "tapable";
+import * as liteTapable from "@rspack/lite-tapable";
 import { Compiler, RspackOptions } from ".";
 import MultiStats from "./MultiStats";
 import MultiWatching from "./MultiWatching";
@@ -25,12 +25,12 @@ export declare class MultiCompiler {
     compilers: Compiler[];
     dependencies: WeakMap<Compiler, string[]>;
     hooks: {
-        done: SyncHook<MultiStats>;
-        invalid: MultiHook<SyncHook<[string | null, number]>>;
-        run: MultiHook<AsyncSeriesHook<[Compiler]>>;
-        watchClose: SyncHook<[]>;
-        watchRun: MultiHook<AsyncSeriesHook<[Compiler]>>;
-        infrastructureLog: MultiHook<SyncBailHook<[string, string, any[]], true>>;
+        done: liteTapable.SyncHook<MultiStats>;
+        invalid: liteTapable.MultiHook<liteTapable.SyncHook<[string | null, number]>>;
+        run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        watchClose: liteTapable.SyncHook<[]>;
+        watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        infrastructureLog: liteTapable.MultiHook<liteTapable.SyncBailHook<[string, string, any[]], true>>;
     };
     _options: MultiCompilerOptions;
     running: boolean;
@@ -55,14 +55,14 @@ export declare class MultiCompiler {
      * @param callback - signals when the validation is complete
      * @returns true if the dependencies are valid
      */
-    validateDependencies(callback: Callback<Error, MultiStats>): boolean;
+    validateDependencies(callback: liteTapable.Callback<Error, MultiStats>): boolean;
     /**
      * @param watchOptions - the watcher's options
      * @param handler - signals when the call finishes
      * @returns a compiler watcher
      */
-    watch(watchOptions: WatchOptions, handler: Callback<Error, MultiStats>): MultiWatching;
-    run(callback: Callback<Error, MultiStats>): void;
+    watch(watchOptions: WatchOptions, handler: liteTapable.Callback<Error, MultiStats>): MultiWatching;
+    run(callback: liteTapable.Callback<Error, MultiStats>): void;
     purgeInputFileSystem(): void;
-    close(callback: Callback<Error, void>): void;
+    close(callback: liteTapable.Callback<Error, void>): void;
 }

package/dist/MultiCompiler.js

@@ -8,6 +8,29 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -19,8 +42,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _MultiCompiler_instances, _MultiCompiler_runGraph;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiCompiler = void 0;
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const neo_async_1 = __importDefault(require("../compiled/neo-async"));
-const tapable_1 = require("tapable");
 const MultiStats_1 = __importDefault(require("./MultiStats"));
 const MultiWatching_1 = __importDefault(require("./MultiWatching"));
 const ConcurrentCompilationError_1 = __importDefault(require("./error/ConcurrentCompilationError"));
@@ -35,18 +58,12 @@ class MultiCompiler {
             });
         }
         this.hooks = {
-            /** @type {SyncHook<[MultiStats]>} */
-            done: new tapable_1.SyncHook(["stats"]),
-            /** @type {MultiHook<SyncHook<[string | null, number]>>} */
-            invalid: new tapable_1.MultiHook(compilers.map(c => c.hooks.invalid)),
-            /** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-            run: new tapable_1.MultiHook(compilers.map(c => c.hooks.run)),
-            /** @type {SyncHook<[]>} */
-            watchClose: new tapable_1.SyncHook([]),
-            /** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-            watchRun: new tapable_1.MultiHook(compilers.map(c => c.hooks.watchRun)),
-            /** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
-            infrastructureLog: new tapable_1.MultiHook(compilers.map(c => c.hooks.infrastructureLog))
+            done: new liteTapable.SyncHook(["stats"]),
+            invalid: new liteTapable.MultiHook(compilers.map(c => c.hooks.invalid)),
+            run: new liteTapable.MultiHook(compilers.map(c => c.hooks.run)),
+            watchClose: new liteTapable.SyncHook([]),
+            watchRun: new liteTapable.MultiHook(compilers.map(c => c.hooks.watchRun)),
+            infrastructureLog: new liteTapable.MultiHook(compilers.map(c => c.hooks.infrastructureLog))
         };
         this.compilers = compilers;
         this._options = {

package/dist/NormalModule.d.ts

@@ -1,12 +1,15 @@
 /// <reference types="node" />
-import { AsyncSeriesBailHook, HookMap, SyncHook } from "tapable";
+import * as liteTapable from "@rspack/lite-tapable";
 import { Compilation } from "./Compilation";
 import { LoaderContext } from "./config";
 export declare class NormalModule {
-    constructor();
     static getCompilationHooks(compilation: Compilation): {
-        loader: SyncHook<[LoaderContext<{}>], void, import("tapable").UnsetAdditionalOptions>;
+        loader: liteTapable.SyncHook<[LoaderContext<{}>], void, {
+            _UnsetAdditionalOptions: true;
+        }>;
         readResourceForScheme: any;
-        readResource: HookMap<AsyncSeriesBailHook<[LoaderContext<{}>], string | Buffer, import("tapable").UnsetAdditionalOptions>>;
+        readResource: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[LoaderContext<{}>], string | Buffer, {
+            _UnsetAdditionalOptions: true;
+        }>>;
     };
 }

package/dist/NormalModule.js

@@ -1,11 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NormalModule = void 0;
 const util_1 = __importDefault(require("util"));
-const tapable_1 = require("tapable");
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Compilation_1 = require("./Compilation");
 const compilationHooksMap = new WeakMap();
 const createFakeHook = (fakeHook, message, code) => {
@@ -46,10 +69,7 @@ const deprecateAllProperties = (obj, message, code) => {
     }
     return newObj;
 };
-// Actually it is just a NormalModule proxy, used for hooks api alignment
-// Maybe we can 1:1 align to webpack NormalModule once we found a better way to reduce communicate overhead between rust and js
 class NormalModule {
-    constructor() { }
     static getCompilationHooks(compilation) {
         if (!(compilation instanceof Compilation_1.Compilation)) {
             throw new TypeError("The 'compilation' argument must be an instance of Compilation");
@@ -57,12 +77,9 @@ class NormalModule {
         let hooks = compilationHooksMap.get(compilation);
         if (hooks === undefined) {
             hooks = {
-                loader: new tapable_1.SyncHook(["loaderContext"]),
-                // beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-                // beforeParse: new SyncHook(["module"]),
-                // beforeSnapshot: new SyncHook(["module"]),
+                loader: new liteTapable.SyncHook(["loaderContext"]),
                 // TODO webpack 6 deprecate
-                readResourceForScheme: new tapable_1.HookMap(scheme => {
+                readResourceForScheme: new liteTapable.HookMap(scheme => {
                     const hook = hooks.readResource.for(scheme);
                     return createFakeHook({
                         tap: (options, fn) => hook.tap(options, (loaderContext) => fn(loaderContext.resource)),
@@ -70,8 +87,7 @@ class NormalModule {
                         tapPromise: (options, fn) => hook.tapPromise(options, (loaderContext) => fn(loaderContext.resource))
                     });
                 }),
-                readResource: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(["loaderContext"]))
-                // needBuild: new AsyncSeriesBailHook(["module", "context"])
+                readResource: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["loaderContext"]))
             };
             compilationHooksMap.set(compilation, hooks);
         }

package/dist/NormalModuleFactory.d.ts

@@ -1,6 +1,6 @@
 import type * as binding from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
 import { ResolveData, ResourceDataWithData } from "./Module";
-import * as liteTapable from "./lite-tapable";
 export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {
     settings: {};
 };
@@ -8,6 +8,8 @@ export declare class NormalModuleFactory {
     hooks: {
         resolveForScheme: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
         beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        factorize: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
+        resolve: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
         afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
         createModule: liteTapable.AsyncSeriesBailHook<[
             NormalModuleCreateData,

package/dist/NormalModuleFactory.js

@@ -24,39 +24,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NormalModuleFactory = void 0;
-const liteTapable = __importStar(require("./lite-tapable"));
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 class NormalModuleFactory {
     constructor() {
         this.hooks = {
-            // /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
-            // resolve: new AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
             resolveForScheme: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["resourceData"])),
-            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-            // resolveInScheme: new HookMap(
-            // 	() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-            // ),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
-            // factorize: new AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
+            factorize: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
+            resolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             createModule: new liteTapable.AsyncSeriesBailHook([
                 "createData",
                 "resolveData"
             ])
-            // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
-            // module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-            // createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-            // parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-            // createGenerator: new HookMap(
-            // 	() => new SyncBailHook(["generatorOptions"])
-            // ),
-            // generator: new HookMap(
-            // 	() => new SyncHook(["generator", "generatorOptions"])
-            // )
         };
     }
 }