@byloth/core 1.3.0-rc.2 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "1.3.0-rc.2",
+  "version": "1.3.1",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -56,11 +56,11 @@
     "ci": "yarn install --frozen-lockfile"
   },
   "devDependencies": {
-    "@byloth/eslint-config-typescript": "^2.6.8",
-    "@typescript-eslint/eslint-plugin": "^6.19.1",
-    "@typescript-eslint/parser": "^6.19.1",
-    "eslint": "^8.56.0",
-    "typescript": "^5.3.3",
-    "vite": "^5.0.12"
+    "@byloth/eslint-config-typescript": "^2.7.0",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "eslint": "^8.57.0",
+    "typescript": "^5.4.2",
+    "vite": "^5.1.6"
   }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "1.3.0-rc.2";
+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/aggregators/_index.old.ts

@@ -1,384 +0,0 @@
-export function aggregate<V>(elements: Iterable<V>)
-{
-    type Iteratee<K> = (element: V, index: number) => K;
-
-    function byKey<K extends string | number | symbol>(iteratee: Iteratee<K>)
-    {
-        function countToMap()
-        {
-            const counts = new Map<K, number>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                const key = iteratee(element, index);
-
-                if (counts.has(key))
-                {
-                    counts.set(key, counts.get(key)! + 1);
-                }
-                else
-                {
-                    counts.set(key, 1);
-                }
-
-                index += 1;
-            }
-
-            return counts;
-        }
-        function countToDict()
-        {
-            const mapCounts = countToMap();
-            const dictCounts = { } as Record<K, number>;
-
-            for (const [key, _count] of mapCounts.entries())
-            {
-                dictCounts[key] = _count;
-            }
-
-            return dictCounts;
-        }
-        function count()
-        {
-            return Array.from(countToMap().values());
-        }
-
-        function groupToMap()
-        {
-            const groups = new Map<K, V[]>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                const key = iteratee(element, index);
-
-                if (groups.has(key))
-                {
-                    groups.get(key)!
-                        .push(element);
-                }
-                else
-                {
-                    groups.set(key, [element]);
-                }
-
-                index += 1;
-            }
-
-            return groups;
-        }
-        function groupToDict()
-        {
-            const mapGroups = groupToMap();
-            const dictGroup = { } as Record<K, V[]>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = _group;
-            }
-
-            return dictGroup;
-        }
-        function group()
-        {
-            return Array.from(groupToMap().values());
-        }
-
-        type Reducer<R = V> = (key: K, group: R | undefined, element: V, index: number) => R;
-
-        function reduceToMap<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            const counts = new Map<K, number>();
-            const groups = new Map<K, R>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                let _count = 0;
-                let _group = initialValue;
-
-                const key = iteratee(element, index);
-                if (groups.has(key))
-                {
-                    _count = counts.get(key)!;
-                    _group = groups.get(key)!;
-                }
-
-                _group = reducer(key, _group, element, _count);
-
-                counts.set(key, _count + 1);
-                groups.set(key, _group);
-
-                index += 1;
-            }
-
-            return groups;
-        }
-        function reduceToDict<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            const mapGroups = reduceToMap(reducer, initialValue);
-            const dictGroup = { } as Record<K, R>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = _group;
-            }
-
-            return dictGroup;
-        }
-        function reduce<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            return Array.from(reduceToMap(reducer, initialValue).values());
-        }
-
-        async function asyncReduceToMap<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            const awaitedGroups = new Map<K, R>();
-            const asyncGroups = reduceToMap(reducer, initialValue);
-
-            for (const [key, asyncGroup] of asyncGroups.entries())
-            {
-                awaitedGroups.set(key, await asyncGroup);
-            }
-
-            return awaitedGroups;
-        }
-        async function asyncReduceToDict<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            const mapGroups = reduceToMap(reducer, initialValue);
-            const dictGroup = { } as Record<K, R>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = await _group;
-            }
-
-            return dictGroup;
-        }
-        function asyncReduce<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            return Promise.all(reduce(reducer, initialValue));
-        }
-
-        return {
-            count,
-            countToMap,
-            countToDict,
-            group,
-            groupToMap,
-            groupToDict,
-            reduce,
-            reduceToMap,
-            reduceToDict,
-            asyncReduce,
-            asyncReduceToMap,
-            asyncReduceToDict
-        };
-    }
-    function byAsyncKey<K extends string | number | symbol>(iteratee: Iteratee<Promise<K>>)
-    {
-        async function countToMap()
-        {
-            const counts = new Map<K, number>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                const key = await iteratee(element, index);
-
-                if (counts.has(key))
-                {
-                    counts.set(key, counts.get(key)! + 1);
-                }
-                else
-                {
-                    counts.set(key, 1);
-                }
-
-                index += 1;
-            }
-
-            return counts;
-        }
-        async function countToDict()
-        {
-            const mapCounts = await countToMap();
-            const dictCounts = { } as Record<K, number>;
-
-            for (const [key, _count] of mapCounts.entries())
-            {
-                dictCounts[key] = _count;
-            }
-
-            return dictCounts;
-        }
-        async function count()
-        {
-            const counts = await countToMap();
-
-            return Array.from(counts.values());
-        }
-
-        async function groupToMap()
-        {
-            const groups = new Map<K, V[]>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                const key = await iteratee(element, index);
-
-                if (groups.has(key))
-                {
-                    groups.get(key)!
-                        .push(element);
-                }
-                else
-                {
-                    groups.set(key, [element]);
-                }
-
-                index += 1;
-            }
-
-            return groups;
-        }
-        async function groupToDict()
-        {
-            const mapGroups = await groupToMap();
-            const dictGroup = { } as Record<K, V[]>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = _group;
-            }
-
-            return dictGroup;
-        }
-        async function group()
-        {
-            const groups = await groupToMap();
-
-            return Array.from(groups.values());
-        }
-
-        type Reducer<R = V> = (key: K, group: R | undefined, element: V, index: number) => R;
-
-        async function reduceToMap<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            const counts = new Map<K, number>();
-            const groups = new Map<K, R>();
-
-            let index = 0;
-            for (const element of elements)
-            {
-                let _count = 0;
-                let _group = initialValue;
-
-                const key = await iteratee(element, index);
-                if (groups.has(key))
-                {
-                    _count = counts.get(key)!;
-                    _group = groups.get(key)!;
-                }
-
-                _group = reducer(key, _group, element, _count);
-
-                counts.set(key, _count + 1);
-                groups.set(key, _group);
-
-                index += 1;
-            }
-
-            return groups;
-        }
-        async function reduceToDict<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            const mapGroups = await reduceToMap(reducer, initialValue);
-            const dictGroup = { } as Record<K, R>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = _group;
-            }
-
-            return dictGroup;
-        }
-        async function reduce<R = V>(reducer: Reducer<R>, initialValue?: R | undefined)
-        {
-            const groups = await reduceToMap(reducer, initialValue);
-
-            return Array.from(groups.values());
-        }
-
-        async function asyncReduceToMap<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            const awaitedGroups = new Map<K, R>();
-            const asyncGroups = await reduceToMap(reducer, initialValue);
-
-            for (const [key, asyncGroup] of asyncGroups.entries())
-            {
-                awaitedGroups.set(key, await asyncGroup);
-            }
-
-            return awaitedGroups;
-        }
-        async function asyncReduceToDict<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            const mapGroups = await reduceToMap(reducer, initialValue);
-            const dictGroup = { } as Record<K, R>;
-
-            for (const [key, _group] of mapGroups.entries())
-            {
-                dictGroup[key] = await _group;
-            }
-
-            return dictGroup;
-        }
-        async function asyncReduce<R = V>(reducer: Reducer<Promise<R>>, initialValue?: Promise<R> | undefined)
-        {
-            const groups = await reduce(reducer, initialValue);
-
-            return Promise.all(groups);
-        }
-
-        return {
-            count,
-            countToMap,
-            countToDict,
-            group,
-            groupToMap,
-            groupToDict,
-            reduce,
-            reduceToMap,
-            reduceToDict,
-            asyncReduce,
-            asyncReduceToMap,
-            asyncReduceToDict
-        };
-    }
-
-    type Mapper<R> = (element: V, index: number) => R;
-
-    function map<R>(mapper: Mapper<R>)
-    {
-        const mapping: R[] = [];
-
-        let index = 0;
-        for (const element of elements)
-        {
-            mapping.push(mapper(element, index));
-
-            index += 1;
-        }
-
-        return mapping;
-    }
-    async function asyncMap<R>(mapper: Mapper<Promise<R>>)
-    {
-        return await Promise.all(map(mapper));
-    }
-
-    return { byKey, byAsyncKey, map, asyncMap };
-}

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";
-    }
-}