@shutterstock/p-map-iterable 0.0.1

package/dist/iterable-mapper.d.ts

@@ -0,0 +1,104 @@
+interface IterableMapperOptions {
+    /**
+          Number of concurrently pending promises returned by `mapper`.
+  
+          Must be an integer from 1 and up or `Infinity`, must be <= `maxUnread`.
+  
+          @default 4
+          */
+    readonly concurrency?: number;
+    /**
+          Number of pending unread iterable items.
+  
+          Must be an integer from 1 and up or `Infinity`, must be >= `concurrency`.
+  
+          @default 8
+          */
+    readonly maxUnread?: number;
+    /**
+          When set to `false`, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an [aggregated error](https://github.com/sindresorhus/aggregate-error) containing all the errors from the rejected promises.
+  
+          @default true
+          */
+    readonly stopOnMapperError?: boolean;
+}
+/**
+    Function which is called for every item in `input`. Expected to return a `Promise` or value.
+
+    @param element - Iterated element.
+    @param index - Index of the element in the source array.
+    */
+export type Mapper<Element = unknown, NewElement = unknown> = (element: Element, index: number) => NewElement | Promise<NewElement>;
+export declare class IterableMapper<Element, NewElement> implements AsyncIterable<NewElement> {
+    private _mapper;
+    private _options;
+    private _unreadQueue;
+    private _iterator;
+    private readonly _errors;
+    private _asyncIterator;
+    private _isRejected;
+    private _isIterableDone;
+    private _activeRunners;
+    private _resolvingCount;
+    private _currentIndex;
+    private _initialRunnersCreated;
+    /**
+     * Iterates over a source iterable with specified concurrency,
+     * calling the `mapper` on each iterated item, and storing the
+     * `mapper` result in a queue of specified max size, before
+     * being iterated / read by the caller.
+     *
+     * Essentially - This allows performing a concurrent mapping with
+     * back pressure (won't iterate all source items if the consumer is
+     * not reading).
+     *
+     * Typical use case is for a `prefetcher` that ensures that items
+     * are always ready for the consumer but that large numbers of items
+     * are not processed before the consumer is ready for them.
+     *
+     * @param input - Iterated over concurrently in the `mapper` function.
+     * @param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
+     * @param options - { concurrency: max mappers to run in parallel,
+     *                    maxUnread: max unread mapped results - this waits for results to be read,
+     *                    stopOnError: return if a mapper throws - note that any other running mappers will then not be able to return results
+     *                  }
+     * @returns A `Promise` that is fulfilled when all promises in `input`
+     * and ones returned from `mapper` are fulfilled, or rejects if any of the
+     * promises reject. The fulfilled value is an `Array` of the fulfilled
+     * values returned from `mapper` in `input` order.
+     */
+    constructor(iterable: AsyncIterable<Element> | Iterable<Element>, mapper: Mapper<Element, NewElement>, { concurrency, stopOnMapperError, maxUnread }?: IterableMapperOptions);
+    [Symbol.asyncIterator](): AsyncIterator<NewElement>;
+    /**
+     * Used by the iterator returned from [Symbol.asyncIterator]
+     * Called every time an item is needed
+     * @returns Iterator result
+     */
+    next(): Promise<IteratorResult<NewElement>>;
+    private bubbleUpErrors;
+    private startARunnerIfNeeded;
+    private startAnotherRunner;
+    private areWeDone;
+    /**
+     * Throw an exception if the wrapped NewElement is an Error
+     * @returns
+     */
+    private throwIfError;
+    /**
+     * Get the next item from the source iterable.
+     *
+     * This is called up to `concurrency` times in parallel.
+     *
+     * If the read queue is not full, and there are source items to read,
+     * each instance of this will keep calling a new instance of itself
+     * that detaches and runs asynchronously (keeping the same number
+     * of instances running).
+     *
+     * If the read queue + runners = max read queue length then the runner
+     * will exit and will be restarted when an item is read from the queue.
+     * @returns
+     */
+    private sourceNext;
+}
+export {};
+//# sourceMappingURL=iterable-mapper.d.ts.map

