extra-iterator 0.11.0 → 0.11.1

package/dist/index.d.ts

@@ -163,11 +163,11 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      * @example
      *
      * ExtraIterator.from([4, 5, 6])
-     *     .prependMany([1, 2, 3])
+     *     .prependAll([1, 2, 3])
      *     .toArray()
      *     // returns [1, 2, 3, 4, 5, 6]
      */
-    prependMany<U>(items: Iterable<U>): ExtraIterator<T | U>;
+    prependAll<U>(items: Iterable<U>): ExtraIterator<T | U>;
     /**
      * Creates a new iterator that invokes the provided callback function over each element of this iterator and yields
      * the elements for which the callback returns `true`, only for as long as the callback returns `true`.
@@ -213,9 +213,9 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     /**
      * Groups the elements in this iterator into groups of variable size.
      *
-     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. It should
-     * return `true` if the elements should belong to the same group, or `false` if they should belong to different
-     * groups.
+     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. The
+     * function should return `true` if the elements should belong to the same group, or `false` if they should belong
+     * to different groups.
      *
      * The resulting iterator yields arrays of elements that belong to the same group.
      *
@@ -292,7 +292,8 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      */
     splice(startIndex: number, deleteCount: number, ...newItems: T[]): ExtraIterator<T>;
     /**
-     * Returns an iterator the provided element if this iterator is empty; otherwise, it returns this iterator.
+     * If this iterator is empty, returns an iterator with the provided element as its only element; otherwise, it
+     * returns a copy of this iterator.
      */
     defaultIfEmpty(provider: () => T): ExtraIterator<T>;
     /**
@@ -380,8 +381,8 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      *
      * @example
      *
-     * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
-     * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
+     * ExtraIterator.from([1, 2, 3]).testUnique() // returns true
+     * ExtraIterator.from([1, 2, 3, 1]).testUnique() // returns false
      */
     testUnique(mapper?: (value: T) => unknown): boolean;
     /**

package/dist/index.js

@@ -271,11 +271,11 @@ export class ExtraIterator extends Iterator {
      * @example
      *
      * ExtraIterator.from([4, 5, 6])
-     *     .prependMany([1, 2, 3])
+     *     .prependAll([1, 2, 3])
      *     .toArray()
      *     // returns [1, 2, 3, 4, 5, 6]
      */
