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

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

@@ -0,0 +1,289 @@
+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* ()
+        {
+            for await (const [key] of elements)
+            {
+                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>
 {

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";
 
 export default class ReducedIterator<K extends PropertyKey, T>
 {

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/index.ts

@@ -1,18 +1,18 @@
-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, ReferenceException, TimeoutException, ValueException } 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 };