Skip to content
This repository was archived by the owner on Dec 25, 2018. It is now read-only.

Commit 11bfb4b

Browse files
author
electricessence
committed
Updated gulp task to output declaration files for all modules. This increases typing compatibility when consuming specific module types.
1 parent e2aca43 commit 11bfb4b

File tree

598 files changed

+13361
-90
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

598 files changed

+13361
-90
lines changed

‎bower.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
{
22
"name": "typescript-dotnet",
3-
"version": "2.11.7",
3+
"version": "2.12.0",
44
"ignore": [
55
".bowercc",
66
".gitignore",

‎dist/amd/System.Linq/Linq.d.ts‎

Lines changed: 196 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,196 @@
1+
/// <reference path="../../../source/System/Primitive.d.ts" />
2+
/// <reference path="../../../source/System/FunctionTypes.d.ts" />
3+
/// <reference path="../../../source/System/Collections/Array/IArray.d.ts" />
4+
/// <reference path="../../../source/System/Collections/Enumeration/IEnumerator.d.ts" />
5+
/// <reference path="../../../source/System/Collections/Enumeration/IEnumerable.d.ts" />
6+
/// <reference path="../../../source/System/Collections/Dictionaries/IDictionary.d.ts" />
7+
/// <reference path="../../../source/System/IComparer.d.ts" />
8+
/// <reference path="../../../source/System/Collections/Sorting/Order.d.ts" />
9+
/// <reference path="../../../source/System/Collections/IEnumerableOrArray.d.ts" />
10+
/*!
11+
* @author electricessence / https://github.com/electricessence/
12+
* Original: http://linqjs.codeplex.com/
13+
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
14+
*/
15+
import Dictionary from "../System/Collections/Dictionaries/Dictionary";
16+
import DisposableBase from "../System/Disposable/DisposableBase";
17+
export declare const enum EnumerableAction {
18+
Break = 0,
19+
Return = 1,
20+
Skip = 2,
21+
}
22+
export declare class InfiniteEnumerable<T> extends DisposableBase implements IEnumerable<T> {
23+
protected _enumeratorFactory: () => IEnumerator<T>;
24+
constructor(_enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void);
25+
protected _isEndless: boolean;
26+
isEndless: boolean;
27+
getEnumerator(): IEnumerator<T>;
28+
protected _onDispose(): void;
29+
asEnumerable(): InfiniteEnumerable<T>;
30+
doAction(action: Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>, initializer?: () => void, isEndless?: boolean): InfiniteEnumerable<T>;
31+
force(): void;
32+
skip(count: number): InfiniteEnumerable<T>;
33+
take(count: number): FiniteEnumerable<T>;
34+
elementAt(index: number): T;
35+
elementAtOrDefault(index: number, defaultValue?: T): T;
36+
first(): T;
37+
firstOrDefault(defaultValue?: T): T;
38+
single(): T;
39+
singleOrDefault(defaultValue?: T): T;
40+
any(): boolean;
41+
isEmpty(): boolean;
42+
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerableOrArray<T>): Enumerable<T>;
43+
traverseBreadthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>): Enumerable<TNode>;
44+
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T>, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable<TResult>;
45+
traverseBreadthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable<TResult>;
46+
traverseDepthFirst(childrenSelector: (element: T) => IEnumerableOrArray<T>): Enumerable<T>;
47+
traverseDepthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>): Enumerable<TNode>;
48+
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T>, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable<TResult>;
49+
traverseDepthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable<TResult>;
50+
flatten(): Enumerable<any>;
51+
pairwise<TSelect>(selector: (prev: T, current: T) => TSelect): Enumerable<TSelect>;
52+
scan(func: (a: T, b: T) => T, seed?: T): Enumerable<T>;
53+
select<TResult>(selector: Selector<T, TResult>): InfiniteEnumerable<TResult>;
54+
protected _selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector?: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
55+
selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult>>): InfiniteEnumerable<TResult>;
56+
selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector: (collection: T, element: TElement) => TResult): InfiniteEnumerable<TResult>;
57+
protected _choose<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
58+
choose(): InfiniteEnumerable<T>;
59+
choose<TResult>(selector?: Selector<T, TResult>): InfiniteEnumerable<TResult>;
60+
where(predicate: Predicate<T>): InfiniteEnumerable<T>;
61+
ofType<TType>(type: {
62+
new (...params: any[]): TType;
63+
}): InfiniteEnumerable<TType>;
64+
except<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): InfiniteEnumerable<T>;
65+
distinct(compareSelector?: (value: T) => T): InfiniteEnumerable<T>;
66+
distinctUntilChanged<TCompare>(compareSelector?: Selector<T, TCompare>): InfiniteEnumerable<T>;
67+
defaultIfEmpty(defaultValue?: T): Enumerable<T>;
68+
zip<TSecond, TResult>(second: IEnumerableOrArray<TSecond>, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable<TResult>;
69+
zipMultiple<TSecond, TResult>(second: IArray<IEnumerableOrArray<TSecond>>, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable<TResult>;
70+
join<TInner, TKey, TResult, TCompare>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: Selector<TKey, TCompare>): Enumerable<TResult>;
71+
groupJoin<TInner, TKey, TResult, TCompare>(inner: IEnumerableOrArray<TInner>, outerKeySelector: Selector<T, TKey>, innerKeySelector: Selector<TInner, TKey>, resultSelector: (outer: T, inner: TInner[]) => TResult, compareSelector?: Selector<TKey, TCompare>): Enumerable<TResult>;
72+
merge(enumerables: IArray<IEnumerableOrArray<T>>): InfiniteEnumerable<T>;
73+
concat(...enumerables: Array<IEnumerableOrArray<T>>): InfiniteEnumerable<T>;
74+
union<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
75+
insertAt(index: number, other: IEnumerableOrArray<T>): Enumerable<T>;
76+
alternateMultiple(sequence: IEnumerableOrArray<T>): Enumerable<T>;
77+
alternateSingle(value: T): Enumerable<T>;
78+
alternate(...sequence: T[]): Enumerable<T>;
79+
catchError(handler: (e: any) => void): InfiniteEnumerable<T>;
80+
finallyAction(action: () => void): InfiniteEnumerable<T>;
81+
buffer(size: number): InfiniteEnumerable<T[]>;
82+
share(): InfiniteEnumerable<T>;
83+
}
84+
export declare class Enumerable<T> extends InfiniteEnumerable<T> {
85+
constructor(enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void, isEndless?: boolean);
86+
static from<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
87+
static fromAny<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
88+
static fromAny(source: any): Enumerable<any>;
89+
static fromOrEmpty<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
90+
static toArray<T>(source: IEnumerableOrArray<T>): T[];
91+
static choice<T>(values: IArray<T>): InfiniteEnumerable<T>;
92+
static chooseFrom<T>(...args: T[]): InfiniteEnumerable<T>;
93+
static cycle<T>(values: IArray<T>): InfiniteEnumerable<T>;
94+
static cycleThrough<T>(...args: T[]): InfiniteEnumerable<T>;
95+
static empty<T>(): FiniteEnumerable<T>;
96+
static repeat<T>(element: T): InfiniteEnumerable<T>;
97+
static repeat<T>(element: T, count: number): FiniteEnumerable<T>;
98+
static repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): InfiniteEnumerable<T>;
99+
static make<T>(element: T): FiniteEnumerable<T>;
100+
static range(start: number, count: number, step?: number): FiniteEnumerable<number>;
101+
static rangeDown(start: number, count: number, step?: number): FiniteEnumerable<number>;
102+
static toInfinity(start?: number, step?: number): InfiniteEnumerable<number>;
103+
static toNegativeInfinity(start?: number, step?: number): InfiniteEnumerable<number>;
104+
static rangeTo(start: number, to: number, step?: number): FiniteEnumerable<number>;
105+
static matches(input: string, pattern: any, flags?: string): FiniteEnumerable<RegExpExecArray>;
106+
static generate<T>(factory: (index?: number) => T): InfiniteEnumerable<T>;
107+
static generate<T>(factory: (index?: number) => T, count: number): FiniteEnumerable<T>;
108+
static unfold<T>(seed: T, valueFactory: Selector<T, T>, skipSeed?: Boolean): InfiniteEnumerable<T>;
109+
static forEach<T>(enumerable: IEnumerableOrArray<T>, action: (element: T, index?: number) => any): void;
110+
static map<T, TResult>(enumerable: IEnumerableOrArray<T>, selector: Selector<T, TResult>): TResult[];
111+
static max(values: FiniteEnumerable<number>): number;
112+
static min(values: FiniteEnumerable<number>): number;
113+
static weave<T>(enumerables: IEnumerableOrArray<IEnumerableOrArray<T>>): Enumerable<T>;
114+
doAction(action: Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>, initializer?: () => void, isEndless?: boolean): Enumerable<T>;
115+
skip(count: number): Enumerable<T>;
116+
skipWhile(predicate: Predicate<T>): Enumerable<T>;
117+
takeWhile(predicate: Predicate<T>): Enumerable<T>;
118+
takeUntil(predicate: Predicate<T>, includeUntilValue?: boolean): Enumerable<T>;
119+
forEach(action: Predicate<T> | Action<T>): void;
120+
toArray(predicate?: Predicate<T>): T[];
121+
copyTo(target: T[], index?: number): T[];
122+
toLookup<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
123+
toMap<TResult>(keySelector: Selector<T, string>, elementSelector: Selector<T, TResult>): IMap<TResult>;
124+
toDictionary<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): Dictionary<TKey, TValue>;
125+
toJoinedString(separator?: string, selector?: Selector<T, string>): string;
126+
takeExceptLast(count?: number): Enumerable<T>;
127+
skipToLast(count: number): Enumerable<T>;
128+
where(predicate: Predicate<T>): Enumerable<T>;
129+
select<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
130+
selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult>>): Enumerable<TResult>;
131+
selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
132+
choose(): Enumerable<T>;
133+
choose<TResult>(selector?: Selector<T, TResult>): Enumerable<TResult>;
134+
reverse(): Enumerable<T>;
135+
shuffle(): Enumerable<T>;
136+
count(predicate?: Predicate<T>): number;
137+
all(predicate: Predicate<T>): boolean;
138+
every(predicate: Predicate<T>): boolean;
139+
any(predicate?: Predicate<T>): boolean;
140+
some(predicate: Predicate<T>): boolean;
141+
contains<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): boolean;
142+
indexOf<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): number;
143+
lastIndexOf<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): number;
144+
merge(enumerables: IArray<IEnumerableOrArray<T>>): Enumerable<T>;
145+
concat(...enumerables: Array<IEnumerableOrArray<T>>): Enumerable<T>;
146+
intersect<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
147+
sequenceEqual(second: IEnumerableOrArray<T>, equalityComparer?: EqualityComparison<T>): boolean;
148+
ofType<TType>(type: {
149+
new (...params: any[]): TType;
150+
}): Enumerable<TType>;
151+
except<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
152+
distinct(compareSelector?: (value: T) => T): Enumerable<T>;
153+
distinctUntilChanged<TCompare>(compareSelector?: Selector<T, TCompare>): Enumerable<T>;
154+
orderBy<TKey extends Comparable>(keySelector?: Selector<T, TKey>): IOrderedEnumerable<T>;
155+
orderUsing(comparison: Comparison<T>): IOrderedEnumerable<T>;
156+
orderUsingReversed(comparison: Comparison<T>): IOrderedEnumerable<T>;
157+
orderByDescending<TKey extends Comparable>(keySelector?: Selector<T, TKey>): IOrderedEnumerable<T>;
158+
buffer(size: number): Enumerable<T[]>;
159+
groupBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
160+
groupBy<TKey, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
161+
partitionBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
162+
partitionBy<TKey, TElement, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TElement>, resultSelector?: (key: TKey, element: TElement[]) => IGrouping<TKey, TElement>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, TElement>>;
163+
aggregate(func: (a: T, b: T) => T, seed?: T): T;
164+
average(selector?: Selector<T, number>): number;
165+
max(): T;
166+
min(): T;
167+
maxBy<TCompare>(keySelector?: Selector<T, TCompare>): T;
168+
minBy<TCompare>(keySelector?: Selector<T, TCompare>): T;
169+
sum(selector?: Selector<T, number>): number;
170+
product(selector?: Selector<T, number>): number;
171+
quotient(selector?: Selector<T, number>): number;
172+
last(): T;
173+
lastOrDefault(defaultValue?: T): T;
174+
share(): Enumerable<T>;
175+
catchError(handler: (e: any) => void): Enumerable<T>;
176+
finallyAction(action: () => void): Enumerable<T>;
177+
memoize(): Enumerable<T>;
178+
}
179+
export declare class FiniteEnumerable<T> extends Enumerable<T> {
180+
constructor(enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void);
181+
}
182+
export interface IGrouping<TKey, TElement> extends Enumerable<TElement> {
183+
key: TKey;
184+
}
185+
export interface ILookup<TKey, TElement> extends IEnumerable<IGrouping<TKey, TElement>> {
186+
count: number;
187+
get(key: TKey): TElement[];
188+
contains(key: TKey): boolean;
189+
}
190+
export interface IOrderedEnumerable<T> extends FiniteEnumerable<T> {
191+
thenBy(keySelector: (value: T) => any): IOrderedEnumerable<T>;
192+
thenByDescending(keySelector: (value: T) => any): IOrderedEnumerable<T>;
193+
thenUsing(comparison: Comparison<T>): IOrderedEnumerable<T>;
194+
thenUsingReversed(comparison: Comparison<T>): IOrderedEnumerable<T>;
195+
}
196+
export default Enumerable;

