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

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/promises/types.ts

@@ -1,3 +1,5 @@
+export type { LongRunningTaskOptions } from "./long-running-task.js";
+
 export type MaybePromise<T> = T | PromiseLike<T>;
 
 export type FulfilledHandler<T = void, R = T> = (value: T) => MaybePromise<R>;

package/src/models/timers/clock.ts

@@ -1,16 +1,23 @@
 import { TimeUnit } from "../../utils/date.js";
-
 import { RangeException, RuntimeException } from "../exceptions/index.js";
+
+import Publisher from "../callbacks/publisher.js";
 import GameLoop from "../game-loop.js";
-import Publisher from "../publisher.js";
+
+interface ClockEventMap
+{
+    start: () => void;
+    stop: () => void;
+    tick: (elapsedTime: number) => void;
+}
 
 export default class Clock extends GameLoop
 {
-    protected _publisher: Publisher<[number], void>;
+    protected _publisher: Publisher<ClockEventMap>;
 
-    public constructor(fpsIfNotBrowser = TimeUnit.Second)
+    public constructor(msIfNotBrowser: number = TimeUnit.Second)
     {
-        super((elapsedTime) => this._publisher.publish(elapsedTime), fpsIfNotBrowser);
+        super((elapsedTime) => this._publisher.publish("tick", elapsedTime), msIfNotBrowser);
 
         this._publisher = new Publisher();
     }
@@ -20,6 +27,8 @@ export default class Clock extends GameLoop
         if (this._isRunning) { throw new RuntimeException("The clock has already been started."); }
 
         super.start(elapsedTime);
+
+        this._publisher.publish("start");
     }
 
     public stop(): void
@@ -27,16 +36,27 @@ export default class Clock extends GameLoop
         if (!(this._isRunning)) { throw new RuntimeException("The clock hadn't yet started."); }
 
         super.stop();
