fix loading yaml in web

Author: waozixyz

src/app.rs

@@ -1,50 +1,40 @@
 use crate::models::{MyLifeApp, Yaml};
 use crate::ui::{BottomPanel, CentralPanel, TopPanel};
-use crate::yaml_manager::get_yaml;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::yaml_manager::{get_available_yamls, get_yaml_manager};
+use crate::yaml_manager::{get_yaml, get_yaml_manager};
 use dioxus::prelude::*;
 
 #[cfg(not(target_arch = "wasm32"))]
 use dioxus_logger::tracing::error;
 
 #[component]
 pub fn App() -> Element {
-    let mut app_state = use_signal(|| MyLifeApp {
-        yaml: get_yaml(),
-        view: "Lifetime".to_string(),
-        selected_yaml: "default.yaml".to_string(),
-        selected_legend_item: None,
-        original_legend_item: None,
-        selected_life_period: None,
-        value: 0.0,
-        #[cfg(not(target_arch = "wasm32"))]
-        yaml_files: get_available_yamls(),
-        #[cfg(target_arch = "wasm32")]
-        yaml_content: String::new(),
-        loaded_yamls: Vec::new(),
-        #[cfg(target_arch = "wasm32")]
-        selected_yaml_index: 0,
-        item_state: None,
-        temp_start_date: String::new(),
-        data_folder: "data".to_string(),
-    });
+    let mut yaml = use_signal(|| get_yaml());
 
-    use_effect(move || {
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let yamls = get_yaml_manager().get_available_yamls();
-            app_state.write().yaml_files = yamls.unwrap_or_default();
-        }
+    let app_state = use_signal(|| {
+        let loaded_yamls = load_yamls();
 
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let loaded_yamls = load_yamls();
-            app_state.write().loaded_yamls = loaded_yamls;
+        MyLifeApp {
+            view: "Lifetime".to_string(),
+            selected_yaml: "default.yaml".to_string(),
+            selected_legend_item: None,
+            original_legend_item: None,
+            selected_life_period: None,
+            value: 0.0,
+            loaded_yamls,
+            item_state: None,
+            temp_start_date: String::new(),
+            data_folder: "data".to_string(),
         }
     });
+    use_effect(move || {
+        let mut app_state = use_context::<Signal<MyLifeApp>>();
+
+        let loaded_yamls = load_yamls();
+        app_state.write().loaded_yamls = loaded_yamls;
+    });
 
     use_context_provider(|| app_state);
+    use_context_provider(|| yaml);
 
     rsx! {
         style { {include_str!("../assets/input.css")} }
@@ -62,23 +52,22 @@ pub fn App() -> Element {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 fn load_yamls() -> Vec<(String, Yaml)> {
-    let yamls = get_yaml_manager().get_available_yamls();
-    yamls
-        .map(|yamls| {
-            yamls
-                .into_iter()
-                .filter_map(|name| {
-                    get_yaml_manager()
-                        .load_yaml(&name)
-                        .map_err(|e| {
-                            error!("Failed to load yaml {}: {:?}", name, e);
-                        })
-                        .ok()
-                        .map(|yaml| (name, yaml))
+    get_yaml_manager()
+        .get_available_yamls()
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|name| {
+            get_yaml_manager()
+                .load_yaml(&name)
+                .map_err(|e| {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    error!("Failed to load yaml {}: {:?}", name, e);
+                    #[cfg(target_arch = "wasm32")]
+                    log::error!("Failed to load yaml {}: {:?}", name, e);
                 })
-                .collect()
+                .ok()
+                .map(|yaml| (name, yaml))
         })
-        .unwrap_or_default()
-}
+        .collect()
+}

src/models.rs

@@ -5,21 +5,14 @@ use uuid::Uuid;
 #[serde(default)]
 pub struct MyLifeApp {
     pub selected_life_period: Option<Uuid>,
-    pub yaml: Yaml,
     pub view: String,
-    #[cfg(not(target_arch = "wasm32"))]
-    pub yaml_files: Vec<String>,
-    #[cfg(target_arch = "wasm32")]
-    pub yaml_content: String,
     pub selected_yaml: String,
     #[serde(skip)]
     pub value: f32,
     pub selected_legend_item: Option<LegendItem>,
     #[serde(skip)]
     pub original_legend_item: Option<LegendItem>,
     pub loaded_yamls: Vec<(String, Yaml)>,
-    #[cfg(target_arch = "wasm32")]
-    pub selected_yaml_index: usize,
     pub item_state: Option<LegendItem>,
     pub temp_start_date: String,
     pub data_folder: String,

src/ui/bottom_panel.rs

@@ -1,4 +1,4 @@
-use crate::models::{LegendItem, MyLifeApp};
+use crate::models::{LegendItem, MyLifeApp, Yaml};
 use crate::ui::{EditLegendItem, Legend};
 use chrono::{Datelike, Local};
 use dioxus::prelude::*;
@@ -7,6 +7,8 @@ use uuid::Uuid;
 #[component]
 pub fn BottomPanel() -> Element {
     let mut app_state = use_context::<Signal<MyLifeApp>>();
+    let yaml_state = use_context::<Signal<Yaml>>();
+
     let add_new_item = move |_| {
         let current_view = &app_state().view;
         let default_start = if *current_view == "Lifetime" {
@@ -15,8 +17,7 @@ pub fn BottomPanel() -> Element {
         } else {
             // For EventView, use the start date of the selected life period
             if let Some(period_id) = app_state().selected_life_period {
-                if let Some(period) = app_state()
-                    .yaml
+                if let Some(period) = yaml_state()
                     .life_periods
                     .iter()
                     .find(|p| p.id == period_id)

src/ui/edit_legend_item.rs

@@ -1,4 +1,4 @@
-use crate::models::{LifePeriod, LifePeriodEvent, MyLifeApp};
+use crate::models::{LifePeriod, LifePeriodEvent, MyLifeApp, Yaml};
 use crate::utils::date_utils::is_valid_date;
 use crate::yaml_manager::update_yaml;
 use chrono::{Local, NaiveDate};
@@ -12,24 +12,23 @@ fn is_valid_hex_color(color: &str) -> bool {
 #[component]
 pub fn EditLegendItem() -> Element {
     let mut app_state = use_context::<Signal<MyLifeApp>>();
+    let mut yaml_state = use_context::<Signal<Yaml>>();
     let mut color_input = use_signal(String::new);
     let mut date_error = use_signal(String::new);
     let mut current_date = use_signal(String::new);
 
     let (min_date, max_date) = use_memo(move || {
         if let Some(item) = &app_state().item_state {
             if item.is_event {
-                if let Some(period) = app_state()
-                    .yaml
+                if let Some(period) = yaml_state()
                     .life_periods
                     .iter()
                     .find(|p| p.id == app_state().selected_life_period.unwrap())
                 {
                     let period_start =
                         NaiveDate::parse_from_str(&format!("{}-01", period.start), "%Y-%m-%d")
                             .unwrap_or_default();
-                    let period_end = app_state()
-                        .yaml
+                    let period_end = yaml_state()
                         .life_periods
                         .iter()
                         .find(|p| p.start > period.start)
@@ -56,17 +55,15 @@ pub fn EditLegendItem() -> Element {
             } else {
                 let default_date = if item.is_event {
                     debug!("Getting default date for new event");
-                    if let Some(period) = app_state()
-                        .yaml
+                    if let Some(period) = yaml_state()
                         .life_periods
                         .iter()
                         .find(|p| p.id == app_state().selected_life_period.unwrap())
                     {
                         let period_start =
                             NaiveDate::parse_from_str(&format!("{}-01", period.start), "%Y-%m-%d")
                                 .unwrap_or_default();
-                        let period_end = app_state()
-                            .yaml
+                        let period_end = yaml_state()
                             .life_periods
                             .iter()
                             .find(|p| p.start > period.start)
@@ -134,8 +131,9 @@ pub fn EditLegendItem() -> Element {
         debug!("Attempting to update yaml item");
         if date_error().is_empty() {
             if let Some(item) = app_state().item_state {
+                let mut new_yaml = yaml_state();
+
                 debug!("Updating item: {:?}", item);
-                let mut new_yaml = app_state().yaml.clone();
                 if item.is_event {
                     if let Some(period) = new_yaml
                         .life_periods
@@ -173,9 +171,9 @@ pub fn EditLegendItem() -> Element {
                     }
                     new_yaml.life_periods.sort_by(|a, b| a.start.cmp(&b.start));
                 }
-                app_state.write().yaml = new_yaml;
+                yaml_state.set(new_yaml);
 
-                let _ = update_yaml(&app_state().yaml, &app_state().selected_yaml);
+                let _ = update_yaml(&yaml_state(), &app_state().selected_yaml);
                 debug!("Yaml updated successfully");
             } else {
                 warn!("Attempted to update yaml with no item state");
@@ -258,7 +256,7 @@ pub fn EditLegendItem() -> Element {
 
     let delete_item = move |_| {
         if let Some(item) = app_state().item_state {
-            let mut new_yaml = app_state().yaml.clone();
+            let mut new_yaml = yaml_state();
             if item.is_event {
                 if let Some(period) = new_yaml
                     .life_periods
@@ -270,8 +268,8 @@ pub fn EditLegendItem() -> Element {
             } else {
                 new_yaml.life_periods.retain(|p| p.id != item.id);
             }
-            app_state.write().yaml = new_yaml;
-            let _ = update_yaml(&app_state().yaml, &app_state().selected_yaml);
+            yaml_state.set(new_yaml);
+            let _ = update_yaml(&yaml_state(), &app_state().selected_yaml);
         }
         app_state.write().item_state = None;
         app_state.write().temp_start_date = String::new();

src/ui/events_view.rs

@@ -1,15 +1,15 @@
-use crate::models::{LifePeriodEvent, MyLifeApp};
+use crate::models::{LifePeriodEvent, MyLifeApp, Yaml};
 use chrono::{Duration, Local, NaiveDate};
 use dioxus::prelude::*;
 use uuid::Uuid;
 
 #[component]
 pub fn EventView(selected_life_period_id: Uuid) -> Element {
     let app_state = use_context::<Signal<MyLifeApp>>();
+    let yaml_state = use_context::<Signal<Yaml>>();
 
     let life_period = use_memo(move || {
-        app_state()
-            .yaml
+        yaml_state()
             .life_periods
             .iter()
             .find(|p| p.id == selected_life_period_id)
@@ -38,8 +38,7 @@ pub fn EventView(selected_life_period_id: Uuid) -> Element {
                         .unwrap_or(Local::now().date_naive())
                 });
 
-            let end_date = app_state()
-                .yaml
+            let end_date = yaml_state()
                 .life_periods
                 .iter()
                 .find(|p| p.start > period.start)

src/ui/legend.rs

@@ -1,10 +1,11 @@
-use crate::models::{LegendItem, MyLifeApp};
+use crate::models::{LegendItem, MyLifeApp, Yaml};
 use dioxus::prelude::*;
 
 #[component]
 pub fn Legend() -> Element {
     // Fetch signals from context
     let mut app_state = use_context::<Signal<MyLifeApp>>();
+    let mut yaml_state = use_context::<Signal<Yaml>>();
 
     let mut open_edit_modal = move |item: LegendItem| {
         app_state.write().item_state = Some(item.clone());
@@ -16,7 +17,7 @@ pub fn Legend() -> Element {
         let mut legend_items = Vec::new();
         match app_state().view.as_str() {
             "Lifetime" => {
-                let mut sorted_periods = app_state().yaml.life_periods.clone();
+                let mut sorted_periods = yaml_state().life_periods.clone();
                 sorted_periods.sort_by(|a, b| a.start.cmp(&b.start));
 
                 for period in sorted_periods {
@@ -44,8 +45,7 @@ pub fn Legend() -> Element {
             }
             "EventView" => {
                 if let Some(period_id) = app_state().selected_life_period {
-                    if let Some(period) = app_state()
-                        .yaml
+                    if let Some(period) = yaml_state()
                         .life_periods
                         .iter()
                         .find(|p| p.id == period_id)