Callback to AsyncIterator in Typescript/Javascript

CallbackToAsyncIterator.ts

/*
* Usage:
* const message: IncomingMessage = ...
* const iterator = new AsyncIteratorHandler<string>();
* message.on("data", chunk => {
*   iterator.handle({value: chunk.toString(), done: false});
* });
* this.message.on("end", () => {
*   iterator.handle({value: null as any, done: true})
* });
* this.message.on("error", error => {
*   iterator.handle(error)
* });
* return iterator;  
*/

type StateHandler = [Function, Function];
type IteratorState<T> = StateHandler | IteratorResult<T> | Error;

function isStateHandler<T>(state: IteratorState<T>): state is StateHandler {
    return Array.isArray(state);
}

function consume<T>(state: IteratorResult<T> | Error, [resolve, reject]:[Function, Function]){
    if (state instanceof Error) reject(state);
    else resolve(state);
}

class AsyncIteratorHandler<T> implements AsyncIterator<T> {
    private state: IteratorState<T>[] = [];

    handle(newState: IteratorState<T>) {
        const nextState = this.state.pop();
        if(typeof nextState == 'undefined') return this.state.push(newState);
        if(isStateHandler(newState) && !isStateHandler(nextState)) return consume(nextState, newState);
        if(!isStateHandler(newState) && isStateHandler(nextState)) return consume(newState, nextState);
        this.state.unshift(nextState);
        this.state.push(newState);
    }

    next(value?: any): Promise<IteratorResult<T>> {
        return new Promise<IteratorResult<T>>((resolve, reject) => {
            this.handle([resolve, reject]);
        });
    }
}