@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/queue/batch_queue.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A queue that groups items into batches based on a group key.
+ *
+ * The batching algorithm is greedy, meaning that as long as consecutive items have the same group key then they will
+ * be batched together. As soon as an item with a different group key is encountered, the old batch is flushed to the
+ * queue and a new batch is started.
+ *
+ * A batch can also be flushed to the queue if:
+ * - it reaches the selected batch size limit
+ * - or the batch duration limit is hit (in milliseconds)
+ *
+ * This ensures that batches don't grow too big and that they are flushed at a minimum rate of 1 batch every interval.
+ *
+ * The consumer side of this queue will process batches as quickly as possible.
+ */
+export declare class BatchQueue<T, K extends string | number> {
+    private processBatch;
+    private maxBatchSize;
+    private maxBatchDuration;
+    private log;
+    private container;
+    private currentBatch?;
+    private runningPromise?;
+    constructor(processBatch: (items: Array<T>, key: K) => void | Promise<void>, maxBatchSize: number, maxBatchDuration: number, log?: import("../log/pino-logger.js").Logger);
+    /**
+     * Put an item in the queue. It will be routed based on the given key
+     * @param item - The item to add
+     * @param key - The group key for this item
+     * @returns A promise that resolves or rejects when the batch this item is part of is processed
+     */
+    put(item: T, key: K): Promise<void>;
+    /**
+     * Immediately flushes the current batch, starting a new one
+     */
+    flushCurrentBatch: () => void;
+    /**
+     * Starts the queue.
+     */
+    start(): void;
+    /**
+     * Stops the queue. Any items in the queue will continue to be processed but new items won't be accepted anymore
+     * @returns A promise that resolves when the queue is drained completely
+     */
+    stop(): Promise<void>;
+    private execProcessor;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hfcXVldWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9iYXRjaF9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHFCQUFhLFVBQVUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxTQUFTLE1BQU0sR0FBRyxNQUFNO0lBTWhELE9BQU8sQ0FBQyxZQUFZO0lBQ3BCLE9BQU8sQ0FBQyxZQUFZO0lBQ3BCLE9BQU8sQ0FBQyxnQkFBZ0I7SUFDeEIsT0FBTyxDQUFDLEdBQUc7SUFSYixPQUFPLENBQUMsU0FBUyxDQUFzQztJQUN2RCxPQUFPLENBQUMsWUFBWSxDQUFDLENBQWM7SUFDbkMsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFnQjtJQUV2QyxZQUNVLFlBQVksRUFBRSxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsS0FBSyxJQUFJLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUMvRCxZQUFZLEVBQUUsTUFBTSxFQUNwQixnQkFBZ0IsRUFBRSxNQUFNLEVBQ3hCLEdBQUcseUNBQXlDLEVBQ2xEO0lBRUo7Ozs7O09BS0c7SUFDSSxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0EwQnpDO0lBRUQ7O09BRUc7SUFDSSxpQkFBaUIsYUFPdEI7SUFFRjs7T0FFRztJQUNJLEtBQUssU0FNWDtJQUVEOzs7T0FHRztJQUNJLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBVzNCO0lBRUQsT0FBTyxDQUFDLGFBQWEsQ0FPbkI7Q0FDSCJ9

package/dest/queue/batch_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch_queue.d.ts","sourceRoot":"","sources":["../../src/queue/batch_queue.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM;IAMhD,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,GAAG;IARb,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,cAAc,CAAC,CAAgB;IAEvC,YACU,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/D,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,GAAG,yCAAyC,EAClD;IAEJ;;;;;OAKG;IACI,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BzC;IAED;;OAEG;IACI,iBAAiB,aAOtB;IAEF;;OAEG;IACI,KAAK,SAMX;IAED;;;OAGG;IACI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAW3B;IAED,OAAO,CAAC,aAAa,CAOnB;CACH"}

package/dest/queue/batch_queue.js

@@ -0,0 +1,106 @@
+import { createLogger } from '../log/pino-logger.js';
+import { promiseWithResolvers } from '../promise/utils.js';
+import { FifoMemoryQueue } from './fifo_memory_queue.js';
+/**
+ * A queue that groups items into batches based on a group key.
+ *
+ * The batching algorithm is greedy, meaning that as long as consecutive items have the same group key then they will
+ * be batched together. As soon as an item with a different group key is encountered, the old batch is flushed to the
+ * queue and a new batch is started.
+ *
+ * A batch can also be flushed to the queue if:
+ * - it reaches the selected batch size limit
+ * - or the batch duration limit is hit (in milliseconds)
+ *
+ * This ensures that batches don't grow too big and that they are flushed at a minimum rate of 1 batch every interval.
+ *
+ * The consumer side of this queue will process batches as quickly as possible.
+ */ export class BatchQueue {
+    processBatch;
+    maxBatchSize;
+    maxBatchDuration;
+    log;
+    container;
+    currentBatch;
+    runningPromise;
+    constructor(processBatch, maxBatchSize, maxBatchDuration, log = createLogger('foundation:batch_queue')){
+        this.processBatch = processBatch;
+        this.maxBatchSize = maxBatchSize;
+        this.maxBatchDuration = maxBatchDuration;
+        this.log = log;
+        this.container = new FifoMemoryQueue();
+        this.flushCurrentBatch = ()=>{
+            if (this.currentBatch) {
+                this.log.trace('Flushing batch', {
+                    size: this.currentBatch.items.length,
+                    key: this.currentBatch.key
+                });
+                clearTimeout(this.currentBatch.enqueueTimeout);
+                this.container.put(this.currentBatch);
+                this.currentBatch = undefined;
+            }
+        };
+        this.execProcessor = async (batch)=>{
+            try {
+                await this.processBatch(batch.items, batch.key);
+                batch.deferred.resolve();
+            } catch (err) {
+                batch.deferred.reject(err);
+            }
+        };
+    }
+    /**
+   * Put an item in the queue. It will be routed based on the given key
+   * @param item - The item to add
+   * @param key - The group key for this item
+   * @returns A promise that resolves or rejects when the batch this item is part of is processed
+   */ put(item, key) {
+        if (!this.runningPromise) {
+            return Promise.reject(new Error('BatchQueue is not started'));
+        }
+        let currentBatch = this.currentBatch;
+        if (!currentBatch || currentBatch.key !== key || currentBatch.items.length >= this.maxBatchSize) {
+            this.flushCurrentBatch();
+            this.log.trace('Creating new batch', {
+                key
+            });
+            currentBatch = {
+                items: [],
+                key,
+                deferred: promiseWithResolvers(),
+                enqueueTimeout: setTimeout(this.flushCurrentBatch, this.maxBatchDuration)
+            };
+            this.currentBatch = currentBatch;
+        }
+        currentBatch.items.push(item);
+        if (currentBatch.items.length >= this.maxBatchSize) {
+            this.flushCurrentBatch();
+        }
+        return currentBatch.deferred.promise;
+    }
+    /**
+   * Immediately flushes the current batch, starting a new one
+   */ flushCurrentBatch;
+    /**
+   * Starts the queue.
+   */ start() {
+        if (this.runningPromise) {
+            return;
+        }
+        this.runningPromise = this.container.process(this.execProcessor);
+    }
+    /**
+   * Stops the queue. Any items in the queue will continue to be processed but new items won't be accepted anymore
+   * @returns A promise that resolves when the queue is drained completely
+   */ stop() {
+        const runningPromise = this.runningPromise;
+        this.runningPromise = undefined;
+        if (!runningPromise) {
+            return Promise.resolve();
+        }
+        this.flushCurrentBatch();
+        this.container.end();
+        return runningPromise;
+    }
+    execProcessor;
+}

package/dest/queue/bounded_serial_queue.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Leverages the unbounded SerialQueue and Semaphore to create a SerialQueue that will block when putting an item
+ * if the queue size = maxQueueSize.
+ */
+export declare class BoundedSerialQueue {
+    private log;
+    private readonly queue;
+    private semaphore;
+    constructor(maxQueueSize: number, log?: import("../log/pino-logger.js").Logger);
+    /**
+     * Initializes the underlying SerialQueue instance, allowing items to be processed from the queue.
+     * The start method should be called before using the BoundedSerialQueue to ensure proper functionality.
+     */
+    start(): void;
+    /**
+     * Returns the current number of items in the queue.
+     * This is useful for monitoring the size of BoundedSerialQueue and understanding its utilization.
+     *
+     * @returns The length of the queue as an integer value.
+     */
+    length(): number;
+    /**
+     * Cancels the current operation in the SerialQueue, if any, and clears the queue.
+     * Any pending tasks in the queue will not be executed, and the queue will be emptied.
+     * This method is useful for cleaning up resources and stopping ongoing processes when they are no longer needed.
+     * @returns A promise, resolved once cancelled.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Ends the queue processing gracefully, preventing new items from being added.
+     * The currently executing item, if any, will complete and remaining queued items
+     * will be processed in order. Once all items have been processed, the queue becomes
+     * permanently unusable.
+     *
+     * @returns A promise that resolves when all items in the queue have been processed.
+     */
+    end(): Promise<void>;
+    /**
+     * The caller will block until fn is successfully enqueued.
+     * The fn itself is execute asynchronously and its result discarded.
+     * TODO(AD) do we need this if we have exec()?
+     * @param fn - The function to call once unblocked.
+     */
+    put(fn: () => Promise<void>): Promise<void>;
+    /**
+     * The caller will block until fn is successfully executed, and it's result returned.
+     * @param fn - The function.
+     * @returns A promise that resolves with the result once executed.
+     */
+    exec<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Awaiting this ensures the queue is empty before resuming.
+     */
+    syncPoint(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm91bmRlZF9zZXJpYWxfcXVldWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9ib3VuZGVkX3NlcmlhbF9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7O0dBR0c7QUFDSCxxQkFBYSxrQkFBa0I7SUFNM0IsT0FBTyxDQUFDLEdBQUc7SUFMYixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBcUI7SUFDM0MsT0FBTyxDQUFDLFNBQVMsQ0FBWTtJQUU3QixZQUNFLFlBQVksRUFBRSxNQUFNLEVBQ1osR0FBRyx5Q0FBa0QsRUFHOUQ7SUFFRDs7O09BR0c7SUFDSSxLQUFLLFNBRVg7SUFFRDs7Ozs7T0FLRztJQUNJLE1BQU0sV0FFWjtJQUVEOzs7OztPQUtHO0lBQ0ksTUFBTSxrQkFFWjtJQUVEOzs7Ozs7O09BT0c7SUFDSSxHQUFHLGtCQUVUO0lBRUQ7Ozs7O09BS0c7SUFDVSxHQUFHLENBQUMsRUFBRSxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FhdkQ7SUFFRDs7OztPQUlHO0lBQ1UsSUFBSSxDQUFDLENBQUMsRUFBRSxFQUFFLEVBQUUsTUFBTSxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQVNyRDtJQUVEOztPQUVHO0lBQ1UsU0FBUyxrQkFFckI7Q0FDRiJ9

package/dest/queue/bounded_serial_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded_serial_queue.d.ts","sourceRoot":"","sources":["../../src/queue/bounded_serial_queue.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qBAAa,kBAAkB;IAM3B,OAAO,CAAC,GAAG;IALb,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,SAAS,CAAY;IAE7B,YACE,YAAY,EAAE,MAAM,EACZ,GAAG,yCAAkD,EAG9D;IAED;;;OAGG;IACI,KAAK,SAEX;IAED;;;;;OAKG;IACI,MAAM,WAEZ;IAED;;;;;OAKG;IACI,MAAM,kBAEZ;IAED;;;;;;;OAOG;IACI,GAAG,kBAET;IAED;;;;;OAKG;IACU,GAAG,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAavD;IAED;;;;OAIG;IACU,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CASrD;IAED;;OAEG;IACU,SAAS,kBAErB;CACF"}

package/dest/queue/bounded_serial_queue.js

@@ -0,0 +1,84 @@
+import { createLogger } from '../log/index.js';
+import { Semaphore } from './semaphore.js';
+import { SerialQueue } from './serial_queue.js';
+/**
+ * Leverages the unbounded SerialQueue and Semaphore to create a SerialQueue that will block when putting an item
+ * if the queue size = maxQueueSize.
+ */ export class BoundedSerialQueue {
+    log;
+    queue;
+    semaphore;
+    constructor(maxQueueSize, log = createLogger('foundation:bounded_serial_queue')){
+        this.log = log;
+        this.queue = new SerialQueue();
+        this.semaphore = new Semaphore(maxQueueSize);
+    }
+    /**
+   * Initializes the underlying SerialQueue instance, allowing items to be processed from the queue.
+   * The start method should be called before using the BoundedSerialQueue to ensure proper functionality.
+   */ start() {
+        this.queue.start();
+    }
+    /**
+   * Returns the current number of items in the queue.
+   * This is useful for monitoring the size of BoundedSerialQueue and understanding its utilization.
+   *
+   * @returns The length of the queue as an integer value.
+   */ length() {
+        return this.queue.length();
+    }
+    /**
+   * Cancels the current operation in the SerialQueue, if any, and clears the queue.
+   * Any pending tasks in the queue will not be executed, and the queue will be emptied.
+   * This method is useful for cleaning up resources and stopping ongoing processes when they are no longer needed.
+   * @returns A promise, resolved once cancelled.
+   */ cancel() {
+        return this.queue.cancel();
+    }
+    /**
+   * Ends the queue processing gracefully, preventing new items from being added.
+   * The currently executing item, if any, will complete and remaining queued items
+   * will be processed in order. Once all items have been processed, the queue becomes
+   * permanently unusable.
+   *
+   * @returns A promise that resolves when all items in the queue have been processed.
+   */ end() {
+        return this.queue.end();
+    }
+    /**
+   * The caller will block until fn is successfully enqueued.
+   * The fn itself is execute asynchronously and its result discarded.
+   * TODO(AD) do we need this if we have exec()?
+   * @param fn - The function to call once unblocked.
+   */ async put(fn) {
+        await this.semaphore.acquire();
+        this.queue.put(async ()=>{
+            try {
+                await fn();
+            } finally{
+                this.semaphore.release();
+            }
+        }).catch((err)=>{
+            this.log.error('BoundedSerialQueue handler exception:', err);
+        });
+    }
+    /**
+   * The caller will block until fn is successfully executed, and it's result returned.
+   * @param fn - The function.
+   * @returns A promise that resolves with the result once executed.
+   */ async exec(fn) {
+        await this.semaphore.acquire();
+        return this.queue.put(async ()=>{
+            try {
+                return await fn();
+            } finally{
+                this.semaphore.release();
+            }
+        });
+    }
+    /**
+   * Awaiting this ensures the queue is empty before resuming.
+   */ async syncPoint() {
+        await this.queue.syncPoint();
+    }
+}

package/dest/queue/fifo_memory_queue.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '../log/index.js';
+import { BaseMemoryQueue } from './base_memory_queue.js';
+/**
+ * A simple fifo queue. It can grow unbounded. It can have multiple producers and consumers.
+ * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
+ * the item being pushed is simply discarded.
+ */
+export declare class FifoMemoryQueue<T> extends BaseMemoryQueue<T> {
+    private container;
+    constructor(log?: Logger);
+    protected get items(): FifoQueue<T>;
+}
+declare class FifoQueue<T> {
+    private items;
+    put(item: T): void;
+    get(): T | undefined;
+    get length(): number;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlmb19tZW1vcnlfcXVldWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9maWZvX21lbW9yeV9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQ7Ozs7R0FJRztBQUNILHFCQUFhLGVBQWUsQ0FBQyxDQUFDLENBQUUsU0FBUSxlQUFlLENBQUMsQ0FBQyxDQUFDO0lBQ3hELE9BQU8sQ0FBQyxTQUFTLENBQXNCO0lBRXZDLFlBQVksR0FBRyxDQUFDLEVBQUUsTUFBTSxFQUV2QjtJQUVELGNBQXVCLEtBQUssaUJBRTNCO0NBQ0Y7QUFFRCxjQUFNLFNBQVMsQ0FBQyxDQUFDO0lBQ2YsT0FBTyxDQUFDLEtBQUssQ0FBVztJQUVqQixHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsR0FBRyxJQUFJLENBRXhCO0lBRU0sR0FBRyxJQUFJLENBQUMsR0FBRyxTQUFTLENBRTFCO0lBRUQsSUFBVyxNQUFNLElBQUksTUFBTSxDQUUxQjtJQUVNLEtBQUssU0FFWDtDQUNGIn0=

package/dest/queue/fifo_memory_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fifo_memory_queue.d.ts","sourceRoot":"","sources":["../../src/queue/fifo_memory_queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;;;GAIG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IACxD,OAAO,CAAC,SAAS,CAAsB;IAEvC,YAAY,GAAG,CAAC,EAAE,MAAM,EAEvB;IAED,cAAuB,KAAK,iBAE3B;CACF;AAED,cAAM,SAAS,CAAC,CAAC;IACf,OAAO,CAAC,KAAK,CAAW;IAEjB,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAExB;IAEM,GAAG,IAAI,CAAC,GAAG,SAAS,CAE1B;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAEM,KAAK,SAEX;CACF"}

package/dest/queue/fifo_memory_queue.js

@@ -0,0 +1,29 @@
+import { BaseMemoryQueue } from './base_memory_queue.js';
+/**
+ * A simple fifo queue. It can grow unbounded. It can have multiple producers and consumers.
+ * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
+ * the item being pushed is simply discarded.
+ */ export class FifoMemoryQueue extends BaseMemoryQueue {
+    container = new FifoQueue();
+    constructor(log){
+        super(log);
+    }
+    get items() {
+        return this.container;
+    }
+}
+class FifoQueue {
+    items = [];
+    put(item) {
+        this.items.push(item);
+    }
+    get() {
+        return this.items.shift();
+    }
+    get length() {
+        return this.items.length;
+    }
+    clear() {
+        this.items = [];
+    }
+}

package/dest/queue/index.d.ts

@@ -0,0 +1,7 @@
+export * from './fifo_memory_queue.js';
+export * from './priority_memory_queue.js';
+export * from './serial_queue.js';
+export * from './bounded_serial_queue.js';
+export * from './semaphore.js';
+export * from './batch_queue.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxrQkFBa0IsQ0FBQyJ9

package/dest/queue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/queue/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dest/queue/index.js

@@ -0,0 +1,6 @@
+export * from './fifo_memory_queue.js';
+export * from './priority_memory_queue.js';
+export * from './serial_queue.js';
+export * from './bounded_serial_queue.js';
+export * from './semaphore.js';
+export * from './batch_queue.js';

package/dest/queue/priority_memory_queue.d.ts

@@ -0,0 +1,13 @@
+import { BaseMemoryQueue } from './base_memory_queue.js';
+import { PriorityQueue } from './priority_queue.js';
+/**
+ * A priority queue. It can grow unbounded. It can have multiple producers and consumers.
+ * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
+ * the item being pushed is simply discarded.
+ */
+export declare class PriorityMemoryQueue<T> extends BaseMemoryQueue<T> {
+    private container;
+    constructor(comparator: (a: T, b: T) => number);
+    protected get items(): PriorityQueue<T>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHlfbWVtb3J5X3F1ZXVlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvcHJpb3JpdHlfbWVtb3J5X3F1ZXVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN6RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFcEQ7Ozs7R0FJRztBQUNILHFCQUFhLG1CQUFtQixDQUFDLENBQUMsQ0FBRSxTQUFRLGVBQWUsQ0FBQyxDQUFDLENBQUM7SUFDNUQsT0FBTyxDQUFDLFNBQVMsQ0FBbUI7SUFFcEMsWUFBWSxVQUFVLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEtBQUssTUFBTSxFQUc3QztJQUVELGNBQXVCLEtBQUsscUJBRTNCO0NBQ0YifQ==

package/dest/queue/priority_memory_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority_memory_queue.d.ts","sourceRoot":"","sources":["../../src/queue/priority_memory_queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,SAAS,CAAmB;IAEpC,YAAY,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAG7C;IAED,cAAuB,KAAK,qBAE3B;CACF"}

package/dest/queue/priority_memory_queue.js

@@ -0,0 +1,16 @@
+import { BaseMemoryQueue } from './base_memory_queue.js';
+import { PriorityQueue } from './priority_queue.js';
+/**
+ * A priority queue. It can grow unbounded. It can have multiple producers and consumers.
+ * Putting an item onto the queue always succeeds, unless either end() or cancel() has been called in which case
+ * the item being pushed is simply discarded.
+ */ export class PriorityMemoryQueue extends BaseMemoryQueue {
+    container;
+    constructor(comparator){
+        super();
+        this.container = new PriorityQueue(comparator);
+    }
+    get items() {
+        return this.container;
+    }
+}

package/dest/queue/priority_queue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Priority queue implementation based on a custom comparator.
+ */
+export declare class PriorityQueue<T> {
+    private comparator;
+    private items;
+    constructor(comparator: (a: T, b: T) => number);
+    put(item: T): void;
+    get(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    get length(): number;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdHlfcXVldWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWV1ZS9wcmlvcml0eV9xdWV1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILHFCQUFhLGFBQWEsQ0FBQyxDQUFDO0lBR2QsT0FBTyxDQUFDLFVBQVU7SUFGOUIsT0FBTyxDQUFDLEtBQUssQ0FBTTtJQUVuQixZQUFvQixVQUFVLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEtBQUssTUFBTSxFQUVyRDtJQUVNLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FNeEI7SUFFTSxHQUFHLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FFMUI7SUFFTSxJQUFJLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FFM0I7SUFFTSxLQUFLLFNBRVg7SUFFRCxJQUFXLE1BQU0sSUFBSSxNQUFNLENBRTFCO0NBQ0YifQ==

package/dest/queue/priority_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority_queue.d.ts","sourceRoot":"","sources":["../../src/queue/priority_queue.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,aAAa,CAAC,CAAC;IAGd,OAAO,CAAC,UAAU;IAF9B,OAAO,CAAC,KAAK,CAAM;IAEnB,YAAoB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,EAErD;IAEM,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAMxB;IAEM,GAAG,IAAI,CAAC,GAAG,SAAS,CAE1B;IAEM,IAAI,IAAI,CAAC,GAAG,SAAS,CAE3B;IAEM,KAAK,SAEX;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;CACF"}

package/dest/queue/priority_queue.js

@@ -0,0 +1,29 @@
+/**
+ * Priority queue implementation based on a custom comparator.
+ */ export class PriorityQueue {
+    comparator;
+    items;
+    constructor(comparator){
+        this.comparator = comparator;
+        this.items = [];
+    }
+    put(item) {
+        let i = 0;
+        while(i < this.items.length && this.comparator(item, this.items[i]) >= 0){
+            i++;
+        }
+        this.items.splice(i, 0, item);
+    }
+    get() {
+        return this.items.shift();
+    }
+    peek() {
+        return this.items[0];
+    }
+    clear() {
+        this.items = [];
+    }
+    get length() {
+        return this.items.length;
+    }
+}

package/dest/queue/semaphore.d.ts

@@ -0,0 +1,27 @@
+export interface ISemaphore {
+    acquire(): Promise<void>;
+    release(): void;
+}
+/**
+ * Allows the acquiring of up to `size` tokens before calls to acquire block, waiting for a call to release().
+ */
+export declare class Semaphore {
+    private readonly queue;
+    constructor(size: number);
+    /**
+     * Acquires a token from the Semaphore, allowing access to a limited resource.
+     * If no tokens are available, the call will block and wait until a token is released.
+     * Use in conjunction with the release() method to manage access to resources with limited capacity.
+     *
+     * @returns A Promise that resolves when a token is acquired.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Releases a token back into the semaphore, allowing another acquire call to proceed.
+     * If there are any pending calls to acquire(), one of them will be unblocked and allowed to proceed.
+     * This method should only be called by the holder of the acquired token to ensure proper functionality
+     * and avoid unexpected behavior.
+     */
+    release(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VtYXBob3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvc2VtYXBob3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sV0FBVyxVQUFVO0lBQ3pCLE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDekIsT0FBTyxJQUFJLElBQUksQ0FBQztDQUNqQjtBQUVEOztHQUVHO0FBQ0gscUJBQWEsU0FBUztJQUNwQixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBa0M7SUFFeEQsWUFBWSxJQUFJLEVBQUUsTUFBTSxFQUV2QjtJQUVEOzs7Ozs7T0FNRztJQUNVLE9BQU8sa0JBRW5CO0lBRUQ7Ozs7O09BS0c7SUFDSSxPQUFPLFNBRWI7Q0FDRiJ9

package/dest/queue/semaphore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semaphore.d.ts","sourceRoot":"","sources":["../../src/queue/semaphore.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IAExD,YAAY,IAAI,EAAE,MAAM,EAEvB;IAED;;;;;;OAMG;IACU,OAAO,kBAEnB;IAED;;;;;OAKG;IACI,OAAO,SAEb;CACF"}

package/dest/queue/semaphore.js

@@ -0,0 +1,26 @@
+import { FifoMemoryQueue } from './fifo_memory_queue.js';
+/**
+ * Allows the acquiring of up to `size` tokens before calls to acquire block, waiting for a call to release().
+ */ export class Semaphore {
+    queue = new FifoMemoryQueue();
+    constructor(size){
+        new Array(size).fill(true).map(()=>this.queue.put(true));
+    }
+    /**
+   * Acquires a token from the Semaphore, allowing access to a limited resource.
+   * If no tokens are available, the call will block and wait until a token is released.
+   * Use in conjunction with the release() method to manage access to resources with limited capacity.
+   *
+   * @returns A Promise that resolves when a token is acquired.
+   */ async acquire() {
+        await this.queue.get();
+    }
+    /**
+   * Releases a token back into the semaphore, allowing another acquire call to proceed.
+   * If there are any pending calls to acquire(), one of them will be unblocked and allowed to proceed.
+   * This method should only be called by the holder of the acquired token to ensure proper functionality
+   * and avoid unexpected behavior.
+   */ release() {
+        this.queue.put(true);
+    }
+}

package/dest/queue/serial_queue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A more specialized fifo queue that enqueues functions to execute. Enqueued functions are executed in serial.
+ */
+export declare class SerialQueue {
+    private readonly queue;
+    private runningPromises;
+    private started;
+    /**
+     * Initializes the execution of enqueued functions in the serial queue.
+     * Functions are executed in the order they were added to the queue, with each function
+     * waiting for the completion of the previous one before starting its execution.
+     * This method should be called once to start processing the queue.
+     */
+    start(numWorkers?: number): void;
+    /**
+     * Returns the current number of enqueued functions in the serial queue.
+     * This provides a way to check the size of the queue and monitor its progress.
+     *
+     * @returns The length of the serial queue as a number.
+     */
+    length(): number;
+    /**
+     * Cancels the processing of the remaining functions in the serial queue and resolves the running promise.
+     * Any enqueued functions that have not yet been executed will be discarded. The queue can still accept new
+     * functions after cancellation, but the previously enqueued functions will not be re-processed.
+     *
+     * @returns The running promise which resolves when the current executing function (if any) completes.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Signals the SerialQueue that it should finish processing its current task and stop accepting new tasks.
+     * The returned Promise resolves when all enqueued tasks have completed execution.
+     *
+     * @returns A Promise that resolves when the queue is completely emptied and no new tasks are allowed.
+     */
+    end(): Promise<void>;
+    /**
+     * Enqueues fn for execution on the serial queue.
+     * Returns the result of the function after execution.
+     * @param fn - The function to enqueue.
+     * @returns A resolution promise. Rejects if the function does, or if the function could not be enqueued.
+     */
+    put<T>(fn: () => T | Promise<T>): Promise<Awaited<T>>;
+    /**
+     * Awaiting this ensures the queue is empty before resuming.
+     */
+    syncPoint(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsX3F1ZXVlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVldWUvc2VyaWFsX3F1ZXVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gscUJBQWEsV0FBVztJQUN0QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBOEM7SUFDcEUsT0FBTyxDQUFDLGVBQWUsQ0FBdUI7SUFDOUMsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUV4Qjs7Ozs7T0FLRztJQUNJLEtBQUssQ0FBQyxVQUFVLFNBQUksUUFNMUI7SUFFRDs7Ozs7T0FLRztJQUNJLE1BQU0sV0FFWjtJQUVEOzs7Ozs7T0FNRztJQUNJLE1BQU0sa0JBR1o7SUFFRDs7Ozs7T0FLRztJQUNJLEdBQUcsa0JBR1Q7SUFFRDs7Ozs7T0FLRztJQUNJLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLE1BQU0sQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBYzNEO0lBRUQ7O09BRUc7SUFDVSxTQUFTLGtCQUVyQjtDQUNGIn0=

package/dest/queue/serial_queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial_queue.d.ts","sourceRoot":"","sources":["../../src/queue/serial_queue.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8C;IACpE,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,OAAO,CAAS;IAExB;;;;;OAKG;IACI,KAAK,CAAC,UAAU,SAAI,QAM1B;IAED;;;;;OAKG;IACI,MAAM,WAEZ;IAED;;;;;;OAMG;IACI,MAAM,kBAGZ;IAED;;;;;OAKG;IACI,GAAG,kBAGT;IAED;;;;;OAKG;IACI,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAc3D;IAED;;OAEG;IACU,SAAS,kBAErB;CACF"}