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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "2.0.0-rc.5",
+  "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",
@@ -48,10 +48,10 @@
   "types": "./src/index.ts",
   "devDependencies": {
     "@byloth/eslint-config-typescript": "^3.0.1",
-    "@types/node": "^20.17.6",
+    "@types/node": "^22.9.0",
     "husky": "^9.1.6",
     "typescript": "^5.6.3",
-    "vite": "^5.4.10"
+    "vite": "^5.4.11"
   },
   "scripts": {
     "dev": "vite",

package/src/index.ts

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

package/src/models/aggregators/aggregated-async-iterator.ts

@@ -190,12 +190,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             for await (const [key, element] of elements)
             {
                 const index = indexes.get(key) ?? 0;
-                if (index >= limit)
-                {
-                    if (indexes.values().every((value) => value >= limit)) { break; }
-
-                    continue;
-                }
+                if (index >= limit) { continue; }
 
                 yield [key, element];
 

package/src/models/aggregators/aggregated-iterator.ts

@@ -178,12 +178,7 @@ export default class AggregatedIterator<K extends PropertyKey, T>
             for (const [key, element] of elements)
             {
                 const index = indexes.get(key) ?? 0;
-                if (index >= limit)
-                {
-                    if (indexes.values().every((value) => value >= limit)) { break; }
-
-                    continue;
-                }
+                if (index >= limit) { continue; }
 
                 yield [key, element];
 

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