Merge commit '74cf3f076eff43755bb4bef62f1c1bb3fc0e6c2a' into feature-clean

apps/app/src/api/mod.rs

@@ -18,6 +18,7 @@ pub mod utils;
 
 pub mod cache;
 pub mod friends;
+pub mod worlds;
 
 pub type Result<T> = std::result::Result<T, TheseusSerializableError>;
 

apps/app/src/api/profile.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use theseus::prelude::*;
+use theseus::profile::QuickPlayType;
 
 pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
     tauri::plugin::Builder::new("profile")
@@ -250,7 +251,7 @@ pub async fn profile_get_pack_export_candidates(
 // invoke('plugin:profile|profile_run', path)
 #[tauri::command]
 pub async fn profile_run(path: &str) -> Result<ProcessMetadata> {
-    let process = profile::run(path).await?;
+    let process = profile::run(path, &QuickPlayType::None).await?;
 
     Ok(process)
 }
@@ -264,7 +265,9 @@ pub async fn profile_run_credentials(
     path: &str,
     credentials: Credentials,
 ) -> Result<ProcessMetadata> {
-    let process = profile::run_credentials(path, &credentials).await?;
+    let process =
+        profile::run_credentials(path, &credentials, &QuickPlayType::None)
+            .await?;
 
     Ok(process)
 }
@@ -347,6 +350,9 @@ pub async fn profile_edit(path: &str, edit_profile: EditProfile) -> Result<()> {
             prof.name = name;
         }
         if let Some(game_version) = edit_profile.game_version.clone() {
+            if game_version != prof.game_version {
+                prof.protocol_version = None;
+            }
             prof.game_version = game_version;
         }
         if let Some(loader) = edit_profile.loader {

apps/app/src/api/utils.rs

@@ -1,12 +1,16 @@
 use serde::{Deserialize, Serialize};
+use tauri::Runtime;
+use tauri_plugin_opener::OpenerExt;
 use theseus::{
     handler,
     prelude::{CommandPayload, DirectoryInfo},
 };
 
-use crate::api::Result;
+use crate::api::{Result, TheseusSerializableError};
 use dashmap::DashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+use theseus::prelude::canonicalize;
+use url::Url;
 
 pub fn init<R: tauri::Runtime>() -> tauri::plugin::TauriPlugin<R> {
     tauri::plugin::Builder::new("utils")
@@ -52,57 +56,56 @@ pub enum OS {
 // Create a new HashMap with the same keys
 // Values provided should not be used directly, as they are not guaranteed to be up-to-date
 #[tauri::command]
-pub async fn progress_bars_list(
-) -> Result<DashMap<uuid::Uuid, theseus::LoadingBar>> {
+pub async fn progress_bars_list()
+-> Result<DashMap<uuid::Uuid, theseus::LoadingBar>> {
     let res = theseus::EventState::list_progress_bars().await?;
     Ok(res)
 }
 
-// cfg only on mac os
 // disables mouseover and fixes a random crash error only fixed by recent versions of macos
-#[cfg(target_os = "macos")]
 #[tauri::command]
 pub async fn should_disable_mouseover() -> bool {
-    // We try to match version to 12.2 or higher. If unrecognizable to pattern or lower, we default to the css with disabled mouseover for safety
-    let os = os_info::get();
-    if let os_info::Version::Semantic(major, minor, _) = os.version() {
-        if *major >= 12 && *minor >= 3 {
-            // Mac os version is 12.3 or higher, we allow mouseover
-            return false;
+    if cfg!(target_os = "macos") {
+        // We try to match version to 12.2 or higher. If unrecognizable to pattern or lower, we default to the css with disabled mouseover for safety
+        if let tauri_plugin_os::Version::Semantic(major, minor, _) =
+            tauri_plugin_os::version()
+        {
+            if major >= 12 && minor >= 3 {
+                // Mac os version is 12.3 or higher, we allow mouseover
+                return false;
+            }
         }
+        true
+    } else {
+        // Not macos, we allow mouseover
+        false
     }
-    true
-}
-#[cfg(not(target_os = "macos"))]
-#[tauri::command]
-pub async fn should_disable_mouseover() -> bool {
-    false
 }
 
 #[tauri::command]
-pub fn highlight_in_folder(path: PathBuf) {
-    let res = opener::reveal(path);
-
-    if let Err(e) = res {
+pub fn highlight_in_folder<R: Runtime>(
+    app: tauri::AppHandle<R>,
+    path: PathBuf,
+) {
+    if let Err(e) = app.opener().reveal_item_in_dir(path) {
         tracing::error!("Failed to highlight file in folder: {}", e);
     }
 }
 
 #[tauri::command]
-pub fn open_path(path: PathBuf) {
-    let res = opener::open(path);
-
-    if let Err(e) = res {
+pub fn open_path<R: Runtime>(app: tauri::AppHandle<R>, path: PathBuf) {
+    if let Err(e) = app.opener().open_path(path.to_string_lossy(), None::<&str>)
+    {
         tracing::error!("Failed to open path: {}", e);
     }
 }
 
 #[tauri::command]
-pub fn show_launcher_logs_folder() {
+pub fn show_launcher_logs_folder<R: Runtime>(app: tauri::AppHandle<R>) {
     let path = DirectoryInfo::launcher_logs_dir().unwrap_or_default();
     // failure to get folder just opens filesystem
     // (ie: if in debug mode only and launcher_logs never created)
-    open_path(path);
+    open_path(app, path);
 }
 
 // Get opening command
@@ -147,3 +150,28 @@ pub async fn handle_command(command: String) -> Result<()> {
     tracing::info!("handle command: {command}");
     Ok(theseus::handler::parse_and_emit_command(&command).await?)
 }
+
+// Remove when (and if) https://github.com/tauri-apps/tauri/issues/12022 is implemented
+pub(crate) fn tauri_convert_file_src(path: &Path) -> Result<Url> {
+    #[cfg(any(windows, target_os = "android"))]
+    const BASE: &str = "http://asset.localhost/";
+    #[cfg(not(any(windows, target_os = "android")))]
+    const BASE: &str = "asset://localhost/";
+
+    macro_rules! theseus_try {
+        ($test:expr) => {
+            match $test {
+                Ok(val) => val,
+                Err(e) => {
+                    return Err(TheseusSerializableError::Theseus(e.into()))
+                }
+            }
+        };
+    }
+
+    let path = theseus_try!(canonicalize(path));
+    let path = path.to_string_lossy();
+    let encoded = urlencoding::encode(&path);
+
+    Ok(theseus_try!(Url::parse(&format!("{BASE}{encoded}"))))
+}

apps/app/src/api/worlds.rs

@@ -0,0 +1,218 @@
+use crate::api::Result;
+use either::Either;
+use enumset::EnumSet;
+use tauri::{AppHandle, Manager, Runtime};
+use theseus::prelude::ProcessMetadata;
+use theseus::profile::{QuickPlayType, get_full_path};
+use theseus::worlds::{
+    DisplayStatus, ServerPackStatus, ServerStatus, World, WorldType,
+    WorldWithProfile,
+};
+use theseus::{profile, worlds};
+
+pub fn init<R: Runtime>() -> tauri::plugin::TauriPlugin<R> {
+    tauri::plugin::Builder::new("worlds")
+        .invoke_handler(tauri::generate_handler![
+            get_recent_worlds,
+            get_profile_worlds,
+            get_singleplayer_world,
+            set_world_display_status,
+            rename_world,
+            reset_world_icon,
+            backup_world,
+            delete_world,
+            add_server_to_profile,
+            edit_server_in_profile,
+            remove_server_from_profile,
+            get_profile_protocol_version,
+            get_server_status,
+            start_join_singleplayer_world,
+            start_join_server,
+        ])
+        .build()
+}
+
+#[tauri::command]
+pub async fn get_recent_worlds<R: Runtime>(
+    app_handle: AppHandle<R>,
+    limit: usize,
+    display_statuses: Option<EnumSet<DisplayStatus>>,
+) -> Result<Vec<WorldWithProfile>> {
+    let mut result = worlds::get_recent_worlds(
+        limit,
+        display_statuses.unwrap_or(EnumSet::all()),
+    )
+    .await?;
+    for world in result.iter_mut() {
+        adapt_world_icon(&app_handle, &mut world.world);
+    }
+    Ok(result)
+}
+
+#[tauri::command]
+pub async fn get_profile_worlds<R: Runtime>(
+    app_handle: AppHandle<R>,
+    path: &str,
+) -> Result<Vec<World>> {
+    let mut result = worlds::get_profile_worlds(path).await?;
+    for world in result.iter_mut() {
+        adapt_world_icon(&app_handle, world);
+    }
+    Ok(result)
+}
+
+#[tauri::command]
+pub async fn get_singleplayer_world<R: Runtime>(
+    app_handle: AppHandle<R>,
+    instance: &str,
+    world: &str,
+) -> Result<World> {
+    let mut world = worlds::get_singleplayer_world(instance, world).await?;
+    adapt_world_icon(&app_handle, &mut world);
+    Ok(world)
+}
+
+fn adapt_world_icon<R: Runtime>(app_handle: &AppHandle<R>, world: &mut World) {
+    if let Some(Either::Left(icon_path)) = &world.icon {
+        let icon_path = icon_path.clone();
+        if let Ok(new_url) = super::utils::tauri_convert_file_src(&icon_path) {
+            world.icon = Some(Either::Right(new_url));
+            if let Err(e) =
+                app_handle.asset_protocol_scope().allow_file(&icon_path)
+            {
+                tracing::warn!(
+                    "Failed to allow file access for icon {}: {}",
+                    icon_path.display(),
+                    e
+                );
+            }
+        } else {
+            tracing::warn!(
+                "Encountered invalid icon path for world {}: {}",
+                world.name,
+                icon_path.display()
+            );
+            world.icon = None;
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn set_world_display_status(
+    instance: &str,
+    world_type: WorldType,
+    world_id: &str,
+    display_status: DisplayStatus,
+) -> Result<()> {
+    Ok(worlds::set_world_display_status(
+        instance,
+        world_type,
+        world_id,
+        display_status,
+    )
+    .await?)
+}
+
+#[tauri::command]
+pub async fn rename_world(
+    instance: &str,
+    world: &str,
+    new_name: &str,
+) -> Result<()> {
+    let instance = get_full_path(instance).await?;
+    worlds::rename_world(&instance, world, new_name).await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn reset_world_icon(instance: &str, world: &str) -> Result<()> {
+    let instance = get_full_path(instance).await?;
+    worlds::reset_world_icon(&instance, world).await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn backup_world(instance: &str, world: &str) -> Result<u64> {
+    let instance = get_full_path(instance).await?;
+    Ok(worlds::backup_world(&instance, world).await?)
+}
+
+#[tauri::command]
+pub async fn delete_world(instance: &str, world: &str) -> Result<()> {
+    let instance = get_full_path(instance).await?;
+    worlds::delete_world(&instance, world).await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn add_server_to_profile(
+    path: &str,
+    name: String,
+    address: String,
+    pack_status: ServerPackStatus,
+) -> Result<usize> {
+    let path = get_full_path(path).await?;
+    Ok(
+        worlds::add_server_to_profile(&path, name, address, pack_status)
+            .await?,
+    )
+}
+
+#[tauri::command]
+pub async fn edit_server_in_profile(
+    path: &str,
+    index: usize,
+    name: String,
+    address: String,
+    pack_status: ServerPackStatus,
+) -> Result<()> {
+    let path = get_full_path(path).await?;
+    worlds::edit_server_in_profile(&path, index, name, address, pack_status)
+        .await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn remove_server_from_profile(
+    path: &str,
+    index: usize,
+) -> Result<()> {
+    let path = get_full_path(path).await?;
+    worlds::remove_server_from_profile(&path, index).await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn get_profile_protocol_version(path: &str) -> Result<Option<i32>> {
+    Ok(worlds::get_profile_protocol_version(path).await?)
+}
+
+#[tauri::command]
+pub async fn get_server_status(
+    address: &str,
+    protocol_version: Option<i32>,
+) -> Result<ServerStatus> {
+    Ok(worlds::get_server_status(address, protocol_version).await?)
+}
+
+#[tauri::command]
+pub async fn start_join_singleplayer_world(
+    path: &str,
+    world: String,
+) -> Result<ProcessMetadata> {
+    let process =
+        profile::run(path, &QuickPlayType::Singleplayer(world)).await?;
+
+    Ok(process)
+}
+
+#[tauri::command]
+pub async fn start_join_server(
+    path: &str,
+    address: &str,
+) -> Result<ProcessMetadata> {
+    let process =
+        profile::run(path, &QuickPlayType::Server(address.to_owned())).await?;
+
+    Ok(process)
+}