@byloth/core 1.4.0 → 1.5.0-rc.1

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

@@ -0,0 +1,73 @@
+import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "../../types.js";
+import { TimeoutException } from "../exceptions/index.js";
+
+export default class TimedPromise<T = void, E = unknown>
+{
+    protected _isPending: boolean;
+    protected _isFulfilled: boolean;
+    protected _isRejected: boolean;
+
+    protected _promise: Promise<T | E>;
+
+    public constructor(executor: PromiseExecutor<T, E>, timeout: number)
+    {
+        this._isPending = true;
+        this._isFulfilled = false;
+        this._isRejected = false;
+
+        const _onFulfilled = (result: T): T =>
+        {
+            this._isPending = false;
+            this._isFulfilled = true;
+
+            return result;
+        };
+        const _onRejected = (reason: E): E =>
+        {
+            this._isPending = false;
+            this._isRejected = true;
+
+            return reason;
+        };
+
+        const _executor = new Promise<T>(executor);
+        const _timeout = new Promise<never>((_, reject) => setTimeout(() =>
+        {
+            reject(new TimeoutException("The operation has timed out."));
+
+        }, timeout));
+
+        this._promise = Promise.race([_executor, _timeout])
+            .then(_onFulfilled, _onRejected);
+    }
+
+    public get isPending(): boolean { return this._isPending; }
+    public get isFulfilled(): boolean { return this._isFulfilled; }
+    public get isRejected(): boolean { return this._isRejected; }
+
+    public then(onFulfilled?: null): Promise<T | E>;
+    public then<F = T | E>(onFulfilled: FulfilledHandler<T | E, F>, onRejected?: null): Promise<F>;
+    public then<F = T, R = E>(
+        onFulfilled: FulfilledHandler<T, F>,
+        onRejected: RejectedHandler<E, R>): Promise<F | R>;
+    public then<F = T, R = E>(
+        onFulfilled?: FulfilledHandler<T, F> | null,
+        onRejected?: RejectedHandler<E, R> | null): Promise<F | R>
+    {
+        return this._promise.then(onFulfilled as FulfilledHandler<T | E, F>, onRejected);
+    }
+
+    public catch(onRejected?: null): Promise<T | E>;
+    public catch<R = E>(onRejected: RejectedHandler<E, R>): Promise<T | R>;
+    public catch<R = E>(onRejected?: RejectedHandler<E, R> | null): Promise<T | E | R>
+    {
+        return this._promise.catch(onRejected);
+    }
+
+    public finally(onFinally?: (() => void) | null): Promise<T | E>
+    {
+        return this._promise.finally(onFinally);
+    }
+
+    public get [Symbol.toStringTag]() { return "TimedPromise"; }
+}

package/src/models/smart-iterator.ts

@@ -1,4 +1,4 @@
-import type { GeneratorFunction, Iteratee, Reducer } from "../types.js";
+import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer } from "../types.js";
 
 export default class SmartIterator<T, R = void, N = undefined> implements Iterator<T, R, N>
 {
@@ -61,6 +61,8 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         }
     }
 
+    public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>;
+    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartIterator<T, S>;
     public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>
     {
         const iterator = this._iterator;

package/src/models/subscribers.ts

@@ -1,4 +1,4 @@
-import Exception from "./exception.js";
+import { ReferenceException } from "./exceptions/index.js";
 
 export default class Subscribers<P extends unknown[] = [], R = void, T extends (...args: P) => R = (...args: P) => R>
 {
@@ -18,7 +18,7 @@ export default class Subscribers<P extends unknown[] = [], R = void, T extends (
         const index = this._subscribers.indexOf(subscriber);
         if (index < 0)
         {
-            throw new Exception("Unable to remove the requested subscriber. It was not found.");
+            throw new ReferenceException("Unable to remove the requested subscriber. It was not found.");
         }
 
         this._subscribers.splice(index, 1);

package/src/types.ts

@@ -4,6 +4,8 @@ export type Constructor<T extends object, P extends unknown[] = any[]> = new (..
 export type GeneratorFunction<T, R = void, N = undefined> = () => Generator<T, R, N>;
 export type AsyncGeneratorFunction<T, R = void, N = undefined> = () => AsyncGenerator<T, R, N>;
 export type Iteratee<T, R = void> = (value: T, index: number) => R;
+export type TypeGuardIteratee<T, R extends T> = (value: T, index: number) => value is R;
+
 export type Reducer<T, A> = (accumulator: A, value: T, index: number) => A;
 
 export type MaybePromise<T> = T | PromiseLike<T>;