package/dist/iterable-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-mapper.d.ts","sourceRoot":"","sources":["../src/iterable-mapper.ts"],"names":[],"mappings":"AAMA,UAAU,qBAAqB;IAC7B;;;;;;YAME;IACF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;YAME;IACF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;YAIE;IACF,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED;;;;;MAKG;AACH,MAAM,MAAM,MAAM,CAAC,OAAO,GAAG,OAAO,EAAE,UAAU,GAAG,OAAO,IAAI,CAC5D,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,KACV,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAUtC,qBAAa,cAAc,CAAC,OAAO,EAAE,UAAU,CAAE,YAAW,aAAa,CAAC,UAAU,CAAC;IACnF,OAAO,CAAC,OAAO,CAA8B;IAC7C,OAAO,CAAC,QAAQ,CAAkC;IAElD,OAAO,CAAC,YAAY,CAA+C;IAEnE,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,sBAAsB,CAAS;IAEvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;gBAED,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,EACpD,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,EACnC,EAAE,WAAe,EAAE,iBAAwB,EAAE,SAAa,EAAE,GAAE,qBAA0B;IAsFnF,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,UAAU,CAAC;IAI1D;;;;OAIG;IACU,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAyBxD,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,oBAAoB;IAuB5B,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,SAAS;IAiBjB;;;OAGG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;;;;;;;;;OAaG;YACW,UAAU;CAiHzB"}

