Решить обещание несколько раз

Я считаю, что у меня есть то, что вы ищете — собственный субъект, который ведет себя как ReplaySubject с одним буфером, но может быть сброшен. Этот код был адаптирован на основе именно этого класса, чтобы обеспечить необходимую вам функциональность.

const NOT_SET = Symbol();
export class ResettableSubject<T> extends Subject<T> {
  private value: T | NOT_SET = NOT_SET;

  constructor() {
    super();
  }

  /** Updates the subject's value and caches it. */
  override next(value: T): void {
    this.value = value;
    super.next(value);
  }

  /** Resets the cached value. */
  reset() {
    this.value = NOT_SET;
  }

  protected  _subscribe(subscriber: Subscriber<T>): Subscription {
    const subscription = this._innerSubscribe(subscriber);
    if (this.value !== NOT_SET) {
      subscriber.next(this.value);
    }
    return subscription;
  }
}

StackBlitz

В приведенном ниже примере подписка будет отправлять все значения, но обещания, созданные из firstValueFrom, будут отправлять только в том случае, если у субъекта есть значение, а сброс не очистил кэшированное значение.

const source$ = new ResettableSubject<number>();
// displays all values.
source$.subscribe(x => console.info(`from subscription ${x}`));
// will only display the first value once set.
firstValueFrom(source$).then(x => console.info(`first value before first next: ${x}`));
source$.next(1);
// will only display the first value.
firstValueFrom(source$).then(x => console.info(`first value displayed immediately: ${x}`));
source$.next(2); // the original subscription should update.
source$.reset(); // no future subscribers will see 2.
firstValueFrom(source$).then(x => console.info(`first value after reset ${x}`));
source$.next(3); // 3 is output by subscription and last promise.

Ваше использование будет похоже на пример ниже. Независимо от того, что устанавливает myAuthObservable, необходимо убедиться, что Auth не является неопределенным, или вы можете обновить класс ResettableSubject, чтобы он игнорировал неопределенные значения, передаваемые следующему методу.

const myAuthObservable = new ResettableSubject<Auth>();

emitter.on("start", async () => {
  // Only emits when myAuthObservable gets updated after reset below was called.
  const auth = await firstValueFrom(myAuthObservable);
  myAuthObservable.reset();
});

прочитав комментарий @Barmar, я в конце концов нашел простое решение, отличное от rxjs.

Похоже, вам нужен объект, который кэширует значение, к которому разрешается обещание, а затем возвращает это кэшированное значение при будущем использовании.

export class MultiResolve<T> {
  private readonly initialSymbol: symbol = Symbol();
  private currentValue: T | symbol = this.initialSymbol;
  private readonly resolvers: Array<(value: T) => void> = [];

  resolve(value: T): void {
    this.currentValue = value;
    for (const resolver of this.resolvers) {
      resolver(value);
    }
  }

  get promise(): Promise<T> {
    return new Promise(resolve => {
      if (this.currentValue !== this.initialSymbol) {
        resolve(this.currentValue as T);
      }
      this.resolvers.push(resolve);
    });
  }

  reset(): void {
    this.currentValue = this.initialSymbol;
  }
}

Применение:

const multiResolve = new MultiResolve<number>();

async function test() {
  console.info(await multiResolve.promise); // Will wait until the first resolve

  multiResolve.resolve(1);
  console.info(await multiResolve.promise); // Will immediately get 1

  multiResolve.resolve(undefined as any); // TypeScript requires an explicit cast to 'any' for undefined
  console.info(await multiResolve.promise); // Will immediately get undefined

  multiResolve.resolve(2);
  console.info(await multiResolve.promise); // Will immediately get 2
}

test();

setTimeout(() => {
  multiResolve.resolve(3); // Will immediately get 3 in the next await
}, 1000);