@xylabs/threads/dist/neutral/observable-promise.mjs

Web workers & worker threads as simple as a function call

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/observable-promise.ts
import { Observable } from "observable-fns";
var doNothing = /* @__PURE__ */ __name(() => {
}, "doNothing");
var returnInput = /* @__PURE__ */ __name((input) => input, "returnInput");
var runDeferred = /* @__PURE__ */ __name((fn) => Promise.resolve().then(fn), "runDeferred");
function fail(error) {
  throw error;
}
__name(fail, "fail");
function isThenable(thing) {
  return thing && typeof thing.then === "function";
}
__name(isThenable, "isThenable");
var ObservablePromise = class _ObservablePromise extends Observable {
  static {
    __name(this, "ObservablePromise");
  }
  [Symbol.toStringTag] = "[object ObservablePromise]";
  initHasRun = false;
  fulfillmentCallbacks = [];
  rejectionCallbacks = [];
  firstValue;
  firstValueSet = false;
  rejection;
  state = "pending";
  constructor(init) {
    super((originalObserver) => {
      const self = this;
      const observer = {
        ...originalObserver,
        complete() {
          originalObserver.complete();
          self.onCompletion();
        },
        error(error) {
          originalObserver.error(error);
          self.onError(error);
        },
        next(value) {
          originalObserver.next(value);
          self.onNext(value);
        }
      };
      try {
        this.initHasRun = true;
        return init(observer);
      } catch (error) {
        observer.error(error);
      }
    });
  }
  onNext(value) {
    if (!this.firstValueSet) {
      this.firstValue = value;
      this.firstValueSet = true;
    }
  }
  onError(error) {
    this.state = "rejected";
    this.rejection = error;
    for (const onRejected of this.rejectionCallbacks) {
      runDeferred(() => onRejected(error));
    }
  }
  onCompletion() {
    this.state = "fulfilled";
    for (const onFulfilled of this.fulfillmentCallbacks) {
      runDeferred(() => onFulfilled(this.firstValue));
    }
  }
  then(onFulfilledRaw, onRejectedRaw) {
    const onFulfilled = onFulfilledRaw || returnInput;
    const onRejected = onRejectedRaw || fail;
    let onRejectedCalled = false;
    return new Promise((resolve, reject) => {
      const rejectionCallback = /* @__PURE__ */ __name((error) => {
        if (onRejectedCalled) return;
        onRejectedCalled = true;
        try {
          resolve(onRejected(error));
        } catch (anotherError) {
          reject(anotherError);
        }
      }, "rejectionCallback");
      const fulfillmentCallback = /* @__PURE__ */ __name((value) => {
        try {
          resolve(onFulfilled(value));
        } catch (ex) {
          const error = ex;
          rejectionCallback(error);
        }
      }, "fulfillmentCallback");
      if (!this.initHasRun) {
        this.subscribe({
          error: rejectionCallback
        });
      }
      if (this.state === "fulfilled") {
        return resolve(onFulfilled(this.firstValue));
      }
      if (this.state === "rejected") {
        onRejectedCalled = true;
        return resolve(onRejected(this.rejection));
      }
      this.fulfillmentCallbacks.push(fulfillmentCallback);
      this.rejectionCallbacks.push(rejectionCallback);
    });
  }
  catch(onRejected) {
    return this.then(void 0, onRejected);
  }
  finally(onCompleted) {
    const handler = onCompleted || doNothing;
    return this.then((value) => {
      handler();
      return value;
    }, () => handler());
  }
  static from(thing) {
    return isThenable(thing) ? new _ObservablePromise((observer) => {
      const onFulfilled = /* @__PURE__ */ __name((value) => {
        observer.next(value);
        observer.complete();
      }, "onFulfilled");
      const onRejected = /* @__PURE__ */ __name((error) => {
        observer.error(error);
      }, "onRejected");
      thing.then(onFulfilled, onRejected);
    }) : super.from(thing);
  }
};
export {
  ObservablePromise
};
//# sourceMappingURL=observable-promise.mjs.map