cbvirtua 1.0.23 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cbvirtua",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "",
   "main": "index.js",
   "scripts": {

package/queue.js

@@ -0,0 +1,124 @@
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise(
+        (res, rej) => {
+            // Executed synchronously!
+            resolve = res;
+            reject = rej;
+        });
+    return { promise, resolve, reject };
+}
+
+class PromiseQueue {
+    constructor() {
+        const { promise, resolve } = Promise.withResolvers();
+        this.frontPromise = promise;
+        this.backResolve = resolve;
+        this.i = 0
+    }
+    put() {
+        const { resolve, promise } = Promise.withResolvers();
+        // By resolving, we add another (pending) element
+        // to the end of the queue
+        this.i++
+        const value = this.i
+        this.backResolve({ value, promise });
+        this.backResolve = resolve;
+    }
+    get() {
+        return this.frontPromise.then(
+            (next) => {
+                this.frontPromise = next.promise;
+                return next.value;
+            }
+        );
+    }
+}
+
+
+let test
+async function aa() {
+    const queue = new PromiseQueue();
+    setTimeout(() => {
+        queue.put()
+    }, 1000)
+    let i = await queue.get()
+    console.log('i1', i)
+    test = queue
+    let i2 = await queue.get()
+    console.log('i2', i2)
+
+}
+
+aa()
+
+
+setTimeout(() => {
+    test.put()
+}, 3000)
+
+class AsyncIterQueue {
+    #frontPromise;
+    #backResolve;
+    constructor() {
+        const { promise, resolve } = Promise.withResolvers();
+        this.#frontPromise = promise;
+        this.#backResolve = resolve;
+    }
+    put(value) {
+        if (this.#backResolve === null) {
+            throw new Error('Queue is closed');
+        }
+        const { resolve, promise } = Promise.withResolvers();
+        this.#backResolve({ done: false, value, promise });
+        this.#backResolve = resolve;
+    }
+    close() {
+        this.#backResolve(
+            { done: true, value: undefined, promise: null }
+        );
+        this.#backResolve = null;
+    }
+    next() {
+        if (this.#frontPromise === null) {
+            return Promise.resolve({ done: true });
+        }
+        return this.#frontPromise.then(
+            (next) => {
+                this.#frontPromise = next.promise;
+                return { value: next.value, done: next.done };
+            }
+        );
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+}
+
+{ // Putting before async iteration
+    const queue = new AsyncIterQueue();
+    queue.put('one');
+    queue.put('two');
+    queue.close();
+    assert.deepEqual(
+        await Array.fromAsync(queue),
+        ['one', 'two']
+    );
+}
+{ // Async iteration before putting
+    const queue = new AsyncIterQueue();
+    setTimeout(
+        // Runs after `await` pauses the current execution context
+        () => {
+            queue.put('one');
+            queue.put('two');
+            queue.close();
+        },
+        0
+    );
+    assert.deepEqual(
+        await Array.fromAsync(queue),
+        ['one', 'two']
+    );
+}