extra-iterator 0.3.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # extra-iterator
 
-> ⚠ Still a work in progress; not ready for production — tests are missing and the documentation is lacking.
+> ⚠ Documentation is still a TODO
 
 ## Install
 

package/dist/index.d.ts

@@ -31,7 +31,7 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     flatMap<U>(callback: (value: T, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>): ExtraIterator<U>;
     flatten(): T extends Iterable<infer U> ? ExtraIterator<U> : never;
     groupBy<K extends string | symbol>(callbackfn: (value: T, index: number) => K): Record<K, T[]>;
-    uniq(keyProvider?: (value: T) => unknown): ExtraIterator<T>;
+    unique(keyProvider?: (value: T) => unknown): ExtraIterator<T>;
     compact(): ExtraIterator<Exclude<T, null | undefined>>;
     withEach(callbackfn: (value: T, index: number) => void): ExtraIterator<T>;
     first(): T | undefined;
@@ -52,5 +52,6 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     collect<U>(collectfn: ((iter: Iterable<T>) => U)): U;
     toSortedBy(...keys: (keyof T)[]): T[];
     count(): number;
+    uniqueness(mapper?: (value: T) => unknown): boolean;
 }
 export {};

package/dist/index.js

@@ -95,14 +95,14 @@ export class ExtraIterator extends Iterator {
         }
         return result;
     }
