Vigia

Upgrading tapable from 1.x to 2.x

Comparison of the public API of tapable 1.1.3 and 2.3.4, computed automatically from their TypeScript types. A changed signature is a candidate for a breaking change, not a certainty.

Summary

Removed import paths0
Removed exports4
Changed signatures4
Removed class or interface members30
Changed class or interface members96
Newly deprecated0
Requirement changes (engines, peer dependencies)0
New exports14

Removed exports

importexportkindBefore
tapableTapTypetype"sync" | "async" | "promise"
tapableTapableclassclass
tapableTapFunctiontypeT extends "sync" ? (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => TResult : T extends "async" ? (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => void : T extends "promise" ? (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => Promise<TResult> : never
tapableHookCompileOptionsinterfaceinterface

Changed signatures

exportBeforeAfter
tapable · TapinterfaceTapOptions & { name: string; }
tapable · TapOptions{ name: string; stage?: number | undefined; context?: boolean | undefined; before?: string | string[] | undefined; } & (TTapType extends "sync" ? { type?: "sync" | undefined; fn?: ((arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => THookResult) | undefined; } : TTapType extends "async" ? { type?: "async" | undefined; fn?: ((arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => void) | undefined; } : TTapType extends "promise" ? { type?: "promise" | undefined; fn?: ((arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => Promise<THookResult>) | undefined; } : { type?: TTapType | …{ before?: string | undefined; stage?: number | undefined; }
tapable · HookInterceptorclassinterface
tapable · HookMapInterceptorclassinterface

Removed class or interface members

memberimportBefore
Hook.calltapable(arg1?: TArg1 | undefined, arg2?: TArg2 | undefined, arg3?: TArg3 | undefined, ...args: any[]): THookResult
Hook.compiletapable(options: HookCompileOptions): Function
Hook.tapAsynctapable(name: string | TapOptions<"async", TArg1, TArg2, TArg3, TTabResult>, fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => void): void
Hook.tapPromisetapable(name: string | TapOptions<"promise", TArg1, TArg2, TArg3, TTabResult>, fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => Promise<TTabResult>): void
HookMap.taptapable(key: any, name: string | TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void
HookMap.tapAsynctapable(key: any, name: string | TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void
HookMap.tapPromisetapable(key: any, name: string | TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void
SyncHook.compiletapable(options: HookCompileOptions): Function
SyncHook.tapAsynctapable(name: string | TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void
SyncHook.tapPromisetapable(name: string | TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void
SyncBailHook.compiletapable(options: HookCompileOptions): Function
SyncBailHook.tapAsynctapable(name: string | TapOptions<"async", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void
SyncBailHook.tapPromisetapable(name: string | TapOptions<"promise", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<THookResult | undefined>): void
SyncLoopHook.compiletapable(options: HookCompileOptions): Function
SyncLoopHook.tapAsynctapable(name: string | TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void
SyncLoopHook.tapPromisetapable(name: string | TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void
AsyncSeriesHook.calltapable(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined
AsyncSeriesHook.compiletapable(options: HookCompileOptions): Function
HookInterceptor.contexttapableboolean | undefined
AsyncParallelHook.calltapable(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined
AsyncParallelHook.compiletapable(options: HookCompileOptions): Function
SyncWaterfallHook.compiletapable(options: HookCompileOptions): Function
SyncWaterfallHook.tapAsynctapable(name: string | TapOptions<"async", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void
SyncWaterfallHook.tapPromisetapable(name: string | TapOptions<"promise", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<T1>): void
AsyncSeriesBailHook.calltapable(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined
AsyncSeriesBailHook.compiletapable(options: HookCompileOptions): Function
AsyncParallelBailHook.calltapable(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined
AsyncParallelBailHook.compiletapable(options: HookCompileOptions): Function
AsyncSeriesWaterfallHook.calltapable(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): T1
AsyncSeriesWaterfallHook.compiletapable(options: HookCompileOptions): Function

Changed class or interface members

memberBeforeAfter
Hook.tap(name: string | TapOptions<"sync", TArg1, TArg2, TArg3, TTabResult>, fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => TTabResult): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
Hook.tapsTap<TapType, TArg1, TArg2, TArg3, THookResult>[]FullTap[]
Hook.promise(arg1?: TArg1 | undefined, arg2?: TArg2 | undefined, arg3?: TArg3 | undefined, ...args: any[]): Promise<THookResult>(...args: AsArray<T>): Promise<R>
Hook.callAsync(arg1?: TArg1 | undefined, arg2?: TArg2 | undefined, arg3?: TArg3 | undefined, ...args: any[]): THookResult(...args: Append<AsArray<T>, Callback<Error, R>>): void
Hook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
Hook.constructor<TArg1 = any, TArg2 = any, TArg3 = any, TTabResult = any, THookResult = any>(tapArgumentNames?: string[] | undefined): Hook<TArg1, TArg2, TArg3, TTabResult, THookResult><T, R, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): Hook<T, R, AdditionalOptions>
Hook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
HookMap.for(key: any): Hook<T1, T2, T3, any, any>(key: any): H
HookMap.get(key: any): Hook<T1, T2, T3, any, any> | undefined(key: any): H | undefined
HookMap.intercept(interceptor: HookMapInterceptor<T1, T2, T3>): void(interceptor: HookMapInterceptor<H, any>): void
HookMap.constructor<T1 = any, T2 = any, T3 = any>(fn: () => Hook<any, any, any, any, any>): HookMap<T1, T2, T3><H>(factory: HookFactory<H, any>, name?: string | undefined): HookMap<H>
SyncHook.tap(name: string | TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
SyncHook.call(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: AsArray<T>): R
SyncHook.tapsTap<TapType, T1, T2, T3, undefined>[]FullTap[]
SyncHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<undefined>(...args: AsArray<T>): Promise<R>
SyncHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: Append<AsArray<T>, Callback<Error, R>>): void
SyncHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
SyncHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): SyncHook<T1, T2, T3><T, R = void, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): SyncHook<T, R, AdditionalOptions>
SyncHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
MultiHook.constructor(hooks: Hook<any, any, any, any, any>[]): MultiHook<H>(hooks: H[], name?: string | undefined): MultiHook<H>
SyncBailHook.tap(name: string | TapOptions<"sync", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => THookResult | undefined): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
SyncBailHook.call(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined(...args: AsArray<T>): R
SyncBailHook.tapsTap<TapType, T1, T2, T3, THookResult | undefined>[]FullTap[]
SyncBailHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<THookResult | undefined>(...args: AsArray<T>): Promise<R>
SyncBailHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined(...args: Append<AsArray<T>, Callback<Error, R>>): void
SyncBailHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
SyncBailHook.constructor<T1 = any, T2 = any, T3 = any, THookResult = any>(tapArgumentNames?: string[] | undefined): SyncBailHook<T1, T2, T3, THookResult><T, R, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): SyncBailHook<T, R, AdditionalOptions>
SyncBailHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
SyncLoopHook.tap(name: string | TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => void): void
SyncLoopHook.call(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: AsArray<T>): void
SyncLoopHook.tapsTap<TapType, T1, T2, T3, undefined>[]FullTap[]
SyncLoopHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<undefined>(...args: AsArray<T>): Promise<void>
SyncLoopHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: Append<AsArray<T>, Callback<Error, void>>): void
SyncLoopHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, void, AdditionalOptions>): void
SyncLoopHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): SyncLoopHook<T1, T2, T3><T, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): SyncLoopHook<T, AdditionalOptions>
SyncLoopHook.interceptorsHookInterceptor[]HookInterceptor<T, void, AdditionalOptions>[]
AsyncSeriesHook.tap(name: string | TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => void): void
AsyncSeriesHook.tapsTap<TapType, T1, T2, T3, undefined>[]FullTap[]
AsyncSeriesHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<undefined>(...args: AsArray<T>): Promise<void>
AsyncSeriesHook.tapAsync(name: string | TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: Append<AsArray<T>, InnerCallback<Error, void>>) => void): void
AsyncSeriesHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: Append<AsArray<T>, Callback<Error, void>>): void
AsyncSeriesHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, void, AdditionalOptions>): void
AsyncSeriesHook.tapPromise(name: string | TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => Promise<void>): void
AsyncSeriesHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): AsyncSeriesHook<T1, T2, T3><T, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): AsyncSeriesHook<T, AdditionalOptions>
AsyncSeriesHook.interceptorsHookInterceptor[]HookInterceptor<T, void, AdditionalOptions>[]
HookInterceptor.tap((tap: Tap<TapType, any, any, any, any>) => void) | undefined((tap: TapOptions & { name: string; } & { type: "sync" | "async" | "promise"; fn: Function; } & IfSet<AdditionalOptions>) => void) | undefined
HookInterceptor.call((...args: any[]) => void) | undefined((...args: AsArray<T>) => void) | undefined
HookInterceptor.loop((...args: any[]) => void) | undefined((...args: AsArray<T>) => void) | undefined
HookInterceptor.register((tap: Tap<TapType, any, any, any, any>) => Tap<TapType, any, any, any, any> | undefined) | undefined((tap: TapOptions & { name: string; } & { type: "sync" | "async" | "promise"; fn: Function; } & IfSet<AdditionalOptions>) => TapOptions & { name: string; } & { type: "sync" | "async" | "promise"; fn: Function; } & IfSet<AdditionalOptions>) | undefined
HookInterceptor.constructor(): HookInterceptor
AsyncParallelHook.tap(name: string | TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => void): void
AsyncParallelHook.tapsTap<TapType, T1, T2, T3, undefined>[]FullTap[]
AsyncParallelHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<undefined>(...args: AsArray<T>): Promise<void>
AsyncParallelHook.tapAsync(name: string | TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: Append<AsArray<T>, InnerCallback<Error, void>>) => void): void
AsyncParallelHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): undefined(...args: Append<AsArray<T>, Callback<Error, void>>): void
AsyncParallelHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, void, AdditionalOptions>): void
AsyncParallelHook.tapPromise(name: string | TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => Promise<void>): void
AsyncParallelHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): AsyncParallelHook<T1, T2, T3><T, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): AsyncParallelHook<T, AdditionalOptions>
AsyncParallelHook.interceptorsHookInterceptor[]HookInterceptor<T, void, AdditionalOptions>[]
SyncWaterfallHook.tap(name: string | TapOptions<"sync", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => T1): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
SyncWaterfallHook.call(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): T1(...args: AsArray<T>): R
SyncWaterfallHook.tapsTap<TapType, T1, T2, T3, T1>[]FullTap[]
SyncWaterfallHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<T1>(...args: AsArray<T>): Promise<R>
SyncWaterfallHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): T1(...args: Append<AsArray<T>, Callback<Error, R>>): void
SyncWaterfallHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
SyncWaterfallHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): SyncWaterfallHook<T1, T2, T3><T, R = AsArray<T>[0], AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): SyncWaterfallHook<T, R, AdditionalOptions>
SyncWaterfallHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
HookMapInterceptor.factory(key: any, hook: Hook<T1, T2, T3, any, any>): Hook<T1, T2, T3, any, any>((key: K, hook: H) => H) | undefined
HookMapInterceptor.constructor<T1 = any, T2 = any, T3 = any>(): HookMapInterceptor<T1, T2, T3>
AsyncSeriesBailHook.tap(name: string | TapOptions<"sync", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => THookResult | undefined): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
AsyncSeriesBailHook.tapsTap<TapType, T1, T2, T3, THookResult | undefined>[]FullTap[]
AsyncSeriesBailHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<THookResult | undefined>(...args: AsArray<T>): Promise<R>
AsyncSeriesBailHook.tapAsync(name: string | TapOptions<"async", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void): void
AsyncSeriesBailHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined(...args: Append<AsArray<T>, Callback<Error, R>>): void
AsyncSeriesBailHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
AsyncSeriesBailHook.tapPromise(name: string | TapOptions<"promise", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<THookResult | undefined>): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => Promise<R>): void
AsyncSeriesBailHook.constructor<T1 = any, T2 = any, T3 = any, THookResult = any>(tapArgumentNames?: string[] | undefined): AsyncSeriesBailHook<T1, T2, T3, THookResult><T, R, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): AsyncSeriesBailHook<T, R, AdditionalOptions>
AsyncSeriesBailHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
AsyncParallelBailHook.tap(name: string | TapOptions<"sync", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => THookResult | undefined): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
AsyncParallelBailHook.tapsTap<TapType, T1, T2, T3, THookResult | undefined>[]FullTap[]
AsyncParallelBailHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<THookResult | undefined>(...args: AsArray<T>): Promise<R>
AsyncParallelBailHook.tapAsync(name: string | TapOptions<"async", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void): void
AsyncParallelBailHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): THookResult | undefined(...args: Append<AsArray<T>, Callback<Error, R>>): void
AsyncParallelBailHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
AsyncParallelBailHook.tapPromise(name: string | TapOptions<"promise", T1, T2, T3, THookResult | undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<THookResult | undefined>): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => Promise<R>): void
AsyncParallelBailHook.constructor<T1 = any, T2 = any, T3 = any, THookResult = any>(tapArgumentNames?: string[] | undefined): AsyncParallelBailHook<T1, T2, T3, THookResult><T, R, AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): AsyncParallelBailHook<T, R, AdditionalOptions>
AsyncParallelBailHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]
AsyncSeriesWaterfallHook.tap(name: string | TapOptions<"sync", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => T1): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => R): void
AsyncSeriesWaterfallHook.tapsTap<TapType, T1, T2, T3, T1>[]FullTap[]
AsyncSeriesWaterfallHook.promise(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): Promise<T1>(...args: AsArray<T>): Promise<R>
AsyncSeriesWaterfallHook.tapAsync(name: string | TapOptions<"async", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void): void
AsyncSeriesWaterfallHook.callAsync(arg1?: T1 | undefined, arg2?: T2 | undefined, arg3?: T3 | undefined, ...args: any[]): T1(...args: Append<AsArray<T>, Callback<Error, R>>): void
AsyncSeriesWaterfallHook.intercept(interceptor: HookInterceptor): void(interceptor: HookInterceptor<T, R, AdditionalOptions>): void
AsyncSeriesWaterfallHook.tapPromise(name: string | TapOptions<"promise", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<T1>): void(options: string | (TapOptions & { name: string; } & IfSet<AdditionalOptions>), fn: (...args: AsArray<T>) => Promise<R>): void
AsyncSeriesWaterfallHook.constructor<T1 = any, T2 = any, T3 = any>(tapArgumentNames?: string[] | undefined): AsyncSeriesWaterfallHook<T1, T2, T3><T, R = AsArray<T>[0], AdditionalOptions = UnsetAdditionalOptions>(args?: FixedSizeArray<AsArray<T>["length"], string> | undefined, name?: string | undefined): AsyncSeriesWaterfallHook<T, R, AdditionalOptions>
AsyncSeriesWaterfallHook.interceptorsHookInterceptor[]HookInterceptor<T, R, AdditionalOptions>[]

