@byloth/core 1.5.0-rc.7 → 1.5.0

package/src/models/aggregators/aggregated-async-iterator.ts

@@ -1,5 +1,6 @@
 import { SmartAsyncIterator } from "../iterators/index.js";
-import type { AsyncGeneratorFunction } from "../iterators/types.js";
+import type { AsyncGeneratorFunction, GeneratorFunction, MaybeAsyncIterLike } from "../iterators/types.js";
+import type { MaybePromise } from "../types.js";
 
 import ReducedIterator from "./reduced-iterator.js";
 import type { MaybeAsyncKeyIteratee, MaybeAsyncKeyTypeGuardIteratee, MaybeAsyncKeyReducer } from "./types.js";
@@ -8,11 +9,14 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 {
     protected _elements: SmartAsyncIterator<[K, T]>;
 
+    public constructor(iterable: Iterable<[K, T]>);
     public constructor(iterable: AsyncIterable<[K, T]>);
+    public constructor(iterator: Iterator<[K, T]>);
     public constructor(iterator: AsyncIterator<[K, T]>);
+    public constructor(generatorFn: GeneratorFunction<[K, T]>);
     public constructor(generatorFn: AsyncGeneratorFunction<[K, T]>);
-    public constructor(argument: AsyncIterable<[K, T]> | AsyncIterator<[K, T]> | AsyncGeneratorFunction<[K, T]>);
-    public constructor(argument: AsyncIterable<[K, T]> | AsyncIterator<[K, T]> | AsyncGeneratorFunction<[K, T]>)
+    public constructor(argument: MaybeAsyncIterLike<[K, T]>);
+    public constructor(argument: MaybeAsyncIterLike<[K, T]>)
     {
         this._elements = new SmartAsyncIterator(argument);
     }
@@ -66,7 +70,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     {
         const elements = this._elements;
 
-        return new AggregatedAsyncIterator(async function* ()
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
             const indexes = new Map<K, number>();
 
@@ -76,7 +80,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 
                 indexes.set(key, index + 1);
 
-                if (predicate(key, element, index)) { yield [key, element]; }
+                if (await predicate(key, element, index)) { yield [key, element]; }
             }
         });
     }
@@ -84,7 +88,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     {
         const elements = this._elements;
 
-        return new AggregatedAsyncIterator(async function* ()
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, V]>
         {
             const indexes = new Map<K, number>();
 
@@ -99,9 +103,9 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
         });
     }
     public async reduce(reducer: MaybeAsyncKeyReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue: (key: K) => A)
