matrix-react-sdk/lib/utils/promise.js

SDK for matrix.org using React

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.batch = batch;
exports.retry = retry;
exports.timeout = timeout;
/*
Copyright 2024 New Vector Ltd.
Copyright 2019, 2020 The Matrix.org Foundation C.I.C.

SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/

// Returns a promise which resolves when the input promise resolves with its value
// or when the timeout of ms is reached with the value of given timeoutValue
async function timeout(promise, timeoutValue, ms) {
  const timeoutPromise = new Promise(resolve => {
    const timeoutId = window.setTimeout(resolve, ms, timeoutValue);
    promise.then(() => {
      clearTimeout(timeoutId);
    });
  });
  return Promise.race([promise, timeoutPromise]);
}

// Helper method to retry a Promise a given number of times or until a predicate fails
async function retry(fn, num, predicate) {
  let lastErr;
  for (let i = 0; i < num; i++) {
    try {
      const v = await fn();
      // If `await fn()` throws then we won't reach here
      return v;
    } catch (err) {
      if (predicate && !predicate(err)) {
        throw err;
      }
      lastErr = err;
    }
  }
  throw lastErr;
}

/**
 * Batch promises into groups of a given size.
 * Execute the promises in parallel, but wait for all promises in a batch to resolve before moving to the next batch.
 * @param funcs - The promises to batch
 * @param batchSize - The number of promises to execute in parallel
 */
