@shutterstock/p-map-iterable 1.1.1 → 1.2.0-prerelease.1

package/dist/src/iterable-queue-mapper-simple.d.ts

@@ -6,22 +6,25 @@ type Errors<T> = {
     } | Error;
 }[];
 /**
- * Options for IterableQueueMapperSimple
+ * Options for `IterableQueueMapperSimple`, also exported as `WorkerQueueOptions`.
  */
 export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'concurrency'>;
 /**
  * Accepts queue items via `enqueue` and calls the `mapper` on them
  * with specified `concurrency`, discards the results, and accumulates
- * exceptions in the `errors` property.  When empty, `await enqueue()`
- * will return immediately, but when `concurrency` items are in progress,
- * `await enqueue()` will block until a slot is available to accept the item.
+ * exceptions in the `errors` property. Await `enqueue()` for producer
+ * backpressure while the worker callback runs asynchronously.
+ *
+ * Also exported as `WorkerQueue`, with the same constructor and instance types.
+ * Each input uses the same worker callback supplied at construction. Asynchronous
+ * work overlaps in the current JavaScript process, and results are consumed internally.
  *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are not needed in a subsequent step (if they are, use `IterableQueueMapper`)
+ * ### Typical Use Cases
+ * - Running background status checks or other queued work through a fixed callback
+ * - Sending items to an async I/O destination
+ * - Processing items whose return values can be discarded (if results are needed, use `IterableQueueMapper` / `MappingQueue`)
  *
  * ### Error Handling
  *   The mapper should ideally handle all errors internally to enable error handling
@@ -31,7 +34,7 @@ export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'conc
  *   - Errors can be checked/handled during processing via the `errors` property
  *
  *   Key Differences from `IterableQueueMapper`:
- *   - `maxUnread` defaults to equal `concurrency` (simplifying queue management)
+ *   - The internal `maxUnread` limit equals `concurrency`; only `concurrency` is configurable
  *   - Results are automatically iterated and discarded (all work should happen in mapper)
  *   - Errors are collected rather than thrown (available via errors property)
  *
@@ -39,7 +42,11 @@ export type IterableQueueMapperSimpleOptions = Pick<IterableMapperOptions, 'conc
  * - Items are added to the queue via the `await enqueue()` method
  * - Check `errors` property to see if any errors occurred, stop if desired
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - After the last awaited enqueue, await `onIdle()` to close input permanently and finish accepted work
+ * - Subsequent enqueues reject, so `onIdle()` is a final shutdown operation
+ * - Worker failures are collected in `errors`; they do not reject `onIdle()`
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
+ * - Admission limits for event callbacks, cancellation, and per-item completion handles belong to the caller
  *
  * Note: the name is somewhat of a misnomer as this wraps `IterableQueueMapper`
  * but is not itself an `Iterable`.
@@ -70,7 +77,7 @@ export declare class IterableQueueMapperSimple<Element> {
     private discardResults;
     private worker;
     /**
-     * Accumulated errors from background `mappers`s
+     * Accumulated errors from the worker callback.
      *
      * @remarks
      *
@@ -83,24 +90,24 @@ export declare class IterableQueueMapperSimple<Element> {
      */
     get errors(): Errors<Element>;
     /**
-     * Accept a request for sending in the background if a concurrency slot is available.
-     * Else, do not return until a concurrency slot is freed up.
-     * This provides concurrency background writes with backpressure to prevent
-     * the caller from getting too far ahead.
+     * Accept an input for the worker callback, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of this item's work.
+     * Await each enqueue for producer backpressure.
      *
-     * MUST await `onIdle` for background `mappers`s to finish
-     * @param item
+     * After the last enqueue, await `onIdle()` to close input and finish accepted work.
+     * @param item Input for the worker callback
      */
     enqueue(item: Element): Promise<void>;
     /**
-     * Wait for all background `mapper`s to finish.
-     * MUST be called before exit to ensure no lost writes.
+     * Permanently close input and wait for all accepted work to finish.
+     * Call after the last awaited enqueue. Subsequent enqueues reject.
+     * Worker failures are available in `errors` instead of rejecting this wait.
      */
     onIdle(): Promise<void>;
     /**
-     * Indicates if all background `mapper`s have finished.
+     * Indicates whether final shutdown has completed.
      *
-     * @returns true if .onIdle() has been called and finished all background writes
+     * @returns true after `onIdle()` has finished all accepted work and closed input
      */
     get isIdle(): boolean;
 }

