async-ray/dist/chainable.d.ts

Allow perform every, filter, find, findIndex, forEach, map, reduce, reduceRight and some on array using Async callback

import * as methods from './methods';
/**
 * Chainable function handler
 *
 * @export
 * @class Chainable
 * @template T
 */
export declare class Chainable<T> {
    input: T[];
    /**
     * Call Stack
     *
     * @private
     * @type {SingleCall[]}
     * @memberof Chainable
     */
    private callQueue;
    /**
     * Creates an instance of Chainable.
     * @param {T[]} input
     * @memberof Chainable
     */
    constructor(input: T[]);
    /**
     * aEvery method of Async-Ray lib
     *
     * @param {methods.CallBackEvery<T>} cb
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aEvery(cb: methods.CallBackEvery<T>): Promise<any>;
    /**
     * aFilter method of Async-Ray lib
     *
     * @param {methods.CallBackFilter<T>} cb
     * @returns {Chainable<T>}
     * @memberof Chainable
     */
    aFilter(cb: methods.CallBackFilter<T>): Chainable<T>;
    /**
     * aFindIndex method of Async-Ray lib
     *
     * @param {methods.CallBackFindIndex<T>} cb
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aFindIndex(cb: methods.CallBackFindIndex<T>): Promise<any>;
    /**
     * aFind method of Async-Ray lib
     *
     * @param {methods.CallBackFind<T>} cb
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aFind(cb: methods.CallBackFind<T>): Promise<any>;
    /**
     * aForEach method of Async-Ray lib
     *
     * @param {methods.CallBackForEach<T>} cb
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aForEach(cb: methods.CallBackForEach<T>): Promise<any>;
    /**
     * aMap method of Async-Ray lib
     *
     * @template R
     * @param {methods.CallBackMap<T, R>} cb
     * @returns {Chainable<T>}
     * @memberof Chainable
     */
    aMap<R>(cb: methods.CallBackMap<T, R>): Chainable<T>;
    /**
     * aReduceRight method of Async-Ray lib
     *
     * @template R
     * @param {methods.CallBackReduceRight<T, R>} cb
     * @param {R} [initialValue]
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aReduceRight<R>(cb: methods.CallBackReduceRight<T, R>, initialValue?: R): Promise<any>;
    /**
     * aReduce method of Async-Ray lib
     *
     * @template R
     * @param {methods.CallBackReduce<T, R>} cb
     * @param {R} [initialValue]
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aReduce<R>(cb: methods.CallBackReduce<T, R>, initialValue?: R): Promise<any>;
    /**
     * aSome method of Async-Ray lib
     *
     * @template R
     * @param {methods.CallBackSome<T>} cb
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    aSome<R>(cb: methods.CallBackSome<T>): Promise<any>;
    /**
     * aFlatMap method of Async-Ray lib
     *
     * @template R
     * @param {CallBackFlatMap<T, R>} cb
     * @returns {Chainable<T>}
     * @memberof Chainable
     */
    aFlatMap<R>(cb: methods.CallBackFlatMap<T, R>): Chainable<T>;
    /**
     * Process the call stack
     *
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    process(): Promise<any>;
    /**
     * Add chainable method to the call queue
     *
     * @private
     * @param {Function} method
     * @param {CallBacks} callBack
     * @param {*} [additional]
     * @returns {Chainable<T>}
     * @memberof Chainable
     */
    private addChainableMethod;
    /**
     * Add none chainable method to the queue and execute the chaining process
     *
     * @private
     * @param {Function} method
     * @param {CallBacks} callBack
     * @param {*} [additional]
     * @returns {Promise<any>}
     * @memberof Chainable
     */
    private addNoneChainableMethod;
    /**
     * Add element to the call queue
     *
     * @private
     * @param {Function} method
     * @param {CallBacks} callBack
     * @memberof Chainable
     */
    private add;
    /**
     * clear the call queue
     *
     * @private
     * @memberof Chainable
     */
    private clear;
}