@byloth/core 2.1.6 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -49,15 +49,15 @@
   },
   "types": "src/index.ts",
   "devDependencies": {
-    "@byloth/eslint-config-typescript": "^3.1.0",
-    "@eslint/compat": "^1.3.0",
-    "@types/node": "^22.15.32",
+    "@byloth/eslint-config-typescript": "^3.2.2",
+    "@eslint/compat": "^1.4.1",
+    "@types/node": "^22.19.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^9.29.0",
+    "eslint": "^9.39.1",
     "husky": "^9.1.7",
-    "jsdom": "^26.1.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5",
+    "jsdom": "^27.1.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.1",
     "vitest": "^3.2.4"
   },
   "scripts": {

package/src/index.ts

@@ -1,9 +1,8 @@
-export const VERSION = "2.1.6";
+export const VERSION = "2.1.8";
 
 export type { Constructor, Interval, Timeout, ValueOf } from "./core/types.js";
 
 export { isBrowser, isNode, isWorker } from "./helpers.js";
-
 export {
     AggregatedIterator,
     AggregatedAsyncIterator,

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

@@ -507,8 +507,9 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
      * @returns
      * A {@link Promise} resolving to a new {@link ReducedIterator} containing the reduced results for each group.
      */
-    public async reduce<A extends PropertyKey>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: MaybePromise<A>)
-        : Promise<ReducedIterator<K, A>>;
+    public async reduce<A extends PropertyKey>(
+        reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: MaybePromise<A>
+    ): Promise<ReducedIterator<K, A>>;
 
     /**
      * Reduces the elements of the iterator using a given reducer function.  
@@ -545,8 +546,9 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
      * @returns
      * A {@link Promise} resolving to a new {@link ReducedIterator} containing the reduced results for each group.
      */
-    public async reduce<A>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
-        : Promise<ReducedIterator<K, A>>;
+    public async reduce<A>(
+        reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>
+    ): Promise<ReducedIterator<K, A>>;
     public async reduce<A>(
         reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue?: MaybePromise<A> | ((key: K) => MaybePromise<A>)
     ): Promise<ReducedIterator<K, A>>
@@ -810,9 +812,9 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
      * A {@link Promise} resolving to a new {@link ReducedIterator} containing
      * the first element that satisfies the condition for each group.
      */
-    public async find<S extends T>(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>)
-        : Promise<ReducedIterator<K, S | undefined>>;
-
+    public async find<S extends T>(
+        predicate: MaybeAsyncKeyedIteratee<K, T, boolean>
+    ): Promise<ReducedIterator<K, S | undefined>>;
     public async find(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, T | undefined>>
     {
         const values = new Map<K, [number, T | undefined]>();
@@ -1020,8 +1022,9 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
      *
      * @returns A new {@link AggregatedAsyncIterator} containing the elements reorganized by the new keys.
      */
-    public reorganizeBy<J extends PropertyKey>(iteratee: MaybeAsyncKeyedIteratee<K, T, J>)
-        : AggregatedAsyncIterator<J, T>
+    public reorganizeBy<J extends PropertyKey>(
+        iteratee: MaybeAsyncKeyedIteratee<K, T, J>
+    ): AggregatedAsyncIterator<J, T>
     {
         const elements = this._elements;
 

package/src/models/callbacks/callable-object.ts

@@ -1,7 +1,7 @@
 import type { Callback } from "./types.js";
 
 const SmartFunction = (Function as unknown) as new<A extends unknown[] = [], R = void>(...args: string[])
-    => (...args: A) => R;
+=> Callback<A, R>;
 
 /**
  * An abstract class that can be used to implement callable objects.
@@ -30,10 +30,10 @@ const SmartFunction = (Function as unknown) as new<A extends unknown[] = [], R =
  *
  * @template T
  * The type signature of the callback function.  
- * It must be a function. Default is `(...args: any[]) => any`.
+ * It must be a function. Default is `() => void`.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default abstract class CallableObject<T extends Callback<any[], any> = () => void>
+export default abstract class CallableObject<T extends Callback<any[], any> = Callback>
     extends SmartFunction<Parameters<T>, ReturnType<T>>
 {
     /**
@@ -41,7 +41,7 @@ export default abstract class CallableObject<T extends Callback<any[], any> = ()
      */
     public constructor()
     {
-        super(`return this._invoke(...arguments);`);
+        super("return this._invoke(...arguments);");
 
         const self = this.bind(this);
         Object.setPrototypeOf(this, self);

package/src/models/callbacks/publisher.ts

@@ -2,8 +2,8 @@ import { ReferenceException } from "../exceptions/index.js";
 
 import type { Callback, CallbackMap, InternalsEventsMap, WildcardEventsMap } from "./types.js";
 
-type I = InternalsEventsMap;
-type W = WildcardEventsMap;
+type P = InternalsEventsMap;
+type S = WildcardEventsMap & InternalsEventsMap;
 
 /**
  * A class implementing the
@@ -68,33 +68,6 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
         this._subscribers = new Map();
     }
 
-    /**
-     * Unsubscribes all the subscribers from all the events.
-     *
-     * ---
-     *
-     * @example
-     * ```ts
-     * publisher.subscribe("player:spawn", (evt) => { [...] });
-     * publisher.subscribe("player:move", (coords) => { [...] });
-     * publisher.subscribe("player:move", () => { [...] });
-     * publisher.subscribe("player:move", ({ x, y }) => { [...] });
-     * publisher.subscribe("player:death", () => { [...] });
-     *
-     * // All these subscribers are working fine...
-     *
-     * publisher.clear();
-     *
-     * // ... but now they're all gone!
-     * ```
-     */
-    public clear(): void
-    {
-        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.
@@ -110,8 +83,8 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * 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.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 *
@@ -120,29 +93,29 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * ---
      *
      * @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`.
+     * A map containing the additional names of the emittable events and
+     * the related callback signatures that can be subscribed to them.
+     * Default is `{ }`.
      *
      * @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>(): Publisher<U>
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    public createScope<U extends CallbackMap<U> = { }>(): Publisher<U & T>
     {
-        const scope = new Publisher<U>();
+        const scope = new Publisher();
 
         this.subscribe("__internals__:clear", () => scope.clear());
-        this.subscribe("*", (event, ...args): void =>
-        {
-            scope.publish(event as keyof U & string, ...args as Parameters<U[keyof U]>);
-        });
+        this.subscribe("*", (event, ...args): void => { scope.publish(event, ...args); });
 
         return scope;
     }
 
     /**
-     * Publishes an event to all the subscribers.
+     * Publishes an event to all the subscribers.  
+     * This events will trigger the wildcard listeners as well, if any.
      *
      * ---
      *
@@ -170,7 +143,8 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * Publishes an internal event to all the subscribers.
      *
      * Internal events follow the pattern `__${string}__:${string}` and are used for internal
-     * communication within the publisher system. These events won't trigger wildcard listeners.
+     * communication within the publisher system. These events won't trigger wildcard listeners.  
+     * Please note to use this method only if you know what you are doing.
      *
      * ---
      *
@@ -189,7 +163,7 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      *
      * @returns An array containing the return values of all the subscribers.
      */
-    public publish<K extends keyof I>(event: K & string, ...args: Parameters<I[K]>): ReturnType<I[K]>[];
+    public publish<K extends keyof P>(event: K & string, ...args: Parameters<P[K]>): ReturnType<P[K]>[];
     public publish(event: string, ...args: unknown[]): unknown[]
     {
         let results: unknown[];
@@ -238,33 +212,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;
-
-    /**
-     * Subscribes to an internal event and adds a subscriber to be executed when the event is published.
-     *
-     * Internal events follow the pattern `__${string}__:${string}` and
-     * are used for internal communication within the publisher system.  
-     * Please note to use this method only if you know what you are doing.
-     *
-     * ---
-     *
-     * @example
-     * ```ts
-     * publisher.subscribe("__internals__:clear", () => console.log("All subscribers have been cleared."));
-     * publisher.clear(); // "All subscribers have been cleared."
-     * ```
-     *
-     * ---
-     *
-     * @template K The key of the internal events map containing the callback signature to subscribe.
-     *
-     * @param event The name of the internal event to subscribe to.
-     * @param subscriber The subscriber to execute when the internal event is published.
-     *
-     * @returns A function that can be used to unsubscribe the subscriber from the event.
-     */
-    public subscribe<K extends keyof I>(event: K & string, subscriber: I[K]): () => void;
+    public subscribe<K extends keyof T>(event: K & string, subscriber: T[K]): Callback;
 
     /**
      * Subscribes to the wildcard event to listen to all published events.
@@ -278,21 +226,21 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      * ```ts
      * publisher.subscribe("*", (type, ...args) =>
      * {
-     *     console.log(`Event \`${type}\` was fired with args:`, args);
+     *     console.log(`Event "${type}" was fired with args:`, args);
      * });
      * ```
      *
      * ---
      *
-     * @template K The key of the wildcard events map (always "*").
+     * @template K The key of the wildcard events map (always `*`).
      *
-     * @param event The wildcard event name ("*").
+     * @param event The wildcard event name (`*`).
      * @param subscriber The subscriber to execute for all published events.
      *
      * @returns A function that can be used to unsubscribe the subscriber from the wildcard event.
      */
-    public subscribe<K extends keyof W>(event: K & string, subscriber: W[K]): () => void;
-    public subscribe(event: string, subscriber: Callback<unknown[], unknown>): () => void
+    public subscribe<K extends keyof S>(event: K & string, subscriber: S[K]): Callback;
+    public subscribe(event: string, subscriber: Callback<unknown[], unknown>): Callback
     {
         const subscribers = this._subscribers.get(event) ?? [];
         subscribers.push(subscriber);
@@ -334,31 +282,6 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      */
     public unsubscribe<K extends keyof T>(event: K & string, subscriber: T[K]): void;
 
-    /**
-     * Unsubscribes from an internal event and removes a subscriber from being executed when the event is published.
-     *
-     * Internal events follow the pattern `__${string}__:${string}` and
-     * are used for internal communication within the publisher system.
-     *
-     * ---
-     *
-     * @example
-     * ```ts
-     * const onClear = () => console.log("Publisher cleared");
-     * 
-     * publisher.subscribe("__internals__:clear", onClear);
-     * publisher.unsubscribe("__internals__:clear", onClear);
-     * ```
-     *
-     * ---
-     *
-     * @template K The key of the internal events map containing the callback signature to unsubscribe.
-     *
-     * @param event The name of the internal event to unsubscribe from.
-     * @param subscriber The subscriber to remove from the internal event.
-     */
-    public unsubscribe<K extends keyof I>(event: K & string, subscriber: I[K]): void;
-
     /**
      * Unsubscribes from the wildcard event and removes a subscriber from being executed for all events.
      *
@@ -376,12 +299,12 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
      *
      * ---
      *
-     * @template K The key of the wildcard events map (always "*").
+     * @template K The key of the wildcard events map (always `*`).
      *
-     * @param event The wildcard event name ("*").
+     * @param event The wildcard event name (`*`).
      * @param subscriber The wildcard subscriber to remove.
      */
-    public unsubscribe<K extends keyof W>(event: K & string, subscriber: W[K]): void;
+    public unsubscribe<K extends keyof S>(event: K & string, subscriber: S[K]): void;
     public unsubscribe(event: string, subscriber: Callback<unknown[], unknown>): void
     {
         const subscribers = this._subscribers.get(event);
@@ -402,5 +325,94 @@ export default class Publisher<T extends CallbackMap<T> = CallbackMap>
         if (subscribers.length === 0) { this._subscribers.delete(event); }
     }
 
+    /**
+     * Unsubscribes all subscribers from a specific event and removes
+     * them from being executed when the event is published.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * publisher.subscribe("player:spawn", (evt) => { [...] });
+     * publisher.subscribe("player:move", (coords) => { [...] });
+     * publisher.subscribe("player:move", () => { [...] });
+     * publisher.subscribe("player:move", ({ x, y }) => { [...] });
+     * publisher.subscribe("player:death", () => { [...] });
+     *
+     * // All these subscribers are working fine...
+     *
+     * publisher.unsubscribeAll("player:move");
+     *
+     * // ... but now "player:move" subscribers are gone!
+     * ```
+     *
+     * ---
+     *
+     * @template K The key of the map containing the event to clear.
+     *
+     * @param event The name of the event to unsubscribe all subscribers from.
+     */
+    public unsubscribeAll<K extends keyof T>(event: K & string): void;
+
+    /**
+     * Unsubscribes all subscribers from the wildcard event and removes
+     * them from being executed for all published events.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * publisher.subscribe("player:spawn", (evt) => { [...] });
+     * publisher.subscribe("*", (type, ...args) => { [...] });
+     * publisher.subscribe("*", (type, arg1, arg2, arg3) => { [...] });
+     * publisher.subscribe("*", (_, arg, ...rest) => { [...] });
+     * publisher.subscribe("player:death", () => { [...] });
+     *
+     * // All these subscribers are working fine...
+     *
+     * publisher.unsubscribeAll("*");
+     *
+     * // ... but now wildcard subscribers are gone!
+     * ```
+     *
+     * ---
+     *
+     * @template K The key of the wildcard events map (`*`).
+     *
+     * @param event The wildcard event name (`*`).
+     */
+    public unsubscribeAll<K extends keyof S>(event: K & string): void;
+    public unsubscribeAll(event: string): void
+    {
+        this._subscribers.delete(event);
+    }
+
+    /**
+     * Unsubscribes all the subscribers from all the events.
+     *
+     * ---
+     *
+     * @example
+     * ```ts
+     * publisher.subscribe("player:spawn", (evt) => { [...] });
+     * publisher.subscribe("player:move", (coords) => { [...] });
+     * publisher.subscribe("*", () => { [...] });
+     * publisher.subscribe("player:move", ({ x, y }) => { [...] });
+     * publisher.subscribe("player:death", () => { [...] });
+     *
+     * // All these subscribers are working fine...
+     *
+     * publisher.clear();
+     *
+     * // ... but now they're all gone!
+     * ```
+     */
+    public clear(): void
+    {
+        this.publish("__internals__:clear");
+
+        this._subscribers.clear();
+    }
+
     public readonly [Symbol.toStringTag]: string = "Publisher";
 }

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

@@ -27,7 +27,7 @@ const Disabler = () => { /* ... */ };
  *
  * ---
  *
- * @template T The type signature of the callback. Default is `(...args: any[]) => any`.
+ * @template T The type signature of the callback. Default is `() => void`.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export default class SwitchableCallback<T extends Callback<any[], any> = Callback> extends CallableObject<T>
@@ -130,7 +130,6 @@ export default class SwitchableCallback<T extends Callback<any[], any> = Callbac
                     "The `SwitchableCallback` has no callback defined yet. " +
                     "Did you forget to call the `register` method?"
                 );
-
             }) as unknown) as T;
         }
 

