linqcontainers/build/src/Collections.js

Linq-Collections (ES5): [IEnumerable, IQueryable, ...] + [List, Dictionary, Stack, ... + readonly]

"use strict";
// -
// Created by Ivan Sanz (@isc30)
// Copyright © 2017 Ivan Sanz Carasa. All rights reserved.
// -
var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
// region IMPORTS
// tslint:disable-next-line:max-line-length
var Enumerables_1 = require("./Enumerables");
var Comparers_1 = require("./Comparers");
// endregion
// region EnumerableCollection
var EnumerableCollection = /** @class */ (function () {
    function EnumerableCollection() {
    }
    EnumerableCollection.prototype.toList = function () {
        return new List(this.toArray());
    };
    EnumerableCollection.prototype.toDictionary = function (keySelector, valueSelector) {
        return Dictionary.fromArray(this.toArray(), keySelector, valueSelector);
    };
    EnumerableCollection.prototype.reverse = function () {
        return new Enumerables_1.ReverseEnumerable(this.asEnumerable());
    };
    EnumerableCollection.prototype.concat = function (other) {
        var others = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            others[_i - 1] = arguments[_i];
        }
        return (_a = this.asEnumerable()).concat.apply(_a, [other].concat(others));
        var _a;
    };
    EnumerableCollection.prototype.contains = function (element) {
        return this.any(function (e) { return e === element; });
    };
    EnumerableCollection.prototype.where = function (predicate) {
        return new Enumerables_1.ConditionalEnumerable(this.asEnumerable(), predicate);
    };
    EnumerableCollection.prototype.select = function (selector) {
        return new Enumerables_1.TransformEnumerable(this.asEnumerable(), selector);
    };
    EnumerableCollection.prototype.selectMany = function (selector) {
        var selectToEnumerable = function (e) {
            var ie = selector(e);
            return Array.isArray(ie)
                ? new Enumerables_1.ArrayEnumerable(ie)
                : ie.asEnumerable();
        };
        return this
            .select(selectToEnumerable).toArray()
            .reduce(function (p, c) { return new Enumerables_1.ConcatEnumerable(p, c); }, Enumerables_1.Enumerable.empty());
    };
    EnumerableCollection.prototype.elementAt = function (index) {
        var element = this.elementAtOrDefault(index);
        if (element === undefined) {
            throw new Error("Out of bounds");
        }
        return element;
    };
    EnumerableCollection.prototype.except = function (other) {
        return this.asEnumerable().except(other);
    };
    EnumerableCollection.prototype.first = function (predicate) {
        var element;
        if (predicate !== undefined) {
            element = this.firstOrDefault(predicate);
        }
        else {
            element = this.firstOrDefault();
        }
        if (element === undefined) {
            throw new Error("Sequence contains no elements");
        }
        return element;
    };
    EnumerableCollection.prototype.groupBy = function (keySelector, valueSelector) {
        var array = this.toArray();
        var dictionary = new Dictionary();
        for (var i = 0; i < array.length; ++i) {
            var key = keySelector(array[i]);
            var value = valueSelector !== undefined
                ? valueSelector(array[i])
                : array[i];
            if (!dictionary.containsKey(key)) {
                dictionary.set(key, new List());
            }
            dictionary.get(key).push(value);
        }
        return dictionary.asEnumerable();
    };
    EnumerableCollection.prototype.last = function (predicate) {
        var element;
        if (predicate !== undefined) {
            element = this.lastOrDefault(predicate);
        }
        else {
            element = this.lastOrDefault();
        }
        if (element === undefined) {
            throw new Error("Sequence contains no elements");
        }
        return element;
    };
    EnumerableCollection.prototype.single = function (predicate) {
        var element;
        if (predicate !== undefined) {
            element = this.singleOrDefault(predicate);
        }
        else {
            element = this.singleOrDefault();
        }
        if (element === undefined) {
            throw new Error("Sequence contains no elements");
        }
        return element;
    };
    EnumerableCollection.prototype.singleOrDefault = function (predicate) {
        if (predicate !== undefined) {
            return this.asEnumerable().singleOrDefault(predicate);
        }
        return this.asEnumerable().singleOrDefault();
    };
    EnumerableCollection.prototype.distinct = function (keySelector) {
        return new Enumerables_1.UniqueEnumerable(this.asEnumerable(), keySelector);
    };
    EnumerableCollection.prototype.min = function (selector) {
        if (selector !== undefined) {
            // Don't copy iterators
            return new Enumerables_1.TransformEnumerable(this.asEnumerable(), selector).min();
        }
        return this.aggregate(function (previous, current) {
            return (previous !== undefined && previous < current)
                ? previous
                : current;
        });
    };
    EnumerableCollection.prototype.orderBy = function (keySelector, comparer) {
        return new Enumerables_1.OrderedEnumerable(this.asEnumerable(), Comparers_1.createComparer(keySelector, true, comparer));
    };
    EnumerableCollection.prototype.orderByDescending = function (keySelector) {
        return new Enumerables_1.OrderedEnumerable(this.asEnumerable(), Comparers_1.createComparer(keySelector, false, undefined));
    };
    EnumerableCollection.prototype.max = function (selector) {
        if (selector !== undefined) {
            // Don't copy iterators
            return new Enumerables_1.TransformEnumerable(this.asEnumerable(), selector).max();
        }
        return this.aggregate(function (previous, current) {
            return (previous !== undefined && previous > current)
                ? previous
                : current;
        });
    };
    EnumerableCollection.prototype.sum = function (selector) {
        return this.aggregate(function (previous, current) { return previous + selector(current); }, 0);
    };
    EnumerableCollection.prototype.skip = function (amount) {
        return new Enumerables_1.RangeEnumerable(this.asEnumerable(), amount, undefined);
    };
    EnumerableCollection.prototype.take = function (amount) {
        return new Enumerables_1.RangeEnumerable(this.asEnumerable(), undefined, amount);
    };
    EnumerableCollection.prototype.union = function (other) {
        return new Enumerables_1.UniqueEnumerable(this.concat(other));
    };
    EnumerableCollection.prototype.aggregate = function (aggregator, initialValue) {
        if (initialValue !== undefined) {
            return this.asEnumerable().aggregate(aggregator, initialValue);
        }
        return this.asEnumerable().aggregate(aggregator);
    };
    EnumerableCollection.prototype.any = function (predicate) {
        if (predicate !== undefined) {
            return this.asEnumerable().any(predicate);
        }
        return this.asEnumerable().any();
    };
    EnumerableCollection.prototype.all = function (predicate) {
        return this.asEnumerable().all(predicate);
    };
    EnumerableCollection.prototype.average = function (selector) {
        return this.asEnumerable().average(selector);
    };
    EnumerableCollection.prototype.count = function (predicate) {
        if (predicate !== undefined) {
            return this.asEnumerable().count(predicate);
        }
        return this.asEnumerable().count();
    };
    EnumerableCollection.prototype.elementAtOrDefault = function (index) {
        return this.asEnumerable().elementAtOrDefault(index);
    };
    EnumerableCollection.prototype.firstOrDefault = function (predicate) {
        if (predicate !== undefined) {
            return this.asEnumerable().firstOrDefault(predicate);
        }
        return this.asEnumerable().firstOrDefault();
    };
    EnumerableCollection.prototype.lastOrDefault = function (predicate) {
        if (predicate !== undefined) {
            return this.asEnumerable().lastOrDefault(predicate);
        }
        return this.asEnumerable().lastOrDefault();
    };
    EnumerableCollection.prototype.forEach = function (action) {
        return this.asEnumerable().forEach(action);
    };
    return EnumerableCollection;
}());
exports.EnumerableCollection = EnumerableCollection;
// endregion
// region ArrayQueryable
var ArrayQueryable = /** @class */ (function (_super) {
    __extends(ArrayQueryable, _super);
    function ArrayQueryable(elements) {
        if (elements === void 0) { elements = []; }
        var _this = _super.call(this) || this;
        _this.source = elements;
        return _this;
    }
    ArrayQueryable.prototype.asArray = function () {
        return this.source;
    };
    ArrayQueryable.prototype.toArray = function () {
        return [].concat(this.source);
    };
    ArrayQueryable.prototype.toList = function () {
        return new List(this.toArray());
    };
    ArrayQueryable.prototype.asEnumerable = function () {
        return new Enumerables_1.ArrayEnumerable(this.source);
    };
    ArrayQueryable.prototype.aggregate = function (aggregator, initialValue) {
        if (initialValue !== undefined) {
            return this.source.reduce(aggregator, initialValue);
        }
        return this.source.reduce(aggregator);
    };
    ArrayQueryable.prototype.any = function (predicate) {
        if (predicate !== undefined) {
            return this.source.some(predicate);
        }
        return this.source.length > 0;
    };
    ArrayQueryable.prototype.all = function (predicate) {
        return this.source.every(predicate);
    };
    ArrayQueryable.prototype.average = function (selector) {
        if (this.count() === 0) {
            throw new Error("Sequence contains no elements");
        }
        var sum = 0;
        for (var i = 0, end = this.source.length; i < end; ++i) {
            sum += selector(this.source[i]);
        }
        return sum / this.source.length;
    };
    ArrayQueryable.prototype.count = function (predicate) {
        if (predicate !== undefined) {
            return this.source.filter(predicate).length;
        }
        return this.source.length;
    };
    ArrayQueryable.prototype.elementAtOrDefault = function (index) {
        if (index < 0) {
            throw new Error("Negative index is forbiden");
        }
        return this.source[index];
    };
    ArrayQueryable.prototype.firstOrDefault = function (predicate) {
        if (predicate !== undefined) {
            return this.source.filter(predicate)[0];
        }
        return this.source[0];
    };
    ArrayQueryable.prototype.groupBy = function (keySelector, valueSelector) {
        var array = this.asArray();
        var dictionary = new Dictionary();
        for (var i = 0; i < array.length; ++i) {
            var key = keySelector(array[i]);
            var value = valueSelector !== undefined
                ? valueSelector(array[i])
                : array[i];
            if (!dictionary.containsKey(key)) {
                dictionary.set(key, new List());
            }
            dictionary.get(key).push(value);
        }
        return dictionary.asEnumerable();
    };
    ArrayQueryable.prototype.lastOrDefault = function (predicate) {
        if (predicate !== undefined) {
            var records = this.source.filter(predicate);
            return records[records.length - 1];
        }
        return this.source[this.source.length - 1];
    };
    ArrayQueryable.prototype.forEach = function (action) {
        for (var i = 0, end = this.source.length; i < end; ++i) {
            action(this.source[i], i);
        }
    };
    return ArrayQueryable;
}(EnumerableCollection));
exports.ArrayQueryable = ArrayQueryable;
var List = /** @class */ (function (_super) {
    __extends(List, _super);
    function List() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    List.prototype.copy = function () {
        return new List(this.toArray());
    };
    List.prototype.asReadOnly = function () {
        return this;
    };
    List.prototype.clear = function () {
        this.source = [];
    };
    List.prototype.remove = function (element) {
        var newSource = [];
        for (var i = 0, end = this.source.length; i < end; ++i) {
            if (this.source[i] !== element) {
                newSource.push(this.source[i]);
            }
        }
        this.source = newSource;
    };
    List.prototype.removeAt = function (index) {
        if (index < 0 || this.source[index] === undefined) {
            throw new Error("Out of bounds");
        }
        return this.source.splice(index, 1)[0];
    };
    List.prototype.get = function (index) {
        return this.source[index];
    };
    List.prototype.push = function (element) {
        return this.source.push(element);
    };
    List.prototype.pushRange = function (elements) {
        if (!Array.isArray(elements)) {
            elements = elements.toArray();
        }
        return this.source.push.apply(this.source, elements);
    };
    List.prototype.pushFront = function (element) {
        return this.source.unshift(element);
    };
    List.prototype.pop = function () {
        return this.source.pop();
    };
    List.prototype.popFront = function () {
        return this.source.shift();
    };
    List.prototype.set = function (index, element) {
        if (index < 0) {
            throw new Error("Out of bounds");
        }
        this.source[index] = element;
    };
    List.prototype.insert = function (index, element) {
        if (index < 0 || index > this.source.length) {
            throw new Error("Out of bounds");
        }
        this.source.splice(index, 0, element);
    };
    List.prototype.indexOf = function (element) {
        return this.source.indexOf(element);
    };
    return List;
}(ArrayQueryable));
exports.List = List;
var Stack = /** @class */ (function (_super) {
    __extends(Stack, _super);
    function Stack() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Stack.prototype.copy = function () {
        return new Stack(this.toArray());
    };
    Stack.prototype.clear = function () {
        this.source = [];
    };
    Stack.prototype.peek = function () {
        return this.source[this.source.length - 1];
    };
    Stack.prototype.pop = function () {
        return this.source.pop();
    };
    Stack.prototype.push = function (element) {
        return this.source.push(element);
    };
    return Stack;
}(ArrayQueryable));
exports.Stack = Stack;
var Dictionary = /** @class */ (function (_super) {
    __extends(Dictionary, _super);
    function Dictionary(keyValuePairs) {
        var _this = _super.call(this) || this;
        _this.clear();
        if (keyValuePairs !== undefined) {
            for (var i = 0; i < keyValuePairs.length; ++i) {
                var pair = keyValuePairs[i];
                _this.set(pair.key, pair.value);
            }
        }
        return _this;
    }
    Dictionary.fromArray = function (array, keySelector, valueSelector) {
        var keyValuePairs = array.map(function (v) {
            return {
                key: keySelector(v),
                value: valueSelector(v),
            };
        });
        return new Dictionary(keyValuePairs);
    };
    Dictionary.fromJsObject = function (object) {
        var keys = new List(Object.getOwnPropertyNames(object));
        var keyValues = keys.select(function (k) { return ({ key: k, value: object[k] }); });
        return new Dictionary(keyValues.toArray());
    };
    Dictionary.prototype.copy = function () {
        return new Dictionary(this.toArray());
    };
    Dictionary.prototype.asReadOnly = function () {
        return this;
    };
    Dictionary.prototype.asEnumerable = function () {
        return new Enumerables_1.ArrayEnumerable(this.toArray());
    };
    Dictionary.prototype.toArray = function () {
        var _this = this;
        return this.getKeys().select(function (p) {
            return {
                key: p,
                value: _this.dictionary[p],
            };
        }).toArray();
    };
    Dictionary.prototype.clear = function () {
        this.dictionary = {};
    };
    Dictionary.prototype.containsKey = function (key) {
        return this.dictionary.hasOwnProperty(key);
    };
    Dictionary.prototype.containsValue = function (value) {
        var keys = this.getKeysFast();
        for (var i = 0; i < keys.length; ++i) {
            if (this.dictionary[keys[i]] === value) {
                return true;
            }
        }
        return false;
    };
    Dictionary.prototype.getKeys = function () {
        var _this = this;
        var keys = this.getKeysFast();
        return new List(keys.map(function (k) { return _this.keyType === "number"
            ? parseFloat(k)
            : k; }));
    };
    Dictionary.prototype.getKeysFast = function () {
        return Object.getOwnPropertyNames(this.dictionary);
    };
    Dictionary.prototype.getValues = function () {
        var keys = this.getKeysFast();
        var result = new Array(keys.length);
        for (var i = 0; i < keys.length; ++i) {
            result[i] = this.dictionary[keys[i]];
        }
        return new List(result);
    };
    Dictionary.prototype.remove = function (key) {
        if (this.containsKey(key)) {
            delete this.dictionary[key];
        }
    };
    Dictionary.prototype.get = function (key) {
        if (!this.containsKey(key)) {
            throw new Error("Key doesn't exist: " + key);
        }
        return this.dictionary[key];
    };
    Dictionary.prototype.set = function (key, value) {
        if (this.containsKey(key)) {
            throw new Error("Key already exists: " + key);
        }
        this.setOrUpdate(key, value);
    };
    Dictionary.prototype.setOrUpdate = function (key, value) {
        if (this.keyType === undefined) {
            this.keyType = typeof key;
        }
        this.dictionary[key] = value;
    };
    return Dictionary;
}(EnumerableCollection));
exports.Dictionary = Dictionary;
// endregion
//# sourceMappingURL=Collections.js.map