Merge pull request #891 from TypeStrong/bas/defer

Promise.defer no more

Author: basarat

dist/main/atomts.js

@@ -181,16 +181,18 @@ function consumeSnippets(snippetsManager) {
 exports.consumeSnippets = consumeSnippets;
 function waitForGrammarActivation() {
     var activated = false;
-    var deferred = Promise.defer();
-    var editorWatch = atom.workspace.observeTextEditors(function (editor) {
-        if (activated)
-            return;
-        editor.observeGrammar(function (grammar) {
-            if (grammar.packageName === 'atom-typescript') {
-                activated = true;
-                deferred.resolve({});
-            }
+    var promise = new Promise(function (resolve, reject) {
+        var editorWatch = atom.workspace.observeTextEditors(function (editor) {
+            if (activated)
+                return;
+            editor.observeGrammar(function (grammar) {
+                if (grammar.packageName === 'atom-typescript') {
+                    activated = true;
+                    resolve({});
+                    editorWatch.dispose();
+                }
+            });
         });
     });
-    return deferred.promise.then(function () { return editorWatch.dispose(); });
+    return promise;
 }

dist/main/tsconfig/tsconfig.js

@@ -32,6 +32,7 @@ var compilerOptionsValidation = {
     noErrorTruncation: { type: types.boolean },
     noFallthroughCasesInSwitch: { type: types.boolean },
     noImplicitAny: { type: types.boolean },
+    noImplicitUseStrict: { type: types.boolean },
     noImplicitReturns: { type: types.boolean },
     noLib: { type: types.boolean },
     noLibCheck: { type: types.boolean },
@@ -90,6 +91,7 @@ exports.defaults = {
     emitDecoratorMetadata: true,
     declaration: false,
     noImplicitAny: false,
+    noImplicitUseStrict: false,
     removeComments: true,
     noLib: false,
     preserveConstEnums: true,

dist/worker/lib/workerLib.js

@@ -30,12 +30,13 @@ var RequesterResponder = (function () {
             if (!_this.currentListeners[message])
                 _this.currentListeners[message] = {};
             var id = createId();
-            var defer = Promise.defer();
-            _this.currentListeners[message][id] = defer;
+            var promise = new Promise(function (resolve, reject) {
+                _this.currentListeners[message][id] = { resolve: resolve, reject: reject, promise: promise };
+            });
             _this.pendingRequests.push(message);
             _this.pendingRequestsChanged(_this.pendingRequests);
             _this.getProcess().send({ message: message, id: id, data: data, request: true });
-            return defer.promise;
+            return promise;
         };
         this.responders = {};
         this.processRequest = function (m) {
@@ -120,12 +121,13 @@ var RequesterResponder = (function () {
                 if (_this.currentLastOfType[message]) {
                     _this.currentLastOfType[message].defer.resolve(defaultResponse);
                 }
-                var defer = Promise.defer();
-                _this.currentLastOfType[message] = {
-                    data: data,
-                    defer: defer
-                };
-                return defer.promise;
+                var promise_1 = new Promise(function (resolve, reject) {
+                    _this.currentLastOfType[message] = {
+                        data: data,
+                        defer: { promise: promise_1, resolve: resolve, reject: reject }
+                    };
+                });
+                return promise_1;
             }
         };
     };

lib/main/atomts.ts

@@ -321,17 +321,19 @@ export function consumeSnippets(snippetsManager) {
 
 function waitForGrammarActivation(): Promise<any> {
     let activated = false;
-    let deferred = Promise.defer();
-    let editorWatch = atom.workspace.observeTextEditors((editor: AtomCore.IEditor) => {
-
-        // Just so we won't attach more events than necessary
-        if (activated) return;
-        editor.observeGrammar((grammar: AtomCore.IGrammar) => {
-            if (grammar.packageName === 'atom-typescript') {
-                activated = true;
-                deferred.resolve({});
-            }
+    const promise = new Promise((resolve,reject) => {
+        let editorWatch = atom.workspace.observeTextEditors((editor: AtomCore.IEditor) => {
+
+            // Just so we won't attach more events than necessary
+            if (activated) return;
+            editor.observeGrammar((grammar: AtomCore.IGrammar) => {
+                if (grammar.packageName === 'atom-typescript') {
+                    activated = true;
+                    resolve({});
+                    editorWatch.dispose();
+                }
+            });
         });
     });
-    return deferred.promise.then(() => editorWatch.dispose());
+    return promise;
 }

lib/typings/atompromise.d.ts

@@ -33,7 +33,7 @@ interface PromiseConstructor {
      * and a reject callback used to reject the promise with a provided reason or error.
      */
     new <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
- 
+
     <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
@@ -86,9 +86,6 @@ interface PromiseConstructor {
      * @returns A resolved promise.
      */
     resolve(): Promise<void>;
-
-    /// BAS ADDITIONS AFTER INSPECTION INTO ATOM
-    defer<T>(): PromiseDeferred<T>;
 }
 
 interface PromiseDeferred<T> {

lib/worker/lib/workerLib.ts

@@ -102,14 +102,15 @@ class RequesterResponder {
 
         // Create an id unique to this call and store the defered against it
         var id = createId();
-        var defer = Promise.defer<any>();
-        this.currentListeners[message][id] = defer;
+        const promise = new Promise((resolve,reject)=>{
+            this.currentListeners[message][id] = { resolve, reject, promise };
+        });
 
         // Send data to worker
         this.pendingRequests.push(message);
         this.pendingRequestsChanged(this.pendingRequests);
         this.getProcess().send({ message: message, id: id, data: data, request: true });
-        return defer.promise;
+        return promise;
     }
 
     /**
@@ -153,12 +154,13 @@ class RequesterResponder {
                 }
 
                 // this needs to be the new last
-                var defer = Promise.defer<Response>();
-                this.currentLastOfType[message] = {
-                    data: data,
-                    defer: defer
-                }
-                return defer.promise;
+                const promise = new Promise<Response>((resolve,reject)=>{
+                    this.currentLastOfType[message] = {
+                        data: data,
+                        defer: {promise,resolve,reject}
+                    }
+                });
+                return promise;
             }
         };
     }