@rspack/core 0.5.6 → 0.5.7-canary-3320ea8-20240312032922

package/dist/config/zod.d.ts

@@ -1923,6 +1923,8 @@ declare const generatorOptionsByModuleType: z.ZodUnion<[z.ZodObject<{
     } | undefined;
 }>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>]>;
 export type GeneratorOptionsByModuleType = z.infer<typeof generatorOptionsByModuleType>;
+declare const noParseOption: z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, "many">]>;
+export type NoParseOption = z.infer<typeof noParseOption>;
 declare const moduleOptions: z.ZodObject<{
     defaultRules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"...">, z.ZodType<RuleSetRule, z.ZodTypeDef, RuleSetRule>]>, z.ZodUnion<[z.ZodLiteral<false>, z.ZodLiteral<0>, z.ZodLiteral<"">, z.ZodNull, z.ZodUndefined]>]>, "many">>;
     rules: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"...">, z.ZodType<RuleSetRule, z.ZodTypeDef, RuleSetRule>]>, z.ZodUnion<[z.ZodLiteral<false>, z.ZodLiteral<0>, z.ZodLiteral<"">, z.ZodNull, z.ZodUndefined]>]>, "many">>;
@@ -2085,6 +2087,7 @@ declare const moduleOptions: z.ZodObject<{
             publicPath?: string | undefined;
         } | undefined;
     }>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>]>>;
+    noParse: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, "many">]>>;
 }, "strict", z.ZodTypeAny, {
     defaultRules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
     rules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
@@ -2121,6 +2124,7 @@ declare const moduleOptions: z.ZodObject<{
             publicPath?: string | undefined;
         } | undefined;
     } | undefined;
+    noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
 }, {
     defaultRules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
     rules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
@@ -2157,6 +2161,7 @@ declare const moduleOptions: z.ZodObject<{
             publicPath?: string | undefined;
         } | undefined;
     } | undefined;