package/dist/src/iterable-queue-mapper-simple.js

@@ -6,16 +6,19 @@ const NoResult = Symbol('noresult');
 /**
  * Accepts queue items via `enqueue` and calls the `mapper` on them
  * with specified `concurrency`, discards the results, and accumulates
- * exceptions in the `errors` property.  When empty, `await enqueue()`
- * will return immediately, but when `concurrency` items are in progress,
- * `await enqueue()` will block until a slot is available to accept the item.
+ * exceptions in the `errors` property. Await `enqueue()` for producer
+ * backpressure while the worker callback runs asynchronously.
+ *
+ * Also exported as `WorkerQueue`, with the same constructor and instance types.
+ * Each input uses the same worker callback supplied at construction. Asynchronous
+ * work overlaps in the current JavaScript process, and results are consumed internally.
  *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are not needed in a subsequent step (if they are, use `IterableQueueMapper`)
+ * ### Typical Use Cases
+ * - Running background status checks or other queued work through a fixed callback
+ * - Sending items to an async I/O destination
+ * - Processing items whose return values can be discarded (if results are needed, use `IterableQueueMapper` / `MappingQueue`)
  *
  * ### Error Handling
  *   The mapper should ideally handle all errors internally to enable error handling
@@ -25,7 +28,7 @@ const NoResult = Symbol('noresult');
  *   - Errors can be checked/handled during processing via the `errors` property
  *
  *   Key Differences from `IterableQueueMapper`:
- *   - `maxUnread` defaults to equal `concurrency` (simplifying queue management)
+ *   - The internal `maxUnread` limit equals `concurrency`; only `concurrency` is configurable
  *   - Results are automatically iterated and discarded (all work should happen in mapper)
  *   - Errors are collected rather than thrown (available via errors property)
  *
@@ -33,7 +36,11 @@ const NoResult = Symbol('noresult');
  * - Items are added to the queue via the `await enqueue()` method
  * - Check `errors` property to see if any errors occurred, stop if desired
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - After the last awaited enqueue, await `onIdle()` to close input permanently and finish accepted work
+ * - Subsequent enqueues reject, so `onIdle()` is a final shutdown operation
+ * - Worker failures are collected in `errors`; they do not reject `onIdle()`
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
+ * - Admission limits for event callbacks, cancellation, and per-item completion handles belong to the caller
  *
  * Note: the name is somewhat of a misnomer as this wraps `IterableQueueMapper`
  * but is not itself an `Iterable`.
@@ -66,7 +73,6 @@ class IterableQueueMapperSimple {
         this._done = this.discardResults();
     }
     async discardResults() {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         let item = await this._writer.next();
         while (item.done !== true) {
             // Just discard all the results
@@ -85,7 +91,7 @@ class IterableQueueMapperSimple {
         return NoResult;
     }
     /**
-     * Accumulated errors from background `mappers`s
+     * Accumulated errors from the worker callback.
      *
      * @remarks
      *
@@ -100,34 +106,34 @@ class IterableQueueMapperSimple {
         return this._errors;
     }
     /**
-     * Accept a request for sending in the background if a concurrency slot is available.
-     * Else, do not return until a concurrency slot is freed up.
-     * This provides concurrency background writes with backpressure to prevent
-     * the caller from getting too far ahead.
+     * Accept an input for the worker callback, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of this item's work.
+     * Await each enqueue for producer backpressure.
      *
-     * MUST await `onIdle` for background `mappers`s to finish
-     * @param item
+     * After the last enqueue, await `onIdle()` to close input and finish accepted work.
+     * @param item Input for the worker callback
      */
     async enqueue(item) {
-        // Return immediately or wait for a slot to free up in the background writer
+        // Return immediately or wait for the underlying mapping queue to accept the input
         await this._writer.enqueue(item);
     }
     /**
-     * Wait for all background `mapper`s to finish.
-     * MUST be called before exit to ensure no lost writes.
+     * Permanently close input and wait for all accepted work to finish.
+     * Call after the last awaited enqueue. Subsequent enqueues reject.
+     * Worker failures are available in `errors` instead of rejecting this wait.
      */
     async onIdle() {
         if (this._isIdle)
             return;
-        // Indicate that we're done writing requests
+        // Indicate that no more inputs will be enqueued
         this._writer.done();
         await this._done;
         this._isIdle = true;
     }
     /**
-     * Indicates if all background `mapper`s have finished.
+     * Indicates whether final shutdown has completed.
      *
-     * @returns true if .onIdle() has been called and finished all background writes
+     * @returns true after `onIdle()` has finished all accepted work and closed input
      */
     get isIdle() {
         return this._isIdle;

package/dist/src/iterable-queue-mapper-simple.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue-mapper-simple.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper-simple.ts"],"names":[],"mappings":";;;AACA,mEAA8D;AAK9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAOpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAa,yBAAyB;IAOpC;;;;;;;;;;OAUG;IACH,YAAY,MAA6B,EAAE,UAA4C,EAAE;QAhBxE,YAAO,GAAoB,EAAE,CAAC;QAGvC,YAAO,GAAG,KAAK,CAAC;QActB,MAAM,EAAE,WAAW,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;QAEpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,IAAI,2CAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC;QAE7F,6BAA6B;QAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,6DAA6D;QAC7D,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YACzB,+BAA+B;YAC/B,oEAAoE;YACpE,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;SAClC;IACH,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,KAAa;QAC/C,IAAI;YACF,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAChC,8DAA8D;SAC/D;QAAC,OAAO,KAAU,EAAE;YACnB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;SACpC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,4EAA4E;QAC5E,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,MAAM;QACjB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAEzB,4CAA4C;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAEpB,MAAM,IAAI,CAAC,KAAK,CAAC;QAEjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AAtGD,8DAsGC"}
+{"version":3,"file":"iterable-queue-mapper-simple.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper-simple.ts"],"names":[],"mappings":";;;AACA,mEAA8D;AAK9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAOpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAa,yBAAyB;IAOpC;;;;;;;;;;OAUG;IACH,YAAY,MAA6B,EAAE,UAA4C,EAAE;QAhBxE,YAAO,GAAoB,EAAE,CAAC;QAGvC,YAAO,GAAG,KAAK,CAAC;QActB,MAAM,EAAE,WAAW,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC;QAEpC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,IAAI,2CAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC;QAE7F,6BAA6B;QAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC1B,+BAA+B;YAC/B,oEAAoE;YACpE,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,KAAa;QAC/C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAChC,8DAA8D;QAChE,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,kFAAkF;QAClF,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,MAAM;QACjB,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QAEzB,gDAAgD;QAChD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAEpB,MAAM,IAAI,CAAC,KAAK,CAAC;QAEjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AArGD,8DAqGC"}

