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.3, đượ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 đổi94
Mới bị ngừng hỗ trợ0
Thay đổi yêu cầu (engines, phụ thuộc peer)0
Export mới15

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.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 (15)
importexportkind
tapableIfSettype
tapableAppendtype
tapableAnyHooktype
tapableAsArraytype
tapableFullTaptype
tapableMeasuretype
tapableCallbacktype
tapableAsyncHookclass
tapableHookFactorytype
tapableTypedHookMapclass
tapableArgumentNamestype
tapableInnerCallbacktype
tapableFixedSizeArraytype
tapableAsyncSeriesLoopHookclass
tapableUnsetAdditionalOptionsclass

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.3, Vigia tìm thấy 4 export bị xóa, 4 chữ ký thay đổi và 124 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.3.

Dành cho tác tử

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