hooks.ts

/**
 * Fonctions pour "patcher" les méthodes d'une classe.
 */

type Hookable<K extends string | symbol, M extends (...args: any[]) => any> = { [X in K]: M };

function isHookable<K extends string | symbol, M extends (...args: any[]) => any>(
  what: unknown,
  key: K
): what is Hookable<K, M> {
  return typeof what === 'object' && what !== null && key in what && typeof (what as any)[key] === 'function';
}

/**
 * Installe un hook.
 */
function installHook<T extends Hookable<K, M>, M extends (this: T, ...args: any[]) => void, K extends string | symbol>(
  target: T,
  name: K,
  makeHook: (old: M) => M
): void {
  if (!isHookable<K, M>(target, name)) {
    throw new Error(`cannot hook ${name} on ${target}`);
  }
  if (name === 'constructor') {
    throw new Error('cannot hook constructors');
  }
  target[name] = <T[K]> makeHook(target[name]);
}

/**
 * Modifie une méthode d'un objet pour éxecuter une fonction avant son éxecution normale.
 *
 * @param {object} target Le prototype à modifier.
 * @param {string|symbol} name Le nom de la méthode à surcharger.
 * @param {function} hook La fonction à ajouter.
 */
export function hookBefore<
  T extends Hookable<K, M>,
  M extends (this: T, ...args: any[]) => void,
  K extends string | symbol
  >(target: Hookable<K, M>, name: K, hook: M): void {
  installHook(
    target,
    name,
    oldMethod =>
      function(...args: any[]): void {
        hook.apply(this, args);
        oldMethod.apply(this, args);
      }
  );
}

/**
 * Modifie une méthode d'un objet pour éxecuter une fonction après son éxecution normale.
 *
 * @param {object} target Le prototype à modifier.
 * @param {string|symbol} name Le nom de la méthode à surcharger.
 * @param {function} hook La fonction à ajouter.
 */
export function hookAfter<
  T extends Hookable<K, M>,
  M extends (this: T, ...args: any[]) => void,
  K extends string | symbol
  >(target: T, name: K, hook: M): void {
  installHook(
    target,
    name,
    oldMethod =>
      function(...args: any[]): void {