-    uniq(keyProvider = value => value) {
+    unique(keyProvider = value => value) {
         return ExtraIterator.from(function* () {
             const seen = new Set();
             for (let item; item = this.next(), !item.done;) {
                 const key = keyProvider(item.value);
                 if (!seen.has(key)) {
-                    yield item.value;
                     seen.add(key);
+                    yield item.value;
                 }
             }
         }.call(this));
@@ -273,4 +273,15 @@ export class ExtraIterator extends Iterator {
         }
         return count;
     }
+    uniqueness(mapper) {
+        const seen = new Set();
+        for (let next; next = this.next(), !next.done;) {
+            const value = mapper ? mapper(next.value) : next.value;
+            if (seen.has(value)) {
+                return false;
+            }
+            seen.add(value);
+        }
+        return true;
+    }
 }

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,121 @@
+import { ExtraIterator } from './index';
+import { describe, it } from 'node:test';
+import { expect } from 'expect';
+describe('ExtraIterator', () => {
+    it('should create an ExtraIterator from an array', () => {
+        const array = [1, 2, 3];
+        const iterator = ExtraIterator.from(array);
+        expect(iterator.toArray()).toEqual(array);
+    });
+    it('should zip two iterators', () => {
+        const a = ExtraIterator.from([1, 2, 3]);
+        const b = ExtraIterator.from(['a', 'b', 'c']);
+        const zipped = ExtraIterator.zip(a, b);
+        expect(zipped.toArray()).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    });
+    it('should count from 0 to a given number', () => {
+        const iterator = ExtraIterator.count(5);
+        expect(iterator.toArray()).toEqual([0, 1, 2, 3, 4]);
+    });
+    it('should repeat a value a given number of times', () => {
+        const iterator = ExtraIterator.repeat(3, 'x');
+        expect(iterator.toArray()).toEqual(['x', 'x', 'x']);
+    });
+    it('should filter values based on a predicate', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).filter(x => x % 2 === 0);
+        expect(iterator.toArray()).toEqual([2, 4]);
+    });
+    it('should map values using a callback function', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]).map(x => x * 2);
+        expect(iterator.toArray()).toEqual([2, 4, 6]);
+    });
+    it('should take a limited number of values', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).take(2);
+        expect(iterator.toArray()).toEqual([1, 2]);
+    });
+    it('should drop a given number of values', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).drop(2);
+        expect(iterator.toArray()).toEqual([3, 4]);
+    });
+    it('should flatten nested iterables', () => {
+        const iterator = ExtraIterator.from([[1, 2], [3, 4]]).flatten();
+        expect(iterator.toArray()).toEqual([1, 2, 3, 4]);
+    });
+    it('should return the first value', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]);
+        expect(iterator.first()).toBe(1);
+    });
+    it('should return the last value', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]);
+        expect(iterator.last()).toBe(3);
+    });
+    it('should return a value at a specific index', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]);
+        expect(iterator.at(1)).toBe(2);
+    });
+    it('should interpose a separator between values', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]).interpose(0);
+        expect(iterator.toArray()).toEqual([1, 0, 2, 0, 3]);
+    });
+    it('should chunk values into groups of a given size', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).chunk(2);
+        expect(iterator.toArray()).toEqual([[1, 2], [3, 4]]);
+    });
+    it('should remove duplicate values', () => {
+        const iterator = ExtraIterator.from([1, 2, 2, 3]).unique();
+        expect(iterator.toArray()).toEqual([1, 2, 3]);
+    });
+    it('should compact values by removing null and undefined', () => {
+        const iterator = ExtraIterator.from([1, null, 2, undefined, 3]).compact();
+        expect(iterator.toArray()).toEqual([1, 2, 3]);
+    });
+    it('should concatenate two iterators', () => {
+        const a = ExtraIterator.from([1, 2]);
+        const b = ExtraIterator.from([3, 4]);
+        const concatenated = a.concat(b);
+        expect(concatenated.toArray()).toEqual([1, 2, 3, 4]);
+    });
+    it('should prepend a value to the iterator', () => {
+        const iterator = ExtraIterator.from([2, 3]).prepend(1);
+        expect(iterator.toArray()).toEqual([1, 2, 3]);
+    });
+    it('should append a value to the iterator', () => {
+        const iterator = ExtraIterator.from([1, 2]).append(3);
+        expect(iterator.toArray()).toEqual([1, 2, 3]);
+    });
+    it('should take values while a predicate is true', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).takeWhile(x => x < 3);
+        expect(iterator.toArray()).toEqual([1, 2]);
+    });
+    it('should drop values while a predicate is true', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).dropWhile(x => x < 3);
+        expect(iterator.toArray()).toEqual([3, 4]);
+    });
+    it('should interleave two iterators', () => {
+        const a = ExtraIterator.from([1, 3]);
+        const b = ExtraIterator.from([2, 4]);
+        const interleaved = a.interleave(b);
+        expect(interleaved.toArray()).toEqual([1, 2, 3, 4]);
+    });
+    it('should splice values in the iterator', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).splice(1, 2, 5, 6);
+        expect(iterator.toArray()).toEqual([1, 5, 6, 4]);
+    });
+    it('should provide a default value if the iterator is empty', () => {
+        const iterator = ExtraIterator.empty().defaultIfEmpty(() => 42);
+        expect(iterator.toArray()).toEqual([42]);
+    });
+    it('should group values by a key', () => {
+        const iterator = ExtraIterator.from(['apple', 'banana', 'apricot']);
+        const grouped = iterator.groupBy(word => word[0]);
+        expect(grouped).toEqual({
+            a: ['apple', 'apricot'],
+            b: ['banana'],
+        });
+    });
+    it('should collect values using a custom collector', () => {
+        const iterator = ExtraIterator.from([1, 2, 3]);
+        const sum = iterator.collect(iter => Array.from(iter).reduce((a, b) => a + b, 0));
+        expect(sum).toBe(6);
+    });
+});

package/package.json

@@ -3,7 +3,7 @@
   "description": "An extension of the Iterator class with additional utility helper functions.",
   "author": "Leonardo Raele <leonardoraele@gmail.com>",
   "license": "MIT",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -13,13 +13,18 @@
     "dist"
   ],
   "scripts": {
-    "test": "node --test **/*.test.js",
+    "test": "run-s test:types test:unit",
+    "test:types": "tsc --noEmit",
+    "test:unit": "node --import=tsx --test **/*.test.ts",
     "build": "tsc",
     "prebuild": "rimraf dist",
-    "prepack": "npm run build"
+    "prepack": "run-s test build"
   },
   "devDependencies": {
+    "expect": "^29.7.0",
+    "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
+    "tsx": "^4.19.3",
     "typescript": "^5.8.3"
   },
   "keywords": [