switch to native promisify

ts/index.ts

@@ -1,45 +1,58 @@
 import 'typings-global'
-
-import * as typedPromisify from 'typed-promisify'
+import * as util from 'util'
 
 export interface IResolve<T> {
-    (value?: T | Promise<T>): void
+  (value?: T | Promise<T>): void
 }
 
 export interface IReject {
-    (reason?: any): void
+  (reason?: any): void
 }
 
 export class Deferred<T> {
-    promise: Promise<T>
-    resolve: IResolve<T>
-    reject: IReject
-    constructor() {
-        this.promise = new Promise<T>((resolve, reject) => {
-            this.resolve = resolve
-            this.reject = reject
-        })
-    }
+  promise: Promise<T>
+  resolve: IResolve<T>
+  reject: IReject
+  constructor() {
+    this.promise = new Promise<T>((resolve, reject) => {
+      this.resolve = resolve
+      this.reject = reject
+    })
+  }
 }
 
 export let defer = <T>() => {
-    return new Deferred<T>()
+  return new Deferred<T>()
 }
 
 /**
  * Creates a new resolved promise for the provided value.
  */
 export let resolvedPromise = <T>(value?: T): Promise<T> => {
-    return Promise.resolve(value)
+  return Promise.resolve(value)
 }
 
 /**
  * Creates a new rejected promise for the provided reason.
  */
 export let rejectedPromise = (err) => {
-    return Promise.reject(err)
+  return Promise.reject(err)
 }
 
-export let promisify = typedPromisify.promisify
-export let map = typedPromisify.map
-export let _try = typedPromisify._try
+// native promisify
+export let promisify = util.promisify
+export let map = async <T> (inputArg: T[],functionArg) => {
+  let promisifedFunction = promisify(functionArg)
+  let promiseArray: Promise<any>[] = []
+  let resultArray = []
+  for (let item of inputArg) {
+    let promise: Promise<any> = promisifedFunction(item)
+    promiseArray.push(promise)
+    promise.then(x => {
+      resultArray.push(x)
+    })
+
+  }
+  await Promise.all(promiseArray)
+  return resultArray
+}