wishthis/node_modules/before-after-hook/index.d.ts

type HookMethod<Options, Result> = (
  options: Options
) => Result | Promise<Result>

type BeforeHook<Options> = (options: Options) => void | Promise<void>
type ErrorHook<Options, Error> = (
  error: Error,
  options: Options
) => void | Promise<void>
type AfterHook<Options, Result> = (
  result: Result,
  options: Options
) => void | Promise<void>
type WrapHook<Options, Result> = (
  hookMethod: HookMethod<Options, Result>,
  options: Options
) => Result | Promise<Result>

type AnyHook<Options, Result, Error> =
  | BeforeHook<Options>
  | ErrorHook<Options, Error>
  | AfterHook<Options, Result>
  | WrapHook<Options, Result>

type TypeStoreKeyLong = 'Options' | 'Result' | 'Error'
type TypeStoreKeyShort = 'O' | 'R' | 'E'
type TypeStore =
  | ({ [key in TypeStoreKeyLong]?: any } &
      { [key in TypeStoreKeyShort]?: never })
  | ({ [key in TypeStoreKeyLong]?: never } &
      { [key in TypeStoreKeyShort]?: any })
type GetType<
  Store extends TypeStore,
  LongKey extends TypeStoreKeyLong,
  ShortKey extends TypeStoreKeyShort
> = LongKey extends keyof Store
  ? Store[LongKey]
  : ShortKey extends keyof Store
  ? Store[ShortKey]
  : any

export interface HookCollection<
  HooksType extends Record<string, TypeStore> = Record<
    string,
    { Options: any; Result: any; Error: any }
  >,
  HookName extends keyof HooksType = keyof HooksType
> {
  /**
   * Invoke before and after hooks
   */
  <Name extends HookName>(
    name: Name | Name[],
    hookMethod: HookMethod<
      GetType<HooksType[Name], 'Options', 'O'>,
      GetType<HooksType[Name], 'Result', 'R'>
    >,
    options?: GetType<HooksType[Name], 'Options', 'O'>
  ): Promise<GetType<HooksType[Name], 'Result', 'R'>>
  /**
   * Add `before` hook for given `name`
   */
  before<Name extends HookName>(
    name: Name,
    beforeHook: BeforeHook<GetType<HooksType[Name], 'Options', 'O'>>
  ): void
  /**
   * Add `error` hook for given `name`
   */
  error<Name extends HookName>(
    name: Name,
    errorHook: ErrorHook<
      GetType<HooksType[Name], 'Options', 'O'>,
      GetType<HooksType[Name], 'Error', 'E'>
    >
  ): void
  /**
   * Add `after` hook for given `name`
   */
  after<Name extends HookName>(
    name: Name,
    afterHook: AfterHook<
      GetType<HooksType[Name], 'Options', 'O'>,
      GetType<HooksType[Name], 'Result', 'R'>
    >
  ): void
  /**
   * Add `wrap` hook for given `name`
   */
  wrap<Name extends HookName>(
    name: Name,
    wrapHook: WrapHook<
      GetType<HooksType[Name], 'Options', 'O'>,
      GetType<HooksType[Name], 'Result', 'R'>
    >
  ): void
  /**
   * Remove added hook for given `name`
   */
  remove<Name extends HookName>(
    name: Name,
    hook: AnyHook<
      GetType<HooksType[Name], 'Options', 'O'>,
      GetType<HooksType[Name], 'Result', 'R'>,
      GetType<HooksType[Name], 'Error', 'E'>
    >
  ): void
  /**
   * Public API
   */
  api: Pick<
    HookCollection<HooksType>,
    'before' | 'error' | 'after' | 'wrap' | 'remove'
  >
}

export interface HookSingular<Options, Result, Error> {
  /**
   * Invoke before and after hooks
   */
  (hookMethod: HookMethod<Options, Result>, options?: Options): Promise<Result>
  /**
   * Add `before` hook
   */
  before(beforeHook: BeforeHook<Options>): void
  /**
   * Add `error` hook
   */
  error(errorHook: ErrorHook<Options, Error>): void
  /**
   * Add `after` hook
   */
  after(afterHook: AfterHook<Options, Result>): void
  /**
   * Add `wrap` hook
   */
  wrap(wrapHook: WrapHook<Options, Result>): void
  /**
   * Remove added hook
   */
  remove(hook: AnyHook<Options, Result, Error>): void
  /**
   * Public API
   */
  api: Pick<
    HookSingular<Options, Result, Error>,
    'before' | 'error' | 'after' | 'wrap' | 'remove'
  >
}

type Collection = new <
  HooksType extends Record<string, TypeStore> = Record<
    string,
    { Options: any; Result: any; Error: any }
  >
>() => HookCollection<HooksType>
type Singular = new <
  Options = any,
  Result = any,
  Error = any
>() => HookSingular<Options, Result, Error>

interface Hook {
  new <
    HooksType extends Record<string, TypeStore> = Record<
      string,
      { Options: any; Result: any; Error: any }
    >
  >(): HookCollection<HooksType>

  /**
   * Creates a collection of hooks
   */
  Collection: Collection

  /**
   * Creates a nameless hook that supports strict typings
   */
  Singular: Singular
}

export const Hook: Hook
export const Collection: Collection
export const Singular: Singular

export default Hook