package/dist/iterable-mapper.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterableMapper = void 0;
+const tslib_1 = require("tslib");
+//
+// 2021-08-25 - Initially based on: https://raw.githubusercontent.com/sindresorhus/p-map/main/index.js
+//
+const aggregate_error_1 = tslib_1.__importDefault(require("aggregate-error"));
+const iterable_queue_1 = require("./iterable-queue");
+class IterableMapper {
+    /**
+     * Iterates over a source iterable with specified concurrency,
+     * calling the `mapper` on each iterated item, and storing the
+     * `mapper` result in a queue of specified max size, before
+     * being iterated / read by the caller.
+     *
+     * Essentially - This allows performing a concurrent mapping with
+     * back pressure (won't iterate all source items if the consumer is
+     * not reading).
+     *
+     * Typical use case is for a `prefetcher` that ensures that items
+     * are always ready for the consumer but that large numbers of items
+     * are not processed before the consumer is ready for them.
+     *
+     * @param input - Iterated over concurrently in the `mapper` function.
+     * @param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
+     * @param options - { concurrency: max mappers to run in parallel,
+     *                    maxUnread: max unread mapped results - this waits for results to be read,
+     *                    stopOnError: return if a mapper throws - note that any other running mappers will then not be able to return results
+     *                  }
+     * @returns A `Promise` that is fulfilled when all promises in `input`
+     * and ones returned from `mapper` are fulfilled, or rejects if any of the
+     * promises reject. The fulfilled value is an `Array` of the fulfilled
+     * values returned from `mapper` in `input` order.
+     */
+    constructor(iterable, mapper, { concurrency = 4, stopOnMapperError = true, maxUnread = 8 } = {}) {
+        this._errors = [];
+        this._asyncIterator = false;
+        this._isRejected = false;
+        this._isIterableDone = false;
+        this._activeRunners = 0;
+        this._resolvingCount = 0;
+        this._currentIndex = 0;
+        this._initialRunnersCreated = false;
+        this._mapper = mapper;
+        this._options = { concurrency, stopOnMapperError, maxUnread };
+        if (typeof mapper !== 'function') {
+            throw new TypeError('Mapper function is required');
+        }
+        // Avoid undefined errors on options
+        if (this._options.concurrency === undefined ||
+            this._options.stopOnMapperError === undefined ||
+            this._options.maxUnread === undefined) {
+            throw new TypeError('Options are malformed after init');
+        }
+        // Validate concurrency option
+        if (!((Number.isSafeInteger(this._options.concurrency) ||
+            this._options.concurrency === Number.POSITIVE_INFINITY) &&
+            this._options.concurrency >= 1)) {
+            throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+        }
+        // Validate maxUnread option
+        if (!((Number.isSafeInteger(this._options.maxUnread) ||
+            this._options.maxUnread === Number.POSITIVE_INFINITY) &&
+            this._options.maxUnread >= 1)) {
+            throw new TypeError(`Expected \`maxUnread\` to be an integer from 1 and up or \`Infinity\`, got \`${maxUnread}\` (${typeof maxUnread})`);
+        }
+        // Validate relationship between maxUnread and concurrency
+        if (this._options.maxUnread < this._options.concurrency) {
+            throw new TypeError(`Expected \`maxUnread\` to be greater than or equal to \`concurrency\`, got \`${maxUnread}\` < \`${concurrency}\``);
+        }
+        this._unreadQueue = new iterable_queue_1.IterableQueue({ maxUnread });
+        // Setup the source iterator
+        if (iterable[Symbol.asyncIterator] !== undefined) {
+            // We've got an async iterable
+            this._iterator = iterable[Symbol.asyncIterator]();
+            this._asyncIterator = true;
+        }
+        else {
+            this._iterator = iterable[Symbol.iterator]();
+        }
+        // Create the initial concurrent runners in a detached (non-awaited)
+        // promise.  We need this so we can await the next() calls
+        // to stop creating runners before hitting the concurrency limit
+        // if the iterable has already been marked as done.
+        void (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (let index = 0; index < concurrency; index++) {
+                // Setup the detached runner
+                this._activeRunners++;
+                // This only waits for the next source item to be iterated
+                // It does NOT wait for the mapper to be called for for a consumer to pickup
+                // the result out of the unread queue.
+                yield this.sourceNext();
+                if (this._isIterableDone || this._isRejected) {
+                    break;
+                }
+            }
+            // Signal that the next() function should now create runners if it sees too few of them
+            this._initialRunnersCreated = true;
+        }))();
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    /**
+     * Used by the iterator returned from [Symbol.asyncIterator]
+     * Called every time an item is needed
+     * @returns Iterator result
+     */
+    next() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Bail out and release all waiters if there are no more items coming
+            const done = this.areWeDone();
+            if (done) {
+                if (!this._options.stopOnMapperError && this._errors.length > 0) {
+                    // throw the errors as an aggregate exception
+                    this._isRejected = true;
+                    throw new aggregate_error_1.default(this._errors);
+                }
+                return { value: undefined, done };
+            }
+            // Check if queue has an item
+            const item = yield this._unreadQueue.dequeue();
+            if (item === undefined) {
+                // We finished - There were no more items
+                this.bubbleUpErrors();
+                return { value: undefined, done: true };
+            }
+            this.startARunnerIfNeeded();
+            return { value: this.throwIfError(item), done: false };
+        });
+    }
+    bubbleUpErrors() {
+        if (!this._options.stopOnMapperError && this._errors.length > 0) {
+            // throw the errors as an aggregate exception
+            throw new aggregate_error_1.default(this._errors);
+        }
+    }
+    startARunnerIfNeeded() {
+        // If there are items left AND there are not enough runners running,
+        // start one more runner - each subsequent read will check this and start more runners
+        // as items are pulled from the queue
+        if (this._initialRunnersCreated) {
+            // The init loop has finished - we don't create runners until that loop
+            // has finished else we'll end up with too many runners
+            if (!this._isIterableDone && !this._isRejected) {
+                // We only create more runners if the source iterable is not already done
+                if (this._activeRunners < this._options.concurrency) {
+                    // We only create runners if we're under the concurrency limit
+                    if (this._unreadQueue.length + this._activeRunners <= this._options.maxUnread) {
+                        // We only create runners if the number of runners + unread items will not
+                        // exceed the unread queue length
+                        // Start another source runner, but do not await it
+                        this.startAnotherRunner();
+                    }
+                }
+            }
+        }
+    }
+    startAnotherRunner() {
+        if (this._activeRunners === this._options.concurrency) {
+            throw new TypeError('active runners would be greater than concurrency limit');
+        }
+        if (this._activeRunners + this._unreadQueue.length > this._options.maxUnread) {
+            throw new TypeError('active runners would overflow the read queue limit');
+        }
+        if (this._isIterableDone) {
+            throw new TypeError('runner should not be started when iterable is already done');
+        }
+        if (this._activeRunners < 0) {
+            throw new TypeError('active runners is less than 0');
+        }
+        // We only create runners if the number of runners + unread items will not
+        // exceed the unread queue length
+        this._activeRunners++;
+        // Start another source runner, but do not await it
+        void this.sourceNext();
+    }
+    areWeDone() {
+        if (this._isIterableDone) {
+            // The source iterable has no more items
+            if (this._resolvingCount === 0) {
+                // There are no more resolvers running
+                if (this._unreadQueue.length === 0) {
+                    // There are no unread items left
+                    this._unreadQueue.done();
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Throw an exception if the wrapped NewElement is an Error
+     * @returns
+     */
+    throwIfError(item) {
+        if (item.error !== undefined) {
+            throw item.error;
+        }
+        else if (item.element === undefined) {
+            throw new TypeError('no element was returned');
+        }
+        return item.element;
+    }
+    /**
+     * Get the next item from the source iterable.
+     *
+     * This is called up to `concurrency` times in parallel.
+     *
+     * If the read queue is not full, and there are source items to read,
+     * each instance of this will keep calling a new instance of itself
+     * that detaches and runs asynchronously (keeping the same number
+     * of instances running).
+     *
+     * If the read queue + runners = max read queue length then the runner
+     * will exit and will be restarted when an item is read from the queue.
+     * @returns
+     */
+    sourceNext() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this._isRejected) {
+                this._activeRunners--;
+                return;
+            }
+            // Note: do NOT await a non-async iterable as it will cause next() to be
+            // pushed into the event loop, slowing down iteration of non-async iterables.
+            let nextItem;
+            try {
+                if (this._asyncIterator) {
+                    nextItem = yield this._iterator.next();
+                }
+                else {
+                    nextItem = this._iterator.next();
+                }
+            }
+            catch (error) {
+                // Iterator protocol / Iterables can throw exceptions - If this happens we have to just stop
+                // regardless of stopOnMapperError since we can't iterate any additional items
+                this._isRejected = true;
+                this._activeRunners--;
+                // Push the error onto the unread queue, to be rethrown by next()
+                yield this._unreadQueue.enqueue({ error });
+                return;
+            }
+            const index = this._currentIndex;
+            this._currentIndex++;
+            if (nextItem.done) {
+                this._isIterableDone = true;
+                // If there are no active resolvers, then release all the waiters
+                if (this._resolvingCount === 0) {
+                    // At this point the only waiters in the queue are not going to get an item
+                    // as there are no source items left
+                    this._unreadQueue.done();
+                }
+                this._activeRunners--;
+                return;
+            }
+            this._resolvingCount++;
+            // This is created as a detached, non-awaited async
+            // to allow next() to return while the async mapper is awaited.
+            // More next() calls will be made up to the concurrency limit.
+            void (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                //
+                // Push an item or error into the read queue
+                // Note: once we push an item we end this try/catch as any subsequent errors
+                // are errors in this class and not errors thrown by the mapper function.
+                // Once we've pushed an item we can't also push an error...
+                //
+                try {
+                    const element = nextItem.value;
+                    if (this._isRejected) {
+                        this._activeRunners--;
+                        return;
+                    }
+                    const value = yield this._mapper(element, index);
+                    this._resolvingCount--;
+                    // if (value === pMapSkip) {
+                    //   skippedIndexes.push(index);
+                    // } else {
+                    //   result[index] = value;
+                    // }
+                    // Push item onto the ready queue
+                    yield this._unreadQueue.enqueue({ element: value });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    if (this._options.stopOnMapperError) {
+                        this._isRejected = true;
+                        this._activeRunners--;
+                        // Push the error onto the unread queue, to be rethrown by next()
+                        yield this._unreadQueue.enqueue({ error });
+                        // Fall through to release a reader
+                    }
+                    else {
+                        // Collect the error but do not stop iterating
+                        // These will be thrown in an AggregateError at the end
+                        this._errors.push(error);
+                        this._resolvingCount--;
+                        yield this.sourceNext();
+                        // Return so we don't release a reader since we didn't push an item
+                        return;
+                    }
+                }
+                //
+                // Tasks below are not related to the mapper
+                //
+                // Bail if read queue length + active runners will hit max unread
+                if (this._unreadQueue.length + this._activeRunners > this._options.maxUnread) {
+                    this._activeRunners--;
+                    return;
+                }
+                // Start myself again
+                // Note: this will bail out if it reaches the end of the source iterable
+                yield this.sourceNext();
+            }))();
+        });
+    }
+}
+exports.IterableMapper = IterableMapper;
+//# sourceMappingURL=iterable-mapper.js.map

package/dist/iterable-mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-mapper.js","sourceRoot":"","sources":["../src/iterable-mapper.ts"],"names":[],"mappings":"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"}

package/dist/iterable-mapper.test.d.ts

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

package/dist/iterable-mapper.test.d.ts.map

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