Revert "Remove node_modules"

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

@@ -0,0 +1,186 @@
+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
+) => unknown | Promise<unknown>;
+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;