egui/eframe UI, clean up deps, remove Svelte/Tauri frontend

src-tauri/src/transfer/manager.rs

@@ -1,32 +1,21 @@
-use std::sync::Arc;
-use tauri::AppHandle;
-use crate::transfer::queue::TransferQueue;
-use crate::transfer::worker::spawn_worker;
 use crate::fs::remote::RemoteRegistry;
+use crate::transfer::queue::TransferQueue;
+use std::sync::Arc;
 
-/// Хранит очередь передач и запускает воркер.
 pub struct TransferManager {
     pub queue: TransferQueue,
-    registry: Arc<RemoteRegistry>,
-    app: AppHandle,
+    pub registry: Arc<RemoteRegistry>,
 }
 
 impl TransferManager {
-    pub fn new(registry: Arc<RemoteRegistry>, app: AppHandle) -> Arc<Self> {
-        let manager = Arc::new(Self {
+    pub fn new(registry: Arc<RemoteRegistry>) -> Arc<Self> {
+        Arc::new(Self {
             queue: TransferQueue::default(),
-            registry: registry.clone(),
-            app: app.clone(),
-        });
-        spawn_worker(manager.clone(), registry, app);
-        manager
+            registry,
+        })
     }
 
     pub fn registry(&self) -> &RemoteRegistry {
         &self.registry
     }
-
-    pub fn app(&self) -> &AppHandle {
-        &self.app
-    }
 }

src-tauri/src/transfer/queue.rs

@@ -1,6 +1,6 @@
+use crate::domain::transfer::{TaskState, TransferTask};
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
-use crate::domain::transfer::{TransferTask, TaskState};
 
 #[derive(Clone, Default)]
 pub struct TransferQueue {
@@ -32,10 +32,8 @@ impl TransferQueue {
         if let Some(t) = q.iter_mut().find(|t| t.id == id) {
             t.transferred_bytes = transferred;
             t.speed = Some(speed);
-            if speed > 0 {
-                let remaining = t.total_bytes.saturating_sub(transferred);
-                t.eta_secs = Some(remaining / speed);
-            }
+            let remaining = t.total_bytes.saturating_sub(transferred);
+            t.eta_secs = remaining.checked_div(speed);
         }
     }
 

src-tauri/src/transfer/task.rs

@@ -1,4 +1,4 @@
-use crate::domain::transfer::{TransferTask, TransferKind};
+use crate::domain::transfer::{TransferKind, TransferTask};
 
 pub fn new_task(
     kind: TransferKind,

src-tauri/src/transfer/worker.rs

@@ -1,40 +1,25 @@
 use std::sync::Arc;
-use tauri::{AppHandle, Emitter};
-use tokio::time::{sleep, Duration};
+use tokio::time::{Duration, sleep};
 
 use crate::domain::transfer::{TaskState, TransferKind};
 use crate::fs::remote::RemoteRegistry;
-use crate::transfer::manager::TransferManager;
-
-/// Событие для фронтенда
-#[derive(Clone, serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-struct TransferProgress {
-    task_id: String,
-    state: String,
-    transferred_bytes: u64,
-    total_bytes: u64,
-    speed: Option<u64>,
-    eta_secs: Option<u64>,
-    error: Option<String>,
-}
+use crate::transfer::queue::TransferQueue;
 
 pub fn spawn_worker(
-    manager: Arc<TransferManager>,
+    queue: TransferQueue,
     registry: Arc<RemoteRegistry>,
-    app: AppHandle,
+    rt_handle: tokio::runtime::Handle,
 ) {
-    tokio::spawn(async move {
+    rt_handle.spawn(async move {
         loop {
             let task = {
-                let task = manager.queue.pop();
-                if let Some(ref t) = task {
-                    if t.state != TaskState::Queued {
-                        // paused/cancelled — не трогаем, вернём
-                        manager.queue.push(t.clone());
-                        sleep(Duration::from_millis(500)).await;
-                        continue;
-                    }
+                let task = queue.pop();
+                if let Some(ref t) = task
+                    && t.state != TaskState::Queued
+                {
+                    queue.push(t.clone());
+                    sleep(Duration::from_millis(500)).await;
+                    continue;
                 }
                 task
             };
@@ -47,17 +32,14 @@ pub fn spawn_worker(
                 }
             };
 
-            // Старт
             task.state = TaskState::Running;
-            manager.queue.update_state(&task.id, TaskState::Running);
-            emit_progress(&app, &task, None);
+            queue.update_state(&task.id, TaskState::Running);
 
             let fs = match registry.get(&task.connection_id) {
                 Some(fs) => fs,
                 None => {
                     task.state = TaskState::Failed("connection not found".into());
-                    manager.queue.update_state(&task.id, task.state.clone());
-                    emit_progress(&app, &task, Some("connection not found"));
+                    queue.update_state(&task.id, task.state.clone());
                     continue;
                 }
             };
@@ -71,29 +53,15 @@ pub fn spawn_worker(
                 Ok(()) => {
                     task.state = TaskState::Completed;
                     task.transferred_bytes = task.total_bytes;
-                    manager.queue.update_state(&task.id, TaskState::Completed);
-                    manager.queue.update_progress(&task.id, task.total_bytes, 0);
-                    emit_progress(&app, &task, None);
+                    queue.update_state(&task.id, TaskState::Completed);
+                    queue.update_progress(&task.id, task.total_bytes, 0);
                 }
                 Err(e) => {
                     let msg = e.to_string();
-                    task.state = TaskState::Failed(msg.clone());
-                    manager.queue.update_state(&task.id, TaskState::Failed(msg.clone()));
-                    emit_progress(&app, &task, Some(&msg));
+                    task.state = TaskState::Failed(msg);
+                    queue.update_state(&task.id, task.state.clone());
                 }
             }
         }
     });
 }
-
-fn emit_progress(app: &AppHandle, task: &crate::domain::transfer::TransferTask, error: Option<&str>) {
-    let _ = app.emit("transfer-progress", TransferProgress {
-        task_id: task.id.clone(),
-        state: task.state.to_string(),
-        transferred_bytes: task.transferred_bytes,
-        total_bytes: task.total_bytes,
-        speed: task.speed,
-        eta_secs: task.eta_secs,
-        error: error.map(|s| s.to_string()),
-    });
-}