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

package/src/models/timers/countdown.ts

@@ -3,17 +3,21 @@ import { TimeUnit } from "../../utils/date.js";
 import { FatalErrorException, RangeException, RuntimeException } from "../exceptions/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 _expirer: Publisher;
-    protected _starter: Publisher;
-    protected _stopper: Publisher<[unknown]>;
-    protected _ticker: Publisher<[number]>;
+    protected _publisher: Publisher<CountdownEventMap>;
 
     protected _duration: number;
     public get duration(): number
@@ -31,23 +35,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 +72,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 +80,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; }
 

package/src/models/types.ts

@@ -11,6 +11,7 @@ export type {
 export type {
     GeneratorFunction,
     AsyncGeneratorFunction,
+    MaybeAsyncGeneratorFunction,
     Iteratee,
     MaybeAsyncIteratee,
     TypeGuardIteratee,
@@ -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 function delay(milliseconds: number): Promise<void>
 {
-    return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 export function nextAnimationFrame(): Promise<void>
 {
-    return new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+
+export function yieldToEventLoop(): Promise<void>
+{
+    return new Promise((resolve) => setTimeout(resolve));
 }

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/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 readonly [Symbol.toStringTag]: string = "Publisher";
-}