@lumx/react 4.19.1-alpha.8 → 4.19.1-alpha.9

package/index.d.ts

@@ -2168,12 +2168,14 @@ declare namespace ComboboxProvider {
  * Hook to subscribe to a combobox event via the handle's subscriber system.
  *
  * Uses `useSyncExternalStore` (shim, for React 17 support) reading the handle's synchronous
- * `getSnapshot`. This lets React pick up changes during its own commit — notably the
- * `optionsChange` snapshot, which the handle refreshes synchronously while coalescing the actual
- * subscriber push into a microtask. Reading the snapshot during commit avoids a state update
- * landing in the microtask outside `act` (which unit tests report as an un-acted update).
+ * `getSnapshot` — the correct pattern for an external (non-React) store. It reads the current
+ * value during commit, so a consumer doesn't miss changes that happened between its render and its
+ * subscription (e.g. options registered by child effects before this consumer subscribed, since
+ * `optionsChange` is not replayed on subscribe), and it is tearing-safe under concurrent rendering.
  *
- * Re-subscribes when the handle changes (e.g. trigger mount/unmount).
+ * The handle dispatches synchronously, so the store update fires within the triggering render/event
+ * (inside React's `act` in tests) rather than a deferred microtask. Re-subscribes when the handle
+ * changes (e.g. trigger mount/unmount).
  */
 declare function useComboboxEvent<K extends keyof ComboboxEventMap>(event: K, initialValue: ComboboxEventMap[K]): ComboboxEventMap[K];
 

package/index.js

@@ -6415,29 +6415,6 @@ function setupListbox(handle, signal, notify, options) {
   return focusNav;
 }
 
-/**
- * Wrap `fn` so that, no matter how many times the returned function is called within the same
- * microtask cycle, `fn` only runs once at the end of that cycle.
- */
-function debounceMicrotask(fn) {
-  let running = false;
-  const debounced = () => {
-    if (!running) {
-      running = true;
-      queueMicrotask(() => {
-        if (running) {
-          running = false;
-          fn();
-        }
-      });
-    }
-  };
-  debounced.cancel = () => {
-    running = false;
-  };
-  return debounced;
-}
-
 /** Options for configuring the shared combobox behavior. */
 
 /**
@@ -6499,15 +6476,11 @@ function setupCombobox(callbacks, options, onTriggerAttach) {
   };
 
   /**
-   * Last value seen for each event, kept in sync so pull-based subscribers (React's
-   * `useSyncExternalStore` via `handle.getSnapshot`) can read the current value during their
-   * own render — without relying on a push landing inside a specific async boundary.
-   *
-   * `optionsChange` is special: its push is coalesced into a microtask (see
-   * `notifyVisibilityChange`), but its snapshot here is refreshed synchronously so React can
-   * pick up the change during the same commit that mounted the options, instead of via the
-   * later microtask (which would fire outside `act` in tests). All other events push
-   * synchronously, so caching in `notify` keeps their snapshot current.
+   * Last value dispatched for each event. Kept in sync so pull-based subscribers — React's
+   * `useSyncExternalStore` via {@link ComboboxHandle.getSnapshot} — can read the current value
+   * during their own render/commit. This lets React catch changes that happened between a
+   * consumer's render and its subscription (e.g. options registered by child effects before the
+   * consumer subscribed, since `optionsChange` is not replayed on subscribe).
    */
   const latestValues = {};
 
@@ -6532,48 +6505,25 @@ function setupCombobox(callbacks, options, onTriggerAttach) {
   }
 
   /**
-   * The current `optionsChange` snapshot. Refreshed synchronously by `refreshOptionsSnapshot`
-   * (so React can read it via `handle.getSnapshot` during the commit that mounts the options)
-   * and pushed to subscribers on a coalesced microtask by `flushVisibilityChange`
-   * (so Vue reacts once to the final state instead of hitting its recursive-update guard).
+   * Notify all registered sections and fire `optionsChange` if the visible option count changed
+   * or if the input value changed while the list is empty (so `emptyMessage` callbacks get
+   * the updated query string).
+   * Called whenever the set of visible options may have changed (option register/unregister, filter change).
    */
-  let optionsSnapshot;
-  /** The last snapshot actually pushed to subscribers, to avoid redundant notifications. */
-  let pushedOptionsSnapshot;
-
-  /**
-   * Recompute the `optionsChange` snapshot when the visible option count changed, or when the
-   * input value changed while the list is empty (so `emptyMessage` callbacks get the updated
-   * query string). Runs synchronously; a new object is created only when the value actually
-   * changes, keeping the reference stable for pull-based subscribers.
-   */
-  function refreshOptionsSnapshot() {
+  function notifyVisibilityChange() {
+    for (const [sectionElement] of sectionRegistrations) {
+      notifySection(sectionElement, sectionRegistrations, optionRegistrations);
+    }
     const visibleCount = getVisibleOptionCount();
     const inputValue = trigger?.value ?? '';
     const isEmpty = visibleCount === 0;
     if (visibleCount !== lastOptionsLength || isEmpty && inputValue !== lastInputValue) {
       lastOptionsLength = visibleCount;
       lastInputValue = inputValue;
-      optionsSnapshot = {
+      notify('optionsChange', {
         optionsLength: visibleCount,
         inputValue
-      };
-      latestValues.optionsChange = optionsSnapshot;
-    }
-  }
-
-  /**
-   * Notify all registered sections, push `optionsChange` when the snapshot changed since the last
-   * push, and re-evaluate `aria-expanded`. Coalesced into a microtask so many option
-   * registrations in one tick collapse into a single subscriber notification.
-   */
-  const flushVisibilityChange = debounceMicrotask(() => {
-    for (const [sectionElement] of sectionRegistrations) {
-      notifySection(sectionElement, sectionRegistrations, optionRegistrations);
-    }
-    if (optionsSnapshot !== pushedOptionsSnapshot) {
-      pushedOptionsSnapshot = optionsSnapshot;
-      notify('optionsChange', optionsSnapshot);
+      });
     }
 
     // Re-evaluate aria-expanded when the combobox is open — visible content may have
@@ -6581,16 +6531,6 @@ function setupCombobox(callbacks, options, onTriggerAttach) {
     if (isOpenState) {
       trigger?.setAttribute('aria-expanded', String(hasVisibleContent()));
     }
-  });
-
-  /**
-   * Called whenever the set of visible options may have changed (option register/unregister,
-   * filter change). Refreshes the snapshot synchronously (for pull-based/React subscribers) then
-   * schedules the coalesced push (for push-based/Vue subscribers).
-   */
-  function notifyVisibilityChange() {
-    refreshOptionsSnapshot();
-    flushVisibilityChange();
   }
 
   // ── Skeleton loading tracking ──────────────────────────────
@@ -6988,8 +6928,6 @@ function setupCombobox(callbacks, options, onTriggerAttach) {
       lastOptionsLength = 0;
       lastInputValue = '';
       lastLoadingState = false;
-      optionsSnapshot = undefined;
-      pushedOptionsSnapshot = undefined;
       // Drop cached snapshots so `getSnapshot` doesn't return stale values after destroy.
       for (const key of Object.keys(latestValues)) {
         delete latestValues[key];
@@ -6997,7 +6935,6 @@ function setupCombobox(callbacks, options, onTriggerAttach) {
       optionRegistrations.clear();
       sectionRegistrations.clear();
       skeletonCount = 0;
-      flushVisibilityChange.cancel();
       clearTimeout(loadingTimer);
       announcementSent = false;
       // Clear all subscribers
@@ -7540,12 +7477,14 @@ function useComboboxContext() {
  * Hook to subscribe to a combobox event via the handle's subscriber system.
  *
  * Uses `useSyncExternalStore` (shim, for React 17 support) reading the handle's synchronous
- * `getSnapshot`. This lets React pick up changes during its own commit — notably the
- * `optionsChange` snapshot, which the handle refreshes synchronously while coalescing the actual
- * subscriber push into a microtask. Reading the snapshot during commit avoids a state update
- * landing in the microtask outside `act` (which unit tests report as an un-acted update).
- *
- * Re-subscribes when the handle changes (e.g. trigger mount/unmount).
+ * `getSnapshot` — the correct pattern for an external (non-React) store. It reads the current
+ * value during commit, so a consumer doesn't miss changes that happened between its render and its
+ * subscription (e.g. options registered by child effects before this consumer subscribed, since
+ * `optionsChange` is not replayed on subscribe), and it is tearing-safe under concurrent rendering.
+ *
+ * The handle dispatches synchronously, so the store update fires within the triggering render/event
+ * (inside React's `act` in tests) rather than a deferred microtask. Re-subscribes when the handle
+ * changes (e.g. trigger mount/unmount).
  */
 function useComboboxEvent(event, initialValue) {
   const {