@byloth/core 2.0.0-rc.6 → 2.0.0-rc.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0-rc.7",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "2.0.0-rc.6";
+export const VERSION = "2.0.0-rc.7";
 
 export type { Constructor, Interval, Timeout } from "./core/types.js";
 

package/src/models/publisher.ts

@@ -2,37 +2,44 @@ 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>
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+export default class Publisher<T extends { [K in keyof T]: [unknown[], unknown] } = Record<string, [[], void]>>
 {
-    protected _subscribers: Subscriber<A, R>[];
+    protected _subscribers: Map<keyof T, Subscriber<unknown[], unknown>[]>;
 
     public constructor()
     {
-        this._subscribers = [];
+        this._subscribers = new Map();
     }
 
-    public subscribe(subscriber: Subscriber<A, R>): () => void
+    public subscribe<K extends keyof T, A extends T[K][0], R extends T[K][1]>(event: K, subscriber: Subscriber<A, R>)
+        : () => void
     {
-        this._subscribers.push(subscriber);
+        if (!(this._subscribers.has(event))) { this._subscribers.set(event, []); }
+
+        const subscribers = this._subscribers.get(event)!;
+        subscribers.push(subscriber as Subscriber<unknown[], unknown>);
 
         return () =>
         {
-            const index = this._subscribers.indexOf(subscriber);
+            const index = subscribers.indexOf(subscriber as Subscriber<unknown[], unknown>);
             if (index < 0)
             {
                 throw new ReferenceException("Unable to unsubscribe the required subscriber. " +
                     "The subscription was already unsubscribed.");
             }
 
-            this._subscribers.splice(index, 1);
+            subscribers.splice(index, 1);
         };
     }
 
-    public publish(...args: A): R[]
+    public publish<K extends keyof T, A extends T[K][0], R extends T[K][1]>(event: K, ...args: A): R[]
     {
-        return this._subscribers
-            .slice()
-            .map((subscriber) => subscriber(...args));
+        const subscribers = this._subscribers.get(event);
+        if (!(subscribers)) { return []; }
+
+        return subscribers.slice()
+            .map((subscriber) => subscriber(...args)) as R[];
     }
 
     public readonly [Symbol.toStringTag]: string = "Publisher";

package/src/models/timers/clock.ts

@@ -1,22 +1,27 @@
 import { TimeUnit } from "../../utils/date.js";
-
 import { RangeException, RuntimeException } from "../exceptions/index.js";
+
 import GameLoop from "../game-loop.js";
 import Publisher from "../publisher.js";
 
+interface ClockEvents
+{
+    /* eslint-disable @typescript-eslint/no-invalid-void-type */
+
+    start: [[], void];
+    stop: [[], void];
+    tick: [[number], void];
+}
+
 export default class Clock extends GameLoop
 {
-    protected _starter: Publisher;
-    protected _stopper: Publisher;
-    protected _ticker: Publisher<[number]>;
+    protected _publisher: Publisher<ClockEvents>;
 
     public constructor(msIfNotBrowser: number = TimeUnit.Second)
     {
-        super((elapsedTime) => this._ticker.publish(elapsedTime), msIfNotBrowser);
+        super((elapsedTime) => this._publisher.publish("tick", elapsedTime), msIfNotBrowser);
 
-        this._starter = new Publisher();
-        this._stopper = new Publisher();
-        this._ticker = new Publisher();
+        this._publisher = new Publisher();
     }
 
     public start(elapsedTime = 0): void
@@ -25,7 +30,7 @@ export default class Clock extends GameLoop
 
         super.start(elapsedTime);
 
-        this._starter.publish();
+        this._publisher.publish("start");
     }
 
     public stop(): void
@@ -34,26 +39,26 @@ export default class Clock extends GameLoop
 
         super.stop();
 
-        this._stopper.publish();
+        this._publisher.publish("stop");
     }
 
     public onStart(callback: () => void): () => void
     {
-        return this._starter.subscribe(callback);
+        return this._publisher.subscribe("start", callback);
     }
     public onStop(callback: () => void): () => void
     {
-        return this._stopper.subscribe(callback);
+        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._ticker.subscribe(callback); }
+        if (tickStep === 0) { return this._publisher.subscribe("tick", callback); }
 
         let lastTick = 0;
 
-        return this._ticker.subscribe((elapsedTime: number) =>
+        return this._publisher.subscribe("tick", (elapsedTime: number) =>
         {
             if ((elapsedTime - lastTick) < tickStep) { return; }
 

package/src/models/timers/countdown.ts

@@ -6,14 +6,21 @@ import { DeferredPromise, SmartPromise } from "../promises/index.js";
 import GameLoop from "../game-loop.js";
 import Publisher from "../publisher.js";
 
+interface CountdownEvents
+{
+    /* eslint-disable @typescript-eslint/no-invalid-void-type */
+
+    start: [[], void];
+    stop: [[unknown], void];
+    tick: [[number], void];
+    expire: [[], void];
+}
+
 export default class Countdown extends GameLoop
 {
     protected _deferrer?: DeferredPromise<void>;
 
-    protected _expirer: Publisher;
-    protected _starter: Publisher;
-    protected _stopper: Publisher<[unknown]>;
-    protected _ticker: Publisher<[number]>;
+    protected _publisher: Publisher<CountdownEvents>;
 
     protected _duration: number;
     public get duration(): number
@@ -31,23 +38,19 @@ export default class Countdown extends GameLoop
         const callback = () =>
         {
             const remainingTime = this.remainingTime;
-            this._ticker.publish(remainingTime);
+            this._publisher.publish("tick", remainingTime);
 
             if (remainingTime <= 0)
             {
                 this._deferrerStop();
 
-                this._expirer.publish();
+                this._publisher.publish("expire");
             }
         };
 
         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;
     }
 
@@ -72,7 +75,7 @@ export default class Countdown extends GameLoop
         this._deferrer = new DeferredPromise();
         super.start(this.duration - remainingTime);
 
-        this._starter.publish();
+        this._publisher.publish("start");
 
         return this._deferrer;
     }
@@ -80,31 +83,31 @@ export default class Countdown extends GameLoop
     {
         this._deferrerStop(reason);
 
-        this._stopper.publish(reason);
+        this._publisher.publish("stop", reason);
     }
 
     public onExpire(callback: () => void): () => void
     {
-        return this._expirer.subscribe(callback);
+        return this._publisher.subscribe("expire", callback);
     }
 
     public onStart(callback: () => void): () => void
     {
-        return this._starter.subscribe(callback);
+        return this._publisher.subscribe("start", callback);
     }
     public onStop(callback: (reason?: unknown) => void): () => void
     {
-        return this._stopper.subscribe(callback);
+        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._ticker.subscribe(callback); }
+        if (tickStep === 0) { return this._publisher.subscribe("tick", callback); }
 
         let lastTick = 0;
 
-        return this._ticker.subscribe((remainingTime: number) =>
+        return this._publisher.subscribe("tick", (remainingTime: number) =>
         {
             if ((lastTick - remainingTime) < tickStep) { return; }