'use strict';

class Pool {

constructor(options = {}) {

this.instances = [];

this.free = [];

this.queue = [];

this.timeout = options.timeout || 0;

this.current = 0;

this.size = 0;

this.available = 0;

}

async acquire() {

if (this.size === 0) return null;

if (this.available === 0) {

return new Promise((resolve, reject) => {

const waiting = { resolve, timer: null };

waiting.timer = setTimeout(() => {

waiting.resolve = null;

this.queue.shift();

reject(new Error('Pool next instance timeout'));

}, this.timeout);

this.queue.push(waiting);

});

}

let instance = null;

let free = false;

do {

instance = this.instances[this.current];

free = this.free[this.current];

this.current++;

if (this.current === this.size) this.current = 0;

} while (!instance || !free);

return instance;

}

add(instance) {

if (this.instances.includes(instance)) {

throw new Error('Pool: add duplicates');

}

this.size++;

this.available++;

this.instances.push(instance);

this.free.push(true);

}

async capture() {

const instance = await this.acquire();

if (!instance) return null;

const index = this.instances.indexOf(instance);

this.free[index] = false;

this.available--;

return instance;

}

release(instance) {

const index = this.instances.indexOf(instance);

if (index < 0) throw new Error('Pool: release unexpected instance');

if (this.free[index]) throw new Error('Pool: release not captured');

this.free[index] = true;

this.available++;

if (this.queue.length > 0) {

const { resolve, timer } = this.queue.shift();

clearTimeout(timer);

if (resolve) setTimeout(resolve, 0, instance);

}

}

}

// Usage

const main = async () => {

const pool = new Pool({ timeout: 5000 });

pool.add({ instance: 1 });

pool.add({ instance: 2 });

const last = { instance: 3 };

pool.add(last);

const x1 = await pool.capture();

console.log({ x1 });

const x2 = await pool.capture();

console.log({ x2 });

const x3 = await pool.capture();

console.log({ x3 });

pool.capture().then((x4) => {

console.log({ x4 });

});

pool.capture().then((x5) => {

console.log({ x5 });

});

pool

.capture()

.then((x6) => {

console.log({ x6 });

})

.catch((err) => {

console.error({ err });

});

pool.release(x2);

pool.release(x1);

setTimeout(() => {

pool.release(x3);

}, 6000);

};

main();