mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-23 12:56:46 +08:00
Linq.js provides its own typings (#11840)
This commit is contained in:
Andy
244
linq/index.d.ts
vendored
244
linq/index.d.ts
vendored
@@ -1,244 +0,0 @@
|
||||
// Type definitions for linq.js 2.2
|
||||
// Project: http://linqjs.codeplex.com/
|
||||
// Definitions by: Marcin Najder <https://github.com/marcinnajder>, Sebastiaan Dammann <https://github.com/Sebazzz>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
// todo: jQuery plugin, RxJS Binding
|
||||
|
||||
declare namespace linq {
|
||||
|
||||
interface EnumerableStatic {
|
||||
Choice<T>(...contents: T[]): Enumerable<T>;
|
||||
Choice<T>(contents: T[]): Enumerable<T>;
|
||||
Cycle<T>(...contents: T[]): Enumerable<T>;
|
||||
Cycle<T>(contents: T[]): Enumerable<T>;
|
||||
Empty<T>(): Enumerable<T>;
|
||||
From<T>(obj: T[]): Enumerable<T>;
|
||||
From(obj: number): Enumerable<number>; // input number returns single number
|
||||
From(obj: string): Enumerable<string>; // input string returns sequence of characters
|
||||
From(obj: NodeList): Enumerable<Node>; // node list returns sequence of nodes
|
||||
From(obj: Object): Enumerable<KeyValuePair<string, any>>; // object returns sequence of key/value pairs
|
||||
Return<T>(element: T): Enumerable<T>;
|
||||
Matches<T>(input: string, pattern: RegExp): Enumerable<string>;
|
||||
Matches<T>(input: string, pattern: string, flags?: string): Enumerable<string>;
|
||||
Range(start: number, count: number, step?: number): Enumerable<number>;
|
||||
RangeDown(start: number, count: number, step?: number): Enumerable<number>;
|
||||
RangeTo(start: number, to: number, step?: number): Enumerable<number>;
|
||||
Repeat<T>(obj: any, count?: number): Enumerable<T>;
|
||||
RepeatWithFinalize<T>(initializer: () => T, finalizer: (resource: T) => void): Enumerable<T>;
|
||||
Generate<T>(func: () => T, count?: number): Enumerable<T>;
|
||||
Generate(func: string, count?: number): Enumerable<any>;
|
||||
ToInfinity(start?: number, step?: number): Enumerable<number>;
|
||||
ToNegativeInfinity(start?: number, step?: number): Enumerable<number>;
|
||||
Unfold<T>(seed: T, func: ($: T) => T): Enumerable<T>;
|
||||
Unfold(seed: any, func: string): Enumerable<any>;
|
||||
}
|
||||
|
||||
interface Enumerable<T> {
|
||||
//Projection and Filtering Methods
|
||||
CascadeBreadthFirst(func: ($: T) => any[], resultSelector: (v: any, i: number) => any): Enumerable<any>;
|
||||
CascadeBreadthFirst(func: string, resultSelector: string): Enumerable<any>;
|
||||
CascadeDepthFirst(func: ($: T) => any[], resultSelector: (v: any, i: number) => any): Enumerable<any>;
|
||||
CascadeDepthFirst(func: string, resultSelector: string): Enumerable<any>;
|
||||
Flatten(...items: any[]): Enumerable<any>;
|
||||
Pairwise(selector: (prev: any, next: any) => any): Enumerable<any>;
|
||||
Pairwise(selector: string): Enumerable<any>;
|
||||
Scan(func: (a: any, b: any) => any): Enumerable<any>;
|
||||
Scan(func: string): Enumerable<any>;
|
||||
Scan(seed: any, func: (a: any, b: any) => any, resultSelector?: ($: T) => any): Enumerable<any>;
|
||||
Scan(seed: any, func: string, resultSelector?: string): Enumerable<any>;
|
||||
Select<TResult>(selector: ($: T, i: number) => TResult): Enumerable<TResult>;
|
||||
Select(selector: string): Enumerable<any>;
|
||||
SelectMany<TResult>(collectionSelector: ($: T, i: number) => TResult[]): Enumerable<TResult>;
|
||||
SelectMany<TResult>(collectionSelector: ($: T, i: number) => Enumerable<TResult>): Enumerable<TResult>;
|
||||
SelectMany<TCollectionItem, TResult>(collectionSelector: ($: T, i: number) => TCollectionItem[], resultSelector: ($: T, item: TCollectionItem) => TResult): Enumerable<TResult>;
|
||||
SelectMany<TCollectionItem, TResult>(collectionSelector: ($: T, i: number) => Enumerable<TCollectionItem>, resultSelector: ($: T, item: TCollectionItem) => TResult): Enumerable<TResult>;
|
||||
SelectMany(collectionSelector: string, resultSelector?: string): Enumerable<any>;
|
||||
Where(predicate: ($ : T, i: number) => boolean): Enumerable<T>;
|
||||
Where(predicate: string): Enumerable<any>;
|
||||
OfType(type: Function): Enumerable<any>;
|
||||
Zip(second: any[], selector: (v1: any, v2: any, i: number) => any): Enumerable<any>;
|
||||
Zip(second: any[], selector: string): Enumerable<any>;
|
||||
Zip(second: Enumerable<any>, selector: (v1: any, v2: any, i: number) => any): Enumerable<any>;
|
||||
Zip(second: Enumerable<any>, selector: string): Enumerable<any>;
|
||||
//Join Methods
|
||||
Join(inner: any[], outerKeySelector: (v1: any) => any, innerKeySelector: (v1: any) => any, resultSelector: (v1: any, v2: any) => any, compareSelector?: (v: any) => any): Enumerable<any>;
|
||||
Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
Join(inner: Enumerable<any>, outerKeySelector: (v1: any) => any, innerKeySelector: (v1: any) => any, resultSelector: (v1: any, v2: any) => any, compareSelector?: (v: any) => any): Enumerable<any>;
|
||||
Join(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
GroupJoin(inner: any[], outerKeySelector: (v1: any) => any, innerKeySelector: (v1: any) => any, resultSelector: (v1: any, v2: Enumerable<any>) => any, compareSelector?: (v: any) => any): Enumerable<any>;
|
||||
GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
GroupJoin(inner: Enumerable<any>, outerKeySelector: (v1: any) => any, innerKeySelector: (v1: any) => any, resultSelector: (v1: any, v2: Enumerable<any>) => any, compareSelector?: (v: any) => any): Enumerable<any>;
|
||||
GroupJoin(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
//Set Methods
|
||||
All(predicate: ($ : T) => boolean): boolean;
|
||||
All(predicate: string): boolean;
|
||||
Any(predicate?: ($: T) => boolean): boolean;
|
||||
Any(predicate?: string): boolean;
|
||||
Concat(second: any[]): Enumerable<any>;
|
||||
Concat(second: Enumerable<any>): Enumerable<any>;
|
||||
Insert(index: number, second: any[]): Enumerable<any>;
|
||||
Insert(index: number, second: Enumerable<any>): Enumerable<any>;
|
||||
Alternate(value: any): Enumerable<any>;
|
||||
Contains(value: any, compareSelector?: ($: T) => any): boolean;
|
||||
Contains(value: any, compareSelector?: string): boolean;
|
||||
DefaultIfEmpty(defaultValue: any): Enumerable<any>;
|
||||
Distinct(compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Distinct(compareSelector?: string): Enumerable<any>;
|
||||
Except(second: any[], compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Except(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Except(second: Enumerable<any>, compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Except(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
Intersect(second: any[], compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Intersect(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Intersect(second: Enumerable<any>, compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Intersect(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
SequenceEqual(second: any[], compareSelector?: ($: T) => any): boolean;
|
||||
SequenceEqual(second: any[], compareSelector?: string): boolean;
|
||||
SequenceEqual(second: Enumerable<any>, compareSelector?: ($: T) => any): boolean;
|
||||
SequenceEqual(second: Enumerable<any>, compareSelector?: string): boolean;
|
||||
Union(second: any[], compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Union(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Union(second: Enumerable<any>, compareSelector?: ($: T) => any): Enumerable<any>;
|
||||
Union(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
//Ordering Methods
|
||||
OrderBy(keySelector?: ($: T) => any): OrderedEnumerable<T>;
|
||||
OrderBy(keySelector?: string): OrderedEnumerable<T>;
|
||||
OrderByDescending(keySelector?: ($: T) => any): OrderedEnumerable<T>;
|
||||
OrderByDescending(keySelector?: string): OrderedEnumerable<T>;
|
||||
Reverse(): Enumerable<T>;
|
||||
Shuffle(): Enumerable<T>;
|
||||
//Grouping Methods
|
||||
GroupBy(keySelector: ($: T) => any, elementSelector?: ($: T) => any, resultSelector?: (key: any, e: any) => any, compareSelector?: ($: T) =>any): Enumerable<any>;
|
||||
GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
|
||||
PartitionBy(keySelector: ($: T) => any, elementSelector?: ($: T) => any, resultSelector?: (key: any, e: any) => any, compareSelector?: ($: T) =>any): Enumerable<any>;
|
||||
PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
|
||||
BufferWithCount(count: number): Enumerable<any>;
|
||||
// Aggregate Methods
|
||||
Aggregate(func: (a: any, b: any) => any): any;
|
||||
Aggregate(seed: any, func: (a: any, b: any) => any, resultSelector?: ($: T) => any): any;
|
||||
Aggregate(func: string): any;
|
||||
Aggregate(seed: any, func: string, resultSelector?: string): any;
|
||||
Average(selector?: ($: T) => number): number;
|
||||
Average(selector?: string): number;
|
||||
Count(predicate?: ($: T) => boolean): number;
|
||||
Count(predicate?: string): number;
|
||||
Max(selector?: ($: T) => any): any;
|
||||
Max(selector?: ($: T) => Date): Date;
|
||||
Max(selector?: ($: T) => number): number;
|
||||
Max(selector: ($: T) => string): string;
|
||||
Max(selector?: string): any;
|
||||
Min(selector?: ($: T) => any): any;
|
||||
Min(selector?: ($: T) => Date): Date;
|
||||
Min(selector: ($: T) => string): string;
|
||||
Min(selector?: ($: T) => number): number;
|
||||
Min(selector?: string): any;
|
||||
MaxBy(selector: ($: T) => any): any;
|
||||
MaxBy(selector: ($: T) => string): string;
|
||||
MaxBy(selector: ($: T) => Date): Date;
|
||||
MaxBy(selector: ($: T) => number): number;
|
||||
MaxBy(selector: string): any;
|
||||
MinBy(selector: ($: T) => Date): Date;
|
||||
MinBy(selector: ($: T) => number): any;
|
||||
MinBy(selector: ($: T) => string): string;
|
||||
MinBy(selector: ($: T) => any): any;
|
||||
MinBy(selector: string): any;
|
||||
Sum(selector?: ($: T) => number): number;
|
||||
Sum(selector?: string): number;
|
||||
//Paging Methods
|
||||
ElementAt(index: number): T;
|
||||
ElementAtOrDefault(index: number, defaultValue: T): T;
|
||||
First(predicate?: ($: T) => boolean): T;
|
||||
First(predicate?: string): T;
|
||||
FirstOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
FirstOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Last(predicate?: ($: T) => boolean): T;
|
||||
Last(predicate?: string): T;
|
||||
LastOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
LastOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Single(predicate?: ($: T) => boolean): T;
|
||||
Single(predicate?: string): T;
|
||||
SingleOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
SingleOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Skip(count: number): Enumerable<T>;
|
||||
SkipWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
|
||||
SkipWhile(predicate: string): Enumerable<T>;
|
||||
Take(count: number): Enumerable<T>;
|
||||
TakeWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
|
||||
TakeWhile(predicate: string): Enumerable<T>;
|
||||
TakeExceptLast(count?: number): Enumerable<T>;
|
||||
TakeFromLast(count: number): Enumerable<T>;
|
||||
IndexOf(item: T): number;
|
||||
LastIndexOf(item: T): number;
|
||||
// Convert Methods
|
||||
ToArray(): T[];
|
||||
ToLookup<TKey, TValue>(keySelector: ($: T) => TKey, elementSelector?: ($: T) => TValue, compareSelector?: (key: TKey) => any): Lookup<TKey, TValue>;
|
||||
ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup<any, any>;
|
||||
ToObject(keySelector: ($: T) => string, elementSelector: ($: T) => any): any;
|
||||
ToObject(keySelector: string, elementSelector: string): any;
|
||||
ToDictionary<TKey, TValue>(keySelector: ($: T) => TKey, elementSelector: ($: T) => TValue, compareSelector?: (key: TKey) => any): Dictionary<TKey, TValue>;
|
||||
ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary<any, any>;
|
||||
ToJSON(replacer?: (key: any, value: any) => any, space?: number): string;
|
||||
ToJSON(replacer?: string, space?: number): string;
|
||||
ToString(separator?: string, selector?: ($: T) =>any): string;
|
||||
ToString(separator?: string, selector?: string): string;
|
||||
//Action Methods
|
||||
Do(action: ($: T, i: number) => void ): Enumerable<any>;
|
||||
Do(action: string): Enumerable<any>;
|
||||
ForEach(action: ($: T, i: number) => void ): void;
|
||||
ForEach(func: ($: T, i: number) => boolean): void;
|
||||
ForEach(action_func: string): void;
|
||||
Write(separator?: string, selector?: ($: T) =>any): void;
|
||||
Write(separator?: string, selector?: string): void;
|
||||
WriteLine(selector?: ($: T) =>any): void;
|
||||
Force(): void;
|
||||
//Functional Methods
|
||||
Let(func: (e: Enumerable<any>) => Enumerable<any>): Enumerable<any>;
|
||||
Share(): Enumerable<any>;
|
||||
MemoizeAll(): Enumerable<any>;
|
||||
//Error Handling Methods
|
||||
Catch(handler: (error: Error) => void ): Enumerable<any>;
|
||||
Catch(handler: string): Enumerable<any>;
|
||||
Finally(finallyAction: () => void ): Enumerable<any>;
|
||||
Finally(finallyAction: string): Enumerable<any>;
|
||||
//For Debug Methods
|
||||
Trace(message?: string, selector?: ($: T) =>any): Enumerable<any>;
|
||||
Trace(message?: string, selector?: string): Enumerable<any>;
|
||||
}
|
||||
|
||||
interface OrderedEnumerable<T> extends Enumerable<T> {
|
||||
ThenBy(keySelector: ($: T) => any): OrderedEnumerable<T>;
|
||||
ThenBy(keySelector: string): OrderedEnumerable<T>;
|
||||
ThenByDescending(keySelector: ($: T) => any): OrderedEnumerable<T>;
|
||||
ThenByDescending(keySelector: string): OrderedEnumerable<T>;
|
||||
}
|
||||
|
||||
interface Grouping<TKey, T> extends Enumerable<T> {
|
||||
Key(): TKey;
|
||||
}
|
||||
|
||||
interface Lookup<TKey, TValue> {
|
||||
Count(): number;
|
||||
Get(key: TKey): Enumerable<TValue>;
|
||||
Contains(key: TKey): boolean;
|
||||
ToEnumerable(): Enumerable<Grouping<TKey, TValue>>;
|
||||
}
|
||||
|
||||
interface Dictionary<TKey, TValue> {
|
||||
Add(key: TKey, value: TValue): void;
|
||||
Get(key: TKey): TValue;
|
||||
Set(key: TKey, value: TValue): boolean;
|
||||
Contains(key: TKey): boolean;
|
||||
Clear(): void;
|
||||
Remove(key: TKey): void;
|
||||
Count(): number;
|
||||
ToEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
|
||||
}
|
||||
|
||||
interface KeyValuePair<TKey, TValue> {
|
||||
Key: TKey;
|
||||
Value: TValue;
|
||||
}
|
||||
}
|
||||
|
||||
declare var Enumerable: linq.EnumerableStatic;
|
||||
@@ -1,37 +0,0 @@
|
||||
/// <reference types="jasmine"/>
|
||||
|
||||
describe("Linq.js tests", function () {
|
||||
it("Projection and Filtering Methods", function () {
|
||||
expect(Enumerable.From([1,2,3,4]).ToString(",")).toBe("1,2,3,4");
|
||||
expect(Enumerable.Range(1, 4).Where((item: number) => item > 2).ToString(",")).toBe("3,4");
|
||||
expect(Enumerable.Range(1, 4).Where("(item) => item > 2").ToString(",")).toBe("3,4");
|
||||
expect(Enumerable.Range(1, 4).Where("$>2").ToString(",")).toBe("3,4");
|
||||
expect(Enumerable.Range(1, 4).Select((item: number,index:number) => item+index).ToString(",")).toBe("1,3,5,7");
|
||||
expect(Enumerable.Range(1, 4).Zip(Enumerable.Range(1, 10), (a: number,b:number) => a-b).ToString(",")).toBe("0,0,0,0");
|
||||
|
||||
});
|
||||
it("Join Methods", function () {
|
||||
expect(Enumerable.Range(1, 4).Join(Enumerable.From(["a", "aaa"]), (l) => l, (r: string) => r.length, (l, r) =>l + ":" + r).ToString(",")).toBe("1:a,3:aaa");
|
||||
});
|
||||
it("Set Methods", function () {
|
||||
expect(Enumerable.Range(2, 4, 2).All((item: number) => item % 2 == 0)).toBe(true);
|
||||
expect(Enumerable.Range(1, 4).Intersect(Enumerable.Range(3, 4)).ToString(",")).toBe("3,4");
|
||||
});
|
||||
it("Ordering Methods", function () {
|
||||
expect(Enumerable.From(
|
||||
[
|
||||
{ name: "marcin", age:15},
|
||||
{ name: "albert", age:51},
|
||||
{ name: "marcin", age:30},
|
||||
]).OrderBy((p) => p.name).ThenByDescending((p) => p.age).Select((p) => p.name+p.age).ToString(",")).toBe("albert51,marcin30,marcin15");
|
||||
});
|
||||
it("Grouping Methods", function () {
|
||||
expect(Enumerable.From(["a","aa","aaa","a","a","aaa"])
|
||||
.GroupBy((item:string) => item.length)
|
||||
.Select((g: linq.Grouping<number, string>) => { return { key: g.Key(), count: g.Count() }; })
|
||||
.OrderBy(g => g.key)
|
||||
.Select(g => g.key+":"+g.count)
|
||||
.ToString(",")).toBe("1:3,2:1,3:2");
|
||||
});
|
||||
});
|
||||
|
||||
276
linq/linq.3.0.4-Beta5.d.ts
vendored
276
linq/linq.3.0.4-Beta5.d.ts
vendored
@@ -1,276 +0,0 @@
|
||||
// Type definitions for linq.js v3.0.4-Beta5
|
||||
// Project: https://linqjs.codeplex.com/
|
||||
// Definitions by: neuecc <https://www.codeplex.com/site/users/view/neuecc>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
declare module linqjs {
|
||||
interface IEnumerator<T> {
|
||||
current(): T;
|
||||
moveNext(): boolean;
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
interface IEqualityComparer<T> {
|
||||
equals(x: T, y: T): boolean;
|
||||
getHashCode(obj: any): string;
|
||||
}
|
||||
|
||||
interface ITuple<T1, T2, T3, T4, T5, T6, T7, T8> {
|
||||
equals(other: ITuple<T1, T2, T3, T4, T5, T6, T7, T8>): boolean;
|
||||
getHashCode(): string;
|
||||
}
|
||||
|
||||
interface ITupleArray {
|
||||
equals(other: ITupleArray): boolean;
|
||||
getHashCode(): string;
|
||||
}
|
||||
|
||||
interface Enumerable {
|
||||
Utils: {
|
||||
createLambda(expression: any): (...params: any[]) => any;
|
||||
createEnumerable<T>(getEnumerator: () => IEnumerator<T>): IEnumerable<T>;
|
||||
createEnumerator<T>(initialize: () => void, tryGetNext: () => boolean, dispose: () => void): IEnumerator<T>;
|
||||
getDefaultEqualityComparer<T>(): IEqualityComparer<T>;
|
||||
createEqualityComparer<T>(equals: (x: T, y: T) => boolean, getHashCode: (obj: any) => string): IEqualityComparer<T>;
|
||||
createKeyedEqualityComparer<TKey, TValue>(keySelector: (element: TValue) => TKey): IEqualityComparer<TValue>;
|
||||
createDictionary<TKey, TValue>(compareSelector: (element: TValue) => TKey): IDictionary<TKey, TValue>;
|
||||
createDictionary<TKey, TValue>(equalityComparer: IEqualityComparer<TValue>): IDictionary<TKey, TValue>;
|
||||
createList<T>(): IList<T>;
|
||||
createTuple<T1, T2, T3, T4, T5, T6, T7, T8>(item1: T1, item2: T2, item3?: T3, item4?: T4, item5?: T5, item6?: T6, item7?: T7, item8?: T8): ITuple<T1, T2, T3, T4, T5, T6, T7, T8>;
|
||||
extendTo(type: any, forceAppend?: boolean): void;
|
||||
};
|
||||
choice<T>(...params: T[]): IEnumerable<T>;
|
||||
cycle<T>(...params: T[]): IEnumerable<T>;
|
||||
empty<T>(): IEnumerable<T>;
|
||||
// from<T>, obj as JScript's IEnumerable or WinMD IIterable<T> is IEnumerable<T> but it can't define.
|
||||
from(): IEnumerable<any>; // empty
|
||||
from<T>(obj: IEnumerable<T>): IEnumerable<T>;
|
||||
from(obj: number): IEnumerable<number>;
|
||||
from(obj: boolean): IEnumerable<boolean>;
|
||||
from(obj: string): IEnumerable<string>;
|
||||
from<T>(obj: T[]): IEnumerable<T>;
|
||||
from<T>(obj: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
from(obj: any): IEnumerable<{ key: string; value: any }>;
|
||||
make<T>(element: T): IEnumerable<T>;
|
||||
matches<T>(input: string, pattern: RegExp): IEnumerable<T>;
|
||||
matches<T>(input: string, pattern: string, flags?: string): IEnumerable<T>;
|
||||
range(start: number, count: number, step?: number): IEnumerable<number>;
|
||||
rangeDown(start: number, count: number, step?: number): IEnumerable<number>;
|
||||
rangeTo(start: number, to: number, step?: number): IEnumerable<number>;
|
||||
repeat<T>(element: T, count?: number): IEnumerable<T>;
|
||||
repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): IEnumerable<T>;
|
||||
generate<T>(func: () => T, count?: number): IEnumerable<T>;
|
||||
toInfinity(start?: number, step?: number): IEnumerable<number>;
|
||||
toNegativeInfinity(start?: number, step?: number): IEnumerable<number>;
|
||||
unfold<T>(seed: T, func: (value: T) => T): IEnumerable<T>;
|
||||
defer<T>(enumerableFactory: () => IEnumerable<T>): IEnumerable<T>;
|
||||
}
|
||||
|
||||
interface IEnumerable<T> {
|
||||
constructor(getEnumerator: () => IEnumerator<T>): IEnumerable<T>;
|
||||
getEnumerator(): IEnumerator<T>;
|
||||
|
||||
// Extension Methods
|
||||
traverseBreadthFirst(func: (element: T) => IEnumerable<T>): IEnumerable<T>;
|
||||
traverseBreadthFirst<TResult>(func: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
||||
traverseDepthFirst<TResult>(func: (element: T) => Enumerable): IEnumerable<T>;
|
||||
traverseDepthFirst<TResult>(func: (element: T) => Enumerable, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
|
||||
flatten(): IEnumerable<any>;
|
||||
pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;
|
||||
scan(func: (prev: T, current: T) => T): IEnumerable<T>;
|
||||
scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>;
|
||||
select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
|
||||
selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>;
|
||||
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
||||
selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>;
|
||||
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
||||
selectMany<TOther>(collectionSelector: (element: T, index: number) => { length: number; [x: number]: TOther; }): IEnumerable<TOther>;
|
||||
selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => { length: number; [x: number]: TCollection; }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
|
||||
where(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
||||
choose(selector: (element: T, index: number) => T): IEnumerable<T>;
|
||||
ofType<TResult>(type: any): IEnumerable<TResult>;
|
||||
zip<TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
|
||||
zip<TResult>(second: { length: number; [x: number]: T; }, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
|
||||
zip<TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
|
||||
zip<TResult>(...params: any[]): IEnumerable<TResult>; // last one is selector
|
||||
merge<TResult>(...params: IEnumerable<T>[]): IEnumerable<T>;
|
||||
merge<TResult>(...params: { length: number; [x: number]: T; }[]): IEnumerable<T>;
|
||||
merge<TResult>(...params: T[][]): IEnumerable<T>;
|
||||
join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
join<TInner, TKey, TResult>(inner: { length: number; [x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
groupJoin<TInner, TKey, TResult>(inner: { length: number; [x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
|
||||
all(predicate: (element: T) => boolean): boolean;
|
||||
any(predicate?: (element: T) => boolean): boolean;
|
||||
isEmpty(): boolean;
|
||||
concat(...sequences: IEnumerable<T>[]): IEnumerable<T>;
|
||||
concat(...sequences: { length: number; [x: number]: T; }[]): IEnumerable<T>;
|
||||
concat(...sequences: T[]): IEnumerable<T>;
|
||||
insert(index: number, second: IEnumerable<T>): IEnumerable<T>;
|
||||
insert(index: number, second: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
alternate(alternateValue: T): IEnumerable<T>;
|
||||
alternate(alternateSequence: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>;
|
||||
alternate(alternateSequence: T[]): IEnumerable<T>;
|
||||
contains(value: T): boolean;
|
||||
contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean;
|
||||
contains(value: T, equalityComparer?: IEqualityComparer<T>): boolean;
|
||||
defaultIfEmpty(defaultValue?: T): IEnumerable<T>;
|
||||
distinct(): IEnumerable<T>;
|
||||
distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
distinctUntilChanged(): IEnumerable<T>;
|
||||
distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
except(second: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
except<TCompare>(second: { length: number; [x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
except(second: IEnumerable<T>): IEnumerable<T>;
|
||||
except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
except(second: T[]): IEnumerable<T>;
|
||||
except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
intersect(second: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
intersect<TCompare>(second: { length: number; [x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
intersect(second: IEnumerable<T>): IEnumerable<T>;
|
||||
intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
intersect(second: T[]): IEnumerable<T>;
|
||||
intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
union(second: { length: number; [x: number]: T; }): IEnumerable<T>;
|
||||
union<TCompare>(second: { length: number; [x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
union(second: IEnumerable<T>): IEnumerable<T>;
|
||||
union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
union(second: T[]): IEnumerable<T>;
|
||||
union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
|
||||
sequenceEqual(second: { length: number; [x: number]: T; }): boolean;
|
||||
sequenceEqual<TCompare>(second: { length: number; [x: number]: T; }, compareSelector: (element: T) => TCompare): boolean;
|
||||
sequenceEqual(second: IEnumerable<T>): boolean;
|
||||
sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
|
||||
sequenceEqual(second: T[]): boolean;
|
||||
sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
|
||||
orderBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
||||
orderBy<TKey>(keySelector: (element: T) => TKey, comparison: (x: TKey, y: TKey) => number): IOrderedEnumerable<T>;
|
||||
orderByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
||||
orderByDescending<TKey>(keySelector: (element: T) => TKey, comparison: (x: TKey, y: TKey) => number): IOrderedEnumerable<T>;
|
||||
reverse(): IEnumerable<T>;
|
||||
shuffle(): IEnumerable<T>;
|
||||
weightedSample(weightSelector: (element: T) => number): IEnumerable<T>;
|
||||
// truly, return type is IEnumerable<IGrouping<TKey, T>> but Visual Studio + TypeScript Compiler can't compile.
|
||||
groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, any>>;
|
||||
groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
||||
groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
||||
groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;
|
||||
// :IEnumerable<IGrouping<TKey, T>>
|
||||
partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, any>>;
|
||||
// :IEnumerable<IGrouping<TKey, TElement>>
|
||||
partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>;
|
||||
partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
|
||||
partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>;
|
||||
buffer(count: number): IEnumerable<T>;
|
||||
aggregate(func: (prev: T, current: T) => T): T;
|
||||
aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate;
|
||||
aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult;
|
||||
average(selector?: (element: T) => number): number;
|
||||
count(predicate?: (element: T, index: number) => boolean): number;
|
||||
max(selector?: (element: T) => number): number;
|
||||
min(selector?: (element: T) => number): number;
|
||||
maxBy<TKey>(keySelector: (element: T) => TKey): T;
|
||||
minBy<TKey>(keySelector: (element: T) => TKey): T;
|
||||
sum(selector?: (element: T) => number): number;
|
||||
elementAt(index: number): T;
|
||||
elementAtOrDefault(index: number, defaultValue?: T): T;
|
||||
first(predicate?: (element: T, index: number) => boolean): T;
|
||||
firstOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T;
|
||||
last(predicate?: (element: T, index: number) => boolean): T;
|
||||
lastOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T;
|
||||
single(predicate?: (element: T, index: number) => boolean): T;
|
||||
singleOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T;
|
||||
skip(count: number): IEnumerable<T>;
|
||||
skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
||||
take(count: number): IEnumerable<T>;
|
||||
takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
|
||||
takeExceptLast(count?: number): IEnumerable<T>;
|
||||
takeFromLast(count: number): IEnumerable<T>;
|
||||
indexOf(item: T): number;
|
||||
indexOf(predicate: (element: T, index: number) => boolean): number;
|
||||
lastIndexOf(item: T): number;
|
||||
lastIndexOf(predicate: (element: T, index: number) => boolean): number;
|
||||
asEnumerable(): IEnumerable<T>;
|
||||
cast<TResult>(): IEnumerable<TResult>;
|
||||
toArray(): T[];
|
||||
toList(): IList<T>;
|
||||
// truly, return type is ILookup<TKey, T> but Visual Studio + TypeScript Compiler can't compile.
|
||||
toLookup<TKey>(keySelector: (element: T) => TKey): ILookup<TKey, any>;
|
||||
toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): ILookup<TKey, TElement>;
|
||||
toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): ILookup<TKey, TElement>;
|
||||
toObject(keySelector: (element: T) => any, elementSelector?: (element: T) => any): Object;
|
||||
// :IDictionary<TKey, T>
|
||||
toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>;
|
||||
toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>;
|
||||
toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>;
|
||||
toJSONString(replacer: (key: string, value: any) => any): string;
|
||||
toJSONString(replacer: any[]): string;
|
||||
toJSONString(replacer: (key: string, value: any) => any, space: any): string;
|
||||
toJSONString(replacer: any[], space: any): string;
|
||||
toJoinedString(separator?: string): string;
|
||||
toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string;
|
||||
doAction(action: (element: T, index: number) => void): IEnumerable<T>;
|
||||
doAction(action: (element: T, index: number) => boolean): IEnumerable<T>;
|
||||
forEach(action: (element: T, index: number) => void): void;
|
||||
forEach(action: (element: T, index: number) => boolean): void;
|
||||
write(separator?: string): void;
|
||||
write<TResult>(separator: string, selector: (element: T) => TResult): void;
|
||||
writeLine(): void;
|
||||
writeLine<TResult>(selector: (element: T) => TResult): void;
|
||||
force(): void;
|
||||
letBind<TResult>(func: (source: IEnumerable<T>) => { length: number; [x: number]: TResult; }): IEnumerable<TResult>;
|
||||
letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>;
|
||||
letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>;
|
||||
share(): IDisposableEnumerable<T>;
|
||||
memoize(): IDisposableEnumerable<T>;
|
||||
catchError(handler: (exception: any) => void): IEnumerable<T>;
|
||||
finallyAction(finallyAction: () => void): IEnumerable<T>;
|
||||
log(): IEnumerable<T>;
|
||||
log<TValue>(selector: (element: T) => TValue): IEnumerable<T>;
|
||||
trace(message?: string): IEnumerable<T>;
|
||||
trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>;
|
||||
}
|
||||
|
||||
interface IOrderedEnumerable<T> extends IEnumerable<T> {
|
||||
createOrderedEnumerable<TKey>(keySelector: (element: T) => TKey, comparison: (x: TKey, y: TKey) => number, descending: boolean): IOrderedEnumerable<T>;
|
||||
thenBy<TKey>(keySelector: (element: T) => TKey) : IOrderedEnumerable<T>;
|
||||
thenBy<TKey>(keySelector: (element: T) => TKey, comparison: (x: TKey, y: TKey) => number) : IOrderedEnumerable<T>;
|
||||
thenByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>;
|
||||
thenByDescending<TKey>(keySelector: (element: T) => TKey, comparison: (x: TKey, y: TKey) => number): IOrderedEnumerable<T>;
|
||||
}
|
||||
|
||||
interface IDisposableEnumerable<T> extends IEnumerable<T> {
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
interface IDictionary<TKey, TValue> {
|
||||
add(key: TKey, value: TValue): void;
|
||||
get(key: TKey): TValue;
|
||||
set(key: TKey, value: TValue): boolean;
|
||||
contains(key: TKey): boolean;
|
||||
clear(): void;
|
||||
remove(key: TKey): void;
|
||||
count(): number;
|
||||
toEnumerable(): IEnumerable<{ key: TKey; value: TValue }>;
|
||||
}
|
||||
|
||||
interface ILookup<TKey, TElement> {
|
||||
count(): number;
|
||||
get(key: TKey): IEnumerable<TElement>;
|
||||
contains(key: TKey): boolean;
|
||||
toEnumerable(): IEnumerable<IGrouping<TKey, TElement>>;
|
||||
}
|
||||
|
||||
interface IGrouping<TKey, TElement> extends IEnumerable<TElement> {
|
||||
key(): TKey;
|
||||
}
|
||||
|
||||
interface IList<T> extends Array<T> {
|
||||
}
|
||||
}
|
||||
|
||||
// export definition
|
||||
declare var Enumerable: linqjs.Enumerable;
|
||||
18
linq/linq.jquery.3.0.4-Beta5.d.ts
vendored
18
linq/linq.jquery.3.0.4-Beta5.d.ts
vendored
@@ -1,18 +0,0 @@
|
||||
// Type definitions for linq.jquery (from linq.js)
|
||||
// Project: https://linqjs.codeplex.com/
|
||||
// Definitions by: neuecc <https://www.codeplex.com/site/users/view/neuecc>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/// <reference types="jquery"/>
|
||||
/// <reference path="index.d.ts"/>
|
||||
|
||||
declare module linqjs {
|
||||
interface IEnumerable<T> {
|
||||
tojQuery(): JQuery;
|
||||
tojQueryAsArray(): JQuery;
|
||||
}
|
||||
}
|
||||
|
||||
interface JQuery {
|
||||
toEnumerable(): linqjs.IEnumerable<JQuery>;
|
||||
}
|
||||
22
linq/linq.jquery.d.ts
vendored
22
linq/linq.jquery.d.ts
vendored
@@ -1,22 +0,0 @@
|
||||
// Type definitions for linq.jquery (from linq.js)
|
||||
// Project: http://linqjs.codeplex.com/
|
||||
// Definitions by: neuecc <http://www.codeplex.com/site/users/view/neuecc>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/// <reference types="jquery"/>
|
||||
/// <reference path="linq.d.ts"/>
|
||||
|
||||
declare namespace linqjs {
|
||||
interface Enumerable {
|
||||
tojQuery(): JQuery;
|
||||
tojQueryAsArray(): JQuery;
|
||||
}
|
||||
}
|
||||
|
||||
interface JQuery {
|
||||
toEnumerable(): linqjs.Enumerable;
|
||||
}
|
||||
|
||||
interface JQueryStatic {
|
||||
Enumerable: linq.EnumerableStatic;
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
{
|
||||
"files": [
|
||||
"index.d.ts",
|
||||
"linq-tests.ts"
|
||||
],
|
||||
"compilerOptions": {
|
||||
"module": "commonjs",
|
||||
"target": "es6",
|
||||
"noImplicitAny": false,
|
||||
"strictNullChecks": false,
|
||||
"baseUrl": "../",
|
||||
"typeRoots": [
|
||||
"../"
|
||||
],
|
||||
"types": [],
|
||||
"noEmit": true,
|
||||
"forceConsistentCasingInFileNames": true
|
||||
}
|
||||
}
|
||||
@@ -22,6 +22,12 @@
|
||||
"typingsPackageName": "spotify-web-api-js",
|
||||
"sourceRepoURL": "https://github.com/JMPerez/spotify-web-api-js",
|
||||
"asOfVersion": "0.21.0"
|
||||
},
|
||||
{
|
||||
"libraryName": "Linq.JS",
|
||||
"typingsPackageName": "linq",
|
||||
"sourceRepoURL": "https://linqjs.codeplex.com/",
|
||||
"asOfVersion": "2.2.33"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user