Migrate from window.electron to tauri IPC functions across components

- Replaced `window.electron.invoke` calls with equivalent `tauri` function calls for all IPC interactions.
- Removed `electron.d.ts` TypeScript definitions as they are no longer needed.
- Updated related logic for offline/online state synchronization.
- Added `types.rs` and `shared/mod.rs` modules to support Tauri IPC integration with Rust enums and shared logic.
- Refactored IPC request queues to use updated handler names for consistency with Tauri.

src-tauri/src/domains/tombstone/commands.rs

@@ -0,0 +1,120 @@
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+use crate::db::connection::DbManager;
+use crate::domains::tombstone::repo;
+use crate::domains::book::service as book_service;
+use crate::domains::chapter::service as chapter_service;
+use crate::domains::character::service as character_service;
+use crate::domains::location::service as location_service;
+use crate::domains::world::service as world_service;
+use crate::domains::incident::service as incident_service;
+use crate::domains::plotpoint::service as plotpoint_service;
+use crate::domains::issue::service as issue_service;
+use crate::domains::spell::service as spell_service;
+use crate::domains::series::service as series_service;
+use crate::domains::series_character::service as series_character_service;
+use crate::domains::series_location::service as series_location_service;
+use crate::domains::series_world::service as series_world_service;
+use crate::domains::series_spell::service as series_spell_service;
+use crate::error::AppError;
+use crate::shared::session::SessionState;
+use crate::shared::types::Lang;
+
+fn get_session(session: &State<SessionState>) -> Result<(String, Lang), AppError> {
+    let session_guard = session.lock().map_err(|e| AppError::Internal(format!("Session lock failed: {}", e)))?;
+    let user_id = session_guard.get_user_id().map_err(|e| AppError::Auth(e))?.to_string();
+    let lang = session_guard.lang;
+    Ok((user_id, lang))
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TombstoneRecord {
+    pub table_name: String,
+    pub entity_id: String,
+    pub book_id: Option<String>,
+    pub deleted_at: i64,
+}
+
+#[tauri::command]
+pub fn get_tombstones_since(since: i64, db: State<DbManager>, session: State<SessionState>) -> Result<Vec<TombstoneRecord>, AppError> {
+    let (user_id, lang) = get_session(&session)?;
+    let db_manager = db.lock().map_err(|e| AppError::Internal(format!("DB lock failed: {}", e)))?;
+    let conn = db_manager.get_connection(&user_id)?;
+    let records = repo::get_deletions_since(conn, &user_id, since, lang)?;
+    Ok(records.into_iter().map(|record| TombstoneRecord {
+        table_name: record.table_name,
+        entity_id: record.entity_id,
+        book_id: record.book_id,
+        deleted_at: record.deleted_at,
+    }).collect())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TombstoneInput {
+    pub table_name: String,
+    pub entity_id: String,
+    pub book_id: Option<String>,
+    pub deleted_at: i64,
+}
+
+#[tauri::command]
+pub fn apply_book_tombstones(tombstones: Vec<TombstoneInput>, db: State<DbManager>, session: State<SessionState>) -> Result<(), AppError> {
+    let (user_id, lang) = get_session(&session)?;
+    let db_manager = db.lock().map_err(|e| AppError::Internal(format!("DB lock failed: {}", e)))?;
+    let conn = db_manager.get_connection(&user_id)?;
+
+    for tombstone in &tombstones {
+        let book_id = tombstone.book_id.as_deref().unwrap_or("");
+        match tombstone.table_name.as_str() {
+            "erit_books" => { let _ = book_service::remove_book(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_chapters" => { let _ = chapter_service::remove_chapter(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_chapter_infos" => { let _ = chapter_service::remove_chapter_information(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_characters" => { let _ = character_service::delete_character(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_characters_attributes" => { let _ = character_service::delete_attribute(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_location" => { let _ = location_service::delete_location_section(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "location_element" => { let _ = location_service::delete_location_element(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "location_sub_element" => { let _ = location_service::delete_location_sub_element(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_world_elements" => { let _ = world_service::remove_element_from_world(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_incidents" => { let _ = incident_service::remove_incident(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_plot_points" => { let _ = plotpoint_service::remove_plot_point(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_issues" => { let _ = issue_service::remove_issue(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_spells" => { let _ = spell_service::delete_spell(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "book_spell_tags" => { let _ = spell_service::delete_spell_tag(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            _ => {}
+        }
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub fn apply_series_tombstones(tombstones: Vec<TombstoneInput>, db: State<DbManager>, session: State<SessionState>) -> Result<(), AppError> {
+    let (user_id, lang) = get_session(&session)?;
+    let db_manager = db.lock().map_err(|e| AppError::Internal(format!("DB lock failed: {}", e)))?;
+    let conn = db_manager.get_connection(&user_id)?;
+
+    for tombstone in &tombstones {
+        match tombstone.table_name.as_str() {
+            "erit_series" => { let _ = series_service::delete_series(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_books" => {
+                if let Some(ref book_id) = tombstone.book_id {
+                    let _ = series_service::remove_book_from_series(conn, &user_id, book_id, &tombstone.entity_id, tombstone.deleted_at, lang);
+                }
+            }
+            "series_characters" => { let _ = series_character_service::delete_character(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_characters_attributes" => { let _ = series_character_service::delete_attribute(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_locations" => { let _ = series_location_service::delete_location(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_location_elements" => { let _ = series_location_service::delete_element(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_location_sub_elements" => { let _ = series_location_service::delete_sub_element(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_world_elements" => { let _ = series_world_service::delete_element(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_spells" => { let _ = series_spell_service::delete_spell(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            "series_spell_tags" => { let _ = series_spell_service::delete_tag(conn, &user_id, &tombstone.entity_id, tombstone.deleted_at, lang); }
+            _ => {}
+        }
+    }
+
+    Ok(())
+}