extra-iterator 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -2,13 +2,20 @@ interface ArrayIsh<T> {
     [index: number]: T;
     length: number;
 }
+export type ExtraIteratorSource<T> = Iterator<T, any, any> | Iterable<T, any, any> | ArrayIsh<T>;
 export declare class ExtraIterator<T> extends Iterator<T, any, any> {
-    static from<T>(source: Iterator<T, any, any> | Iterable<T, any, any> | ArrayIsh<T>): ExtraIterator<T>;
-    static fromKeys<T extends {}>(subject: T): ExtraIterator<keyof T>;
-    static fromValues<T extends {}>(subject: T): ExtraIterator<T[keyof T]>;
-    static fromEntries<T extends {}>(subject: T): ExtraIterator<[keyof T, T[keyof T]]>;
+    static from<T>(source: ExtraIteratorSource<T>): ExtraIterator<T>;
+    static zip<A, B>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>): ExtraIterator<[A, B]>;
+    static zip<A, B, C>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>): ExtraIterator<[A, B, C]>;
+    static zip<A, B, C, D>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>, d: ExtraIteratorSource<D>): ExtraIterator<[A, B, C, D]>;
+    static zip<A, B, C, D, E>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>, d: ExtraIteratorSource<D>, e: ExtraIteratorSource<E>): ExtraIterator<[A, B, C, D, E]>;
+    static zip<A, B, C, D, E, F>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>, d: ExtraIteratorSource<D>, e: ExtraIteratorSource<E>, f: ExtraIteratorSource<F>): ExtraIterator<[A, B, C, D, E, F]>;
+    static zip<A, B, C, D, E, F, G>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>, d: ExtraIteratorSource<D>, e: ExtraIteratorSource<E>, f: ExtraIteratorSource<F>, g: ExtraIteratorSource<G>): ExtraIterator<[A, B, C, D, E, F, G]>;
+    static zip<A, B, C, D, E, F, G, H>(a: ExtraIteratorSource<A>, b: ExtraIteratorSource<B>, c: ExtraIteratorSource<C>, d: ExtraIteratorSource<D>, e: ExtraIteratorSource<E>, f: ExtraIteratorSource<F>, g: ExtraIteratorSource<G>, h: ExtraIteratorSource<H>): ExtraIterator<[A, B, C, D, E, F, G, H]>;
+    static zip<T>(...iterables: ExtraIteratorSource<T>[]): ExtraIterator<T[]>;
     static empty<T = any>(): ExtraIterator<T>;
-    static count(max: number): ExtraIterator<number>;
+    static count(): ExtraIterator<number>;
+    static count(end: number): ExtraIterator<number>;
     static count(start: number, end: number): ExtraIterator<number>;
     static count(start: number, end: number, interval: number): ExtraIterator<number>;
     static repeat<T>(count: number, value: T): ExtraIterator<T>;
@@ -30,26 +37,20 @@ export declare class ExtraIterator<T> extends Iterator<T, any, any> {
     first(): T | undefined;
     last(): T | undefined;
     at(index: number): T | undefined;
-    appendMany(items: Iterable<T>): ExtraIterator<T>;
-    appendOne(item: T): ExtraIterator<T>;
+    concat(items: Iterable<T>): ExtraIterator<T>;
+    append(item: T): ExtraIterator<T>;
     prependMany(items: Iterable<T>): ExtraIterator<T>;
-    prependOne(item: T): ExtraIterator<T>;
+    prepend(item: T): ExtraIterator<T>;
     takeWhile(predicate: (value: T, index: number) => boolean): ExtraIterator<T>;
     dropWhile(predicate: (value: T, index: number) => boolean): ExtraIterator<T>;
     chunk(size: number): ExtraIterator<T[]>;
-    /**
-     * Pairs with another iterable to form an iterator of pairs.
-     * // TODO Expand to support more than 2 iterables
-     */
     zip<U>(other: Iterable<U>): ExtraIterator<[T, U]>;
-    /**
-     * Transforms from an iterator of pairs into a pair of iterators.
-     * // TODO Expand to support more than 2 iterables
-     */
-    unzip(): T extends [infer U, infer V] ? [ExtraIterator<U>, ExtraIterator<V>] : never;
+    interpose<U>(separator: U): ExtraIterator<T | U>;
+    interleave<U>(other: ExtraIteratorSource<U>): ExtraIterator<T | U>;
     splice(startIndex: number, deleteCount: number, ...newItems: T[]): ExtraIterator<T>;
-    with(index: number, value: T): ExtraIterator<T>;
+    defaultIfEmpty(provider: () => T): ExtraIterator<T>;
     collect<U>(collectfn: ((iter: Iterable<T>) => U)): U;
     toSortedBy(...keys: (keyof T)[]): T[];
+    count(): number;
 }
 export {};

