Vigia

Aktualizacja tapable z 1.x do 2.x

Porównanie publicznego API tapable 1.1.3 i 2.3.4, obliczone automatycznie na podstawie typów TypeScript. Zmieniona sygnatura to możliwa zmiana niekompatybilna, a nie pewność.

Podsumowanie

Usunięte ścieżki importu0
Usunięte eksporty4
Zmienione sygnatury4
Usunięte składowe klas lub interfejsów30
Zmienione składowe klas lub interfejsów96
Nowo wycofane0
Zmiany wymagań (engines, zależności peer)0
Nowe eksporty14

Usunięte eksporty

importexportkindPrzed
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

Zmienione sygnatury

exportPrzedPo
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

Usunięte składowe klas lub interfejsów

memberimportPrzed
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

Zmienione składowe klas lub interfejsów

memberPrzedPo
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>[]

Nowo wycofane

Nie wykryto.

Zmiany wymagań (engines, zależności peer)

Nie wykryto.

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

Przekaż te dane swojemu agentowi AI

Vigia to darmowy serwer MCP: Twój agent programistyczny sprawdza wersje, zmiany łamiące zgodność i podatności, zanim napisze kod. Bez rejestracji i klucza API.

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

Dodaj do CursorDodaj do VS Code★ Gwiazdka na GitHubie

Dowolny inny klient MCP
{ "mcpServers": { "vigia": { "url": "https://vigia.coredls.cloud/mcp" } } }

Skill dla agentów (SKILL.md): mówi agentowi, kiedy używać Vigii · GitHub Action dla pull requestów

Najczęściej zadawane pytania

Jakie są zmiany niekompatybilne przy aktualizacji tapable z 1 do 2?

Między tapable 1.1.3 a 2.3.4 Vigia znalazła 4 usuniętych eksportów, 4 zmienionych sygnatur i 126 usuniętych lub zmienionych składowych klas lub interfejsów.

Co zostało wycofane w tapable 2?

0 eksportów lub składowych oznaczono w tapable 2.3.4 jako wycofane.

Dla agentów

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