tsreflect-ioc/src/array.ts

Inversion of control and Dependency injection framework for typescript based on the tsreflect-compiler package.

/// <reference path="_references.ts" />
var extend = require('extend');

interface Array<T> {
    each(fn: (item: T, index?: number, self?: T[]) => boolean): boolean;
    where(expr: (item: T, index: number, self: T[]) => any): any[];
    where(equalsObj: T): any[];
    any(expr?: (item: T, index: number, self: T[]) => boolean): boolean;
    any(equalsObj?: T): boolean;
    first(expr?: (item: T, index: number, self: T[]) => boolean): T;
    first(equalsObj?: T): T;
    firstOrDefault(expr?: (item: T, index: number, self: T[]) => boolean): T;
    firstOrDefault(equalsObj?: T): T;
    select(expr: (item: T, index: number, self: T[]) => any): any[];
}

class ArrayExtensions<T> {

    select(expr: (item: T, index: number, self: T[]) => any): any[]{
        if (expr === undefined) throw new ReferenceError('Expression for selection needs to get defined');
        var resultSet = [];
        this.each((item: T, index: number, self: T[]): boolean => {
            resultSet.push(expr(item, index, self));
            return true;
        });
        return resultSet;
    }

    any(expr: (item: T, index: number, self: T[]) => boolean): boolean {
        var self = (<Array<T>><any>this);
        if (expr === undefined) {
            return self.length > 0;
        }
        var fn: Function;
        if (typeof expr == 'function') {
            fn = expr;
        } else {
            fn = function (item: any): boolean {
                return item == expr;
            }
        }
        var len = self.length;
        for (var i = 0; i < len; i++) {
            var current = this[i],
                result = fn(current, i, self);
            if (result == true) {
                return true;
            }
        }
        return false;
    }

    first(expr: (item: T, index: number, self: T[]) => boolean): any {
        var res = this.firstOrDefault(expr);
        if(res==null)
            throw new Error('The collection is empty or your expression does not match, first() cant deliver any entry.');
        return res;
    }

    firstOrDefault(expr: (item: T, index: number, self: T[]) => boolean): any {
        var self = (<Array<T>><any>this);
        if (expr === undefined && self.length > 0) {
            return self[0];
        } else {
            var fn: Function;
            if (typeof expr == 'function') {
                fn = expr;
            } else {
                fn = function (item: any): boolean {
                    return item == expr;
                }
            }
            var len = self.length;
            for (var i = 0; i < len; i++) {
                var current = this[i],
                    result = fn(current, i, self);
                if (result == true) {
                    return current;
                }
            }
        }
        return null;
    }

    each(fn: (item: T, index: number, self: T[]) => boolean): boolean {
        var self = (<Array<T>><any>this);
        var length = self.length;
        for (var i = 0; i < length; i++) {
            if (fn(self[i], i, self) === false) {
                return false;
            }
        }
        return true;
    }

    where(expr: (item: T, index: number, self: T[]) => any): any[] {
        var self = (<Array<T>><any>this);
        var result = [];
        var fn = typeof expr == 'function' ? expr : (item) => item == expr;
        this.each((item, index, _self) => {
            if (fn(item, index, _self)) result.push(item);
            return true;
        });
        return result;
    }
};
extend(false, Array.prototype, ArrayExtensions.prototype);