typed-utilities/build/AsyncResult.js

Strongly typed general purpose utilities

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AsyncResult = void 0;
var AsyncResultTag;

(function (AsyncResultTag) {
  AsyncResultTag["Pending"] = "pending";
  AsyncResultTag["Resolved"] = "resolved";
  AsyncResultTag["Rejected"] = "rejected";
})(AsyncResultTag || (AsyncResultTag = {}));

function isPending(result) {
  return result[0] === AsyncResultTag.Pending;
}

function assertPending(result, message) {
  if (!isPending(result)) {
    throw new TypeError(message ?? `asyncValue should be 'pending'`);
  }
}

function isRejected(result) {
  return result[0] === AsyncResultTag.Rejected;
}

function assertRejected(result, message) {
  if (!isRejected(result)) {
    throw new TypeError(message ?? `asyncValue should be 'rejected'`);
  }
}

function isResolved(result) {
  return result[0] === AsyncResultTag.Resolved;
}

function assertResolved(result, message) {
  if (!isResolved(result)) {
    throw new TypeError(message ?? `asyncValue should be 'resolved'`);
  }
}

const resolvedValue = resolved => resolved[1];

const rejectedError = rejected => rejected[1];

const dependencyList = result => match(result, {
  pending: () => [AsyncResultTag.Pending, null, null],
  rejected: error => [AsyncResultTag.Rejected, null, error],
  resolved: value => [AsyncResultTag.Resolved, value, null]
});

const is = {
  pending: isPending,
  rejected: isRejected,
  resolved: isResolved
};
const assert = {
  pending: assertPending,
  rejected: assertRejected,
  resolved: assertResolved
};
const of = {
  pending: () => [AsyncResultTag.Pending],
  rejected: error => [AsyncResultTag.Rejected, error],
  resolved: value => [AsyncResultTag.Resolved, value]
};
const to = {
  resolvedValue,
  rejectedError,
  dependencyList
};

const match = (result, match) => isPending(result) ? match.pending() : isRejected(result) ? match.rejected(to.rejectedError(result)) : match.resolved(to.resolvedValue(result));

const join = results => {
  const pending = results.filter(is.pending);
  const rejected = results.filter(is.rejected);
  const resolved = results.filter(is.resolved);

  if (pending.length > 0) {
    return of.pending();
  }

  if (rejected.length > 0) {
    return of.rejected(new AggregateError(rejected.map(to.rejectedError)));
  }

  return of.resolved(resolved.map(to.resolvedValue));
};

const pipe = (result, fn) => match(result, {
  pending: of.pending,
  rejected: of.rejected,
  resolved: value => {
    try {
      return of.resolved(fn(value));
    } catch (error) {
      return of.rejected(error);
    }
  }
}); // "catch" identifier is reserved


const $catch = (result, fn) => AsyncResult.match(result, {
  pending: () => AsyncResult.of.pending(),
  rejected: outerError => {
    try {
      return of.resolved(fn(outerError));
    } catch (innerError) {
      return of.rejected(innerError);
    }
  },
  resolved: value => AsyncResult.of.resolved(value)
});

const AsyncResult = {
  Tag: AsyncResultTag,
  is,
  assert,
  of,
  to,
  match,
  join,
  pipe,
  catch: $catch
};
exports.AsyncResult = AsyncResult;
//# sourceMappingURL=AsyncResult.js.map