package/dist/src/iterable-queue-mapper.d.ts

@@ -1,6 +1,6 @@
 import { IterableMapperOptions, Mapper } from './iterable-mapper';
 /**
- * Options for IterableQueueMapper
+ * Options for `IterableQueueMapper`, also exported as `MappingQueueOptions`.
  */
 export type IterableQueueMapperOptions = IterableMapperOptions;
 /**
@@ -9,12 +9,16 @@ export type IterableQueueMapperOptions = IterableMapperOptions;
  * of `maxUnread` size, before being iterated / read by the caller.
  * The `enqueue` method will block if the queue is full, until an item is read.
  *
+ * Also exported as `MappingQueue`, with the same constructor and instance types.
+ * Each input uses the same callback supplied at construction; results are exposed
+ * through the async iterator as mapping completes.
+ *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are needed in a subsequent step (if they are not, use `IterableQueueMapperSimple`)
+ * ### Typical Use Cases
+ * - Enqueuing capability probes or metadata lookups as inputs become available
+ * - Sending items to an async I/O destination and consuming its acknowledgements
+ * - Consuming mapped results in a subsequent step (if results can be discarded, use `IterableQueueMapperSimple` / `WorkerQueue`)
  * - Prevents the producer from racing ahead of the consumer if `maxUnread` is reached
  *
  * ### Error Handling
@@ -33,8 +37,10 @@ export type IterableQueueMapperOptions = IterableMapperOptions;
  * ### Usage
  * - Items are added to the queue via the `await enqueue()` method
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - Call `done()` when no more items will be enqueued
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - Produce inputs and consume results concurrently so the result buffer can drain
+ * - Call `done()` after the last awaited enqueue, then finish consuming the iterator
+ * - `enqueue()` confirms acceptance of an input; `done()` closes input without waiting for work to finish
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
  *
  * @category Enqueue Input
  *
@@ -62,7 +68,9 @@ export declare class IterableQueueMapper<Element, NewElement> implements AsyncIt
      */
     next(): Promise<IteratorResult<NewElement>>;
     /**
-     * Add an item to the queue, wait if the queue is full.
+     * Add an item to the queue, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of the mapper for this item.
+     * Await each enqueue while consuming results concurrently for producer backpressure.
      *
      * @param item Element to add
      */
