@aws/lsp-codewhisperer 0.0.9 → 0.0.10

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/Promise.js

@@ -1,293 +0,0 @@
-'use strict';
-
-/**
- * Promise
- *
- * Inspired by https://gist.github.com/RubaXa/8501359 from RubaXa <trash@rubaxa.org>
- * @template T
- * @template [E=Error]
- * @param {Function} handler   Called as handler(resolve: Function, reject: Function)
- * @param {Promise} [parent]   Parent promise for propagation of cancel and timeout
- */
-function Promise(handler, parent) {
-  var me = this;
-
-  if (!(this instanceof Promise)) {
-    throw new SyntaxError('Constructor must be called with the new operator');
-  }
-
-  if (typeof handler !== 'function') {
-    throw new SyntaxError('Function parameter handler(resolve, reject) missing');
-  }
-
-  var _onSuccess = [];
-  var _onFail = [];
-
-  // status
-  /**
-   * @readonly
-   */
-  this.resolved = false;
-  /**
-   * @readonly
-   */
-  this.rejected = false;
-  /**
-   * @readonly
-   */
-  this.pending = true;
-
-  /**
-   * Process onSuccess and onFail callbacks: add them to the queue.
-   * Once the promise is resolved, the function _promise is replace.
-   * @param {Function} onSuccess
-   * @param {Function} onFail
-   * @private
-   */
-  var _process = function (onSuccess, onFail) {
-    _onSuccess.push(onSuccess);
-    _onFail.push(onFail);
-  };
-
-  /**
-   * Add an onSuccess callback and optionally an onFail callback to the Promise
-   * @template TT
-   * @template [TE=never]
-   * @param {(r: T) => TT | PromiseLike<TT>} onSuccess
-   * @param {(r: E) => TE | PromiseLike<TE>} [onFail]
-   * @returns {Promise<TT | TE, any>} promise
-   */
-  this.then = function (onSuccess, onFail) {
-    return new Promise(function (resolve, reject) {
-      var s = onSuccess ? _then(onSuccess, resolve, reject) : resolve;
-      var f = onFail    ? _then(onFail,    resolve, reject) : reject;
-
-      _process(s, f);
-    }, me);
-  };
-
-  /**
-   * Resolve the promise
-   * @param {*} result
-   * @type {Function}
-   */
-  var _resolve = function (result) {
-    // update status
-    me.resolved = true;
-    me.rejected = false;
-    me.pending = false;
-
-    _onSuccess.forEach(function (fn) {
-      fn(result);
-    });
-
-    _process = function (onSuccess, onFail) {
-      onSuccess(result);
-    };
-
-    _resolve = _reject = function () { };
-
-    return me;
-  };
-
-  /**
-   * Reject the promise
-   * @param {Error} error
-   * @type {Function}
-   */
-  var _reject = function (error) {
-    // update status
-    me.resolved = false;
-    me.rejected = true;
-    me.pending = false;
-
-    _onFail.forEach(function (fn) {
-      fn(error);
-    });
-
-    _process = function (onSuccess, onFail) {
-      onFail(error);
-    };
-
-    _resolve = _reject = function () { }
-
-    return me;
-  };
-
-  /**
-   * Cancel the promise. This will reject the promise with a CancellationError
-   * @returns {this} self
-   */
-  this.cancel = function () {
-    if (parent) {
-      parent.cancel();
-    }
-    else {
-      _reject(new CancellationError());
-    }
-
-    return me;
-  };
-
-  /**
-   * Set a timeout for the promise. If the promise is not resolved within
-   * the time, the promise will be cancelled and a TimeoutError is thrown.
-   * If the promise is resolved in time, the timeout is removed.
-   * @param {number} delay     Delay in milliseconds
-   * @returns {this} self
-   */
-  this.timeout = function (delay) {
-    if (parent) {
-      parent.timeout(delay);
-    }
-    else {
-      var timer = setTimeout(function () {
-        _reject(new TimeoutError('Promise timed out after ' + delay + ' ms'));
-      }, delay);
-
-      me.always(function () {
-        clearTimeout(timer);
-      });
-    }
-
-    return me;
-  };
-
-  // attach handler passing the resolve and reject functions
-  handler(function (result) {
-    _resolve(result);
-  }, function (error) {
-    _reject(error);
-  });
-}
-
-/**
- * Execute given callback, then call resolve/reject based on the returned result
- * @param {Function} callback
- * @param {Function} resolve
- * @param {Function} reject
- * @returns {Function}
- * @private
- */
-function _then(callback, resolve, reject) {
-  return function (result) {
-    try {
-      var res = callback(result);
-      if (res && typeof res.then === 'function' && typeof res['catch'] === 'function') {
-        // method returned a promise
-        res.then(resolve, reject);
-      }
-      else {
-        resolve(res);
-      }
-    }
-    catch (error) {
-      reject(error);
-    }
-  }
-}
-
-/**
- * Add an onFail callback to the Promise
- * @template TT
- * @param {(error: E) => TT | PromiseLike<TT>} onFail
- * @returns {Promise<T | TT>} promise
- */
-Promise.prototype['catch'] = function (onFail) {
-  return this.then(null, onFail);
-};
-
-// TODO: add support for Promise.catch(Error, callback)
-// TODO: add support for Promise.catch(Error, Error, callback)
-
-/**
- * Execute given callback when the promise either resolves or rejects.
- * @template TT
- * @param {() => Promise<TT>} fn
- * @returns {Promise<TT>} promise
- */
-Promise.prototype.always = function (fn) {
-  return this.then(fn, fn);
-};
-
-/**
- * Create a promise which resolves when all provided promises are resolved,
- * and fails when any of the promises resolves.
- * @param {Promise[]} promises
- * @returns {Promise<any[], any>} promise
- */
-Promise.all = function (promises){
-  return new Promise(function (resolve, reject) {
-    var remaining = promises.length,
-        results = [];
-
-    if (remaining) {
-      promises.forEach(function (p, i) {
-        p.then(function (result) {
-          results[i] = result;
-          remaining--;
-          if (remaining == 0) {
-            resolve(results);
-          }
-        }, function (error) {
-          remaining = 0;
-          reject(error);
-        });
-      });
-    }
-    else {
-      resolve(results);
-    }
-  });
-};
-
-/**
- * Create a promise resolver
- * @returns {{promise: Promise, resolve: Function, reject: Function}} resolver
- */
-Promise.defer = function () {
-  var resolver = {};
-
-  resolver.promise = new Promise(function (resolve, reject) {
-    resolver.resolve = resolve;
-    resolver.reject = reject;
-  });
-
-  return resolver;
-};
-
-/**
- * Create a cancellation error
- * @param {String} [message]
- * @extends Error
- */
-function CancellationError(message) {
-  this.message = message || 'promise cancelled';
-  this.stack = (new Error()).stack;
-}
-
-CancellationError.prototype = new Error();
-CancellationError.prototype.constructor = Error;
-CancellationError.prototype.name = 'CancellationError';
-
-Promise.CancellationError = CancellationError;
-
-
-/**
- * Create a timeout error
- * @param {String} [message]
- * @extends Error
- */
-function TimeoutError(message) {
-  this.message = message || 'timeout exceeded';
-  this.stack = (new Error()).stack;
-}
-
-TimeoutError.prototype = new Error();
-TimeoutError.prototype.constructor = Error;
-TimeoutError.prototype.name = 'TimeoutError';
-
-Promise.TimeoutError = TimeoutError;
-
-
-exports.Promise = Promise;