@byloth/core 2.0.0-rc.2 → 2.0.0-rc.3

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

@@ -1,11 +1,14 @@
+import AggregatedAsyncIterator from "../aggregators/aggregated-async-iterator.js";
 import { ValueException } from "../exceptions/index.js";
 
 import type {
-    AsyncGeneratorFunction,
     GeneratorFunction,
+    AsyncGeneratorFunction,
+    MaybeAsyncGeneratorFunction,
     MaybeAsyncIteratee,
     MaybeAsyncReducer,
-    MaybeAsyncIterLike,
+    MaybeAsyncIterable,
+    MaybeAsyncIteratorLike,
     MaybeAsyncTypeGuardIteratee
 
 } from "./types.js";
@@ -23,8 +26,8 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     public constructor(iterator: AsyncIterator<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>)
+    public constructor(argument: MaybeAsyncIteratorLike<T, R, N> | MaybeAsyncGeneratorFunction<T, R, N>);
+    public constructor(argument: MaybeAsyncIteratorLike<T, R, N> | MaybeAsyncGeneratorFunction<T, R, N>)
     {
         if (argument instanceof Function)
         {
@@ -100,7 +103,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
             const result = await this._iterator.next();
 
             if (result.done) { return true; }
-            if (!(predicate(result.value, index))) { return false; }
+            if (!(await predicate(result.value, index))) { return false; }
 
             index += 1;
         }
@@ -115,7 +118,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
             const result = await this._iterator.next();
 
             if (result.done) { return false; }
-            if (predicate(result.value, index)) { return true; }
+            if (await predicate(result.value, index)) { return true; }
 
             index += 1;
         }
@@ -136,7 +139,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
                 const result = await iterator.next();
 
                 if (result.done) { return result.value; }
-                if (predicate(result.value, index)) { yield result.value; }
+                if (await predicate(result.value, index)) { yield result.value; }
 
                 index += 1;
             }
@@ -155,7 +158,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
                 const result = await iterator.next();
                 if (result.done) { return result.value; }
 
-                yield iteratee(result.value, index);
+                yield await iteratee(result.value, index);
 
                 index += 1;
             }
@@ -188,6 +191,94 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
         }
     }
 
+    public flatMap<V>(iteratee: MaybeAsyncIteratee<T, MaybeAsyncIterable<V>>): SmartAsyncIterator<V, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<V, R>(async function* ()
+        {
+            let index = 0;
+
+            while (true)
+            {
+                const result = await iterator.next();
+                if (result.done) { return result.value; }
+
+                const elements = await iteratee(result.value, index);
+
+                for await (const element of elements)
+                {
+                    yield element;
+                }
+
+                index += 1;
+            }
+        });
+    }
+
+    public drop(count: number): SmartAsyncIterator<T, R | void>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R | void>(async function* ()
+        {
+            let index = 0;
+
+            while (index < count)
+            {
+                const result = await iterator.next();
+                if (result.done) { return; }
+
+                index += 1;
+            }
+
+            while (true)
+            {
+                const result = await iterator.next();
+                if (result.done) { return result.value; }
+
+                yield result.value;
+            }
+        });
+    }
+    public take(limit: number): SmartAsyncIterator<T, R | void>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R | void>(async function* ()
+        {
+            let index = 0;
+
+            while (index < limit)
+            {
+                const result = await iterator.next();
+                if (result.done) { return result.value; }
+
+                yield result.value;
+
+                index += 1;
+            }
+
+            return;
+        });
+    }
+
+    public async find(predicate: MaybeAsyncIteratee<T, boolean>): Promise<T | void>
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+
+            if (result.done) { return; }
+            if (await predicate(result.value, index)) { return result.value; }
+
+            index += 1;
+        }
+    }
+
     public enumerate(): SmartAsyncIterator<[number, T], R>
     {
         return this.map((value, index) => [index, value]);
@@ -248,18 +339,19 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
         return this._iterator.next(...values);
     }
 