+
+        this._publisher.publish("stop");
+    }
+
+    public onStart(callback: () => void): () => void
+    {
+        return this._publisher.subscribe("start", callback);
+    }
+    public onStop(callback: () => void): () => void
+    {
+        return this._publisher.subscribe("stop", callback);
     }
 
     public onTick(callback: (elapsedTime: number) => void, tickStep = 0): () => void
     {
         if (tickStep < 0) { throw new RangeException("The tick step must be a non-negative number."); }
-        if (tickStep === 0) { return this._publisher.subscribe(callback); }
+        if (tickStep === 0) { return this._publisher.subscribe("tick", callback); }
 
         let lastTick = 0;
 
-        return this._publisher.subscribe((elapsedTime: number) =>
+        return this._publisher.subscribe("tick", (elapsedTime: number) =>
         {
             if ((elapsedTime - lastTick) < tickStep) { return; }
 
@@ -44,4 +64,6 @@ export default class Clock extends GameLoop
             lastTick = elapsedTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Clock";
 }

package/src/models/timers/countdown.ts

@@ -1,15 +1,23 @@
 import { TimeUnit } from "../../utils/date.js";
 
 import { FatalErrorException, RangeException, RuntimeException } from "../exceptions/index.js";
-import { DeferredPromise } from "../promises/index.js";
+import { DeferredPromise, SmartPromise } from "../promises/index.js";
 
+import Publisher from "../callbacks/publisher.js";
 import GameLoop from "../game-loop.js";
-import Publisher from "../publisher.js";
+
+interface CountdownEventMap
+{
+    start: () => void;
+    stop: (reason: unknown) => void;
+    tick: (remainingTime: number) => void;
+    expire: () => void;
+}
 
 export default class Countdown extends GameLoop
 {
     protected _deferrer?: DeferredPromise<void>;
-    protected _publisher: Publisher<[number], void>;
+    protected _publisher: Publisher<CountdownEventMap>;
 
     protected _duration: number;
     public get duration(): number
@@ -22,55 +30,81 @@ export default class Countdown extends GameLoop
         return this._duration - this.elapsedTime;
     }
 
-    public constructor(duration: number, fpsIfNotBrowser = TimeUnit.Second)
+    public constructor(duration: number, msIfNotBrowser: number = TimeUnit.Second)
     {
-        const callback = (elapsedTime: number) =>
+        const callback = () =>
         {
-            this._duration -= elapsedTime;
-
             const remainingTime = this.remainingTime;
-            this._publisher.publish(remainingTime);
+            this._publisher.publish("tick", remainingTime);
 
-            if (remainingTime <= 0) { this.stop(); }
+            if (remainingTime <= 0)
+            {
+                this._deferrerStop();
+
+                this._publisher.publish("expire");
+            }
         };
 
-        super(callback, fpsIfNotBrowser);
+        super(callback, msIfNotBrowser);
 
         this._publisher = new Publisher();
         this._duration = duration;
     }
 
-    public start(remainingTime: number = this.duration): DeferredPromise<void>
+    protected _deferrerStop(reason?: unknown): void
+    {
+        if (!(this._isRunning)) { throw new RuntimeException("The countdown hadn't yet started."); }
+        if (!(this._deferrer)) { throw new FatalErrorException(); }
+
+        super.stop();
+
+        if (reason !== undefined) { this._deferrer.reject(reason); }
+        else { this._deferrer.resolve(); }
+
+        this._deferrer = undefined;
+    }
+
+    public start(remainingTime: number = this.duration): SmartPromise<void>
     {
         if (this._isRunning) { throw new RuntimeException("The countdown has already been started."); }
         if (this._deferrer) { throw new FatalErrorException(); }
 
-        this._deferrer = new DeferredPromise(() => this.stop());
+        this._deferrer = new DeferredPromise();
         super.start(this.duration - remainingTime);
 
+        this._publisher.publish("start");
+
         return this._deferrer;
     }
     public stop(reason?: unknown): void
     {
-        if (!(this._isRunning)) { throw new RuntimeException("The countdown hadn't yet started."); }
-        if (!(this._deferrer)) { throw new FatalErrorException(); }
+        this._deferrerStop(reason);
 
-        super.stop();
+        this._publisher.publish("stop", reason);
+    }
 
-        if (reason !== undefined) { this._deferrer.reject(reason); }
-        else { this._deferrer.resolve(); }
+    public onExpire(callback: () => void): () => void
+    {
+        return this._publisher.subscribe("expire", callback);
+    }
 
-        this._deferrer = undefined;
+    public onStart(callback: () => void): () => void
+    {
+        return this._publisher.subscribe("start", callback);
+    }
+    public onStop(callback: (reason?: unknown) => void): () => void
+    {
+        return this._publisher.subscribe("stop", callback);
     }
 
     public onTick(callback: (remainingTime: number) => void, tickStep = 0): () => void
     {
         if (tickStep < 0) { throw new RangeException("The tick step must be a non-negative number."); }
-        if (tickStep === 0) { return this._publisher.subscribe(callback); }
+        if (tickStep === 0) { return this._publisher.subscribe("tick", callback); }
 
         let lastTick = 0;
 
-        return this._publisher.subscribe((remainingTime: number) =>
+        return this._publisher.subscribe("tick", (remainingTime: number) =>
         {
             if ((lastTick - remainingTime) < tickStep) { return; }
 
@@ -78,4 +112,6 @@ export default class Countdown extends GameLoop
             lastTick = remainingTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Countdown";
 }

package/src/models/types.ts

@@ -1,25 +1,26 @@
 export type {
-    KeyIteratee,
-    MaybeAsyncKeyIteratee,
-    KeyTypeGuardIteratee,
-    MaybeAsyncKeyTypeGuardIteratee,
-    KeyReducer,
-    MaybeAsyncKeyReducer
+    KeyedIteratee,
+    MaybeAsyncKeyedIteratee,
+    KeyedTypeGuardIteratee,
+    MaybeAsyncKeyedTypeGuardIteratee,
+    KeyedReducer,
+    MaybeAsyncKeyedReducer
 
 } from "./aggregators/types.js";
 
 export type {
     GeneratorFunction,
     AsyncGeneratorFunction,
+    MaybeAsyncGeneratorFunction,
     Iteratee,
     MaybeAsyncIteratee,
     TypeGuardIteratee,
     MaybeAsyncTypeGuardIteratee,
     Reducer,
     MaybeAsyncReducer,
-    IterLike,
-    AsyncIterLike,
-    MaybeAsyncIterLike
+    IteratorLike,
+    AsyncIteratorLike,
+    MaybeAsyncIteratorLike
 
 } from "./iterators/types.js";
 
@@ -31,6 +32,7 @@ export type {
 } from "./json/types.js";
 
 export type {
+    LongRunningTaskOptions,
     MaybePromise,
     FulfilledHandler,
     RejectedHandler,
@@ -40,4 +42,4 @@ export type {
 
 } from "./promises/types.js";
 
-export type { Subscriber } from "./publisher.js";
+export type { Callback } from "./callbacks/types.js";

package/src/utils/async.ts

@@ -1,9 +1,14 @@
-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((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((resolve) => requestAnimationFrame(() => resolve()));
+}
+
+export function yieldToEventLoop(): Promise<void>
+{
+    return new Promise((resolve) => setTimeout(resolve));
 }

package/src/utils/date.ts

@@ -1,7 +1,10 @@
+
 import { SmartIterator } from "../models/index.js";
 
 export enum TimeUnit
 {
+    /* eslint-disable @typescript-eslint/prefer-literal-enum-member */
+
     Millisecond = 1,
     Second = 1000,
     Minute = 60 * Second,

package/src/utils/index.ts

@@ -1,6 +1,6 @@
 import Random from "./random.js";
 
-export { delay, nextAnimationFrame } from "./async.js";
+export { delay, nextAnimationFrame, yieldToEventLoop } from "./async.js";
 export { dateDifference, dateRange, dateRound, TimeUnit } from "./date.js";
 export { loadScript } from "./dom.js";
 export { chain, count, enumerate, range, shuffle, unique, zip } from "./iterator.js";

package/src/utils/random.ts

@@ -2,7 +2,7 @@ import { ValueException } from "../models/index.js";
 
 export default class Random
 {
-    public static Boolean(ratio: number = 0.5): boolean
+    public static Boolean(ratio = 0.5): boolean
     {
         return (Math.random() < ratio);
     }
@@ -38,6 +38,7 @@ export default class Random
         return elements[Random.Index(elements)];
     }
 
-    // eslint-disable-next-line no-useless-constructor
-    private constructor() { }
+    private constructor() { /* ... */ }
+
+    public readonly [Symbol.toStringTag]: string = "Random";
 }

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

package/src/models/publisher.ts

@@ -1,39 +0,0 @@
-import { ReferenceException } from "./exceptions/index.js";
-
-export type Subscriber<A extends unknown[] = [], R = void> = (...args: A) => R;
-
-export default class Publisher<A extends unknown[] = [], R = void>
-{
-    protected _subscribers: Subscriber<A, R>[];
-
-    public constructor()
-    {
-        this._subscribers = [];
-    }
-
-    public subscribe(subscriber: Subscriber<A, R>): () => void
-    {
-        this._subscribers.push(subscriber);
-
-        return () =>
-        {
-            const index = this._subscribers.indexOf(subscriber);
-            if (index < 0)
-            {
-                throw new ReferenceException("Unable to unsubscribe the required subscriber. " +
-                    "The subscription was already unsubscribed.");
-            }
-
-            this._subscribers.splice(index, 1);
-        };
-    }
-
-    public publish(...args: A): R[]
-    {
-        return this._subscribers
-            .slice()
-            .map((subscriber) => subscriber(...args));
-    }
-
-    public get [Symbol.toStringTag]() { return "Publisher"; }
-}