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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "2.0.0-rc.4",
+  "version": "2.0.0-rc.6",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -47,11 +47,11 @@
   },
   "types": "./src/index.ts",
   "devDependencies": {
-    "@byloth/eslint-config-typescript": "^3.0.0",
-    "@types/node": "^20.16.11",
+    "@byloth/eslint-config-typescript": "^3.0.1",
+    "@types/node": "^22.9.0",
     "husky": "^9.1.6",
     "typescript": "^5.6.3",
-    "vite": "^5.4.8"
+    "vite": "^5.4.11"
   },
   "scripts": {
     "dev": "vite",

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "2.0.0-rc.4";
+export const VERSION = "2.0.0-rc.6";
 
 export type { Constructor, Interval, Timeout } from "./core/types.js";
 
@@ -29,6 +29,7 @@ export {
     SmartIterator,
     SmartAsyncIterator,
     SmartPromise,
+    Thenable,
     TimeoutException,
     TimedPromise,
     TypeException,

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

package/src/models/index.ts

@@ -28,7 +28,7 @@ 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";
+export { DeferredPromise, SmartPromise, Thenable, TimedPromise } from "./promises/index.js";
 
 import Publisher from "./publisher.js";
 

package/src/models/promises/index.ts

@@ -1,5 +1,6 @@
 import DeferredPromise from "./deferred-promise.js";
 import SmartPromise from "./smart-promise.js";
+import Thenable from "./thenable.js";
 import TimedPromise from "./timed-promise.js";
 
-export { DeferredPromise, SmartPromise, TimedPromise };
+export { DeferredPromise, SmartPromise, Thenable, TimedPromise };

package/src/models/promises/thenable.ts

@@ -0,0 +1,97 @@
+export default class Thenable<T> implements Promise<T>
+{
+    protected _onFulfilled: (result: T) => T;
+    protected _resolve(result: T): T
+    {
+        return this._onFulfilled(result);
+    }
+
+    public constructor()
+    {
+        this._onFulfilled = (result: T) => result;
+    }
+
+    public then(onFulfilled?: null): Thenable<T>;
+    public then<F = T>(onFulfilled: (result: T) => F, onRejected?: null): Thenable<F>;
+    public then<F = T, R = never>(onFulfilled: (result: T) => F, onRejected: (reason: unknown) => R)
+        : Thenable<F | R>;
+    public then<F = T, R = never>(onFulfilled?: ((result: T) => F) | null, onRejected?: ((reason: unknown) => R) | null)
+        : Thenable<F | R>
+    {
+        if (onRejected)
+        {
+            const _previousOnFulfilled = this._onFulfilled;
+            this._onFulfilled = (result: T) =>
+            {
+                try
+                {
+                    result = _previousOnFulfilled(result);
+
+                    return (onFulfilled!(result) as unknown) as T;
+                }
+                catch (error)
+                {
+                    return (onRejected(error) as unknown) as T;
+                }
+            };
+        }
+        else if (onFulfilled)
+        {
+            const _previousOnFulfilled = this._onFulfilled;
+            this._onFulfilled = (result: T) =>
+            {
+                result = _previousOnFulfilled(result);
+
+                return (onFulfilled(result) as unknown) as T;
+            };
+        }
+
+        return (this as unknown) as Thenable<F | R>;
+    }
+
+    public catch(onRejected?: null): Thenable<T>;
+    public catch<R = never>(onRejected: (reason: unknown) => R): Thenable<T | R>;
+    public catch<R = never>(onRejected?: ((reason: unknown) => R) | null): Thenable<T | R>
+    {
+        if (onRejected)
+        {
+            const _previousOnFulfilled = this._onFulfilled;
+            this._onFulfilled = (result) =>
+            {
+                try
+                {
+                    return _previousOnFulfilled(result);
+                }
+                catch (error)
+                {
+                    return (onRejected(error) as unknown) as T;
+                }
+            };
+        }
+
+        return this as Thenable<T | R>;
+    }
+
+    public finally(onFinally?: (() => void) | null): Thenable<T>
+    {
+        if (onFinally)
+        {
+            const _previousOnFulfilled = this._onFulfilled;
+            this._onFulfilled = (result) =>
+            {
+                try
+                {
+                    return _previousOnFulfilled(result);
+                }
+                finally
+                {
+                    onFinally();
+                }
+            };
+        }
+
+        return this;
+    }
+
+    public readonly [Symbol.toStringTag]: string = "Thenable";
+}

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

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