diff --git a/packages/cli-rs/crates/plugin/examples/pipe/v2probe/tui.tsx b/packages/cli-rs/crates/plugin/examples/pipe/v2probe/tui.tsx index bb240c6b398..db28cdeb002 100644 --- a/packages/cli-rs/crates/plugin/examples/pipe/v2probe/tui.tsx +++ b/packages/cli-rs/crates/plugin/examples/pipe/v2probe/tui.tsx @@ -174,6 +174,13 @@ export default Plugin.define({ run: () => context.ui.dialog.show(() => log({ draft: value })} />), }, + // A key that opens a dialog of its own with a focused field, which the user types into at once (big-boi ds-3). + { + id: "v2probe.ahead", + bind: "f2", + run: () => + context.ui.dialog.show(() => log({ ahead: value })} />), + }, { id: "v2probe.relayer", run: () => context.keymap.layer(() => ({ commands: [{ id: "v2probe.relayered", run() {} }] })) }, { id: "v2probe.color", diff --git a/packages/cli-rs/crates/plugin/src/interact.rs b/packages/cli-rs/crates/plugin/src/interact.rs index 4e9321c62ed..8afc9d84764 100644 --- a/packages/cli-rs/crates/plugin/src/interact.rs +++ b/packages/cli-rs/crates/plugin/src/interact.rs @@ -74,6 +74,11 @@ pub struct Owner { dialog: Cell, /// Brings a widget of the mount's tree into view in the scrolls of the tree that hold it. reveal: RefCell>, + /// What waits for a node of the mount to take the focus, or for the mount to end: input typed while a dialog + /// surface opened goes on then (big-boi ds-3). + focus_waiters: RefCell>>, + /// When a dialog surface's mount began: input waits for its focus only that soon after ([`OPENING`]). + born: Cell>, layers: RefCell>, mode: RefCell>, /// The ids of its tree's nodes, and of its focusable ones. @@ -113,6 +118,9 @@ struct Listener { deliver: Deliver, } +/// How long after a plugin's dialog surface opens the input waits for its field to take the focus, at most. +pub(crate) const OPENING: std::time::Duration = std::time::Duration::from_millis(500); + /// How many events a hold keeps; at the limit it is released, and what it kept goes on in order. pub const HOLD_LIMIT: usize = 256; @@ -283,6 +291,8 @@ impl Owner { composer: Cell::new(false), dialog: Cell::new(false), reveal: RefCell::default(), + focus_waiters: RefCell::default(), + born: Cell::new(None), layers: RefCell::default(), mode: RefCell::default(), ids: RefCell::default(), @@ -307,6 +317,7 @@ impl Owner { /// A dialog surface's mount, before its layers register: they hold in the host dialogs' mode. pub(crate) fn mark_dialog(&self) { self.dialog.set(true); + self.born.set(Some(std::time::Instant::now())); } /// The scope of the surface is the dialog whose body is `view`, while it is on top. @@ -336,6 +347,16 @@ impl Owner { !self.ids.borrow().is_empty() } + /// Runs `then` once a node of the mount takes the focus, or once the mount ends. + pub(crate) fn when_focused(&self, then: Box) { + self.focus_waiters.borrow_mut().push(then); + } + + fn focused_now(&self) { + let waiters = std::mem::take(&mut *self.focus_waiters.borrow_mut()); + waiters.into_iter().for_each(|then| then()); + } + /// Sets what brings a widget of the mount's tree into view ([`Owner::focus`]). pub(crate) fn set_reveal(&self, reveal: Reveal) { *self.reveal.borrow_mut() = Some(reveal); @@ -686,6 +707,7 @@ impl Owner { reveal(id, &widget); } host.reveal(&widget); + self.focused_now(); } // A node the tree does not hold yet waits for the mount's next view, which may show it; one it holds that // takes no focus (a text, a node in a hidden box) is refused. @@ -767,6 +789,7 @@ impl Owner { /// composer as it mounts the route again, and an overlay's close does too. pub(crate) fn end(self: &Rc) { self.alive.set(false); + self.focused_now(); if self.ended.replace(true) { return; } @@ -1118,6 +1141,18 @@ impl Router { self.offered(host) } + /// The mount of a plugin's dialog surface on top, opened less than [`OPENING`] ago, whose nodes have not taken the + /// focus yet: its first tree and focus may still come (the JS host's next revisions). + pub(crate) fn opening(&self, host: &dyn Host) -> Option> { + let owners: Vec> = self.owners.borrow().iter().filter_map(Weak::upgrade).collect(); + owners.into_iter().rev().find(|owner| { + owner.alive() + && owner.born.get().is_some_and(|born| born.elapsed() < OPENING) + && owner.on_top(host) + && owner.focused().node.is_none() + }) + } + /// Whether an overlay has the focus. fn overlaid(&self, host: &dyn Host) -> bool { self.overlays.borrow().iter().any(|shown| focus_within(host.app(), shown.frame.id())) diff --git a/packages/cli-rs/crates/plugin/src/pipe/mod.rs b/packages/cli-rs/crates/plugin/src/pipe/mod.rs index 758e00640a7..12b81f9b295 100644 --- a/packages/cli-rs/crates/plugin/src/pipe/mod.rs +++ b/packages/cli-rs/crates/plugin/src/pipe/mod.rs @@ -801,6 +801,11 @@ struct Hold { input: VecDeque<(Held, Past)>, /// Input put back now, which the intercepts let through. replaying: bool, + /// A plugin's dialog surface just opened and none of its nodes took the focus yet: the input waits for that focus + /// (or the mount's end, or [`crate::interact::OPENING`]), so what the user typed as it opened is its field's + /// (big-boi ds-3). The number tells this wait from an earlier one, and the timer is its deadline. + opening: Option<(u64, TimerId)>, + openings: u64, } /// A call input waits for: its sequence, the key that ran it if a key did (it goes back if the call declines it), and @@ -838,7 +843,7 @@ impl Past { impl Hold { fn holding(&self) -> bool { - !self.owners.is_empty() || self.settling > 0 + !self.owners.is_empty() || self.settling > 0 || self.opening.is_some() } /// Ends owner `seq`, if it still owns its entry, and puts its key back if `put_back`: its deadline, to cancel. @@ -2271,6 +2276,16 @@ impl Scripts { /// [`HELD`] the owners end as at their deadline, and the input goes on after the turn, none of it dropped (cg2-1). fn take(&self, input: Held) -> bool { let mut past = self.past(); + // Input while a plugin's dialog that just opened has not focused its field yet waits for that focus; escape does + // not, as it closes the dialog at once. + let escape = matches!(&input, Held::Key(key) if key.code == opentui::input::KeyCode::Escape); + let opening = { + let hold = self.hold.borrow(); + !escape && !hold.holding() && !hold.replaying + }; + if opening && let Some(host) = self.host.upgrade() { + self.await_opening(&*host, true); + } let mut hold = self.hold.borrow_mut(); if !hold.holding() || hold.replaying { return false; @@ -2310,7 +2325,8 @@ impl Scripts { let timers: Vec = { let mut hold = self.hold.borrow_mut(); hold.input.clear(); - hold.owners.drain(..).filter_map(|owner| owner.timer).collect() + let opening = hold.opening.take().map(|(_, timer)| timer); + hold.owners.drain(..).filter_map(|owner| owner.timer).chain(opening).collect() }; self.cancel(timers); } @@ -2414,6 +2430,9 @@ impl Scripts { /// Puts the held input back in order once nothing holds it. A put-back key that starts a hold keeps the rest held. fn release(&self) { let Some(host) = self.host.upgrade() else { return }; + if self.await_opening(&*host, false) { + return; + } loop { let input = { let mut hold = self.hold.borrow_mut(); @@ -2437,6 +2456,51 @@ impl Scripts { self.hold.borrow_mut().replaying = false; } } + + /// Whether the input waits for a plugin's dialog surface on top to focus its field: one that just opened, whose first + /// tree and focus come with the JS host's next revisions. It goes on once a node of that dialog takes the focus, the + /// dialog's mount ends, or [`crate::interact::OPENING`] passes. `incoming`: input comes now, which the wait takes. + fn await_opening(&self, host: &dyn Host, incoming: bool) -> bool { + { + let hold = self.hold.borrow(); + if hold.holding() || hold.replaying || (hold.input.is_empty() && !incoming) { + return false; + } + } + let Some(owner) = host.router().and_then(|router| router.opening(host)) else { return false }; + let token = { + let mut hold = self.hold.borrow_mut(); + hold.openings += 1; + hold.openings + }; + let timed = self.this.clone(); + let timer = host.app().set_timeout(crate::interact::OPENING, move |_| { + if let Some(scripts) = timed.upgrade() { + scripts.opened(token); + } + }); + self.hold.borrow_mut().opening = Some((token, timer)); + let (focused, owner_host) = (self.this.clone(), self.host.clone()); + owner.when_focused(Box::new(move || { + // After the focus applied, in the order of what the effects did. + if let Some(host) = owner_host.upgrade() { + host.app().defer(move |_| { + if let Some(scripts) = focused.upgrade() { + scripts.opened(token); + } + }); + } + })); + true + } + + /// The wait for an opening dialog `token` ended: the input goes on. + fn opened(&self, token: u64) { + let timer = self.hold.borrow_mut().opening.take_if(|(waiting, _)| *waiting == token); + let Some((_, timer)) = timer else { return }; + self.cancel([timer]); + self.release(); + } } impl InputHold for Scripts { diff --git a/packages/cli-rs/crates/tui/tests/all/plugin_compat.rs b/packages/cli-rs/crates/tui/tests/all/plugin_compat.rs index 41683bad776..0ddaf0e0935 100644 --- a/packages/cli-rs/crates/tui/tests/all/plugin_compat.rs +++ b/packages/cli-rs/crates/tui/tests/all/plugin_compat.rs @@ -2159,3 +2159,24 @@ fn a_dialog_field_keeps_its_draft_across_a_reload() { }); assert_eq!(drafts().last(), Some(&json!("abXcd")), "{:?}", drafts()); } + +// Expected (big-boi ds-3): keys typed right after the key that opens a JS plugin's dialog with a focused field go to that +// field once it has the focus, in order, not to the composer under it and not lost. +#[test] +fn keys_typed_as_a_dialog_opens_go_to_its_field() { + let Some(config) = config() else { return }; + let (pipe, log) = probe(config); + let ahead = || calls(&log).into_iter().filter_map(|call| call.get("ahead").cloned()).collect::>(); + pipe.harness.app.press("f2"); + pipe.harness.app.type_text("ab"); + pipe.harness.app.wait_until(Duration::from_secs(5), || { + pipe.settle(); + ahead().last() == Some(&json!("ab")) + }); + assert_eq!(ahead().last(), Some(&json!("ab")), "{:?}", ahead()); + pipe.harness.tui.dialogs.clear(); + pipe.settle(); + let screen = pipe.harness.app.text(); + let composed = screen.lines().any(|line| line.trim_start_matches([' ', '┃']).starts_with("ab")); + assert!(!composed, "the keys reached the composer:\n{screen}"); +}