@peter.naydenov/cuts 2.0.1 → 2.0.3

package/test-e2e/node_modules/ask-for-promise/README.md

@@ -0,0 +1,278 @@
+<img src="Ask-for-promise.png" width="100%" alt="Ask for Promise" title="Ask for Promise" align="center" />
+
+ ----
+
+
+# Ask for Promise
+
+![version](https://img.shields.io/github/package-json/v/peterNaydenov/ask-for-promise)
+![license](https://img.shields.io/github/license/peterNaydenov/ask-for-promise)
+![npm](https://img.shields.io/npm/dt/ask-for-promise)
+![GitHub issues](https://img.shields.io/github/issues/peterNaydenov/ask-for-promise)
+![GitHub top language](https://img.shields.io/github/languages/top/peterNaydenov/ask-for-promise)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/peterNaydenov/ask-for-promise)
+![npm bundle size](https://img.shields.io/bundlephobia/min/ask-for-promise)
+
+
+
+Decouple **promises** from their 'resolve' and 'reject' functions and make posible to use them with any javascript function ( sync or async). 'Ask-for-promise' also provide sugar syntax for some long statements.
+
+'Ask-for-promise' provides also an option to set a **ttl ( time to live) for the promise**. If time is up promise will close with timeout message.
+
+```js
+
+// standard promise pattern
+let standardTask = new Promire ( (resolve,reject) => {
+       // ... wrap everything related to the promise inside this function
+       // when promise resolve - call resolve (result)
+       // or call reject ( result )
+    })
+
+// after promise:
+standardTask.then ( item => {
+  // where 'item' is a 'result' argument sent from 'resolve' or 'reject' function. 
+})
+
+
+
+// askForPromise pattern
+let askTask = askForPromise()
+/* 
+  askTask is an object that contains
+  {
+     promise    - Promise itself
+     done       - function : Resolve function
+     cancel     - function : Reject function
+     onComplete - function : Sugar synax for askTask.promise.then
+     timeout    - function : Set time to live for the promise
+  }
+
+  You can complete the promise anywhere in your code by writing:
+  askTask.done(result)
+
+  Or reject promise by:
+  askTask.cancel(result)
+*/
+
+// after promise:
+askTask.onComplete ( item => { 
+// where 'item' is a 'result' argument sent from 'done' or 'cancel' function. 
+})
+
+
+// Execute a list of promise functions in sequence
+let task = askForPromise.sequence ( [ function1, function2, function3 ] )
+// where function1, function2, function3 are functions that return a promise
+// function1 will be executed first, then function2 and function3
+task.onComplete ( result => {
+            // result is an array of results from all promises
+   })
+
+
+// Execute a list of promise functions in parallel
+let task = askForPromise.all ( [ function1, function2, function3 ] )
+// where function1, function2, function3 are functions that return a promise
+// function1, function2 and function3 will be executed in parallel
+task.onComplete ( result => {
+            // result is an array of results from all promises in same order as they are in the array
+   })
+```
+
+
+
+
+## Installation
+
+Install by writing in your terminal:
+
+```
+npm install ask-for-promise
+
+```
+
+Once it has been installed, it can be used by writing this line of JavaScript:
+
+```js
+// if you are using ES6:
+import askForPromise from 'ask-for-promise'
+
+// if you are using commonJS:
+const askForPromise = require ( 'ask-for-promise' )
+```
+
+
+
+
+## Examples
+
+### Simple promise
+
+```js
+let task = askForPromise()
+
+function asyncFn ( ) {
+   // ... do something
+   // when ready -> 
+   task.done ( 'task complete' )   
+} 
+
+task.onComplete ( r => {
+            console.log ( r )
+            // r ===  'task complete'
+   })
+// Method 'onComplete' is sugar syntax for 'task.promise.then'.
+// task.promise.then ( r => { console.log ( r ) })
+```
+
+AskForPromise will return an object. Property `task.promise` will contain promise it self. Resolve function is available as `task.done` and reject function as `task.cancel`. Completion of asyncFunction will complete the promise with 'task complete' argument and will print a console message 'task complete'.
+
+### Let's do a Promise.race without using `Promise.race`.
+```js
+let task = askForPromise()
+
+async_1 ( arg, ( err, r) => task.done('1') )
+async_2 ( arg, ( err, r) => task.done('2') )
+
+task.onComplete ( r => console.log(r)   )
+// It's equal of:
+// task.promise.than ( r => console.log ( r )   )
+```
+It's almost the same as previous example - right?
+
+### Long Promise Chain
+Let's see how looks long chain of promises:
+```js
+
+// Keep definition of all promises together.
+let prepareFolders  = askForPromise()
+let writeFiles      = askForPromise()
+let updateInterface = askForPromise()
+
+// myFS is a dummy library that works with files.
+myFS.makeFolders ( folders, ( err , r ) => prepareFolders.done() )
+
+prepareFolders
+ .onComplete ( () => {
+                  myFS.writeFiles ( files , () => writeFiles.done() )
+                  return writeFiles.promise
+              })
+.then ( () => {
+                 updateInterface ()  // if it's not async.
+                 updateInterface.done()
+                 return updateInterface.promise
+   })
+.then ( () => {
+                 console.log('DONE')
+   })
+
+```
+
+
+
+
+### Promise with Timeout
+
+```js
+let final;
+const task = askForPromise().timeout ( 2000, 'expire' );
+// setTimeout: .timeout ( ttl, 'expireMessage'). ttl is time to live in milliseconds
+
+task.onComplete ( result => {
+    if ( result === 'expire' ) final = 'timeout'                    // ... it's after timeout
+    else                       final = 'success resolved promise'
+})
+
+```
+
+
+
+
+
+### Promise All
+
+Promise all by providing array of data. Here is the example:
+```js
+
+  const files = [ 'info.txt', 'general.txt', 'about.txt' ]
+
+  let writeFile = askForPromise ( files )
+
+   writeFiles.each ( ({ value, done, cancel }) => {
+                  fs.writeFile ( value,'dummy text', () => done() )
+            })
+   /**
+    *  Will execute a callback function with each item from the list
+    *  first value - 'info.txt', done and cancel functions are related to first promise
+    */
+
+   writeFile.onComplete ( () => console.log ( 'DONE' )   )
+/*
+Last statement is equivalent of:
+Promise
+   .all ( writeFile.promises )
+   .then ( () => console.log ( 'DONE' )   )
+*/
+
+```
+
+When function askForPromise get array of data will create interally an array of askForPromise objects. One askForPromise object for each item in the list. 'onComplete' will be called when all promises are completed. With method 'each' you can execute a callback function for each item in the list.
+
+
+
+
+### Control of single promise and many promises
+With 'ask-for-promise' asking for one or many promises have almost same syntax. There is some code sample to illustrate this:
+```js
+
+  // ask for single promise
+     let singlePromise = askForPromise ()
+
+ // ask for list of promises
+    let listOfItems = [ 'first', 'second', 'third' ]
+    let manyPromises = askForPromise ( listOfItems )
+
+   //execute single promise
+   function asyncFn () {
+            // ... do something
+            // when ready -> 
+            singlePromise.done ( 'task complete' )
+      }
+   
+   //execute many promises
+   manyPromises.each ( ({ value, done, cancel }) => {
+                     // ... do something
+                     // when ready -> 
+                     done ( 'task complete' )
+            })
+
+ // Promise complete for single promise
+    singlePromise.onComplete ( (r) => { console.log (r)   })
+
+ // All promises for the array are completed.
+    manyPromises.onComplete ( (r) => { console.log (r)   })
+
+```
+
+
+
+
+
+### More
+For more examples please visit "**test**" folder of the project.
+
+
+
+
+## External Links
+- [History of changes](https://github.com/PeterNaydenov/ask-for-promise/blob/master/Changelog.md)
+
+
+
+## Credits
+'ask-for-promise' was created by Peter Naydenov.
+
+
+
+
+## License
+'ask-for-promise' is released under the [MIT License](http://opensource.org/licenses/MIT).

package/test-e2e/node_modules/ask-for-promise/dist/ask-for-promise.cjs

@@ -0,0 +1 @@
+"use strict";function e(e){return e?function(e){let i=e.map(e=>n()),r=i.map(e=>e.promise);i.promises=i;let c=t(Promise.all(r));function u(e){let n="pending";return e.then(()=>n="fulfilled").catch(()=>n="rejected"),n}function l(n,...t){i.forEach((o,i)=>n({value:e[i],done:o.done,cancel:o.cancel,timeout:o.timeout,state:u(o.promise)},...t))}const m={promise:Promise.all(r),promises:i,done:e=>{i.forEach(n=>n.done(e))},cancel:e=>{i.forEach(n=>n.cancel(e))},each:l,onComplete:c,timeout:()=>{}};return m.timeout=o(!0,m),m}(e):n()}function n(){let e,n;const i=new Promise((t,o)=>{e=t,n=o}),r={promise:i,promises:null,done:e,cancel:n,each:()=>{},onComplete:t(i),timeout:()=>{}};return r.timeout=o(!1,r),r.each=(t,...o)=>{t({value:null,done:e,cancel:n,timeout:r.timeout},...o)},r}function t(e){return function(n,t=null){null===t?e.then(e=>n(e)):e.then(e=>n(e),e=>t(e))}}function o(e,n){let o;return o=e?Promise.all(n.promises.map(e=>e.promise)):n.promise,function(e,i){let r,c=new Promise((n,t)=>{r=setTimeout(()=>{n(i),Promise.resolve(o)},e)});return o.then(()=>clearTimeout(r)),n.onComplete=t(Promise.race([o,c])),n}}e.sequence=function(n,...t){const o=e(),i=[];const r=function*(e){for(const n of e)yield n}(n);return function e(n,...t){n.done?o.done(i):n.value(...t).then(n=>{i.push(n),e(r.next(),...t,n)})}(r.next(),...t),o},e.all=function(n,...t){const o=e(),i=[],r=n.map((e,n)=>"function"==typeof e?e(...t).then(e=>i[n]=e):e.then(e=>i[n]=e));return Promise.all(r).then(()=>o.done(i)),o},module.exports=e;

package/test-e2e/node_modules/ask-for-promise/dist/ask-for-promise.esm.mjs

@@ -0,0 +1 @@
+function e(e){return e?function(e){let i=e.map(e=>n()),r=i.map(e=>e.promise);i.promises=i;let c=t(Promise.all(r));function u(e){let n="pending";return e.then(()=>n="fulfilled").catch(()=>n="rejected"),n}function l(n,...t){i.forEach((o,i)=>n({value:e[i],done:o.done,cancel:o.cancel,timeout:o.timeout,state:u(o.promise)},...t))}const m={promise:Promise.all(r),promises:i,done:e=>{i.forEach(n=>n.done(e))},cancel:e=>{i.forEach(n=>n.cancel(e))},each:l,onComplete:c,timeout:()=>{}};return m.timeout=o(!0,m),m}(e):n()}function n(){let e,n;const i=new Promise((t,o)=>{e=t,n=o}),r={promise:i,promises:null,done:e,cancel:n,each:()=>{},onComplete:t(i),timeout:()=>{}};return r.timeout=o(!1,r),r.each=(t,...o)=>{t({value:null,done:e,cancel:n,timeout:r.timeout},...o)},r}function t(e){return function(n,t=null){null===t?e.then(e=>n(e)):e.then(e=>n(e),e=>t(e))}}function o(e,n){let o;return o=e?Promise.all(n.promises.map(e=>e.promise)):n.promise,function(e,i){let r,c=new Promise((n,t)=>{r=setTimeout(()=>{n(i),Promise.resolve(o)},e)});return o.then(()=>clearTimeout(r)),n.onComplete=t(Promise.race([o,c])),n}}e.sequence=function(n,...t){const o=e(),i=[];const r=function*(e){for(const n of e)yield n}(n);return function e(n,...t){n.done?o.done(i):n.value(...t).then(n=>{i.push(n),e(r.next(),...t,n)})}(r.next(),...t),o},e.all=function(n,...t){const o=e(),i=[],r=n.map((e,n)=>"function"==typeof e?e(...t).then(e=>i[n]=e):e.then(e=>i[n]=e));return Promise.all(r).then(()=>o.done(i)),o};export{e as default};

package/test-e2e/node_modules/ask-for-promise/dist/ask-for-promise.umd.js

@@ -0,0 +1 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e="undefined"!=typeof globalThis?globalThis:e||self).askForPromise=n()}(this,function(){"use strict";function e(e){return e?function(e){let i=e.map(e=>n()),u=i.map(e=>e.promise);i.promises=i;let r=o(Promise.all(u));function c(e){let n="pending";return e.then(()=>n="fulfilled").catch(()=>n="rejected"),n}function l(n,...o){i.forEach((t,i)=>n({value:e[i],done:t.done,cancel:t.cancel,timeout:t.timeout,state:c(t.promise)},...o))}const s={promise:Promise.all(u),promises:i,done:e=>{i.forEach(n=>n.done(e))},cancel:e=>{i.forEach(n=>n.cancel(e))},each:l,onComplete:r,timeout:()=>{}};return s.timeout=t(!0,s),s}(e):n()}function n(){let e,n;const i=new Promise((o,t)=>{e=o,n=t}),u={promise:i,promises:null,done:e,cancel:n,each:()=>{},onComplete:o(i),timeout:()=>{}};return u.timeout=t(!1,u),u.each=(o,...t)=>{o({value:null,done:e,cancel:n,timeout:u.timeout},...t)},u}function o(e){return function(n,o=null){null===o?e.then(e=>n(e)):e.then(e=>n(e),e=>o(e))}}function t(e,n){let t;return t=e?Promise.all(n.promises.map(e=>e.promise)):n.promise,function(e,i){let u,r=new Promise((n,o)=>{u=setTimeout(()=>{n(i),Promise.resolve(t)},e)});return t.then(()=>clearTimeout(u)),n.onComplete=o(Promise.race([t,r])),n}}return e.sequence=function(n,...o){const t=e(),i=[];const u=function*(e){for(const n of e)yield n}(n);return function e(n,...o){n.done?t.done(i):n.value(...o).then(n=>{i.push(n),e(u.next(),...o,n)})}(u.next(),...o),t},e.all=function(n,...o){const t=e(),i=[],u=n.map((e,n)=>"function"==typeof e?e(...o).then(e=>i[n]=e):e.then(e=>i[n]=e));return Promise.all(u).then(()=>t.done(i)),t},e});

package/test-e2e/node_modules/ask-for-promise/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "ask-for-promise",
+  "description": "promise utility library",
+  "version": "3.1.0",
+  "license": "MIT",
+  "author": "Peter Naydenov",
+  "main": "src/askForPromise.js",
+  "type": "module",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/askForPromise.js",
+      "require": "./dist/ask-for-promise.cjs",
+      "default": "./src/askForPromise.js"
+    },
+    "./package.json": "./package.json",
+    "./src/*": "./src/*",
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*"
+  },
+  "files": [
+    "src/*.js",
+    "dist/*",
+    "types/*",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "mocha test",
+    "cover": "c8 mocha test",
+    "build": "tsc --noEmit && rollup -c"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PeterNaydenov/ask-for-promise.git"
+  },
+  "homepage": "https://github.com/PeterNaydenov/ask-for-promise#readme",
+  "bugs": {
+    "url": "https://github.com/PeterNaydenov/ask-for-promise/issues"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.8",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/node": "^24.9.1",
+    "c8": "^10.1.3",
+    "chai": "6.2.0",
+    "mocha": "11.7.4",
+    "rollup": "^4.52.5",
+    "typescript": "^5.9.3"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "c8": {
+    "include": [
+      "src/**/*.js"
+    ],
+    "exclude": [
+      "node_modules",
+      "test"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "keywords": [
+    "promise",
+    "sequence",
+    "paralel",
+    "timout",
+    "ttl",
+    "decoupled promise"
+  ]
+}

package/test-e2e/node_modules/ask-for-promise/src/askForPromise.js

@@ -0,0 +1,277 @@
+'use strict'
+/*
+   askForPromise Description
+   ========================
+   Returns object with the promise and related helper functions.
+   - Created March 12th, 2016;
+   - Promise with timeout added July 16th, 2017 (v.1.3.0);
+   - askForPromise.all & AskForPromise.sequence added October 15th, 2023(v.1.4.0);
+   - jsDocs type definitions added October 27th, 2023(v.1.5.0);
+   - Converted to ES6 module January 6th, 2024(v.2.0.0);
+   - Massive refactoring of the library. Method 'each' added December 18th, 2024(v.3.0.0);
+*/
+
+
+
+/**
+ * @interface AskObject
+ * @description Object with promise and related helper functions
+ * @property {Promise} promise - Promise object
+ * @property {Array<AskObject>|null} [promises] - Array of promises if multiple promises are created
+ * @property {Function} done - Resolve function
+ * @property {Function} cancel - Reject function
+ * @property {Function} each - Callback function to be called for each list item
+ * @property {Function} onComplete - Function to be called after promise is resolved
+ * @property {Function} timeout - Function to set timeout on promise
+ */
+
+
+
+/**
+ * Creates object with promise and related helper functions
+ * @function askForPromise
+ * @param {Array<any>} [list] - List of items that need to have a corresponding promise.(optional)
+ * @returns {AskObject} Object with promise and related helper functions
+ */
+function askForPromise ( list ) {
+        if ( list ) return _manyPromises ( list )
+        else        return _singlePromise ();
+ } // askForPromise func.
+
+
+
+/**
+ * @function sequence
+ * @description Executes list of functions that return a promise in sequence.
+ * @param {Array<Function>} list - List of functions that return a promise
+ * @param {...any} args - Arguments to be passed to each function in the list
+ * @returns {AskObject} - Object with promise and related helper functions
+ */
+ askForPromise.sequence = function promiseInSequence ( list, ...args ) {
+  const 
+        task = askForPromise ()
+      , result = []
+      ;
+
+  function* listGen ( n ) {   for ( const el of n ) { yield el }} 
+  const g = listGen ( list );
+
+  function wait ( n, ...args ) {   // Recursive function for calling function list in sequence
+      if ( n.done ) {
+               task.done ( result )
+               return
+          }
+      n.value (...args).then ( r => {
+              result.push ( r )
+              wait( g.next(), ...args, r )
+          }) 
+      } // wait func.
+
+  wait ( g.next(), ...args ) // Starting with iteration of list
+  return task
+} // promiseInSequence func.
+
+
+
+/**
+ * @function all
+ * @description Executes list of functions that return a promise in parallel.
+ * @param {Array<Function>} list - List of functions that return a promise
+ * @param {...any} args - Arguments to be passed to each function in the list
+ * @returns {AskObject} - Object with promise and related helper functions
+ */
+askForPromise.all = function promiseAll ( list, ...args ) {
+  const 
+        task = askForPromise ()
+      , result = []
+      , r = list.map ( (n,i) => { 
+                            return (typeof n === 'function') ? n(...args).then ( r => result[i] = r   ) 
+                                                             : n.then ( r => result[i] = r   )
+                        })
+      ;
+  Promise.all ( r ).then ( () => task.done(result)   )
+  return task
+} // promiseAll func.
+
+
+
+
+
+/**
+ * Creates a single promise with helper functions.
+ * @function _singlePromise Creates a single promise
+ * @returns {AskObject} Object containing the promise and related helper functions such as:
+ * - promise: The promise itself
+ * - done: Function to resolve the promise
+ * - cancel: Function to reject the promise
+ * - each: Function to iterate over a single promise (no-op for a single promise)
+ * - onComplete: Function to be called after the promise is resolved
+ * - timeout: Function to set a timeout on the promise
+ */
+function _singlePromise () {
+  let  done, cancel;
+  const x = new Promise ( (resolve, reject ) => { 
+                                                  done   = resolve
+                                                  cancel = reject
+                                 })
+    /** @type {AskObject} */
+    const askObject = {
+               promise    : x
+             , promises   : null
+             , done       
+             , cancel     
+             , each       : () => {}
+             , onComplete : _after(x)
+             , timeout    : () => {}
+           }
+
+    askObject.timeout = _timeout ( false, askObject )
+    askObject.each = (cbFn, ...args) => { cbFn({value: null, done: done, cancel: cancel, timeout: askObject.timeout}, ...args) }
+    
+    return askObject
+   } // _singlePromise func.
+
+
+
+/**
+ * Creates an object with multiple promises and related helper functions.
+ * @param {Array<any>} list - List of items that need to have a corresponding promise.
+ * @returns {AskObject} Object containing the promises and related helper functions such as:
+ * - promise: It's equal to Promise.all (list of promises)
+ * - promises: An array of single promise objects
+ * - done: Function to resolve all promises
+ * - cancel: Function to reject all promises
+ * - each: Function to iterate over the promises and call a callback function for each promise
+ * - onComplete: Function to be called after all promises are resolved
+ * - timeout: Function to set a timeout on all promises
+ */
+ function _manyPromises ( list ) {
+                                    let listOfPromiseObjects = list.map ( el => _singlePromise() )
+                                    let listOfPromises   = listOfPromiseObjects.map ( o => o.promise )
+                                    
+                                    listOfPromiseObjects [ 'promises' ] = listOfPromiseObjects
+                                    let onComplete = _after ( Promise.all (listOfPromises) )
+
+
+
+                                  /**
+                                   * Reads the state of a promise
+                                   * @function readPromiseState
+                                   * @description Returns the state of the promise as string: 'pending', 'fulfilled', or 'rejected'
+                                   * @param {Promise} promise - The promise to read the state of
+                                   * @returns {string} The state of the promise as string
+                                   */
+                                    function readPromiseState ( promise ) {
+                                            let state = 'pending';
+                                            promise.then ( () => state = 'fulfilled' )
+                                                    .catch ( () => state = 'rejected' )
+                                            return state
+                                      } // readPromiseState func.
+                                   
+
+
+                                  /**
+                                   * Iterates over the promises and calls the callback function for each.
+                                   * Callback function will receive an object with the following properties:
+                                   * - value: the value associated with the promise
+                                   * - done: the promise resolve function
+                                   * - cancel: the promise reject function
+                                   * - timeout: a function that sets the timeout on the promise
+                                   * @param {function} cbFn - callback function to be called for each promise
+                                   * @param {...any} args - additional arguments to be passed to the callback function
+                                   */
+                                    function each ( cbFn, ...args ) {
+                                            listOfPromiseObjects.forEach ( (prom,i) => cbFn ({
+                                                                                            value:list[i], 
+                                                                                            done: prom.done, 
+                                                                                            cancel: prom.cancel, 
+                                                                                            timeout: prom.timeout, 
+                                                                                            state: readPromiseState(prom.promise) 
+                                                                                        }, 
+                                                                                        ...args
+                                                                                      ))
+                                      } // each func.
+
+
+
+                                     /** @type {AskObject} */
+                                     const askObject = {
+                                                  promise    : Promise.all ( listOfPromises )
+                                                , promises   : listOfPromiseObjects
+                                                , done       : ( response )  => { listOfPromiseObjects.forEach ( o => o.done( response  ) )}
+                                                , cancel     : ( response )  => { listOfPromiseObjects.forEach ( o => o.cancel( response ) )}
+                                                , each
+                                                , onComplete : onComplete
+                                                , timeout    : () => {}
+                                            }
+                                    askObject.timeout = _timeout ( true, askObject )
+                                    return askObject
+   } // _manyPromises func.
+
+
+
+/**
+ * Creates a function that will be called after promise is resolved
+ * @param {Promise} x - The promise
+ * @returns {Function} Function to be called after promise is resolved
+ */
+function _after ( x ) {
+/**
+ * @function onComplete
+ * @description Function to be called after promise is resolved
+ * @param {Function} fx - Function to be called after promise is resolved
+ * @param {Function|null} [rejectFx] - Optional. Function to be called if promise is rejected
+ * @returns {void} - Nothing
+ */
+return function onComplete ( fx, rejectFx=null ) {
+                if ( rejectFx === null ) x.then ( res => fx(res) )
+                else                     x.then ( res => fx(res) , res => rejectFx(res)  )
+}} // _after func.
+
+
+
+/**
+ * Creates a timeout function for the given promise(s) in the AskObject.
+ * If `isList` is true, the timeout is applied to the collection of promises,
+ * otherwise it is applied to a single promise.
+ * 
+ * When the timeout duration (`ttl`) is reached before the promise(s) resolve,
+ * the provided expiration message (`expMsg`) is returned.
+ * 
+ * @param {boolean} isList - Flag indicating if the AskObject contains multiple promises.
+ * @param {AskObject} askObject - The AskObject containing the promise(s) to apply the timeout to.
+ * @returns {Function} - A function that sets a timeout on the promise(s) and updates the AskObject.
+ */
+
+function _timeout ( isList, askObject ) {
+      let main;
+      
+      if ( isList ) main = Promise.all( askObject.promises.map ( o => o.promise ) );
+      else          main = askObject.promise;
+
+      /**
+       * @function timeout
+       * @description Sets timeout on promise
+       * @param {number} ttl - Timeout in milliseconds
+       * @param {string|number} expMsg - Message to be returned if timeout occurs
+       * @returns {AskObject} - Object with promise and related helper functions
+       */
+      return function timeout( ttl, expMsg ) {
+                let timer;
+                let timeout = new Promise ( (resolve, reject) => {
+                                        timer = setTimeout ( () => {
+                                                        resolve ( expMsg )
+                                                        Promise.resolve ( main )
+                                                    }, ttl)
+                                    }); // timeout
+                main.then ( () => clearTimeout(timer)   )                
+                askObject [ 'onComplete'] = _after ( Promise.race ([main, timeout])   )
+                return askObject
+            }
+    } // _timeout func.
+
+
+
+export default askForPromise
+
+

package/test-e2e/node_modules/ask-for-promise/types/index.d.ts

@@ -0,0 +1,18 @@
+export interface AskObject {
+    promise: Promise<any>;
+    promises?: AskObject[] | null;
+    done: (response?: any) => void;
+    cancel: (response?: any) => void;
+    each: (cbFn: (...args: any[]) => void, ...args: any[]) => void;
+    onComplete: (fx: (result: any) => void, rejectFx?: ((error: any) => void) | null) => void;
+    timeout: (ttl: number, expMsg: any) => AskObject;
+}
+
+export default askForPromise;
+
+declare function askForPromise(list?: any[]): AskObject;
+
+declare namespace askForPromise {
+    function sequence(list: (() => Promise<any>)[], ...args: any[]): AskObject;
+    function all(list: (() => Promise<any>)[], ...args: any[]): AskObject;
+}

package/test-e2e/node_modules/csstype/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017-2018 Fredrik Nicol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.