@byloth/core 1.5.0-rc.5 → 1.5.0-rc.7

package/src/models/aggregators/aggregated-async-iterator.ts

@@ -0,0 +1,294 @@
+import { SmartAsyncIterator } from "../iterators/index.js";
+import type { AsyncGeneratorFunction } from "../iterators/types.js";
+
+import ReducedIterator from "./reduced-iterator.js";
+import type { MaybeAsyncKeyIteratee, MaybeAsyncKeyTypeGuardIteratee, MaybeAsyncKeyReducer } from "./types.js";
+
+export default class AggregatedAsyncIterator<K extends PropertyKey, T>
+{
+    protected _elements: SmartAsyncIterator<[K, T]>;
+
+    public constructor(iterable: AsyncIterable<[K, T]>);
+    public constructor(iterator: AsyncIterator<[K, T]>);
+    public constructor(generatorFn: AsyncGeneratorFunction<[K, T]>);
+    public constructor(argument: AsyncIterable<[K, T]> | AsyncIterator<[K, T]> | AsyncGeneratorFunction<[K, T]>);
+    public constructor(argument: AsyncIterable<[K, T]> | AsyncIterator<[K, T]> | AsyncGeneratorFunction<[K, T]>)
+    {
+        this._elements = new SmartAsyncIterator(argument);
+    }
+
+    public async every(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    {
+        const indexes = new Map<K, [number, boolean]>();
+
+        for await (const [key, element] of this._elements)
+        {
+            const [index, result] = indexes.get(key) ?? [0, true];
+
+            if (!(result)) { continue; }
+
+            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, [_, result]] of indexes)
+            {
+                yield [key, result];
+            }
+        });
+    }
+    public async some(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    {
+        const indexes = new Map<K, [number, boolean]>();
+
+        for await (const [key, element] of this._elements)
+        {
+            const [index, result] = indexes.get(key) ?? [0, false];
+
+            if (result) { continue; }
+
+            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, [_, result]] of indexes)
+            {
+                yield [key, result];
+            }
+        });
+    }
+
+    public filter(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>;
+    public filter<S extends T>(predicate: MaybeAsyncKeyTypeGuardIteratee<K, T, S>): AggregatedAsyncIterator<K, S>;
+    public filter(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* ()
+        {
+            const indexes = new Map<K, number>();
+
+            for await (const [key, element] of elements)
+            {
+                const index = indexes.get(key) ?? 0;
+
+                indexes.set(key, index + 1);
+
+                if (predicate(key, element, index)) { yield [key, element]; }
+            }
+        });
+    }
+    public map<V>(iteratee: MaybeAsyncKeyIteratee<K, T, V>): AggregatedAsyncIterator<K, V>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* ()
+        {
+            const indexes = new Map<K, number>();
+
+            for await (const [key, element] of elements)
+            {
+                const index = indexes.get(key) ?? 0;
+
+                indexes.set(key, index + 1);
+
+                yield [key, await iteratee(key, element, index)];
+            }
+        });
+    }
+    public async reduce(reducer: MaybeAsyncKeyReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
+    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue: (key: K) => A)
+        : Promise<ReducedIterator<K, A>>;
+    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue?: (key: K) => A)
+        : Promise<ReducedIterator<K, A>>
+    {
+        const accumulators = new Map<K, [number, A]>();
+
+        for await (const [key, element] of this._elements)
+        {
+            let index: number;
+            let accumulator: A;
+
+            if (accumulators.has(key))
+            {
+                [index, accumulator] = accumulators.get(key)!;
+
+                index += 1;
+            }
+            else if (initialValue !== undefined)
+            {
+                index = 0;
+                accumulator = initialValue(key);
+            }
+            else
+            {
+                accumulators.set(key, [0, (element as unknown) as A]);
+
+                continue;
+            }
+
+            accumulator = await reducer(key, accumulator, element, index);
+
+            accumulators.set(key, [index, accumulator]);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, [_, accumulator]] of accumulators)
+            {
+                yield [key, accumulator];
+            }
+        });
+    }
+
+    public unique(): AggregatedAsyncIterator<K, T>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* ()
+        {
+            const keys = new Map<K, Set<T>>();
+
+            for await (const [key, element] of elements)
+            {
+                const values = keys.get(key) ?? new Set<T>();
+
+                if (values.has(element)) { continue; }
+
+                values.add(element);
+                keys.set(key, values);
+
+                yield [key, element];
+            }
+        });
+    }
+
+    public async count(): Promise<ReducedIterator<K, number>>
+    {
+        const counters = new Map<K, number>();
+
+        for await (const [key] of this._elements)
+        {
+            const count = counters.get(key) ?? 0;
+
+            counters.set(key, count + 1);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, count] of counters)
+            {
+                yield [key, count];
+            }
+        });
+    }
+    public async first(): Promise<ReducedIterator<K, T>>
+    {
+        const firsts = new Map<K, T>();
+
+        for await (const [key, element] of this._elements)
+        {
+            if (firsts.has(key)) { continue; }
+
+            firsts.set(key, element);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, element] of firsts)
+            {
+                yield [key, element];
+            }
+        });
+    }
+    public async last(): Promise<ReducedIterator<K, T>>
+    {
+        const lasts = new Map<K, T>();
+
+        for await (const [key, element] of this._elements)
+        {
+            lasts.set(key, element);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, element] of lasts)
+            {
+                yield [key, element];
+            }
+        });
+    }
+
+    public keys(): SmartAsyncIterator<K>
+    {
+        const elements = this._elements;
+
+        return new SmartAsyncIterator<K>(async function* ()
+        {
+            const keys = new Set<K>();
+
+            for await (const [key] of elements)
+            {
+                if (keys.has(key)) { continue; }
+                keys.add(key);
+
+                yield key;
+            }
+        });
+    }
+    public items(): SmartAsyncIterator<[K, T]>
+    {
+        return this._elements;
+    }
+    public values(): SmartAsyncIterator<T>
+    {
+        const elements = this._elements;
+
+        return new SmartAsyncIterator<T>(async function* ()
+        {
+            for await (const [_, element] of elements)
+            {
+                yield element;
+            }
+        });
+    }
+
+    public async toArray(): Promise<T[][]>
+    {
+        const map = await this.toMap();
+
+        return Array.from(map.values());
+    }
+    public async toMap(): Promise<Map<K, T[]>>
+    {
+        const groups = new Map<K, T[]>();
+
+        for await (const [key, element] of this._elements)
+        {
+            const value = groups.get(key) ?? [];
+
+            value.push(element);
+            groups.set(key, value);
+        }
+
+        return groups;
+    }
+    public async toObject(): Promise<Record<K, T[]>>
+    {
+        const groups = { } as Record<K, T[]>;
+
+        for await (const [key, element] of this._elements)
+        {
+            const value = groups[key] ?? [];
+
+            value.push(element);
+            groups[key] = value;
+        }
+
+        return groups;
+    }
+
+    public get [Symbol.toStringTag]() { return "AggregatedAsyncIterator"; }
+}

