@byloth/core 1.2.0 → 1.3.0-rc.1

package/src/models/aggregators/_index.old.ts

@@ -0,0 +1,384 @@
+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/aggregators/aggregated-iterator.ts

@@ -0,0 +1,214 @@
+import ReducedIterator from "./reduced-iterator.js";
+import SmartIterator from "../smart-iterator.js";
+
+import type { KeyIteratee, KeyReducer } from "./types.js";
+import type { GeneratorFunction } from "../../types.js";
+
+export default class AggregatedIterator<T, K extends PropertyKey>
+{
+    protected _elements: SmartIterator<[K, T]>;
+
+    public constructor(iterable: Iterable<[K, T]>);
+    public constructor(iterator: Iterator<[K, T]>);
+    public constructor(generatorFn: GeneratorFunction<[K, T]>);
+    public constructor(argument: Iterable<[K, T]> | Iterator<[K, T]> | GeneratorFunction<[K, T]>);
+    public constructor(argument: Iterable<[K, T]> | Iterator<[K, T]> | GeneratorFunction<[K, T]>)
+    {
+        this._elements = new SmartIterator(argument);
+    }
+
+    public every(predicate: KeyIteratee<T, K, boolean>): ReducedIterator<boolean, K>
+    {
+        const indexes = new Map<K, [number, boolean]>();
+
+        for (const [key, element] of this._elements)
+        {
+            const [index, result] = indexes.get(key) ?? [0, true];
+
+            if (!(result)) { continue; }
+
+            indexes.set(key, [index + 1, predicate(key, element, index)]);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, [_, result]] of indexes)
+            {
+                yield [key, result];
+            }
+        });
+    }
+    public some(predicate: KeyIteratee<T, K, boolean>): ReducedIterator<boolean, K>
+    {
+        const indexes = new Map<K, [number, boolean]>();
+
+        for (const [key, element] of this._elements)
+        {
+            const [index, result] = indexes.get(key) ?? [0, false];
+
+            if (result) { continue; }
+
+            indexes.set(key, [index + 1, predicate(key, element, index)]);
+        }
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [key, [_, result]] of indexes)
+            {
+                yield [key, result];
+            }
+        });
+    }
+
+    public filter(predicate: KeyIteratee<T, K, boolean>): AggregatedIterator<T, K>
+    {
+        const elements = this._elements;
+
+        return new AggregatedIterator(function* ()
+        {
+            const indexes = new Map<K, number>();
+
+            for (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: KeyIteratee<T, K, V>): AggregatedIterator<V, K>
+    {
+        const elements = this._elements;
+
+        return new AggregatedIterator(function* ()
+        {
+            const indexes = new Map<K, number>();
+
+            for (const [key, element] of elements)
+            {
+                const index = indexes.get(key) ?? 0;
+
+                indexes.set(key, index + 1);
+
+                yield [key, iteratee(key, element, index)];
+            }
+        });
+    }
+    public reduce<A>(reducer: KeyReducer<T, K, A>, initialValue?: A): ReducedIterator<A, K>
+    {
+        const accumulators = new Map<K, [number, A]>();
+
+        for (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;
+            }
+            else
+            {
+                accumulators.set(key, [0, (element as unknown) as A]);
+
+                continue;
+            }
+
+            accumulator = 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(): AggregatedIterator<T, K>
+    {
+        const elements = this._elements;
+
+        return new AggregatedIterator(function* ()
+        {
+            const keys = new Map<K, Set<T>>();
+
+            for (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 count(): ReducedIterator<number, K>
+    {
+        const counters = new Map<K, number>();
+
+        for (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 toArray(): T[][]
+    {
+        return Array.from(this.toMap().values());
+    }
+    public toMap(): Map<K, T[]>
+    {
+        const groups = new Map<K, T[]>();
+
+        for (const [key, element] of this._elements)
+        {
+            const value = groups.get(key) ?? [];
+
+            value.push(element);
+            groups.set(key, value);
+        }
+
+        return groups;
+    }
+    public toObject(): Record<K, T[]>
+    {
+        const groups = { } as Record<K, T[]>;
+
+        for (const [key, element] of this._elements)
+        {
+            const value = groups[key] ?? [];
+
+            value.push(element);
+            groups[key] = value;
+        }
+
+        return groups;
+    }
+}

package/src/models/aggregators/index.ts

@@ -0,0 +1,45 @@
+import AggregatedIterator from "./aggregated-iterator.js";
+import ReducedIterator from "./reduced-iterator.js";
+import SmartIterator from "../smart-iterator.js";
+
+import type { GeneratorFunction, Iteratee } 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>
+    {
+        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 byKey<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<T, K>
+    {
+        return new AggregatedIterator(this._elements.map((element, index) =>
+        {
+            const key = iteratee(element, index);
+
+            return [key, element];
+        }));
+    }
+}
+
+export { AggregatedIterator, ReducedIterator };

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

@@ -0,0 +1,59 @@
+import SmartIterator from "../smart-iterator.js";
+
+import type { KeyIteratee } from "./types.js";
+import type { GeneratorFunction } from "../../types.js";
+
+export default class ReducedIterator<T, K extends PropertyKey>
+{
+    protected _elements: SmartIterator<[K, T]>;
+
+    public constructor(iterable: Iterable<[K, T]>);
+    public constructor(iterator: Iterator<[K, T]>);
+    public constructor(generatorFn: GeneratorFunction<[K, T]>);
+    public constructor(argument: Iterable<[K, T]> | Iterator<[K, T]> | GeneratorFunction<[K, T]>);
+    public constructor(argument: Iterable<[K, T]> | Iterator<[K, T]> | GeneratorFunction<[K, T]>)
+    {
+        this._elements = new SmartIterator(argument);
+    }
+
+    public filter(predicate: KeyIteratee<T, K, boolean>): ReducedIterator<T, K>
+    {
+        const elements = this._elements;
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [index, [key, element]] of elements.enumerate())
+            {
+                if (predicate(key, element, index))
+                {
+                    yield [key, element];
+                }
+            }
+        });
+    }
+    public map<V>(iteratee: KeyIteratee<T, K, V>): ReducedIterator<V, K>
+    {
+        const elements = this._elements;
+
+        return new ReducedIterator(function* ()
+        {
+            for (const [index, [key, element]] of elements.enumerate())
+            {
+                yield [key, iteratee(key, element, index)];
+            }
+        });
+    }
+
+    public toArray(): T[]
+    {
+        return Array.from(this.toMap().values());
+    }
+    public toMap(): Map<K, T>
+    {
+        return new Map(this._elements.toArray());
+    }
+    public toObject(): Record<K, T>
+    {
+        return Object.fromEntries(this._elements.toArray()) as Record<K, T>;
+    }
+}

package/src/models/aggregators/types.ts

@@ -0,0 +1,2 @@
+export type KeyIteratee<T, K extends PropertyKey, R = void> = (key: K, value: T, index: number) => R;
+export type KeyReducer<T, K extends PropertyKey, A> = (key: K, accumulator: A, value: T, index: number) => A;