@byloth/core 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -57,10 +57,10 @@
   },
   "devDependencies": {
     "@byloth/eslint-config-typescript": "^2.7.0",
-    "@typescript-eslint/eslint-plugin": "^7.0.2",
-    "@typescript-eslint/parser": "^7.0.2",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
     "eslint": "^8.57.0",
-    "typescript": "^5.3.3",
-    "vite": "^5.1.4"
+    "typescript": "^5.4.2",
+    "vite": "^5.1.6"
   }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "1.3.0";
+export const VERSION = "1.3.1";
 
 export {
     AggregatedIterator,
@@ -8,6 +8,7 @@ export {
     JsonStorage,
     ReducedIterator,
     SmartIterator,
+    SmartPromise,
     Subscribers
 
 } from "./models/index.js";

package/src/models/index.ts

@@ -2,14 +2,13 @@ import Exception from "./exception.js";
 import SmartIterator from "./smart-iterator.js";
 import Aggregator, { AggregatedIterator, ReducedIterator } from "./aggregators/index.js";
 
-import DeferredPromise from "./deferred-promise.js";
 import JsonStorage from "./json-storage.js";
 import Subscribers from "./subscribers.js";
 
+export { DeferredPromise, SmartPromise } from "./promises/index.js";
 export {
     AggregatedIterator,
     Aggregator,
-    DeferredPromise,
     Exception,
     JsonStorage,
     ReducedIterator,

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

@@ -0,0 +1,117 @@
+import type {
+    PromiseResolver,
+    PromiseRejecter,
+    FulfilledHandler,
+    RejectedHandler,
+    PromiseExecutor
+
+} from "../../types.js";
+
+export default class DeferredPromise<T = void, E = unknown, F = T, R = never>
+{
+    protected _isPending: boolean;
+    protected _isFulfilled: boolean;
+    protected _isRejected: boolean;
+
+    protected _resolve!: PromiseResolver<T>;
+    protected _reject!: PromiseRejecter<E>;
+
+    protected _promise: Promise<F | R>;
+
+    public constructor(onFulfilled?: FulfilledHandler<T, F> | null, onRejected?: RejectedHandler<E, R> | null)
+    {
+        this._isPending = true;
+        this._isFulfilled = false;
+        this._isRejected = false;
+
+        let _resolve: PromiseResolver<T>;
+        let _reject: PromiseRejecter<E>;
+
+        const executor: PromiseExecutor<T, E> = (resolve, reject) =>
+        {
+            _resolve = resolve;
+            _reject = reject;
+        };
+
+        let _onFulfilled: FulfilledHandler<T, F>;
+        if (onFulfilled)
+        {
+            _onFulfilled = (value) =>
+            {
+                this._isPending = false;
+                this._isFulfilled = true;
+
+                return onFulfilled!(value);
+            };
+        }
+        else
+        {
+            _onFulfilled = (value) =>
+            {
+                this._isPending = false;
+                this._isFulfilled = true;
+
+                return (value as unknown) as F;
+            };
+        }
+
+        let _onRejected: RejectedHandler<E, R>;
+        if (onRejected)
+        {
+            _onRejected = (reason) =>
+            {
+                this._isPending = false;
+                this._isRejected = true;
+
+                return onRejected!(reason);
+            };
+        }
+        else
+        {
+            _onRejected = (reason) =>
+            {
+                this._isPending = false;
+                this._isRejected = true;
+
+                return (reason as unknown) as R;
+            };
+        }
+
+        this._promise = new Promise<T>(executor)
+            .then(_onFulfilled, _onRejected);
+
+        this._resolve = _resolve!;
+        this._reject = _reject!;
+    }
+
+    public get isPending(): boolean { return this._isPending; }
+    public get isFulfilled(): boolean { return this._isFulfilled; }
+    public get isRejected(): boolean { return this._isRejected; }
+
+    public get resolve(): PromiseResolver<T> { return this._resolve; }
+    public get reject(): PromiseRejecter<E> { return this._reject; }
+
+    public then<N = F | R, H = R>(
+        onFulfilled?: FulfilledHandler<F | R, N> | null,
+        onRejected?: RejectedHandler<R, H> | null): Promise<N | H>
+    {
+        return this._promise.then(onFulfilled, onRejected);
+    }
+    public catch<H = R>(onRejected?: RejectedHandler<R, H> | null): Promise<F | R | H>
+    {
+        return this._promise.catch(onRejected);
+    }
+    public finally(onFinally?: (() => void) | null): Promise<F | R>
+    {
+        return this._promise.finally(onFinally);
+    }
+
+    public watch(promise: Promise<T>): this
+    {
+        promise.then(this.resolve, this.reject);
+
+        return this;
+    }
+
+    public get [Symbol.toStringTag]() { return "DeferredPromise"; }
+}

package/src/models/promises/index.ts

@@ -0,0 +1,4 @@
+import DeferredPromise from "./deferred-promise.js";
+import SmartPromise from "./smart-promise.js";
+
+export { DeferredPromise, SmartPromise };

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

@@ -0,0 +1,56 @@
+import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "../../types.js";
+
+export default class SmartPromise<T = void, E = unknown>
+{
+    protected _isPending: boolean;
+    protected _isFulfilled: boolean;
+    protected _isRejected: boolean;
+
+    protected _promise: Promise<T | E>;
+
+    public constructor(executor: PromiseExecutor<T, E>)
+    {
+        this._isPending = true;
+        this._isFulfilled = false;
+        this._isRejected = false;
+
+        const _resolve = (result: T): T =>
+        {
+            this._isPending = false;
+            this._isFulfilled = true;
+
+            return result;
+        };
+        const _reject = (reason: E): E =>
+        {
+            this._isPending = false;
+            this._isRejected = true;
+
+            return reason;
+        };
+
+        this._promise = new Promise<T>(executor)
+            .then(_resolve, _reject);
+    }
+
+    public get isPending(): boolean { return this._isPending; }
+    public get isFulfilled(): boolean { return this._isFulfilled; }
+    public get isRejected(): boolean { return this._isRejected; }
+
+    public then<F = T, R = E>(
+        onFulfilled?: FulfilledHandler<T | E, F> | null,
+        onRejected?: RejectedHandler<E, R> | null): Promise<F | R>
+    {
+        return this._promise.then(onFulfilled, onRejected);
+    }
+    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 "SmartPromise"; }
+}

package/src/types.ts

@@ -10,7 +10,7 @@ export type MaybePromise<T> = T | PromiseLike<T>;
 export type FulfilledHandler<T = void, R = T> = (value: T) => MaybePromise<R>;
 export type RejectedHandler<E = unknown, R = never> = (reason: E) => MaybePromise<R>;
 
-export type PromiseResolver<T = void> = (result?: MaybePromise<T>) => void;
+export type PromiseResolver<T = void> = (result: MaybePromise<T>) => void;
 export type PromiseRejecter<E = unknown> = (reason?: MaybePromise<E>) => void;
 export type PromiseExecutor<T = void, E = unknown> = (resolve: PromiseResolver<T>, reject: PromiseRejecter<E>) => void;
 

package/src/models/deferred-promise.ts

@@ -1,61 +0,0 @@
-import type { PromiseResolver, PromiseRejecter, FulfilledHandler, RejectedHandler } from "../types.js";
-
-export default class DeferredPromise<T = void, E = unknown, F = T, R = never>
-{
-    protected _resolve!: PromiseResolver<T>;
-    protected _reject!: PromiseRejecter<E>;
-
-    protected _promise: Promise<F | R>;
-
-    public constructor(onFulfilled?: FulfilledHandler<T, F> | null, onRejected?: RejectedHandler<E, R> | null)
-    {
-        let _resolve: PromiseResolver<T>;
-        let _reject: PromiseRejecter<E>;
-
-        this._promise = new Promise<T>((resolve, reject) =>
-        {
-            _resolve = resolve as PromiseResolver<T>;
-            _reject = reject as PromiseRejecter<E>;
-
-        }).then(onFulfilled, onRejected);
-
-        this._resolve = _resolve!;
-        this._reject = _reject!;
-    }
-
-    public get resolve(): PromiseResolver<T>
-    {
-        return this._resolve;
-    }
-    public get reject(): PromiseRejecter<E>
-    {
-        return this._reject;
-    }
-
-    public then<N = F | R, H = R>(
-        onFulfilled?: FulfilledHandler<F | R, N> | null,
-        onRejected?: RejectedHandler<R, H> | null): Promise<N | H>
-    {
-        return this._promise.then(onFulfilled, onRejected);
-    }
-    public catch<H = R>(onRejected?: RejectedHandler<R, H> | null): Promise<F | R | H>
-    {
-        return this._promise.catch(onRejected);
-    }
-    public finally(onFinally?: (() => void) | null): Promise<F | R>
-    {
-        return this._promise.finally(onFinally);
-    }
-
-    public watch(promise: Promise<T>): this
-    {
-        promise.then(this.resolve, this.reject);
-
-        return this;
-    }
-
-    public get [Symbol.toStringTag]()
-    {
-        return "DeferredPromise";
-    }
-}