modelfusion 0.132.0 → 0.134.0

package/util/AsyncQueue.d.ts

@@ -1,51 +0,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);
- *   }
- * })();
- */
-export declare class AsyncQueue<T> implements AsyncIterable<T> {
-    private values;
-    private pendingResolvers;
-    private closed;
-    private processPendingResolvers;
-    /**
-     * 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;
-    error(error: unknown): 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

@@ -1,117 +0,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);
- *   }
- * })();
- */
-export class AsyncQueue {
-    constructor() {
-        Object.defineProperty(this, "values", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Array()
-        });
-        Object.defineProperty(this, "pendingResolvers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-    }
-    processPendingResolvers() {
-        while (this.pendingResolvers.length > 0) {
-            this.pendingResolvers.shift()?.();
-        }
-    }
-    /**
-     * 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.");
-        }
-        this.values.push({ type: "value", value });
-        this.processPendingResolvers();
-    }
-    error(error) {
-        if (this.closed) {
-            throw new Error("Cannot push error to closed queue.");
-        }
-        this.values.push({ type: "error", error });
-        this.processPendingResolvers();
-    }
-    /**
-     * Closes the queue, preventing more elements from being pushed onto it.
-     *
-     * @example
-     * queue.close();
-     */
-    close() {
-        this.closed = true;
-        this.processPendingResolvers();
-    }
-    /**
-     * 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, reject) => {
-                const attemptResolve = () => {
-                    if (position < this.values.length) {
-                        const entry = this.values[position++];
-                        switch (entry.type) {
-                            case "value":
-                                resolve({ value: entry.value, done: false });
-                                break;
-                            case "error":
-                                reject(entry.error);
-                                break;
-                        }
-                    }
-                    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

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const delay_js_1 = require("./delay.cjs");
-const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-it("should 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;
-    expect(receivedValues).toEqual([1, 2, 3]);
-});
-it("should 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;
-    expect(receivedValues).toEqual([1, 2, 3]);
-});
-it("should 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);
-    }
-    expect(receivedValues).toEqual([1, 2]);
-});
-it("should error handling in consumer", async () => {
-    const asyncQueue = new AsyncQueue_js_1.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]);
-});
-it("should 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);
-    }
-    expect(receivedValues).toEqual([]);
-});
-it("should multiple closings", async () => {
-    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
-    asyncQueue.close();
-    expect(() => asyncQueue.close()).not.toThrow();
-});
-it("should 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) => {
-        expect(receivedValues).toEqual([1, 2, 3]);
-    });
-});
-it("should 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.
-    expect(receivedValues1).toEqual([1, 2, 3]);
-    expect(receivedValues2).toEqual([1, 2, 3]); // This will likely fail because consumer2 started late.
-});
-it("should throw error when pushing to a closed queue", async () => {
-    const asyncQueue = new AsyncQueue_js_1.AsyncQueue();
-    asyncQueue.close();
-    expect(() => asyncQueue.push(1)).toThrowError("Cannot push value to closed queue.");
-});

package/util/AsyncQueue.test.d.ts

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

package/util/AsyncQueue.test.js

@@ -1,135 +0,0 @@
-import { delay } from "./delay.js";
-import { AsyncQueue } from "./AsyncQueue.js";
-it("should 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]);
-});
-it("should 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]);
-});
-it("should 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]);
-});
-it("should 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]);
-});
-it("should 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([]);
-});
-it("should multiple closings", async () => {
-    const asyncQueue = new AsyncQueue();
-    asyncQueue.close();
-    expect(() => asyncQueue.close()).not.toThrow();
-});
-it("should 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]);
-    });
-});
-it("should 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.
-});
-it("should 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.");
-});

package/util/DurationMeasurement.cjs

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDurationMeasurement = void 0;
-function startDurationMeasurement() {
-    // certain environments may not have the performance API:
-    return globalThis.performance != null
-        ? new PerformanceNowDurationMeasurement()
-        : new DateDurationMeasurement();
-}
-exports.startDurationMeasurement = startDurationMeasurement;
-class PerformanceNowDurationMeasurement {
-    constructor() {
-        Object.defineProperty(this, "startTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: globalThis.performance.now()
-        });
-    }
-    get startEpochSeconds() {
-        return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
-    }
-    get startDate() {
-        return new Date(this.startEpochSeconds * 1000);
-    }
-    get durationInMs() {
-        return Math.ceil(globalThis.performance.now() - this.startTime);
-    }
-}
-class DateDurationMeasurement {
-    constructor() {
-        Object.defineProperty(this, "startTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Date.now()
-        });
-    }
-    get startEpochSeconds() {
-        return Math.floor(this.startTime / 1000);
-    }
-    get startDate() {
-        return new Date(this.startTime);
-    }
-    get durationInMs() {
-        return Date.now() - this.startTime;
-    }
-}

package/util/DurationMeasurement.d.ts

@@ -1,6 +0,0 @@
-export declare function startDurationMeasurement(): DurationMeasurement;
-export interface DurationMeasurement {
-    startEpochSeconds: number;
-    startDate: Date;
-    durationInMs: number;
-}

package/util/DurationMeasurement.js

@@ -1,44 +0,0 @@
-export function startDurationMeasurement() {
-    // certain environments may not have the performance API:
-    return globalThis.performance != null
-        ? new PerformanceNowDurationMeasurement()
-        : new DateDurationMeasurement();
-}
-class PerformanceNowDurationMeasurement {
-    constructor() {
-        Object.defineProperty(this, "startTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: globalThis.performance.now()
-        });
-    }
-    get startEpochSeconds() {
-        return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
-    }
-    get startDate() {
-        return new Date(this.startEpochSeconds * 1000);
-    }
-    get durationInMs() {
-        return Math.ceil(globalThis.performance.now() - this.startTime);
-    }
-}
-class DateDurationMeasurement {
-    constructor() {
-        Object.defineProperty(this, "startTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Date.now()
-        });
-    }
-    get startEpochSeconds() {
-        return Math.floor(this.startTime / 1000);
-    }
-    get startDate() {
-        return new Date(this.startTime);
-    }
-    get durationInMs() {
-        return Date.now() - this.startTime;
-    }
-}

package/util/ErrorHandler.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/util/ErrorHandler.d.ts

@@ -1 +0,0 @@
-export type ErrorHandler = (error: unknown) => void;

package/util/ErrorHandler.js

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

package/util/SafeResult.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/util/SafeResult.d.ts

@@ -1,8 +0,0 @@
-export type SafeResult<OUTPUT> = {
-    ok: true;
-    value: OUTPUT;
-} | {
-    ok: false;
-    isAborted?: boolean;
-    error?: unknown;
-};

package/util/SafeResult.js

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

package/util/SimpleWebSocket.cjs

@@ -1,48 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSimpleWebSocket = void 0;
-const Runtime = __importStar(require("./detectRuntime.cjs"));
-/**
- * Creates a simplified websocket connection. This function works in both Node.js and browser.
- */
-async function createSimpleWebSocket(url) {
-    switch (Runtime.detectRuntime()) {
-        case "vercel-edge":
-        case "cloudflare-workers":
-        case "browser": {
-            return new WebSocket(url);
-        }
-        case "node": {
-            // Use ws library (for Node.js):
-            const { default: WebSocket } = await Promise.resolve().then(() => __importStar(require("ws")));
-            return new WebSocket(url);
-        }
-        default: {
-            throw new Error("Unknown runtime");
-        }
-    }
-}
-exports.createSimpleWebSocket = createSimpleWebSocket;

package/util/SimpleWebSocket.d.ts

@@ -1,12 +0,0 @@
-export interface SimpleWebSocket {
-    send(data: string): void;
-    onmessage: ((event: MessageEvent) => void) | null;
-    onopen: ((event: Event) => void) | null;
-    onclose: ((event: CloseEvent) => void) | null;
-    onerror: ((event: Event) => void) | null;
-    close(code?: number, reason?: string): void;
-}
-/**
- * Creates a simplified websocket connection. This function works in both Node.js and browser.
- */
-export declare function createSimpleWebSocket(url: string): Promise<SimpleWebSocket>;

package/util/SimpleWebSocket.js

@@ -1,21 +0,0 @@
-import * as Runtime from "./detectRuntime.js";
-/**
- * Creates a simplified websocket connection. This function works in both Node.js and browser.
- */
-export async function createSimpleWebSocket(url) {
-    switch (Runtime.detectRuntime()) {
-        case "vercel-edge":
-        case "cloudflare-workers":
-        case "browser": {
-            return new WebSocket(url);
-        }
-        case "node": {
-            // Use ws library (for Node.js):
-            const { default: WebSocket } = await import("ws");
-            return new WebSocket(url);
-        }
-        default: {
-            throw new Error("Unknown runtime");
-        }
-    }
-}

package/util/audio/AudioMimeType.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/util/audio/AudioMimeType.d.ts

@@ -1 +0,0 @@
-export type AudioMimeType = "audio/webm" | "audio/mp3" | "audio/wav" | "audio/mp4" | "audio/mpeg" | "audio/mpga" | "audio/ogg" | "audio/oga" | "audio/flac" | "audio/m4a";

package/util/audio/AudioMimeType.js

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