Make the live event proxy opt-in

With live access enabled by default every dispatched object was registered
with the client, which made even plain synchronous handlers block on the
browser. Those handlers are therefore run in a worker thread, where calling
set_state() fails with 'no running event loop' because scheduling a render
needs the layout's loop. Default the option to off so existing apps keep the
plain snapshot behaviour, and enable live access per handler or globally.

Author: Archmonger

CHANGELOG.md

@@ -41,7 +41,7 @@ Don't forget to remove deprecated code on each major release!
     - `debounce` waits until activity stops, then fires once. Default is 200 ms on `input`/`select`/`textarea`, 0 ms elsewhere.
     - `throttle` caps the rate how often an event is allowed to execute. No default; opt in per event.
 - Added a live event proxy which lets event handlers read properties from, and call methods on, the browser objects which triggered them rather than being limited to the snapshot sent along with the event. Handlers can `await event.target.value` or `await event.target.focus()` when asynchronous, or simply use `event.target.value` and `event.target.focus()` when synchronous. The new `reactpy.types.AsyncEvent` and `reactpy.types.SyncEvent` types describe these objects for editors and type checkers.
-    - This can be disabled entirely via `reactpy.config.REACTPY_ENABLE_EVENT_PROXY`.
+    - This is opt-in. Enable it globally with `reactpy.config.REACTPY_ENABLE_EVENT_PROXY`, or per handler with `EventHandler(fn, event_proxy=True)`.
     - Unanswered requests are bounded by `reactpy.config.REACTPY_EVENT_PROXY_TIMEOUT`, `reactpy.config.REACTPY_EVENT_PROXY_MAX_TIMEOUTS`, and `reactpy.config.REACTPY_EVENT_PROXY_MAX_DEPTH`.
 
 ### Changed

src/reactpy/config.py

@@ -141,18 +141,23 @@ def boolean(value: str | bool | int) -> bool:
 
 REACTPY_ENABLE_EVENT_PROXY = Option(
     "REACTPY_ENABLE_EVENT_PROXY",
-    default=True,
+    default=False,
     mutable=True,
     validator=boolean,
 )
 """Whether event handlers receive live client-backed event objects.
 
-When enabled (the default) the client keeps a reference to the dispatched JavaScript
-``Event`` around and lets the server read properties from, and call methods on, that
-object. Event handlers then receive a :class:`reactpy.types.SyncEvent` or
+Disabled by default. When enabled the client keeps a reference to the dispatched
+JavaScript ``Event`` around and lets the server read properties from, and call methods
+on, that object. Event handlers then receive a :class:`reactpy.types.SyncEvent` or
 :class:`reactpy.types.AsyncEvent` (both are ``dict`` subclasses holding the usual
 snapshot). When disabled, or when the client does not support live access, handlers
 receive the plain :class:`reactpy.types.Event` snapshot as they always have.
+
+Individual handlers can opt in with ``EventHandler(fn, event_proxy=True)`` without
+turning this on globally. Note that a *synchronous* handler which reads a live value
+is run in a worker thread so that it may block, and cannot safely call ``set_state``
+from there yet.
 """
 
 REACTPY_EVENT_PROXY_TIMEOUT = Option(

tests/test_core/test_event_proxy.py

@@ -31,6 +31,7 @@
     serialize_argument,
 )
 from reactpy.config import (
+    REACTPY_ENABLE_EVENT_PROXY,
     REACTPY_EVENT_PROXY_MAX_TIMEOUTS,
     REACTPY_EVENT_PROXY_TIMEOUT,
 )
@@ -450,7 +451,8 @@ def event_handlers_of(model: dict[str, Any]) -> dict[str, Any]:
     raise KeyError(msg)
 
 
-async def test_layout_hands_handlers_events_of_their_own_flavour():
+async def test_layout_hands_handlers_events_of_their_own_flavour(monkeypatch):
+    monkeypatch.setattr(REACTPY_ENABLE_EVENT_PROXY, "current", True)
     main_thread = threading.current_thread().name
     received: dict[str, tuple[Any, str, Any]] = {}
     objects = make_objects()
@@ -533,7 +535,8 @@ def MyComponent():
     assert client.requests == []
 
 
-async def test_merged_handlers_get_the_flavour_each_needs():
+async def test_merged_handlers_get_the_flavour_each_needs(monkeypatch):
+    monkeypatch.setattr(REACTPY_ENABLE_EVENT_PROXY, "current", True)
     received: dict[str, Any] = {}
 
     def sync_handler(args):

tests/test_core/test_serve.py

@@ -60,7 +60,6 @@ def make_events_and_expected_model():
                         "target": STATIC_EVENT_HANDLER.target,
                         "preventDefault": False,
                         "stopPropagation": False,
-                        "eventProxy": True,
                     }
                 },
             }