@rspack/core 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/Compilation.d.ts

@@ -9,11 +9,10 @@
  */
 import type * as binding from "@rspack/binding";
 import { type ExternalObject, type JsCompilation, type JsModule, type JsPathData, type JsRuntimeModule } from "@rspack/binding";
-import * as tapable from "tapable";
+import * as liteTapable from "@rspack/lite-tapable";
 import { Source } from "../compiled/webpack-sources";
 import { ContextModuleFactory } from "./ContextModuleFactory";
 import { Filename, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
-import * as liteTapable from "./lite-tapable";
 import ResolverFactory = require("./ResolverFactory");
 import { Chunk } from "./Chunk";
 import { ChunkGraph } from "./ChunkGraph";
@@ -106,8 +105,8 @@ export declare class Compilation {
     hooks: Readonly<{
         processAssets: liteTapable.AsyncSeriesHook<Assets>;
         afterProcessAssets: liteTapable.SyncHook<Assets>;
-        childCompiler: tapable.SyncHook<[Compiler, string, number]>;
-        log: tapable.SyncBailHook<[string, LogEntry], true>;
+        childCompiler: liteTapable.SyncHook<[Compiler, string, number]>;
+        log: liteTapable.SyncBailHook<[string, LogEntry], true>;
         additionalAssets: any;
         optimizeModules: liteTapable.SyncBailHook<Iterable<Module>, void>;
         afterOptimizeModules: liteTapable.SyncHook<Iterable<Module>, void>;
@@ -122,16 +121,19 @@ export declare class Compilation {
         finishModules: liteTapable.AsyncSeriesHook<[Iterable<Module>], void>;
         chunkHash: liteTapable.SyncHook<[Chunk, Hash], void>;
         chunkAsset: liteTapable.SyncHook<[Chunk, string], void>;
-        processWarnings: tapable.SyncWaterfallHook<[Error[]]>;
+        processWarnings: liteTapable.SyncWaterfallHook<[Error[]]>;
         succeedModule: liteTapable.SyncHook<[Module], void>;
         stillValidModule: liteTapable.SyncHook<[Module], void>;
-        statsPreset: tapable.HookMap<tapable.SyncHook<[Partial<StatsOptions>, CreateStatsOptionsContext], void>>;
-        statsNormalize: tapable.SyncHook<[
+        statsPreset: liteTapable.HookMap<liteTapable.SyncHook<[
+            Partial<StatsOptions>,
+            CreateStatsOptionsContext
+        ], void>>;
+        statsNormalize: liteTapable.SyncHook<[
             Partial<StatsOptions>,
             CreateStatsOptionsContext
         ], void>;
-        statsFactory: tapable.SyncHook<[StatsFactory, StatsOptions], void>;
-        statsPrinter: tapable.SyncHook<[StatsPrinter, StatsOptions], void>;
+        statsFactory: liteTapable.SyncHook<[StatsFactory, StatsOptions], void>;
+        statsPrinter: liteTapable.SyncHook<[StatsPrinter, StatsOptions], void>;
         buildModule: liteTapable.SyncHook<[Module]>;
         executeModule: liteTapable.SyncHook<[
             ExecuteModuleArgument,
@@ -175,7 +177,7 @@ export declare class Compilation {
     /**
      * Get the named chunks.
      *
-     * Note: This is a proxy for webpack internal API, only method `get` is supported now.
+     * Note: This is a proxy for webpack internal API, only method `get` and `keys` is supported now.
      */
     get namedChunks(): ReadonlyMap<string, Readonly<Chunk>>;
     /**

package/dist/Compilation.js

@@ -40,8 +40,7 @@ var _Compilation_instances, _Compilation_inner, _Compilation_cachedAssets, _Comp
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compilation = void 0;
 const binding_1 = require("@rspack/binding");
-const tapable = __importStar(require("tapable"));
-const liteTapable = __importStar(require("./lite-tapable"));
+const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Chunk_1 = require("./Chunk");
 const ChunkGraph_1 = require("./ChunkGraph");
 const Entrypoint_1 = require("./Entrypoint");
@@ -131,12 +130,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             afterProcessAssets: new liteTapable.SyncHook(["assets"]),
             /** @deprecated */
             additionalAssets: createProcessAssetsHook("additionalAssets", Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, () => []),
-            childCompiler: new tapable.SyncHook([
+            childCompiler: new liteTapable.SyncHook([
                 "childCompiler",
                 "compilerName",
                 "compilerIndex"
             ]),
-            log: new tapable.SyncBailHook(["origin", "logEntry"]),
+            log: new liteTapable.SyncBailHook(["origin", "logEntry"]),
             optimizeModules: new liteTapable.SyncBailHook(["modules"]),
             afterOptimizeModules: new liteTapable.SyncBailHook(["modules"]),
             optimizeTree: new liteTapable.AsyncSeriesHook(["chunks", "modules"]),
@@ -147,13 +146,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             finishModules: new liteTapable.AsyncSeriesHook(["modules"]),
             chunkHash: new liteTapable.SyncHook(["chunk", "hash"]),
             chunkAsset: new liteTapable.SyncHook(["chunk", "filename"]),
-            processWarnings: new tapable.SyncWaterfallHook(["warnings"]),
+            processWarnings: new liteTapable.SyncWaterfallHook(["warnings"]),
             succeedModule: new liteTapable.SyncHook(["module"]),
             stillValidModule: new liteTapable.SyncHook(["module"]),
-            statsPreset: new tapable.HookMap(() => new tapable.SyncHook(["options", "context"])),
-            statsNormalize: new tapable.SyncHook(["options", "context"]),
-            statsFactory: new tapable.SyncHook(["statsFactory", "options"]),
-            statsPrinter: new tapable.SyncHook(["statsPrinter", "options"]),
+            statsPreset: new liteTapable.HookMap(() => new liteTapable.SyncHook(["options", "context"])),
+            statsNormalize: new liteTapable.SyncHook(["options", "context"]),
+            statsFactory: new liteTapable.SyncHook(["statsFactory", "options"]),
+            statsPrinter: new liteTapable.SyncHook(["statsPrinter", "options"]),
             buildModule: new liteTapable.SyncHook(["module"]),
             executeModule: new liteTapable.SyncHook(["options", "context"]),
             additionalTreeRuntimeRequirements: new liteTapable.SyncHook([
@@ -203,10 +202,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     /**
      * Get the named chunks.
      *
-     * Note: This is a proxy for webpack internal API, only method `get` is supported now.
+     * Note: This is a proxy for webpack internal API, only method `get` and `keys` is supported now.
      */
     get namedChunks() {
         return {
+            keys: () => {
+                const names = __classPrivateFieldGet(this, _Compilation_inner, "f").getNamedChunkKeys();
+                return names[Symbol.iterator]();
+            },
             get: (property) => {
                 if (typeof property === "string") {
                     const chunk = __classPrivateFieldGet(this, _Compilation_inner, "f").getNamedChunk(property) || undefined;

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,7 +17,6 @@ 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");
@@ -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;
@@ -700,6 +702,22 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             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)

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/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,11 +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 {
     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) => {
@@ -54,9 +77,9 @@ class NormalModule {
         let hooks = compilationHooksMap.get(compilation);
         if (hooks === undefined) {
             hooks = {
-                loader: new tapable_1.SyncHook(["loaderContext"]),
+                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)),
@@ -64,7 +87,7 @@ class NormalModule {
                         tapPromise: (options, fn) => hook.tapPromise(options, (loaderContext) => fn(loaderContext.resource))
                     });
                 }),
-                readResource: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(["loaderContext"]))
+                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: {};
 };
@@ -9,6 +9,7 @@ export declare class NormalModuleFactory {
         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,13 +24,14 @@ 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 = {
             resolveForScheme: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["resourceData"])),
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             factorize: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
+            resolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             createModule: new liteTapable.AsyncSeriesBailHook([
                 "createData",

package/dist/ResolverFactory.d.ts

@@ -24,13 +24,13 @@ declare class ResolverFactory {
 declare namespace ResolverFactory {
     export { ResolveOptions, Resolver, WebpackResolveOptions, ResolvePluginInstance, ResolveOptionsWithDependencyType, WithOptions, ResolverWithOptions, ResolverCache };
 }
-import { HookMap } from "tapable";
-import { SyncWaterfallHook } from "tapable";
+import { HookMap } from "@rspack/lite-tapable";
+import { SyncWaterfallHook } from "@rspack/lite-tapable";
 type ResolveOptionsWithDependencyType = WebpackResolveOptions & {
     dependencyType?: string;
     resolveToContext?: boolean;
 };
-import { SyncHook } from "tapable";
+import { SyncHook } from "@rspack/lite-tapable";
 type Resolver = import("../compiled/enhanced-resolve").Resolver;
 type ResolveOptions = import("../compiled/enhanced-resolve").ResolveOptions;
 type ResolverCache = {

package/dist/ResolverFactory.js

@@ -9,7 +9,7 @@
  */
 "use strict";
 const Factory = require("../compiled/enhanced-resolve").ResolverFactory;
-const { HookMap, SyncHook, SyncWaterfallHook } = require("tapable");
+const { HookMap, SyncHook, SyncWaterfallHook } = require("@rspack/lite-tapable");
 const { cachedCleverMerge, removeOperations, resolveByProperty } = require("./util/cleverMerge");
 /** @typedef {import("../compiled/enhanced-resolve").ResolveOptions} ResolveOptions */
 /** @typedef {import("../compiled/enhanced-resolve").Resolver} Resolver */

package/dist/Stats.d.ts

@@ -7,6 +7,8 @@ export declare class Stats {
     compilation: Compilation;
     constructor(compilation: Compilation);
     get hash(): Readonly<string | null>;
+    get startTime(): number | undefined;
+    get endTime(): number | undefined;
     hasErrors(): boolean;
     hasWarnings(): boolean;
     toJson(opts?: StatsValue, forToString?: boolean): StatsCompilation;

package/dist/Stats.js

@@ -25,6 +25,12 @@ class Stats {
     get hash() {
         return this.compilation.hash;
     }
+    get startTime() {
+        return this.compilation.startTime;
+    }
+    get endTime() {
+        return this.compilation.endTime;
+    }
     hasErrors() {
         return __classPrivateFieldGet(this, _Stats_inner, "f").getErrors().length > 0;
     }

package/dist/Watching.d.ts

@@ -1,4 +1,4 @@
-import { Callback } from "tapable";
+import { Callback } from "@rspack/lite-tapable";
 import type { Compiler } from ".";
 import { Stats } from ".";
 import { WatchOptions } from "./config";

package/dist/builtin-loader/swc/index.d.ts

@@ -2,6 +2,4 @@ export { resolvePluginImport } from "./pluginImport";
 export type { PluginImportOptions } from "./pluginImport";
 export type { ReactOptions } from "./react";
 export { resolveReact } from "./react";
-export { resolvePreact } from "./preact";
-export type { PreactOptions } from "./preact";
 export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";