async function batch(funcs, batchSize) {
  const results = [];
  for (let i = 0; i < funcs.length; i += batchSize) {
    const batch = funcs.slice(i, i + batchSize);
    results.push(...(await Promise.all(batch.map(f => f()))));
  }
  return results;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ0aW1lb3V0IiwicHJvbWlzZSIsInRpbWVvdXRWYWx1ZSIsIm1zIiwidGltZW91dFByb21pc2UiLCJQcm9taXNlIiwicmVzb2x2ZSIsInRpbWVvdXRJZCIsIndpbmRvdyIsInNldFRpbWVvdXQiLCJ0aGVuIiwiY2xlYXJUaW1lb3V0IiwicmFjZSIsInJldHJ5IiwiZm4iLCJudW0iLCJwcmVkaWNhdGUiLCJsYXN0RXJyIiwiaSIsInYiLCJlcnIiLCJiYXRjaCIsImZ1bmNzIiwiYmF0Y2hTaXplIiwicmVzdWx0cyIsImxlbmd0aCIsInNsaWNlIiwicHVzaCIsImFsbCIsIm1hcCIsImYiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvcHJvbWlzZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuQ29weXJpZ2h0IDIwMjQgTmV3IFZlY3RvciBMdGQuXG5Db3B5cmlnaHQgMjAxOSwgMjAyMCBUaGUgTWF0cml4Lm9yZyBGb3VuZGF0aW9uIEMuSS5DLlxuXG5TUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQUdQTC0zLjAtb25seSBPUiBHUEwtMy4wLW9ubHlcblBsZWFzZSBzZWUgTElDRU5TRSBmaWxlcyBpbiB0aGUgcmVwb3NpdG9yeSByb290IGZvciBmdWxsIGRldGFpbHMuXG4qL1xuXG4vLyBSZXR1cm5zIGEgcHJvbWlzZSB3aGljaCByZXNvbHZlcyB3aGVuIHRoZSBpbnB1dCBwcm9taXNlIHJlc29sdmVzIHdpdGggaXRzIHZhbHVlXG4vLyBvciB3aGVuIHRoZSB0aW1lb3V0IG9mIG1zIGlzIHJlYWNoZWQgd2l0aCB0aGUgdmFsdWUgb2YgZ2l2ZW4gdGltZW91dFZhbHVlXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gdGltZW91dDxULCBZPihwcm9taXNlOiBQcm9taXNlPFQ+LCB0aW1lb3V0VmFsdWU6IFksIG1zOiBudW1iZXIpOiBQcm9taXNlPFQgfCBZPiB7XG4gICAgY29uc3QgdGltZW91dFByb21pc2UgPSBuZXcgUHJvbWlzZTxUIHwgWT4oKHJlc29sdmUpID0+IHtcbiAgICAgICAgY29uc3QgdGltZW91dElkID0gd2luZG93LnNldFRpbWVvdXQocmVzb2x2ZSwgbXMsIHRpbWVvdXRWYWx1ZSk7XG4gICAgICAgIHByb21pc2UudGhlbigoKSA9PiB7XG4gICAgICAgICAgICBjbGVhclRpbWVvdXQodGltZW91dElkKTtcbiAgICAgICAgfSk7XG4gICAgfSk7XG5cbiAgICByZXR1cm4gUHJvbWlzZS5yYWNlKFtwcm9taXNlLCB0aW1lb3V0UHJvbWlzZV0pO1xufVxuXG4vLyBIZWxwZXIgbWV0aG9kIHRvIHJldHJ5IGEgUHJvbWlzZSBhIGdpdmVuIG51bWJlciBvZiB0aW1lcyBvciB1bnRpbCBhIHByZWRpY2F0ZSBmYWlsc1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJldHJ5PFQsIEUgZXh0ZW5kcyBFcnJvcj4oXG4gICAgZm46ICgpID0+IFByb21pc2U8VD4sXG4gICAgbnVtOiBudW1iZXIsXG4gICAgcHJlZGljYXRlPzogKGU6IEUpID0+IGJvb2xlYW4sXG4pOiBQcm9taXNlPFQ+IHtcbiAgICBsZXQgbGFzdEVyciE6IGFueTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IG51bTsgaSsrKSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICBjb25zdCB2ID0gYXdhaXQgZm4oKTtcbiAgICAgICAgICAgIC8vIElmIGBhd2FpdCBmbigpYCB0aHJvd3MgdGhlbiB3ZSB3b24ndCByZWFjaCBoZXJlXG4gICAgICAgICAgICByZXR1cm4gdjtcbiAgICAgICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICAgICAgICBpZiAocHJlZGljYXRlICYmICFwcmVkaWNhdGUoZXJyIGFzIEUpKSB7XG4gICAgICAgICAgICAgICAgdGhyb3cgZXJyO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgbGFzdEVyciA9IGVycjtcbiAgICAgICAgfVxuICAgIH1cbiAgICB0aHJvdyBsYXN0RXJyO1xufVxuXG4vKipcbiAqIEJhdGNoIHByb21pc2VzIGludG8gZ3JvdXBzIG9mIGEgZ2l2ZW4gc2l6ZS5cbiAqIEV4ZWN1dGUgdGhlIHByb21pc2VzIGluIHBhcmFsbGVsLCBidXQgd2FpdCBmb3IgYWxsIHByb21pc2VzIGluIGEgYmF0Y2ggdG8gcmVzb2x2ZSBiZWZvcmUgbW92aW5nIHRvIHRoZSBuZXh0IGJhdGNoLlxuICogQHBhcmFtIGZ1bmNzIC0gVGhlIHByb21pc2VzIHRvIGJhdGNoXG4gKiBAcGFyYW0gYmF0Y2hTaXplIC0gVGhlIG51bWJlciBvZiBwcm9taXNlcyB0byBleGVjdXRlIGluIHBhcmFsbGVsXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBiYXRjaDxUPihmdW5jczogQXJyYXk8KCkgPT4gUHJvbWlzZTxUPj4sIGJhdGNoU2l6ZTogbnVtYmVyKTogUHJvbWlzZTxUW10+IHtcbiAgICBjb25zdCByZXN1bHRzOiBUW10gPSBbXTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGZ1bmNzLmxlbmd0aDsgaSArPSBiYXRjaFNpemUpIHtcbiAgICAgICAgY29uc3QgYmF0Y2ggPSBmdW5jcy5zbGljZShpLCBpICsgYmF0Y2hTaXplKTtcbiAgICAgICAgcmVzdWx0cy5wdXNoKC4uLihhd2FpdCBQcm9taXNlLmFsbChiYXRjaC5tYXAoKGYpID0+IGYoKSkpKSk7XG4gICAgfVxuICAgIHJldHVybiByZXN1bHRzO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUVBO0FBQ0E7QUFDTyxlQUFlQSxPQUFPQSxDQUFPQyxPQUFtQixFQUFFQyxZQUFlLEVBQUVDLEVBQVUsRUFBa0I7RUFDbEcsTUFBTUMsY0FBYyxHQUFHLElBQUlDLE9BQU8sQ0FBU0MsT0FBTyxJQUFLO0lBQ25ELE1BQU1DLFNBQVMsR0FBR0MsTUFBTSxDQUFDQyxVQUFVLENBQUNILE9BQU8sRUFBRUgsRUFBRSxFQUFFRCxZQUFZLENBQUM7SUFDOURELE9BQU8sQ0FBQ1MsSUFBSSxDQUFDLE1BQU07TUFDZkMsWUFBWSxDQUFDSixTQUFTLENBQUM7SUFDM0IsQ0FBQyxDQUFDO0VBQ04sQ0FBQyxDQUFDO0VBRUYsT0FBT0YsT0FBTyxDQUFDTyxJQUFJLENBQUMsQ0FBQ1gsT0FBTyxFQUFFRyxjQUFjLENBQUMsQ0FBQztBQUNsRDs7QUFFQTtBQUNPLGVBQWVTLEtBQUtBLENBQ3ZCQyxFQUFvQixFQUNwQkMsR0FBVyxFQUNYQyxTQUE2QixFQUNuQjtFQUNWLElBQUlDLE9BQWE7RUFDakIsS0FBSyxJQUFJQyxDQUFDLEdBQUcsQ0FBQyxFQUFFQSxDQUFDLEdBQUdILEdBQUcsRUFBRUcsQ0FBQyxFQUFFLEVBQUU7SUFDMUIsSUFBSTtNQUNBLE1BQU1DLENBQUMsR0FBRyxNQUFNTCxFQUFFLENBQUMsQ0FBQztNQUNwQjtNQUNBLE9BQU9LLENBQUM7SUFDWixDQUFDLENBQUMsT0FBT0MsR0FBRyxFQUFFO01BQ1YsSUFBSUosU0FBUyxJQUFJLENBQUNBLFNBQVMsQ0FBQ0ksR0FBUSxDQUFDLEVBQUU7UUFDbkMsTUFBTUEsR0FBRztNQUNiO01BQ0FILE9BQU8sR0FBR0csR0FBRztJQUNqQjtFQUNKO0VBQ0EsTUFBTUgsT0FBTztBQUNqQjs7QUFFQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDTyxlQUFlSSxLQUFLQSxDQUFJQyxLQUE4QixFQUFFQyxTQUFpQixFQUFnQjtFQUM1RixNQUFNQyxPQUFZLEdBQUcsRUFBRTtFQUN2QixLQUFLLElBQUlOLENBQUMsR0FBRyxDQUFDLEVBQUVBLENBQUMsR0FBR0ksS0FBSyxDQUFDRyxNQUFNLEVBQUVQLENBQUMsSUFBSUssU0FBUyxFQUFFO0lBQzlDLE1BQU1GLEtBQUssR0FBR0MsS0FBSyxDQUFDSSxLQUFLLENBQUNSLENBQUMsRUFBRUEsQ0FBQyxHQUFHSyxTQUFTLENBQUM7SUFDM0NDLE9BQU8sQ0FBQ0csSUFBSSxDQUFDLElBQUksTUFBTXRCLE9BQU8sQ0FBQ3VCLEdBQUcsQ0FBQ1AsS0FBSyxDQUFDUSxHQUFHLENBQUVDLENBQUMsSUFBS0EsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztFQUMvRDtFQUNBLE9BQU9OLE9BQU87QUFDbEIiLCJpZ25vcmVMaXN0IjpbXX0=