Rewind through the descent history (#114)

You can now rewind through the descent history of the last realization using the *Step* control that's been added to the diagnostics panel.

The starting value of the *Step* control depends on the realization status. After a successful realization, we show the realized state (the last step). After an unsuccessful realization, we show the initial guess (step zero).

Co-authored-by: Aaron Fenyes <aaron.fenyes@fareycircles.ooo>
Reviewed-on: StudioInfinity/dyna3#114
Co-authored-by: Vectornaut <vectornaut@nobody@nowhere.net>
Co-committed-by: Vectornaut <vectornaut@nobody@nowhere.net>

app-proto/src/components/diagnostics.rs

@@ -7,7 +7,7 @@ use charming::{
 };
 use sycamore::prelude::*;
 
-use crate::AppState;
+use crate::{AppState, specified::SpecifiedValue};
 
 #[derive(Clone)]
 struct DiagnosticsState {
@@ -48,6 +48,69 @@ fn RealizationStatus() -> View {
     }
 }
 
+// history step input
+#[component]
+fn StepInput() -> View {
+    // get the assembly
+    let state = use_context::<AppState>();
+    let assembly = state.assembly;
+    
+    // the `last_step` signal holds the index of the last step
+    let last_step = assembly.descent_history.map(
+        |history| match history.config.len() {
+            0 => None,
+            n => Some(n - 1),
+        }
+    );
+    let input_max = last_step.map(|last| last.unwrap_or(0));
+    
+    // these signals hold the entered step number
+    let value = create_signal(String::new());
+    let value_as_number = create_signal(0.0);
+    
+    create_effect(move || {
+        value.set(assembly.step.with(|n| n.spec.clone()));
+    });
+    
+    view! {
+        div(id = "step-input") {
+            label { "Step" }
+            input(
+                r#type = "number",
+                min = "0",
+                max = input_max.with(|max| max.to_string()),
+                bind:value = value,
+                bind:valueAsNumber = value_as_number,
+                on:change = move |_| {
+                    if last_step.with(|last| last.is_some()) {
+                        // clamp the step within its allowed range. the lower
+                        // bound is redundant on browsers that make it
+                        // impossible to type negative values into a number
+                        // input with a non-negative `min`, but there's no harm
+                        // in being careful
+                        let step_raw = value.with(
+                            |val| SpecifiedValue::try_from(val.clone())
+                                .unwrap_or(SpecifiedValue::from_empty_spec()
+                            )
+                        );
+                        let step = SpecifiedValue::from(
+                            step_raw.value.map(
+                                |val| val.clamp(0.0, input_max.get() as f64)
+                            )
+                        );
+                        
+                        // set the input string and the assembly's active step
+                        value.set(step.spec.clone());
+                        assembly.step.set(step);
+                    } else {
+                        value.set(String::new());
+                    }
+                },
+            )
+        }
+    }
+}
+
 fn into_log10_time_point((step, value): (usize, f64)) -> Vec<Option<f64>> {
     vec![
         Some(step as f64),
@@ -248,6 +311,7 @@ pub fn Diagnostics() -> View {
                     option(value = "loss") { "Loss" }
                     option(value = "spectrum") { "Spectrum" }
                 }
+                StepInput {}
             }
             DiagnosticsPanel(name = "loss") { LossHistory {} }
             DiagnosticsPanel(name = "spectrum") { SpectrumHistory {} }