update deps

README.md

@@ -34,7 +34,7 @@ const input = [1, 2, 3, 4, 5];
 const i = pipe(
     input,
     filter((a) => a % 2 === 0), // find even numbers
-    map((value) => ({value})) // remap into objects
+    map((value) => ({value})), // remap into objects
 );
 
 console.log(...i); //=> {value: 2}, {value: 4}
@@ -50,7 +50,7 @@ const input = [1, 2, 2, 3, 3, 4];
 const i = pipe(
     toAsync(input), // make asynchronous
     distinct(), // emit unique numbers
-    delay(1000) // delay each value by 1s
+    delay(1000), // delay each value by 1s
 );
 // or you can replace `pipe` + `toAsync` with just `pipeAsync`
 

benchmarks/src/tests/iter-ops.ts

@@ -6,7 +6,7 @@ export async function testIterOps(input: UnknownIterable<number>) {
         input,
         filter((a) => a % 2 === 0),
         map((b) => ({value: b})),
-        toArray()
+        toArray(),
     );
     const {length} = (await i.first)!;
     const duration = Date.now() - start;

benchmarks/src/tests/rxjs.ts

@@ -3,13 +3,13 @@ import {filter, firstValueFrom, from, map, toArray} from 'rxjs';
 
 export async function testRXJS(
     input: UnknownIterable<number>,
-    withSubscription?: boolean
+    withSubscription?: boolean,
 ) {
     const start = Date.now();
     const i = from(input).pipe(
         filter((a) => a % 2 === 0),
         map((b) => ({value: b})),
-        toArray()
+        toArray(),
     );
     if (withSubscription) {
         // key to measuring RXJS correctly;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "iter-ops",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "Basic operations on iterables",
   "keywords": [
     "typescript",
@@ -65,39 +65,39 @@
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "1.0.2",
-    "@rollup/plugin-node-resolve": "15.0.1",
-    "@rollup/plugin-typescript": "10.0.1",
-    "@types/chai": "4.3.4",
-    "@types/estree": "1.0.0",
+    "@rollup/plugin-node-resolve": "15.1.0",
+    "@rollup/plugin-typescript": "11.1.2",
+    "@types/chai": "4.3.5",
+    "@types/estree": "1.0.1",
     "@types/mocha": "10.0.1",
-    "@types/node": "18.11.17",
+    "@types/node": "20.4.1",
     "@types/rollup-plugin-auto-external": "2.0.2",
-    "@typescript-eslint/eslint-plugin": "5.47.0",
-    "@typescript-eslint/parser": "5.47.0",
+    "@typescript-eslint/eslint-plugin": "6.0.0",
+    "@typescript-eslint/parser": "6.0.0",
     "chai": "4.3.7",
     "cross-env": "7.0.3",
-    "cspell": "6.18.0",
-    "eslint": "8.30.0",
-    "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-prettier": "4.2.1",
+    "cspell": "6.31.1",
+    "eslint": "8.44.0",
+    "eslint-config-prettier": "8.8.0",
+    "eslint-plugin-prettier": "5.0.0",
     "mocha": "10.2.0",
     "nyc": "15.1.0",
-    "prettier": "2.8.1",
-    "prettier-plugin-packagejson": "2.3.0",
-    "rimraf": "3.0.2",
+    "prettier": "3.0.0",
+    "prettier-plugin-packagejson": "2.4.5",
+    "rimraf": "5.0.1",
     "rollup": "2.79.1",
     "rollup-plugin-auto-external": "2.0.0",
-    "rollup-plugin-dts": "4.2.3",
+    "rollup-plugin-dts": "5.3.0",
     "rollup-plugin-gzip": "3.1.0",
-    "rollup-plugin-terser": "7.0.2",
+    "rollup-plugin-terser": "6.1.0",
     "ts-node": "10.9.1",
-    "tsd": "0.25.0",
-    "tslib": "2.4.1",
-    "typedoc": "0.23.23",
-    "typescript": "4.9.4"
+    "tsd": "0.28.1",
+    "tslib": "2.6.0",
+    "typedoc": "0.24.8",
+    "typescript": "5.1.6"
   },
   "packageManager": "yarn@3.2.4",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   }
 }

src/helpers.ts