package/src/models/callbacks/types.ts

@@ -69,7 +69,7 @@ export type CallbackMap<T = Record<string, Callback<unknown[], unknown>>> = { [K
  * publisher.clear(); // "Publisher cleared"
  * ```
  */
-export type InternalsEventsMap = Record<`__${string}__:${string}`, (...args: unknown[]) => unknown>;
+export type InternalsEventsMap = Record<`__${string}__:${string}`, Callback<unknown[], unknown>>;
 
 /**
  * An utility interface that defines a wildcard event for listening to all events.
@@ -87,14 +87,14 @@ export type InternalsEventsMap = Record<`__${string}__:${string}`, (...args: unk
  *
  * publisher.subscribe("*", (type: string, ...args: unknown[]) =>
  * {
- *     console.log(`Event \`${type}\` was fired with args:`, args));
+ *     console.log(`Event "${type}" was fired with args:`, args));
  * });
  * 
  * publisher.publish("player:move", { x: 10, y: 20 }); // "Event `player:move` was fired with args: [{ x: 10, y: 20 }]"
  * publisher.publish("player:death"); // "Event `player:death` was fired with args: []"
  * ```
  */
-export interface WildcardEventsMap { "*": (type: string, ...args: unknown[]) => void; }
+export interface WildcardEventsMap { "*": (type: string, ...args: unknown[]) => void }
 
 /**
  * An utility type that represents a {@link Publisher} object that can be published to.
@@ -178,7 +178,7 @@ export interface Subscribable<T extends CallbackMap<T> = CallbackMap>
      *
      * @returns A function that can be used to unsubscribe the subscriber from the event.
      */
-    subscribe<K extends keyof T>(event: K & string, subscriber: T[K]): () => void;
+    subscribe<K extends keyof T>(event: K & string, subscriber: T[K]): Callback;
 
     /**
      * Unsubscribes from an event and removes a subscriber from being executed when the event is published.

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

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

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

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

package/src/models/collections/types.ts

@@ -1,3 +1,5 @@
+import type { Callback } from "../types.js";
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type MapView from "./map-view.js";
 
@@ -66,7 +68,7 @@ export interface ReadonlyMapView<K, V> extends ReadonlyMap<K, V>
      *
      * @returns A function that can be used to unsubscribe the callback from the event.
      */
-    subscribe<T extends keyof MapViewEventsMap<K, V>>(event: T, callback: MapViewEventsMap<K, V>[T]): () => void;
+    subscribe<T extends keyof MapViewEventsMap<K, V>>(event: T & string, callback: MapViewEventsMap<K, V>[T]): Callback;
 
     /**
      * Unsubscribes from an event and removes a callback from being executed when the event is published.
@@ -92,7 +94,7 @@ export interface ReadonlyMapView<K, V> extends ReadonlyMap<K, V>
      * @param event The name of the event to unsubscribe from.
      * @param callback The callback to remove from the event.
      */
-    unsubscribe<T extends keyof MapViewEventsMap<K, V>>(event: T, callback: MapViewEventsMap<K, V>[T]): void;
+    unsubscribe<T extends keyof MapViewEventsMap<K, V>>(event: T & string, callback: MapViewEventsMap<K, V>[T]): void;
 }
 
 /**
@@ -155,7 +157,7 @@ export interface ReadonlySetView<T> extends ReadonlySet<T>
      *
      * @returns A function that can be used to unsubscribe the callback from the event.
      */
-    subscribe<K extends keyof SetViewEventsMap<T>>(event: K, callback: SetViewEventsMap<T>[K]): () => void;
+    subscribe<K extends keyof SetViewEventsMap<T>>(event: K & string, callback: SetViewEventsMap<T>[K]): Callback;
 
     /**
      * Unsubscribes from an event and removes a callback from being executed when the event is published.
@@ -181,5 +183,5 @@ export interface ReadonlySetView<T> extends ReadonlySet<T>
      * @param event The name of the event to unsubscribe from.
      * @param callback The callback to remove from the event.
      */
-    unsubscribe<K extends keyof SetViewEventsMap<T>>(event: K, callback: SetViewEventsMap<T>[K]): void;
+    unsubscribe<K extends keyof SetViewEventsMap<T>>(event: K & string, callback: SetViewEventsMap<T>[K]): void;
 }

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

@@ -212,7 +212,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
 
                         next = [yield result.value];
                     }
-
                 })();
             }
         }
@@ -232,7 +231,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
 
                     yield result.value;
                 }
-
             })();
         }
         else
@@ -248,7 +246,6 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
 
                     next = [yield result.value];
                 }
-
             })();
         }
     }

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

@@ -178,8 +178,7 @@ export default class JSONStorage
      * @returns The value with the specified key or the default value if the key doesn't exist.
      */
     public get<T extends JSONValue>(key: string, defaultValue?: T, persistent?: boolean): T | undefined;
-    public get<T extends JSONValue>(key: string, defaultValue?: T, persistent = this._preferPersistence)
-        : T | undefined
+    public get<T extends JSONValue>(key: string, defaultValue?: T, persistent = this._preferPersistence): T | undefined
     {
         const storage = persistent ? this._persistent : this._volatile;
 

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

@@ -103,9 +103,9 @@ export default class PromiseQueue extends SmartPromise<void>
      *
      * @param promise A `DeferredPromise<void, T>` instance to enqueue.
      *
-     * @returns A {@link Promise} that resolves to the value of the enqueued promise.
+     * @returns A {@link SmartPromise} that resolves to the value of the enqueued promise.
      */
-    public enqueue<T>(promise: DeferredPromise<void, T>): Promise<T>;
+    public enqueue<T>(promise: DeferredPromise<void, T>): SmartPromise<T>;
 
     /**
      * Enqueues a {@link DeferredPromise} into the queue with an optional timeout.
@@ -156,9 +156,9 @@ export default class PromiseQueue extends SmartPromise<void>
      *
      * @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.
+     * @returns A {@link SmartPromise} that resolves to the value of the enqueued executor.
      */
-    public enqueue<T>(executor: Callback<[], MaybePromise<T>>): Promise<T>;
+    public enqueue<T>(executor: Callback<[], MaybePromise<T>>): SmartPromise<T>;
 
     /**
      * Enqueues a callback that returns a {@link MaybePromise}
@@ -188,8 +188,9 @@ export default class PromiseQueue extends SmartPromise<void>
      * 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>
+    public enqueue<T>(
+        executor: DeferredPromise<void, T> | Callback<[], MaybePromise<T>>, timeout?: number
+    ): SmartPromise<T> | TimedPromise<T>
     {
         this._count += 1;
 
@@ -215,7 +216,7 @@ export default class PromiseQueue extends SmartPromise<void>
 
         if (timeout) { return new TimedPromise<T>(_executor, timeout); }
 
-        return new Promise<T>(_executor);
+        return new SmartPromise<T>(_executor);
     }
 
     public override readonly [Symbol.toStringTag]: string = "PromiseQueue";