package/src/models/aggregators/aggregated-iterator.ts

@@ -1,8 +1,8 @@
-import ReducedIterator from "./reduced-iterator.js";
-import SmartIterator from "../smart-iterator.js";
+import { SmartIterator } from "../iterators/index.js";
+import type { GeneratorFunction } from "../iterators/types.js";
 
+import ReducedIterator from "./reduced-iterator.js";
 import type { KeyIteratee, KeyTypeGuardIteratee, KeyReducer } from "./types.js";
-import type { GeneratorFunction } from "../../types.js";
 
 export default class AggregatedIterator<K extends PropertyKey, T>
 {
@@ -225,8 +225,13 @@ export default class AggregatedIterator<K extends PropertyKey, T>
 
         return new SmartIterator<K>(function* ()
         {
+            const keys = new Set<K>();
+
             for (const [key] of elements)
             {
+                if (keys.has(key)) { continue; }
+                keys.add(key);
+
                 yield key;
             }
         });

package/src/models/aggregators/aggregator.ts

@@ -0,0 +1,46 @@
+import AggregatedIterator from "./aggregated-iterator.js";
+
+import { SmartIterator } from "../iterators/index.js";
+import type { GeneratorFunction, Iteratee, TypeGuardIteratee } from "../iterators/types.js";
+
+export default class Aggregator<T>
+{
+    protected _elements: SmartIterator<T>;
+
+    public constructor(iterable: Iterable<T>);
+    public constructor(iterator: Iterator<T>);
+    public constructor(generatorFn: GeneratorFunction<T>);
+    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>);
+    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>)
+    {
+        this._elements = new SmartIterator(argument);
+    }
+
+    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>;
+    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): Aggregator<S>;
+    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>
+    {
+        return new Aggregator(this._elements.filter(predicate));
+    }
+    public map<V>(iteratee: Iteratee<T, V>): Aggregator<V>
+    {
+        return new Aggregator(this._elements.map(iteratee));
+    }
+
+    public unique(): Aggregator<T>
+    {
+        return new Aggregator(this._elements.unique());
+    }
+
+    public groupBy<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<K, T>
+    {
+        return new AggregatedIterator(this._elements.map((element, index) =>
+        {
+            const key = iteratee(element, index);
+
+            return [key, element] as [K, T];
+        }));
+    }
+
+    public get [Symbol.toStringTag]() { return "Aggregator"; }
+}

