@byloth/core 2.1.3 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -50,15 +50,15 @@
   "types": "src/index.ts",
   "devDependencies": {
     "@byloth/eslint-config-typescript": "^3.1.0",
-    "@eslint/compat": "^1.2.9",
-    "@types/node": "^22.15.30",
-    "@vitest/coverage-v8": "^3.2.2",
-    "eslint": "^9.28.0",
+    "@eslint/compat": "^1.3.0",
+    "@types/node": "^22.15.32",
+    "@vitest/coverage-v8": "^3.2.3",
+    "eslint": "^9.29.0",
     "husky": "^9.1.7",
     "jsdom": "^26.1.0",
     "typescript": "^5.8.3",
     "vite": "^6.3.5",
-    "vitest": "^3.2.2"
+    "vitest": "^3.2.3"
   },
   "scripts": {
     "dev": "vite",

package/src/core/types.ts

@@ -74,7 +74,7 @@ export type Timeout = ReturnType<typeof setTimeout>;
  *     public greet() { console.log("Hello, world!"); }
  * }
  *
- * type MyObjectProperties = ValueOf<MyObject>;  // number | (() => void)
+ * type MyObjectProperties = ValueOf<MyObject>; // number | (() => void)
  * ```
  *
  * ---

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "2.1.3";
+export const VERSION = "2.1.5";
 
 export type { Constructor, Interval, Timeout, ValueOf } from "./core/types.js";
 
@@ -24,6 +24,7 @@ export {
     NotImplementedException,
     NetworkException,
     PermissionException,
+    PromiseQueue,
     Publisher,
     RangeException,
     ReducedIterator,

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

@@ -52,7 +52,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     /**
      * The internal {@link SmartAsyncIterator} object that holds the elements to aggregate.
      */
-    protected _elements: SmartAsyncIterator<[K, T]>;
+    protected readonly _elements: SmartAsyncIterator<[K, T]>;
 
     /**
      * Initializes a new instance of the {@link AggregatedAsyncIterator} class.

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

@@ -43,7 +43,7 @@ export default class AggregatedIterator<K extends PropertyKey, T>
     /**
      * The internal {@link SmartIterator} object that holds the elements to aggregate.
      */
-    protected _elements: SmartIterator<[K, T]>;
+    protected readonly _elements: SmartIterator<[K, T]>;
 
     /**
      * Initializes a new instance of the {@link AggregatedIterator} class.

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

@@ -45,7 +45,7 @@ export default class ReducedIterator<K extends PropertyKey, T>
     /**
      * The internal {@link SmartIterator} object that holds the reduced elements.
      */
-    protected _elements: SmartIterator<[K, T]>;
+    protected readonly _elements: SmartIterator<[K, T]>;
 
     /**
      * Initializes a new instance of the {@link ReducedIterator} class.

package/src/models/callbacks/publisher.ts

@@ -1,6 +1,6 @@
 import { ReferenceException } from "../exceptions/index.js";
 
-import type { Callback, CallbackMap } from "./types.js";
+import type { Callback, CallbackMap, WithWildcard } from "./types.js";
 
 /**
  * A class implementing the
@@ -39,8 +39,10 @@ import type { Callback, CallbackMap } from "./types.js";
  * A map containing the names of the emittable events and the
  * related callback signatures that can be subscribed to them.  
  * Default is `Record<string, (...args: unknown[]) => unknown>`.
+ *
+ * @template E An utility type that extends the `T` map with a wildcard event.
  */
-export default class Publisher<T extends CallbackMap<T> = CallbackMap>
+export default class Publisher<T extends CallbackMap<T> = CallbackMap, W extends WithWildcard<T> = WithWildcard<T>>
 {
     /**
      * A map containing all the subscribers for each event.
@@ -48,7 +50,7 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * The keys are the names of the events they are subscribed to.  
      * The values are the arrays of the subscribers themselves.
      */
-    protected _subscribers: Map<string, Callback<unknown[], unknown>[]>;
+    protected readonly _subscribers: Map<string, Callback<unknown[], unknown>[]>;
 
     /**
      * Initializes a new instance of the {@link Publisher} class.
@@ -87,9 +89,63 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      */
     public clear(): void
     {
+        // @ts-expect-error It's an internal event, not part of the public API.
+        this.publish("__internals__:clear");
+
         this._subscribers.clear();
     }
 
+    /**
+     * Creates a new scoped instance of the {@link Publisher} class,
+     * which can be used to publish and subscribe events within a specific context.
+     *
+     * It can receive all events published to the parent publisher while also allowing
+     * the scoped publisher to handle its own events independently.  
+     * In fact, events published to the scoped publisher won't be propagated back to the parent publisher.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const publisher = new Publisher();
+     * const context = publisher.createScope();
+     *
+     * publisher.subscribe("player:death", () => { console.log(`Player has died.`); });
+     * context.subscribe("player:spawn", () => { console.log(`Player has spawned.`); });
+     *
+     * publisher.publish("player:spawn"); // Player has spawned.
+     * context.publish("player:death"); // * no output *
+     * ```
+     *
+     * ---
+     *
+     * @template U
+     * A map containing the names of the emittable events and the
+     * related callback signatures that can be subscribed to them.
+     * Default is `T`.
+     *
+     * @template X An utility type that extends the `U` map with a wildcard event.
+     *
+     * @return
+     * A new instance of the {@link Publisher} class that can be
+     * used to publish and subscribe events within a specific context.
+     */
+    public createScope<U extends T = T, X extends WithWildcard<U> = WithWildcard<U>>(): Publisher<U, X>
+    {
+        const scope = new Publisher<U, X>();
+
+        const propagator = (event: (keyof T) & string, ...args: Parameters<T[keyof T]>): void =>
+        {
+            scope.publish(event, ...args);
+        };
+
+        // @ts-expect-error It's an internal event, not part of the public API.
+        this.subscribe("__internals__:clear", () => scope.clear());
+        this.subscribe("*", propagator as W["*"]);
+
+        return scope;
+    }
+
     /**
      * Publishes an event to all the subscribers.
      *
@@ -115,11 +171,26 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      */
     public publish<K extends keyof T>(event: K & string, ...args: Parameters<T[K]>): ReturnType<T[K]>[]
     {
-        const subscribers = this._subscribers.get(event);
-        if (!(subscribers)) { return []; }
+        let results: ReturnType<T[K]>[];
+        let subscribers = this._subscribers.get(event);
+        if (subscribers)
+        {
+            results = subscribers.slice()
+                .map((subscriber) => subscriber(...args)) as ReturnType<T[K]>[];
+        }
+        else { results = []; }
+
+        if (!(event.startsWith("__")))
+        {
+            subscribers = this._subscribers.get("*");
+            if (subscribers)
+            {
+                subscribers.slice()
+                    .forEach((subscriber) => subscriber(event, ...args));
+            }
+        }
 
-        return subscribers.slice()
-            .map((subscriber) => subscriber(...args)) as ReturnType<T[K]>[];
+        return results;
     }
 
     /**
@@ -146,7 +217,7 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      *
      * @returns A function that can be used to unsubscribe the subscriber from the event.
      */
