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

package/src/models/iterators/smart-async-iterator.ts

@@ -0,0 +1,208 @@
+import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncReducer, TypeGuardIteratee } from "./types.js";
+
+export default class SmartAsyncIterator<T, R = void, N = undefined> implements AsyncIterator<T, R, N>
+{
+    protected _iterator: AsyncIterator<T, R, N>;
+
+    public return?: (value?: R) => Promise<IteratorResult<T, R>>;
+    public throw?: (error?: unknown) => Promise<IteratorResult<T, R>>;
+
+    public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: AsyncIterator<T, R, N>);
+    public constructor(generatorFn: () => AsyncGenerator<T, R, N>);
+    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>);
+    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>)
+    {
+        if (argument instanceof Function)
+        {
+            this._iterator = argument();
+        }
+        else if (Symbol.asyncIterator in argument)
+        {
+            this._iterator = argument[Symbol.asyncIterator]() as AsyncIterator<T, R, N>;
+        }
+        else
+        {
+            this._iterator = argument;
+        }
+
+        if (this._iterator.return) { this.return = (value?: R) => this._iterator.return!(value); }
+        if (this._iterator.throw) { this.throw = (error?: unknown) => this._iterator.throw!(error); }
+    }
+
+    public async every(predicate: MaybeAsyncIteratee<T, boolean>): Promise<boolean>
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+
+            if (result.done) { return true; }
+            if (!(predicate(result.value, index))) { return false; }
+
+            index += 1;
+        }
+    }
+    public async some(predicate: MaybeAsyncIteratee<T, boolean>): Promise<boolean>
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+
+            if (result.done) { return false; }
+            if (predicate(result.value, index)) { return true; }
+
+            index += 1;
+        }
+    }
+
+    public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>;
+    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartAsyncIterator<T, S>;
+    public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R>(async function* ()
+        {
+            let index = 0;
+
+            while (true)
+            {
+                const result = await iterator.next();
+
+                if (result.done) { return result.value; }
+                if (predicate(result.value, index)) { yield result.value; }
+
+                index += 1;
+            }
+        });
+    }
+    public map<V>(iteratee: MaybeAsyncIteratee<T, V>): SmartAsyncIterator<V, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<V, R>(async function* ()
+        {
+            let index = 0;
+
+            while (true)
+            {
+                const result = await iterator.next();
+                if (result.done) { return result.value; }
+
+                yield iteratee(result.value, index);
+
+                index += 1;
+            }
+        });
+    }
+    public async reduce(reducer: MaybeAsyncReducer<T, T>): Promise<T>;
+    public async reduce<A>(reducer: MaybeAsyncReducer<T, A>, initialValue: A): Promise<A>;
+    public async reduce<A>(reducer: MaybeAsyncReducer<T, A>, initialValue?: A): Promise<A>
+    {
+        let index = 0;
+        let accumulator = initialValue;
+        if (accumulator === undefined)
+        {
+            const result = await this._iterator.next();
+            if (result.done) { throw new TypeError("Reduce of empty iterator with no initial value"); }
+
+            accumulator = (result.value as unknown) as A;
+            index += 1;
+        }
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+            if (result.done) { return accumulator; }
+
+            accumulator = await reducer(accumulator, result.value, index);
+
+            index += 1;
+        }
+    }
+
+    public enumerate(): SmartAsyncIterator<[number, T], R>
+    {
+        return this.map((value, index) => [index, value]);
+    }
+    public unique(): SmartAsyncIterator<T, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartAsyncIterator<T, R>(async function* ()
+        {
+            const values = new Set<T>();
+
+            while (true)
+            {
+                const result = await iterator.next();
+
+                if (result.done) { return result.value; }
+                if (values.has(result.value)) { continue; }
+
+                values.add(result.value);
+
+                yield result.value;
+            }
+        });
+    }
+
+    public async count(): Promise<number>
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+            if (result.done) { return index; }
+
+            index += 1;
+        }
+    }
+    public async forEach(iteratee: MaybeAsyncIteratee<T>): Promise<void>
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+            if (result.done) { return; }
+
+            await iteratee(result.value, index);
+
+            index += 1;
+        }
+    }
+
+    public next(...values: N extends undefined ? [] : [N]): Promise<IteratorResult<T, R>>
+    {
+        return this._iterator.next(...values);
+    }
+
+    public async toArray(): Promise<T[]>
+    {
+        const elements: T[] = [];
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = await this._iterator.next();
+            if (result.done) { return elements; }
+
+            elements.push(result.value);
+        }
+    }
+
+    public get [Symbol.toStringTag]() { return "SmartAsyncIterator"; }
+
+    public [Symbol.asyncIterator](): SmartAsyncIterator<T, R, N> { return this; }
+}

