fixed types

Author: morrisjdev

dev/IArray.ts

@@ -1,11 +1,11 @@
 interface Array<T> {
-    Order: Array<Linq4JS.OrderEntry>;
+    Order: Linq4JS.OrderEntry[];
     GroupValue: any;
 
     /**
      * Creates a copy of the array
      */
-    Clone(): Array<T>;
+    Clone(): T[];
 
     /**
      * Gets the index of the first item found by a filter
@@ -29,75 +29,75 @@
      * Executes a method for each item in the array
      * @param action A function (or function-string) that gets executed for each element. If it returns false the loop stops.
      */
-    ForEach(action: ((item: T, index?: number) => boolean | any) | string): Array<T>;
+    ForEach(action: ((item: T, index?: number) => boolean | any) | string): T[];
 
     /**
      * Updates an object in the array
      * @param object The object to update
      * @param primaryKeySelector A selector-function (or function-string) to define a property to indentify object in array
      */
-    Update(object: T, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    Update(object: T, primaryKeySelector?: ((item: T) => any) | string): T[];
 
     /**
      * Updates objects in the array
      * @param objects The array of objects to update
      * @param primaryKeySelector A selector-function (or function-string) to define a property to indentify object in array
      */
-    UpdateRange(objects: Array<T>, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    UpdateRange(objects: T[], primaryKeySelector?: ((item: T) => any) | string): T[];
 
     /**
      * Removes an object from the array
      * @param object The object to remove
      * @param primaryKeySelector A selector-function (or function-string) to define a property to indentify object in array
      */
-    Remove(object: T, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    Remove(object: T, primaryKeySelector?: ((item: T) => any) | string): T[];
 
     /**
      * Removes objects from the array
      * @param objects The array of objects to remove
      * @param primaryKeySelector A selector-function (or function-string) to define a property to indentify object in array
      */
-    RemoveRange(objects: Array<T>, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    RemoveRange(objects: T[], primaryKeySelector?: ((item: T) => any) | string): T[];
 
     /**
      * Adds an object to the array
      * @param object The object to add
      * @param generateId Auto-generate a property to identify object in later processes
      */
-    Add(object: T, generateId?: boolean): Array<T>;
+    Add(object: T, generateId?: boolean): T[];
 
     /**
      * Adds objects to the array
      * @param objects The array of objects to add
      */
-    AddRange(objects: Array<T>, generateId?: boolean): Array<T>;
+    AddRange(objects: T[], generateId?: boolean): T[];
 
     /**
      * Inserts an entry at a specific position
      * @param object The object to insert
      * @param index The position to insert
      */
-    Insert(object: T, index: number): Array<T>;
+    Insert(object: T, index: number): T[];
 
     /**
      * Searches for all items in array that match the given filter
      * @param filter A function (or function-string) that returns a boolean when matching element was found
      */
-    Where(filter: ((item: T, index?: number) => boolean) | string): Array<T>;
+    Where(filter: ((item: T, index?: number) => boolean) | string): T[];
 
     /**
      * Takes items in a specific range
      * @param start The start position
      * @param length The number of elements to take
      */
-    Range(start: number, length: number): Array<T>;
+    Range(start: number, length: number): T[];
 
     /**
      * Repeats an object in the array
      * @param object The object to repeat
      * @param count The count of repeats
      */
-    Repeat(object: T, count: number): Array<T>;
+    Repeat(object: T, count: number): T[];
 
     /**
      * Returns the length of the array
@@ -151,45 +151,45 @@
      * Limits the number of entries taken
      * @param count The count of elements taken
      */
-    Take(count: number): Array<T>;
+    Take(count: number): T[];
 
     /**
      * Takes entries as long as a condition is true
      * @param condition The condition-function (or function-string) that returns a boolean. All elements until a false gets created are taken
      * @param initial A initial-function (or function-string) that gets executed once at the start of the loop
      * @param after A function that gets executed after every element-iteration after the condition-function was evaluated
      */
-    TakeWhile(condition: ((item: T, storage?: any) => boolean) | string, initial?: ((storage: any) => void) | string, after?: ((item: T, storage: any) => void) | string): Array<T>;
+    TakeWhile(condition: ((item: T, storage?: any) => boolean) | string, initial?: ((storage: any) => void) | string, after?: ((item: T, storage: any) => void) | string): T[];
 
     /**
      * Skips entries
      * @param count The count of elements skipped
      */
-    Skip(count: number): Array<T>;
+    Skip(count: number): T[];
 
     /**
      * Orders array by property or value in ascending direction
      * @param valueSelector The selector-function (or function-string) that selects the property for sorting
      */
-    OrderBy(valueSelector: ((item: T) => any) | string): Array<T>;
+    OrderBy(valueSelector: ((item: T) => any) | string): T[];
 
     /**
      * Orders array by additional properties in ascending direction in combination with OrderBy/OrderByDescending
      * @param valueSelector The selector-function (or function-string) that selects the property for sorting
      */
-    ThenBy(valueSelector: ((item: T) => any) | string): Array<T>;
+    ThenBy(valueSelector: ((item: T) => any) | string): T[];
 
     /**
      * Orders array by property or value in descending direction
      * @param valueSelector The selector-function (or function-string) that selects the property for sorting
      */
-    OrderByDescending(valueSelector: ((item: T) => any) | string): Array<T>;
+    OrderByDescending(valueSelector: ((item: T) => any) | string): T[];
 
     /**
      * Orders array by additional properties in descending direction in combination with OrderBy/OrderByDescending
      * @param valueSelector The selector-function (or function-string) that selects the property for sorting
      */
-    ThenByDescending(valueSelector: ((item: T) => any) | string): Array<T>;
+    ThenByDescending(valueSelector: ((item: T) => any) | string): T[];
 
     /**
      * Returns the smallest element in array
@@ -207,20 +207,20 @@
      * Groups array by property
      * @param selector The selector-function (or function-string) that selects the property for grouping
      */
-    GroupBy(selector: ((item: T) => any) | string): Array<Array<T>>;
+    GroupBy(selector: ((item: T) => any) | string): T[][];
 
     /**
      * Moves an item from one index to another
      * @param oldIndex The current position of the item
      * @param newIndex The new position of the item
      */
-    Move(oldIndex: number, newIndex: number): Array<T>;
+    Move(oldIndex: number, newIndex: number): T[];
 
     /**
      * Makes all values unique
      * @param valueSelector A selector-function (or function-string) to select property for comparison and distinction
      */
-    Distinct(valueSelector?: ((item: T) => any) | string): Array<T>;
+    Distinct(valueSelector?: ((item: T) => any) | string): T[];
 
     /**
      * Tests if array contains specific object
@@ -232,13 +232,13 @@
      * Combines two arrays
      * @param array The array to combine
      */
-    Concat(array: Array<T>): Array<T>;
+    Concat(array: T[]): T[];
 
     /**
      * Combines two arrays but only applies values that are in both arrays
      * @param array The array to combine
      */
-    Intersect(array: Array<T>): Array<T>;
+    Intersect(array: T[]): T[];
 
     /**
      * Joins the entries by a given char
@@ -257,7 +257,7 @@
     /**
      * Reverses the array
      */
-    Reverse(): Array<T>;
+    Reverse(): T[];
 
     /**
      * Computes the average of the elements
@@ -277,20 +277,20 @@
      * Compares to sequences of objects
      * @param array The array to compare
      */
-    SequenceEqual(array: Array<T>): boolean;
+    SequenceEqual(array: T[]): boolean;
 
     /**
      * Combines the entries of two arrays using a custom function
      * @param array The array to combine
      * @param result The function (or function-string) to combine elements
      */
-    Zip<T, X>(array: Array<X>, result: ((first: T, second: X) => any) | string): Array<any>;
+    Zip<T, X>(array: X[], result: ((first: T, second: X) => any) | string): any[];
 
     /**
      * Combines two arrays without duplicates
      * @param array The array to combine
      */
-    Union(array: Array<T>): Array<T>;
+    Union(array: T[]): T[];
 
     /**
      * Converts the array to a dictionary

dev/Linq4JS.ts

@@ -1,5 +1,5 @@
-Array.prototype.Add = function<T> (this: Array<T>, object: T, generateId?: boolean): Array<T> {
-    let that: Array<T> = this;
+Array.prototype.Add = function<T> (this: T[], object: T, generateId?: boolean): T[] {
+    let that: T[] = this;
 
     if (object != null) {
         if (generateId == true) {

dev/Modules/Add.ts

@@ -1,5 +1,5 @@
-Array.prototype.AddRange = function<T> (this: Array<T>, objects: Array<T>, generateId: boolean): Array<T> {
-    let that: Array<T> = this;
+Array.prototype.AddRange = function<T> (this: T[], objects: T[], generateId: boolean): T[] {
+    let that: T[] = this;
 
     objects.ForEach(function (x: T) {
         that.Add(x, generateId);

dev/Modules/AddRange.ts

@@ -1,5 +1,5 @@
-Array.prototype.Aggregate = function<T> (this: Array<T>, method: ((result: any, item: T) => any) | string, startVal?: any): string {
-    let that: Array<T> = this;
+Array.prototype.Aggregate = function<T> (this: T[], method: ((result: any, item: T) => any) | string, startVal?: any): string {
+    let that: T[] = this;
 
     let result: any;
 

dev/Modules/Aggregate.ts

@@ -1,5 +1,5 @@
-Array.prototype.All = function<T> (this: Array<T>, filter: ((item: T) => boolean) | string): boolean {
-    let that: Array<T> = this;
+Array.prototype.All = function<T> (this: T[], filter: ((item: T) => boolean) | string): boolean {
+    let that: T[] = this;
 
     return that.Count(filter) == that.Count();
 };

dev/Modules/All.ts

@@ -1,5 +1,5 @@
-Array.prototype.Any = function<T> (this: Array<T>, filter?: ((item: T) => boolean) | string): boolean {
-    let that: Array<T> = this;
+Array.prototype.Any = function<T> (this: T[], filter?: ((item: T) => boolean) | string): boolean {
+    let that: T[] = this;
 
     return that.Count(filter) > 0;
 };

dev/Modules/Any.ts

@@ -1,5 +1,5 @@
-Array.prototype.Average = function <T>(this: Array<T>, selector?: ((item: T) => any) | string, filter?: ((item: T) => boolean) | string): number {
-    let that: Array<T> = this;
+Array.prototype.Average = function <T>(this: T[], selector?: ((item: T) => any) | string, filter?: ((item: T) => boolean) | string): number {
+    let that: T[] = this;
 
     let result: number = 0;
     let array: Array<any> = that;

dev/Modules/Average.ts

@@ -1,7 +1,7 @@
-Array.prototype.Clone = function<T> (this: Array<T>): Array<T> {
-    let that: Array<T> = this;
+Array.prototype.Clone = function<T> (this: T[]): T[] {
+    let that: T[] = this;
 
-    let newArray: Array<T> = new Array<T>();
+    let newArray: T[] = [];
 
     for (let obj of that) {
         newArray.Add(obj);

dev/Modules/Clone.ts

@@ -1,5 +1,5 @@
-Array.prototype.Concat = function<T> (this: Array<T>, array: Array<T>): Array<T> {
-    let that: Array<T> = this;
+Array.prototype.Concat = function<T> (this: T[], array: T[]): T[] {
+    let that: T[] = this;
     that = that.concat(array); 
     return that;
 };