@byloth/core 1.5.0-rc.2 → 1.5.0-rc.4

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

@@ -1,72 +1,30 @@
-import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "../../types.js";
+import type { MaybePromise, PromiseExecutor } 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>;
+import SmartPromise from "./smart-promise.js";
 
-    public constructor(executor: PromiseExecutor<T, E>, timeout: number)
+export default class TimedPromise<T = void> extends SmartPromise<T>
+{
+    public constructor(executor: PromiseExecutor<T>, 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): never =>
+        super((resolve, reject) =>
         {
-            this._isPending = false;
-            this._isRejected = true;
-
-            throw 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);
+            const _resolve = (result: MaybePromise<T>) =>
+            {
+                clearTimeout(_timeoutId);
+                resolve(result);
+            };
+            const _reject = (reason: unknown) =>
+            {
+                clearTimeout(_timeoutId);
+                reject(reason);
+            };
+
+            const _timeout = () => _reject(new TimeoutException("The operation has timed out."));
+            const _timeoutId = setTimeout(_timeout, timeout);
+
+            executor(_resolve, _reject);
+        });
     }
 
     public get [Symbol.toStringTag]() { return "TimedPromise"; }

package/src/utils/math.ts

@@ -1,3 +1,4 @@
+import { ValueException } from "../models/exceptions/index.js";
 import { zip } from "./iterator.js";
 
 export function average<T extends number>(values: Iterable<T>): number;
@@ -7,26 +8,33 @@ export function average<T extends number>(values: Iterable<T>, weights?: Iterabl
     if (weights === undefined)
     {
         let _sum = 0;
-        let _count = 0;
+        let _index = 0;
 
         for (const value of values)
         {
             _sum += value;
-            _count += 1;
+            _index += 1;
         }
 
-        return _sum / _count;
+        if (_index === 0) { throw new ValueException("You must provide at least one value."); }
+
+        return _sum / _index;
     }
 
     let _sum = 0;
     let _count = 0;
+    let _index = 0;
 
     for (const [value, weight] of zip(values, weights))
     {
         _sum += value * weight;
         _count += weight;
+        _index += 1;
     }
 
+    if (_index === 0) { throw new ValueException("You must provide at least one value and weight."); }
+    if (_count === 0) { throw new ValueException("The sum of weights must be greater than zero."); }
+
     return _sum / _count;
 }