package/dist/index.js

@@ -10,24 +10,21 @@ export class ExtraIterator extends Iterator {
         }
         return new ExtraIterator(source);
     }
-    static fromKeys(subject) {
-        return new ExtraIterator(Object.keys(subject));
-    }
-    static fromValues(subject) {
-        return new ExtraIterator(Object.values(subject));
-    }
-    static fromEntries(subject) {
-        return new ExtraIterator(Object.entries(subject));
+    static zip(...iterables) {
+        return new ExtraIterator(function* () {
+            for (let iterators = iterables.map(iterable => ExtraIterator.from(iterable)), results; results = iterators.map(iterator => iterator.next()),
+                results.every(value => !value.done);) {
+                yield results.map(value => value.value);
+            }
+        }().toArray());
     }
     static empty() {
         return new ExtraIterator([]);
     }
-    static count(start, end, interval) {
-        if (typeof end === 'undefined') {
-            end = start;
-            start = 0;
-        }
-        interval ??= 1;
+    static count(...args) {
+        const [start, end, interval] = args.length === 0 ? [0, Infinity, 1]
+            : args.length === 1 ? [0, args[0], 1]
+                : [args[0], args[1], args[2] ?? 1];
         return new ExtraIterator(function* () {
             for (let counter = start; counter < end; counter += interval) {
                 yield counter;
@@ -140,13 +137,13 @@ export class ExtraIterator extends Iterator {
             : index < 0 ? this.take(index).at(0)
                 : this.drop(index).first();
     }
-    appendMany(items) {
+    concat(items) {
         return ExtraIterator.from(function* () {
             yield* this;
             yield* items;
         }.call(this));
     }
-    appendOne(item) {
+    append(item) {
         return ExtraIterator.from(function* () {
             yield* this;
             yield item;
@@ -158,7 +155,7 @@ export class ExtraIterator extends Iterator {
             yield* this;
         }.call(this));
     }
-    prependOne(item) {
+    prepend(item) {
         return ExtraIterator.from(function* () {
             yield item;
             yield* this;
@@ -192,10 +189,6 @@ export class ExtraIterator extends Iterator {
             }
         }.call(this));
     }
-    /**
-     * Pairs with another iterable to form an iterator of pairs.
-     * // TODO Expand to support more than 2 iterables
-     */
     zip(other) {
         return ExtraIterator.from(function* () {
             const otherIterator = Iterator.from(other);
@@ -204,15 +197,31 @@ export class ExtraIterator extends Iterator {
             }
         }.call(this));
     }
-    /**
-     * Transforms from an iterator of pairs into a pair of iterators.
-     * // TODO Expand to support more than 2 iterables
-     */
-    unzip() {
-        return [
-            this.map(value => value[0]),
-            this.map(value => value[1]),
-        ];
+    interpose(separator) {
+        return ExtraIterator.from(function* () {
+            for (let next = this.next(); !next.done;) {
+                yield next.value;
+                next = this.next();
+                if (!next.done) {
+                    yield separator;
+                }
+            }
+        }.call(this));
+    }
+    interleave(other) {
+        return ExtraIterator.from(function* () {
+            const otherIterator = ExtraIterator.from(other);
+            for (let next, otherNext; next = this.next(),
+                otherNext = otherIterator.next(),
+                !next.done || !otherNext.done;) {
+                if (!next.done) {
+                    yield next.value;
+                }
+                if (!otherNext.done) {
+                    yield otherNext.value;
+                }
+            }
+        }.call(this));
     }
     splice(startIndex, deleteCount, ...newItems) {
         if (startIndex < 0) {
@@ -230,8 +239,17 @@ export class ExtraIterator extends Iterator {
             }
         }.call(this));
     }
-    with(index, value) {
-        return this.splice(index, 1, value);
+    defaultIfEmpty(provider) {
+        return ExtraIterator.from(function* () {
+            const result = this.next();
+            if (result.done) {
+                yield provider();
+            }
+            else {
+                yield result.value;
+                yield* this;
+            }
+        }.call(this));
     }
     collect(collectfn) {
         return collectfn(this);
@@ -248,4 +266,11 @@ export class ExtraIterator extends Iterator {
             return 0;
         });
     }
+    count() {
+        let count = 0;
+        for (let next; next = this.next(), !next.done;) {
+            count++;
+        }
+        return count;
+    }
 }

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