+    noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
 }>;
 export type ModuleOptions = z.infer<typeof moduleOptions>;
 declare const target: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<false>, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["web", "webworker", "es3", "es5", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020", "es2021", "es2022", "browserslist"]>, z.ZodLiteral<"node">]>, z.ZodLiteral<"async-node">]>, z.ZodType<`node${number}`, z.ZodTypeDef, `node${number}`>]>, z.ZodType<`async-node${number}`, z.ZodTypeDef, `async-node${number}`>]>, z.ZodType<`node${number}.${number}`, z.ZodTypeDef, `node${number}.${number}`>]>, z.ZodType<`async-node${number}.${number}`, z.ZodTypeDef, `async-node${number}.${number}`>]>, z.ZodLiteral<"electron-main">]>, z.ZodType<`electron${number}-main`, z.ZodTypeDef, `electron${number}-main`>]>, z.ZodType<`electron${number}.${number}-main`, z.ZodTypeDef, `electron${number}.${number}-main`>]>, z.ZodLiteral<"electron-renderer">]>, z.ZodType<`electron${number}-renderer`, z.ZodTypeDef, `electron${number}-renderer`>]>, z.ZodType<`electron${number}.${number}-renderer`, z.ZodTypeDef, `electron${number}.${number}-renderer`>]>, z.ZodLiteral<"electron-preload">]>, z.ZodType<`electron${number}-preload`, z.ZodTypeDef, `electron${number}-preload`>]>, z.ZodType<`electron${number}.${number}-preload`, z.ZodTypeDef, `electron${number}.${number}-preload`>]>]>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["web", "webworker", "es3", "es5", "es2015", "es2016", "es2017", "es2018", "es2019", "es2020", "es2021", "es2022", "browserslist"]>, z.ZodLiteral<"node">]>, z.ZodLiteral<"async-node">]>, z.ZodType<`node${number}`, z.ZodTypeDef, `node${number}`>]>, z.ZodType<`async-node${number}`, z.ZodTypeDef, `async-node${number}`>]>, z.ZodType<`node${number}.${number}`, z.ZodTypeDef, `node${number}.${number}`>]>, z.ZodType<`async-node${number}.${number}`, z.ZodTypeDef, `async-node${number}.${number}`>]>, z.ZodLiteral<"electron-main">]>, z.ZodType<`electron${number}-main`, z.ZodTypeDef, `electron${number}-main`>]>, z.ZodType<`electron${number}.${number}-main`, z.ZodTypeDef, `electron${number}.${number}-main`>]>, z.ZodLiteral<"electron-renderer">]>, z.ZodType<`electron${number}-renderer`, z.ZodTypeDef, `electron${number}-renderer`>]>, z.ZodType<`electron${number}.${number}-renderer`, z.ZodTypeDef, `electron${number}.${number}-renderer`>]>, z.ZodLiteral<"electron-preload">]>, z.ZodType<`electron${number}-preload`, z.ZodTypeDef, `electron${number}-preload`>]>, z.ZodType<`electron${number}.${number}-preload`, z.ZodTypeDef, `electron${number}.${number}-preload`>]>, "many">]>;
@@ -2417,6 +2422,7 @@ declare const statsOptions: z.ZodObject<{
     children: z.ZodOptional<z.ZodBoolean>;
     usedExports: z.ZodOptional<z.ZodBoolean>;
     providedExports: z.ZodOptional<z.ZodBoolean>;
+    optimizationBailout: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     all?: boolean | undefined;
     preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -2451,6 +2457,7 @@ declare const statsOptions: z.ZodObject<{
     children?: boolean | undefined;
     usedExports?: boolean | undefined;
     providedExports?: boolean | undefined;
+    optimizationBailout?: boolean | undefined;
 }, {
     all?: boolean | undefined;
     preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -2485,6 +2492,7 @@ declare const statsOptions: z.ZodObject<{
     children?: boolean | undefined;
     usedExports?: boolean | undefined;
     providedExports?: boolean | undefined;
+    optimizationBailout?: boolean | undefined;
 }>;
 export type StatsOptions = z.infer<typeof statsOptions>;
 declare const statsValue: z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["none", "errors-only", "errors-warnings", "normal", "verbose"]>, z.ZodBoolean]>, z.ZodObject<{
@@ -2521,6 +2529,7 @@ declare const statsValue: z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["none", "errors-onl
     children: z.ZodOptional<z.ZodBoolean>;
     usedExports: z.ZodOptional<z.ZodBoolean>;
     providedExports: z.ZodOptional<z.ZodBoolean>;
+    optimizationBailout: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     all?: boolean | undefined;
     preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -2555,6 +2564,7 @@ declare const statsValue: z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["none", "errors-onl
     children?: boolean | undefined;
     usedExports?: boolean | undefined;
     providedExports?: boolean | undefined;
+    optimizationBailout?: boolean | undefined;
 }, {
     all?: boolean | undefined;
     preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -2589,6 +2599,7 @@ declare const statsValue: z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["none", "errors-onl
     children?: boolean | undefined;
     usedExports?: boolean | undefined;
     providedExports?: boolean | undefined;
+    optimizationBailout?: boolean | undefined;
 }>]>;
 export type StatsValue = z.infer<typeof statsValue>;
 export interface RspackPluginInstance {
@@ -3914,6 +3925,7 @@ export declare const rspackOptions: z.ZodObject<{
         children: z.ZodOptional<z.ZodBoolean>;
         usedExports: z.ZodOptional<z.ZodBoolean>;
         providedExports: z.ZodOptional<z.ZodBoolean>;
+        optimizationBailout: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         all?: boolean | undefined;
         preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -3948,6 +3960,7 @@ export declare const rspackOptions: z.ZodObject<{
         children?: boolean | undefined;
         usedExports?: boolean | undefined;
         providedExports?: boolean | undefined;
+        optimizationBailout?: boolean | undefined;
     }, {
         all?: boolean | undefined;
         preset?: "none" | "normal" | "verbose" | "errors-only" | "errors-warnings" | undefined;
@@ -3982,6 +3995,7 @@ export declare const rspackOptions: z.ZodObject<{
         children?: boolean | undefined;
         usedExports?: boolean | undefined;
         providedExports?: boolean | undefined;
+        optimizationBailout?: boolean | undefined;
     }>]>>;
     snapshot: z.ZodOptional<z.ZodObject<{
         module: z.ZodOptional<z.ZodObject<{
@@ -4486,6 +4500,7 @@ export declare const rspackOptions: z.ZodObject<{
                 publicPath?: string | undefined;
             } | undefined;
         }>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>]>>;
+        noParse: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>]>, "many">]>>;
     }, "strict", z.ZodTypeAny, {
         defaultRules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
         rules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
@@ -4522,6 +4537,7 @@ export declare const rspackOptions: z.ZodObject<{
                 publicPath?: string | undefined;
             } | undefined;
         } | undefined;
+        noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
     }, {
         defaultRules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
         rules?: (false | "" | 0 | "..." | RuleSetRule | null | undefined)[] | undefined;
@@ -4558,6 +4574,7 @@ export declare const rspackOptions: z.ZodObject<{
                 publicPath?: string | undefined;
             } | undefined;
         } | undefined;
+        noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
     }>>;
     profile: z.ZodOptional<z.ZodBoolean>;
     bail: z.ZodOptional<z.ZodBoolean>;
@@ -4772,6 +4789,7 @@ export declare const rspackOptions: z.ZodObject<{
         children?: boolean | undefined;
         usedExports?: boolean | undefined;
         providedExports?: boolean | undefined;
+        optimizationBailout?: boolean | undefined;
     } | undefined;
     snapshot?: {
         module?: {
@@ -4882,6 +4900,7 @@ export declare const rspackOptions: z.ZodObject<{
                 publicPath?: string | undefined;
             } | undefined;
         } | undefined;
+        noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
     } | undefined;
     profile?: boolean | undefined;
     bail?: boolean | undefined;
@@ -5096,6 +5115,7 @@ export declare const rspackOptions: z.ZodObject<{
         children?: boolean | undefined;
         usedExports?: boolean | undefined;
         providedExports?: boolean | undefined;
+        optimizationBailout?: boolean | undefined;
     } | undefined;
     snapshot?: {
         module?: {
@@ -5206,6 +5226,7 @@ export declare const rspackOptions: z.ZodObject<{
                 publicPath?: string | undefined;
             } | undefined;
         } | undefined;
+        noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
     } | undefined;
     profile?: boolean | undefined;
     bail?: boolean | undefined;

package/dist/config/zod.js

@@ -345,11 +345,17 @@ const generatorOptionsByModuleTypeKnown = zod_1.z.strictObject({
 });
 const generatorOptionsByModuleTypeUnknown = zod_1.z.record(zod_1.z.record(zod_1.z.any()));
 const generatorOptionsByModuleType = generatorOptionsByModuleTypeKnown.or(generatorOptionsByModuleTypeUnknown);
+const noParseOptionSingle = zod_1.z
+    .string()
+    .or(zod_1.z.instanceof(RegExp))
+    .or(zod_1.z.function().args(zod_1.z.string()).returns(zod_1.z.boolean()));
+const noParseOption = noParseOptionSingle.or(zod_1.z.array(noParseOptionSingle));
 const moduleOptions = zod_1.z.strictObject({
     defaultRules: ruleSetRules.optional(),
     rules: ruleSetRules.optional(),
     parser: parserOptionsByModuleType.optional(),
-    generator: generatorOptionsByModuleType.optional()
+    generator: generatorOptionsByModuleType.optional(),
+    noParse: noParseOption.optional()
 });
 //#endregion
 //#region Target
@@ -568,7 +574,8 @@ const statsOptions = zod_1.z.strictObject({
     runtimeModules: zod_1.z.boolean().optional(),
     children: zod_1.z.boolean().optional(),
     usedExports: zod_1.z.boolean().optional(),
-    providedExports: zod_1.z.boolean().optional()
+    providedExports: zod_1.z.boolean().optional(),
+    optimizationBailout: zod_1.z.boolean().optional()
 });
 const statsValue = zod_1.z
     .enum(["none", "errors-only", "errors-warnings", "normal", "verbose"])

package/dist/exports.d.ts

@@ -233,6 +233,7 @@ export declare const config: {
             children?: boolean | undefined;
             usedExports?: boolean | undefined;
             providedExports?: boolean | undefined;
+            optimizationBailout?: boolean | undefined;
         } | undefined;
         snapshot?: {
             module?: {
@@ -343,6 +344,7 @@ export declare const config: {
                     publicPath?: string | undefined;
                 } | undefined;
             } | undefined;
+            noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
         } | undefined;
         profile?: boolean | undefined;
         bail?: boolean | undefined;
@@ -559,6 +561,7 @@ export declare const config: {
             children?: boolean | undefined;
             usedExports?: boolean | undefined;
             providedExports?: boolean | undefined;
+            optimizationBailout?: boolean | undefined;
         } | undefined;
         snapshot?: {
             module?: {
@@ -669,6 +672,7 @@ export declare const config: {
                     publicPath?: string | undefined;
                 } | undefined;
             } | undefined;
+            noParse?: string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean) | (string | RegExp | ((args_0: string, ...args_1: unknown[]) => boolean))[] | undefined;
         } | undefined;
         profile?: boolean | undefined;
         bail?: boolean | undefined;

