@byloth/core 2.0.0-rc.1 → 2.0.0-rc.10

package/src/models/callbacks/switchable-callback.ts

@@ -0,0 +1,108 @@
+import { KeyException, NotImplementedException, RuntimeException } from "../exceptions/index.js";
+
+import CallableObject from "./callable-object.js";
+import type { Callback } from "./types.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default class SwitchableCallback<T extends Callback<any[], any> = Callback> extends CallableObject<T>
+{
+    protected _callback: T;
+    protected _callbacks: Map<string, T>;
+
+    protected _isEnabled: boolean;
+    public get isEnabled(): boolean { return this._isEnabled; }
+
+    protected _key: string;
+    public get key(): string { return this._key; }
+
+    public readonly invoke: (...args: Parameters<T>) => ReturnType<T>;
+
+    public constructor()
+    {
+        const _default = () =>
+        {
+            throw new NotImplementedException(
+                "The `SwitchableCallback` has no callback defined yet. " +
+                "Did you forget to call the `register` method?"
+            );
+        };
+
+        super();
+
+        this._callback = ((_default) as unknown) as T;
+        this._callbacks = new Map<string, T>();
+
+        this._isEnabled = true;
+        this._key = "";
+
+        this.invoke = (...args: Parameters<T>): ReturnType<T> => this._callback(...args);
+    }
+
+    public enable(): void
+    {
+        if (!(this._key))
+        {
+            throw new KeyException(
+                "The `SwitchableCallback` has no callback defined yet. " +
+                "Did you forget to call the `register` method?"
+            );
+        }
+        if (this._isEnabled)
+        {
+            throw new RuntimeException("The `SwitchableCallback` is already enabled.");
+        }
+
+        this._callback = this._callbacks.get(this._key)!;
+        this._isEnabled = true;
+    }
+    public disable(): void
+    {
+        if (!(this._isEnabled))
+        {
+            throw new RuntimeException("The `SwitchableCallback` is already disabled.");
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this._callback = (() => { }) as T;
+        this._isEnabled = false;
+    }
+
+    public register(key: string, callback: T): void
+    {
+        if (this._callbacks.size === 0)
+        {
+            this._key = key;
+            this._callback = callback;
+        }
+        else if (this._callbacks.has(key))
+        {
+            throw new KeyException(`The key '${key}' has already been used for another callback.`);
+        }
+
+        this._callbacks.set(key, callback);
+    }
+    public unregister(key: string): void
+    {
+        if (!(this._callbacks.has(key)))
+        {
+            throw new KeyException(`The key '${key}' doesn't yet have any associated callback.`);
+        }
+
+        this._callbacks.delete(key);
+    }
+
+    public switch(key: string): void
+    {
+        if (!(this._callbacks.has(key)))
+        {
+            throw new KeyException(`The key '${key}' doesn't yet have any associated callback.`);
+        }
+
+        this._key = key;
+
+        if (this._isEnabled)
+        {
+            this._callback = this._callbacks.get(key)!;
+        }
+    }
+}

package/src/models/callbacks/types.ts

@@ -0,0 +1 @@
+export type Callback<A extends unknown[] = [], R = void> = (...args: A) => R;

package/src/models/exceptions/core.ts

@@ -39,7 +39,7 @@ export default class Exception extends Error
         }
     }
 
-    public get [Symbol.toStringTag]() { return "Exception"; }
+    public readonly [Symbol.toStringTag]: string = "Exception";
 }
 
 export class FatalErrorException extends Exception
@@ -55,7 +55,7 @@ export class FatalErrorException extends Exception
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "FatalErrorException"; }
+    public readonly [Symbol.toStringTag]: string = "FatalErrorException";
 }
 export class NotImplementedException extends FatalErrorException
 {
@@ -69,5 +69,5 @@ export class NotImplementedException extends FatalErrorException
         super(message, cause, name);
     }
 
-    public get [Symbol.toStringTag]() { return "NotImplementedException"; }
+    public readonly [Symbol.toStringTag]: string = "NotImplementedException";
 }

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

@@ -1,11 +1,11 @@
+import type { Interval } from "../core/types.js";
 import { isBrowser } from "../helpers.js";
-import { TimeUnit } from "../utils/date.js";
 
 import { FatalErrorException, RuntimeException } from "./exceptions/index.js";
 
 export default class GameLoop
 {
-    protected _handle?: number;
+    protected _handle?: number | Interval;
 
     protected _startTime: number;
     public get startTime(): number
@@ -27,7 +27,7 @@ export default class GameLoop
     protected _start: () => void;
     protected _stop: () => void;
 
-    public constructor(callback: FrameRequestCallback, fpsIfNotBrowser = 30)
+    public constructor(callback: FrameRequestCallback, msIfNotBrowser = 40)
     {
         this._startTime = 0;
         this._isRunning = false;
@@ -41,24 +41,22 @@ export default class GameLoop
                 this._handle = window.requestAnimationFrame(this._start);
             };
 
-            this._stop = () => window.cancelAnimationFrame(this._handle!);
+            this._stop = () => window.cancelAnimationFrame(this._handle as number);
         }
         else
         {
             // eslint-disable-next-line no-console
             console.warn(
                 "Not a browser environment detected. " +
-                `Using setInterval@${fpsIfNotBrowser}fps instead of requestAnimationFrame...`
+                `Using setInterval@${msIfNotBrowser}ms instead of requestAnimationFrame...`
             );
 
             this._start = () =>
             {
-                const delay = (TimeUnit.Second / fpsIfNotBrowser);
-
-                this._handle = (setInterval(() => callback(this.elapsedTime), delay) as unknown) as number;
+                this._handle = setInterval(() => callback(this.elapsedTime), msIfNotBrowser);
             };
 
-            this._stop = () => clearInterval(this._handle!);
+            this._stop = () => clearInterval(this._handle as Interval);
         }
     }
 
@@ -80,4 +78,6 @@ export default class GameLoop
         this._handle = undefined;
         this._isRunning = false;
     }
+
+    public readonly [Symbol.toStringTag]: string = "GameLoop";
 }

package/src/models/index.ts

@@ -1,12 +1,11 @@
 export {
-    Aggregator,
-    AsyncAggregator,
     AggregatedIterator,
     AggregatedAsyncIterator,
     ReducedIterator
 
 } from "./aggregators/index.js";
 
+export { CallableObject, Publisher, SmartFunction, SwitchableCallback } from "./callbacks/index.js";
 export {
     Exception,
     FatalErrorException,
@@ -30,10 +29,8 @@ import GameLoop from "./game-loop.js";
 
 export { SmartIterator, SmartAsyncIterator } from "./iterators/index.js";
 export { JSONStorage } from "./json/index.js";
-export { DeferredPromise, SmartPromise, TimedPromise } from "./promises/index.js";
-
-import Publisher from "./publisher.js";
+export { DeferredPromise, LongRunningTask, SmartPromise, Thenable, TimedPromise } from "./promises/index.js";
 
 export { Clock, Countdown } from "./timers/index.js";
 
-export { GameLoop, Publisher };
+export { GameLoop };

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; }
 }