Vigia

Upgrade von tapable 1.x auf 2.x

Vergleich der öffentlichen API von tapable 1.1.3 und 2.3.4, automatisch aus den TypeScript-Typen berechnet. Eine geänderte Signatur ist ein möglicher Breaking Change, keine Gewissheit.

Zusammenfassung

Entfernte Importpfade0
Entfernte Exporte4
Geänderte Signaturen4
Entfernte Member von Klassen oder Interfaces30
Geänderte Member von Klassen oder Interfaces96
Neu als veraltet markiert0
Geänderte Anforderungen (engines, Peer-Abhängigkeiten)0
Neue Exporte14

Entfernte Exporte

importexportkindVorher
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

Geänderte Signaturen

exportVorherNachher
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

Entfernte Member von Klassen oder Interfaces

memberimportVorher
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

Geänderte Member von Klassen oder Interfaces

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

Neu als veraltet markiert

Keine gefunden.

Geänderte Anforderungen (engines, Peer-Abhängigkeiten)

Keine gefunden.

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

Gib deinem KI-Agenten diese Fakten

Vigia ist ein kostenloser MCP-Server: Dein Coding-Agent prüft Versionen, Breaking Changes und Sicherheitslücken, bevor er Code schreibt. Ohne Anmeldung, ohne API-Schlüssel.

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

Zu Cursor hinzufügenZu VS Code hinzufügen★ Stern auf GitHub

Jeder andere MCP-Client
{ "mcpServers": { "vigia": { "url": "https://vigia.coredls.cloud/mcp" } } }

Agent-Skill (SKILL.md): sagt dem Agenten, wann er Vigia nutzen soll · GitHub Action für Pull Requests

Häufige Fragen

Welche Breaking Changes gibt es beim Upgrade von tapable 1 auf 2?

Zwischen tapable 1.1.3 und 2.3.4 hat Vigia 4 entfernte Exporte, 4 geänderte Signaturen und 126 entfernte oder geänderte Member von Klassen oder Interfaces gefunden.

Was wurde in tapable 2 als veraltet markiert?

0 Exporte oder Member sind in tapable 2.3.4 neu als veraltet markiert.

Für Agenten

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