myty / composable-async / 3004645212

/**

 */

export class Composable<T> extends Promise<T> implements Promise<T> {

  /**

   */

  static create<T>(wrappedClass: T): AsyncComposable<T> {

    return new Composable(wrappedClass) as unknown as AsyncComposable<T>;

  }

  private _valuePromise: Promise<T>;

  private constructor(_wrappedClass: T) {

    super((_resolve, _reject) => {});

    this._valuePromise = Promise.resolve(_wrappedClass);

    this.then = (...args) => this._valuePromise.then(...args);

    Composable.keysOfObject(_wrappedClass).forEach((key) => {

      const callableFunc = _wrappedClass[key];

      if (!(callableFunc instanceof Function)) {

        return;

      }

      Object.defineProperty(this, key, {

        value: (...args: unknown[]) => {

          this._valuePromise = this._valuePromise.then((val: T) =>

            callableFunc.apply(val, args)

          );

          return this;

        },

      });

    });

  }

  // Private static methods

  private static keysOfObject<T>(obj: T): Array<keyof T> {

    const proto = Object.getPrototypeOf(obj);

    const keys = Object.keys(obj).concat(

      Object.getOwnPropertyNames(proto).filter((name) =>

        name !== "constructor"

      ),

    );

    return keys as Array<keyof T>;

  }

}