Vigia

Nâng cấp tapable từ 1.x lên 2.x

So sánh API công khai của tapable 1.1.3 và 2.3.4, được tính tự động từ kiểu TypeScript. Chữ ký thay đổi là thay đổi có thể không tương thích, không phải điều chắc chắn.

Tóm tắt

Đường dẫn import bị xóa0
Export bị xóa4
Chữ ký thay đổi4
Thành viên lớp hoặc interface bị xóa30
Thành viên lớp hoặc interface thay đổi96
Mới bị ngừng hỗ trợ0
Thay đổi yêu cầu (engines, phụ thuộc peer)0
Export mới14

Export bị xóa

importexportkindTrước
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

Chữ ký thay đổi

exportTrướcSau
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

Thành viên lớp hoặc interface bị xóa

memberimportTrước
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

Thành viên lớp hoặc interface thay đổi

memberTrướcSau
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>[]

Mới bị ngừng hỗ trợ

Không phát hiện.

Thay đổi yêu cầu (engines, phụ thuộc peer)

Không phát hiện.

Export mới (14)
importexportkind
tapableIfSettype
tapableAppendtype
tapableAsArraytype
tapableFullTaptype
tapableMeasuretype
tapableCallbacktype
tapableAsyncHookclass
tapableHookFactorytype
tapableTypedHookMapinterface
tapableArgumentNamestype
tapableInnerCallbacktype
tapableFixedSizeArraytype
tapableAsyncSeriesLoopHookclass
tapableUnsetAdditionalOptionsclass

Cung cấp dữ liệu này cho tác tử AI của bạn

Vigia là máy chủ MCP miễn phí: tác tử lập trình của bạn kiểm tra phiên bản, thay đổi phá vỡ tương thích và lỗ hổng trước khi viết mã. Không cần đăng ký, không cần khóa API.

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

Thêm vào CursorThêm vào VS Code★ Gắn sao trên GitHub

Mọi ứng dụng MCP khác
{ "mcpServers": { "vigia": { "url": "https://vigia.coredls.cloud/mcp" } } }

Kỹ năng cho tác tử (SKILL.md): cho tác tử biết khi nào dùng Vigia · GitHub Action cho pull request

Câu hỏi thường gặp

Nâng cấp tapable từ 1 lên 2 có những thay đổi không tương thích nào?

Giữa tapable 1.1.3 và 2.3.4, Vigia tìm thấy 4 export bị xóa, 4 chữ ký thay đổi và 126 thành viên lớp hoặc interface bị xóa hay thay đổi.

Những gì bị ngừng hỗ trợ trong tapable 2?

0 export hoặc thành viên mới bị đánh dấu ngừng hỗ trợ trong tapable 2.3.4.

Dành cho tác tử

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