save prompting on close

src-tauri/capabilities/default.json

···
   ],
   "permissions": [
     "core:default",
+    "core:window:allow-destroy",
     "opener:default",
     "dialog:default"
   ]

src-tauri/src/frontend_calls/load_previous_tabs.rs

···
 use crate::{ structs::nodes::Node, utils::config::Config };
 
 #[tauri::command]
-pub fn load_previous_tabs( conf: State<Config> ) -> HashMap<String, Vec<Node>> {
+pub fn load_previous_tabs( conf: State<Config> ) -> HashMap<String, ( Vec<Node>, String, Option<String> )> {
   let config = conf.store.lock().unwrap();
 
   let tabs = config.loaded_tabs.clone();

src-tauri/src/frontend_calls/sync_tab.rs

···
 use crate::{ runtime::commands::RuntimeCommand, structs::nodes::Node, utils::config::Config };
 
 #[tauri::command]
-pub fn sync_tab( graph: Vec<Node>, id: String, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
+pub fn sync_tab( graph: Vec<Node>, id: String, name: String, location: Option<String>, cmd: State<Sender<RuntimeCommand>>, conf: State<Config> ){
   cmd.send(RuntimeCommand::AddTab(graph.clone(), id.clone())).unwrap();
 
   let mut config = conf.store.lock().unwrap();
-  config.loaded_tabs.insert(id, graph);
+  config.loaded_tabs.insert(id, ( graph, name, location ));
   drop(config);
 
   conf.save();

src-tauri/src/utils/config.rs

···
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct ConfigValues{
   #[serde(default)]
-  pub loaded_tabs: HashMap<String, Vec<Node>>
+  pub loaded_tabs: HashMap<String, ( Vec<Node>, String, Option<String> )>
 }
 
 pub struct Config {

src/Mangers/NodeManager.tsx

···
     invoke('load_previous_tabs').then(async ( tabs: any ) => {
       let version = await getVersion();
 
-      for(let tab of Object.entries(tabs)){
+      for(let tab of Object.entries<any>(tabs)){
         console.log(tab);
 
-        await this._loadFromConfig(null, tab[0], JSON.stringify({
-          tab_name: 'test',
+        await this._loadFromConfig(tab[1][2], tab[0], JSON.stringify({
+          tab_name: tab[1][1],
           version,
-          graph: tab[1]
+          graph: tab[1][0]
         }));
       };
     });
···
     (async () => {
       let window = await getCurrentWindow();
 
-      window.onCloseRequested(async ev => {
-        ev.preventDefault();
-
+      window.onCloseRequested(async _ => {
         let tabs = Object.values(this._tabs);
         let tabsNeedingSaving = tabs.filter(x => x.needsSave());
 
···
             )
           });
         }
-
-        window.close();
       });
     })();
   }
···
       tab.saveLocation ||
       await save({ defaultPath: tab.name + '.macro', filters: [ { name: 'Macro Files', extensions: [ 'macro' ] } ] });
 
-    if(!path)return;
+    if(!path)throw new Error("Cannot save");
 
     tab.saveLocation = path;
     tab.setNeedsSave(false);
···
     if(!tab)return;
 
     if(tab.refuseSync)return;
-    invoke('sync_tab', { graph: this._generateTabGraph(tab.id)[0], id: tab.id });
+    invoke('sync_tab', { graph: this._generateTabGraph(tab.id)[0], id: tab.id, name: tab.name, location: tab.saveLocation });
 
     if(needsSave)tab.setNeedsSave(true);
   }