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

package/src/models/exceptions/index.ts

@@ -7,7 +7,7 @@ export class FileException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "FileException"; }
+    public readonly [Symbol.toStringTag]: string = "FileException";
 }
 export class FileExistsException extends FileException
 {
@@ -16,7 +16,7 @@ export class FileExistsException extends FileException
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "FileExistsException"; }
+    public readonly [Symbol.toStringTag]: string = "FileExistsException";
 }
 export class FileNotFoundException extends FileException
 {
@@ -25,7 +25,7 @@ export class FileNotFoundException extends FileException
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "FileNotFoundException"; }
+    public readonly [Symbol.toStringTag]: string = "FileNotFoundException";
 }
 
 export class KeyException extends Exception
@@ -35,7 +35,7 @@ export class KeyException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "KeyException"; }
+    public readonly [Symbol.toStringTag]: string = "KeyException";
 }
 export class NetworkException extends Exception
 {
@@ -44,7 +44,7 @@ export class NetworkException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "NetworkException"; }
+    public readonly [Symbol.toStringTag]: string = "NetworkException";
 }
 export class PermissionException extends Exception
 {
@@ -53,7 +53,7 @@ export class PermissionException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "PermissionException"; }
+    public readonly [Symbol.toStringTag]: string = "PermissionException";
 }
 export class ReferenceException extends Exception
 {
@@ -62,7 +62,7 @@ export class ReferenceException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "ReferenceException"; }
+    public readonly [Symbol.toStringTag]: string = "ReferenceException";
 }
 
 export class RuntimeException extends Exception
@@ -72,7 +72,7 @@ export class RuntimeException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "RuntimeException"; }
+    public readonly [Symbol.toStringTag]: string = "RuntimeException";
 }
 export class EnvironmentException extends RuntimeException
 {
@@ -81,7 +81,7 @@ export class EnvironmentException extends RuntimeException
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "EnvironmentException"; }
+    public readonly [Symbol.toStringTag]: string = "EnvironmentException";
 }
 
 export class TimeoutException extends Exception
@@ -91,7 +91,7 @@ export class TimeoutException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "TimeoutException"; }
+    public readonly [Symbol.toStringTag]: string = "TimeoutException";
 }
 export class TypeException extends Exception
 {
@@ -100,7 +100,7 @@ export class TypeException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "TypeException"; }
+    public readonly [Symbol.toStringTag]: string = "TypeException";
 }
 
 export class ValueException extends Exception
@@ -110,7 +110,7 @@ export class ValueException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "ValueException"; }
+    public readonly [Symbol.toStringTag]: string = "ValueException";
 }
 export class RangeException extends ValueException
 {
@@ -119,7 +119,7 @@ export class RangeException extends ValueException
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "RangeException"; }
+    public readonly [Symbol.toStringTag]: string = "RangeException";
 }
 
 export { Exception };

package/src/models/game-loop.ts

@@ -80,4 +80,6 @@ export default class GameLoop
         this._handle = undefined;
         this._isRunning = false;
     }
+
+    public readonly [Symbol.toStringTag]: string = "GameLoop";
 }

package/src/models/index.ts

@@ -1,6 +1,4 @@
 export {
-    Aggregator,
-    AsyncAggregator,
     AggregatedIterator,
     AggregatedAsyncIterator,
     ReducedIterator

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)
         {
@@ -94,13 +97,12 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             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;
         }
@@ -109,13 +111,12 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             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 +137,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 +156,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;
             }
