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

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,13 +6,17 @@ import Publisher from "../publisher.js";
 
 export default class Clock extends GameLoop
 {
-    protected _publisher: Publisher<[number]>;
+    protected _starter: Publisher;
+    protected _stopper: Publisher;
+    protected _ticker: Publisher<[number]>;
 
-    public constructor(fpsIfNotBrowser: number = TimeUnit.Second)
+    public constructor(msIfNotBrowser: number = TimeUnit.Second)
     {
-        super((elapsedTime) => this._publisher.publish(elapsedTime), fpsIfNotBrowser);
+        super((elapsedTime) => this._ticker.publish(elapsedTime), msIfNotBrowser);
 
-        this._publisher = new Publisher();
+        this._starter = new Publisher();
+        this._stopper = new Publisher();
+        this._ticker = new Publisher();
     }
 
     public start(elapsedTime = 0): void
@@ -20,6 +24,8 @@ export default class Clock extends GameLoop
         if (this._isRunning) { throw new RuntimeException("The clock has already been started."); }
 
         super.start(elapsedTime);
+
+        this._starter.publish();
     }
 
     public stop(): void
@@ -27,16 +33,27 @@ export default class Clock extends GameLoop
         if (!(this._isRunning)) { throw new RuntimeException("The clock hadn't yet started."); }
 
         super.stop();
+
+        this._stopper.publish();
+    }
+
+    public onStart(callback: () => void): () => void
+    {
+        return this._starter.subscribe(callback);
+    }
+    public onStop(callback: () => void): () => void
+    {
+        return this._stopper.subscribe(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._ticker.subscribe(callback); }
 
         let lastTick = 0;
 
-        return this._publisher.subscribe((elapsedTime: number) =>
+        return this._ticker.subscribe((elapsedTime: number) =>
         {
             if ((elapsedTime - lastTick) < tickStep) { return; }
 
@@ -44,4 +61,6 @@ export default class Clock extends GameLoop
             lastTick = elapsedTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Clock";
 }

package/src/models/timers/countdown.ts

@@ -9,7 +9,11 @@ import Publisher from "../publisher.js";
 export default class Countdown extends GameLoop
 {
     protected _deferrer?: DeferredPromise<void>;
-    protected _publisher: Publisher<[number]>;
+
+    protected _expirer: Publisher;
+    protected _starter: Publisher;
+    protected _stopper: Publisher<[unknown]>;
+    protected _ticker: Publisher<[number]>;
 
     protected _duration: number;
     public get duration(): number
@@ -22,22 +26,44 @@ export default class Countdown extends GameLoop
         return this._duration - this.elapsedTime;
     }
 
-    public constructor(duration: number, fpsIfNotBrowser: number = TimeUnit.Second)
+    public constructor(duration: number, msIfNotBrowser: number = TimeUnit.Second)
     {
         const callback = () =>
         {
             const remainingTime = this.remainingTime;
-            this._publisher.publish(remainingTime);
+            this._ticker.publish(remainingTime);
+
+            if (remainingTime <= 0)
+            {
+                this._deferrerStop();
 
-            if (remainingTime <= 0) { this.stop(); }
+                this._expirer.publish();
+            }
         };
 
-        super(callback, fpsIfNotBrowser);
+        super(callback, msIfNotBrowser);
+
+        this._expirer = new Publisher();
+        this._starter = new Publisher();
+        this._stopper = new Publisher();
+        this._ticker = new Publisher();
 
-        this._publisher = new Publisher();
         this._duration = duration;
     }
 
+    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."); }
@@ -46,29 +72,39 @@ export default class Countdown extends GameLoop
         this._deferrer = new DeferredPromise();
         super.start(this.duration - remainingTime);
 
+        this._starter.publish();
+
         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._stopper.publish(reason);
+    }
 
-        if (reason !== undefined) { this._deferrer.reject(reason); }
-        else { this._deferrer.resolve(); }
+    public onExpire(callback: () => void): () => void
+    {
+        return this._expirer.subscribe(callback);
+    }
 
-        this._deferrer = undefined;
+    public onStart(callback: () => void): () => void
+    {
+        return this._starter.subscribe(callback);
+    }
+    public onStop(callback: (reason?: unknown) => void): () => void
+    {
+        return this._stopper.subscribe(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._ticker.subscribe(callback); }
 
         let lastTick = 0;
 
-        return this._publisher.subscribe((remainingTime: number) =>
+        return this._ticker.subscribe((remainingTime: number) =>
         {
             if ((lastTick - remainingTime) < tickStep) { return; }
 
@@ -76,4 +112,6 @@ export default class Countdown extends GameLoop
             lastTick = remainingTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Countdown";
 }

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