package/dist/lite-tapable/index.d.ts

@@ -14,12 +14,15 @@ type Append<T extends any[], U> = {
     7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], U];
     8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], U];
 }[Measure<T["length"]>];
-type AsArray<T> = T extends any[] ? T : [T];
+export type AsArray<T> = T extends any[] ? T : [T];
+export type Fn<T, R> = (...args: AsArray<T>) => R;
+export type FnWithCallback<T, R> = (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void;
 declare class UnsetAdditionalOptions {
     _UnsetAdditionalOptions: true;
 }
 type IfSet<X> = X extends UnsetAdditionalOptions ? {} : X;
 type Callback<E, T> = (error: E | null, result?: T) => void;
+type InnerCallback<E, T> = (error?: E | null | false, result?: T) => void;
 type FullTap = Tap & {
     type: "sync" | "async" | "promise";
     fn: Function;
@@ -31,7 +34,8 @@ type TapOptions = {
     before?: string;
     stage?: number;
 };
-interface HookInterceptor<T, R, AdditionalOptions = UnsetAdditionalOptions> {
+export type Options<AdditionalOptions = UnsetAdditionalOptions> = string | (Tap & IfSet<AdditionalOptions>);
+export interface HookInterceptor<T, R, AdditionalOptions = UnsetAdditionalOptions> {
     name?: string;
     tap?: (tap: FullTap & IfSet<AdditionalOptions>) => void;
     call?: (...args: any[]) => void;
@@ -55,38 +59,44 @@ declare class Hook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
     _runTapInterceptors(tap: FullTap & IfSet<AdditionalOptions>): void;
     _runDoneInterceptors(): void;
     isUsed(): boolean;
-    callAsyncStageRange(stageRange: StageRange, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    queryStageRange(stageRange: StageRange): QueriedHook<T, R, AdditionalOptions>;
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
     callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
-    promiseStageRange(stageRange: StageRange, ...args: AsArray<T>): Promise<R>;
+    promiseStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): Promise<R>;
     promise(...args: AsArray<T>): Promise<R>;
-    tap(options: string | (Tap & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void;
-    _tap(type: "sync" | "async" | "promise", options: string | (Tap & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void;
+    tap(options: Options<AdditionalOptions>, fn: Fn<T, R>): void;
+    _tap(type: "sync" | "async" | "promise", options: Options<AdditionalOptions>, fn: Function): void;
     _insert(item: FullTap & IfSet<AdditionalOptions>): void;
 }
-export declare class StageRange {
-    #private;
-    constructor(from: number, to: number);
-    static from(from: number, to: number): StageRange;
-    static all(): StageRange;
-    get from(): number;
-    get to(): number;
-    static MAX: number;
-    static MIN: number;
-    static trim(n: number): number;
+export type StageRange = readonly [number, number];
+export declare const minStage: number;
+export declare const maxStage: number;
+export declare const safeStage: (stage: number) => number;
+export declare class QueriedHook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
+    stageRange: StageRange;
+    hook: Hook<T, R, AdditionalOptions>;
+    tapsInRange: (FullTap & IfSet<AdditionalOptions>)[];
+    constructor(stageRange: StageRange, hook: Hook<T, R, AdditionalOptions>);
+    isUsed(): boolean;
+    call(...args: AsArray<T>): R;
+    callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    promise(...args: AsArray<T>): Promise<R>;
 }
 export declare class SyncHook<T, R = void, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
-    callAsyncStageRange({ from, to }: StageRange, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
     call(...args: AsArray<T>): R;
-    /**
-     * call a range of taps, from < stage <= to, (from, to]
-     */
-    callStageRange(stageRange: StageRange, ...args: AsArray<T>): R;
+    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
     tapAsync(): never;
     tapPromise(): never;
 }
 export declare class AsyncParallelHook<T, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, void, AdditionalOptions> {
-    callAsyncStageRange({ from, to }: StageRange, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
-    tapAsync(options: string | (Tap & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => void): void;
-    tapPromise(options: string | (Tap & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => void): void;
+    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
+    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
+    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
+}
+export declare class AsyncSeriesHook<T, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, void, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
+    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
+    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
 }
 export {};

package/dist/lite-tapable/index.js

@@ -1,18 +1,6 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-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");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _StageRange_from, _StageRange_to;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncParallelHook = exports.SyncHook = exports.StageRange = void 0;
+exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = void 0;
 class Hook {
     constructor(args, name) {
         this.args = args;
@@ -70,16 +58,20 @@ class Hook {
     isUsed() {
         return this.taps.length > 0 || this.interceptors.length > 0;
     }
-    callAsyncStageRange(stageRange, ...args) {
+    queryStageRange(stageRange) {
+        return new QueriedHook(stageRange, this);
+    }
+    callAsyncStageRange(queried, ...args) {
         throw new Error("Hook should implement there own _callAsyncStageRange");
     }
     callAsync(...args) {
-        return this.callAsyncStageRange(StageRange.all(), ...args);
+        return this.callAsyncStageRange(this.queryStageRange(allStageRange), ...args);
     }
-    promiseStageRange(stageRange, ...args) {
+    promiseStageRange(queried, ...args) {
         return new Promise((resolve, reject) => {
+            this.callAsyncStageRange(queried, 
             // @ts-expect-error
-            this.callAsyncStageRange(stageRange, ...args, (e, r) => {
+            ...args, (e, r) => {
                 if (e)
                     return reject(e);
                 return resolve(r);
@@ -87,7 +79,7 @@ class Hook {
         });
     }
     promise(...args) {
-        return this.promiseStageRange(StageRange.all(), ...args);
+        return this.promiseStageRange(this.queryStageRange(allStageRange), ...args);
     }
     tap(options, fn) {
         this._tap("sync", options, fn);
@@ -144,74 +136,95 @@ class Hook {
         this.taps[i] = item;
     }
 }
-class StageRange {
-    constructor(from, to) {
-        _StageRange_from.set(this, void 0);
-        _StageRange_to.set(this, void 0);
-        __classPrivateFieldSet(this, _StageRange_from, StageRange.trim(from), "f");
-        __classPrivateFieldSet(this, _StageRange_to, StageRange.trim(to), "f");
-    }
-    static from(from, to) {
-        return new StageRange(from, to);
+exports.minStage = -Infinity;
+exports.maxStage = Infinity;
+const allStageRange = [exports.minStage, exports.maxStage];
+const i32MIN = -(2 ** 31);
+const i32MAX = 2 ** 31 - 1;
+const safeStage = (stage) => {
+    if (stage < i32MIN)
+        return i32MIN;
+    if (stage > i32MAX)
+        return i32MAX;
+    return stage;
+};
+exports.safeStage = safeStage;
+class QueriedHook {
+    constructor(stageRange, hook) {
+        var _a;
+        const tapsInRange = [];
+        const [from, to] = stageRange;
+        for (let tap of hook.taps) {
+            const stage = (_a = tap.stage) !== null && _a !== void 0 ? _a : 0;
+            if (from < stage && stage <= to) {
+                tapsInRange.push(tap);
+            }
+            else if (from === exports.minStage && stage === exports.minStage) {
+                tapsInRange.push(tap);
+            }
+        }
+        this.stageRange = stageRange;
+        this.hook = hook;
+        this.tapsInRange = tapsInRange;
     }
-    static all() {
-        return StageRange.from(StageRange.MIN, StageRange.MAX);
+    isUsed() {
+        if (this.tapsInRange.length > 0)
+            return true;
+        if (this.stageRange[0] === exports.minStage &&
+            this.hook.interceptors.some(i => i.call))
+            return true;
+        if (this.stageRange[1] === exports.maxStage &&
+            this.hook.interceptors.some(i => i.done))
+            return true;
+        return false;
     }
-    get from() {
-        return __classPrivateFieldGet(this, _StageRange_from, "f");
+    call(...args) {
+        if (typeof this.hook.callStageRange !==
+            "function") {
+            throw new Error("hook is not a SyncHook, call methods only exists on SyncHook");
+        }
+        return this.hook.callStageRange(this, ...args);
     }
-    get to() {
-        return __classPrivateFieldGet(this, _StageRange_to, "f");
+    callAsync(...args) {
+        return this.hook.callAsyncStageRange(this, ...args);
     }
-    static trim(n) {
-        if (n > StageRange.MAX)
-            return StageRange.MAX;
-        if (n < StageRange.MIN)
-            return StageRange.MIN;
-        return n;
+    promise(...args) {
+        return this.hook.promiseStageRange(this, ...args);
     }
 }
-_StageRange_from = new WeakMap(), _StageRange_to = new WeakMap();
-StageRange.MAX = 2 ** 31 - 1;
-StageRange.MIN = -(2 ** 31);
-exports.StageRange = StageRange;
+exports.QueriedHook = QueriedHook;
 class SyncHook extends Hook {
-    callAsyncStageRange({ from, to }, ...args) {
-        var _a;
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
         const args2 = [...args];
         const cb = args2.pop();
-        if (from === StageRange.MIN) {
+        if (from === exports.minStage) {
             this._runCallInterceptors(...args2);
         }
-        for (let tap of this.taps) {
-            const stage = (_a = tap.stage) !== null && _a !== void 0 ? _a : 0;
-            if (from < stage && stage <= to) {
-                this._runTapInterceptors(tap);
-                try {
-                    tap.fn(...args2);
-                }
-                catch (e) {
-                    const err = e;
-                    this._runErrorInterceptors(err);
-                    return cb(err);
-                }
+        for (let tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            try {
+                tap.fn(...args2);
+            }
+            catch (e) {
+                const err = e;
+                this._runErrorInterceptors(err);
+                return cb(err);
             }
         }
-        if (to === StageRange.MAX) {
+        if (to === exports.maxStage) {
             this._runDoneInterceptors();
             cb(null);
         }
     }
     call(...args) {
-        return this.callStageRange(StageRange.all(), ...args);
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
     }
-    /**
-     * call a range of taps, from < stage <= to, (from, to]
-     */
-    callStageRange(stageRange, ...args) {
+    callStageRange(queried, ...args) {
         let result, error;
+        this.callAsyncStageRange(queried, 
         // @ts-expect-error
-        this.callAsyncStageRange(stageRange, ...args, (e, r) => {
+        ...args, (e, r) => {
             error = e;
             result = r;
         });
@@ -229,11 +242,11 @@ class SyncHook extends Hook {
 }
 exports.SyncHook = SyncHook;
 class AsyncParallelHook extends Hook {
-    callAsyncStageRange({ from, to }, ...args) {
-        var _a;
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
         const args2 = [...args];
         const cb = args2.pop();
-        if (from === StageRange.MIN) {
+        if (from === exports.minStage) {
             this._runCallInterceptors(...args2);
         }
         const done = () => {
@@ -244,13 +257,6 @@ class AsyncParallelHook extends Hook {
             this._runErrorInterceptors(e);
             cb(e);
         };
-        const tapsInRange = [];
-        for (let tap of this.taps) {
-            const stage = (_a = tap.stage) !== null && _a !== void 0 ? _a : 0;
-            if (from < stage && stage <= to) {
-                tapsInRange.push(tap);
-            }
-        }
         if (tapsInRange.length === 0)
             return done();
         let counter = tapsInRange.length;
@@ -313,3 +319,95 @@ class AsyncParallelHook extends Hook {
     }
 }
 exports.AsyncParallelHook = AsyncParallelHook;
+class AsyncSeriesHook extends Hook {
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
+        const args2 = [...args];
+        const cb = args2.pop();
+        if (from === exports.minStage) {
+            this._runCallInterceptors(...args2);
+        }
+        const done = () => {
+            this._runDoneInterceptors();
+            cb(null);
+        };
+        const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+        };
+        if (tapsInRange.length === 0)
+            return done();
+        let index = 0;
+        const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if (tap.type === "promise") {
+                const promise = tap.fn(...args2);
+                if (!promise || !promise.then) {
+                    throw new Error("Tap function (tapPromise) did not return promise (returned " +
+                        promise +
+                        ")");
+                }
+                promise.then(() => {
+                    index += 1;
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }, (e) => {
+                    index = tapsInRange.length;
+                    error(e);
+                });
+            }
+            else if (tap.type === "async") {
+                tap.fn(...args2, (e) => {
+                    if (e) {
+                        index = tapsInRange.length;
+                        error(e);
+                    }
+                    else {
+                        index += 1;
+                        if (index === tapsInRange.length) {
+                            done();
+                        }
+                        else {
+                            next();
+                        }
+                    }
+                });
+            }
+            else {
+                let hasError = false;
+                try {
+                    tap.fn(...args2);
+                }
+                catch (e) {
+                    hasError = true;
+                    index = tapsInRange.length;
+                    error(e);
+                }
+                if (!hasError) {
+                    index += 1;
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }
+            }
+            if (index === tapsInRange.length)
+                return;
+        };
+        next();
+    }
+    tapAsync(options, fn) {
+        this._tap("async", options, fn);
+    }
+    tapPromise(options, fn) {
+        this._tap("promise", options, fn);
+    }
+}
+exports.AsyncSeriesHook = AsyncSeriesHook;

package/dist/loader-runner/index.js

@@ -119,11 +119,13 @@ async function runLoaders(compiler, rawContext) {
     const resource = rawContext.resource;
     const loaderContext = {};
     //
-    const splittedResource = parsePathQueryFragment(resource);
-    const resourcePath = splittedResource.path;
-    const resourceQuery = splittedResource.query;
-    const resourceFragment = splittedResource.fragment;
-    const contextDirectory = dirname(resourcePath);
+    const splittedResource = resource && parsePathQueryFragment(resource);
+    const resourcePath = splittedResource ? splittedResource.path : undefined;
+    const resourceQuery = splittedResource ? splittedResource.query : undefined;
+    const resourceFragment = splittedResource
+        ? splittedResource.fragment
+        : undefined;
+    const contextDirectory = resourcePath ? dirname(resourcePath) : null;
     // execution state
     let cacheable = true;
     const fileDependencies = rawContext.fileDependencies.slice();