Settings

// From: src-tauri/src/app/options.rs:30
pub(crate) struct Options {
    #[serde(rename = "start")]
    pub start_options: StartOptions,
    #[serde(rename = "version")]
    pub version_options: VersionOptions,
    #[serde(rename = "launcher")]
    pub launcher_options: LauncherOptions,
    #[serde(rename = "premium")]
    pub premium_options: PremiumOptions,
}

// From: src-tauri/src/app/options.rs:42
pub(crate) struct StartOptions {
    #[serde(rename = "account")]
    pub minecraft_account: Option<MinecraftAccount>,
    #[serde(rename = "customDataPath", default)]
    pub custom_data_path: String,
    #[serde(rename = "javaDistribution", default)]
    pub java_distribution: DistributionSelection,
    #[serde(rename = "jvmArgs", default)]
    pub jvm_args: Option<Vec<String>>,
    #[serde(rename = "memory", default = "default_memory")]
    pub memory: u64,
}

// From: src-tauri/src/minecraft/java/distribution.rs:6
pub enum DistributionSelection {
    Automatic(String),  // Let launcher choose
    Custom(String),     // Custom Java path
    Manual(JavaDistribution),  // Specific distribution
}

{custom_data_path}/
├── assets/
├── gameDir/
├── libraries/
├── mod_cache/
├── custom_mods/
├── natives/
├── runtimes/
└── versions/

// Garbage Collection
-XX:+UseG1GC                    // Use G1 garbage collector
-XX:+ParallelRefProcEnabled      // Enable parallel reference processing
-XX:MaxGCPauseMillis=200         // Target max GC pause time

// Performance
-XX:+UnlockExperimentalVMOptions // Unlock experimental options
-XX:+DisableExplicitGC           // Disable explicit GC calls
-XX:+AlwaysPreTouch              // Pre-touch memory pages

// Memory
-Xms4G                           // Initial heap size
-Xmx8G                           // Maximum heap size

// Debugging
-XX:+PrintGCDetails              // Print GC details
-Xlog:gc*:file=gc.log            // Log GC to file

// From: src-tauri/src/app/options.rs:56
pub(crate) struct VersionOptions {
    #[serde(rename = "branchName")]
    pub branch_name: Option<String>,
    #[serde(rename = "buildId", default)]
    pub build_id: i32,
    #[serde(rename = "options", default)]
    pub options: HashMap<String, BranchOptions>,
}

// From: src-tauri/src/app/options.rs:88
pub(crate) struct BranchOptions {
    #[serde(rename = "modStates", default)]
    pub mod_states: HashMap<String, bool>,
    #[serde(rename = "customModStates", default)]
    pub custom_mod_states: HashMap<String, bool>,
}

// From: src-tauri/src/app/options.rs:66
pub(crate) struct LauncherOptions {
    #[serde(rename = "firstRun", default)]
    pub first_run: bool,
    #[serde(rename = "showNightlyBuilds")]
    pub show_nightly_builds: bool,
    #[serde(rename = "concurrentDownloads")]
    pub concurrent_downloads: u32,
    #[serde(rename = "keepLauncherOpen")]
    pub keep_launcher_open: bool,
    #[serde(rename = "sessionToken", default = "random_token")]
    pub session_token: String,
}

// From: src-tauri/src/app/options.rs:206
fn random_token() -> String {
    Alphanumeric.sample_string(&mut rand::rng(), 16)
}

// From: src-tauri/src/app/options.rs:80
pub(crate) struct PremiumOptions {
    #[serde(rename = "account")]
    pub account: Option<ClientAccount>,
    #[serde(rename = "skipAdvertisement", default)]
    pub skip_advertisement: bool,
}

// From: src-tauri/src/app/gui/commands/data.rs:26
#[tauri::command]
pub(crate) async fn get_options() -> Result<Options, String> {
    let config_dir = LAUNCHER_DIRECTORY.config_dir();
    let options = Options::load(config_dir).await.unwrap_or_default();
    Ok(options)
}

// From: src-tauri/src/app/gui/commands/data.rs:33
#[tauri::command]
pub(crate) async fn store_options(options: Options) -> Result<(), String> {
    let config_dir = LAUNCHER_DIRECTORY.config_dir();
    options
        .store(config_dir)
        .await
        .map_err(|e| format!("unable to store config data: {:?}", e))?;
    Ok(())
}

// Load current options
const options = await invoke('get_options');

// Modify settings
options.start.memory = 8192;  // 8 GB
options.launcher.concurrent_downloads = 15;
options.launcher.keep_launcher_open = true;

// Save changes
await invoke('store_options', { options });

// From: src-tauri/src/app/gui/commands/system.rs:52
#[tauri::command]
pub(crate) fn sys_memory() -> u64 {
    utils::sys_memory() / (1024 * 1024)
}

// From: src-tauri/src/app/gui/commands/system.rs:24
#[tauri::command]
pub(crate) async fn get_launcher_version() -> Result<String, String> {
    Ok(LAUNCHER_VERSION.to_string())
}

// From: src-tauri/src/app/gui/commands/data.rs:43
#[tauri::command]
pub(crate) async fn clear_data(options: Options) -> Result<(), String> {
    let data_directory = if !options.start_options.custom_data_path.is_empty() {
        Some(options.start_options.custom_data_path)
    } else {
        None
    }
        .map(|x| x.into())
        .unwrap_or_else(|| LAUNCHER_DIRECTORY.data_dir().to_path_buf());

    [
        "assets",
        "gameDir",
        "libraries",
        "mod_cache",
        "natives",
        "runtimes",
        "versions",
    ]
        .iter()
        .map(|dir| data_directory.join(dir))
        .filter(|dir| dir.exists())
        .map(std::fs::remove_dir_all)
        .collect::<Result<Vec<_>, _>>()?;
    Ok(())
}

// From: src-tauri/src/app/gui/commands/data.rs:71
#[tauri::command]
pub(crate) async fn default_data_folder_path() -> Result<String, String> {
    let data_directory = LAUNCHER_DIRECTORY.data_dir().to_str();

    match data_directory {
        None => Err("unable to get data folder path".to_string()),
        Some(path) => Ok(path.to_string()),
    }
}

// From: src-tauri/src/app/options.rs:96
impl Options {
    pub async fn load(app_data: &Path) -> Result<Self> {
        let file_content = fs::read(app_data.join("options.json")).await?;

        // Try modern format first
        if let Ok(options) = serde_json::from_slice::<Self>(&file_content) {
            return Ok(options);
        }

        // Fall back to legacy format
        if let Ok(legacy) = serde_json::from_slice::<LegacyOptions>(&file_content) {
            return Ok(Self::from_legacy(legacy));
        }

        Ok(serde_json::from_slice::<Self>(&file_content)?)
    }
}