@@ -70,7 +78,8 @@ export declare class IterableQueueMapper<Element, NewElement> implements AsyncIt
     /**
      * Indicate that no more items will be enqueued.
      *
-     * This releases all readers blocked on `enqueue`
+     * Call after the last awaited enqueue. Finish consuming the async iterator
+     * to wait for mapped results; this method does not wait for processing to finish.
      */
     done(): void;
 }

package/dist/src/iterable-queue-mapper.js

@@ -12,12 +12,16 @@ const iterable_queue_1 = require("./iterable-queue");
  * of `maxUnread` size, before being iterated / read by the caller.
  * The `enqueue` method will block if the queue is full, until an item is read.
  *
+ * Also exported as `MappingQueue`, with the same constructor and instance types.
+ * Each input uses the same callback supplied at construction; results are exposed
+ * through the async iterator as mapping completes.
+ *
  * @remarks
  *
- * ### Typical Use Case
- * - Pushing items to an async I/O destination
- * - In the simple sequential (`concurrency: 1`) case, allows 1 item to be flushed async while caller prepares next item
- * - Results of the flushed items are needed in a subsequent step (if they are not, use `IterableQueueMapperSimple`)
+ * ### Typical Use Cases
+ * - Enqueuing capability probes or metadata lookups as inputs become available
+ * - Sending items to an async I/O destination and consuming its acknowledgements
+ * - Consuming mapped results in a subsequent step (if results can be discarded, use `IterableQueueMapperSimple` / `WorkerQueue`)
  * - Prevents the producer from racing ahead of the consumer if `maxUnread` is reached
  *
  * ### Error Handling
@@ -36,8 +40,10 @@ const iterable_queue_1 = require("./iterable-queue");
  * ### Usage
  * - Items are added to the queue via the `await enqueue()` method
  * - IMPORTANT: `await enqueue()` method will block until a slot is available, if queue is full
- * - Call `done()` when no more items will be enqueued
- * - IMPORTANT: Always `await onIdle()` to ensure all items are processed
+ * - Produce inputs and consume results concurrently so the result buffer can drain
+ * - Call `done()` after the last awaited enqueue, then finish consuming the iterator
+ * - `enqueue()` confirms acceptance of an input; `done()` closes input without waiting for work to finish
+ * - Await each enqueue for producer backpressure; unawaited calls can accumulate pending inputs
  *
  * @category Enqueue Input
  *
@@ -72,7 +78,9 @@ class IterableQueueMapper {
         return this._iterableMapper.next();
     }
     /**
-     * Add an item to the queue, wait if the queue is full.
+     * Add an item to the queue, waiting until it can be accepted.
+     * Resolves on acceptance, rather than completion of the mapper for this item.
+     * Await each enqueue while consuming results concurrently for producer backpressure.
      *
      * @param item Element to add
      */
