@byloth/core 2.0.0-rc.2 → 2.0.0-rc.4

package/src/helpers.ts

@@ -1,3 +1,10 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore
 export const isBrowser = ((typeof window !== "undefined") && (typeof window.document !== "undefined"));
+
+// @ts-ignore
 export const isNode = ((typeof process !== "undefined") && (process.versions?.node));
+
+// @ts-ignore
 export const isWebWorker = ((typeof self === "object") && (self.constructor?.name === "DedicatedWorkerGlobalScope"));

package/src/index.ts

@@ -1,4 +1,4 @@
-export const VERSION = "2.0.0-rc.2";
+export const VERSION = "2.0.0-rc.4";
 
 export type { Constructor, Interval, Timeout } from "./core/types.js";
 
@@ -7,8 +7,6 @@ export { isBrowser, isNode, isWebWorker } from "./helpers.js";
 export {
     AggregatedIterator,
     AggregatedAsyncIterator,
-    Aggregator,
-    AsyncAggregator,
     Clock,
     Countdown,
     DeferredPromise,
@@ -40,23 +38,23 @@ export {
 
 export type {
     AsyncGeneratorFunction,
-    AsyncIterLike,
+    AsyncIteratorLike,
     FulfilledHandler,
     GeneratorFunction,
     Iteratee,
-    IterLike,
+    IteratorLike,
     JSONArray,
     JSONObject,
     JSONValue,
-    KeyIteratee,
-    KeyReducer,
-    KeyTypeGuardIteratee,
-    MaybeAsyncKeyIteratee,
-    MaybeAsyncKeyReducer,
-    MaybeAsyncKeyTypeGuardIteratee,
+    KeyedIteratee,
+    KeyedReducer,
+    KeyedTypeGuardIteratee,
+    MaybeAsyncKeyedIteratee,
+    MaybeAsyncKeyedReducer,
+    MaybeAsyncKeyedTypeGuardIteratee,
     MaybeAsyncReducer,
     MaybeAsyncIteratee,
-    MaybeAsyncIterLike,
+    MaybeAsyncIteratorLike,
     MaybeAsyncTypeGuardIteratee,
     MaybePromise,
     PromiseExecutor,

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

@@ -1,9 +1,15 @@
 import { SmartAsyncIterator } from "../iterators/index.js";
-import type { AsyncGeneratorFunction, GeneratorFunction, MaybeAsyncIterLike } from "../iterators/types.js";
+import type {
+    GeneratorFunction,
+    AsyncGeneratorFunction,
+    MaybeAsyncGeneratorFunction,
+    MaybeAsyncIteratorLike
+
+} from "../iterators/types.js";
 import type { MaybePromise } from "../types.js";
 
 import ReducedIterator from "./reduced-iterator.js";
-import type { MaybeAsyncKeyIteratee, MaybeAsyncKeyTypeGuardIteratee, MaybeAsyncKeyReducer } from "./types.js";
+import type { MaybeAsyncKeyedIteratee, MaybeAsyncKeyedTypeGuardIteratee, MaybeAsyncKeyedReducer } from "./types.js";
 
 export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 {
@@ -15,58 +21,52 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     public constructor(iterator: AsyncIterator<[K, T]>);
     public constructor(generatorFn: GeneratorFunction<[K, T]>);
     public constructor(generatorFn: AsyncGeneratorFunction<[K, T]>);
-    public constructor(argument: MaybeAsyncIterLike<[K, T]>);
-    public constructor(argument: MaybeAsyncIterLike<[K, T]>)
+    public constructor(argument: MaybeAsyncIteratorLike<[K, T]> | MaybeAsyncGeneratorFunction<[K, T]>);
+    public constructor(argument: MaybeAsyncIteratorLike<[K, T]> | MaybeAsyncGeneratorFunction<[K, T]>)
     {
         this._elements = new SmartAsyncIterator(argument);
     }
 
-    public async every(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    public async every(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
     {
-        const indexes = new Map<K, [number, boolean]>();
+        const values = new Map<K, [number, boolean]>();
 
         for await (const [key, element] of this._elements)
         {
-            const [index, result] = indexes.get(key) ?? [0, true];
+            const [index, result] = values.get(key) ?? [0, true];
 
             if (!(result)) { continue; }
 
-            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+            values.set(key, [index + 1, await predicate(key, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, result]] of indexes)
-            {
-                yield [key, result];
-            }
+            for (const [key, [_, result]] of values) { yield [key, result]; }
         });
     }
-    public async some(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    public async some(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
     {
-        const indexes = new Map<K, [number, boolean]>();
+        const values = new Map<K, [number, boolean]>();
 
         for await (const [key, element] of this._elements)
         {
-            const [index, result] = indexes.get(key) ?? [0, false];
+            const [index, result] = values.get(key) ?? [0, false];
 
             if (result) { continue; }
 
-            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+            values.set(key, [index + 1, await predicate(key, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, result]] of indexes)
-            {
-                yield [key, result];
-            }
+            for (const [key, [_, result]] of values) { 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>
+    public filter(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>;
+    public filter<S extends T>(predicate: MaybeAsyncKeyedTypeGuardIteratee<K, T, S>): AggregatedAsyncIterator<K, S>;
+    public filter(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>
     {
         const elements = this._elements;
 
@@ -78,13 +78,13 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             {
                 const index = indexes.get(key) ?? 0;
 
-                indexes.set(key, index + 1);
-
                 if (await predicate(key, element, index)) { yield [key, element]; }
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public map<V>(iteratee: MaybeAsyncKeyIteratee<K, T, V>): AggregatedAsyncIterator<K, V>
+    public map<V>(iteratee: MaybeAsyncKeyedIteratee<K, T, V>): AggregatedAsyncIterator<K, V>
     {
         const elements = this._elements;
 
@@ -96,31 +96,26 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             {
                 const index = indexes.get(key) ?? 0;
 
-                indexes.set(key, index + 1);
-
                 yield [key, await iteratee(key, element, index)];
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public async reduce(reducer: MaybeAsyncKeyReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
+    public async reduce(reducer: MaybeAsyncKeyedReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
+    public async reduce<A>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue?: (key: K) => MaybePromise<A>)
+    public async reduce<A>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue?: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>
     {
-        const accumulators = new Map<K, [number, A]>();
+        const values = 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;
-            }
+            if (values.has(key)) { [index, accumulator] = values.get(key)!; }
             else if (initialValue !== undefined)
             {
                 index = 0;
@@ -128,103 +123,164 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             }
             else
             {
-                accumulators.set(key, [0, (element as unknown) as A]);
+                values.set(key, [0, (element as unknown) as A]);
 
                 continue;
             }
 
-            accumulator = await reducer(key, accumulator, element, index);
-
-            accumulators.set(key, [index, accumulator]);
+            values.set(key, [index + 1, await reducer(key, accumulator, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, accumulator]] of accumulators)
+            for (const [key, [_, accumulator]] of values) { yield [key, accumulator]; }
+        });
+    }
+
+    public flatMap<V>(iteratee: MaybeAsyncKeyedIteratee<K, T, Iterable<V>>): AggregatedAsyncIterator<K, V>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, V]>
+        {
+            const indexes = new Map<K, number>();
+
+            for await (const [key, element] of elements)
             {
-                yield [key, accumulator];
+                const index = indexes.get(key) ?? 0;
+                const values = await iteratee(key, element, index);
+
+                for await (const value of values) { yield [key, value]; }
+
+                indexes.set(key, index + 1);
             }
         });
     }
 
-    public unique(): AggregatedAsyncIterator<K, T>
+    public drop(count: number): AggregatedAsyncIterator<K, T>
     {
         const elements = this._elements;
 
         return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
-            const keys = new Map<K, Set<T>>();
+            const indexes = new Map<K, number>();
 
             for await (const [key, element] of elements)
             {
-                const values = keys.get(key) ?? new Set<T>();
-
-                if (values.has(element)) { continue; }
+                const index = indexes.get(key) ?? 0;
+                if (index < count)
+                {
+                    indexes.set(key, index + 1);
 
-                values.add(element);
-                keys.set(key, values);
+                    continue;
+                }
 
                 yield [key, element];
             }
         });
     }
-
-    public async count(): Promise<ReducedIterator<K, number>>
+    public take(limit: number): AggregatedAsyncIterator<K, T>
     {
-        const counters = new Map<K, number>();
+        const elements = this._elements;
 
-        for await (const [key] of this._elements)
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
-            const count = counters.get(key) ?? 0;
-
-            counters.set(key, count + 1);
-        }
+            const indexes = new Map<K, number>();
 
-        return new ReducedIterator(function* ()
-        {
-            for (const [key, count] of counters)
+            for await (const [key, element] of elements)
             {
-                yield [key, count];
+                const index = indexes.get(key) ?? 0;
+                if (index >= limit)
+                {
+                    if (indexes.values().every((value) => value >= limit)) { break; }
+
+                    continue;
+                }
+
+                yield [key, element];
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public async first(): Promise<ReducedIterator<K, T>>
+
+    public async find(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, T | undefined>>;
+    public async find<S extends T>(predicate: MaybeAsyncKeyedTypeGuardIteratee<K, T, S>)
+        : Promise<ReducedIterator<K, S | undefined>>;
+
+    public async find(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, T | undefined>>
     {
-        const firsts = new Map<K, T>();
+        const values = new Map<K, [number, T | undefined]>();
 
         for await (const [key, element] of this._elements)
         {
-            if (firsts.has(key)) { continue; }
+            let [index, finding] = values.get(key) ?? [0, undefined];
 
-            firsts.set(key, element);
+            if (finding !== undefined) { continue; }
+            if (await predicate(key, element, index)) { finding = element; }
+
+            values.set(key, [index + 1, finding]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, element] of firsts)
+            for (const [key, [_, finding]] of values) { yield [key, finding]; }
+        });
+    }
+
+    public unique(): AggregatedAsyncIterator<K, T>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
+        {
+            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 last(): Promise<ReducedIterator<K, T>>
+
+    public async count(): Promise<ReducedIterator<K, number>>
     {
-        const lasts = new Map<K, T>();
+        const counters = new Map<K, number>();
 
-        for await (const [key, element] of this._elements)
+        for await (const [key] of this._elements)
         {
-            lasts.set(key, element);
+            const count = counters.get(key) ?? 0;
+
+            counters.set(key, count + 1);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, element] of lasts)
-            {
-                yield [key, element];
-            }
+            for (const [key, count] of counters) { yield [key, count]; }
         });
     }
 
+    public async forEach(iteratee: MaybeAsyncKeyedIteratee<K, T>): Promise<void>
+    {
+        const indexes = new Map<K, number>();
+
+        for await (const [key, element] of this._elements)
+        {
+            const index = indexes.get(key) ?? 0;
+
+            iteratee(key, element, index);
+
+            indexes.set(key, index + 1);
+        }
+    }
+
     public keys(): SmartAsyncIterator<K>
     {
         const elements = this._elements;
@@ -252,10 +308,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 
         return new SmartAsyncIterator<T>(async function* ()
         {
-            for await (const [_, element] of elements)
-            {
-                yield element;
-            }
+            for await (const [_, element] of elements) { yield element; }
         });
     }
 
@@ -294,5 +347,5 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
         return groups;
     }
 
-    public get [Symbol.toStringTag]() { return "AggregatedAsyncIterator"; }
+    public readonly [Symbol.toStringTag]: string = "AggregatedAsyncIterator";
 }