@byloth/core 1.5.0-rc.7 → 1.5.0-rc.8

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,
+    MaybeAsyncIterables,
+    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: MaybeAsyncIterables<T>);
+    public constructor(argument: MaybeAsyncIterables<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,
+    MaybeAsyncIterables,
+    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: MaybeAsyncIterables<T, R, N>);
+    public constructor(argument: MaybeAsyncIterables<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, Iterables } 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: Iterables<T, R, N>);
+    public constructor(argument: Iterables<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 Iterables<T, R = void, N = undefined> = Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>;
+export type AsyncIterables<T, R = void, N = undefined> =
+    AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>;
+
+export type MaybeAsyncIterables<T, R = void, N = undefined> = Iterables<T, R, N> | AsyncIterables<T, R, N>;