@develia/commons 0.3.12 → 0.3.13

package/src/from.ts

@@ -0,0 +1,526 @@
+import {Consumer, EqualityComparer, UnaryFunction, Predicate, Provider} from "./types";
+import {toPairs} from "./functions";
+import Pair from "./pair";
+
+
+export default function from<T>(source: Iterable<T> | Provider<Iterable<T>>): From<T> | From<Pair<any, any>> {
+    if (source == null)
+        throw "Source is null.";
+    if (typeof source === 'function')
+        return From.fn<T>(source);
+    if (typeof source[Symbol.iterator] === 'function') {
+        return From.iterable<T>(source);
+    } else if (typeof source === 'object') {
+        return From.object(source)
+    }
+
+    throw "Invalid source.";
+}
+
+export class From<T> implements Iterable<T> {
+
+    public static object(obj: any): From<Pair<any, any>> {
+        return new From<Pair<any, any>>(function () {
+            return toPairs(obj);
+        });
+    }
+
+    private static _shallowEqual(obj1: any, obj2: any): boolean {
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+
+        for (let key of keys1) {
+            if (obj1[key] !== obj2[key]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private readonly _fn: Provider<Iterable<T>>
+
+    protected constructor(fn: Provider<Iterable<T>>) {
+        this._fn = fn;
+    }
+
+    public static fn<T>(callable: Provider<Iterable<T>>): From<T> {
+        return new From<T>(callable);
+    };
+
+    public collect(): From<T> {
+        const cache = Array.from(this);
+        return From.iterable(cache);
+    }
+
+    public static iterable<T>(iterable: Iterable<T>): From<T> {
+        return From.fn<T>(function* () {
+            for (const item of iterable) {
+                yield item;
+            }
+        });
+    };
+
+    public map<R>(mapper: UnaryFunction<T, R>): From<R> {
+        const self = this;
+        return From.fn<R>(function* () {
+            for (let item of self) {
+                yield mapper(item);
+            }
+        })
+    }
+
+    * [Symbol.iterator](): Iterator<T> {
+        yield* this._fn()
+    }
+
+
+    public all(predicate: Predicate<T>): boolean {
+        for (let item of this._fn()) {
+            if (!predicate(item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public any(predicate: Predicate<T>): boolean {
+        for (let item of this) {
+            if (predicate(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public filter(predicate: Predicate<T>): From<T> {
+        const self = this;
+        return From.fn<T>(function* () {
+            for (let item of self) {
+                if (predicate(item)) {
+                    yield item;
+                }
+            }
+        });
+    }
+
+    public contains(value: T): boolean {
+        for (let item of this) {
+            if (item === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    // noinspection LoopStatementThatDoesntLoopJS
+    public first(predicate?: Predicate<T>): T | undefined {
+
+        if (predicate) {
+            for (let item of this) {
+                if (!predicate || predicate(item)) {
+                    return item;
+                }
+            }
+        } else {
+            // noinspection LoopStatementThatDoesntLoopJS
+            for (let item of this) {
+                return item;
+            }
+        }
+
+        return undefined;
+    }
+
+    public append(item: T): From<T> {
+        const self = this;
+        return From.fn<T>(function* () {
+            for (let element of self) {
+                yield element;
+            }
+            yield item;
+        });
+    }
+
+    public prepend(item: T): From<T> {
+        const self = this;
+        return From.fn<T>(function* () {
+            yield item;
+            for (let element of self) {
+                yield element;
+            }
+        });
+    }
+
+    public at(index: number): T | undefined {
+        let idx = 0;
+        for (let item of this) {
+            if (idx++ === index) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+
+    public last(predicate?: Predicate<T>): T | undefined {
+
+
+        let last: T | undefined = undefined;
+
+        if (predicate)
+            for (let item of this) {
+                if (!predicate || predicate(item)) {
+                    last = item;
+                }
+            }
+        else {
+            for (let item of this) {
+                last = item;
+            }
+        }
+        return last;
+    }
+
+    public mapMany<R>(mapper: UnaryFunction<T, Iterable<R>>): From<R> {
+        const self = this;
+        return From.fn(function* () {
+            for (const item of self) {
+                const subitems = mapper(item)
+                for (const subitem of subitems) {
+                    yield subitem;
+                }
+            }
+        })
+    }
+
+    public flatten(): From<any> {
+        const self = this;
+        return From.fn<T>(function* () {
+            for (let item of self) {
+                let temp = <Iterable<any>>item;
+                for (let subitem of temp) {
+                    yield subitem
+                }
+            }
+        });
+    }
+
+    public sum(mapper?: UnaryFunction<T, number>): number {
+        let total = 0;
+
+        if (mapper)
+            for (let item of this) {
+                total += mapper(item);
+            }
+        else
+            for (let item of this) {
+                total += item as number;
+            }
+        return total;
+    }
+
+    public avg(mapper?: UnaryFunction<T, number>): number {
+        let total = 0;
+        let count = 0;
+
+        if (mapper)
+            for (let item of this) {
+                total += mapper(item);
+                count++;
+            }
+        else
+            for (let item of this) {
+                total += item as number;
+                count++;
+            }
+        return count > 0 ? total / count : 0;
+    }
+
+    public max(mapper: UnaryFunction<T, number>): number {
+        let max = -Infinity;
+        for (let item of this) {
+            let value = mapper(item);
+            max = value > max ? value : max;
+        }
+        return max;
+    }
+
+    public min(mapper: UnaryFunction<T, number>): number {
+        let min = Infinity;
+        for (let item of this) {
+            let value = mapper(item);
+            min = value < min ? value : min;
+        }
+        return min;
+    }
+
+    public maxBy(mapper: UnaryFunction<T, number>): T | undefined {
+        let max = -Infinity;
+        let maxItem: T | undefined;
+        for (let item of this) {
+            let value = mapper(item);
+            if (value > max) {
+                max = value;
+                maxItem = item;
+            }
+        }
+        return maxItem;
+    }
+
+    public minBy(mapper: UnaryFunction<T, number>): T | undefined {
+        let min = Infinity;
+        let minItem: T | undefined;
+        for (let item of this) {
+            let value = mapper(item);
+            if (value < min) {
+                min = value;
+                minItem = item;
+            }
+        }
+        return minItem;
+    }
+
+    public orderBy<R>(mapper: UnaryFunction<T, R>): From<T> {
+        const array = Array.from(this._fn());
+        array.sort((a, b) => {
+            const aValue = mapper(a);
+            const bValue = mapper(b);
+            return aValue > bValue ? 1 : aValue < bValue ? -1 : 0;
+        });
+        return From.iterable(array);
+    }
+
+    public groupBy<TKey>(keySelector: UnaryFunction<T, TKey>, equalityComparer?: EqualityComparer<TKey>): From<Grouping<TKey, T>> {
+
+        equalityComparer = (equalityComparer == null ? From._shallowEqual : equalityComparer);
+        const self = this;
+
+        return From.fn<Grouping<TKey, T>>(function* () {
+            const groups: Array<[TKey, T[]]> = [];
+            for (let item of self) {
+                const key = keySelector(item);
+                let found = false;
+                for (let [entryKey, group] of groups) {
+                    if (equalityComparer(key, entryKey)) {
+                        group.push(item);
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    groups.push([key, [item]]);
+                }
+            }
+            yield* groups.map(([key, values]) => new Grouping<TKey, T>(key, values));
+        });
+    }
+
+    public head(n: number): From<T> {
+
+        const self = this;
+        return From.fn<T>(function* () {
+            let count = 0;
+            for (let item of self) {
+                if (count++ < n) {
+                    yield item;
+                } else {
+                    return;
+                }
+            }
+        });
+    }
+
+    public tail(n: number): From<T> {
+
+        const self = this;
+        return From.fn<T>(function* () {
+            let buffer = [];
+            for (let item of self) {
+                buffer.push(item);
+                if (buffer.length > n) {
+                    buffer.shift();
+                }
+            }
+            yield* buffer;
+        });
+    }
+
+    public forEach(action: Consumer<T>): void {
+        for (let item of this) {
+            action(item);
+        }
+    }
+
+    public toArray(): T[] {
+        return Array.from(this);
+    }
+
+
+    public instancesOf(type: string): From<T> {
+        return this.filter(item => typeof item === type);
+    }
+
+    public allInstanceOf(type: new (...args: any[]) => any): boolean {
+        for (let item of this) {
+            if (!(item instanceof type)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public distinct(eq_comparer?: EqualityComparer<T>): From<T> {
+
+        if (eq_comparer == null)
+            eq_comparer = From._shallowEqual;
+
+        const self = this;
+        return From.fn<T>(function* () {
+
+            const included = [];
+
+            for (let item of self) {
+                if (!From.iterable(included).any(x => eq_comparer(x, item))) {
+                    included.push(item);
+                    yield item;
+                }
+            }
+        });
+    }
+
+    public insert(item: T, index: number): From<T> {
+
+        const self = this;
+        return From.fn<T>(function* () {
+            let i = 0;
+            let inserted = false;
+            for (let existingItem of self) {
+                if (i === index) {
+                    yield item;
+                    inserted = true;
+                }
+                yield existingItem;
+                i++;
+            }
+            if (!inserted) {
+                yield item;
+            }
+        });
+    }
+
+    public skip(n: number): From<T> {
+        const self = this;
+        return From.fn<T>(function* () {
+            let i = 0;
+            for (let item of self) {
+                if (i >= n) {
+                    yield item;
+                }
+                i++;
+            }
+        });
+    }
+
+
+    public union(other: Iterable<T>): From<T> {
+        const self = this;
+        return From.fn<T>(function* () {
+            yield* self;
+            yield* other;
+        });
+    }
+
+    public innerJoin<T2, R, R2>(other: Iterable<T2>, thisKeySelector: UnaryFunction<T, R>, otherKeySelector: UnaryFunction<T2, R>, resultSelector: (thisItem: T, otherItem: T2) => R2): From<R2> {
+
+        const self = this;
+        return From.fn<R2>(() => {
+            const otherByKey = new Map<R, T2>();
+            for (let item of other) {
+                otherByKey.set(otherKeySelector(item), item);
+            }
+            return Array.from(self)
+                .filter(item => otherByKey.has(thisKeySelector(item)))
+                .map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))!));
+        });
+    }
+
+    public leftJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItem: T, otherItem: U | undefined) => R): From<R> {
+
+        const self = this;
+        return From.fn<R>(() => {
+            const otherByKey = new Map<K, U>();
+            for (let item of other) {
+                otherByKey.set(otherKeySelector(item), item);
+            }
+            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
+        });
+    }
+
+
+    public leftGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItem: T, otherItems: Array<U>) => R): From<R> {
+
+        const self = this;
+        return From.fn<R>(() => {
+            const otherByKeys = new Map<K, Array<U>>();
+            for (let item of other) {
+                const key = otherKeySelector(item);
+                if (!otherByKeys.has(key)) {
+                    otherByKeys.set(key, []);
+                }
+                otherByKeys.get(key)!.push(item);
+            }
+            return Array.from(self).map(item => resultSelector(item, otherByKeys.get(thisKeySelector(item)) || []));
+        });
+    }
+
+    public rightGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItems: Array<T>, otherItem: U) => R): From<R> {
+
+        const self = this;
+        return From.fn<R>(() => {
+            const thisByKeys = new Map<K, Array<T>>();
+            for (let item of self) {
+                const key = thisKeySelector(item);
+                if (!thisByKeys.has(key)) {
+                    thisByKeys.set(key, []);
+                }
+                thisByKeys.get(key)!.push(item);
+            }
+            return Array.from(other).map(item => resultSelector(thisByKeys.get(otherKeySelector(item)) || [], item));
+        });
+    }
+
+
+    public rightJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItem: T | undefined, otherItem: U) => R): From<R> {
+
+        const self = this;
+        return From.fn<R>(() => {
+            const thisByKey = new Map<K, T>();
+            for (let item of self) {
+                thisByKey.set(thisKeySelector(item), item);
+            }
+            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)), item));
+        });
+    }
+
+}
+
+export class Grouping<TKey, T> extends From<T> {
+
+    private readonly _key: TKey;
+
+    public get key(): TKey {
+        return this._key;
+    }
+
+    public constructor(key: TKey, values: Array<T>) {
+        super(() => values);
+        this._key = key;
+    }
+
+
+}