@@ -82,7 +90,8 @@ class IterableQueueMapper {
     /**
      * Indicate that no more items will be enqueued.
      *
-     * This releases all readers blocked on `enqueue`
+     * Call after the last awaited enqueue. Finish consuming the async iterator
+     * to wait for mapped results; this method does not wait for processing to finish.
      */
     done() {
         this._sourceIterable.done();

package/dist/src/iterable-queue-mapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue-mapper.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper.ts"],"names":[],"mappings":";;;AAAA,EAAE;AACF,sGAAsG;AACtG,EAAE;AACF,uDAAkF;AAClF,qDAAiD;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAa,mBAAmB;IAK9B;;;;;;;;;OASG;IACH,YAAY,MAAmC,EAAE,UAAsC,EAAE;QACvF,IAAI,CAAC,eAAe,GAAG,IAAI,8BAAa,CAAC;YACvC,SAAS,EAAE,CAAC;SACb,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACnF,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACI,IAAI;QACT,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC9B,CAAC;CACF;AApDD,kDAoDC"}
+{"version":3,"file":"iterable-queue-mapper.js","sourceRoot":"","sources":["../../src/iterable-queue-mapper.ts"],"names":[],"mappings":";;;AAAA,EAAE;AACF,sGAAsG;AACtG,EAAE;AACF,uDAAkF;AAClF,qDAAiD;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,mBAAmB;IAK9B;;;;;;;;;OASG;IACH,YAAY,MAAmC,EAAE,UAAsC,EAAE;QACvF,IAAI,CAAC,eAAe,GAAG,IAAI,8BAAa,CAAC;YACvC,SAAS,EAAE,CAAC;SACb,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,GAAG,IAAI,gCAAc,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACnF,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,OAAO,CAAC,IAAa;QAChC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACI,IAAI;QACT,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC9B,CAAC;CACF;AAvDD,kDAuDC"}

package/dist/src/iterable-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"iterable-queue.js","sourceRoot":"","sources":["../../src/iterable-queue.ts"],"names":[],"mappings":";;;AAAA,qDAAuE;AAIvE;;;;GAIG;AACH,MAAa,aACX,SAAQ,8BAAsB;IAG9B;;;OAGG;IACH,YAAY,UAAgC,EAAE;QAC5C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI;QACf,6BAA6B;QAC7B,MAAM,IAAI,GAAwB,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QAEvD,IAAI,IAAI,KAAK,SAAS,EAAE;YACtB,yCAAyC;YACzC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;SACzC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACtC,CAAC;CACF;AAjCD,sCAiCC"}
+{"version":3,"file":"iterable-queue.js","sourceRoot":"","sources":["../../src/iterable-queue.ts"],"names":[],"mappings":";;;AAAA,qDAAuE;AAIvE;;;;GAIG;AACH,MAAa,aACX,SAAQ,8BAAsB;IAG9B;;;OAGG;IACH,YAAY,UAAgC,EAAE;QAC5C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI;QACf,6BAA6B;QAC7B,MAAM,IAAI,GAAwB,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QAEvD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,yCAAyC;YACzC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QAC1C,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACtC,CAAC;CACF;AAjCD,sCAiCC"}

package/dist/src/queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/queue.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,kGAAkG;AAClG,EAAE;;;AAEF;;;;GAIG;AACH,MAAa,KAAK;IAAlB;QACU,WAAM,GAA2B,EAAE,CAAC;QACpC,UAAK,GAAG,CAAC,CAAC;QACV,UAAK,GAAG,CAAC,CAAC;IAsBpB,CAAC;IApBC,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC;IAED,0CAA0C;IACnC,OAAO,CAAC,OAAU;QACvB,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;SACnD;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACtC,CAAC;IAED,yCAAyC;IAClC,OAAO;QACZ,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAEhD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACjC,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAzBD,sBAyBC"}
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../src/queue.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,kGAAkG;AAClG,EAAE;;;AAEF;;;;GAIG;AACH,MAAa,KAAK;IAAlB;QACU,WAAM,GAA2B,EAAE,CAAC;QACpC,UAAK,GAAG,CAAC,CAAC;QACV,UAAK,GAAG,CAAC,CAAC;IAsBpB,CAAC;IApBC,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC;IAED,0CAA0C;IACnC,OAAO,CAAC,OAAU;QACvB,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACtC,CAAC;IAED,yCAAyC;IAClC,OAAO;QACZ,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK;YAAE,OAAO,SAAS,CAAC;QAEhD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACjC,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAzBD,sBAyBC"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@shutterstock/p-map-iterable",
-  "version": "1.1.1",
-  "description": "Set of classes used for async prefetching with backpressure (IterableMapper) and async flushing with backpressure (IterableQueueMapper, IterableQueueMapperSimple)",
+  "version": "1.2.0-prerelease.1",
+  "packageManager": "pnpm@12.7.0",
+  "description": "Concurrent mapping and queued background work with backpressure, streaming results, and collected errors",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "publishConfig": {
@@ -24,14 +25,15 @@
     "AsyncIterator"
   ],
   "scripts": {
-    "build": "tsc --build tsconfig.json && echo 'examples/\n*.tsbuildinfo' > dist/.npmignore",
+    "build": "tsc --build tsconfig.json && echo 'examples/\n*.tsbuildinfo\n*.test.*\n*.d.ts.map' > dist/.npmignore",
     "build:docs": "typedoc src/index.ts",
     "example:iterable-mapper": "ts-node -r tsconfig-paths/register examples/iterable-mapper.ts",
     "example:iterable-queue-mapper": "ts-node -r tsconfig-paths/register examples/iterable-queue-mapper.ts",
     "example:iterable-queue-mapper-simple": "ts-node -r tsconfig-paths/register examples/iterable-queue-mapper-simple.ts",
+    "example:semantic-aliases": "ts-node -r tsconfig-paths/register examples/semantic-aliases.ts",
     "test": "jest",
-    "lint": "eslint ./ --ext .ts --ext .tsx",
-    "lint-and-fix": "eslint ./ --ext .ts --ext .tsx --fix"
+    "lint": "eslint .",
+    "lint-and-fix": "eslint . --fix"
   },
   "files": [
     "dist/",
@@ -44,24 +46,28 @@
   },
   "license": "MIT",
   "dependencies": {
-    "aggregate-error": "^3.0.0"
+    "aggregate-error": "^3.1.0"
   },
   "peerDependencies": {
-    "aggregate-error": "^3.0.0"
+    "aggregate-error": "^3.1.0"
   },
   "devDependencies": {
-    "@types/jest": "29.5.2",
-    "@typescript-eslint/eslint-plugin": "^5.13.0",
-    "@typescript-eslint/parser": "^5.13.0",
-    "eslint": "^7.15.0",
-    "eslint-config-prettier": "^7.0.0",
-    "eslint-plugin-prettier": "^3.2.0",
-    "jest": "29.5.0",
-    "prettier": "^2.2.1",
-    "ts-jest": "29.1.0",
-    "ts-node": "10.9.1",
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "30.0.0",
+    "@types/node": "^26.6.3",
+    "@typescript-eslint/eslint-plugin": "^8.70.1",
+    "@typescript-eslint/parser": "^8.70.1",
+    "eslint": "^10.11.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.12.0",
+    "jest": "30.5.2",
+    "lcov-parse": "1.0.0",
+    "prettier": "^3.9.9",
+    "ts-jest": "29.4.14",
+    "ts-node": "10.9.2",
     "tsconfig-paths": "4.2.0",
-    "typedoc": "^0.24.8",
-    "typescript": "5.1.3"
+    "typedoc": "^0.28.20",
+    "typescript": "6.0.3"
   }
 }

