import { aop, hookName, createHook } from 'to-aop';

const nowHook = createHook(hookName.aroundMethod, 'now', (args) => {
    return 1;
});

aop(Date, nowHook);

Date.now() // returns 1

// a.js
export default class A {
  constructor(variable) {
    this.variable = variable;
  }

  method() {
    return this.variable;
  }

  notHookedMethod() {
    return 'not hook';
  }    
}

import { aop, hookName, createHook, unAop } from 'to-aop';
import A from './a';

const classHookBefore = createHook(
  hookName.beforeMethod,
  /^(method)$/,
  ({ target, object, property, context, args, meta }) => {
    //call your own hook
    meta.startTime = performance.now();
    console.log(
      `Instance of ${target.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}.`
    );
  }
);

const classHookAfter = createHook(
  hookName.afterMethod,
  /^(method)$/,
  ({ target, object, property, context, args, payload, meta }) => {
    //call your own hook
    console.log(
      `Instance of ${target.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}
and return value is "${payload}" took ${performance.now() - meta.startTime}.`
    );
  }
);

const hooks = Object.assign({}, classHookBefore, classHookAfter);

aop(
  A,
  hooks
); // bind hook to class
const a = new A('my hook');

a.method(); // log: 'Instance of A call "method" with arguments [] and return value is "my hook".', returns: 'my hook'
a.notHookedClassMethod(); // returns: 'not hook'

unAop(A);
a.method(); // returns: 'my hook'
a.notHookedClassMethod(); // returns: 'not hook'

import { aop, hookName, createHook, unAop } from 'to-aop';
import A from './a';

const instanceHook = createHook(
  hookName.afterMethod,
  /^(method)$/,
  ({ target, object, property, context, args, payload, meta }) => {
    console.log(
      `Instance of ${object.constructor.name} call "${property}"
with arguments ${args && args.length ? args : '[]'}
and return value is "${payload}".`
    );
  }
);

const a = new A('my hook');
const hookedInstance = aop(a, instanceHook); // bind hook to instance

hookedInstance.method(); // log: 'Instance of A call "method" with arguments [] and return value is "my hook.', returns: 'my hook'
hookedInstance.notHookedClassMethod(); // returns: 'not hook'

unAop(a);
a.method(); // returns: 'my hook'
a.notHookedClassMethod(); // returns: 'not hook'

import { hookName } from 'to-aop';

// hookName.(beforeMethod|afterMethod|...)