package/src/models/{smart-iterator.ts → iterators/smart-iterator.ts}

@@ -1,4 +1,4 @@
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee, 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>
 {

package/src/models/iterators/types.ts

@@ -0,0 +1,14 @@
+import type { MaybePromise } from "../promises/types.js";
+
+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 MaybeAsyncIteratee<T, R = void> = (value: T, index: number) => MaybePromise<R>;
+
+export type TypeGuardIteratee<T, R extends T> = (value: T, index: number) => value is R;
+export type MaybeAsyncTypeGuardIteratee<T, R extends T> = (value: MaybePromise<T>, index: number) =>
+    value is MaybePromise<R>;
+
+export type Reducer<T, A> = (accumulator: A, value: T, index: number) => A;
+export type MaybeAsyncReducer<T, A> = (accumulator: A, value: T, index: number) => MaybePromise<A>;

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

@@ -1,30 +1,38 @@
-import type { PromiseResolver, PromiseRejecter, FulfilledHandler, RejectedHandler } from "../../types.js";
+import type { PromiseResolver, PromiseRejecter, FulfilledHandler, RejectedHandler } from "./types.js";
 
 import SmartPromise from "./smart-promise.js";
 
 export default class DeferredPromise<T = void, F = T, R = never> extends SmartPromise<F | R>
 {
-    protected _resolve!: PromiseResolver<T>;
-    protected _reject!: PromiseRejecter;
+    protected _resolve: PromiseResolver<T>;
+    protected _reject: PromiseRejecter;
 
     public constructor(onFulfilled?: FulfilledHandler<T, F> | null, onRejected?: RejectedHandler<unknown, R> | null)
     {
+        let _resolve: PromiseResolver<T>;
+        let _reject: PromiseRejecter;
+
         super((resolve, reject) =>
         {
-            this._resolve = resolve as PromiseResolver<T>;
-            this._reject = reject;
+            // ReferenceError: Must call super constructor in derived class before accessing
+            //                  'this' or returning from derived constructor.
+            //
+            _resolve = resolve as PromiseResolver<T>;
+            _reject = reject;
         });
 
-        this._promise
-            .then(onFulfilled as FulfilledHandler<F | R>, onRejected as RejectedHandler<unknown, R>);
+        this._promise.then(onFulfilled as FulfilledHandler<F | R>, onRejected);
+
+        this._resolve = _resolve!;
+        this._reject = _reject!;
     }
 
     public get resolve(): PromiseResolver<T> { return this._resolve; }
     public get reject(): PromiseRejecter { return this._reject; }
 
-    public watch(promise: Promise<T>): this
+    public watch(otherPromise: PromiseLike<T>): this
     {
-        promise.then(this.resolve, this.reject);
+        otherPromise.then(this.resolve, this.reject);
 
         return this;
     }

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

@@ -1,4 +1,4 @@
-import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "../../types.js";
+import type { FulfilledHandler, PromiseExecutor, RejectedHandler } from "./types.js";
 
 export default class SmartPromise<T = void> implements Promise<T>
 {

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

@@ -1,7 +1,7 @@
-import type { MaybePromise, PromiseExecutor } from "../../types.js";
 import { TimeoutException } from "../exceptions/index.js";
 
 import SmartPromise from "./smart-promise.js";
+import type { MaybePromise, PromiseExecutor } from "./types.js";
 
 export default class TimedPromise<T = void> extends SmartPromise<T>
 {

package/src/models/promises/types.ts

@@ -0,0 +1,8 @@
+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 PromiseRejecter<E = unknown> = (reason?: MaybePromise<E>) => void;
+export type PromiseExecutor<T = void, E = unknown> = (resolve: PromiseResolver<T>, reject: PromiseRejecter<E>) => void;

package/src/models/types.ts

@@ -0,0 +1,22 @@
+export type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./aggregators/types.js";
+export type {
+    GeneratorFunction,
+    AsyncGeneratorFunction,
+    Iteratee,
+    MaybeAsyncIteratee,
+    TypeGuardIteratee,
+    MaybeAsyncTypeGuardIteratee,
+    Reducer,
+    MaybeAsyncReducer
+
+} from "./iterators/types.js";
+
+export type {
+    MaybePromise,
+    FulfilledHandler,
+    RejectedHandler,
+    PromiseResolver,
+    PromiseRejecter,
+    PromiseExecutor
+
+} from "./promises/types.js";

package/src/utils/dom.ts

@@ -1,4 +1,4 @@
-export async function loadScript(scriptUrl: string, scriptType = "text/javascript"): Promise<void>
+export function loadScript(scriptUrl: string, scriptType = "text/javascript"): Promise<void>
 {
     return new Promise<void>((resolve, reject) =>
     {

package/src/utils/iterator.ts

@@ -1,5 +1,16 @@
 import { SmartIterator } from "../models/index.js";
 
+export function chain<T>(...iterables: Iterable<T>[]): SmartIterator<T>
+{
+    return new SmartIterator<T>(function* ()
+    {
+        for (const iterable of iterables)
+        {
+            for (const element of iterable) { yield element; }
+        }
+    });
+}
+
 export function count<T>(elements: Iterable<T>): number
 {
     if (Array.isArray(elements)) { return elements.length; }

package/src/utils/math.ts

@@ -27,13 +27,18 @@ export function average<T extends number>(values: Iterable<T>, weights?: Iterabl
 
     for (const [value, weight] of zip(values, weights))
     {
+        if (weight <= 0)
+        {
+            throw new ValueException(`The weight for the value #${_index} must be greater than zero.`);
+        }
+
         _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."); }
+    if (_count > 0) { throw new ValueException("The sum of weights must be greater than zero."); }
 
     return _sum / _count;
 }

package/src/utils/random.ts

@@ -1,3 +1,5 @@
+import { ValueException } from "../models/index.js";
+
 export default class Random
 {
     public static Boolean(ratio: number = 0.5): boolean
@@ -9,29 +11,31 @@ export default class Random
     public static Integer(min: number, max: number): number;
     public static Integer(min: number, max?: number): number
     {
-        if (max === undefined)
-        {
-            return Math.floor(Math.random() * min);
-        }
+        if (max === undefined) { return Math.floor(Math.random() * min); }
 
         return Math.floor(Math.random() * (max - min) + min);
     }
 
+    public static Decimal(): number;
     public static Decimal(max: number): number;
     public static Decimal(min: number, max: number): number;
-    public static Decimal(min: number, max?: number): number
+    public static Decimal(min?: number, max?: number): number
     {
-        if (max === undefined)
-        {
-            return (Math.random() * min);
-        }
+        if (min === undefined) { return Math.random(); }
+        if (max === undefined) { return (Math.random() * min); }
 
         return (Math.random() * (max - min) + min);
     }
 
+    public static Index<T>(elements: T[]): number
+    {
+        if (elements.length === 0) { throw new ValueException("You must provide at least one element."); }
+
+        return this.Integer(elements.length);
+    }
     public static Choice<T>(elements: T[]): T
     {
-        return elements[this.Integer(elements.length)];
+        return elements[Random.Index(elements)];
     }
 
     // eslint-disable-next-line no-useless-constructor

package/src/types.ts

@@ -1,21 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Constructor<T extends object, P extends unknown[] = any[]> = new (...args: P) => T;
-
-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>;
-
-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 PromiseRejecter<E = unknown> = (reason?: MaybePromise<E>) => void;
-export type PromiseExecutor<T = void, E = unknown> = (resolve: PromiseResolver<T>, reject: PromiseRejecter<E>) => void;
-
-export type Interval = ReturnType<typeof setInterval>;
-export type Timeout = ReturnType<typeof setTimeout>;