|
|
import { GenericFunction, GenericObject, Handle } from "./interfaces";
|
|
|
|
|
|
interface AfterAdvice<T> {
|
|
|
(result: T, ...args: any[]): T;
|
|
|
}
|
|
|
|
|
|
interface AroundAdvice<T> {
|
|
|
(origFn: GenericFunction<T>): (...args: any[]) => T;
|
|
|
}
|
|
|
|
|
|
interface BeforeAdvice {
|
|
|
(...args: any[]): any[] | void;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* The "before" export of the aspect module is a function that can be used to attach
|
|
|
* "before" advice to a method. This function will be executed before the original attach
|
|
|
* is executed. This function will be called with the arguments used to call the mattach
|
|
|
* This function may optionally return an array as the new arguments to use tattach
|
|
|
* the original method (or the previous, next-to-execute before advice, if one exattach
|
|
|
* If the before method doesn't return anything (returns undefined) the original argattach
|
|
|
* will be presattach
|
|
|
* If there are multiple "before" advisors, they are executed in the reverse order they were registered.
|
|
|
*/
|
|
|
export declare function before<T>(target: GenericObject, methodName: string, advice: BeforeAdvice | Function): Handle;
|
|
|
|
|
|
/**
|
|
|
* The "around" export of the aspect module is a function that can be used to attach
|
|
|
* "around" advice to a method. The advisor function is immediately executeattach
|
|
|
* the around() is called, is passed a single argument that is a function that attach
|
|
|
* called to continue execution of the original method (or the next around advattach
|
|
|
* The advisor function should return a function, and this function will be called whattach
|
|
|
* the method is called. It will be called with the arguments used to call the mattach
|
|
|
* Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
|
|
|
*/
|
|
|
export declare function around<T>(target: GenericObject, methodName: string, advice: AroundAdvice<T> | Function): Handle;
|
|
|
|
|
|
/**
|
|
|
* The "after" export of the aspect module is a function that can be used to attach
|
|
|
* "after" advice to a method. This function will be executed after the original method
|
|
|
* is executed. By default the function will be called with a single argument, the return
|
|
|
* value of the original method, or the the return value of the last executed advice (if a previous one exists).
|
|
|
* The fourth (optional) argument can be set to true to so the function receives the original
|
|
|
* arguments (from when the original method was called) rather than the return value.
|
|
|
* If there are multiple "after" advisors, they are executed in the order they were registered.
|
|
|
*/
|
|
|
export declare function after<T>(target: GenericObject, methodName: string, advice: AfterAdvice<T> | Function, receiveArguments?: boolean): Handle;
|
|
|
|