Newly deprecated

None detected.

Requirement changes (engines, peer dependencies)

None detected.

New exports (14)
importexportkind
tapableIfSettype
tapableAppendtype
tapableAsArraytype
tapableFullTaptype
tapableMeasuretype
tapableCallbacktype
tapableAsyncHookclass
tapableHookFactorytype
tapableTypedHookMapinterface
tapableArgumentNamestype
tapableInnerCallbacktype
tapableFixedSizeArraytype
tapableAsyncSeriesLoopHookclass
tapableUnsetAdditionalOptionsclass

Give your AI agent these facts

Vigia is a free MCP server: your coding agent checks versions, breaking changes and vulnerabilities before it writes code. No signup, no API key.

claude mcp add --transport http vigia https://vigia.coredls.cloud/mcp

Add to CursorAdd to VS Code★ Star on GitHub

Any other MCP client
{ "mcpServers": { "vigia": { "url": "https://vigia.coredls.cloud/mcp" } } }

Agent skill (SKILL.md): tells the agent when to use Vigia · GitHub Action for pull requests

Frequently asked questions

What are the breaking changes when upgrading tapable from 1 to 2?

Between tapable 1.1.3 and 2.3.4, Vigia found 4 removed exports, 4 changed signatures and 126 removed or changed class or interface members.

What became deprecated in tapable 2?

0 exports or members are newly marked as deprecated in tapable 2.3.4.

For agents

GET https://vigia.coredls.cloud/v1/packages/npm/tapable/upgrade?from=1.1.3&to=2.3.4