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

Commit

Permalink
Updated gulp task to output declaration files for all modules. This i…
Browse files Browse the repository at this point in the history 
…ncreases typing compatibility when consuming specific module types.
  • Loading branch information
electricessence committed May 17, 2016
1 parent e2aca43 commit 11bfb4b
Show file tree
Hide file tree
Showing 598 changed files with 13,361 additions and 90 deletions.
2 changes: 1 addition & 1 deletion bower.json
View file
@@ -1,6 +1,6 @@
{
"name": "typescript-dotnet",
"version": "2.11.7",
"version": "2.12.0",
"ignore": [
".bowercc",
".gitignore",
Expand Down
196 changes: 196 additions & 0 deletions dist/amd/System.Linq/Linq.d.ts
View file
@@ -0,0 +1,196 @@
/// <reference path="../../../source/System/Primitive.d.ts" />
/// <reference path="../../../source/System/FunctionTypes.d.ts" />
/// <reference path="../../../source/System/Collections/Array/IArray.d.ts" />
/// <reference path="../../../source/System/Collections/Enumeration/IEnumerator.d.ts" />
/// <reference path="../../../source/System/Collections/Enumeration/IEnumerable.d.ts" />
/// <reference path="../../../source/System/Collections/Dictionaries/IDictionary.d.ts" />
/// <reference path="../../../source/System/IComparer.d.ts" />
/// <reference path="../../../source/System/Collections/Sorting/Order.d.ts" />
/// <reference path="../../../source/System/Collections/IEnumerableOrArray.d.ts" />
/*!
* @author electricessence / https://github.com/electricessence/
* Original: http://linqjs.codeplex.com/
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
*/
import Dictionary from "../System/Collections/Dictionaries/Dictionary";
import DisposableBase from "../System/Disposable/DisposableBase";
export declare const enum EnumerableAction {
Break = 0,
Return = 1,
Skip = 2,
}
export declare class InfiniteEnumerable<T> extends DisposableBase implements IEnumerable<T> {
protected _enumeratorFactory: () => IEnumerator<T>;
constructor(_enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void);
protected _isEndless: boolean;
isEndless: boolean;
getEnumerator(): IEnumerator<T>;
protected _onDispose(): void;
asEnumerable(): InfiniteEnumerable<T>;
doAction(action: Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>, initializer?: () => void, isEndless?: boolean): InfiniteEnumerable<T>;
force(): void;
skip(count: number): InfiniteEnumerable<T>;
take(count: number): FiniteEnumerable<T>;
elementAt(index: number): T;
elementAtOrDefault(index: number, defaultValue?: T): T;
first(): T;
firstOrDefault(defaultValue?: T): T;
single(): T;
singleOrDefault(defaultValue?: T): T;
any(): boolean;
isEmpty(): boolean;
traverseBreadthFirst(childrenSelector: (element: T) => IEnumerableOrArray<T>): Enumerable<T>;
traverseBreadthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>): Enumerable<TNode>;
traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T>, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable<TResult>;
traverseBreadthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable<TResult>;
traverseDepthFirst(childrenSelector: (element: T) => IEnumerableOrArray<T>): Enumerable<T>;
traverseDepthFirst<TNode>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>): Enumerable<TNode>;
traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerableOrArray<T>, resultSelector?: (element: T, nestLevel?: number) => TResult): Enumerable<TResult>;
traverseDepthFirst<TNode, TResult>(childrenSelector: (element: T | TNode) => IEnumerableOrArray<TNode>, resultSelector?: (element: TNode, nestLevel?: number) => TResult): Enumerable<TResult>;
flatten(): Enumerable<any>;
pairwise<TSelect>(selector: (prev: T, current: T) => TSelect): Enumerable<TSelect>;
scan(func: (a: T, b: T) => T, seed?: T): Enumerable<T>;
select<TResult>(selector: Selector<T, TResult>): InfiniteEnumerable<TResult>;
protected _selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector?: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult>>): InfiniteEnumerable<TResult>;
selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector: (collection: T, element: TElement) => TResult): InfiniteEnumerable<TResult>;
protected _choose<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
choose(): InfiniteEnumerable<T>;
choose<TResult>(selector?: Selector<T, TResult>): InfiniteEnumerable<TResult>;
where(predicate: Predicate<T>): InfiniteEnumerable<T>;
ofType<TType>(type: {
new (...params: any[]): TType;
}): InfiniteEnumerable<TType>;
except<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): InfiniteEnumerable<T>;
distinct(compareSelector?: (value: T) => T): InfiniteEnumerable<T>;
distinctUntilChanged<TCompare>(compareSelector?: Selector<T, TCompare>): InfiniteEnumerable<T>;
defaultIfEmpty(defaultValue?: T): Enumerable<T>;
zip<TSecond, TResult>(second: IEnumerableOrArray<TSecond>, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable<TResult>;
zipMultiple<TSecond, TResult>(second: IArray<IEnumerableOrArray<TSecond>>, resultSelector: (first: T, second: TSecond, index?: number) => TResult): Enumerable<TResult>;
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>;
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>;
merge(enumerables: IArray<IEnumerableOrArray<T>>): InfiniteEnumerable<T>;
concat(...enumerables: Array<IEnumerableOrArray<T>>): InfiniteEnumerable<T>;
union<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
insertAt(index: number, other: IEnumerableOrArray<T>): Enumerable<T>;
alternateMultiple(sequence: IEnumerableOrArray<T>): Enumerable<T>;
alternateSingle(value: T): Enumerable<T>;
alternate(...sequence: T[]): Enumerable<T>;
catchError(handler: (e: any) => void): InfiniteEnumerable<T>;
finallyAction(action: () => void): InfiniteEnumerable<T>;
buffer(size: number): InfiniteEnumerable<T[]>;
share(): InfiniteEnumerable<T>;
}
export declare class Enumerable<T> extends InfiniteEnumerable<T> {
constructor(enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void, isEndless?: boolean);
static from<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
static fromAny<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
static fromAny(source: any): Enumerable<any>;
static fromOrEmpty<T>(source: IEnumerableOrArray<T>): Enumerable<T>;
static toArray<T>(source: IEnumerableOrArray<T>): T[];
static choice<T>(values: IArray<T>): InfiniteEnumerable<T>;
static chooseFrom<T>(...args: T[]): InfiniteEnumerable<T>;
static cycle<T>(values: IArray<T>): InfiniteEnumerable<T>;
static cycleThrough<T>(...args: T[]): InfiniteEnumerable<T>;
static empty<T>(): FiniteEnumerable<T>;
static repeat<T>(element: T): InfiniteEnumerable<T>;
static repeat<T>(element: T, count: number): FiniteEnumerable<T>;
static repeatWithFinalize<T>(initializer: () => T, finalizer: (element: T) => void): InfiniteEnumerable<T>;
static make<T>(element: T): FiniteEnumerable<T>;
static range(start: number, count: number, step?: number): FiniteEnumerable<number>;
static rangeDown(start: number, count: number, step?: number): FiniteEnumerable<number>;
static toInfinity(start?: number, step?: number): InfiniteEnumerable<number>;
static toNegativeInfinity(start?: number, step?: number): InfiniteEnumerable<number>;
static rangeTo(start: number, to: number, step?: number): FiniteEnumerable<number>;
static matches(input: string, pattern: any, flags?: string): FiniteEnumerable<RegExpExecArray>;
static generate<T>(factory: (index?: number) => T): InfiniteEnumerable<T>;
static generate<T>(factory: (index?: number) => T, count: number): FiniteEnumerable<T>;
static unfold<T>(seed: T, valueFactory: Selector<T, T>, skipSeed?: Boolean): InfiniteEnumerable<T>;
static forEach<T>(enumerable: IEnumerableOrArray<T>, action: (element: T, index?: number) => any): void;
static map<T, TResult>(enumerable: IEnumerableOrArray<T>, selector: Selector<T, TResult>): TResult[];
static max(values: FiniteEnumerable<number>): number;
static min(values: FiniteEnumerable<number>): number;
static weave<T>(enumerables: IEnumerableOrArray<IEnumerableOrArray<T>>): Enumerable<T>;
doAction(action: Action<T> | Predicate<T> | Selector<T, number> | Selector<T, EnumerableAction>, initializer?: () => void, isEndless?: boolean): Enumerable<T>;
skip(count: number): Enumerable<T>;
skipWhile(predicate: Predicate<T>): Enumerable<T>;
takeWhile(predicate: Predicate<T>): Enumerable<T>;
takeUntil(predicate: Predicate<T>, includeUntilValue?: boolean): Enumerable<T>;
forEach(action: Predicate<T> | Action<T>): void;
toArray(predicate?: Predicate<T>): T[];
copyTo(target: T[], index?: number): T[];
toLookup<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): ILookup<TKey, TValue>;
toMap<TResult>(keySelector: Selector<T, string>, elementSelector: Selector<T, TResult>): IMap<TResult>;
toDictionary<TKey, TValue, TCompare>(keySelector: Selector<T, TKey>, elementSelector: Selector<T, TValue>, compareSelector?: Selector<TKey, TCompare>): Dictionary<TKey, TValue>;
toJoinedString(separator?: string, selector?: Selector<T, string>): string;
takeExceptLast(count?: number): Enumerable<T>;
skipToLast(count: number): Enumerable<T>;
where(predicate: Predicate<T>): Enumerable<T>;
select<TResult>(selector: Selector<T, TResult>): Enumerable<TResult>;
selectMany<TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TResult>>): Enumerable<TResult>;
selectMany<TElement, TResult>(collectionSelector: Selector<T, IEnumerableOrArray<TElement>>, resultSelector: (collection: T, element: TElement) => TResult): Enumerable<TResult>;
choose(): Enumerable<T>;
choose<TResult>(selector?: Selector<T, TResult>): Enumerable<TResult>;
reverse(): Enumerable<T>;
shuffle(): Enumerable<T>;
count(predicate?: Predicate<T>): number;
all(predicate: Predicate<T>): boolean;
every(predicate: Predicate<T>): boolean;
any(predicate?: Predicate<T>): boolean;
some(predicate: Predicate<T>): boolean;
contains<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): boolean;
indexOf<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): number;
lastIndexOf<TCompare>(value: T, compareSelector?: Selector<T, TCompare>): number;
merge(enumerables: IArray<IEnumerableOrArray<T>>): Enumerable<T>;
concat(...enumerables: Array<IEnumerableOrArray<T>>): Enumerable<T>;
intersect<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
sequenceEqual(second: IEnumerableOrArray<T>, equalityComparer?: EqualityComparison<T>): boolean;
ofType<TType>(type: {
new (...params: any[]): TType;
}): Enumerable<TType>;
except<TCompare>(second: IEnumerableOrArray<T>, compareSelector?: Selector<T, TCompare>): Enumerable<T>;
distinct(compareSelector?: (value: T) => T): Enumerable<T>;
distinctUntilChanged<TCompare>(compareSelector?: Selector<T, TCompare>): Enumerable<T>;
orderBy<TKey extends Comparable>(keySelector?: Selector<T, TKey>): IOrderedEnumerable<T>;
orderUsing(comparison: Comparison<T>): IOrderedEnumerable<T>;
orderUsingReversed(comparison: Comparison<T>): IOrderedEnumerable<T>;
orderByDescending<TKey extends Comparable>(keySelector?: Selector<T, TKey>): IOrderedEnumerable<T>;
buffer(size: number): Enumerable<T[]>;
groupBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
groupBy<TKey, TCompare>(keySelector: Selector<T, TKey>, elementSelector?: Selector<T, T>, compareSelector?: Selector<TKey, TCompare>): Enumerable<IGrouping<TKey, T>>;
partitionBy<TKey>(keySelector: Selector<T, TKey>): Enumerable<IGrouping<TKey, T>>;
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>>;
aggregate(func: (a: T, b: T) => T, seed?: T): T;
average(selector?: Selector<T, number>): number;
max(): T;
min(): T;
maxBy<TCompare>(keySelector?: Selector<T, TCompare>): T;
minBy<TCompare>(keySelector?: Selector<T, TCompare>): T;
sum(selector?: Selector<T, number>): number;
product(selector?: Selector<T, number>): number;
quotient(selector?: Selector<T, number>): number;
last(): T;
lastOrDefault(defaultValue?: T): T;
share(): Enumerable<T>;
catchError(handler: (e: any) => void): Enumerable<T>;
finallyAction(action: () => void): Enumerable<T>;
memoize(): Enumerable<T>;
}
export declare class FiniteEnumerable<T> extends Enumerable<T> {
constructor(enumeratorFactory: () => IEnumerator<T>, finalizer?: () => void);
}
export interface IGrouping<TKey, TElement> extends Enumerable<TElement> {
key: TKey;
}
export interface ILookup<TKey, TElement> extends IEnumerable<IGrouping<TKey, TElement>> {
count: number;
get(key: TKey): TElement[];
contains(key: TKey): boolean;
}
export interface IOrderedEnumerable<T> extends FiniteEnumerable<T> {
thenBy(keySelector: (value: T) => any): IOrderedEnumerable<T>;
thenByDescending(keySelector: (value: T) => any): IOrderedEnumerable<T>;
thenUsing(comparison: Comparison<T>): IOrderedEnumerable<T>;
thenUsingReversed(comparison: Comparison<T>): IOrderedEnumerable<T>;
}
export default Enumerable;
10 changes: 10 additions & 0 deletions dist/amd/System/Char.d.ts
View file
@@ -0,0 +1,10 @@
/*!
* @author electricessence / https://github.com/electricessence/
* From Netjs mscorlib.ts
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
*/
export declare function isWhiteSpace(ch: number): boolean;
export declare function isLetter(ch: number): boolean;
export declare function isLetterOrDigit(ch: number): boolean;
export declare function isDigit(ch: number): boolean;
export declare function isDigit(str: string, index: number): boolean;
13 changes: 13 additions & 0 deletions dist/amd/System/Collections/Array/Compare.d.ts
View file
@@ -0,0 +1,13 @@
/// <reference path="../../../../../source/System/Collections/Array/IArray.d.ts" />
/// <reference path="../../../../../source/System/FunctionTypes.d.ts" />
/// <reference path="../../../../../source/System/Primitive.d.ts" />
/// <reference path="../../../../../source/System/IComparable.d.ts" />
/*!
* @author electricessence / https://github.com/electricessence/
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
*/
export declare function areAllEqual(arrays: any[][], strict?: boolean, equalityComparer?: EqualityComparison<any>): boolean;
export declare function areEqual<T>(a: IArray<T>, b: IArray<T>, strict?: boolean, equalityComparer?: EqualityComparison<T>): boolean;
export declare function areEquivalent<T extends Primitive>(a: IArray<T>, b: IArray<T>): boolean;
export declare function areEquivalent<T>(a: IArray<IComparable<T>>, b: IArray<IComparable<T>>): boolean;
export declare function areEquivalent<T>(a: IArray<T>, b: IArray<T>, comparer: Comparison<T>): boolean;
13 changes: 13 additions & 0 deletions dist/amd/System/Collections/Array/Dispatch.d.ts
View file
@@ -0,0 +1,13 @@
/// <reference path="../../../../../source/System/Collections/Array/IArray.d.ts" />
/// <reference path="../../../../../source/System/FunctionTypes.d.ts" />
/*!
* @author electricessence / https://github.com/electricessence/
* Licensing: MIT https://github.com/electricessence/TypeScript.NET/blob/master/LICENSE.md
*/
export interface DispatchErrorHandler {
(ex?: any, i?: number): void;
}
export declare function unsafe<T>(listeners: IArray<(payload: T) => any>, payload: T, trap?: boolean | DispatchErrorHandler): void;
export declare function mapped<T, TResult>(listeners: IArray<(payload: T) => TResult>, payload: T, trap?: boolean | DispatchErrorHandler): TResult[];
export declare function dispatch<T>(listeners: IArray<(payload: T) => any>, payload: T, trap?: boolean | DispatchErrorHandler): void;
export default dispatch;
6 changes: 6 additions & 0 deletions dist/amd/System/Collections/Array/Dispatch.js
View file

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

0 comments on commit 11bfb4b

Please sign in to comment.