package/dist/src/blocking-queue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blocking-queue.d.ts","sourceRoot":"","sources":["../../src/blocking-queue.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAOD;;;;;;;GAOG;AACH,qBAAa,aAAa,CAAC,OAAO;IAChC,OAAO,CAAC,QAAQ,CAAiC;IAKjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA+B;IAO5D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAO1E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAE1E,OAAO,CAAC,WAAW,CAAS;IAE5B;;;;OAIG;gBACS,OAAO,GAAE,oBAAyB;IAuB9C,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;OAIG;IACI,IAAI,IAAI,IAAI;IAcnB;;;;OAIG;IACU,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BlD;;;;OAIG;IACU,OAAO,IAAI,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;IAoCpD,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,SAAS;IAqCjB;;OAEG;YACW,YAAY;IAW1B;;OAEG;YACW,WAAW;CAU1B"}

package/dist/src/blocking-queue.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=blocking-queue.test.d.ts.map

package/dist/src/blocking-queue.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blocking-queue.test.d.ts","sourceRoot":"","sources":["../../src/blocking-queue.test.ts"],"names":[],"mappings":""}

package/dist/src/blocking-queue.test.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/// <reference types="jest" />
-const blocking_queue_1 = require("./blocking-queue");
-describe('BlockingQueue', () => {
-    beforeAll(() => {
-        // nothing
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('maxUnread: 0', () => {
-        it('single item enqueue/dequeue works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 0 });
-            setTimeout(() => {
-                void queue.enqueue(1);
-            }, 1000);
-            const item = await queue.dequeue();
-            queue.done();
-            expect(item).toBe(1);
-        });
-        it('dequeue after done does not hang', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 0 });
-            setTimeout(() => {
-                void queue.enqueue(1);
-            }, 1000);
-            const item = await queue.dequeue();
-            queue.done();
-            await queue.dequeue();
-            expect(item).toBe(1);
-        });
-        it('enqueue after done throws', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 0 });
-            setTimeout(() => {
-                void queue.enqueue(1);
-            }, 1000);
-            const item = await queue.dequeue();
-            queue.done();
-            await expect(async () => queue.enqueue(2)).rejects.toThrowError('`enqueue` called after `done` called');
-            expect(item).toBe(1);
-        });
-        it('balanced enqueue/dequeue works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 0 });
-            const writers = [];
-            writers.push(queue.enqueue(1));
-            writers.push(queue.enqueue(2));
-            const readers = [];
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            await Promise.all(writers);
-            queue.done();
-            await Promise.all(readers);
-            expect(await readers[0]).toBe(1);
-            expect(await readers[1]).toBe(2);
-        });
-        it('full queue blocks enqueue until dequeue', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            // Add first item
-            void queue.enqueue(1);
-            // Do not wait for second item to add (it will wait until an enqueue completes)
-            setTimeout(() => {
-                void queue.enqueue(2);
-            }, 2000);
-            const startTime = Date.now();
-            expect(await queue.dequeue()).toBe(1);
-            expect(Date.now() - startTime).toBeLessThan(2000);
-            expect(await queue.dequeue()).toBe(2);
-            expect(Math.ceil(Date.now() - startTime)).toBeGreaterThanOrEqual(2000);
-            queue.done();
-        });
-    });
-    describe('maxUnread: 1', () => {
-        it('single item enqueue/dequeue works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            await queue.enqueue(1);
-            const item = await queue.dequeue();
-            queue.done();
-            expect(item).toBe(1);
-        });
-        it('dequeue after done does not hang', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            await queue.enqueue(1);
-            const item = await queue.dequeue();
-            queue.done();
-            await queue.dequeue();
-            expect(item).toBe(1);
-        });
-        it('dequeue after done and empty does not hang', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            await queue.enqueue(1);
-            const item = await queue.dequeue();
-            queue.done();
-            await queue.dequeue();
-            expect(item).toBe(1);
-            await queue.dequeue();
-        });
-        it('enqueue after done throws', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            await queue.enqueue(1);
-            const item = await queue.dequeue();
-            queue.done();
-            await expect(async () => queue.enqueue(2)).rejects.toThrowError('`enqueue` called after `done` called');
-            expect(item).toBe(1);
-        });
-        it('balanced enqueue/dequeue works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            const writers = [];
-            writers.push(queue.enqueue(1));
-            writers.push(queue.enqueue(2));
-            const readers = [];
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            await Promise.all(writers);
-            queue.done();
-            await Promise.all(readers);
-            expect(await readers[0]).toBe(1);
-            expect(await readers[1]).toBe(2);
-        });
-        it('more dequeue than enqueue works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            const writers = [];
-            writers.push(queue.enqueue(1));
-            writers.push(queue.enqueue(2));
-            const readers = [];
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            await Promise.all(writers);
-            queue.done();
-            await Promise.all(readers);
-            expect(await readers[0]).toBe(1);
-            expect(await readers[1]).toBe(2);
-            expect(await readers[2]).toBeUndefined();
-            expect(await readers[3]).toBeUndefined();
-        });
-        it('full queue blocks enqueue until dequeue', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 1 });
-            // Wait for first item to add
-            await queue.enqueue(1);
-            // Do not wait for second item to add (it will wait until an enqueue completes)
-            setTimeout(() => {
-                void queue.enqueue(2);
-            }, 2000);
-            expect(await queue.dequeue()).toBe(1);
-            const startTime = Date.now();
-            expect(await queue.dequeue()).toBe(2);
-            const duration = Math.ceil(Date.now() - startTime);
-            expect(duration).toBeGreaterThanOrEqual(2000);
-            queue.done();
-        });
-    });
-    describe('maxUnread: 2', () => {
-        it('no reads until done works', async () => {
-            const queue = new blocking_queue_1.BlockingQueue({ maxUnread: 2 });
-            const writers = [];
-            writers.push(queue.enqueue(1));
-            writers.push(queue.enqueue(2));
-            await Promise.all(writers);
-            queue.done();
-            const readers = [];
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            readers.push(queue.dequeue());
-            await Promise.all(readers);
-            expect(await readers[0]).toBe(1);
-            expect(await readers[1]).toBe(2);
-            expect(await readers[2]).toBeUndefined();
-            expect(await readers[3]).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=blocking-queue.test.js.map