Finalized Promise module structure and separated out final version of…

… LazyPromise class.

This introduces smart defer methods which for LazyPromises do not trigger the underlying promise unless the consumer calls 'then'.

bower.json

@@ -1,6 +1,6 @@
 {
 	"name": "typescript-dotnet",
-	"version": "2.16.6",
+	"version": "2.17.0",
 	"ignore": [
 		".bowercc",
 		".gitignore",

dist/amd/System/Promises/LazyPromise.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * @author electricessence / https://github.com/electricessence/
+ * Licensing: MIT
+ */
+import { Promise, PromiseBase } from "./Promise";
+export declare class LazyPromise<T> extends Promise<T> {
+    private _resolver;
+    constructor(_resolver: Promise.Executor<T>);
+    protected _onDispose(): void;
+    private _onThen();
+    thenSynchronous<TResult>(onFulfilled: Promise.Fulfill<T, TResult>, onRejected?: Promise.Reject<TResult>): PromiseBase<TResult>;
+    thenThis(onFulfilled: (v?: T) => any, onRejected?: (v?: any) => any): PromiseBase<T>;
+    delayFromNow(milliseconds?: number): PromiseBase<T>;
+    delayAfterResolve(milliseconds?: number): PromiseBase<T>;
+}
+export default LazyPromise;

dist/amd/System/Promises/Promise.d.ts

@@ -42,23 +42,15 @@ export declare abstract class Resolved<T> extends Resolvable<T> {
 }
 export declare class Promise<T> extends Resolvable<T> {
     private _waiting;
-    constructor(resolver?: Promise.Executor<T>);
+    constructor(resolver?: Promise.Executor<T>, forceSynchronous?: boolean);
     thenSynchronous<TResult>(onFulfilled: Promise.Fulfill<T, TResult>, onRejected?: Promise.Reject<TResult>): PromiseBase<TResult>;
     thenThis(onFulfilled: (v?: T) => any, onRejected?: (v?: any) => any): PromiseBase<T>;
     protected _onDispose(): void;
     protected _resolvedCalled: boolean;
-    resolveUsing(resolver: Promise.Executor<T>, throwIfSettled?: boolean): void;
+    resolveUsing(resolver: Promise.Executor<T>, forceSynchronous?: boolean, throwIfSettled?: boolean): void;
     resolve(result?: T, throwIfSettled?: boolean): void;
     reject(error: any, throwIfSettled?: boolean): void;
 }
-export declare class LazyPromise<T> extends Promise<T> {
-    private _resolver;
-    constructor(_resolver: Promise.Executor<T>);
-    protected _onDispose(): void;
-    private _onThen();
-    thenSynchronous<TResult>(onFulfilled: Promise.Fulfill<T, TResult>, onRejected?: Promise.Reject<TResult>): PromiseBase<TResult>;
-    thenThis(onFulfilled: (v?: T) => any, onRejected?: (v?: any) => any): PromiseBase<T>;
-}
 export declare module Promise {
     enum State {
         Pending = 0,
@@ -85,8 +77,6 @@ export declare module Promise {
     function resolve(): PromiseBase<void>;
     function resolve<T>(value: T | PromiseLike<T>): PromiseBase<T>;
     function reject<T>(reason: T): PromiseBase<T>;
-    function lazy<T>(resolver: Promise.Executor<T>): LazyPromise<T>;
     function wrap<T>(target: PromiseLike<T>): PromiseBase<T>;
     function createFrom<T, TResult>(then: Then<T, TResult>): PromiseBase<T>;
-    function pending<T>(resolver?: Promise.Executor<T>): Promise<T>;
 }