@barchart/common-js/dist/cjs/lang/promise.js

Library of common JavaScript utilities

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var promise_exports = {};
__export(promise_exports, {
  build: () => build,
  first: () => first,
  map: () => map,
  pipeline: () => pipeline,
  timeout: () => timeout
});
module.exports = __toCommonJS(promise_exports);
var assert = __toESM(require("./assert.js"));
async function timeout(promise, milliseconds, description) {
  assert.argumentIsRequired(promise, "promise", Promise, "Promise");
  assert.argumentIsRequired(milliseconds, "milliseconds", Number);
  assert.argumentIsOptional(description, "description", String);
  if (!(milliseconds > 0)) {
    throw 'Unable to configure promise timeout, the "milliseconds" argument must be positive';
  }
  let timeoutToken = null;
  const timeoutPromise = build((resolveCallback, rejectCallback) => {
    timeoutToken = setTimeout(() => {
      rejectCallback(description || `Promise timed out after ${milliseconds} milliseconds`);
    }, milliseconds);
  });
  const userPromise = (async () => {
    try {
      const result = await promise;
      if (timeoutToken !== null) {
        clearTimeout(timeoutToken);
      }
      return result;
    } catch (e) {
      if (timeoutToken !== null) {
        clearTimeout(timeoutToken);
      }
      throw e;
    }
  })();
  return Promise.race([userPromise, timeoutPromise]);
}
async function map(items, mapper, concurrency) {
  assert.argumentIsArray(items, "items");
  assert.argumentIsRequired(mapper, "mapper", Function);
  assert.argumentIsOptional(concurrency, "concurrency", Number);
  const c = Math.max(0, concurrency || 0);
  let mapPromise;
  if (c === 0 || items.length === 0) {
    mapPromise = Promise.all(items.map((item) => mapper(item)));
  } else {
    const total = items.length;
    let active = 0;
    let complete = 0;
    let failure = false;
    const results = Array.of(total);
    const executors = items.map((item, index) => {
      return async () => {
        const result = await mapper(item);
        results[index] = result;
      };
    });
    mapPromise = build((resolveCallback, rejectCallback) => {
      const execute = () => {
        if (!(executors.length > 0 && c > active && !failure)) {
          return;
        }
        active = active + 1;
        const executor = executors.shift();
        (async () => {
          try {
            await executor();
            if (failure) {
              return;
            }
            active = active - 1;
            complete = complete + 1;
            if (complete < total) {
              execute();
            } else {
              resolveCallback(results);
            }
          } catch (error) {
            failure = true;
            rejectCallback(error);
          }
        })();
        execute();
      };
      execute();
    });
  }
  return mapPromise;
}
async function pipeline(functions, input) {
  assert.argumentIsArray(functions, "functions", Function);
  let result = input;
  for (let i = 0; i < functions.length; i++) {
    result = await functions[i](result);
  }
  return result;
}
async function first(executors) {
  assert.argumentIsArray(executors, "executors", Function);
  let result = null;
  for (let i = 0; i < executors.length && result === null; i++) {
    try {
      result = await executors[i]();
    } catch {
      result = null;
    }
  }
  return result;
}
async function build(executor) {
  return new Promise((resolve, reject) => {
    try {
      executor(resolve, reject);
    } catch (e) {
      reject(e);
    }
  });
}