Aggiornare tapable da 1.x a 2.x

Confronto dell’API pubblica di tapable 1.1.3 e 2.3.3, calcolato automaticamente dai tipi TypeScript. Una firma modificata è una possibile modifica incompatibile, non una certezza.

Riepilogo

Percorsi di import rimossi	0
Export rimossi	4
Firme modificate	4
Membri di classi o interfacce rimossi	30
Membri di classi o interfacce modificati	94
Nuove deprecazioni	0
Requisiti cambiati (engines, dipendenze peer)	0
Nuovi export	15

Export rimossi

import	export	kind	Prima
`tapable`	`TapType`	type	`"sync" \| "async" \| "promise"`
`tapable`	`Tapable`	class	`class`
`tapable`	`TapFunction`	type	`T 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`
`tapable`	`HookCompileOptions`	interface	`interface`

Firme modificate

export	Prima	Dopo
`tapable · Tap`	`interface`	`TapOptions & { 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 · HookInterceptor`	`class`	`interface`
`tapable · HookMapInterceptor`	`class`	`interface`

Membri di classi o interfacce rimossi

member	import	Prima
`Hook.call`	`tapable`	`(arg1?: TArg1 \| undefined, arg2?: TArg2 \| undefined, arg3?: TArg3 \| undefined, ...args: any[]): THookResult`
`Hook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`Hook.tapAsync`	`tapable`	`(name: string \| TapOptions<"async", TArg1, TArg2, TArg3, TTabResult>, fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => void): void`
`Hook.tapPromise`	`tapable`	`(name: string \| TapOptions<"promise", TArg1, TArg2, TArg3, TTabResult>, fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, ...args: any[]) => Promise<TTabResult>): void`
`HookMap.tap`	`tapable`	`(key: any, name: string \| TapOptions<"sync", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => any): void`
`HookMap.tapAsync`	`tapable`	`(key: any, name: string \| TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void`
`HookMap.tapPromise`	`tapable`	`(key: any, name: string \| TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void`
`SyncHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`SyncHook.tapAsync`	`tapable`	`(name: string \| TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void`
`SyncHook.tapPromise`	`tapable`	`(name: string \| TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void`
`SyncBailHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`SyncBailHook.tapAsync`	`tapable`	`(name: string \| TapOptions<"async", T1, T2, T3, THookResult \| undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void`
`SyncBailHook.tapPromise`	`tapable`	`(name: string \| TapOptions<"promise", T1, T2, T3, THookResult \| undefined>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<THookResult \| undefined>): void`
`SyncLoopHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`SyncLoopHook.tapAsync`	`tapable`	`(name: string \| TapOptions<"async", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void`
`SyncLoopHook.tapPromise`	`tapable`	`(name: string \| TapOptions<"promise", T1, T2, T3, any>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<any>): void`
`AsyncSeriesHook.call`	`tapable`	`(arg1?: T1 \| undefined, arg2?: T2 \| undefined, arg3?: T3 \| undefined, ...args: any[]): undefined`
`AsyncSeriesHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`HookInterceptor.context`	`tapable`	`boolean \| undefined`
`AsyncParallelHook.call`	`tapable`	`(arg1?: T1 \| undefined, arg2?: T2 \| undefined, arg3?: T3 \| undefined, ...args: any[]): undefined`
`AsyncParallelHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`SyncWaterfallHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`SyncWaterfallHook.tapAsync`	`tapable`	`(name: string \| TapOptions<"async", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => void): void`
`SyncWaterfallHook.tapPromise`	`tapable`	`(name: string \| TapOptions<"promise", T1, T2, T3, T1>, fn: (arg1: T1, arg2: T2, arg3: T3, ...args: any[]) => Promise<T1>): void`
`AsyncSeriesBailHook.call`	`tapable`	`(arg1?: T1 \| undefined, arg2?: T2 \| undefined, arg3?: T3 \| undefined, ...args: any[]): THookResult \| undefined`
`AsyncSeriesBailHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`AsyncParallelBailHook.call`	`tapable`	`(arg1?: T1 \| undefined, arg2?: T2 \| undefined, arg3?: T3 \| undefined, ...args: any[]): THookResult \| undefined`
`AsyncParallelBailHook.compile`	`tapable`	`(options: HookCompileOptions): Function`
`AsyncSeriesWaterfallHook.call`	`tapable`	`(arg1?: T1 \| undefined, arg2?: T2 \| undefined, arg3?: T3 \| undefined, ...args: any[]): T1`
`AsyncSeriesWaterfallHook.compile`	`tapable`	`(options: HookCompileOptions): Function`

Membri di classi o interfacce modificati

member	Prima	Dopo
`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`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.taps`	`Tap<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.interceptors`	`HookInterceptor[]`	`HookInterceptor<T, R, AdditionalOptions>[]`

Nuove deprecazioni

Nessuna rilevata.

Requisiti cambiati (engines, dipendenze peer)

Nessuna rilevata.

Nuovi export (15)

import	export	kind
`tapable`	`IfSet`	type
`tapable`	`Append`	type
`tapable`	`AnyHook`	type
`tapable`	`AsArray`	type
`tapable`	`FullTap`	type
`tapable`	`Measure`	type
`tapable`	`Callback`	type
`tapable`	`AsyncHook`	class
`tapable`	`HookFactory`	type
`tapable`	`TypedHookMap`	class
`tapable`	`ArgumentNames`	type
`tapable`	`InnerCallback`	type
`tapable`	`FixedSizeArray`	type
`tapable`	`AsyncSeriesLoopHook`	class
`tapable`	`UnsetAdditionalOptions`	class

Domande frequenti

Quali sono le modifiche incompatibili aggiornando tapable da 1 a 2?

Tra tapable 1.1.3 e 2.3.3, Vigia ha trovato 4 export rimossi, 4 firme modificate e 124 membri di classi o interfacce rimossi o modificati.

Cosa è stato deprecato in tapable 2?

0 export o membri risultano ora deprecati in tapable 2.3.3.

Per gli agenti

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