Unexpected missed subscription event.

[dts]

If you do a paired unsubscribe/resubscribe (how you might do it with a changing callback in a useEffect), you can miss non-synchronous events. See this test case:

import { proxy, subscribe } from "valtio";
import { describe, it, expect } from "vitest";

// Define a proxy state
const state = proxy({ count: 0 });

// Test suite for Valtio
describe("Valtio state change subscription", () => {
  it("should not notify subscriber after state change", async () => {
    let notified = false;

    // Subscribe to state changes
    const unsubscribe = subscribe(state, () => {
      notified = true;
    });

    // Change the state
    state.count += 1;

    subscribe(state, () => {
      notified = true;
    });
    unsubscribe();

    // Check that the subscriber was not notified
    await expect.poll(() => notified).toBe(true);  // <-- fails here, we are not notified.
  });
});

In fact, you won't be notified - because the unsubscribed one had the change in it, and it got blown away and not-sent, and the new subscription, after the fact, won't.

I think the right answer is for sync to default to true instead of false. It's totally reasonable to design around this behavior if you are opting in to it, but it's a bit tougher when you're not.

[dai-shi]

As you implied, this is the expected limited behavior with notifyInSync=false.
I guess the right solution is to document this behavior better somehow.

By the way, you might be interested in https://github.com/valtiojs/valtio-reactive.

[dts]

I've solved this problem at my org by defaulting notifyInSync to true, which is obviously easier than changing it in a library (huge breaking change - obvs).

[dai-shi]

Yeah, come to think of it, since React 18 has automatic batching, we can probably drop microtask batching in subscribe. We will consider it in v4 (not planned yet).