Async queue for processing data

~96% code coverage ✨

Zero dependencies ✨

Installation and Usage

ES2018 via npm

1npm install async-queued

1import { CreateAsyncQueue } from 'async-queued'
2
3const queue = new CreateAsyncQueue((value: string) => value, ['1', '2', '3'])
4await queue.run()

or if you want to transform every item after queue iteration:

1import { CreateAsyncQueue } from 'async-queued'
2
3const queue = new CreateAsyncQueue((value: string) => {
4  ...you can do anything with passed value (value from entry array)
5  return value
6}, ['1', '2', '3'])
7await queue.run((item) => {
8  ...do all with iteration item
9})

Documentation

You can see sample usage in Installation and Usage heading, but this library do more. So the simple example with extended function here:

1const queue = new CreateAsyncQueue((value: string) => value, ['1', '2', '3'])
2await queue.run()
3
4queue.push(['3', '2', '1'])
5
6queue.run()
7...
8
9...
10
11queue.stop()
12...
13
14...
15await queue.resume()
16
17queue.getResultedData()

If you want to pass function with multiple arguments, you can:

1const queue = new CreateAsyncQueue(
2  (first: string, second: number) => first + second,
3  [
4    ['1', 1],
5    ['2', 2],
6  ],
7)
8await queue.run()

If you want to control, log or transform every queue item after awaiting, you can pass function to run:

1const queue = new CreateAsyncQueue((value: string) => value, ['1', '2', '3'])
2await queue.run((item) => {
3  ...do with item everything
4})

it will be invoked on every iteration.

Also, if you invoke run function second time and don't want to invoke previous function passed, you can suppress this:

1const queue = new CreateAsyncQueue((value: string) => value, ['1', '2', '3'])
2await queue.run((item) => {
3  ...
4})
5
6...
7
8await queue.run(null, false)

just pass the second argument as false to suppress invocation

API

Stop

Stop function that stopping all future Promises, but not current.

1/**
2 * @returns CreateAsyncQueue instance
3 */
4queue.stop()

Resume

Resume function that resume current queue.

1/**
2 * @returns CreateAsyncQueue instance
3 */
4queue.resume()

Push

Push function that push values to current queue.

1/**
2 * @entry Array of { values }
3 * @returns CreateAsyncQueue instance
4 */
5queue.push([1, 2, 3])

resetAll

resetAll function that reset queue and set queue data.

1/**
2 * @entry Array of { values }
3 * @returns CreateAsyncQueue instance
4 */
5queue.resetAll([1, 2, 3])

getResultedData

getResultedData function that returns data after the passed iteration, which could be changed.

1/**
2 * @returns Array of { values }
3 */
4queue.getResultedData()

getQueueData

getQueueData function that returns data to current queue, that need to be processed.

1/**
2 * @returns Array of { values }
3 */
4queue.getQueueData()

getProcessedData

getProcessedData function that returns data that already processed, but not resulted.

1/**
2 * @returns Array of { values }
3 */
4queue.getProcessedData()

Couple words about Typescript

If we providing types, it could be easy to queue:

1const iterationFn = (value: string) => value
2/**
3 * value: string -> we have only 1 way how to pass entry value array it is a Array<string>
4 */
5const queue = new CreateAsyncQueue(iterationFn, ['1', '2', '3'])
6await queue.run()

1const iterationFn = (value: boolean) => value
2/**
3 * value: boolean -> we have only 1 way how to pass entry value array it is a Array<boolean>
4 */
5const queue = new CreateAsyncQueue(iterationFn, [true, false])
6await queue.run()

1const iterationFn = (value: boolean, secondValue: number) => value
2/**
3 * value: [boolean, number] -> we have only 1 way how to pass entry value array it is a Array<[boolean,number]>
4 */
5const queue = new CreateAsyncQueue(iterationFn, [
6  [true, 1],
7  [false, 2],
8])
9await queue.run()

it also works with partial arguments

1const iterationFn = (value: boolean, secondValue?: number) => value
2/**
3 * value: [boolean, number] -> we have only 1 way how to pass entry value array
4 * it is a Array<[boolean,number]> or Array<[boolean]>
5 */
6const queue = new CreateAsyncQueue(iterationFn, [[true, 1], [false]])
7await queue.run()

Goals

• Smaller overall bundles sizes
• Provide better performance than solutions with Promise.all or smth like that
• Remove Promise all for awaiting iterable data

Building/Testing

• yarn compile build everything
• yarn serve run locally
• yarn tests run tests