Asynchronous (asyn-await/promise) function queue.

Example

1import { Queue } from '@ex1st/tiny-queue';
2
3const queue = new Queue(async function (task) {
4  const r = await task;
5  return r;
6}, { timeout: 2000 });
7
8const result = [];
9
10// add task to the queue
11queue.push(new Promise(resolve => {
12  setTimeout(() => {
13    resolve(1);
14  }, 1000);
15}));
16
17// add task to the queue
18queue.push(new Promise(resolve => {
19  setTimeout(() => {
20    resolve(2);
21  }, 500);
22}));
23
24// add task to the queue
25queue.push(new Promise(resolve => {
26  setTimeout(() => {
27    resolve(3);
28  }, 100);
29}), new Promise(resolve => {
30  setTimeout(() => {
31    resolve(4);
32  }, 50);
33}));
34
35// add task to the queue
36queue.push(new Promise(resolve => {
37  setTimeout(() => {
38    resolve(5);
39  }, 2500);
40}));
41
42queue.on('done', function (res, task) {
43  result.push(res);
44});
45
46queue.on('timeout', function (task) {
47  console.log('task timed out:', task);
48});
49
50console.log(queue.running()); // true
51console.log(queue.length()); // 4
52
53queue.on('drain', function () {
54  console.log(result); // [1,2,3,4]
55});

Install

npm install @ex1st/tiny-queue

API

const queue = new Queue(worker, { timeout, filter })

• worker function
• timeout integer, is optional
• filter function, is optional

Instance methods

queue.push(...tasks)

add new task(s) to the queue.

queue.pause()

a function that pauses the processing of tasks.

queue.resume()

a function that resumes the processing of the queued tasks.

queue.kill()

a function that empties remaining tasks from the queue

queue.running()

a function returning execution state of the queue

queue.length()

a function returning the queue's size

queue.setFilter(fn)

a function set a custom filter

Events

queue.on('done', (result, task) => {})

When a task is done.

queue.on('error', (error, task) => {})

When a task throws an error.

queue.on('timeout', (task) => {})

When timeout params milliseconds have elapsed.

queue.on('drain', () => {})

When a last task from a queue has returned from a worker

queue.on('empty', () => {})

When a last task from a queue is given to a worker