+    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue?: (key: K) => A)
+    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue?: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>
     {
         const accumulators = new Map<K, [number, A]>();
@@ -120,7 +124,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             else if (initialValue !== undefined)
             {
                 index = 0;
-                accumulator = initialValue(key);
+                accumulator = await initialValue(key);
             }
             else
             {
@@ -147,7 +151,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     {
         const elements = this._elements;
 
-        return new AggregatedAsyncIterator(async function* ()
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
             const keys = new Map<K, Set<T>>();
 

package/src/models/aggregators/aggregator.ts

@@ -1,7 +1,7 @@
 import AggregatedIterator from "./aggregated-iterator.js";
 
 import { SmartIterator } from "../iterators/index.js";
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee } from "../iterators/types.js";
+import type { GeneratorFunction, Iteratee, IterLike, TypeGuardIteratee } from "../iterators/types.js";
 
 export default class Aggregator<T>
 {
@@ -10,8 +10,8 @@ export default class Aggregator<T>
     public constructor(iterable: Iterable<T>);
     public constructor(iterator: Iterator<T>);
     public constructor(generatorFn: GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>)
+    public constructor(argument: IterLike<T>);
+    public constructor(argument: IterLike<T>)
     {
         this._elements = new SmartIterator(argument);
     }

package/src/models/aggregators/async-aggregator.ts

@@ -1,17 +1,27 @@
 import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
 
 import { SmartAsyncIterator } from "../iterators/index.js";
-import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncTypeGuardIteratee } from "../iterators/types.js";
+import type {
+    AsyncGeneratorFunction,
+    GeneratorFunction,
+    MaybeAsyncIterLike,
+    MaybeAsyncIteratee,
+    MaybeAsyncTypeGuardIteratee
+
+} from "../iterators/types.js";
 
 export default class AsyncAggregator<T>
 {
     protected _elements: SmartAsyncIterator<T>;
 
+    public constructor(iterable: Iterable<T>);
     public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: Iterator<T>);
     public constructor(iterator: AsyncIterator<T>);
+    public constructor(generatorFn: GeneratorFunction<T>);
     public constructor(generatorFn: AsyncGeneratorFunction<T>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>)
+    public constructor(argument: MaybeAsyncIterLike<T>);
+    public constructor(argument: MaybeAsyncIterLike<T>)
     {
         this._elements = new SmartAsyncIterator(argument);
     }

package/src/models/aggregators/reduced-iterator.ts

@@ -1,3 +1,4 @@
+import { TypeException } from "../exceptions/index.js";
 import { SmartIterator } from "../iterators/index.js";
 import type { GeneratorFunction } from "../iterators/types.js";
 
@@ -61,7 +62,7 @@ export default class ReducedIterator<K extends PropertyKey, T>
             const firstElement = this._elements.next();
             if (firstElement.done)
             {
-                throw new TypeError("Reduce of empty iterator with no initial value");
+                throw new TypeException("Reduce of empty iterator with no initial value");
             }
 
             index += 1;

package/src/models/aggregators/types.ts

@@ -7,7 +7,7 @@ export type MaybeAsyncKeyIteratee<K extends PropertyKey, T, R = void> = (key: K,
 export type KeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
     (key: K, value: T, index: number) => value is R;
 export type MaybeAsyncKeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
-    (key: K, value: MaybePromise<T>, index: number) => value is MaybePromise<R>;
+    (key: K, value: MaybePromise<T>, index: number) => value is Awaited<R>;
 
 export type KeyReducer<K extends PropertyKey, T, A> = (key: K, accumulator: A, value: T, index: number) => A;
 export type MaybeAsyncKeyReducer<K extends PropertyKey, T, A> =

package/src/models/iterators/smart-async-iterator.ts

@@ -1,4 +1,12 @@
-import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncReducer, TypeGuardIteratee } from "./types.js";
+import type {
+    AsyncGeneratorFunction,
+    GeneratorFunction,
+    MaybeAsyncIteratee,
+    MaybeAsyncReducer,
+    MaybeAsyncIterLike,
+    MaybeAsyncTypeGuardIteratee
+
+} from "./types.js";
 
 export default class SmartAsyncIterator<T, R = void, N = undefined> implements AsyncIterator<T, R, N>
 {
@@ -7,23 +15,73 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     public return?: (value?: R) => Promise<IteratorResult<T, R>>;
     public throw?: (error?: unknown) => Promise<IteratorResult<T, R>>;
 
+    public constructor(iterable: Iterable<T>);
     public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: Iterator<T, R, N>);
     public constructor(iterator: AsyncIterator<T, R, N>);
-    public constructor(generatorFn: () => AsyncGenerator<T, R, N>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>)
+    public constructor(generatorFn: GeneratorFunction<T, R, N>);
+    public constructor(generatorFn: AsyncGeneratorFunction<T, R, N>);
+    public constructor(argument: MaybeAsyncIterLike<T, R, N>);
+    public constructor(argument: MaybeAsyncIterLike<T, R, N>)
     {
         if (argument instanceof Function)
         {
-            this._iterator = argument();
+            const generator = argument();
+            if (Symbol.asyncIterator in generator)
+            {
+                this._iterator = generator;
+            }
+            else
+            {
+                this._iterator = (async function* ()
+                {
+                    let next: [] | [N] = [];
+
+                    while (true)
+                    {
+                        const result = generator.next(...next);
+                        if (result.done) { return result.value; }
+
+                        next = [yield result.value];
+                    }
+
+                })();
+            }
         }
         else if (Symbol.asyncIterator in argument)
         {
             this._iterator = argument[Symbol.asyncIterator]() as AsyncIterator<T, R, N>;
         }
+        else if (Symbol.iterator in argument)
+        {
+            const iterator = argument[Symbol.iterator]();
+            this._iterator = (async function* ()
+            {
+                while (true)
+                {
+                    const result = iterator.next();
+                    if (result.done) { return result.value; }
+
+                    yield result.value;
+                }
+
+            })();
+        }
         else
         {
-            this._iterator = argument;
+            this._iterator = (async function* ()
+            {
+                let next: [] | [N] = [];
+
+                while (true)
+                {
+                    const result: IteratorResult<T, R> = await argument.next(...next);
+                    if (result.done) { return result.value; }
+
+                    next = [yield result.value];
+                }
+
+            })();
         }
 
         if (this._iterator.return) { this.return = (value?: R) => this._iterator.return!(value); }
@@ -62,7 +120,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     }
 
     public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartAsyncIterator<T, S>;
+    public filter<S extends T>(predicate: MaybeAsyncTypeGuardIteratee<T, S>): SmartAsyncIterator<S, R>;
     public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>
     {
         const iterator = this._iterator;

package/src/models/iterators/smart-iterator.ts

@@ -1,4 +1,4 @@
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer } from "./types.js";
+import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer, IterLike } from "./types.js";
 
 export default class SmartIterator<T, R = void, N = undefined> implements Iterator<T, R, N>
 {
@@ -10,8 +10,8 @@ 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(argument: 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: IterLike<T, R, N>);
+    public constructor(argument: IterLike<T, R, N>)
     {
         if (argument instanceof Function)
         {
@@ -62,7 +62,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     }
 
     public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartIterator<T, S>;
+    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartIterator<S, R>;
     public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>
     {
         const iterator = this._iterator;

package/src/models/iterators/types.ts

@@ -12,3 +12,9 @@ export type MaybeAsyncTypeGuardIteratee<T, R extends T> = (value: MaybePromise<T
 
 export type Reducer<T, A> = (accumulator: A, value: T, index: number) => A;
 export type MaybeAsyncReducer<T, A> = (accumulator: A, value: T, index: number) => MaybePromise<A>;
+
+export type IterLike<T, R = void, N = undefined> = Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>;
+export type AsyncIterLike<T, R = void, N = undefined> =
+    AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>;
+
+export type MaybeAsyncIterLike<T, R = void, N = undefined> = IterLike<T, R, N> | AsyncIterLike<T, R, N>;

package/src/models/types.ts

@@ -1,4 +1,13 @@
-export type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./aggregators/types.js";
+export type {
+    KeyIteratee,
+    MaybeAsyncKeyIteratee,
+    KeyTypeGuardIteratee,
+    MaybeAsyncKeyTypeGuardIteratee,
+    KeyReducer,
+    MaybeAsyncKeyReducer
+
+} from "./aggregators/types.js";
+
 export type {
     GeneratorFunction,
     AsyncGeneratorFunction,
@@ -7,7 +16,10 @@ export type {
     TypeGuardIteratee,
     MaybeAsyncTypeGuardIteratee,
     Reducer,
-    MaybeAsyncReducer
+    MaybeAsyncReducer,
+    IterLike,
+    AsyncIterLike,
+    MaybeAsyncIterLike
 
 } from "./iterators/types.js";
 

package/src/utils/index.ts

@@ -3,7 +3,7 @@ import Random from "./random.js";
 export { delay, nextAnimationFrame } from "./async.js";
 export { dateDifference, dateRange, dateRound, DateUnit } from "./date.js";
 export { loadScript } from "./dom.js";
-export { count, range, shuffle, unique, zip } from "./iterator.js";
+export { chain, count, enumerate, range, shuffle, unique, zip } from "./iterator.js";
 export { average, hash, sum } from "./math.js";
 export { capitalize } from "./string.js";