@@ -233,7 +233,7 @@ export function toIterable<T>(i: unknown) {
 export function reverse<T>(input: ArrayLike<T>): Iterable<T> {
     if (typeof input?.length !== 'number') {
         throw new TypeError(
-            `An array-like value was expected: ${JSON.stringify(input)}`
+            `An array-like value was expected: ${JSON.stringify(input)}`,
         );
     }
     return {
@@ -261,7 +261,7 @@ function toSyncIterable<T>(value: T): Iterable<T> {
  * Create an async iterable that has the awaited given value as its only element.
  */
 function toSingleAsyncIterable<T>(
-    asyncValue: PromiseLike<T>
+    asyncValue: PromiseLike<T>,
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {

src/ops/aggregate.ts

@@ -32,7 +32,7 @@ import {isPromiseLike} from '../typeguards';
  * @category Sync+Async
  */
 export function aggregate<T, R>(
-    cb: (arr: T[]) => R | Promise<R>
+    cb: (arr: T[]) => R | Promise<R>,
 ): Operation<T, R>;
 
 export function aggregate(...args: unknown[]) {
@@ -41,7 +41,7 @@ export function aggregate(...args: unknown[]) {
 
 function aggregateSync<T, R>(
     iterable: Iterable<T>,
-    cb: (arr: T[]) => R
+    cb: (arr: T[]) => R,
 ): Iterable<R> {
     return {
         [$S](): Iterator<R> {
@@ -67,7 +67,7 @@ function aggregateSync<T, R>(
 
 function aggregateAsync<T, R>(
     iterable: AsyncIterable<T>,
-    cb: (arr: T[]) => R | Promise<R>
+    cb: (arr: T[]) => R | Promise<R>,
 ): AsyncIterable<R> {
     return {
         [$A](): AsyncIterator<R> {

src/ops/async/delay.ts

@@ -41,7 +41,7 @@ export function delay<T>(timeout: number): Operation<T, T>;
  * @category Async-only
  */
 export function delay<T>(
-    cb: (value: T, index: number, state: IterationState) => number
+    cb: (value: T, index: number, state: IterationState) => number,
 ): Operation<T, T>;
 
 export function delay(...args: unknown[]) {
@@ -52,12 +52,12 @@ function delayAsync<T>(
     iterable: AsyncIterable<T>,
     timeout:
         | number
-        | ((value: T, index: number, state: IterationState) => number)
+        | ((value: T, index: number, state: IterationState) => number),
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {
             const i = iterable[$A]();
-            if (timeout < 0) {
+            if (typeof timeout === 'number' && timeout < 0) {
                 return i; // use no delay;
             }
             const cb = typeof timeout === 'function' && timeout;
@@ -75,7 +75,7 @@ function delayAsync<T>(
                         return delay < 0
                             ? a
                             : new Promise((resolve) =>
-                                  setTimeout(() => resolve(a), delay)
+                                  setTimeout(() => resolve(a), delay),
                               );
                     });
                 },

src/ops/async/retry.ts

@@ -59,8 +59,8 @@ export function retry<T>(
     cb: (
         index: number,
         attempts: number,
-        state: IterationState
-    ) => boolean | Promise<boolean>
+        state: IterationState,
+    ) => boolean | Promise<boolean>,
 ): Operation<T, T>;
 
 export function retry(...args: unknown[]) {
@@ -74,8 +74,8 @@ function retryAsync<T>(
         | ((
               index: number,
               attempts: number,
-              state: IterationState
-          ) => boolean | Promise<boolean>)
+              state: IterationState,
+          ) => boolean | Promise<boolean>),
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {
@@ -102,7 +102,7 @@ function retryAsync<T>(
                                 const r = cb(
                                     index,
                                     attempts++,
-                                    state
+                                    state,
                                 ) as Promise<boolean>;
                                 return isPromiseLike(r) ? r.then(b) : b(r);
                             }
@@ -111,7 +111,7 @@ function retryAsync<T>(
                                 return this.next();
                             }
                             return Promise.reject(e);
-                        }
+                        },
                     );
                 },
             };

src/ops/async/throttle.ts

@@ -27,7 +27,7 @@ import {createOperation, throwOnSync} from '../../utils';
  * @category Async-only
  */
 export function throttle<T>(
-    cb: (value: T, index: number, state: IterationState) => Promise<any>
+    cb: (value: T, index: number, state: IterationState) => Promise<any>,
 ): Operation<T, T>;
 
 export function throttle(...args: unknown[]) {
@@ -36,7 +36,7 @@ export function throttle(...args: unknown[]) {
 
 function throttleAsync<T>(
     iterable: AsyncIterable<T>,
-    cb: (value: T, index: number, state: IterationState) => Promise<any>
+    cb: (value: T, index: number, state: IterationState) => Promise<any>,
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {
@@ -50,7 +50,7 @@ function throttleAsync<T>(
                         .then((a) =>
                             a.done
                                 ? a
-                                : cb(a.value, index++, state).then(() => a)
+                                : cb(a.value, index++, state).then(() => a),
                         );
                 },
             };

src/ops/async/wait-race.ts

@@ -66,7 +66,7 @@ export function waitRace(...args: unknown[]) {
 // implemented by: https://stackoverflow.com/users/1048572/bergi
 export function waitRaceAsync<T>(
     iterable: AsyncIterable<Promise<T> | T>,
-    cacheSize: number
+    cacheSize: number,
 ): AsyncIterable<T> {
     cacheSize = cacheSize >= 2 ? cacheSize : 1;
     return {
@@ -75,7 +75,7 @@ export function waitRaceAsync<T>(
             let finished = false;
             // resolvers for currently active tasks, that are racing to remove and call the first one:
             const resolvers: ((
-                res: IteratorResult<T> | Promise<never>
+                res: IteratorResult<T> | Promise<never>,
             ) => void)[] = [];
             // cache of promises to be resolved or to be returned by `.next()` to the destination:
             const promises: Promise<IteratorResult<T>>[] = [];
@@ -101,10 +101,10 @@ export function waitRaceAsync<T>(
                                         },
                                         () => {
                                             resolvers.shift()?.(
-                                                promise as Promise<never>
+                                                promise as Promise<never>,
                                             );
                                             kickOffMore();
-                                        }
+                                        },
                                     );
                                 } else {
                                     resolvers.shift()?.(a as IteratorResult<T>);
@@ -115,9 +115,9 @@ export function waitRaceAsync<T>(
                                 // handle rejections from calling `i.next()`
                                 resolvers.shift()?.(Promise.reject(err));
                                 finished = true;
-                            }
+                            },
                         );
-                    })
+                    }),
                 );
             }
             function kickOffMore() {

src/ops/async/wait.ts

@@ -56,7 +56,7 @@ export function wait() {
 }
 
 export function waitAsync<T>(
-    iterable: AsyncIterable<Promise<T> | T>
+    iterable: AsyncIterable<Promise<T> | T>,
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {

src/ops/catch-error.ts

@@ -55,7 +55,7 @@ import {createOperation} from '../utils';
  * @category Diagnostics
  */
 export function catchError<T>(
-    cb: (error: any, ctx: IErrorContext<T>) => void
+    cb: (error: any, ctx: IErrorContext<T>) => void,
 ): Operation<T, T>;
 
 export function catchError(...args: unknown[]) {
@@ -64,7 +64,7 @@ export function catchError(...args: unknown[]) {
 
 function catchErrorSync<T>(
     iterable: Iterable<T>,
-    cb: (error: any, ctx: IErrorContext<T>) => void
+    cb: (error: any, ctx: IErrorContext<T>) => void,
 ): Iterable<T> {
     return {
         [$S](): Iterator<T> {
@@ -111,7 +111,7 @@ function catchErrorSync<T>(
 
 function catchErrorAsync<T>(
     iterable: AsyncIterable<T>,
-    cb: (error: any, ctx: IErrorContext<T>) => void
+    cb: (error: any, ctx: IErrorContext<T>) => void,
 ): AsyncIterable<T> {
     return {
         [$A](): AsyncIterator<T> {
@@ -144,7 +144,7 @@ function catchErrorAsync<T>(
                                 },
                             });
                             return emitted ? {value, done: false} : this.next();
-                        }
+                        },
                     );
                 },
             };

src/ops/concurrency-fork.ts

@@ -77,7 +77,7 @@ export interface IConcurrencyWork<T, R> {
  * @category Sync+Async
  */
 export function concurrencyFork<T, R = T>(
-    work: IConcurrencyWork<T, R>
+    work: IConcurrencyWork<T, R>,
 ): Operation<T, R>;
 
 export function concurrencyFork(...args: unknown[]) {
@@ -86,7 +86,7 @@ export function concurrencyFork(...args: unknown[]) {
 
 function concurrencyForkSync<T, R>(
     iterable: Iterable<T>,
-    work: IConcurrencyWork<T, R>
+    work: IConcurrencyWork<T, R>,
 ): Iterable<R> {
     try {
         return work.onSync?.(iterable) ?? (iterable as Iterable<any>);
@@ -110,7 +110,7 @@ function concurrencyForkSync<T, R>(
 
 function concurrencyForkAsync<T, R>(
     iterable: AsyncIterable<T>,
-    work: IConcurrencyWork<T, R>
+    work: IConcurrencyWork<T, R>,
 ): AsyncIterable<R> {
     try {
         return work.onAsync?.(iterable) ?? (iterable as AsyncIterable<any>);

src/ops/consume.ts

@@ -27,7 +27,7 @@ import {isPromiseLike} from '../typeguards';
  * @category Sync+Async
  */
 export function consume<T, R>(
-    consumer: (data: UnknownIterable<T>, sync: boolean) => R | Promise<R>
+    consumer: (data: UnknownIterable<T>, sync: boolean) => R | Promise<R>,
 ): Operation<T, R>;
 
 export function consume(...args: unknown[]) {
@@ -36,7 +36,7 @@ export function consume(...args: unknown[]) {
 
 function consumeSync<T, R>(
     iterable: Iterable<T>,
-    consumer: (data: Iterable<T>, sync: boolean) => R
+    consumer: (data: Iterable<T>, sync: boolean) => R,
 ): Iterable<R> {
     return {
         [$S](): Iterator<R> {
@@ -56,7 +56,7 @@ function consumeSync<T, R>(
 
 function consumeAsync<T, R>(
     iterable: AsyncIterable<T>,
-    consumer: (data: AsyncIterable<T>, sync: boolean) => R | Promise<R>
+    consumer: (data: AsyncIterable<T>, sync: boolean) => R | Promise<R>,
 ): AsyncIterable<R> {
     return {
         [$A](): AsyncIterator<R> {