package/src/models/aggregators/async-aggregator.ts

@@ -0,0 +1,46 @@
+import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
+
+import { SmartAsyncIterator } from "../iterators/index.js";
+import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncTypeGuardIteratee } from "../iterators/types.js";
+
+export default class AsyncAggregator<T>
+{
+    protected _elements: SmartAsyncIterator<T>;
+
+    public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: AsyncIterator<T>);
+    public constructor(generatorFn: AsyncGeneratorFunction<T>);
+    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>);
+    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>)
+    {
+        this._elements = new SmartAsyncIterator(argument);
+    }
+
+    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>;
+    public filter<S extends T>(predicate: MaybeAsyncTypeGuardIteratee<T, S>): AsyncAggregator<S>;
+    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>
+    {
+        return new AsyncAggregator(this._elements.filter(predicate));
+    }
+    public map<V>(iteratee: MaybeAsyncIteratee<T, V>): AsyncAggregator<V>
+    {
+        return new AsyncAggregator(this._elements.map(iteratee));
+    }
+
+    public unique(): AsyncAggregator<T>
+    {
+        return new AsyncAggregator(this._elements.unique());
+    }
+
+    public groupBy<K extends PropertyKey>(iteratee: MaybeAsyncIteratee<T, K>): AggregatedAsyncIterator<K, T>
+    {
+        return new AggregatedAsyncIterator(this._elements.map(async (element, index) =>
+        {
+            const key = await iteratee(element, index);
+
+            return [key, element] as [K, T];
+        }));
+    }
+
+    public get [Symbol.toStringTag]() { return "AsyncAggregator"; }
+}

package/src/models/aggregators/index.ts

@@ -1,50 +1,7 @@
+import Aggregator from "./aggregator.js";
+import AsyncAggregator from "./async-aggregator.js";
 import AggregatedIterator from "./aggregated-iterator.js";
+import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
 import ReducedIterator from "./reduced-iterator.js";
-import SmartIterator from "../smart-iterator.js";
 
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee } from "../../types.js";
-
-export default class Aggregator<T>
-{
-    protected _elements: SmartIterator<T>;
-
-    public constructor(iterable: Iterable<T>);
-    public constructor(iterator: Iterator<T>);
-    public constructor(generatorFn: GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>)
-    {
-        this._elements = new SmartIterator(argument);
-    }
-
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): Aggregator<S>;
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>
-    {
-        return new Aggregator(this._elements.filter(predicate));
-    }
-    public map<V>(iteratee: Iteratee<T, V>): Aggregator<V>
-    {
-        return new Aggregator(this._elements.map(iteratee));
-    }
-
-    public unique(): Aggregator<T>
-    {
-        return new Aggregator(this._elements.unique());
-    }
-
-    public groupBy<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<K, T>
-    {
-        return new AggregatedIterator(this._elements.map((element, index) =>
-        {
-            const key = iteratee(element, index);
-
-            return [key, element] as [K, T];
-        }));
-    }
-
-    public get [Symbol.toStringTag]() { return "Aggregator"; }
-}
-
-export { AggregatedIterator, ReducedIterator };
-export type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./types.js";
+export { Aggregator, AsyncAggregator, AggregatedIterator, AggregatedAsyncIterator, ReducedIterator };

package/src/models/aggregators/reduced-iterator.ts

@@ -1,7 +1,7 @@
-import SmartIterator from "../smart-iterator.js";
+import { SmartIterator } from "../iterators/index.js";
+import type { GeneratorFunction } from "../iterators/types.js";
 
-import type { KeyIteratee, KeyTypeGuardIteratee } from "./types.js";
-import type { GeneratorFunction } from "../../types.js";
+import type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./types.js";
 
 export default class ReducedIterator<K extends PropertyKey, T>
 {
@@ -45,6 +45,38 @@ export default class ReducedIterator<K extends PropertyKey, T>
             }
         });
     }
