@altano/tiny-async-pool 1.0.3 → 2.0.0

package/README.md

@@ -1,5 +1,7 @@
 # tiny-async-pool
 
+This is an ESM + TypeScript rewrite of [tiny-async-pool](https://www.npmjs.com/package/tiny-async-pool) by Rafael Xavier de Souza.
+
 ## Why?
 
 The goal of this library is to use the native async iterator (ES9), native async functions, and native Promise to implement concurrent/batched work.
@@ -69,17 +71,16 @@ Iterator function that takes two arguments: the value of each iteration and the
 
 ### `doWork(concurrency, iterable, iteratorFn)`
 
-The same as `doWorkAndYield(...)` but just returns a Promise that resolves when all work resolves/rejects, e.g.:
+Like `doWorkAndYield(...)` but returns a Promise that resolves when all work resolves (or rejects immediately when any Promise rejects). Useful when you don't care about the return of `iteratorFn`, such as a worker pool where you do batch file proccessing and the workers produce a side effect instead of returning a value. For example, a batch file eraser:
 
 ```js
-const timeout = (ms) => new Promise((resolve) => setTimeout(() => resolve(ms), ms));
-
-await doWork(2, [1000, 5000, 3000, 2000], timeout);
+const eraseFile = (path) => fs.unlink(path);
+const eraseFiles = async (files) => doWork(4, files, eraseFile);
 ```
 
-## License
+It will be enforced that `iteratorFn` returns `Promise<void>` when using TypeScript.
 
-This project is a fork of `async-pool` by Rafael Xavier de Souza. It modernizes (as of 2022) the library by being a first-class TypeScript and ESM module.
+## License
 
 MIT © [Rafael Xavier de Souza](http://rafael.xavier.blog.br)
 MIT © [Alan Norbauer](https://alan.norbauer.com)

package/dist/doWork.d.ts

@@ -1,6 +1,21 @@
-import { doWorkAndYield } from "./doWorkAndYield";
+import { type IterableItem } from "./doWorkAndYield";
 /**
  * Process items from `iterable` in batches.
  */
-export declare function doWork<TIn, TOut, TIterable extends Iterable<TIn>>(...args: Parameters<typeof doWorkAndYield<TIn, TOut, TIterable>>): Promise<void>;
+export declare function doWork<TIn, TOut, TIterable extends Iterable<TIn>>(
+/**
+ * The size of the batch of work, or, how many times `iteratorFn` will be
+ * called in parallel.
+ */
+concurrentCount: number, 
+/**
+ * An iterable that contains the items that should be passed to `iteratorFn`.
+ */
+iterable: TIterable, 
+/**
+ * The async callback function that does the work. Will be passed items from
+ * `iterable`. Promise returned must not resolve to a value, as it will be
+ * ignored.
+ */
+iteratorFn: (item: IterableItem<TIterable>, Iterable: TIterable) => Promise<void>): Promise<void>;
 //# sourceMappingURL=doWork.d.ts.map

package/dist/doWorkAndYield.d.ts

@@ -1,4 +1,4 @@
-type IterableItem<T> = T extends Iterable<infer R> ? R : never;
+export type IterableItem<T> = T extends Iterable<infer R> ? R : never;
 /**
  * Process items from `iterable` in batches and yield the result of each call to
  * `iteratorFn`
@@ -18,5 +18,4 @@ iterable: TIterable,
  * `iterable`.
  */
 iteratorFn: (item: IterableItem<TIterable>, Iterable: TIterable) => Promise<TOut>): AsyncGenerator<Awaited<TOut>, void, unknown>;
-export {};
 //# sourceMappingURL=doWorkAndYield.d.ts.map

package/dist/index.js

@@ -23,8 +23,12 @@ async function* doWorkAndYield(concurrentCount, iterable, iteratorFn) {
 }
 
 // src/doWork.ts
-async function doWork(...args) {
-  for await (const _result of doWorkAndYield(...args)) {
+async function doWork(concurrentCount, iterable, iteratorFn) {
+  for await (const _result of doWorkAndYield(
+    concurrentCount,
+    iterable,
+    iteratorFn
+  )) {
   }
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altano/tiny-async-pool",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "Run multiple promise-returning & async functions with limited concurrency using native ES9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",