-    public async toArray(): Promise<T[]>
+    public groupBy<K extends PropertyKey>(iteratee: MaybeAsyncIteratee<T, K>): AggregatedAsyncIterator<K, T>
     {
-        const elements: T[] = [];
-
-        // eslint-disable-next-line no-constant-condition
-        while (true)
+        return new AggregatedAsyncIterator(this.map(async (element, index) =>
         {
-            const result = await this._iterator.next();
-            if (result.done) { return elements; }
+            const key = await iteratee(element, index);
 
-            elements.push(result.value);
-        }
+            return [key, element] as [K, T];
+        }));
+    }
+
+    public toArray(): Promise<T[]>
+    {
+        return Array.fromAsync(this as AsyncIterable<T>);
     }
 
     public get [Symbol.toStringTag]() { return "SmartAsyncIterator"; }

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

@@ -1,6 +1,7 @@
+import AggregatedIterator from "../aggregators/aggregated-iterator.js";
 import { ValueException } from "../exceptions/index.js";
 
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer, IterLike } from "./types.js";
+import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer, IteratorLike } from "./types.js";
 
 export default class SmartIterator<T, R = void, N = undefined> implements Iterator<T, R, N>
 {
@@ -9,11 +10,11 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     public return?: (value?: R) => IteratorResult<T, R>;
     public throw?: (error?: unknown) => IteratorResult<T, R>;
 
-    public constructor(iterable: Iterable<T>);
+    public constructor(iterable: Iterable<T, R, N>);
     public constructor(iterator: Iterator<T, R, N>);
     public constructor(generatorFn: GeneratorFunction<T, R, N>);
-    public constructor(argument: IterLike<T, R, N>);
-    public constructor(argument: IterLike<T, R, N>)
+    public constructor(argument: IteratorLike<T, R, N> | GeneratorFunction<T, R, N>);
+    public constructor(argument: IteratorLike<T, R, N> | GeneratorFunction<T, R, N>)
     {
         if (argument instanceof Function)
         {
@@ -28,8 +29,8 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             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); }
+        if (this._iterator.return) { this.return = (value) => this._iterator.return!(value); }
+        if (this._iterator.throw) { this.throw = (error) => this._iterator.throw!(error); }
     }
 
     public every(predicate: Iteratee<T, boolean>): boolean
@@ -130,6 +131,93 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         }
     }
 
+    public flatMap<V>(iteratee: Iteratee<T, Iterable<V>>): SmartIterator<V, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<V, R>(function* ()
+        {
+            let index = 0;
+
+            while (true)
+            {
+                const result = iterator.next();
+                if (result.done) { return result.value; }
+
+                const iterable = iteratee(result.value, index);
+                for (const value of iterable)
+                {
+                    yield value;
+                }
+
+                index += 1;
+            }
+        });
+    }
+
+    public drop(count: number): SmartIterator<T, R | void>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R | void>(function* ()
+        {
+            let index = 0;
+            while (index < count)
+            {
+                const result = iterator.next();
+                if (result.done) { return; }
+
+                index += 1;
+            }
+
+            while (true)
+            {
+                const result = iterator.next();
+                if (result.done) { return result.value; }
+
+                yield result.value;
+            }
+        });
+    }
+    public take(limit: number): SmartIterator<T, R | void>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R | void>(function* ()
+        {
+            let index = 0;
+            while (index < limit)
+            {
+                const result = iterator.next();
+                if (result.done) { return result.value; }
+
+                yield result.value;
+
+                index += 1;
+            }
+
+            return;
+        });
+    }
+
+    public find(predicate: Iteratee<T, boolean>): T | void;
+    public find<S extends T>(predicate: TypeGuardIteratee<T, S>): S | void;
+    public find(predicate: Iteratee<T, boolean>): T | void
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = this._iterator.next();
+
+            if (result.done) { return; }
+            if (predicate(result.value, index)) { return result.value; }
+
+            index += 1;
+        }
+    }
+
     public enumerate(): SmartIterator<[number, T], R>
     {
         return this.map((value, index) => [index, value]);
@@ -169,6 +257,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             index += 1;
         }
     }
+
     public forEach(iteratee: Iteratee<T>): void
     {
         let index = 0;
@@ -190,6 +279,16 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         return this._iterator.next(...values);
     }
 
