Function waitFor

packages/core/src/waitFor.ts:42–129

(
  actorRef: TActorRef,
  predicate: (emitted: SnapshotFrom<TActorRef>) => boolean,
  options?: Partial<WaitForOptions>
)

 *   the condition
 */
export function waitFor<TActorRef extends AnyActorRef>(
  actorRef: TActorRef,
  predicate: (emitted: SnapshotFrom<TActorRef>) => boolean,
  options?: Partial<WaitForOptions>
): Promise<SnapshotFrom<TActorRef>> {
  const resolvedOptions: WaitForOptions = {
    ...defaultWaitForOptions,
    ...options
  };
  return new Promise((res, rej) => {
    const { signal } = resolvedOptions;
    if (signal?.aborted) {
      // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
      rej(signal.reason);
      return;
    }
    let done = false;
    if (isDevelopment && resolvedOptions.timeout < 0) {
      console.error(
        '`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.'
      );
    }
    const handle =
      resolvedOptions.timeout === Infinity
        ? undefined
        : setTimeout(() => {
            dispose();
            rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
          }, resolvedOptions.timeout);

    const dispose = () => {
      clearTimeout(handle);
      done = true;
      sub?.unsubscribe();
      if (abortListener) {
        signal!.removeEventListener('abort', abortListener);
      }
    };

    function checkEmitted(emitted: SnapshotFrom<TActorRef>) {
      if (predicate(emitted)) {
        dispose();
        res(emitted);
      }
    }

    /**
     * If the `signal` option is provided, this will be the listener for its
     * `abort` event
     */
    let abortListener: () => void | undefined;
    // eslint-disable-next-line prefer-const
    let sub: Subscription | undefined; // avoid TDZ when disposing synchronously

    // See if the current snapshot already matches the predicate
    checkEmitted(actorRef.getSnapshot());
    if (done) {
      return;