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

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

@@ -1,73 +1,50 @@
-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>
+export default class TimedPromise<T = void> extends Promise<T>
 {
     protected _isPending: boolean;
     protected _isFulfilled: boolean;
     protected _isRejected: boolean;
 
-    protected _promise: Promise<T>;
-
-    public constructor(executor: PromiseExecutor<T, E>, timeout: number)
+    public constructor(executor: PromiseExecutor<T>, timeout?: number)
     {
-        this._isPending = true;
-        this._isFulfilled = false;
-        this._isRejected = false;
-
-        const _onFulfilled = (result: T): T =>
+        super((resolve, reject) =>
         {
-            this._isPending = false;
-            this._isFulfilled = true;
+            const _resolve = (result: MaybePromise<T>) =>
+            {
+                this._isPending = false;
+                this._isFulfilled = true;
 
-            return result;
-        };
-        const _onRejected = (reason: E): never =>
-        {
-            this._isPending = false;
-            this._isRejected = true;
+                clearTimeout(_timeoutId);
+                resolve(result);
+            };
+            const _reject = (reason: unknown) =>
+            {
+                this._isPending = false;
+                this._isRejected = true;
 
-            throw reason;
-        };
+                clearTimeout(_timeoutId);
+                reject(reason);
+            };
 
-        const _executor = new Promise<T>(executor);
-        const _timeout = new Promise<never>((_, reject) => setTimeout(() =>
-        {
-            reject(new TimeoutException("The operation has timed out."));
+            const _timeoutId = setTimeout(() =>
+            {
+                _reject(new TimeoutException("The operation has timed out."));
+
+            }, timeout);
 
-        }, timeout));
+            executor(_resolve, _reject);
+        });
 
-        this._promise = Promise.race([_executor, _timeout])
-            .then(_onFulfilled, _onRejected);
+        this._isPending = true;
+        this._isFulfilled = false;
+        this._isRejected = false;
     }
 
     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/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;
 }