3.0.7

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartpromise",
-  "version": "3.0.3",
+  "version": "3.0.7",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -453,9 +453,9 @@
       "dev": true
     },
     "@types/node": {
-      "version": "10.5.1",
+      "version": "12.7.5",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-10.5.1.tgz",
+      "resolved": "https://verdaccio.lossless.one/@types%2fnode/-/node-12.7.5.tgz",
-      "integrity": "sha512-AFLl1IALIuyt6oK4AYZsgWVJ/5rnyzQWud7IebaZWWV3YmgtPZkQmYio9R5Ze/2pdd7XfqF5bP+hWS11mAKoOQ==",
+      "integrity": "sha512-9fq4jZVhPNW8r+UYKnxF1e2HkDWOWKM5bC2/7c9wPV835I0aOrVbS/Hw/pWPk2uKrNXQqg9Z959Kz+IYDd5p3w==",
       "dev": true
     },
     "@types/vinyl": {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pushrocks/smartpromise",
   "private": false,
-  "version": "3.0.3",
+  "version": "3.0.7",
   "description": "simple promises and Deferred constructs",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -24,7 +24,7 @@
     "@gitzone/tsbuild": "^2.1.17",
     "@gitzone/tstest": "^1.0.24",
     "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^10.5.1",
+    "@types/node": "^12.7.5",
     "tslint": "^5.20.0",
     "tslint-config-prettier": "^1.18.0"
   },

test/test.ts

@@ -1,27 +1,27 @@
 import { expect, tap } from '@pushrocks/tapbundle';
-import * as q from '../ts/index';
+import * as smartpromise from '../ts/index';
 
 tap.test('should return a Deferred for .defer()', async () => {
-  let myDeferred = q.defer();
+  const myDeferred = smartpromise.defer();
-  let expectPromise = expect(myDeferred.promise).to.eventually.be.fulfilled;
+  const expectPromise = expect(myDeferred.promise).to.eventually.be.fulfilled;
   myDeferred.resolve();
   return expectPromise;
 });
 
 tap.test('should let types flow through the Promise', async () => {
-  let myString = 'someString';
+  const myString = 'someString';
-  let myDeferred = q.defer<string>();
+  const myDeferred = smartpromise.defer<string>();
-  let expectPromise = expect(myDeferred.promise).to.eventually.equal('someString');
+  const expectPromise = expect(myDeferred.promise).to.eventually.equal('someString');
   myDeferred.resolve(myString);
   return expectPromise;
 });
 
 tap.test('should map callbacks', async () => {
-  let inputArray = ['hi', 'awesome'];
+  const inputArray = ['hi', 'awesome'];
   const myPromisified = async myInput => {
     return myInput;
   };
-  const expectPromise = expect(q.map(inputArray, myPromisified)).to.eventually.deep.equal(
+  const expectPromise = expect(smartpromise.map(inputArray, myPromisified)).to.eventually.deep.equal(
     inputArray
   );
   return expectPromise;

ts/index.ts

@@ -1,5 +1,5 @@
 export interface IResolve<T> {
-  (value?: T | Promise<T>): void;
+  (value?: T | PromiseLike<T>): void;
 }
 
 export interface IReject {
@@ -42,21 +42,21 @@ export class Deferred<T> {
   }
 }
 
-export let defer = <T>() => {
+export const defer = <T>() => {
   return new Deferred<T>();
 };
 
 /**
  * Creates a new resolved promise for the provided value.
  */
-export let resolvedPromise = <T>(value?: T): Promise<T> => {
+export const resolvedPromise = <T>(value?: T): Promise<T> => {
   return Promise.resolve(value);
 };
 
 /**
  * Creates a new rejected promise for the provided reason.
  */
-export let rejectedPromise = err => {
+export const rejectedPromise = (err) => {
   return Promise.reject(err);
 };
 
@@ -64,16 +64,31 @@ interface IAsyncFunction<T> {
   (someArg: T): Promise<T>;
 }
 
-export let map = async <T>(inputArg: T[], functionArg: IAsyncFunction<T>) => {
+/**
-  let promiseArray: Promise<any>[] = [];
+ * accepts an array of inputs and a function that accepts the input.
-  let resultArray = [];
+ * runs all items with the function and returns the result array when all items have run
-  for (let item of inputArg) {
+ * @param inputArg
-    let promise: Promise<any> = functionArg(item);
+ * @param functionArg
+ */
+export const map = async <T>(inputArg: T[], functionArg: IAsyncFunction<T>) => {
+  const promiseArray: Promise<any>[] = [];
+  const resultArray = [];
+  for (const item of inputArg) {
+    const promise: Promise<any> = functionArg(item);
     promiseArray.push(promise);
-    promise.then(x => {
+    promise.then((x) => {
       resultArray.push(x);
     });
   }
   await Promise.all(promiseArray);
   return resultArray;
 };
+
+export const timeoutWrap = (ms, promise) => {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error('timeout'));
+    }, ms);
+    promise.then(resolve, reject);
+  });
+};