github.com/jfrog/frogbot@v1.1.1-0.20231221090046-821a26f50338/action/node_modules/before-after-hook/index.d.ts (about)

     1  type HookMethod<Options, Result> = (
     2    options: Options
     3  ) => Result | Promise<Result>
     4  
     5  type BeforeHook<Options> = (options: Options) => void | Promise<void>
     6  type ErrorHook<Options, Error> = (
     7    error: Error,
     8    options: Options
     9  ) => void | Promise<void>
    10  type AfterHook<Options, Result> = (
    11    result: Result,
    12    options: Options
    13  ) => void | Promise<void>
    14  type WrapHook<Options, Result> = (
    15    hookMethod: HookMethod<Options, Result>,
    16    options: Options
    17  ) => Result | Promise<Result>
    18  
    19  type AnyHook<Options, Result, Error> =
    20    | BeforeHook<Options>
    21    | ErrorHook<Options, Error>
    22    | AfterHook<Options, Result>
    23    | WrapHook<Options, Result>
    24  
    25  type TypeStoreKeyLong = 'Options' | 'Result' | 'Error'
    26  type TypeStoreKeyShort = 'O' | 'R' | 'E'
    27  type TypeStore =
    28    | ({ [key in TypeStoreKeyLong]?: any } &
    29        { [key in TypeStoreKeyShort]?: never })
    30    | ({ [key in TypeStoreKeyLong]?: never } &
    31        { [key in TypeStoreKeyShort]?: any })
    32  type GetType<
    33    Store extends TypeStore,
    34    LongKey extends TypeStoreKeyLong,
    35    ShortKey extends TypeStoreKeyShort
    36  > = LongKey extends keyof Store
    37    ? Store[LongKey]
    38    : ShortKey extends keyof Store
    39    ? Store[ShortKey]
    40    : any
    41  
    42  export interface HookCollection<
    43    HooksType extends Record<string, TypeStore> = Record<
    44      string,
    45      { Options: any; Result: any; Error: any }
    46    >,
    47    HookName extends keyof HooksType = keyof HooksType
    48  > {
    49    /**
    50     * Invoke before and after hooks
    51     */
    52    <Name extends HookName>(
    53      name: Name | Name[],
    54      hookMethod: HookMethod<
    55        GetType<HooksType[Name], 'Options', 'O'>,
    56        GetType<HooksType[Name], 'Result', 'R'>
    57      >,
    58      options?: GetType<HooksType[Name], 'Options', 'O'>
    59    ): Promise<GetType<HooksType[Name], 'Result', 'R'>>
    60    /**
    61     * Add `before` hook for given `name`
    62     */
    63    before<Name extends HookName>(
    64      name: Name,
    65      beforeHook: BeforeHook<GetType<HooksType[Name], 'Options', 'O'>>
    66    ): void
    67    /**
    68     * Add `error` hook for given `name`
    69     */
    70    error<Name extends HookName>(
    71      name: Name,
    72      errorHook: ErrorHook<
    73        GetType<HooksType[Name], 'Options', 'O'>,
    74        GetType<HooksType[Name], 'Error', 'E'>
    75      >
    76    ): void
    77    /**
    78     * Add `after` hook for given `name`
    79     */
    80    after<Name extends HookName>(
    81      name: Name,
    82      afterHook: AfterHook<
    83        GetType<HooksType[Name], 'Options', 'O'>,
    84        GetType<HooksType[Name], 'Result', 'R'>
    85      >
    86    ): void
    87    /**
    88     * Add `wrap` hook for given `name`
    89     */
    90    wrap<Name extends HookName>(
    91      name: Name,
    92      wrapHook: WrapHook<
    93        GetType<HooksType[Name], 'Options', 'O'>,
    94        GetType<HooksType[Name], 'Result', 'R'>
    95      >
    96    ): void
    97    /**
    98     * Remove added hook for given `name`
    99     */
   100    remove<Name extends HookName>(
   101      name: Name,
   102      hook: AnyHook<
   103        GetType<HooksType[Name], 'Options', 'O'>,
   104        GetType<HooksType[Name], 'Result', 'R'>,
   105        GetType<HooksType[Name], 'Error', 'E'>
   106      >
   107    ): void
   108    /**
   109     * Public API
   110     */
   111    api: Pick<
   112      HookCollection<HooksType>,
   113      'before' | 'error' | 'after' | 'wrap' | 'remove'
   114    >
   115  }
   116  
   117  export interface HookSingular<Options, Result, Error> {
   118    /**
   119     * Invoke before and after hooks
   120     */
   121    (hookMethod: HookMethod<Options, Result>, options?: Options): Promise<Result>
   122    /**
   123     * Add `before` hook
   124     */
   125    before(beforeHook: BeforeHook<Options>): void
   126    /**
   127     * Add `error` hook
   128     */
   129    error(errorHook: ErrorHook<Options, Error>): void
   130    /**
   131     * Add `after` hook
   132     */
   133    after(afterHook: AfterHook<Options, Result>): void
   134    /**
   135     * Add `wrap` hook
   136     */
   137    wrap(wrapHook: WrapHook<Options, Result>): void
   138    /**
   139     * Remove added hook
   140     */
   141    remove(hook: AnyHook<Options, Result, Error>): void
   142    /**
   143     * Public API
   144     */
   145    api: Pick<
   146      HookSingular<Options, Result, Error>,
   147      'before' | 'error' | 'after' | 'wrap' | 'remove'
   148    >
   149  }
   150  
   151  type Collection = new <
   152    HooksType extends Record<string, TypeStore> = Record<
   153      string,
   154      { Options: any; Result: any; Error: any }
   155    >
   156  >() => HookCollection<HooksType>
   157  type Singular = new <
   158    Options = any,
   159    Result = any,
   160    Error = any
   161  >() => HookSingular<Options, Result, Error>
   162  
   163  interface Hook {
   164    new <
   165      HooksType extends Record<string, TypeStore> = Record<
   166        string,
   167        { Options: any; Result: any; Error: any }
   168      >
   169    >(): HookCollection<HooksType>
   170  
   171    /**
   172     * Creates a collection of hooks
   173     */
   174    Collection: Collection
   175  
   176    /**
   177     * Creates a nameless hook that supports strict typings
   178     */
   179    Singular: Singular
   180  }
   181  
   182  export const Hook: Hook
   183  export const Collection: Collection
   184  export const Singular: Singular
   185  
   186  export default Hook