async/timing.js

  1. /**
  2.  * Asynchronous tools.
  3.  *
  4.  * @module async
  5.  * @license Apache-2.0
  6.  * @copyright Mat. 2018-present
  7.  */
  9. import { identity } from "../func/tools";
  10. import { timeUnit } from "../utils/misc";
  15. /**
  16.  * Delay current async execution by `time` miliseconds.
  17.  *
  18.  * Example:
  19.  *
  20.  * ```
  21.  * (async () => {
  22.  *     await async.delay()
  23.  *     console.log("Hello ...")
  24.  *     await async.delay()
  25.  *     console.log("... world")
  26.  * })()
  27.  * ```
  28.  *
  29.  * @async
  30.  * @function delay
  31.  * @see [timeout]{@link module:async~timeout}
  32.  * @param {Number} [time=timeUnit.second]
  33.  * @param {Function} [passCancel] cancel => any
  34.  * @returns {Promise.<Number>}
  35.  */
  36. export const delay = (
  37.     time = timeUnit.second,
  38.     passCancel = identity,
  39. ) =>
  40.     timeout(() => time, time, passCancel);
  45. /**
  46.  * `setInterval` in `Promise` / `async` skin.
  47.  *
  48.  * Example 1:
  49.  *
  50.  * ```
  51.  * global.x = 0
  52.  * async.interval(
  53.  *     c => {
  54.  *         if (global.x === 10) { c("tada") }
  55.  *         else { global.x += 1 }
  56.  *         console.log("ping", Date.now())
  57.  *     }
  58.  * )
  59.  * .then(utils.to_("success"))
  60.  * .catch(utils.to_("failure"))
  61.  * ```
  62.  *
  63.  * Example 2:
  64.  * ```
  65.  * interval(
  66.  *     () => { console.log("Hey!"); return 42 },
  67.  *     c => timeout(() => c(), 4 * timeUnit.second)
  68.  * )
  69.  * .then(x => console.log("Finished:", x))
  70.  * .catch(c => console.log("Error:", c))
  71.  * ```
  72.  *
  73.  * @async
  74.  * @function interval
  75.  * @param {Function} f
  76.  * @param {Function} [passClear] (Function) => any
  77.  * @param {Number} [time=timeUnit.second]
  78.  * @returns {Promise.<any>}
  79.  */
  80. export const interval = (
  81.     f,
  82.     passClear = identity,
  83.     time = timeUnit.second,
  84. ) => {
  85.     let resolve = null, handle = null, result = null;
  86.     const
  87.         clear = (...args) => {
  88.             clearInterval(handle);
  89.             resolve(...(args.length > 0 ? args : [result]));
  90.             return result;
  91.         },
  92.         promise = new Promise((res, rej) => {
  93.             resolve = res;
  94.             handle = setInterval(() => {
  95.                 try { result = f(clear); }
  96.                 catch (ex) {
  97.                     clearInterval(handle);
  98.                     rej(ex);
  99.                 }
  100.             }, time);
  101.         });
  103.     passClear(clear);
  105.     return promise;
  106. };
  111. /**
  112.  * `setTimeout` in `Promise` / `async` skin.
  113.  *
  114.  * Example:
  115.  *
  116.  * ```
  117.  * async.timeout(
  118.  *     () => { console.log("Hey!"); return 42 }, 2000,
  119.  *     c => async.timeout(() => c("Cancelled!"), 1000)
  120.  * )
  121.  * .then(x => console.log("Success:", x))
  122.  * .catch(c => console.log("Error or cancel:", c))
  123.  * ```
  124.  *
  125.  * @async
  126.  * @function timeout
  127.  * @param {Function} f
  128.  * @param {Number} [time=timeUnit.second]
  129.  * @param {Function} [passCancel] cancel => any
  130.  * @returns {Promise.<any>}
  131.  */
  132. export const timeout = (
  133.     f,
  134.     time = timeUnit.second,
  135.     passCancel = identity,
  136. ) => {
  137.     let reject = null, handle = null;
  138.     const promise = new Promise((res, rej) => {
  139.         reject = rej;
  140.         handle = setTimeout(() => {
  141.             try { res(f()); }
  142.             catch (ex) { rej(ex); }
  143.         }, time);
  144.     });
  146.     passCancel(reason => {
  147.         clearTimeout(handle);
  148.         reject(reason);
  149.     });
  151.     return promise;
  152. };