@@ -176,7 +177,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
             index += 1;
         }
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = await this._iterator.next();
@@ -188,6 +188,93 @@ 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 | undefined>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R | undefined>(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 | undefined>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R | undefined>(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 | undefined>
+    {
+        let index = 0;
+
+        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]);
@@ -218,7 +305,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = await this._iterator.next();
@@ -231,7 +317,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = await this._iterator.next();
@@ -248,21 +333,22 @@ 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"; }
+    public readonly [Symbol.toStringTag]: string = "SmartAsyncIterator";
 
     public [Symbol.asyncIterator](): SmartAsyncIterator<T, R, N> { return this; }
 }

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,15 +29,14 @@ 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
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = this._iterator.next();
@@ -51,7 +51,6 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = this._iterator.next();
@@ -118,7 +117,6 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             index += 1;
         }
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = this._iterator.next();
@@ -130,6 +128,92 @@ 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 | undefined>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R | undefined>(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 | undefined>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R | undefined>(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 | undefined;
+    public find<S extends T>(predicate: TypeGuardIteratee<T, S>): S | undefined;
+    public find(predicate: Iteratee<T, boolean>): T | undefined
+    {
+        let index = 0;
+
+        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]);
@@ -160,7 +244,6 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = this._iterator.next();
@@ -169,11 +252,11 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             index += 1;
         }
     }
+
     public forEach(iteratee: Iteratee<T>): void
     {
         let index = 0;
 
-        // eslint-disable-next-line no-constant-condition
         while (true)
         {
             const result = this._iterator.next();
@@ -190,12 +273,22 @@ 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>);
     }
 
-    public get [Symbol.toStringTag]() { return "SmartIterator"; }
+    public readonly [Symbol.toStringTag]: string = "SmartIterator";
 
     public [Symbol.iterator](): SmartIterator<T, R, N> { return this; }
 }

package/src/models/iterators/types.ts

@@ -1,20 +1,30 @@
+
 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/json/json-storage.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-trailing-spaces */
 
 import { isBrowser } from "../../helpers.js";
 import { EnvironmentException } from "../exceptions/index.js";
@@ -45,7 +44,7 @@ export default class JSONStorage
             {
                 return JSON.parse(propertyValue);
             }
-            catch (error)
+            catch
             {
                 // eslint-disable-next-line no-console
                 console.warn(
@@ -252,5 +251,5 @@ export default class JSONStorage
         this._persistent.removeItem(propertyName);
     }
 
-    public get [Symbol.toStringTag]() { return "JSONStorage"; }
+    public readonly [Symbol.toStringTag]: string = "JSONStorage";
 }

package/src/models/json/types.ts

@@ -1,3 +1,7 @@
 export type JSONArray = JSONValue[];
-export type JSONObject = { [key: string]: JSONValue };
+
+// @ts-expect-error - This is a circular reference to itself.
+export type JSONObject = Record<string, JSONValue>;
+
+// @ts-expect-error - This is a circular reference to itself.
 export type JSONValue = boolean | number | string | null | JSONObject | JSONArray;

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

@@ -37,5 +37,5 @@ export default class DeferredPromise<T = void, F = T, R = never> extends SmartPr
         return this;
     }
 
-    public get [Symbol.toStringTag]() { return "DeferredPromise"; }
+    public readonly [Symbol.toStringTag]: string = "DeferredPromise";
 }

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;
@@ -59,5 +64,5 @@ export default class SmartPromise<T = void> implements Promise<T>
         return this._promise.finally(onFinally);
     }
 
-    public get [Symbol.toStringTag]() { return "SmartPromise"; }
+    public readonly [Symbol.toStringTag]: string = "SmartPromise";
 }

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

@@ -27,5 +27,5 @@ export default class TimedPromise<T = void> extends SmartPromise<T>
         });
     }
 
-    public get [Symbol.toStringTag]() { return "TimedPromise"; }
+    public readonly [Symbol.toStringTag]: string = "TimedPromise";
 }

package/src/models/publisher.ts

@@ -35,5 +35,5 @@ export default class Publisher<A extends unknown[] = [], R = void>
             .map((subscriber) => subscriber(...args));
     }
 
-    public get [Symbol.toStringTag]() { return "Publisher"; }
+    public readonly [Symbol.toStringTag]: string = "Publisher";
 }

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)
     {
@@ -44,4 +44,6 @@ export default class Clock extends GameLoop
             lastTick = elapsedTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Clock";
 }