extra-iterator 0.8.0 → 0.9.1

package/dist/index.d.ts

@@ -187,6 +187,23 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      *     // returns [[1, 2, 3], [4, 5, 6], [7]]
      */
     chunk(size: number): ExtraIterator<T[]>;
+    /**
+     * 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.
+     *
+     * The resulting iterator yields arrays of elements that belong to the same group.
+     *
+     * @example
+     *
+     * ExtraIterator.from([1, 1, 2, 3, 3, 3, 2, 2])
+     *     .chunkWith((lhs, rhs) => lhs === rhs)
+     *     .toArray()
+     *     // returns [[1, 1], [2], [3, 3, 3], [2, 2]]
+     */
+    chunkWith(predicate: (lhs: T, rhs: T, index: number, chunk: [T, ...T[]]) => boolean): ExtraIterator<T[]>;
     /**
      * Creates a new iterator that iterates on this iterator and the proviuded other iterator, yielding arrays of pairs
      * of elements from this iterator and the other.
@@ -343,7 +360,7 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
      * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
      * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
      */
-    uniqueness(mapper?: (value: T) => unknown): boolean;
+    testUnique(mapper?: (value: T) => unknown): boolean;
     /**
      * Lazily executes a function over each element of this iterator as the values are iterated.
      *

package/dist/index.js

@@ -137,7 +137,7 @@ export class ExtraIterator extends Iterator {
      * @example ExtraIterator.from([[1, 2], [3, 4]]).flatten().toArray() // returns [1, 2, 3, 4]
      */
     flatten() {
-        return this.flatMap(value => value);
+        return this.flatMap(value => Array.isArray(value) ? new ExtraIterator(value).flatten() : [value]);
     }
     /**
      * Creates a new iterator that yields the values of this iterator, but won't yield any duplicates.
@@ -311,6 +311,41 @@ export class ExtraIterator extends Iterator {
             }
         }.call(this));
     }
+    /**
+     * 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.
+     *
+     * The resulting iterator yields arrays of elements that belong to the same group.
+     *
+     * @example
+     *
+     * ExtraIterator.from([1, 1, 2, 3, 3, 3, 2, 2])
+     *     .chunkWith((lhs, rhs) => lhs === rhs)
+     *     .toArray()
+     *     // returns [[1, 1], [2], [3, 3, 3], [2, 2]]
+     */
+    chunkWith(predicate) {
+        return ExtraIterator.from(function* () {
+            const first = this.next();
+            if (first.done) {
+                return;
+            }
+            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);
+                }
+                else {
+                    yield chunk;
+                    chunk = [right.value];
+                }
+            }
+            yield chunk;
+        }.call(this));
+    }
     /**
      * Creates a new iterator that iterates on this iterator and the proviuded other iterator, yielding arrays of pairs
      * of elements from this iterator and the other.
@@ -615,7 +650,7 @@ export class ExtraIterator extends Iterator {
      * ExtraIterator.from([1, 2, 3]).uniqueness() // returns true
      * ExtraIterator.from([1, 2, 3, 1]).uniqueness() // returns false
      */
-    uniqueness(mapper) {
+    testUnique(mapper) {
         const seen = new Set();
         for (let next; next = this.next(), !next.done;) {
             const value = mapper ? mapper(next.value) : next.value;

package/dist/index.test.js

@@ -47,8 +47,8 @@ describe('ExtraIterator', () => {
         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]);
+        const iterator = ExtraIterator.from([0, [1, [2, [3, 4]]], [5, [6]], 7]).flatten();
+        expect(iterator.toArray()).toEqual([0, 1, 2, 3, 4, 5, 6, 7]);
     });
     it('should return the first value', () => {
         const iterator = ExtraIterator.from([1, 2, 3]);
@@ -164,6 +164,14 @@ describe('ExtraIterator', () => {
             expect(iter.sum()).toBe(26);
         });
     });
+    describe('chunkWith', () => {
+        it('should chunk using a comparer function', () => {
+            const result = ExtraIterator.from([1, 1, 2, 3, 3, 3, 2, 2])
+                .chunkWith((lhs, rhs) => lhs === rhs)
+                .toArray();
+            expect(result).toEqual([[1, 1], [2], [3, 3, 3], [2, 2]]);
+        });
+    });
     it('should create a chain of responsibility function', () => {
         const humanizeDuration = ExtraIterator.from([
             (next, miliseconds) => miliseconds < 1000 ? `${miliseconds} miliseconds` : next(miliseconds / 1000),

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.8.0",
+  "version": "0.9.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",