github.com/nektos/act@v0.2.63/pkg/runner/testdata/actions/node12/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  ) => unknown | Promise<unknown>;
    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;