@parallel-park/run-jobs 0.3.0 → 0.3.1

package/dist/run-jobs.d.ts

@@ -0,0 +1,13 @@
+declare let debug: null | ((...args: any) => void);
+export declare function setDebug(debugFunction: typeof debug): void;
+export declare function runJobs<T, U>(inputs: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>, mapper: (input: T, index: number, length: number) => Promise<U>, { 
+/**
+ * How many jobs are allowed to run at once.
+ */
+concurrency, }?: {
+    /**
+     * How many jobs are allowed to run at once.
+     */
+    concurrency?: number;
+}): Promise<Array<U>>;
+export {};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@parallel-park/run-jobs",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Parallel async work with an optional concurrency limit, like Bluebird's Promise.map",
   "main": "dist/index.js",
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "scripts": {
     "test": "vitest run",
     "build": "rm -rf ./dist && tsc"

package/src/run-jobs.ts

@@ -1,159 +0,0 @@
-let debug: null | ((...args: any) => void) = null;
-
-export function setDebug(debugFunction: typeof debug) {
-  debug = debugFunction;
-}
-
-function isThenable<T>(value: unknown): value is Promise<T> {
-  return (
-    typeof value === "object" &&
-    value != null &&
-    // @ts-ignore accessing .then
-    typeof value.then === "function"
-  );
-}
-
-const NOTHING = Symbol("NOTHING");
-
-let runJobsCallId = 0;
-
-export async function runJobs<T, U>(
-  inputs: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>,
-  mapper: (input: T, index: number, length: number) => Promise<U>,
-  {
-    /**
-     * How many jobs are allowed to run at once.
-     */
-    concurrency = 8,
-  }: {
-    /**
-     * How many jobs are allowed to run at once.
-     */
-    concurrency?: number;
-  } = {}
-): Promise<Array<U>> {
-  const callId = runJobsCallId;
-  runJobsCallId++;
-
-  if (debug) {
-    debug(`runJobs called (callId: ${callId})`, {
-      inputs,
-      mapper,
-      concurrency,
-    });
-  }
-
-  if (concurrency < 1) {
-    throw new Error(
-      "Concurrency can't be less than one; that doesn't make any sense."
-    );
-  }
-
-  const inputsArray: Array<T> = [];
-  const inputIteratorFactory =
-    inputs[Symbol.asyncIterator || NOTHING] || inputs[Symbol.iterator];
-  const inputIterator = inputIteratorFactory.call(inputs);
-  const maybeLength = Array.isArray(inputs) ? inputs.length : null;
-
-  let iteratorDone = false;
-
-  async function readInput(): Promise<boolean> {
-    if (debug) {
-      debug(`reading next input (callId: ${callId})`);
-    }
-    let nextResult = inputIterator.next();
-    if (isThenable(nextResult)) {
-      nextResult = await nextResult;
-    }
-    if (nextResult.done) {
-      iteratorDone = true;
-      return false;
-    } else {
-      let value = nextResult.value;
-      if (isThenable<T>(value)) {
-        value = await value;
-      }
-      inputsArray.push(value);
-      return true;
-    }
-  }
-
-  let unstartedIndex = 0;
-
-  const results = new Array(maybeLength || 0);
-  const runningPromises = new Set();
-  let error: Error | null = null;
-
-  async function takeInput() {
-    const read = await readInput();
-    if (!read) return;
-
-    const inputIndex = unstartedIndex;
-    unstartedIndex++;
-
-    const input = inputsArray[inputIndex];
-    if (debug) {
-      debug(`mapping input into Promise (callId: ${callId})`);
-    }
-    const promise = mapper(input, inputIndex, maybeLength || Infinity);
-
-    if (!isThenable(promise)) {
-      throw new Error(
-        "Mapper function passed into runJobs didn't return a Promise. The mapper function should always return a Promise. The easiest way to ensure this is the case is to make your mapper function an async function."
-      );
-    }
-
-    const promiseWithMore = promise.then(
-      (result) => {
-        if (debug) {
-          debug(`child Promise resolved for input (callId: ${callId}):`, input);
-        }
-        results[inputIndex] = result;
-        runningPromises.delete(promiseWithMore);
-      },
-      (err) => {
-        if (debug) {
-          debug(
-            `child Promise rejected for input (callId: ${callId}):`,
-            input,
-            "with error:",
-            err
-          );
-        }
-        runningPromises.delete(promiseWithMore);
-        error = err;
-      }
-    );
-    runningPromises.add(promiseWithMore);
-  }
-
-  async function proceed() {
-    while (!iteratorDone && runningPromises.size < concurrency) {
-      await takeInput();
-    }
-  }
-
-  await proceed();
-  while (runningPromises.size > 0 && !error) {
-    await Promise.race(runningPromises.values());
-    if (error) {
-      if (debug) {
-        debug(`throwing error (callId: ${callId})`);
-      }
-      throw error;
-    }
-    await proceed();
-  }
-
-  if (error) {
-    if (debug) {
-      debug(`throwing error (callId: ${callId})`);
-    }
-    throw error;
-  }
-
-  if (debug) {
-    debug(`all done (callId: ${callId})`);
-  }
-  return results;
-}