@krist7599555/ts-async-result/dist/async-result.js

[](https://www.npmjs.com/package/@krist7599555/ts-async-result)

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
const _AsyncResult = class _AsyncResult {
  constructor(fn) {
    __publicField(this, "promise");
    this.promise = new Promise(fn);
  }
  static resolve(value) {
    return new _AsyncResult(async (res, rej) => {
      try {
        res(await value);
      } catch (err) {
        rej(err);
      }
    });
  }
  static reject(error) {
    return new _AsyncResult((_res, rej) => rej(error));
  }
  static from(data) {
    return new _AsyncResult(async (res, rej) => {
      try {
        if (data instanceof Function) {
          res(await data());
        } else {
          res(await data);
        }
      } catch (err) {
        rej(err);
      }
    });
  }
  toPromise() {
    return this.promise;
  }
  then(fn_ok, fn_err = (v) => {
    throw v;
  }) {
    return new _AsyncResult(async (resolve, reject) => {
      try {
        await this.promise.then(
          async (val) => resolve(await fn_ok(val)),
          async (err) => resolve(await fn_err(err))
        );
      } catch (err) {
        reject(err);
      }
    });
  }
  catch(fn) {
    return new _AsyncResult(async (resolve, reject) => {
      try {
        resolve(await this.promise);
      } catch (err) {
        try {
          resolve(await fn(err));
        } catch (err2) {
          reject(await err2);
        }
      }
    });
  }
  flatten() {
    return this.then(
      (ok) => _AsyncResult.resolve(ok),
      (err) => _AsyncResult.resolve(err)
    );
  }
  swap() {
    return this.then(
      (ok) => _AsyncResult.reject(ok),
      (err) => _AsyncResult.resolve(err)
    );
  }
  pair() {
    return this.then(
      (val) => [val, void 0],
      (err) => [void 0, err]
    );
  }
  guard(fn, on_false) {
    return this.then(
      (value) => fn(value) ? _AsyncResult.resolve(value) : _AsyncResult.reject(on_false instanceof Function ? on_false(value) : on_false),
      (err) => _AsyncResult.reject(err)
    );
  }
  mapErr(fn) {
    return new _AsyncResult(async (res, rej) => {
      try {
        return res(await this);
      } catch (err) {
        return rej(await fn(err));
      }
    });
  }
  tap(fn) {
    return this.then(async (val) => {
      await fn(val);
      return val;
    });
  }
  tapErr(fn) {
    return this.mapErr(async (err) => {
      await fn(err);
      return err;
    });
  }
  fallback(value) {
    return this.then(
      (ok) => Promise.resolve(ok),
      () => Promise.resolve(value)
    );
  }
  static all(data) {
    if (Array.isArray(data)) {
      return _AsyncResult.from(() => Promise.all(data));
    } else if (typeof data === "object" && data != null) {
      return _AsyncResult.resolve(data).pipe(
        (o) => Object.entries(o),
        (o) => o.map(async ([k, v]) => [k, await v]),
        (o) => Promise.all(o),
        (o) => Object.fromEntries(o),
        (o) => o
      );
    } else {
      return _AsyncResult.reject(
        new Error(`AsyncResult.all expect to pass Array or Object but got ${typeof data}`)
      );
    }
  }
  pipe(...fns) {
    return new _AsyncResult(async (resolve, reject) => {
      try {
        let data = await this;
        for (const fn of fns) {
          data = await fn(data);
        }
        return resolve(data);
      } catch (err) {
        return reject(err);
      }
    });
  }
};
__publicField(_AsyncResult, "NEVER", new _AsyncResult(() => {
}));
__publicField(_AsyncResult, "EMPTY", _AsyncResult.resolve(void 0));
let AsyncResult = _AsyncResult;
export {
  AsyncResult
};