wip

src/Analytics.ts

@@ -2,7 +2,6 @@
  * @flow
  */
 
-// @ts-ignore
 import CoreManager from './CoreManager';
 
 /**

src/ParseObject.ts

@@ -2447,11 +2447,11 @@ const DefaultController = {
 
             // Queue up tasks for each object in the batch.
             // When every task is ready, the API request will execute
-            const batchReturned = new resolvingPromise();
+            const batchReturned = resolvingPromise();
             const batchReady: any[] = [];
             const batchTasks: any[] = [];
             batch.forEach((obj, index) => {
-              const ready = new resolvingPromise();
+              const ready = resolvingPromise();
               batchReady.push(ready);
               const task = function () {
                 ready.resolve();

src/TaskQueue.js → src/TaskQueue.ts

@@ -4,19 +4,19 @@
 import { resolvingPromise } from './promiseUtils';
 
 type Task = {
-  task: () => Promise,
-  _completion: Promise,
+  task: () => Promise<any>,
+  _completion: resolvingPromise<Task>,
 };
 
 class TaskQueue {
-  queue: Array<Task>;
+  queue: Task[];
 
   constructor() {
     this.queue = [];
   }
 
-  enqueue(task: () => Promise): Promise {
-    const taskComplete = new resolvingPromise();
+  enqueue(task: () => Promise<any>): Promise<any> {
+    const taskComplete = resolvingPromise();
     this.queue.push({
       task: task,
       _completion: taskComplete,
@@ -55,3 +55,4 @@ class TaskQueue {
 }
 
 module.exports = TaskQueue;
+export default TaskQueue;

src/promiseUtils.js → src/promiseUtils.ts

@@ -1,8 +1,13 @@
 // Create Deferred Promise
+export interface resolvingPromise<T> extends Promise<T> {
+  resolve?:(value?: any) => void;
+  reject?:(value?: any) => void;
+}
+
 export function resolvingPromise() {
-  let res;
-  let rej;
-  const promise = new Promise((resolve, reject) => {
+  let res: (value: any) => void | null;
+  let rej: (value: any) => void | null;
+  const promise: resolvingPromise<any> = new Promise((resolve, reject) => {
     res = resolve;
     rej = reject;
   });
@@ -32,7 +37,7 @@ export function when(promises) {
     return Promise.resolve(returnValue);
   }
 
-  const promise = new resolvingPromise();
+  const promise = resolvingPromise();
 
   const resolveOne = function () {
     total--;

types/TaskQueue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @flow
+ */
+import { resolvingPromise } from './promiseUtils';
+type Task = {
+    task: () => Promise<any>;
+    _completion: resolvingPromise<Task>;
+};
+declare class TaskQueue {
+    queue: Task[];
+    constructor();
+    enqueue(task: () => Promise<any>): Promise<any>;
+    _dequeue(): void;
+}
+export default TaskQueue;

types/promiseUtils.d.ts

@@ -0,0 +1,7 @@
+export interface resolvingPromise<T> extends Promise<T> {
+    resolve?: (value?: any) => void;
+    reject?: (value?: any) => void;
+}
+export declare function resolvingPromise(): resolvingPromise<any>;
+export declare function when(promises: any): resolvingPromise<any> | Promise<any[]>;
+export declare function continueWhile(test: any, emitter: any): any;