error on commas

.eslintrc.json

@@ -25,7 +25,7 @@
     "/**/*.js"
   ],
   "rules": {
-    "@typescript-eslint/comma-dangle": "off",
+    "@typescript-eslint/comma-dangle": "error",
     "@typescript-eslint/quotes": ["error", "single"],
     "@typescript-eslint/semi": ["error", "always"],
     "@typescript-eslint/no-explicit-any": "off",

.prettierrc

@@ -4,6 +4,7 @@
     "bracketSpacing": false,
     "semi": true,
     "singleQuote": true,
+    "trailingComma": "none",
     "tabWidth": 4,
     "overrides": [
         {

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/async.ts

@@ -18,16 +18,16 @@ const input: AsyncIterable<number> = {
         return {
             async next(): Promise<IteratorResult<number>> {
                 return i.next();
-            },
+            }
         };
-    },
+    }
 };
 
 (async function testAsync() {
     const result = {
         ...(await testIterOps(toAsync(data))),
         ...(await testRXJS(input)),
-        ...(await testRXJS(input, true)),
+        ...(await testRXJS(input, true))
     };
     console.log(`Asynchronous test for ${maxItems.toExponential()} items:`);
     console.table(result);

benchmarks/src/sync.ts

@@ -14,7 +14,7 @@ for (let i = 0; i < maxItems; i++) {
     const result = {
         ...(await testIterOps(input)),
         ...(await testRXJS(input)),
-        ...(await testRXJS(input, true)),
+        ...(await testRXJS(input, true))
     };
     console.log(`Synchronous test for ${maxItems.toExponential()} items:`);
     console.table(result);

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;

rollup.config.ts

@@ -15,7 +15,7 @@ const common = {
     input: 'src/index.ts',
 
     output: {
-        sourcemap: false,
+        sourcemap: false
     },
 
     external: [],
@@ -24,8 +24,8 @@ const common = {
         annotations: true,
         moduleSideEffects: [],
         propertyReadSideEffects: false,
-        unknownGlobalSideEffects: false,
-    },
+        unknownGlobalSideEffects: false
+    }
 };
 
 /**
@@ -36,8 +36,8 @@ function getPlugins(tsconfig = 'tsconfig.build.json') {
         rollupPluginAutoExternal(),
         rollupPluginNodeResolve(),
         rollupPluginTypescript({
-            tsconfig,
-        }),
+            tsconfig
+        })
     ];
 }
 
@@ -75,10 +75,10 @@ const cjs = {
     output: {
         ...common.output,
         file: pkg.main,
-        format: 'cjs',
+        format: 'cjs'
     },
 
-    plugins: getPlugins(),
+    plugins: getPlugins()
 };
 
 /**
@@ -90,10 +90,10 @@ const esm = {
     output: {
         ...common.output,
         file: pkg.module,
-        format: 'esm',
+        format: 'esm'
     },
 
-    plugins: getPlugins(),
+    plugins: getPlugins()
 };
 
 /**
@@ -108,18 +108,18 @@ const web = {
         file: 'dist/web/iter-ops.min.js',
         format: 'iife',
         name: 'iterOps',
-        banner: copyright,
+        banner: copyright
     },
 
     plugins: [
         ...getPlugins('tsconfig.build.web.json'),
         rollupPluginTerser({
             output: {
-                comments: 'some',
-            },
+                comments: 'some'
+            }
         }),
-        rollupPluginGzip(),
-    ],
+        rollupPluginGzip()
+    ]
 };
 
 /**
@@ -131,18 +131,18 @@ const webModule = {
     output: {
         ...web.output,
         file: 'dist/web/iter-ops.min.mjs',
-        format: 'esm',
+        format: 'esm'
     },
 
     plugins: [
         ...getPlugins('tsconfig.build.web.json'),
         rollupPluginTerser({
             output: {
-                comments: 'some',
-            },
+                comments: 'some'
+            }
         }),
-        rollupPluginGzip(),
-    ],
+        rollupPluginGzip()
+    ]
 };
 
 /**
@@ -153,10 +153,10 @@ const dts = {
 
     output: {
         file: pkg.types,
-        format: 'esm',
+        format: 'esm'
     },
 
-    plugins: [rollupPluginDts()],
+    plugins: [rollupPluginDts()]
 };
 
 export default buildTypesOnly ? dts : [cjs, esm, web, webModule, dts];

src/helpers.ts

@@ -6,7 +6,7 @@ import {
     isObject,
     isPromiseLike,
     isIndexed,
-    isArrayLike,
+    isArrayLike
 } from './typeguards';
 import {$A, $S, UnknownIterable} from './types';
 import {indexedAsyncIterable} from './utils';
@@ -52,9 +52,9 @@ export function toAsync<T>(i: UnknownIterable<T>): AsyncIterable<T> {
             return {
                 next(): Promise<IteratorResult<T>> {
                     return Promise.resolve(it.next());
-                },
+                }
             };
-        },
+        }
     };
 }
 
@@ -179,9 +179,9 @@ export function toIterable<T>(i: unknown) {
                                     }
                                     started = true;
                                     return value;
-                                },
+                                }
                             };
-                        },
+                        }
                     };
                 }
             }
@@ -201,9 +201,9 @@ export function toIterable<T>(i: unknown) {
                             return k < i.length
                                 ? {value: i[k++] as T, done: false}
                                 : {value: undefined, done: true};
-                        },
+                        }
                     };
-                },
+                }
             };
         }
     }
@@ -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 {
@@ -244,9 +244,9 @@ export function reverse<T>(input: ArrayLike<T>): Iterable<T> {
                     return i
                         ? {value: input[--i], done: false}
                         : {value: undefined, done: true};
-                },
+                }
             };
-        },
+        }
     };
 }
 
@@ -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> {
@@ -271,16 +271,16 @@ function toSingleAsyncIterable<T>(
                     if (finished) {
                         return Promise.resolve({
                             value: undefined,
-                            done: true,
+                            done: true
                         });
                     }
                     finished = true;
                     return (asyncValue as Promise<T>).then((value: T) => ({
                         value,
-                        done: false,
+                        done: false
                     }));
-                },
+                }
             };
-        },
+        }
     };
 }

src/index.ts

@@ -8,7 +8,7 @@ export {
     UnknownIterable,
     UnknownIterableOrIterator,
     UnknownIterator,
-    Value,
+    Value
 } from './types';
 export {reverse, toAsync, toIterable} from './helpers';
 export {pipe, pipeSync, pipeAsync} from './pipe';
@@ -39,7 +39,7 @@ export {
     onEnd,
     IIterationSummary,
     IDuration,
-    IValueDuration,
+    IValueDuration
 } from './ops/on-end';
 export {page} from './ops/page';
 export {reduce} from './ops/reduce';

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> {
@@ -59,15 +59,15 @@ function aggregateSync<T, R>(
                     }
                     finished = true;
                     return {value: cb(arr), done: false};
-                },
+                }
             };
-        },
+        }
     };
 }
 
 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> {
@@ -86,16 +86,16 @@ function aggregateAsync<T, R>(
                             if (isPromiseLike(r)) {
                                 return r.then((value: R) => ({
                                     value,
-                                    done: false,
+                                    done: false
                                 }));
                             }
                             return {value: r, done: false};
                         }
                         arr.push(a.value);
                         return this.next();
                     });
-                },
+                }
             };
-        },
+        }
     };
 }