+    public reduce(reducer: KeyReducer<K, T, T>): T;
+    public reduce<A>(reducer: KeyReducer<K, T, A>, initialValue: A): A;
+    public reduce<A>(reducer: KeyReducer<K, T, A>, initialValue?: A): A
+    {
+        let index = 0;
+        let accumulator: A;
+
+        if (initialValue !== undefined)
+        {
+            accumulator = initialValue;
+        }
+        else
+        {
+            const firstElement = this._elements.next();
+            if (firstElement.done)
+            {
+                throw new TypeError("Reduce of empty iterator with no initial value");
+            }
+
+            index += 1;
+            accumulator = (firstElement.value[1] as unknown) as A;
+        }
+
+        for (const [key, element] of this._elements)
+        {
+            accumulator = reducer(key, accumulator, element, index);
+
+            index += 1;
+        }
+
+        return accumulator;
+    }
 
     public keys(): SmartIterator<K>
     {

package/src/models/aggregators/types.ts

@@ -1,5 +1,14 @@
+import type { MaybePromise } from "../promises/types.js";
+
 export type KeyIteratee<K extends PropertyKey, T, R = void> = (key: K, value: T, index: number) => R;
+export type MaybeAsyncKeyIteratee<K extends PropertyKey, T, R = void> = (key: K, value: T, index: number) =>
+    MaybePromise<R>;
+
 export type KeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
     (key: K, value: T, index: number) => value is R;
+export type MaybeAsyncKeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
+    (key: K, value: MaybePromise<T>, index: number) => value is MaybePromise<R>;
 
 export type KeyReducer<K extends PropertyKey, T, A> = (key: K, accumulator: A, value: T, index: number) => A;
+export type MaybeAsyncKeyReducer<K extends PropertyKey, T, A> =
+    (key: K, accumulator: A, value: T, index: number) => MaybePromise<A>;

package/src/models/exceptions/core.ts

@@ -41,3 +41,34 @@ export default class Exception extends Error
 
     public get [Symbol.toStringTag]() { return "Exception"; }
 }
+
+export class FatalErrorException extends Exception
+{
+    public constructor(message?: string, cause?: unknown, name = "FatalErrorException")
+    {
+        if (message === undefined)
+        {
+            message = "The routine has encountered an unrecoverable error and cannot continue as expected. " +
+                "Please, refresh the page and try again. If the problem persists, contact the support team.";
+        }
+
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "FatalErrorException"; }
+}
+
+export class NotImplementedException extends Exception
+{
+    public constructor(message?: string, cause?: unknown, name = "NotImplementedException")
+    {
+        if (message === undefined)
+        {
+            message = "This feature is not implemented yet. Please, try again later.";
+        }
+
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "NotImplementedException"; }
+}

package/src/models/exceptions/index.ts

@@ -1,5 +1,32 @@
 import Exception from "./core.js";
 
+export class FileNotFoundException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "FileNotFoundException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "FileNotFoundException"; }
+}
+export class NetworkException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "NetworkException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "NetworkException"; }
+}
+export class PermissionException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "PermissionException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "PermissionException"; }
+}
 export class ReferenceException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "ReferenceException")
@@ -9,6 +36,15 @@ export class ReferenceException extends Exception
 
     public get [Symbol.toStringTag]() { return "ReferenceException"; }
 }
+export class RuntimeException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "RuntimeException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "RuntimeException"; }
+}
 export class TimeoutException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "TimeoutException")
@@ -18,6 +54,15 @@ export class TimeoutException extends Exception
 
     public get [Symbol.toStringTag]() { return "TimeoutException"; }
 }
+export class TypeException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "TypeException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "TypeException"; }
+}
 export class ValueException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "ValueException")
@@ -29,3 +74,4 @@ export class ValueException extends Exception
 }
 
 export { Exception };
+export { FatalErrorException, NotImplementedException } from "./core.js";

package/src/models/index.ts

@@ -1,18 +1,32 @@
-import Aggregator, { AggregatedIterator, ReducedIterator } from "./aggregators/index.js";
-export type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./aggregators/index.js";
+export {
+    Aggregator,
+    AsyncAggregator,
+    AggregatedIterator,
+    AggregatedAsyncIterator,
+    ReducedIterator
+
+} from "./aggregators/index.js";
+
+export {
+    Exception,
+    FatalErrorException,
+    NotImplementedException,
+    FileNotFoundException,
+    NetworkException,
+    PermissionException,
+    ReferenceException,
+    RuntimeException,
+    TimeoutException,
+    TypeException,
+    ValueException
 
-export { Exception, ReferenceException, TimeoutException, ValueException } from "./exceptions/index.js";
+} from "./exceptions/index.js";
+
+export { SmartIterator, SmartAsyncIterator } from "./iterators/index.js";
 
 import JsonStorage from "./json-storage.js";
-import SmartIterator from "./smart-iterator.js";
 import Subscribers from "./subscribers.js";
 
 export { DeferredPromise, SmartPromise, TimedPromise } from "./promises/index.js";
-export {
-    AggregatedIterator,
-    Aggregator,
-    JsonStorage,
-    ReducedIterator,
-    SmartIterator,
-    Subscribers
-};
+
+export { JsonStorage, Subscribers };

package/src/models/iterators/index.ts

@@ -0,0 +1,4 @@
+import SmartIterator from "./smart-iterator.js";
+import SmartAsyncIterator from "./smart-async-iterator.js";
+
+export { SmartIterator, SmartAsyncIterator };