magic-queue.ts

import { assertDefined } from './utils'

type AsyncFunc<T> = () => Promise<T>

export class MagicQueue<T> {

    private isActive = false
    private isKilled = false

    private queue: AsyncFunc<T>[] = []

    constructor(private options: {
        onSuccess: (item: T) => void
        onError: (error: unknown) => void
        onStart: () => void
        onEnd: () => void
    }) { }

    push(fn: AsyncFunc<T>) {
        this.isKilled = false

        this.queue.push(fn)
        this.run()
    }

    kill() {
        this.isActive = false
        this.isKilled = true
    }

    private run() {
        if (this.isActive || this.isKilled || this.queue.length <= 0) {
            return
        }

        this.isActive = true
        this.options.onStart()

        const fn = this.queue.pop()
        assertDefined(fn)

        fn().then((result) => this.handleThen(result))
            .catch((error) => this.options.onError(error))
    }

    private handleThen(result: T) {
        if (this.isKilled) {
            return
        }

        this.options.onSuccess(result)

        if (this.queue.length <= 0) {
            this.isActive = false
            this.options.onEnd()
            return
        }

        const nextFn = this.queue.pop()
        assertDefined(nextFn)

        nextFn()
            .then((result) => this.handleThen(result))
            .catch((error) => this.options.onError(error))
    }

}