-    prependMany(items) {
+    prependAll(items) {
         return ExtraIterator.from(function* () {
             yield* items;
             yield* this;
@@ -351,9 +351,9 @@ export class ExtraIterator extends Iterator {
     /**
      * Groups the elements in this iterator into groups of variable size.
      *
-     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. It should
-     * return `true` if the elements should belong to the same group, or `false` if they should belong to different
-     * groups.
+     * This method calls the provided predicate function for each pair of adjacent elements in this iterator. The
+     * function should return `true` if the elements should belong to the same group, or `false` if they should belong
+     * to different groups.
      *
      * The resulting iterator yields arrays of elements that belong to the same group.
      *
@@ -373,7 +373,7 @@ export class ExtraIterator extends Iterator {
             let chunk = [first.value];
             for (let left = first, right, index = 0; right = this.next(), !right.done; left = right, index++) {
                 if (predicate(left.value, right.value, index, chunk)) {
-                    chunk.push(left.value);
+                    chunk.push(right.value);
                 }
                 else {
                     yield chunk;
@@ -489,8 +489,7 @@ export class ExtraIterator extends Iterator {
      */
     splice(startIndex, deleteCount, ...newItems) {
         if (startIndex < 0) {
-            return ExtraIterator.from(this.toArray()
-                .toSpliced(startIndex, deleteCount, ...newItems));
+            return ExtraIterator.from(this.toArray().toSpliced(startIndex, deleteCount, ...newItems));
         }
         return ExtraIterator.from(function* () {
             for (let index = 0, next; next = this.next(), !next.done; index++) {
@@ -504,7 +503,8 @@ export class ExtraIterator extends Iterator {
         }.call(this));
     }
     /**
-     * Returns an iterator the provided element if this iterator is empty; otherwise, it returns this iterator.
+     * If this iterator is empty, returns an iterator with the provided element as its only element; otherwise, it
+     * returns a copy of this iterator.
      */
     defaultIfEmpty(provider) {
         return ExtraIterator.from(function* () {
@@ -528,9 +528,6 @@ export class ExtraIterator extends Iterator {
     loop(times = Infinity) {
         return ExtraIterator.from(function* () {
             const values = this.toArray();
-            if (values.length === 0) {
-                return;
-            }
             for (let i = 0; i < times; i++) {
                 yield* values;
             }
@@ -663,8 +660,8 @@ export class ExtraIterator extends Iterator {
      *
      * @example
      *
-     * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
-     * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
+     * ExtraIterator.from([1, 2, 3]).testUnique() // returns true
+     * ExtraIterator.from([1, 2, 3, 1]).testUnique() // returns false
      */
     testUnique(mapper) {
         const seen = new Set();

package/dist/index.test.js

@@ -7,12 +7,24 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from(array);
         expect(iterator.toArray()).toEqual(array);
     });
+    it('should create an ExtraIterator from an "array-like" object', () => {
+        const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+        const iterator = ExtraIterator.from(arrayLike);
+        expect(iterator.toArray()).toEqual(['a', 'b', 'c']);
+    });
     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);
+        const zipped = a.zip(b);
         expect(zipped.toArray()).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
     });
+    it('should zip three iterators', () => {
+        const a = ExtraIterator.from([1, 2, 3]);
+        const b = ExtraIterator.from(['a', 'b', 'c']);
+        const c = ExtraIterator.from([true, false, true]);
+        const zipped = ExtraIterator.zip(a, b, c);
+        expect(zipped.toArray()).toEqual([[1, 'a', true], [2, 'b', false], [3, 'c', true]]);
+    });
     it('should count from 0 to a given number', () => {
         const iterator = ExtraIterator.count().take(5);
         expect(iterator.toArray()).toEqual([0, 1, 2, 3, 4]);
@@ -42,6 +54,10 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).take(2);
         expect(iterator.toArray()).toEqual([1, 2]);
     });
+    it('should take the last values of the sequence', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).take(-2);
+        expect(iterator.toArray()).toEqual([3, 4]);
+    });
     it('should drop a given number of values', () => {
         const iterator = ExtraIterator.from([1, 2, 3, 4]).drop(2);
         expect(iterator.toArray()).toEqual([3, 4]);
@@ -54,9 +70,15 @@ describe(ExtraIterator.name, () => {
         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);
+    describe(ExtraIterator.prototype.last.name, () => {
+        it('should return the last value if the iterator is not empty', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]);
+            expect(iterator.last()).toBe(3);
+        });
+        it('should return undefined if the iterator is empty', () => {
+            const iterator = ExtraIterator.empty();
+            expect(iterator.last()).toBeUndefined();
+        });
     });
     it('should return a value at a specific index', () => {
         const iterator = ExtraIterator.from([1, 2, 3]);
@@ -92,6 +114,10 @@ describe(ExtraIterator.name, () => {
         const iterator = ExtraIterator.from([2, 3]).prepend(1);
         expect(iterator.toArray()).toEqual([1, 2, 3]);
     });
+    it('should prepend multiple values to the iterator', () => {
+        const iterator = ExtraIterator.from([4, 5, 6]).prependAll([1, 2, 3]);
+        expect(iterator.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+    });
     it('should append a value to the iterator', () => {
         const iterator = ExtraIterator.from([1, 2]).append(3);
         expect(iterator.toArray()).toEqual([1, 2, 3]);
@@ -114,9 +140,19 @@ describe(ExtraIterator.name, () => {
         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 splice values from the end of the iterator', () => {
+        const iterator = ExtraIterator.from([1, 2, 3, 4]).splice(-3, 2, 5, 6);
+        expect(iterator.toArray()).toEqual([1, 5, 6, 4]);
+    });
+    describe('defaultIfEmpty', () => {
+        it('should provide a default value if the iterator is empty', () => {
+            const iterator = ExtraIterator.empty().defaultIfEmpty(() => 42);
+            expect(iterator.toArray()).toEqual([42]);
+        });
+        it('should relay the iterator itself if it is not empty', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]).defaultIfEmpty(() => 42);
+            expect(iterator.toArray()).toEqual([1, 2, 3]);
+        });
     });
     it('should group values by a key', () => {
         const iterator = ExtraIterator.from(['apple', 'banana', 'apricot']);
@@ -171,6 +207,16 @@ describe(ExtraIterator.name, () => {
                 .toArray();
             expect(result).toEqual([[1, 1], [2], [3, 3, 3], [2, 2]]);
         });
+        it('should chunk using a key selector function', () => {
+            const result = ExtraIterator.from(['apple', 'apricot', 'banana', 'avocado'])
+                .chunkWith((lhs, rhs) => lhs[0] === rhs[0])
+                .toArray();
+            expect(result).toEqual([['apple', 'apricot'], ['banana'], ['avocado']]);
+        });
+        it('should build an empty iterator for an empty iterator', () => {
+            const result = ExtraIterator.from([]).chunkWith((lhs, rhs) => lhs === rhs).toArray();
+            expect(result).toEqual([]);
+        });
     });
     it('should create a chain of responsibility function', () => {
         const humanizeDuration = ExtraIterator.from([
@@ -191,9 +237,18 @@ describe(ExtraIterator.name, () => {
         const chain = handlers.toChainOfResponsibilityFunction(next => next());
         expect(() => chain()).toThrow();
     });
-    it('should repeat values', () => {
-        const iterator = ExtraIterator.from([1, 2, 3]).loop(3);
-        expect(iterator.toArray()).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
+    describe(ExtraIterator.prototype.loop.name, () => {
+        it('should repeat values', () => {
+            const iterator = ExtraIterator.from([1, 2, 3]).loop(3);
+            expect(iterator.toArray()).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
+        });
+        it('should yield an empty iterator if the count is equal to or lower than 0', () => {
+            expect(ExtraIterator.from([1, 2, 3]).loop(0).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-1).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-3).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-4).toArray()).toEqual([]);
+            expect(ExtraIterator.from([1, 2, 3]).loop(-99999).toArray()).toEqual([]);
+        });
     });
     describe(ExtraIterator.range.name, () => {
         it('should iterate over ranges', () => {
@@ -216,4 +271,42 @@ describe(ExtraIterator.name, () => {
             expect(() => ExtraIterator.range(0, 10, { step: 0 }).toArray()).toThrow();
         });
     });
+    it('should count the number of elements in the iterator', () => {
+        expect(ExtraIterator.from([1, 2, 3]).count()).toBe(3);
+        expect(ExtraIterator.empty().count()).toBe(0);
+    });
+    describe(ExtraIterator.prototype.testUnique.name, () => {
+        it('should return true if all values are unique', () => {
+            expect(ExtraIterator.from([1, 2, 3]).testUnique()).toBe(true);
+        });
+        it('should return false if there are duplicate values', () => {
+            expect(ExtraIterator.from([1, 2, 2, 3]).testUnique()).toBe(false);
+        });
+        it('should return true for an empty iterator', () => {
+            expect(ExtraIterator.empty().testUnique()).toBe(true);
+        });
+    });
+    describe(ExtraIterator.prototype.withEach.name, () => {
+        it('should perform a side effect for each value', () => {
+            const sideEffects = [];
+            const iterator = ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            expect(iterator.toArray()).toEqual([1, 2, 3]);
+            expect(sideEffects).toEqual([1, 2, 3]);
+        });
+        it('should not perform side effects if the iterator is not consumed', () => {
+            const sideEffects = [];
+            ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            expect(sideEffects).toEqual([]);
+        });
+        it('should perform side effects even if the iterator is only partially consumed', () => {
+            const sideEffects = [];
+            const iterator = ExtraIterator.from([1, 2, 3]).withEach(x => void sideEffects.push(x));
+            iterator.next();
+            expect(sideEffects).toEqual([1]);
+        });
+        it('should perform side effects on objects', () => {
+            const iterator = ExtraIterator.from([{ value: 1 }, { value: 2 }, { value: 3 }]).withEach(obj => obj.value *= 2);
+            expect(iterator.toArray()).toEqual([{ value: 2 }, { value: 4 }, { value: 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.11.0",
+  "version": "0.11.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",