Merge remote-tracking branch 'origin/next' into v5/sta-3440-remove-au…

…toforward

# Conflicts:
#	packages/core/test/invoke.test.ts

.changeset/lemon-dancers-repeat.md

@@ -0,0 +1,13 @@
+---
+'xstate': major
+---
+
+The `actor.onTransition(...)` method has been removed in favor of `.subscribe(...)`
+
+```diff
+ const actor = interpret(machine)
+-  .onTransition(...)
+-  .start();
++actor.subscribe(...);
++actor.start();
+```

.changeset/lemon-mails-smoke.md

@@ -0,0 +1,19 @@
+---
+'xstate': major
+---
+
+Observing an actor via `actor.subscribe(...)` no longer immediately receives the current snapshot. Instead, the current snapshot can be read from `actor.getSnapshot()`, and observers will receive snapshots only when a transition in the actor occurs.
+
+```ts
+const actor = interpret(machine);
+actor.start();
+
+// Late subscription; will not receive the current snapshot
+actor.subscribe((state) => {
+  // Only called when the actor transitions
+  console.log(state);
+});
+
+// Instead, current snapshot can be read at any time
+console.log(actor.getSnapshot());
+```

examples/todo-mvc-svelte/src/Todos.svelte

@@ -7,7 +7,6 @@
   import { useMachine } from '@xstate/svelte';
 
   const { state, send, service } = useMachine(todosMachine, { devTools: true });
-  // service.onTransition((state) => console.log(state));
 
   $: ({ todo, todos, filter } = $state.context);
 

packages/core/src/interpreter.ts

@@ -215,25 +215,6 @@ export class Interpreter<
     }
   }
 
-  /*
-   * Adds a listener that is notified whenever a state transition happens. The listener is called with
-   * the next state and the event object that caused the state transition.
-   *
-   * @param listener The state listener
-   * @deprecated Use .subscribe(listener) instead
-   */
-  public onTransition(listener: SnapshotListener<TBehavior>): this {
-    const observer = toObserver(listener);
-    this.observers.add(observer);
-
-    // Send current state to listener
-    if (this.status === ActorStatus.Running) {
-      observer.next?.(this.getSnapshot());
-    }
-
-    return this;
-  }
-
   public subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
   public subscribe(
     nextListener?: (state: SnapshotFrom<TBehavior>) => void,
@@ -255,11 +236,6 @@ export class Interpreter<
 
     this.observers.add(observer);
 
-    // Send current state to listener
-    if (this.status !== ActorStatus.NotStarted) {
-      observer.next?.(this.getSnapshot());
-    }
-
     if (this.status === ActorStatus.Stopped) {
       observer.complete?.();
       this.observers.delete(observer);

packages/core/src/waitFor.ts

@@ -65,13 +65,18 @@ export function waitFor<TActorRef extends ActorRef<any, any>>(
       sub?.unsubscribe();
     };
 
+    function checkEmitted(emitted: SnapshotFrom<TActorRef>) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+
     const sub = actorRef.subscribe({
-      next: (emitted) => {
-        if (predicate(emitted)) {
-          dispose();
-          res(emitted);
-        }
-      },
+      next: checkEmitted,
       error: (err) => {
         dispose();
         rej(err);

packages/core/test/actor.test.ts

@@ -734,11 +734,11 @@ describe('actors', () => {
       }
     });
 
-    interpret(startMachine)
-      .onTransition(() => {
-        expect(count).toEqual(1);
-      })
-      .start();
+    const actor = interpret(startMachine);
+    actor.subscribe(() => {
+      expect(count).toEqual(1);
+    });
+    actor.start();
   });
 
   it('should only spawn an actor in an initial state of a child that gets invoked in the initial state of a parent when the parent gets started', () => {
@@ -868,13 +868,13 @@ describe('actors', () => {
         }
       });
 
-      const countService = interpret(countMachine)
-        .onTransition((state) => {
-          if (state.context.count?.getSnapshot() === 2) {
-            done();
-          }
-        })
-        .start();
+      const countService = interpret(countMachine);
+      countService.subscribe((state) => {
+        if (state.context.count?.getSnapshot() === 2) {
+          done();
+        }
+      });
+      countService.start();
 
       countService.send({ type: 'INC' });
       countService.send({ type: 'INC' });

packages/core/test/assign.test.ts

@@ -398,18 +398,12 @@ describe('assign meta', () => {
       }
     });
 
-    let state: any;
-
-    const service = interpret(parentMachine)
-      .onTransition((s) => {
-        state = s;
-      })
-      .start();
+    const service = interpret(parentMachine).start();
 
     service.send({ type: 'PING_CHILD' });
     service.send({ type: 'PING_CHILD' });
 
-    expect(state.context).toMatchInlineSnapshot(`
+    expect(service.getSnapshot().context).toMatchInlineSnapshot(`
       {
         "eventLog": [
           {

packages/core/test/event.test.ts

@@ -69,14 +69,14 @@ describe('SCXML events', () => {
       }
     });
 
-    interpret(machine)
-      .onTransition((state) => {
-        if (state.done) {
-          expect(state.context.childOrigin).toEqual('callback_child');
-          done();
-        }
-      })
-      .start();
+    const actor = interpret(machine);
+    actor.subscribe((state) => {
+      if (state.done) {
+        expect(state.context.childOrigin).toEqual('callback_child');
+        done();
+      }
+    });
+    actor.start();
   });
 
   it('respond() should be able to respond to sender', (done) => {

packages/core/test/final.test.ts

@@ -187,12 +187,11 @@ describe('final states', () => {
       }
     });
 
-    let _context: any;
-
     const service = interpret(machine)
-      .onTransition((state) => (_context = state.context))
       .onDone(() => {
-        expect(_context).toEqual({ revealedSecret: 'the secret' });
+        expect(service.getSnapshot().context).toEqual({
+          revealedSecret: 'the secret'
+        });
         done();
       })
       .start();

packages/core/test/input.test.ts

@@ -141,12 +141,16 @@ describe('input', () => {
 
     const observableActor = interpret(observableBehavior, {
       input: { count: 42 }
-    }).start();
+    });
 
-    observableActor.subscribe((state) => {
+    const sub = observableActor.subscribe((state) => {
+      if (state?.count !== 42) return;
       expect(state).toEqual({ count: 42 });
       done();
+      sub.unsubscribe();
     });
+
+    observableActor.start();
   });
 
   it('should create a callback actor with input', (done) => {