@jsenv/navi 0.29.92 → 0.29.94

package/dist/jsenv_navi.js

@@ -24208,12 +24208,25 @@ const useUIStateController = (
       } = controlInfo;
       controller.value = value;
       controller.defaultValue = defaultValue;
+      // An optimistic control with work in flight keeps the user's intent on
+      // screen: an incoming external state is the echo of an intermediate
+      // commit (the first of two queued toggles landing), and the queued
+      // request about to go out was built on top of the UI state —
+      // overwriting it would both flash the superseded value and send it.
+      // `controller.state` is still taken below: it is the last known good
+      // state, the rollback target if the chain fails.
+      const optimisticWorkInFlight = Boolean(
+        props.optimistic &&
+        (controller.actionInFlight || controller.queuedActionAllowedEvent),
+      );
       if (hasStateProp) {
         controller.hasStateProp = true;
         const currentState = controller.state;
         if (!compareTwoJsValues(state, currentState)) {
           controller.state = state;
-          controller.setUIState(state, new CustomEvent("state_prop_change"));
+          if (!optimisticWorkInFlight) {
+            controller.setUIState(state, new CustomEvent("state_prop_change"));
+          }
         }
       } else {
         if (controller.hasStateProp) {
@@ -24230,10 +24243,12 @@ const useUIStateController = (
           const currentState = controller.state;
           if (!compareTwoJsValues(stateFromSignal, currentState)) {
             controller.state = stateFromSignal;
-            controller.setUIState(
-              stateFromSignal,
-              new CustomEvent("state_prop_change"),
-            );
+            if (!optimisticWorkInFlight) {
+              controller.setUIState(
+                stateFromSignal,
+                new CustomEvent("state_prop_change"),
+              );
+            }
           }
         }
       }
@@ -24664,7 +24679,7 @@ const useUIGroupStateController = (
 
       // onChange and applyState live inside init so they close over the stable
       // signals/pubsub without needing external refs.
-      const onChange = (e, { notifyExternal }) => {
+      const onChange = (e, { notifyExternal, actingChild }) => {
         if (groupIsRenderingRef.current) {
           // Held until the layout effect below, WITH what it asked for: a child
           // whose bound signal was written from the outside changes during the
@@ -24677,6 +24692,7 @@ const useUIGroupStateController = (
             e,
             notifyExternal:
               pendingChange?.notifyExternal === true ? true : notifyExternal,
+            actingChild,
           };
           return;
         }
@@ -24700,6 +24716,21 @@ const useUIGroupStateController = (
           // Somebody answered: what the group is worth is what its children say
           // between them, from here on.
           controller.stateGivenFromAbove = false;
+          if (resolvedDistributeChildStates) {
+            // A group answering for all its children at once holds ONE answer
+            // its children are views OF, rather than a value that IS what they
+            // said: a list saying who plays and four seats saying who sits
+            // where. One view speaking moves the answer, so the others have to
+            // show it again — the same rule as a child arriving after the value
+            // did, for a child that was there when the value moved without it.
+            // The one that just acted is left alone: it is where the user put
+            // it.
+            controller.placeChildrenUIState(
+              groupUIState,
+              new CustomEvent("propagate_down_set_ui_state", { detail: {} }),
+              { except: actingChild },
+            );
+          }
           applyState(groupUIState, e);
         } else if (notifyExternal === "silent") {
           controller.syncInternalState(groupUIState);
@@ -24780,7 +24811,7 @@ const useUIGroupStateController = (
         // place — see warnChildAnswersForItself.
         // One pass over every child, which is what a plural distribute needs:
         // it is asked once, sees the whole group, and answers for all of them.
-        placeChildrenUIState: (groupUIState, e) => {
+        placeChildrenUIState: (groupUIState, e, { except } = {}) => {
           if (!resolvedDistributeChildStates) {
             for (const childUIStateController of childUIStateControllerArray) {
               controller.placeChildUIState(
@@ -24802,6 +24833,9 @@ const useUIGroupStateController = (
             return;
           }
           for (const childUIStateController of monitoredChildren) {
+            if (childUIStateController === except) {
+              continue;
+            }
             if (!stateByChild.has(childUIStateController)) {
               // Not named by the answer: left where it is, the way
               // CANNOT_DERIVE leaves a child a per-child distribute says
@@ -25001,7 +25035,10 @@ const useUIGroupStateController = (
             )}`,
           );
           if (stateChanged) {
-            onChange(e, { notifyExternal: silent ? "silent" : true });
+            onChange(e, {
+              notifyExternal: silent ? "silent" : true,
+              actingChild: childUIStateController,
+            });
           } else {
             controller.onUIAction(e);
           }
@@ -25214,6 +25251,7 @@ const useUIGroupStateController = (
       chainEvent(batchedEvent, pendingChange.e);
       scope._onChange(batchedEvent, {
         notifyExternal: pendingChange.notifyExternal,
+        actingChild: pendingChange.actingChild,
       });
     }
   });
@@ -27219,7 +27257,6 @@ const useInteractiveProps = (props, {
           uiStateController.actionInFlight = false;
           uiStateController.runningAction = null;
           const queuedEvent = uiStateController.queuedActionAllowedEvent;
-          uiStateController.queuedActionAllowedEvent = null;
           if (!queuedEvent) {
             return;
           }
@@ -27227,12 +27264,20 @@ const useInteractiveProps = (props, {
             // A failure abandons the queue: the UI is rolled back to the last
             // known state (resetOnError above), and what was queued was built
             // on top of the state that just failed.
+            uiStateController.queuedActionAllowedEvent = null;
             return;
           }
           // A microtask later, not right here: this runs inside the batch()
           // that settles the action (see watchActionCompletion for the same
           // constraint).
           queueMicrotask(() => {
+            // Cleared here, right before the dispatch, never earlier: between
+            // the outcome and this microtask a render can slip in (the echo
+            // of what the settled run committed), and the external-state gate
+            // in ui_state_controller.js must still see work in flight or it
+            // would overwrite the UI state the queued request is about to
+            // send.
+            uiStateController.queuedActionAllowedEvent = null;
             executeAction(queuedEvent);
           });
         });