@byloth/core 1.2.0-rc.3 → 1.2.1-rc.1

package/src/models/index.ts

@@ -1,7 +1,18 @@
-import DeferredPromise from "./deferred-promise.js";
 import Exception from "./exception.js";
-import JsonStorage from "./json-storage.js";
 import SmartIterator from "./smart-iterator.js";
+import Aggregator, { AggregatedIterator, ReducedIterator } from "./aggregators/index.js";
+
+import DeferredPromise from "./deferred-promise.js";
+import JsonStorage from "./json-storage.js";
 import Subscribers from "./subscribers.js";
 
-export { DeferredPromise, Exception, JsonStorage, SmartIterator, Subscribers };
+export {
+    AggregatedIterator,
+    Aggregator,
+    DeferredPromise,
+    Exception,
+    JsonStorage,
+    ReducedIterator,
+    SmartIterator,
+    Subscribers
+};

package/src/models/smart-iterator.ts

@@ -10,26 +10,27 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     public constructor(iterable: Iterable<T>);
     public constructor(iterator: Iterator<T, R, N>);
     public constructor(generatorFn: GeneratorFunction<T, R, N>);
-    public constructor(iterable: Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>)
+    public constructor(argument: Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>);
+    public constructor(argument: Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>)
     {
-        if (iterable instanceof Function)
+        if (argument instanceof Function)
         {
-            this._iterator = iterable();
+            this._iterator = argument();
         }
-        else if (Symbol.iterator in iterable)
+        else if (Symbol.iterator in argument)
         {
-            this._iterator = iterable[Symbol.iterator]() as Iterator<T, R, N>;
+            this._iterator = argument[Symbol.iterator]() as Iterator<T, R, N>;
         }
         else
         {
-            this._iterator = iterable;
+            this._iterator = argument;
         }
 
         if (this._iterator.return) { this.return = (value?: R) => this._iterator.return!(value); }
         if (this._iterator.throw) { this.throw = (error?: unknown) => this._iterator.throw!(error); }
     }
 
-    public every(iteratee: Iteratee<T, boolean>): boolean
+    public every(predicate: Iteratee<T, boolean>): boolean
     {
         let index = 0;
 
@@ -39,12 +40,12 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             const result = this._iterator.next();
 
             if (result.done) { return true; }
-            if (!(iteratee(result.value, index))) { return false; }
+            if (!(predicate(result.value, index))) { return false; }
 
             index += 1;
         }
     }
-    public some(iteratee: Iteratee<T, boolean>): boolean
+    public some(predicate: Iteratee<T, boolean>): boolean
     {
         let index = 0;
 
@@ -54,56 +55,62 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             const result = this._iterator.next();
 
             if (result.done) { return false; }
-            if (iteratee(result.value, index)) { return true; }
+            if (predicate(result.value, index)) { return true; }
 
             index += 1;
         }
     }
 
-    public filter(iteratee: Iteratee<T, boolean>): SmartIterator<T, R, N>
+    public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>
     {
-        let index = 0;
         const iterator = this._iterator;
 
-        return new SmartIterator<T, R, N>({
-            *[Symbol.iterator]()
+        return new SmartIterator<T, R>(function* ()
+        {
+            let index = 0;
+
+            while (true)
             {
-                while (true)
-                {
-                    const result = iterator.next();
+                const result = iterator.next();
 
-                    if (result.done) { return result.value; }
-                    if (iteratee(result.value, index)) { yield result.value; }
+                if (result.done) { return result.value; }
+                if (predicate(result.value, index)) { yield result.value; }
 
-                    index += 1;
-                }
+                index += 1;
             }
         });
     }
     public map<V>(iteratee: Iteratee<T, V>): SmartIterator<V, R>
     {
-        let index = 0;
         const iterator = this._iterator;
 
-        return new SmartIterator<V, R>({
-            *[Symbol.iterator]()
+        return new SmartIterator<V, R>(function* ()
+        {
+            let index = 0;
+
+            while (true)
             {
-                while (true)
-                {
-                    const result = iterator.next();
-                    if (result.done) { return result.value; }
+                const result = iterator.next();
+                if (result.done) { return result.value; }
 
-                    yield iteratee(result.value, index);
+                yield iteratee(result.value, index);
 
-                    index += 1;
-                }
+                index += 1;
             }
         });
     }
-    public reduce<A>(reducer: Reducer<T, A>, initialValue: A): A
+    public reduce<A>(reducer: Reducer<T, A>, initialValue?: A): A
     {
         let index = 0;
         let accumulator = initialValue;
+        if (accumulator === undefined)
+        {
+            const result = this._iterator.next();
+            if (result.done) { throw new TypeError("Reduce of empty iterator with no initial value"); }
+
+            accumulator = (result.value as unknown) as A;
+            index += 1;
+        }
 
         // eslint-disable-next-line no-constant-condition
         while (true)
@@ -117,6 +124,45 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         }
     }
 
+    public enumerate(): SmartIterator<[number, T], R>
+    {
+        return this.map((value, index) => [index, value]);
+    }
+    public unique(): SmartIterator<T, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R>(function* ()
+        {
+            const values = new Set<T>();
+
+            while (true)
+            {
+                const result = iterator.next();
+
+                if (result.done) { return result.value; }
+                if (values.has(result.value)) { continue; }
+
+                values.add(result.value);
+
+                yield result.value;
+            }
+        });
+    }
+
+    public count(): number
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = this._iterator.next();
+            if (result.done) { return index; }
+
+            index += 1;
+        }
+    }
     public forEach(iteratee: Iteratee<T>): void
     {
         let index = 0;
@@ -140,7 +186,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
 
     public toArray(): T[]
     {
-        return [...this];
+        return Array.from(this as Iterable<T>);
     }
 
     public [Symbol.iterator](): SmartIterator<T, R, N> { return this; }

package/src/types.ts

@@ -1,4 +1,5 @@
-export type Constructor<T extends object, P extends unknown[] = []> = new (...args: P) => T;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Constructor<T extends object, P extends unknown[] = any[]> = new (...args: P) => T;
 
 export type GeneratorFunction<T, R = void, N = undefined> = () => Generator<T, R, N>;
 export type Iteratee<T, R = void> = (value: T, index: number) => R;

package/src/utils/iterator.ts

@@ -10,6 +10,21 @@ export function count<T>(elements: Iterable<T>): number
     return _count;
 }
 
+export function enumerate<T>(elements: Iterable<T>): SmartIterator<[number, T]>
+{
+    return new SmartIterator<[number, T]>(function* ()
+    {
+        let index = 0;
+
+        for (const element of elements)
+        {
+            yield [index, element];
+
+            index += 1;
+        }
+    });
+}
+
 export function range(end: number): SmartIterator<number>;
 export function range(start: number, end: number): SmartIterator<number>;
 export function range(start: number, end: number, step: number): SmartIterator<number>;
@@ -31,7 +46,7 @@ export function range(start: number, end?: number, step = 1): SmartIterator<numb
 
 export function shuffle<T>(iterable: Iterable<T>): T[]
 {
-    const array = [...iterable];
+    const array = Array.from(iterable);
 
     for (let index = array.length - 1; index > 0; index -= 1)
     {
@@ -47,13 +62,13 @@ export function unique<T>(elements: Iterable<T>): SmartIterator<T>
 {
     return new SmartIterator<T>(function* ()
     {
-        const seen = new Set<T>();
+        const values = new Set<T>();
 
         for (const element of elements)
         {
-            if (seen.has(element)) { continue; }
+            if (values.has(element)) { continue; }
 
-            seen.add(element);
+            values.add(element);
 
             yield element;
         }