+    public groupBy<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<K, T>
+    {
+        return new AggregatedIterator(this.map((element, index) =>
+        {
+            const key = iteratee(element, index);
+
+            return [key, element] as [K, T];
+        }));
+    }
+
     public toArray(): T[]
     {
         return Array.from(this as Iterable<T>);

package/src/models/iterators/types.ts

@@ -1,20 +1,31 @@
+/* eslint-disable max-len */
+
 import type { MaybePromise } from "../promises/types.js";
 
+export type MaybeAsyncIterable<T, R = void, N = undefined> = Iterable<T, R, N> | AsyncIterable<T, R, N>;
+export type MaybeAsyncIterator<T, R = void, N = undefined> = Iterator<T, R, N> | AsyncIterator<T, R, N>;
+export type MaybeAsyncGenerator<T, R = void, N = undefined> = Generator<T, R, N> | AsyncGenerator<T, R, N>;
+
 export type GeneratorFunction<T, R = void, N = undefined> = () => Generator<T, R, N>;
 export type AsyncGeneratorFunction<T, R = void, N = undefined> = () => AsyncGenerator<T, R, N>;
+export type MaybeAsyncGeneratorFunction<T, R = void, N = undefined> = () => MaybeAsyncGenerator<T, R, N>;
 
 export type Iteratee<T, R = void> = (value: T, index: number) => R;
+export type AsyncIteratee<T, R = void> = (value: T, index: number) => Promise<R>;
 export type MaybeAsyncIteratee<T, R = void> = (value: T, index: number) => MaybePromise<R>;
 
 export type TypeGuardIteratee<T, R extends T> = (value: T, index: number) => value is R;
-export type MaybeAsyncTypeGuardIteratee<T, R extends T> = (value: MaybePromise<T>, index: number) =>
-    value is MaybePromise<R>;
+
+// @ts-expect-error - This is an asyncronous type guard iteratee that guarantees the return value is a promise.
+export type AsyncTypeGuardIteratee<T, R extends T> = (value: T, index: number) => value is Promise<R>;
+
+// @ts-expect-error - This may be an asyncronous type guard iteratee that guarantees the return value may be a promise.
+export type MaybeAsyncTypeGuardIteratee<T, R extends T> = (value: T, index: number) => value is MaybePromise<R>;
 
 export type Reducer<T, A> = (accumulator: A, value: T, index: number) => A;
+export type AsyncReducer<T, A> = (accumulator: A, value: T, index: number) => Promise<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>;
+export type IteratorLike<T, R = void, N = undefined> = Iterable<T> | Iterator<T, R, N>;
+export type AsyncIteratorLike<T, R = void, N = undefined> = AsyncIterable<T> | AsyncIterator<T, R, N>;
+export type MaybeAsyncIteratorLike<T, R = void, N = undefined> = IteratorLike<T, R, N> | AsyncIteratorLike<T, R, N>;

package/src/models/promises/smart-promise.ts

@@ -2,6 +2,11 @@ import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "./types
 
 export default class SmartPromise<T = void> implements Promise<T>
 {
+    public static FromPromise<T>(promise: Promise<T>): SmartPromise<T>
+    {
+        return new SmartPromise((resolve, reject) => promise.then(resolve, reject));
+    }
+
     protected _isPending: boolean;
     protected _isFulfilled: boolean;
     protected _isRejected: boolean;

package/src/models/timers/clock.ts

@@ -6,7 +6,7 @@ import Publisher from "../publisher.js";
 
 export default class Clock extends GameLoop
 {
-    protected _publisher: Publisher<[number], void>;
+    protected _publisher: Publisher<[number]>;
 
     public constructor(fpsIfNotBrowser: number = TimeUnit.Second)
     {

package/src/models/timers/countdown.ts

@@ -9,7 +9,7 @@ import Publisher from "../publisher.js";
 export default class Countdown extends GameLoop
 {
     protected _deferrer?: DeferredPromise<void>;
-    protected _publisher: Publisher<[number], void>;
+    protected _publisher: Publisher<[number]>;
 
     protected _duration: number;
     public get duration(): number

package/src/models/types.ts

@@ -1,10 +1,10 @@
 export type {
-    KeyIteratee,
-    MaybeAsyncKeyIteratee,
-    KeyTypeGuardIteratee,
-    MaybeAsyncKeyTypeGuardIteratee,
-    KeyReducer,
-    MaybeAsyncKeyReducer
+    KeyedIteratee,
+    MaybeAsyncKeyedIteratee,
+    KeyedTypeGuardIteratee,
+    MaybeAsyncKeyedTypeGuardIteratee,
+    KeyedReducer,
+    MaybeAsyncKeyedReducer
 
 } from "./aggregators/types.js";
 
@@ -17,9 +17,9 @@ export type {
     MaybeAsyncTypeGuardIteratee,
     Reducer,
     MaybeAsyncReducer,
-    IterLike,
-    AsyncIterLike,
-    MaybeAsyncIterLike
+    IteratorLike,
+    AsyncIteratorLike,
+    MaybeAsyncIteratorLike
 
 } from "./iterators/types.js";
 

package/src/utils/async.ts

@@ -1,9 +1,9 @@
-export async function delay(milliseconds: number): Promise<void>
+export function delay(milliseconds: number): Promise<void>
 {
-    return new Promise<void>((resolve, reject) => setTimeout(resolve, milliseconds));
+    return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
 }
 
-export async function nextAnimationFrame(): Promise<void>
+export function nextAnimationFrame(): Promise<void>
 {
-    return new Promise<void>((resolve, reject) => requestAnimationFrame(() => resolve()));
+    return new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
 }

package/src/models/aggregators/aggregator.ts

@@ -1,46 +0,0 @@
-import AggregatedIterator from "./aggregated-iterator.js";
-
-import { SmartIterator } from "../iterators/index.js";
-import type { GeneratorFunction, Iteratee, IterLike, TypeGuardIteratee } from "../iterators/types.js";
-
-export default class Aggregator<T>
-{
-    protected _elements: SmartIterator<T>;
-
-    public constructor(iterable: Iterable<T>);
-    public constructor(iterator: Iterator<T>);
-    public constructor(generatorFn: GeneratorFunction<T>);
-    public constructor(argument: IterLike<T>);
-    public constructor(argument: IterLike<T>)
-    {
-        this._elements = new SmartIterator(argument);
-    }
-
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): Aggregator<S>;
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>
-    {
-        return new Aggregator(this._elements.filter(predicate));
-    }
-    public map<V>(iteratee: Iteratee<T, V>): Aggregator<V>
-    {
-        return new Aggregator(this._elements.map(iteratee));
-    }
-
-    public unique(): Aggregator<T>
-    {
-        return new Aggregator(this._elements.unique());
-    }
-
-    public groupBy<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<K, T>
-    {
-        return new AggregatedIterator(this._elements.map((element, index) =>
-        {
-            const key = iteratee(element, index);
-
-            return [key, element] as [K, T];
-        }));
-    }
-
-    public get [Symbol.toStringTag]() { return "Aggregator"; }
-}

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

@@ -1,56 +0,0 @@
-import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
-
-import { SmartAsyncIterator } from "../iterators/index.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: MaybeAsyncIterLike<T>);
-    public constructor(argument: MaybeAsyncIterLike<T>)
-    {
-        this._elements = new SmartAsyncIterator(argument);
-    }
-
-    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>;
-    public filter<S extends T>(predicate: MaybeAsyncTypeGuardIteratee<T, S>): AsyncAggregator<S>;
-    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>
-    {
-        return new AsyncAggregator(this._elements.filter(predicate));
-    }
-    public map<V>(iteratee: MaybeAsyncIteratee<T, V>): AsyncAggregator<V>
-    {
-        return new AsyncAggregator(this._elements.map(iteratee));
-    }
-
-    public unique(): AsyncAggregator<T>
-    {
-        return new AsyncAggregator(this._elements.unique());
-    }
-
-    public groupBy<K extends PropertyKey>(iteratee: MaybeAsyncIteratee<T, K>): AggregatedAsyncIterator<K, T>
-    {
-        return new AggregatedAsyncIterator(this._elements.map(async (element, index) =>
-        {
-            const key = await iteratee(element, index);
-
-            return [key, element] as [K, T];
-        }));
-    }
-
-    public get [Symbol.toStringTag]() { return "AsyncAggregator"; }
-}