In dequeue launching Promise.all on empty promises causes negative value on this.currentlyHandled
Because of that the bigger the number of requests the more requests is launched making this.options.concurrent irrelevant

I expect the queue to refill automatically as it becomes free.

const queue = new Queue({
    concurrent: 3,
    start: true,
    interval: 0
});
queue.on("resolve", n => {
    console.log(n);
});

[10, 10, 1, 1, 1, 1, 1, 1, 1].forEach(n => {
    queue.enqueue(async () => {
        await new Promise((resolve) => {
            setTimeout(resolve, n*1000);
        });
        return n;
    })
})

In this code, I want the fourth task to be executed after the completion of the third one. But in fact, the 4 task will be completed only after the completion of the first two.

return:

1
10, 10
1, 1, 1
1, 1, 1

I expect:

1
1 
1
1
1
1
1
10, 10

How can I achieve the automatic start of a task if space is freed up in the queue?

Is there a way to get the amount of remaining tasks in the queue?

i'm can run it in nodejs

but i cant, run it in breswer

index.js

var QueuePromise = require('queue-promise');
module.exports = QueuePromise;

weback config

const path = require('path');
module.exports = {
    entry: './src/index.js',
    output: {
        path: path.resolve(__dirname, '../dist'),
        publicPath: '/dist/',
        filename: 'queue-promise.js',
        library: 'QueuePromise',
        libraryTarget: 'umd',
        umdNamedDefine: true
    }
};

  <script src="./queue-promise.js"></script>
  <script>
 // var QueuePromise = require('queue-promise')
    var queue = new QueuePromise({
      concurrent: 1, // 并行个数
      interval: 50, // 调用间隔
    });

    queue.on("start", (data) => console.log(data));
    queue.on("stop", (data) => console.log(data));
    queue.on("end", (data) => console.log(data));

    queue.on("resolve", data => console.log(data));
    queue.on("reject", error => console.error(error));

    queue.enqueue(function () {
      return new Promise(res => {
        setTimeout(() => {
          res(11)
        }, 1000);
      })
    });
    queue.enqueue(function () {
      return new Promise(res => {
        setTimeout(() => {
          res(22)
        }, 1000);
      })

    });
    queue.enqueue(function () {
      return new Promise(res => {
        setTimeout(() => {
          res(33)
        }, 1000);
      })

    });
  </script>

Dependabot encountered the following error when parsing your .dependabot/config.yml:

Automerging is not enabled for this account. You can enable it from the [account settings](https://app.dependabot.com/accounts/Bartozzz/settings) screen in your Dependabot dashboard.

Please update the config file to conform with Dependabot's specification using our docs and online validator.

Right now this library does not work on ie 11 because missing babel plugin" form transform classes".
I can make Pr but I'm not sure if this is something you want to add.

Documentation shows this can be called to determine Whether the queue is running. However, I see no reference to this variable in the code, nor does it seem to work in the last build (2.2.1).

What am I missing?

I literally can't explain it.

export const queue = new Queue({
  concurrent: 20,
  interval: 0,
});

export async function queueTest() {
  const tests: Array<string> = ['1', ... '1000'];

  tests.forEach((testId) => { 
    queue.enqueue(async () => {
      console.log(`Test ${testId}`);
    })
  });
}

I call a function that adds to the queue which lives in a global scope (I think that's how you describe it) in a React app. It worked fine until users told me otherwise. I just can not get it to start. The queued tasks never execute!

I've reproduced my issue here: https://codesandbox.io/s/why-isnt-my-queue-working-4zqke?file=/src/App.js

For a simple port scanning script I queued executions of port scans expecting each of the scans to either resolve (port opened) or reject (port closed).

Another problem I found is that the queue was not really executing concurrently. After analyzing the reason for this I found the problem on the dequeue() method, which is broken in multiple ways:

return Promise.all(promises) .then(values => { for (let output of values) this.emit("resolve", output); return values;# }) .catch(error => { this.emit("reject", error); return error; }) .then(output => { this.finalize(); return output; });

Promise.all will reject when the first promise rejects! This has two bad effects:

1. This leads to finalize only being called once even if multiple promises should have been dequeued, leading the currentlyHandled counter to stay one below max, not allowing concurrent execution anymore but just continue with serial execution

2. No "reject", "resolve" events will be emitted for the executed tasks, that come after the resolve.

I will submit a pull request for a fix.

I'm trying to queue a bunch of files to upload and when the queue is finished I want to stop it, so I can do other stuff with the data.
On end:

queue.on("end", () => {
    if (queue.isEmpty) {
      console.log("Queue isEmpty", queue.isEmpty);
      queue.stop();
    }
  });

Result:

Starting queue...
 LOG  Queue isEmpty true
 LOG  Queue isEmpty true
 LOG  Queue isEmpty true
 LOG  success: 1 failed: 0

Last log is when the upload is concluded. Maybe I'm thinking this in a wrong way...