‎dist/amd/System/Char.d.ts‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
/*!
2+
* @author electricessence / https://github.com/electricessence/
3+
* From Netjs mscorlib.ts
4+
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
5+
*/
6+
export declare function isWhiteSpace(ch: number): boolean;
7+
export declare function isLetter(ch: number): boolean;
8+
export declare function isLetterOrDigit(ch: number): boolean;
9+
export declare function isDigit(ch: number): boolean;
10+
export declare function isDigit(str: string, index: number): boolean;

‎dist/amd/System/Collections/Array/Compare.d.ts‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
/// <reference path="../../../../../source/System/Collections/Array/IArray.d.ts" />
2+
/// <reference path="../../../../../source/System/FunctionTypes.d.ts" />
3+
/// <reference path="../../../../../source/System/Primitive.d.ts" />
4+
/// <reference path="../../../../../source/System/IComparable.d.ts" />
5+
/*!
6+
* @author electricessence / https://github.com/electricessence/
7+
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
8+
*/
9+
export declare function areAllEqual(arrays: any[][], strict?: boolean, equalityComparer?: EqualityComparison<any>): boolean;
10+
export declare function areEqual<T>(a: IArray<T>, b: IArray<T>, strict?: boolean, equalityComparer?: EqualityComparison<T>): boolean;
11+
export declare function areEquivalent<T extends Primitive>(a: IArray<T>, b: IArray<T>): boolean;
12+
export declare function areEquivalent<T>(a: IArray<IComparable<T>>, b: IArray<IComparable<T>>): boolean;
13+
export declare function areEquivalent<T>(a: IArray<T>, b: IArray<T>, comparer: Comparison<T>): boolean;

‎dist/amd/System/Collections/Array/Dispatch.d.ts‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
/// <reference path="../../../../../source/System/Collections/Array/IArray.d.ts" />
2+
/// <reference path="../../../../../source/System/FunctionTypes.d.ts" />
3+
/*!
4+
* @author electricessence / https://github.com/electricessence/
5+
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
6+
*/
7+
export interface DispatchErrorHandler {
8+
(ex?: any, i?: number): void;
9+
}
10+
export declare function unsafe<T>(listeners: IArray<(payload: T) => any>, payload: T, trap?: boolean | DispatchErrorHandler): void;
11+
export declare function mapped<T, TResult>(listeners: IArray<(payload: T) => TResult>, payload: T, trap?: boolean | DispatchErrorHandler): TResult[];
12+
export declare function dispatch<T>(listeners: IArray<(payload: T) => any>, payload: T, trap?: boolean | DispatchErrorHandler): void;
13+
export default dispatch;

‎dist/amd/System/Collections/Array/Dispatch.js‎

Lines changed: 6 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

0 commit comments

Comments
 (0)