modelfusion 0.50.0 → 0.52.0

package/util/AsyncQueue.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingResolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value) {
+        if (this.closed) {
+            throw new Error("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+        }
+        this.values.push(value);
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close() {
+        this.closed = true;
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator]() {
+        let position = 0;
+        return {
+            next: () => new Promise((resolve) => {
+                const attemptResolve = () => {
+                    if (position < this.values.length) {
+                        // There's an available value, resolve it immediately.
+                        resolve({ value: this.values[position++], done: false });
+                    }
+                    else if (this.closed) {
+                        // The queue is closed, and there are no more values. Complete the iteration.
+                        resolve({ value: undefined, done: true }); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    }
+                    else {
+                        // No values are currently available, and the queue is not closed.
+                        // The consumer is now pending and will be resolved when a new value is pushed
+                        // or when the queue is closed.
+                        this.pendingResolvers.push(attemptResolve);
+                    }
+                };
+                attemptResolve();
+            }),
+        };
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/util/AsyncQueue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private values;
+    private pendingResolvers;
+    private closed;
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value: T): void;
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close(): void;
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/util/AsyncQueue.js

@@ -0,0 +1,102 @@
+/**
+ * `AsyncQueue` is a class that represents an asynchronous queue.
+ * It allows values to be pushed onto it and consumed (pulled) by an iterator.
+ * The queue is async-iterable, making it compatible with async/await syntax.
+ *
+ * @template T The type of elements contained in the queue.
+ * @example
+ * const queue = new AsyncQueue<number>();
+ * queue.push(1);
+ * (async () => {
+ *   for await (const value of queue) {
+ *     console.log(value);
+ *   }
+ * })();
+ */
+export class AsyncQueue {
+    constructor() {
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingResolvers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Pushes an element onto the queue. If the queue is closed, an error is thrown.
+     *
+     * @param {T} value - The element to add to the queue.
+     * @throws {Error} Throws an error if the queue is closed.
+     * @example
+     * queue.push(2);
+     */
+    push(value) {
+        if (this.closed) {
+            throw new Error("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+        }
+        this.values.push(value);
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Closes the queue, preventing more elements from being pushed onto it.
+     *
+     * @example
+     * queue.close();
+     */
+    close() {
+        this.closed = true;
+        while (this.pendingResolvers.length > 0) {
+            this.pendingResolvers.shift()?.();
+        }
+    }
+    /**
+     * Creates and returns an async iterator that allows the queue to be consumed.
+     * You can create multiple iterators for the same queue.
+     *
+     * @returns {AsyncIterator<T>} An async iterator for the queue.
+     * @example
+     * (async () => {
+     *   for await (const value of queue) {
+     *     console.log(value);
+     *   }
+     * })();
+     */
+    [Symbol.asyncIterator]() {
+        let position = 0;
+        return {
+            next: () => new Promise((resolve) => {
+                const attemptResolve = () => {
+                    if (position < this.values.length) {
+                        // There's an available value, resolve it immediately.
+                        resolve({ value: this.values[position++], done: false });
+                    }
+                    else if (this.closed) {
+                        // The queue is closed, and there are no more values. Complete the iteration.
+                        resolve({ value: undefined, done: true }); // eslint-disable-line @typescript-eslint/no-explicit-any
+                    }
+                    else {
+                        // No values are currently available, and the queue is not closed.
+                        // The consumer is now pending and will be resolved when a new value is pushed
+                        // or when the queue is closed.
+                        this.pendingResolvers.push(attemptResolve);
+                    }
+                };
+                attemptResolve();
+            }),
+        };
+    }
+}

package/util/AsyncQueue.test.cjs

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const delay_js_1 = require("./delay.cjs");
+const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
+(0, vitest_1.test)("receive values in order for single iterator created before pushing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    await receiveValuesPromise;
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+});
+(0, vitest_1.test)("receive values in order for single iterator created after closing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    await receiveValuesPromise;
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+});
+(0, vitest_1.test)("handle delayed pushing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    setTimeout(() => {
+        asyncQueue.push(1);
+        asyncQueue.push(2);
+        asyncQueue.close();
+    }, 5);
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+});
+(0, vitest_1.test)("error handling in consumer", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.push(1);
+    await (0, vitest_1.expect)((async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for await (const _value of asyncQueue) {
+            throw new Error("Consumer error");
+        }
+    })()).rejects.toThrow("Consumer error");
+    // Check the queue is still operational after an error in the consumer
+    asyncQueue.push(2);
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([1, 2]);
+});
+(0, vitest_1.test)("behavior on empty queue closing", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    (0, vitest_1.expect)(receivedValues).toEqual([]);
+});
+(0, vitest_1.test)("multiple closings", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    (0, vitest_1.expect)(() => asyncQueue.close()).not.toThrow();
+});
+(0, vitest_1.test)("receive all values in multiple independent consumers", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    const consumerPromises = [1, 2].map(async () => {
+        const receivedValues = [];
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+        return receivedValues;
+    });
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(1);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(2);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(3);
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.close();
+    const allReceivedValues = await Promise.all(consumerPromises);
+    allReceivedValues.forEach((receivedValues) => {
+        (0, vitest_1.expect)(receivedValues).toEqual([1, 2, 3]);
+    });
+});
+(0, vitest_1.test)("each consumer receives all pushed values under varying conditions", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    // Start the first consumer, which will await values.
+    const receivedValues1 = [];
+    const consumer1 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues1.push(value);
+        }
+    })();
+    // Simulate some operation delay, then push the first value.
+    await (0, delay_js_1.delay)(5); // Delay is necessary to simulate real-world async operations.
+    asyncQueue.push(1);
+    // Start the second consumer after the first value was pushed.
+    const receivedValues2 = [];
+    const consumer2 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues2.push(value);
+        }
+    })();
+    // Push the remaining values with some delays.
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    // Close the queue and wait for consumers to finish processing.
+    await (0, delay_js_1.delay)(5);
+    asyncQueue.close();
+    await Promise.all([consumer1, consumer2]);
+    // Both consumers should have received all values, even if they started at different times.
+    (0, vitest_1.expect)(receivedValues1).toEqual([1, 2, 3]);
+    (0, vitest_1.expect)(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+});
+(0, vitest_1.test)("throw error when pushing to a closed queue", async () => {
+    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
+    asyncQueue.close();
+    (0, vitest_1.expect)(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+});

package/util/AsyncQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/util/AsyncQueue.test.js

@@ -0,0 +1,136 @@
+import { expect, test } from "vitest";
+import { delay } from "./delay.js";
+import { AsyncQueue } from "./AsyncQueue.js";
+test("receive values in order for single iterator created before pushing", async () => {
+    const asyncQueue = new AsyncQueue();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    await receiveValuesPromise;
+    expect(receivedValues).toEqual([1, 2, 3]);
+});
+test("receive values in order for single iterator created after closing", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.push(1);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    asyncQueue.close();
+    const receivedValues = [];
+    const receiveValuesPromise = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+    })();
+    await receiveValuesPromise;
+    expect(receivedValues).toEqual([1, 2, 3]);
+});
+test("handle delayed pushing", async () => {
+    const asyncQueue = new AsyncQueue();
+    setTimeout(() => {
+        asyncQueue.push(1);
+        asyncQueue.push(2);
+        asyncQueue.close();
+    }, 5);
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([1, 2]);
+});
+test("error handling in consumer", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.push(1);
+    await expect((async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for await (const _value of asyncQueue) {
+            throw new Error("Consumer error");
+        }
+    })()).rejects.toThrow("Consumer error");
+    // Check the queue is still operational after an error in the consumer
+    asyncQueue.push(2);
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([1, 2]);
+});
+test("behavior on empty queue closing", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    const receivedValues = [];
+    for await (const value of asyncQueue) {
+        receivedValues.push(value);
+    }
+    expect(receivedValues).toEqual([]);
+});
+test("multiple closings", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    expect(() => asyncQueue.close()).not.toThrow();
+});
+test("receive all values in multiple independent consumers", async () => {
+    const asyncQueue = new AsyncQueue();
+    const consumerPromises = [1, 2].map(async () => {
+        const receivedValues = [];
+        for await (const value of asyncQueue) {
+            receivedValues.push(value);
+        }
+        return receivedValues;
+    });
+    await delay(5);
+    asyncQueue.push(1);
+    await delay(5);
+    asyncQueue.push(2);
+    await delay(5);
+    asyncQueue.push(3);
+    await delay(5);
+    asyncQueue.close();
+    const allReceivedValues = await Promise.all(consumerPromises);
+    allReceivedValues.forEach((receivedValues) => {
+        expect(receivedValues).toEqual([1, 2, 3]);
+    });
+});
+test("each consumer receives all pushed values under varying conditions", async () => {
+    const asyncQueue = new AsyncQueue();
+    // Start the first consumer, which will await values.
+    const receivedValues1 = [];
+    const consumer1 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues1.push(value);
+        }
+    })();
+    // Simulate some operation delay, then push the first value.
+    await delay(5); // Delay is necessary to simulate real-world async operations.
+    asyncQueue.push(1);
+    // Start the second consumer after the first value was pushed.
+    const receivedValues2 = [];
+    const consumer2 = (async () => {
+        for await (const value of asyncQueue) {
+            receivedValues2.push(value);
+        }
+    })();
+    // Push the remaining values with some delays.
+    await delay(5);
+    asyncQueue.push(2);
+    asyncQueue.push(3);
+    // Close the queue and wait for consumers to finish processing.
+    await delay(5);
+    asyncQueue.close();
+    await Promise.all([consumer1, consumer2]);
+    // Both consumers should have received all values, even if they started at different times.
+    expect(receivedValues1).toEqual([1, 2, 3]);
+    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
+});
+test("throw error when pushing to a closed queue", async () => {
+    const asyncQueue = new AsyncQueue();
+    asyncQueue.close();
+    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue. The queue has been closed and is no longer accepting new items.");
+});

