Allow passing Infinity to waitFor as timeout (#3215)

* Allow passing `Infinity` to as `waitFor` timeout

* Add changeset

* Add dev warning for negative timeouts

Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com>

* Format

* Add test

* Simplify casting situation in `waitFor`

* Update .changeset/cool-ducks-pretend.md

Co-authored-by: Mateusz Burzyński <mateuszburzynski@gmail.com>

.changeset/cool-ducks-pretend.md

@@ -0,0 +1,20 @@
+---
+'xstate': patch
+---
+
+Removing the timeout that's built in to `waitFor` is now supported by explicitly passing an `Infinity` value.
+
+Example usage:
+
+```js
+import { waitFor } from 'xstate/lib/waitFor';
+
+// This will
+const loggedInState = await waitFor(
+  loginService,
+  (state) => state.hasTag('loggedIn'),
+  { timeout: Infinity }
+);
+```
+
+This fixes a bug that causes `waitFor` to reject with an error immediately due to the behaviour of `setTimeout`.

packages/core/src/waitFor.ts

@@ -44,13 +44,21 @@ export function waitFor<TActorRef extends ActorRef<any, any>>(
   };
   return new Promise((res, rej) => {
     let done = false;
-    const handle = setTimeout(() => {
-      sub.unsubscribe();
-      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
-    }, resolvedOptions.timeout);
+    if (process.env.NODE_ENV !== 'production' && 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(() => {
+            sub.unsubscribe();
+            rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+          }, resolvedOptions.timeout);
 
     const dispose = () => {
-      clearTimeout(handle);
+      clearTimeout(handle!);
       done = true;
       sub?.unsubscribe();
     };

packages/core/test/waitFor.test.ts

@@ -46,6 +46,31 @@ describe('waitFor', () => {
     }
   });
 
+  it('should not reject immediately when passing Infinity as timeout', async () => {
+    const machine = createMachine({
+      initial: 'a',
+      states: {
+        a: {
+          on: { NEXT: 'b' }
+        },
+        b: {
+          on: { NEXT: 'c' }
+        },
+        c: {}
+      }
+    });
+    const service = interpret(machine).start();
+    const result = await Promise.race([
+      waitFor(service, (state) => state.matches('c'), {
+        timeout: Infinity
+      }),
+      new Promise((res) => setTimeout(res, 10)).then(() => 'timeout')
+    ]);
+
+    expect(result).toBe('timeout');
+    service.stop();
+  });
+
   it('should throw an error when reaching a final state that does not match the predicate', async () => {
     const machine = createMachine({
       initial: 'a',