-    public subscribe<K extends keyof T>(event: K & string, subscriber: T[K]): () => void
+    public subscribe<K extends keyof W>(event: K & string, subscriber: W[K]): () => void
     {
         const subscribers = this._subscribers.get(event) ?? [];
         subscribers.push(subscriber);
@@ -186,7 +257,7 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * @param event The name of the event to unsubscribe from.
      * @param subscriber The subscriber to remove from the event.
      */
-    public unsubscribe<K extends keyof T>(event: K & string, subscriber: T[K]): void
+    public unsubscribe<K extends keyof W>(event: K & string, subscriber: W[K]): void
     {
         const subscribers = this._subscribers.get(event);
         if (!(subscribers))

package/src/models/callbacks/switchable-callback.ts

@@ -43,7 +43,7 @@ export default class SwitchableCallback<T extends Callback<any[], any> = Callbac
      * The keys are the names of the implementations they were registered with.  
      * The values are the implementations themselves.
      */
-    protected _callbacks: Map<string, T>;
+    protected readonly _callbacks: Map<string, T>;
 
     /**
      * A flag indicating whether the callback is enabled or not.

package/src/models/callbacks/types.ts

@@ -157,3 +157,16 @@ export interface Subscribable<T extends CallbackMap<T> = CallbackMap>
      */
     unsubscribe<K extends keyof T>(event: K & string, subscriber: T[K]): void;
 }
+
+/**
+ * An utility type that may be used to wrap a {@link CallbackMap} and extend it with a wildcard event. 
+ * The resulting type will be the same as the original map, but with an additional `"*"` key. 
+ *
+ * It's natively used by the {@link Publisher} class to allow subscribers to listen to all events.
+ *
+ * ---
+ *
+ * @template T A `CallbackMap` compatible interface that defines the map of callbacks.
+ * 
+ */
+export type WithWildcard<T extends CallbackMap<T>> = T & { "*"?: (type: string, ...args: unknown[]) => void };

package/src/models/collections/map-view.ts

@@ -1,4 +1,5 @@
 import Publisher from "../callbacks/publisher.js";
+import type { WithWildcard } from "../callbacks/types.js";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type SetView from "./set-view.js";
@@ -172,7 +173,9 @@ export default class MapView<K, V> extends Map<K, V>
      *
      * @returns A function that can be used to unsubscribe the callback from the event.
      */
-    public subscribe<T extends keyof MapViewEventsMap<K, V>>(event: T, callback: MapViewEventsMap<K, V>[T]): () => void
+    public subscribe<T extends keyof WithWildcard<MapViewEventsMap<K, V>>>(
+        event: T & string, callback: WithWildcard<MapViewEventsMap<K, V>>[T]
+    ): () => void
     {
         return this._publisher.subscribe(event, callback);
     }
@@ -201,7 +204,8 @@ export default class MapView<K, V> extends Map<K, V>
      * @param event The name of the event to unsubscribe from.
      * @param callback The callback to remove from the event.
      */
-    public unsubscribe<T extends keyof MapViewEventsMap<K, V>>(event: T, callback: MapViewEventsMap<K, V>[T]): void
+    public unsubscribe<T extends keyof WithWildcard<MapViewEventsMap<K, V>>>(
+        event: T & string, callback: WithWildcard<MapViewEventsMap<K, V>>[T]): void
     {
         this._publisher.unsubscribe(event, callback);
     }

package/src/models/collections/set-view.ts

@@ -1,4 +1,5 @@
 import Publisher from "../callbacks/publisher.js";
+import type { WithWildcard } from "../callbacks/types.js";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type MapView from "./map-view.js";
@@ -166,7 +167,9 @@ export default class SetView<T> extends Set<T>
      *
      * @returns A function that can be used to unsubscribe the callback from the event.
      */
-    public subscribe<K extends keyof SetViewEventsMap<T>>(event: K, callback: SetViewEventsMap<T>[K]): () => void
+    public subscribe<K extends keyof WithWildcard<SetViewEventsMap<T>>>(
+        event: K & string, callback: WithWildcard<SetViewEventsMap<T>>[K]
+    ): () => void
     {
         return this._publisher.subscribe(event, callback);
     }
@@ -195,7 +198,9 @@ export default class SetView<T> extends Set<T>
      * @param event The name of the event to unsubscribe from.
      * @param callback The callback to remove from the event.
      */
-    public unsubscribe<K extends keyof SetViewEventsMap<T>>(event: K, callback: SetViewEventsMap<T>[K]): void
+    public unsubscribe<K extends keyof WithWildcard<SetViewEventsMap<T>>>(
+        event: K & string, callback: WithWildcard<SetViewEventsMap<T>>[K]
+    ): void
     {
         this._publisher.unsubscribe(event, callback);
     }

package/src/models/index.ts

@@ -29,5 +29,5 @@ export {
 
 export { SmartIterator, SmartAsyncIterator } from "./iterators/index.js";
 export { JSONStorage } from "./json/index.js";
-export { DeferredPromise, SmartPromise, TimedPromise } from "./promises/index.js";
+export { DeferredPromise, PromiseQueue, SmartPromise, TimedPromise } from "./promises/index.js";
 export { Clock, Countdown, GameLoop } from "./timers/index.js";

package/src/models/iterators/smart-async-iterator.ts

@@ -51,7 +51,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     /**
      * The native {@link AsyncIterator} object that is being wrapped by this instance.
      */
-    protected _iterator: AsyncIterator<T, R, N>;
+    protected readonly _iterator: AsyncIterator<T, R, N>;
 
     /**
      * Initializes a new instance of the {@link SmartAsyncIterator} class.

package/src/models/iterators/smart-iterator.ts

@@ -42,7 +42,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     /**
      * The native {@link Iterator} object that is being wrapped by this instance.
      */
-    protected _iterator: Iterator<T, R, N>;
+    protected readonly _iterator: Iterator<T, R, N>;
 
     /**
      * Initializes a new instance of the {@link SmartIterator} class.

package/src/models/json/json-storage.ts

@@ -29,17 +29,17 @@ export default class JSONStorage
      * If `true`, the persistent storage is preferred. If `false`, the volatile storage is preferred.  
      * Default is `true`.
      */
-    protected _preferPersistence: boolean;
+    protected readonly _preferPersistence: boolean;
 
     /**
      * A reference to the volatile {@link sessionStorage} storage.
      */
-    protected _volatile: Storage;
+    protected readonly _volatile: Storage;
 
     /**
      * A reference to the persistent {@link localStorage} storage.
      */
-    protected _persistent: Storage;
+    protected readonly _persistent: Storage;
 
     /**
      * Initializes a new instance of the {@link JSONStorage} class.  

package/src/models/promises/deferred-promise.ts

@@ -40,7 +40,7 @@ export default class DeferredPromise<T = void, F = T, R = never> extends SmartPr
      * This protected property is the only one that can be modified directly by the derived classes.  
      * If you're looking for the public and readonly property, use the {@link DeferredPromise.resolve} getter instead.
      */
-    protected _resolve: PromiseResolver<T>;
+    protected readonly _resolve: PromiseResolver<T>;
 
     /**
      * The exposed function that allows to reject the promise.
@@ -53,13 +53,18 @@ export default class DeferredPromise<T = void, F = T, R = never> extends SmartPr
      * This protected property is the only one that can be modified directly by the derived classes.  
      * If you're looking for the public and readonly property, use the {@link DeferredPromise.reject} getter instead.
      */
-    protected _reject: PromiseRejecter;
+    protected readonly _reject: PromiseRejecter;
 
     /**
      * The exposed function that allows to reject the promise.
      */
     public get reject(): PromiseRejecter { return this._reject; }
 
+    /**
+     * The native {@link Promise} object wrapped by this instance.
+     */
+    declare protected readonly _promise: Promise<F | R>;
+
     /**
      * Initializes a new instance of the {@link DeferredPromise} class.
      *

package/src/models/promises/index.ts

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

package/src/models/promises/promise-queue.ts

@@ -0,0 +1,222 @@
+import type { Callback } from "../callbacks/types.js";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { TimeoutException, ValueException } from "../exceptions/index.js";
+
+import DeferredPromise from "./deferred-promise.js";
+import SmartPromise from "./smart-promise.js";
+import TimedPromise from "./timed-promise.js";
+import type { MaybePromise, PromiseRejecter, PromiseResolver } from "./types.js";
+
+/**
+ * A class that represents a queue of asynchronous operations, allowing them to be executed sequentially.
+ *
+ * It extends the {@link SmartPromise} class, providing a way to manage multiple promises in a controlled manner.   
+ * This class is useful for scenarios where you need to ensure
+ * that only one asynchronous operation is executed at a time,
+ * such as when dealing with API requests, file operations or any other
+ * asynchronous tasks that need to be handled in a specific order.
+ *
+ * ---
+ *
+ * @example
+ * ```ts
+ * const queue = new PromiseQueue();
+ *
+ * queue.enqueue(() => new Promise((resolve) => setTimeout(() => resolve("First"), 2000)))
+ * queue.enqueue(() => new Promise((resolve) => setTimeout(() => resolve("Second"), 500)))
+ * queue.enqueue(() => new Promise((resolve) => setTimeout(() => resolve("Third"), 1000)))
+ *
+ * await queue; // "First", "Second", "Third"
+ * ```
+ */
+export default class PromiseQueue extends SmartPromise<void>
+{
+    /**
+     * The number of promises currently in the queue.
+     */
+    protected _count: number;
+
+    /**
+     * A flag indicating whether the promise is still pending or not.
+     */
+    public override get isPending(): boolean
+    {
+        return this._count > 0;
+    }
+    /**
+     * A flag indicating whether the promise has been fulfilled or not.
+     */
+    public override get isFulfilled(): boolean
+    {
+        return this._count === 0;
+    }
+
+    /**
+     * A flag indicating whether the promise has been rejected or not.
+     *
+     * Please note the {@link PromiseQueue} doesn't support rejection states.  
+     * Accessing this property will always result in a {@link ValueException}.
+     */
+    public override get isRejected(): never
+    {
+        throw new ValueException("`PromiseQueue` doesn't support rejection states.");
+    }
+
+    /**
+     * The native {@link Promise} object wrapped by this instance.
+     */
+    declare protected _promise: Promise<void>;
+
+    /**
+     * Initializes a new instance of the {@link PromiseQueue} class.
+     */
+    public constructor()
+    {
+        super((resolve) => resolve());
+
+        this._count = 0;
+
+        this._isPending = false;
+        this._isFulfilled = false;
+        this._isRejected = false;
+    }
+
+    /**
+     * Enqueues a {@link DeferredPromise} into the queue.
+     *
+     * The promise will be executed in sequence after previously enqueued promises.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const queue = new PromiseQueue();
+     * const deferred = new DeferredPromise(() => console.log("Hello, world!"));
+     * 
+     * queue.enqueue(deferred); // "Hello, world!"
+     * ```
+     *
+     * ---
+     *
+     * @template T The type of value the promise will eventually resolve to.
+     *
+     * @param promise A `DeferredPromise<void, T>` instance to enqueue.
+     *
+     * @returns A {@link Promise} that resolves to the value of the enqueued promise.
+     */
+    public enqueue<T>(promise: DeferredPromise<void, T>): Promise<T>;
+
+    /**
+     * Enqueues a {@link DeferredPromise} into the queue with an optional timeout.
+     *
+     * The promise will be executed in sequence after previously enqueued promises.  
+     * If the promise takes longer than the specified timeout, it will be rejected with a {@link TimeoutException}.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const queue = new PromiseQueue();
+     * const deferred = new DeferredPromise(() => console.log("Hello, world!"));
+     *
+     * queue.enqueue(deferred, 5000); // "Hello, world!"
+     * ```
+     *
+     * ---
+     *
+     * @template T The type of value the promise will eventually resolve to.
+     *
+     * @param promise A `DeferredPromise<void, T>` instance to enqueue.
+     * @param timeout The maximum time in milliseconds that the operation can take before timing out.
+     *
+     * @returns
+     * A {@link TimedPromise} that resolves to the value of the enqueued promise or rejects
+     * with a `TimeoutException` if the operation takes longer than the specified timeout.
+     */
+    public enqueue<T>(promise: DeferredPromise<void, T>, timeout: number): TimedPromise<T>;
+
+    /**
+     * Enqueues a callback that returns a {@link MaybePromise} value of type `T` into the queue.
+     *
+     * The executor will be executed in sequence after previously enqueued promises.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const queue = new PromiseQueue();
+     *
+     * queue.enqueue(() => console.log("Hello, world!")); // "Hello, world!"
+     * ```
+     *
+     * ---
+     *
+     * @template T The type of value the promise will eventually resolve to.
+     *
+     * @param executor A callback that returns a `MaybePromise<T>` value to enqueue.
+     *
+     * @returns A {@link Promise} that resolves to the value of the enqueued executor.
+     */
+    public enqueue<T>(executor: Callback<[], MaybePromise<T>>): Promise<T>;
+
+    /**
+     * Enqueues a callback that returns a {@link MaybePromise}
+     * value of type `T` into the queue with an optional timeout.
+     *
+     * The executor will be executed in sequence after previously enqueued promises.  
+     * If the executor takes longer than the specified timeout, it will be rejected with a {@link TimeoutException}.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * const queue = new PromiseQueue();
+     *
+     * queue.enqueue(() => console.log("Hello, world!"), 5000); // "Hello, world!"
+     * ```
+     *
+     * ---
+     *
+     * @template T The type of value the promise will eventually resolve to.
+     *
+     * @param executor A callback that returns a `MaybePromise<T>` value to enqueue.
+     * @param timeout The maximum time in milliseconds that the operation can take before timing out.
+     *
+     * @returns
+     * A {@link TimedPromise} that resolves to the value of the enqueued executor or rejects
+     * with a `TimeoutException` if the operation takes longer than the specified timeout.
+     */
+    public enqueue<T>(executor: Callback<[], MaybePromise<T>>, timeout?: number): TimedPromise<T>;
+    public enqueue<T>(executor: DeferredPromise<void, T> | Callback<[], MaybePromise<T>>, timeout?: number)
+        : Promise<T> | TimedPromise<T>
+    {
+        this._count += 1;
+
+        if (executor instanceof DeferredPromise)
+        {
+            const _executor = executor as DeferredPromise<void, T>;
+
+            executor = () =>
+            {
+                _executor.resolve();
+
+                return _executor;
+            };
+        }
+
+        const _executor = (resolve: PromiseResolver<T>, reject: PromiseRejecter) =>
+        {
+            this._promise = this._promise
+                .then(executor)
+                .then((value) => { this._count -= 1; resolve(value); })
+                .catch((value) => { this._count -= 1; reject(value); });
+        };
+
+        if (timeout) { return new TimedPromise<T>(_executor, timeout); }
+
+        return new Promise<T>(_executor);
+    }
+
+    public override readonly [Symbol.toStringTag]: string = "PromiseQueue";
+}

package/src/models/promises/smart-promise.ts

@@ -110,7 +110,7 @@ export default class SmartPromise<T = void> implements Promise<T>
     /**
      * The native {@link Promise} object wrapped by this instance.
      */
-    protected _promise: Promise<T>;
+    protected readonly _promise: Promise<T>;
 
     /**
      * Initializes a new instance of the {@link SmartPromise} class.

package/src/models/timers/clock.ts

@@ -2,18 +2,14 @@ import { TimeUnit } from "../../utils/date.js";
 
 import Publisher from "../callbacks/publisher.js";
 import { FatalErrorException, RangeException, RuntimeException } from "../exceptions/index.js";
-import type { Callback } from "../types.js";
 
 import GameLoop from "./game-loop.js";
 
-interface ClockEventMap
+interface ClockEventsMap
 {
     start: () => void;
     stop: () => void;
     tick: (elapsedTime: number) => void;
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [key: string]: Callback<any[], any>;
 }
 
 /**
@@ -40,7 +36,7 @@ export default class Clock extends GameLoop
     /**
      * The {@link Publisher} object that will be used to publish the events of the clock.
      */
-    protected override _publisher: Publisher<ClockEventMap>;
+    declare protected readonly _publisher: Publisher<ClockEventsMap>;
 
     /**
      * Initializes a new instance of the {@link Clock} class.
@@ -61,8 +57,6 @@ export default class Clock extends GameLoop
     public constructor(msIfNotBrowser: number = TimeUnit.Second)
     {
         super((elapsedTime) => this._publisher.publish("tick", elapsedTime), msIfNotBrowser);
-
-        this._publisher = new Publisher();
     }
 
     /**