@altano/tiny-async-pool 1.0.2 → 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.
@@ -9,8 +11,7 @@ The goal of this library is to use the native async iterator (ES9), native async
 `doWorkAndYield` runs multiple promise-returning & async functions in a limited concurrency pool. It rejects immediately as soon as one of the promises rejects. It calls the iterator function as soon as possible (under concurrency limit). It returns an async iterator that yields as soon as a promise completes (under concurrency limit). For example:
 
 ```js
-const timeout = (ms) =>
-  new Promise((resolve) => setTimeout(() => resolve(ms), ms));
+const timeout = (ms) => new Promise((resolve) => setTimeout(() => resolve(ms), ms));
 
 for await (const ms of doWorkAndYield(2, [1000, 5000, 3000, 2000], timeout)) {
   console.log(ms);
@@ -70,18 +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

@@ -0,0 +1,21 @@
+import { type IterableItem } from "./doWorkAndYield";
+/**
+ * Process items from `iterable` in batches.
+ */
+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

@@ -0,0 +1,21 @@
+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`
+ */
+export declare function doWorkAndYield<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`.
+ */
+iteratorFn: (item: IterableItem<TIterable>, Iterable: TIterable) => Promise<TOut>): AsyncGenerator<Awaited<TOut>, void, unknown>;
+//# sourceMappingURL=doWorkAndYield.d.ts.map

package/dist/index.d.ts

@@ -1,27 +1,3 @@
-declare 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`
- */
-declare function doWorkAndYield<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`.
- */
-iteratorFn: (item: IterableItem<TIterable>, Iterable: TIterable) => Promise<TOut>): AsyncGenerator<Awaited<TOut>, void, unknown>;
-
-/**
- * Process items from `iterable` in batches.
- */
-declare function doWork<TIn, TOut, TIterable extends Iterable<TIn>>(...args: Parameters<typeof doWorkAndYield<TIn, TOut, TIterable>>): Promise<void>;
-
-export { doWork, doWorkAndYield };
+export * from "./doWork";
+export * from "./doWorkAndYield";
+//# sourceMappingURL=index.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.2",
+  "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",
@@ -8,18 +8,10 @@
   "sideEffects": false,
   "files": [
     "LICENSE-MIT",
-    "dist",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts --watch --format esm --dts",
-    "format": "prettier --write src",
-    "lint": "TIMING=1 eslint src/**/*.ts* --fix",
-    "clean": "rm -rf .turbo && rm -rf .tsbuildinfo && rm -rf node_modules && rm -rf dist",
-    "test": "vitest --run",
-    "test:watch": "vitest"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/altano/npm-packages",
@@ -46,25 +38,34 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@altano/tsconfig": "*",
-    "@types/node": "^18.6.4",
-    "@types/prettier": "^2.7.0",
-    "@typescript-eslint/eslint-plugin": "^5.36.1",
-    "@typescript-eslint/parser": "^5.36.1",
-    "@vitest/ui": "^0.21.0",
+    "@types/node": "^20.11.25",
+    "@types/prettier": "^3.0.0",
+    "@vitest/ui": "^1.3.1",
+    "chai": "^4.4.1",
     "chai-as-promised": "^7.1.1",
-    "chai": "^4.3.6",
-    "eslint-config-altano": "*",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "eslint": "^8.23.0",
-    "mocha": "^10.0.0",
-    "prettier": "^2.7.1",
-    "tsup": "^6.2.3",
-    "typescript": "^4.8.2",
-    "vitest": "^0.21.0"
+    "eslint": "^8.57.0",
+    "mocha": "^10.3.0",
+    "prettier": "^3.2.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.2",
+    "vitest": "^1.3.1",
+    "@altano/tsconfig": "0.0.0",
+    "eslint-config-altano": "0.0.1"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --onSuccess \"pnpm build:types\"",
+    "build:types": "tsc --emitDeclarationOnly --declaration",
+    "dev": "tsup src/index.ts --watch --format esm --dts",
+    "format": "prettier --check src",
+    "format:fix": "prettier --write src",
+    "lint": "eslint src/**/*.ts*",
+    "lint:timing": "TIMING=1 eslint src/**/*.ts*",
+    "lint:fix": "TIMING=1 eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf .tsbuildinfo && rm -rf node_modules && rm -rf dist",
+    "test": "vitest --run",
+    "test:watch": "vitest"
   }
-}
+}