use crate::prelude::*;
use day_core::{BuildCx, Flex, Piece, RNode, with_tree};
use day_reactive::{Binding, bind_seeded};
use day_spec::{Event, Support};
use std::rc::Rc;
pub use day_spec::controls::stepper::*;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum StepperIdiom {
Native,
Composed,
#[default]
Automatic,
}
#[must_use]
pub fn support() -> day_spec::Support {
let support = day_core::capability(day_spec::Cap::Stepper);
if support == day_spec::Support::Unsupported {
day_spec::Support::Emulated
} else {
support
}
}
type ParseValue = Rc<dyn Fn(&str) -> Option<f64>>;
#[derive(Clone)]
struct ValueFormat {
display: Rc<dyn Fn(f64) -> String>,
parse: ParseValue,
}
#[must_use]
pub struct Stepper<V: Binding<f64>> {
value: V,
min: f64,
max: f64,
step: f64,
decimals: u32,
format: Option<ValueFormat>,
idiom: StepperIdiom,
key: day_core::ElementId,
}
pub fn stepper<V: Binding<f64>>(value: V) -> Stepper<V> {
Stepper {
value,
min: 0.0,
max: 100.0,
step: 1.0,
decimals: 0,
format: None,
idiom: StepperIdiom::Automatic,
key: day_core::id!(stepper),
}
}
#[day_macros::builder(StepperBuilder)]
impl<V: Binding<f64>> Stepper<V> {
pub fn range(mut self, range: std::ops::RangeInclusive<f64>) -> Self {
self.min = *range.start();
self.max = *range.end();
self
}
pub fn step(mut self, step: f64) -> Self {
self.step = step.max(f64::EPSILON);
self
}
pub fn decimals(mut self, decimals: u32) -> Self {
self.decimals = decimals;
self
}
pub fn format_with<T: Into<String>>(
mut self,
display: impl Fn(f64) -> T + 'static,
parse: impl Fn(&str) -> Option<f64> + 'static,
) -> Self {
self.format = Some(ValueFormat {
display: Rc::new(move |v| display(v).into()),
parse: Rc::new(parse),
});
self
}
pub fn format(self, format: day_localization::NumberFormat) -> Self {
self.format_with(move |v| format.format(v), move |s| format.parse(s))
}
pub fn idiom(mut self, idiom: StepperIdiom) -> Self {
self.idiom = idiom;
self
}
pub fn native(self) -> Self {
self.idiom(StepperIdiom::Native)
}
pub fn composed(self) -> Self {
self.idiom(StepperIdiom::Composed)
}
pub fn id(mut self, id: day_core::ElementId) -> Self {
self.key = id;
self
}
}
impl<V: Binding<f64>> Piece for Stepper<V> {
fn build(self, cx: &mut BuildCx) -> RNode {
let native = match self.idiom {
StepperIdiom::Composed => false,
StepperIdiom::Native => true,
StepperIdiom::Automatic => support() == Support::Native,
};
if native && self.format.is_none() {
build_native(self, cx)
} else {
build_composed(self, cx)
}
}
}
fn build_native<V: Binding<f64>>(stepper: Stepper<V>, cx: &mut BuildCx) -> RNode {
let Stepper {
value,
min,
max,
step,
decimals,
key,
..
} = stepper;
let clamp = move |v: f64| v.clamp(min, max);
let initial = clamp(value.peek());
let node = cx.leaf(
KIND,
&StepperProps {
value: initial,
min,
max,
step,
decimals,
},
Flex::default(),
);
with_tree(|t| t.set_id(node, key.as_str().to_owned()));
let note_probe = move |v: f64| {
with_tree(|t| t.set_probe_value(node, v, fmt_value(v, decimals)));
};
note_probe(initial);
{
let v = value.clone();
bind_seeded(
initial,
move || clamp(v.read()),
move |val: &f64| {
with_tree(|t| t.patch(node, Box::new(StepperPatch::SetValue(*val)), false));
note_probe(*val);
},
);
}
cx.on(node, move |ev| {
match ev {
Event::Custom { tag, text, .. } if *tag == VALUE_TAG || tag.is_empty() => {
if let Ok(v) = text.trim().parse::<f64>() {
value.write_commit(clamp(v));
}
}
Event::TextChanged(s) => {
if let Ok(v) = s.trim().parse::<f64>() {
value.write_commit(clamp(v));
}
}
Event::ValueChanged(v) => value.write_preview(clamp(*v)),
Event::ValueCommitted(v) => value.write_commit(clamp(*v)),
_ => {}
}
});
node
}
struct FieldBinding<V: Binding<f64>> {
value: V,
min: f64,
max: f64,
decimals: u32,
format: Option<ValueFormat>,
}
impl<V: Binding<f64>> Clone for FieldBinding<V> {
fn clone(&self) -> Self {
FieldBinding {
value: self.value.clone(),
min: self.min,
max: self.max,
decimals: self.decimals,
format: self.format.clone(),
}
}
}
impl<V: Binding<f64>> Binding<String> for FieldBinding<V> {
fn read(&self) -> String {
let value = self.value.read().clamp(self.min, self.max);
match &self.format {
Some(format) => (format.display)(value),
None => fmt_value(value, self.decimals),
}
}
fn peek(&self) -> String {
day_reactive::untrack(|| self.read())
}
fn write(&self, s: String) {
self.write_commit(s);
}
fn write_preview(&self, _s: String) {}
fn write_commit(&self, s: String) {
let parsed = match &self.format {
Some(format) => (format.parse)(&s).filter(|v| v.is_finite()),
None => s.trim().parse::<f64>().ok().filter(|v| v.is_finite()),
};
if let Some(v) = parsed {
self.value.write_commit(v.clamp(self.min, self.max));
}
}
}
fn build_composed<V: Binding<f64>>(stepper: Stepper<V>, cx: &mut BuildCx) -> RNode {
let Stepper {
value,
min,
max,
step,
decimals,
format,
key,
..
} = stepper;
let clamp = move |v: f64| v.clamp(min, max);
let stepped = {
let value = value.clone();
move |dir: f64| {
let v = clamp(value.peek() + dir * step);
value.write_commit(v);
}
};
let dec = {
let stepped = stepped.clone();
move || stepped(-1.0)
};
let inc = move || stepped(1.0);
let (dec_id, inc_id) = (
day_core::id!(stepper_decrement, key.as_str()),
day_core::id!(stepper_increment, key.as_str()),
);
let binding = FieldBinding {
value: value.clone(),
min,
max,
decimals,
format,
};
let restore = binding.format.as_ref().map(|_| {
let binding = binding.clone();
Rc::new(move || binding.peek()) as Rc<dyn Fn() -> String>
});
let target = Rc::new(std::cell::Cell::new(None));
let field_target = target.clone();
let field = Valued {
inner: text_field(binding).id(key),
value,
clamp,
restore,
};
let field = day_core::piece_fn(move |cx| {
let node = field.build(cx);
field_target.set(Some(node));
node
})
.width(56.0);
let row = row((
button("−").compact().action(dec).id(dec_id),
field,
button("+").compact().action(inc).id(inc_id),
))
.spacing(4.0)
.align(VAlign::Center)
.build(cx);
with_tree(|tree| tree.set_element_target(row, target.get().expect("the field was built")));
row
}
#[must_use]
pub struct NumberField<V: Binding<f64>> {
value: V,
min: f64,
max: f64,
format: day_localization::NumberFormat,
key: day_core::ElementId,
placeholder: Option<crate::TextSource>,
enabled: Reactive<bool>,
read_only: Reactive<bool>,
purpose: day_spec::InputPurpose,
submit_label: day_spec::SubmitLabel,
on_submit: Option<Rc<dyn Fn()>>,
}
pub fn number_field<V: Binding<f64>>(value: V) -> NumberField<V> {
NumberField {
value,
min: -f64::MAX,
max: f64::MAX,
format: NumberFormat::decimal(),
key: day_core::id!(number_field),
placeholder: None,
enabled: Reactive::Const(true),
read_only: Reactive::Const(false),
purpose: day_spec::InputPurpose::Decimal,
submit_label: day_spec::SubmitLabel::Return,
on_submit: None,
}
}
#[day_macros::builder(NumberFieldBuilder)]
impl<V: Binding<f64>> NumberField<V> {
pub fn enabled<M>(mut self, enabled: impl IntoReactive<bool, M>) -> Self {
self.enabled = enabled.into_reactive();
self
}
pub fn read_only<M>(mut self, read_only: impl IntoReactive<bool, M>) -> Self {
self.read_only = read_only.into_reactive();
self
}
pub fn placeholder<M>(mut self, text: impl IntoText<M>) -> Self {
self.placeholder = Some(text.into_text());
self
}
pub fn input_purpose(mut self, purpose: day_spec::InputPurpose) -> Self {
self.purpose = purpose;
self
}
pub fn submit_label(mut self, label: day_spec::SubmitLabel) -> Self {
self.submit_label = label;
self
}
pub fn on_submit(mut self, action: impl Fn() + 'static) -> Self {
self.on_submit = Some(Rc::new(action));
self
}
pub fn range(mut self, range: std::ops::RangeInclusive<f64>) -> Self {
self.min = *range.start();
self.max = *range.end();
self
}
pub fn format(mut self, format: day_localization::NumberFormat) -> Self {
self.format = format;
self
}
pub fn id(mut self, key: day_core::ElementId) -> Self {
self.key = key;
self
}
}
impl<V: Binding<f64>> Piece for NumberField<V> {
fn build(self, cx: &mut BuildCx) -> RNode {
let Self {
value,
min,
max,
format,
key,
placeholder,
enabled,
read_only,
purpose,
submit_label,
on_submit,
} = self;
let binding = FieldBinding {
value: value.clone(),
min,
max,
decimals: 0,
format: Some(ValueFormat {
display: Rc::new(move |v| format.format(v)),
parse: Rc::new(move |s| format.parse(s)),
}),
};
let restore = binding.clone();
let field_enabled = enabled.clone();
let field_read_only = read_only.clone();
let mut field = text_field(binding)
.enabled(move || field_enabled.get())
.read_only(move || field_read_only.get())
.input_purpose(purpose)
.submit_label(submit_label);
if let Some(placeholder) = placeholder {
field = field.placeholder(placeholder);
}
let node = Valued {
inner: field.id(key),
value,
clamp: move |v: f64| v.clamp(min, max),
restore: Some(Rc::new(move || restore.peek())),
}
.build(cx);
if let Some(on_submit) = on_submit {
cx.on(node, move |event| {
if matches!(event, Event::Submitted)
&& enabled.get_untracked()
&& !read_only.get_untracked()
{
on_submit();
}
});
}
node
}
}
struct Valued<P: Piece, V: Binding<f64>, C: Fn(f64) -> f64 + 'static> {
inner: P,
value: V,
clamp: C,
restore: Option<Rc<dyn Fn() -> String>>,
}
impl<P: Piece, V: Binding<f64>, C: Fn(f64) -> f64 + 'static> Piece for Valued<P, V, C> {
fn build(self, cx: &mut BuildCx) -> RNode {
let Valued {
inner,
value,
clamp,
restore,
} = self;
let node = inner.build(cx);
cx.on(node, move |ev| match ev {
Event::ValueChanged(v) => value.write_preview(clamp(*v)),
Event::ValueCommitted(v) => value.write_commit(clamp(*v)),
Event::Submitted | Event::FocusChanged(false) => {
if let Some(display) = &restore {
let text = display();
with_tree(|t| {
t.patch(
node,
Box::new(day_spec::props::TextFieldPatch::Text {
text,
from_native: false,
}),
false,
);
});
}
}
_ => {}
});
node
}
}
#[cfg(test)]
mod tests {
use super::*;
use day_mock::MockToolkit;
use day_reactive::{Signal, flush_sync};
use day_spec::WindowOptions;
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Clone)]
struct Writes {
value: Signal<f64>,
events: Rc<RefCell<Vec<(&'static str, f64)>>>,
}
impl Binding<f64> for Writes {
fn read(&self) -> f64 {
self.value.get()
}
fn peek(&self) -> f64 {
self.value.get_untracked()
}
fn write(&self, value: f64) {
self.write_commit(value);
}
fn write_preview(&self, value: f64) {
self.events.borrow_mut().push(("preview", value));
self.value.set(value);
}
fn write_commit(&self, value: f64) {
self.events.borrow_mut().push(("commit", value));
self.value.set(value);
}
}
fn boot(native: bool) -> (Writes, RNode) {
day_core::uninstall_tree();
let writes = Writes {
value: Signal::new(3.0),
events: Rc::default(),
};
let binding = writes.clone();
let (mock, _) = MockToolkit::new();
day_core::launch_with(mock, WindowOptions::default(), move || {
let field = stepper(binding).range(0.0..=10.0);
if native {
field.native()
} else {
field.composed()
}
.id(day_core::id!(fixture_stepper))
.any()
});
let node = with_tree(|t| t.find_by_id(day_core::id!(fixture_stepper).as_str())).unwrap();
(writes, node)
}
fn emit(node: RNode, event: Event) {
day_core::enqueue_event(day_core::rnode_to_id(node), event);
flush_sync();
}
#[test]
fn localized_numeric_controls_preserve_drafts_commit_once_and_refresh_locale() {
for field_only in [false, true] {
day_core::uninstall_tree();
let writes = Writes {
value: Signal::new(0.4),
events: Rc::default(),
};
let binding = writes.clone();
let (mock, probe) = MockToolkit::new();
day_core::launch_with(mock, WindowOptions::default(), move || {
if field_only {
number_field(binding)
.format(NumberFormat::percent().fraction_digits(1))
.range(0.0..=1.0)
.id(day_core::id!(numeric_fixture))
.any()
} else {
stepper(binding)
.format(NumberFormat::percent().fraction_digits(1))
.range(0.0..=1.0)
.id(day_core::id!(numeric_fixture))
.any()
}
});
day_localization::locale().set("de".to_owned());
flush_sync();
let node = with_tree(|t| t.find_by_id("numeric_fixture")).unwrap();
let display = || probe.find_by_kind("day.text_field")[0].1.text.clone();
assert_eq!(
display(),
NumberFormat::percent()
.fraction_digits(1)
.format_in("de", 0.4)
);
emit(node, Event::TextChanged("-".into()));
assert_eq!(writes.peek(), 0.4);
assert!(writes.events.borrow().is_empty());
emit(node, Event::TextChanged("72,5 %".into()));
emit(node, Event::Submitted);
emit(node, Event::FocusChanged(false));
assert_eq!(*writes.events.borrow(), [("commit", 0.725)]);
emit(node, Event::TextChanged("1.5".into())); emit(node, Event::Submitted);
assert_eq!(writes.peek(), 0.725);
assert_eq!(writes.events.borrow().len(), 1);
day_localization::locale().set("ar-EG".to_owned());
flush_sync();
assert_eq!(
display(),
NumberFormat::percent()
.fraction_digits(1)
.format_in("ar-EG", 0.725)
);
emit(node, Event::TextChanged("١٥٠٪".into()));
emit(node, Event::FocusChanged(false));
assert_eq!(writes.peek(), 1.0);
}
day_localization::locale().set("en".to_owned());
}
#[test]
fn formatted_edits_commit_once_clamp_and_restore_rejected_text() {
for idiom in [
StepperIdiom::Automatic,
StepperIdiom::Native,
StepperIdiom::Composed,
] {
day_core::uninstall_tree();
let writes = Writes {
value: Signal::new(0.4),
events: Rc::default(),
};
let binding = writes.clone();
let (mock, probe) = MockToolkit::new();
day_core::launch_with(mock, WindowOptions::default(), move || {
stepper(binding)
.range(0.0..=1.0)
.step(0.01)
.format_with(
|v| format!("{:.0}%", v * 100.0),
|text| {
text.trim()
.trim_end_matches('%')
.trim()
.parse::<f64>()
.ok()
.map(|v| v / 100.0)
},
)
.idiom(idiom)
.id(day_core::id!(fixture_stepper))
.any()
});
let node = with_tree(|t| t.find_by_id("fixture_stepper")).unwrap();
let text = || probe.find_by_kind("day.text_field")[0].1.text.clone();
assert_eq!(text(), "40%");
assert!(
probe.find_by_kind(KIND).is_empty(),
"custom text always uses the composed control"
);
emit(node, Event::TextChanged("73%".into()));
assert!(
writes.events.borrow().is_empty(),
"unfinished typing is not a numeric edit"
);
emit(node, Event::Submitted);
emit(node, Event::FocusChanged(false));
assert_eq!(*writes.events.borrow(), [("commit", 0.73)]);
assert_eq!(text(), "73%");
for invalid in ["invalid", "NaN%", "inf%", "-inf%"] {
emit(node, Event::TextChanged(invalid.into()));
emit(node, Event::Submitted);
assert_eq!(writes.peek(), 0.73);
assert_eq!(text(), "73%");
assert_eq!(writes.events.borrow().len(), 1);
}
emit(node, Event::TextChanged("150%".into()));
emit(node, Event::FocusChanged(false));
assert_eq!(writes.peek(), 1.0);
assert_eq!(text(), "100%");
emit(node, Event::TextChanged("100".into()));
emit(node, Event::Submitted);
assert_eq!(
text(),
"100%",
"canonical text is restored even when the number is unchanged"
);
assert_eq!(writes.events.borrow().len(), 3);
}
}
#[test]
fn formatted_reads_track_dependencies_and_numeric_events_keep_bound_units() {
day_core::uninstall_tree();
let value = Signal::new(0.4);
let suffix = Signal::new("%");
let (mock, probe) = MockToolkit::new();
day_core::launch_with(mock, WindowOptions::default(), move || {
stepper(value)
.range(0.0..=1.0)
.step(0.01)
.format_with(
move |v| format!("{:.0}{}", v * 100.0, suffix.get()),
|_| None,
)
.id(day_core::id!(fixture_stepper))
.any()
});
let text = || probe.find_by_kind("day.text_field")[0].1.text.clone();
suffix.set(" %");
flush_sync();
assert_eq!(
text(),
"40 %",
"formatter dependencies update without a numeric change"
);
let node = with_tree(|t| t.find_by_id("fixture_stepper")).unwrap();
emit(node, Event::ValueChanged(0.6));
assert_eq!(value.get(), 0.6);
assert_eq!(text(), "60 %");
emit(node, Event::ValueCommitted(0.7));
assert_eq!(text(), "70 %");
let inc = day_core::id!(stepper_increment, "fixture_stepper");
let button = with_tree(|t| t.find_by_id(inc.as_str())).unwrap();
emit(button, Event::Pressed);
assert!((value.get() - 0.71).abs() < 1e-10);
assert_eq!(text(), "71 %");
}
#[test]
fn scripted_typing_commits_once_in_both_idioms() {
for native in [true, false] {
let (writes, node) = boot(native);
day_core::synthesize_text(node, "7".into());
flush_sync();
emit(node, Event::Submitted);
assert_eq!(writes.peek(), 7.0);
assert_eq!(
*writes.events.borrow(),
[("commit", 7.0)],
"native={native}"
);
}
}
#[test]
fn native_custom_events_accept_only_value_tags_and_the_legacy_bridge() {
let (writes, node) = boot(true);
emit(node, Event::custom(day_core::SYNTHESIZED_TEXT, "8"));
emit(node, Event::custom("fixture:unrelated", "9"));
assert_eq!(writes.peek(), 3.0);
assert!(writes.events.borrow().is_empty());
emit(node, Event::custom(VALUE_TAG, "6"));
emit(node, Event::custom("", "12"));
assert_eq!(*writes.events.borrow(), [("commit", 6.0), ("commit", 10.0)]);
assert_eq!(writes.peek(), 10.0);
}
#[test]
fn scripted_values_keep_the_preview_and_commit_boundary() {
for native in [true, false] {
let (writes, node) = boot(native);
emit(node, Event::ValueChanged(12.0));
emit(node, Event::ValueCommitted(12.0));
assert_eq!(
*writes.events.borrow(),
[("preview", 10.0), ("commit", 10.0)],
"native={native}"
);
assert_eq!(writes.peek(), 10.0);
}
}
}
#[cfg(feature = "conformance")]
pub mod conformance {
#[day_macros::test(day_core)]
fn localized_numeric_input() -> day_core::conformance::Case {
use crate::prelude::*;
let value = Signal::new(0.4);
let submitted = Signal::new(0.0);
let enabled = Signal::new(true);
Case::new()
.proves(day_spec::kinds::TEXT_FIELD)
.page(move || {
column((
stepper(value)
.padding(4.0)
.range(0.0..=1.0)
.format(NumberFormat::percent())
.id(day_core::id!(percent_stepper)),
number_field(value)
.padding(4.0)
.range(0.0..=1.0)
.format(NumberFormat::percent())
.placeholder("Fixture percentage")
.submit_label(SubmitLabel::Done)
.enabled(enabled)
.on_submit(move || submitted.set(value.get()))
.id(day_core::id!(percent_field)),
label(move || NumberFormat::percent().format(submitted.get()))
.id(day_core::id!(percent_submitted)),
button("Disable fixture field")
.action(move || enabled.set(false))
.id(day_core::id!(percent_disable)),
))
})
.drive(|d: Drive| async move {
d.input("percent_field", "73%").await?;
d.submit("percent_field").await?;
d.assert_text("percent_submitted", &NumberFormat::percent().format(0.73))
.await?;
d.assert_text("percent_stepper", &NumberFormat::percent().format(0.73))
.await?;
d.input("percent_stepper", "invalid").await?;
d.submit("percent_stepper").await?;
d.assert_text("percent_stepper", &NumberFormat::percent().format(0.73))
.await?;
d.set_value("percent_stepper", 0.4).await?;
d.assert_text("percent_field", &NumberFormat::percent().format(0.4))
.await?;
d.tap("percent_disable").await?;
d.assert_enabled("percent_field", false).await
})
}
use crate::*;
use day_core::AnyPiece;
use day_core::conformance::{Case, Drive};
use day_reactive::Signal;
use super::{KIND, stepper};
fn page(composed: bool) -> AnyPiece {
let value = Signal::new(3.0f64);
let field = stepper(value)
.range(0.0..=10.0)
.id(day_core::id!(stepper::count));
column((
label(move || format!("value {}", value.get())).id(day_core::id!(stepper::value)),
if composed {
field.composed().any()
} else {
field.native().any()
},
))
.any()
}
#[day_macros::test(day_core)]
fn stepper_sets_value() -> Case {
Case::new()
.proves(KIND)
.page(|| page(false))
.drive(|d: Drive| async move {
d.assert_text("stepper::count", "3").await?;
d.set_value("stepper::count", 7.0).await?;
d.assert_text("stepper::value", "value 7").await?;
d.assert_text("stepper::count", "7").await
})
}
#[day_macros::test(day_core)]
fn stepper_clamps_to_range() -> Case {
Case::new()
.proves(KIND)
.page(|| page(false))
.drive(|d: Drive| async move {
d.set_value("stepper::count", 42.0).await?;
d.assert_text("stepper::value", "value 10").await
})
}
#[day_macros::test(day_core)]
fn stepper_composed_sets_value() -> Case {
Case::new()
.page(|| page(true))
.drive(|d: Drive| async move {
d.input("stepper::count", "5").await?;
d.submit("stepper::count").await?;
d.assert_text("stepper::value", "value 5").await?;
d.tap(day_core::id!(stepper_increment, "stepper::count").as_str())
.await?;
d.assert_text("stepper::value", "value 6").await?;
d.assert_text("stepper::count", "6").await?;
d.set_value("stepper::count", 9.0).await?;
d.assert_text("stepper::value", "value 9").await?;
d.assert_text("stepper::count", "9").await
})
}
}