package/util/delay.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.delay = delay;

package/util/delay.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/util/delay.js

@@ -0,0 +1,3 @@
+export async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/util/index.cjs

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AsyncQueue.cjs"), exports);
 __exportStar(require("./JSONParseError.cjs"), exports);
 __exportStar(require("./cosineSimilarity.cjs"), exports);
 __exportStar(require("./getAudioFileExtension.cjs"), exports);

package/util/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./AsyncQueue.js";
 export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";

package/util/index.js

@@ -1,3 +1,4 @@
+export * from "./AsyncQueue.js";
 export * from "./JSONParseError.js";
 export * from "./cosineSimilarity.js";
 export * from "./getAudioFileExtension.js";

package/event-source/AsyncQueue.cjs

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncQueue = void 0;
-class AsyncQueue {
-    constructor() {
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "resolvers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    push(value) {
-        if (this.closed) {
-            throw new Error("Pushing to a closed queue");
-        }
-        const resolve = this.resolvers.shift();
-        if (resolve) {
-            resolve({ value, done: false });
-        }
-        else {
-            this.queue.push(value);
-        }
-    }
-    close() {
-        while (this.resolvers.length) {
-            const resolve = this.resolvers.shift();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            resolve?.({ value: undefined, done: true });
-        }
-        this.closed = true;
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    return Promise.resolve({
-                        value: this.queue.shift(),
-                        done: false,
-                    });
-                }
-                else if (this.closed) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                else {
-                    return new Promise((resolve) => {
-                        this.resolvers.push(resolve);
-                    });
-                }
-            },
-        };
-    }
-}
-exports.AsyncQueue = AsyncQueue;

package/event-source/AsyncQueue.d.ts

@@ -1,8 +0,0 @@
-export declare class AsyncQueue<T> implements AsyncIterable<T> {
-    private queue;
-    private resolvers;
-    private closed;
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}