refactor: migrate to common eslint+prettier configs (#4168)

* refactor: migrate to common eslint+prettier configs

* fix: prettier frontend

* feat: config changes

* fix: lint issues

* fix: lint

* fix: type imports

* fix: cyclical import issue

* fix: lockfile

* fix: missing dep

* fix: switch to tabs

* fix: continue switch to tabs

* fix: rustfmt parity

* fix: moderation lint issue

* fix: lint issues

* fix: ui intl

* fix: lint issues

* Revert "fix: rustfmt parity"

This reverts commit cb99d2376c321d813d4b7fc7e2a213bb30a54711.

* feat: revert last rs

apps/app-frontend/src/helpers/ads.js

@@ -1,21 +1,24 @@
 import { invoke } from '@tauri-apps/api/core'
 
 export async function init_ads_window(overrideShown = false) {
-  return await invoke('plugin:ads|init_ads_window', { overrideShown, dpr: window.devicePixelRatio })
+	return await invoke('plugin:ads|init_ads_window', {
+		overrideShown,
+		dpr: window.devicePixelRatio,
+	})
 }
 
 export async function show_ads_window() {
-  return await invoke('plugin:ads|show_ads_window', { dpr: window.devicePixelRatio })
+	return await invoke('plugin:ads|show_ads_window', { dpr: window.devicePixelRatio })
 }
 
 export async function hide_ads_window(reset) {
-  return await invoke('plugin:ads|hide_ads_window', { reset })
+	return await invoke('plugin:ads|hide_ads_window', { reset })
 }
 
 export async function record_ads_click() {
-  return await invoke('plugin:ads|record_ads_click')
+	return await invoke('plugin:ads|record_ads_click')
 }
 
 export async function open_ads_link(path, origin) {
-  return await invoke('plugin:ads|open_link', { path, origin })
+	return await invoke('plugin:ads|open_link', { path, origin })
 }

apps/app-frontend/src/helpers/analytics.js

@@ -1,24 +1,24 @@
 import { posthog } from 'posthog-js'
 
 export const initAnalytics = () => {
-  posthog.init('phc_9Iqi6lFs9sr5BSqh9RRNRSJ0mATS9PSgirDiX3iOYJ', {
-    persistence: 'localStorage',
-    api_host: 'https://posthog.modrinth.com',
-  })
+	posthog.init('phc_9Iqi6lFs9sr5BSqh9RRNRSJ0mATS9PSgirDiX3iOYJ', {
+		persistence: 'localStorage',
+		api_host: 'https://posthog.modrinth.com',
+	})
 }
 
 export const debugAnalytics = () => {
-  posthog.debug()
+	posthog.debug()
 }
 
 export const optOutAnalytics = () => {
-  posthog.opt_out_capturing()
+	posthog.opt_out_capturing()
 }
 
 export const optInAnalytics = () => {
-  posthog.opt_in_capturing()
+	posthog.opt_in_capturing()
 }
 
 export const trackEvent = (eventName, properties) => {
-  posthog.capture(eventName, properties)
+	posthog.capture(eventName, properties)
 }

apps/app-frontend/src/helpers/auth.js

@@ -22,7 +22,7 @@ import { invoke } from '@tauri-apps/api/core'
  * @property {string} user_code - The code to enter on the verification_uri page.
  */
 export async function login() {
-  return await invoke('plugin:auth|login')
+	return await invoke('plugin:auth|login')
 }
 
 /**
@@ -30,7 +30,7 @@ export async function login() {
  * @return {Promise<UUID | undefined>}
  */
 export async function get_default_user() {
-  return await invoke('plugin:auth|get_default_user')
+	return await invoke('plugin:auth|get_default_user')
 }
 
 /**
@@ -38,7 +38,7 @@ export async function get_default_user() {
  * @param {UUID} user
  */
 export async function set_default_user(user) {
-  return await invoke('plugin:auth|set_default_user', { user })
+	return await invoke('plugin:auth|set_default_user', { user })
 }
 
 /**
@@ -46,7 +46,7 @@ export async function set_default_user(user) {
  * @param {UUID} user
  */
 export async function remove_user(user) {
-  return await invoke('plugin:auth|remove_user', { user })
+	return await invoke('plugin:auth|remove_user', { user })
 }
 
 /**
@@ -54,5 +54,5 @@ export async function remove_user(user) {
  * @returns {Promise<Credential[]>}
  */
 export async function users() {
-  return await invoke('plugin:auth|get_users')
+	return await invoke('plugin:auth|get_users')
 }

apps/app-frontend/src/helpers/cache.js

@@ -1,53 +1,53 @@
 import { invoke } from '@tauri-apps/api/core'
 
 export async function get_project(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_project', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_project', { id, cacheBehaviour })
 }
 
 export async function get_project_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_project_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_project_many', { ids, cacheBehaviour })
 }
 
 export async function get_version(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_version', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_version', { id, cacheBehaviour })
 }
 
 export async function get_version_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_version_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_version_many', { ids, cacheBehaviour })
 }
 
 export async function get_user(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_user', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_user', { id, cacheBehaviour })
 }
 
 export async function get_user_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_user_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_user_many', { ids, cacheBehaviour })
 }
 
 export async function get_team(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_team', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_team', { id, cacheBehaviour })
 }
 
 export async function get_team_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_team_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_team_many', { ids, cacheBehaviour })
 }
 
 export async function get_organization(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_organization', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_organization', { id, cacheBehaviour })
 }
 
 export async function get_organization_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_organization_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_organization_many', { ids, cacheBehaviour })
 }
 
 export async function get_search_results(id, cacheBehaviour) {
-  return await invoke('plugin:cache|get_search_results', { id, cacheBehaviour })
+	return await invoke('plugin:cache|get_search_results', { id, cacheBehaviour })
 }
 
 export async function get_search_results_many(ids, cacheBehaviour) {
-  return await invoke('plugin:cache|get_search_results_many', { ids, cacheBehaviour })
+	return await invoke('plugin:cache|get_search_results_many', { ids, cacheBehaviour })
 }
 
 export async function purge_cache_types(cacheTypes) {
-  return await invoke('plugin:cache|purge_cache_types', { cacheTypes })
+	return await invoke('plugin:cache|purge_cache_types', { cacheTypes })
 }

apps/app-frontend/src/helpers/events.js

@@ -41,7 +41,7 @@ import { listen } from '@tauri-apps/api/event'
     }
 */
 export async function loading_listener(callback) {
-  return await listen('loading', (event) => callback(event.payload))
+	return await listen('loading', (event) => callback(event.payload))
 }
 
 /// Payload for the 'process' event
@@ -54,7 +54,7 @@ export async function loading_listener(callback) {
     }
 */
 export async function process_listener(callback) {
-  return await listen('process', (event) => callback(event.payload))
+	return await listen('process', (event) => callback(event.payload))
 }
 
 /// Payload for the 'profile' event
@@ -68,7 +68,7 @@ export async function process_listener(callback) {
     }
 */
 export async function profile_listener(callback) {
-  return await listen('profile', (event) => callback(event.payload))
+	return await listen('profile', (event) => callback(event.payload))
 }
 
 /// Payload for the 'command' event
@@ -79,9 +79,9 @@ export async function profile_listener(callback) {
   }
 */
 export async function command_listener(callback) {
-  return await listen('command', (event) => {
-    callback(event.payload)
-  })
+	return await listen('command', (event) => {
+		callback(event.payload)
+	})
 }
 
 /// Payload for the 'warning' event
@@ -91,9 +91,9 @@ export async function command_listener(callback) {
     }
 */
 export async function warning_listener(callback) {
-  return await listen('warning', (event) => callback(event.payload))
+	return await listen('warning', (event) => callback(event.payload))
 }
 
 export async function friend_listener(callback) {
-  return await listen('friend', (event) => callback(event.payload))
+	return await listen('friend', (event) => callback(event.payload))
 }

apps/app-frontend/src/helpers/fetch.js

@@ -3,17 +3,17 @@ import { getVersion } from '@tauri-apps/api/app'
 import { fetch } from '@tauri-apps/plugin-http'
 
 export const useFetch = async (url, item, isSilent) => {
-  try {
-    const version = await getVersion()
-    return await fetch(url, {
-      method: 'GET',
-      headers: { 'User-Agent': `modrinth/theseus/${version} (support@modrinth.com)` },
-    })
-  } catch (err) {
-    if (!isSilent) {
-      const { handleError } = injectNotificationManager()
-      handleError({ message: `Error fetching ${item}` })
-    }
-    console.error(err)
-  }
+	try {
+		const version = await getVersion()
+		return await fetch(url, {
+			method: 'GET',
+			headers: { 'User-Agent': `modrinth/theseus/${version} (support@modrinth.com)` },
+		})
+	} catch (err) {
+		if (!isSilent) {
+			const { handleError } = injectNotificationManager()
+			handleError({ message: `Error fetching ${item}` })
+		}
+		console.error(err)
+	}
 }

apps/app-frontend/src/helpers/friends.js

@@ -1,17 +1,17 @@
 import { invoke } from '@tauri-apps/api/core'
 
 export async function friends() {
-  return await invoke('plugin:friends|friends')
+	return await invoke('plugin:friends|friends')
 }
 
 export async function friend_statuses() {
-  return await invoke('plugin:friends|friend_statuses')
+	return await invoke('plugin:friends|friend_statuses')
 }
 
 export async function add_friend(userId) {
-  return await invoke('plugin:friends|add_friend', { userId })
+	return await invoke('plugin:friends|add_friend', { userId })
 }
 
 export async function remove_friend(userId) {
-  return await invoke('plugin:friends|remove_friend', { userId })
+	return await invoke('plugin:friends|remove_friend', { userId })
 }

apps/app-frontend/src/helpers/import.js

@@ -4,6 +4,7 @@
  *  and deserialized into a usable JS object.
  */
 import { invoke } from '@tauri-apps/api/core'
+
 import { create } from './profile'
 
 /*
@@ -27,37 +28,37 @@ import { create } from './profile'
 /// eg: get_importable_instances("MultiMC", "C:/MultiMC")
 /// returns ["Instance 1", "Instance 2"]
 export async function get_importable_instances(launcherType, basePath) {
-  return await invoke('plugin:import|get_importable_instances', { launcherType, basePath })
+	return await invoke('plugin:import|get_importable_instances', { launcherType, basePath })
 }
 
 /// Import an instance from a launcher type and base path
 /// eg: import_instance("profile-name-to-go-to", "MultiMC", "C:/MultiMC", "Instance 1")
 export async function import_instance(launcherType, basePath, instanceFolder) {
-  // create a basic, empty instance (most properties will be filled in by the import process)
-  // We do NOT watch the fs for changes to avoid duplicate events during installation
-  // fs watching will be enabled once the instance is imported
-  const profilePath = await create(instanceFolder, '1.19.4', 'vanilla', 'latest', null, true)
+	// create a basic, empty instance (most properties will be filled in by the import process)
+	// We do NOT watch the fs for changes to avoid duplicate events during installation
+	// fs watching will be enabled once the instance is imported
+	const profilePath = await create(instanceFolder, '1.19.4', 'vanilla', 'latest', null, true)
 
-  return await invoke('plugin:import|import_instance', {
-    profilePath,
-    launcherType,
-    basePath,
-    instanceFolder,
-  })
+	return await invoke('plugin:import|import_instance', {
+		profilePath,
+		launcherType,
+		basePath,
+		instanceFolder,
+	})
 }
 
 /// Checks if this instance is valid for importing, given a certain launcher type
 /// eg: is_valid_importable_instance("C:/MultiMC/Instance 1", "MultiMC")
 export async function is_valid_importable_instance(instanceFolder, launcherType) {
-  return await invoke('plugin:import|is_valid_importable_instance', {
-    instanceFolder,
-    launcherType,
-  })
+	return await invoke('plugin:import|is_valid_importable_instance', {
+		instanceFolder,
+		launcherType,
+	})
 }
 
 /// Gets the default path for the given launcher type
 /// null if it can't be found or doesn't exist
 /// eg: get_default_launcher_path("MultiMC")
 export async function get_default_launcher_path(launcherType) {
-  return await invoke('plugin:import|get_default_launcher_path', { launcherType })
+	return await invoke('plugin:import|get_default_launcher_path', { launcherType })
 }

apps/app-frontend/src/helpers/jre.js

@@ -15,37 +15,37 @@ JavaVersion {
 */
 
 export async function get_java_versions() {
-  return await invoke('plugin:jre|get_java_versions')
+	return await invoke('plugin:jre|get_java_versions')
 }
 
 export async function set_java_version(javaVersion) {
-  return await invoke('plugin:jre|set_java_version', { javaVersion })
+	return await invoke('plugin:jre|set_java_version', { javaVersion })
 }
 
 // Finds all the installation of Java 7, if it exists
 // Returns [JavaVersion]
 export async function find_filtered_jres(version) {
-  return await invoke('plugin:jre|jre_find_filtered_jres', { version })
+	return await invoke('plugin:jre|jre_find_filtered_jres', { version })
 }
 
 // Gets java version from a specific path by trying to run 'java -version' on it.
 // This also validates it, as it returns null if no valid java version is found at the path
 export async function get_jre(path) {
-  return await invoke('plugin:jre|jre_get_jre', { path })
+	return await invoke('plugin:jre|jre_get_jre', { path })
 }
 
 // Tests JRE version by running 'java -version' on it.
 // Returns true if the version is valid, and matches given (after extraction)
 export async function test_jre(path, majorVersion) {
-  return await invoke('plugin:jre|jre_test_jre', { path, majorVersion })
+	return await invoke('plugin:jre|jre_test_jre', { path, majorVersion })
 }
 
 // Automatically installs specified java version
 export async function auto_install_java(javaVersion) {
-  return await invoke('plugin:jre|jre_auto_install_java', { javaVersion })
+	return await invoke('plugin:jre|jre_auto_install_java', { javaVersion })
 }
 
 // Get max memory in KiB
 export async function get_max_memory() {
-  return await invoke('plugin:jre|jre_get_max_memory')
+	return await invoke('plugin:jre|jre_get_max_memory')
 }

apps/app-frontend/src/helpers/logs.js

@@ -18,31 +18,35 @@ pub struct Logs {
 /// Get all logs that exist for a given profile
 /// This is returned as an array of Log objects, sorted by filename (the folder name, when the log was created)
 export async function get_logs(profilePath, clearContents) {
-  return await invoke('plugin:logs|logs_get_logs', { profilePath, clearContents })
+	return await invoke('plugin:logs|logs_get_logs', { profilePath, clearContents })
 }
 
 /// Get a profile's log by filename
 export async function get_logs_by_filename(profilePath, logType, filename) {
-  return await invoke('plugin:logs|logs_get_logs_by_filename', { profilePath, logType, filename })
+	return await invoke('plugin:logs|logs_get_logs_by_filename', { profilePath, logType, filename })
 }
 
 /// Get a profile's log text only by filename
 export async function get_output_by_filename(profilePath, logType, filename) {
-  return await invoke('plugin:logs|logs_get_output_by_filename', { profilePath, logType, filename })
+	return await invoke('plugin:logs|logs_get_output_by_filename', {
+		profilePath,
+		logType,
+		filename,
+	})
 }
 
 /// Delete a profile's log by filename
 export async function delete_logs_by_filename(profilePath, logType, filename) {
-  return await invoke('plugin:logs|logs_delete_logs_by_filename', {
-    profilePath,
-    logType,
-    filename,
-  })
+	return await invoke('plugin:logs|logs_delete_logs_by_filename', {
+		profilePath,
+		logType,
+		filename,
+	})
 }
 
 /// Delete all logs for a given profile
 export async function delete_logs(profilePath) {
-  return await invoke('plugin:logs|logs_delete_logs', { profilePath })
+	return await invoke('plugin:logs|logs_delete_logs', { profilePath })
 }
 
 /// Get the latest log for a given profile and cursor (startpoint to read withi nthe file)
@@ -57,5 +61,5 @@ export async function delete_logs(profilePath) {
 
 // From latest.log directly
 export async function get_latest_log_cursor(profilePath, cursor) {
-  return await invoke('plugin:logs|logs_get_latest_log_cursor', { profilePath, cursor })
+	return await invoke('plugin:logs|logs_get_latest_log_cursor', { profilePath, cursor })
 }

apps/app-frontend/src/helpers/metadata.js

@@ -3,11 +3,11 @@ import { invoke } from '@tauri-apps/api/core'
 /// Gets the game versions from daedalus
 // Returns a VersionManifest
 export async function get_game_versions() {
-  return await invoke('plugin:metadata|metadata_get_game_versions')
+	return await invoke('plugin:metadata|metadata_get_game_versions')
 }
 
 // Gets the given loader versions from daedalus
 // Returns Manifest
 export async function get_loader_versions(loader) {
-  return await invoke('plugin:metadata|metadata_get_loader_versions', { loader })
+	return await invoke('plugin:metadata|metadata_get_loader_versions', { loader })
 }

apps/app-frontend/src/helpers/mr_auth.js

@@ -6,17 +6,17 @@
 import { invoke } from '@tauri-apps/api/core'
 
 export async function login() {
-  return await invoke('plugin:mr-auth|modrinth_login')
+	return await invoke('plugin:mr-auth|modrinth_login')
 }
 
 export async function logout() {
-  return await invoke('plugin:mr-auth|logout')
+	return await invoke('plugin:mr-auth|logout')
 }
 
 export async function get() {
-  return await invoke('plugin:mr-auth|get')
+	return await invoke('plugin:mr-auth|get')
 }
 
 export async function cancelLogin() {
-  return await invoke('plugin:mr-auth|cancel_modrinth_login')
+	return await invoke('plugin:mr-auth|cancel_modrinth_login')
 }

apps/app-frontend/src/helpers/pack.js

@@ -4,61 +4,62 @@
  *  and deserialized into a usable JS object.
  */
 import { invoke } from '@tauri-apps/api/core'
+
 import { create } from './profile'
 
 // Installs pack from a version ID
 export async function create_profile_and_install(
-  projectId,
-  versionId,
-  packTitle,
-  iconUrl,
-  createInstanceCallback = () => {},
+	projectId,
+	versionId,
+	packTitle,
+	iconUrl,
+	createInstanceCallback = () => {},
 ) {
-  const location = {
-    type: 'fromVersionId',
-    project_id: projectId,
-    version_id: versionId,
-    title: packTitle,
-    icon_url: iconUrl,
-  }
-  const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
-  const profile = await create(
-    profile_creator.name,
-    profile_creator.gameVersion,
-    profile_creator.modloader,
-    profile_creator.loaderVersion,
-    null,
-    true,
-  )
-  createInstanceCallback(profile)
+	const location = {
+		type: 'fromVersionId',
+		project_id: projectId,
+		version_id: versionId,
+		title: packTitle,
+		icon_url: iconUrl,
+	}
+	const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
+	const profile = await create(
+		profile_creator.name,
+		profile_creator.gameVersion,
+		profile_creator.modloader,
+		profile_creator.loaderVersion,
+		null,
+		true,
+	)
+	createInstanceCallback(profile)
 
-  return await invoke('plugin:pack|pack_install', { location, profile })
+	return await invoke('plugin:pack|pack_install', { location, profile })
 }
 
 export async function install_to_existing_profile(projectId, versionId, title, profilePath) {
-  const location = {
-    type: 'fromVersionId',
-    project_id: projectId,
-    version_id: versionId,
-    title,
-  }
-  return await invoke('plugin:pack|pack_install', { location, profile: profilePath })
+	const location = {
+		type: 'fromVersionId',
+		project_id: projectId,
+		version_id: versionId,
+		title,
+	}
+	return await invoke('plugin:pack|pack_install', { location, profile: profilePath })
 }
 
 // Installs pack from a path
 export async function create_profile_and_install_from_file(path) {
-  const location = {
-    type: 'fromFile',
-    path: path,
-  }
-  const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
-  const profile = await create(
-    profile_creator.name,
-    profile_creator.gameVersion,
-    profile_creator.modloader,
-    profile_creator.loaderVersion,
-    null,
-    true,
-  )
-  return await invoke('plugin:pack|pack_install', { location, profile })
+	const location = {
+		type: 'fromFile',
+		path: path,
+	}
+	const profile_creator = await invoke('plugin:pack|pack_get_profile_from_pack', { location })
+	const profile = await create(
+		profile_creator.name,
+		profile_creator.gameVersion,
+		profile_creator.modloader,
+		profile_creator.loaderVersion,
+		null,
+		true,
+	)
+	return await invoke('plugin:pack|pack_install', { location, profile })
 }

apps/app-frontend/src/helpers/process.js

@@ -8,16 +8,16 @@ import { invoke } from '@tauri-apps/api/core'
 /// Gets all running process IDs with a given profile path
 /// Returns [u32]
 export async function get_by_profile_path(path) {
-  return await invoke('plugin:process|process_get_by_profile_path', { path })
+	return await invoke('plugin:process|process_get_by_profile_path', { path })
 }
 
 /// Gets all running process IDs with a given profile path
 /// Returns [u32]
 export async function get_all() {
-  return await invoke('plugin:process|process_get_all')
+	return await invoke('plugin:process|process_get_all')
 }
 
 /// Kills a process by UUID
 export async function kill(uuid) {
-  return await invoke('plugin:process|process_kill', { uuid })
+	return await invoke('plugin:process|process_kill', { uuid })
 }

apps/app-frontend/src/helpers/profile.js

@@ -3,10 +3,11 @@
  * So, for example, addDefaultInstance creates a blank Profile object, where the Rust struct is serialized,
  *  and deserialized into a usable JS object.
  */
-import { install_to_existing_profile } from '@/helpers/pack.js'
 import { injectNotificationManager } from '@modrinth/ui'
 import { invoke } from '@tauri-apps/api/core'
 
+import { install_to_existing_profile } from '@/helpers/pack.js'
+
 /// Add instance
 /*
     name: String,           // the name of the profile, and relative path to create
@@ -19,142 +20,145 @@ import { invoke } from '@tauri-apps/api/core'
 */
 
 export async function create(name, gameVersion, modloader, loaderVersion, iconPath, skipInstall) {
-  //Trim string name to avoid "Unable to find directory"
-  name = name.trim()
-  return await invoke('plugin:profile-create|profile_create', {
-    name,
-    gameVersion,
-    modloader,
-    loaderVersion,
-    iconPath,
-    skipInstall,
-  })
+	//Trim string name to avoid "Unable to find directory"
+	name = name.trim()
+	return await invoke('plugin:profile-create|profile_create', {
+		name,
+		gameVersion,
+		modloader,
+		loaderVersion,
+		iconPath,
+		skipInstall,
+	})
 }
 
 // duplicate a profile
 export async function duplicate(path) {
-  return await invoke('plugin:profile-create|profile_duplicate', { path })
+	return await invoke('plugin:profile-create|profile_duplicate', { path })
 }
 
 // Remove a profile
 export async function remove(path) {
-  return await invoke('plugin:profile|profile_remove', { path })
+	return await invoke('plugin:profile|profile_remove', { path })
 }
 
 // Get a profile by path
 // Returns a Profile
 export async function get(path) {
-  return await invoke('plugin:profile|profile_get', { path })
+	return await invoke('plugin:profile|profile_get', { path })
 }
 
 export async function get_many(paths) {
-  return await invoke('plugin:profile|profile_get_many', { paths })
+	return await invoke('plugin:profile|profile_get_many', { paths })
 }
 
 // Get a profile's projects
 // Returns a map of a path to profile file
 export async function get_projects(path, cacheBehaviour) {
-  return await invoke('plugin:profile|profile_get_projects', { path, cacheBehaviour })
+	return await invoke('plugin:profile|profile_get_projects', { path, cacheBehaviour })
 }
 
 // Get a profile's full fs path
 // Returns a path
 export async function get_full_path(path) {
-  return await invoke('plugin:profile|profile_get_full_path', { path })
+	return await invoke('plugin:profile|profile_get_full_path', { path })
 }
 
 // Get's a mod's full fs path
 // Returns a path
 export async function get_mod_full_path(path, projectPath) {
-  return await invoke('plugin:profile|profile_get_mod_full_path', { path, projectPath })
+	return await invoke('plugin:profile|profile_get_mod_full_path', { path, projectPath })
 }
 
 // Get optimal java version from profile
 // Returns a java version
 export async function get_optimal_jre_key(path) {
-  return await invoke('plugin:profile|profile_get_optimal_jre_key', { path })
+	return await invoke('plugin:profile|profile_get_optimal_jre_key', { path })
 }
 
 // Get a copy of the profile set
 // Returns hashmap of path -> Profile
 export async function list() {
-  return await invoke('plugin:profile|profile_list')
+	return await invoke('plugin:profile|profile_list')
 }
 
 export async function check_installed(path, projectId) {
-  return await invoke('plugin:profile|profile_check_installed', { path, projectId })
+	return await invoke('plugin:profile|profile_check_installed', { path, projectId })
 }
 
 // Installs/Repairs a profile
 export async function install(path, force) {
-  return await invoke('plugin:profile|profile_install', { path, force })
+	return await invoke('plugin:profile|profile_install', { path, force })
 }
 
 // Updates all of a profile's projects
 export async function update_all(path) {
-  return await invoke('plugin:profile|profile_update_all', { path })
+	return await invoke('plugin:profile|profile_update_all', { path })
 }
 
 // Updates a specified project
 export async function update_project(path, projectPath) {
-  return await invoke('plugin:profile|profile_update_project', { path, projectPath })
+	return await invoke('plugin:profile|profile_update_project', { path, projectPath })
 }
 
 // Add a project to a profile from a version
 // Returns a path to the new project file
 export async function add_project_from_version(path, versionId) {
-  return await invoke('plugin:profile|profile_add_project_from_version', { path, versionId })
+	return await invoke('plugin:profile|profile_add_project_from_version', { path, versionId })
 }
 
 // Add a project to a profile from a path + project_type
 // Returns a path to the new project file
 export async function add_project_from_path(path, projectPath, projectType) {
-  return await invoke('plugin:profile|profile_add_project_from_path', {
-    path,
-    projectPath,
-    projectType,
-  })
+	return await invoke('plugin:profile|profile_add_project_from_path', {
+		path,
+		projectPath,
+		projectType,
+	})
 }
 
 // Toggle disabling a project
 export async function toggle_disable_project(path, projectPath) {
-  return await invoke('plugin:profile|profile_toggle_disable_project', { path, projectPath })
+	return await invoke('plugin:profile|profile_toggle_disable_project', { path, projectPath })
 }
 
 // Remove a project
 export async function remove_project(path, projectPath) {
-  return await invoke('plugin:profile|profile_remove_project', { path, projectPath })
+	return await invoke('plugin:profile|profile_remove_project', { path, projectPath })
 }
 
 // Update a managed Modrinth profile to a specific version
 export async function update_managed_modrinth_version(path, versionId) {
-  return await invoke('plugin:profile|profile_update_managed_modrinth_version', { path, versionId })
+	return await invoke('plugin:profile|profile_update_managed_modrinth_version', {
+		path,
+		versionId,
+	})
 }
 
 // Repair a managed Modrinth profile
 export async function update_repair_modrinth(path) {
-  return await invoke('plugin:profile|profile_repair_managed_modrinth', { path })
+	return await invoke('plugin:profile|profile_repair_managed_modrinth', { path })
 }
 
 // Export a profile to .mrpack
 /// included_overrides is an array of paths to override folders to include (ie: 'mods', 'resource_packs')
 // Version id is optional (ie: 1.1.5)
 export async function export_profile_mrpack(
-  path,
-  exportLocation,
-  includedOverrides,
-  versionId,
-  description,
-  name,
+	path,
+	exportLocation,
+	includedOverrides,
+	versionId,
+	description,
+	name,
 ) {
-  return await invoke('plugin:profile|profile_export_mrpack', {
-    path,
-    exportLocation,
-    includedOverrides,
-    versionId,
-    description,
-    name,
-  })
+	return await invoke('plugin:profile|profile_export_mrpack', {
+		path,
+		exportLocation,
+		includedOverrides,
+		versionId,
+		description,
+		name,
+	})
 }
 
 // Given a folder path, populate an array of all the subfolders
@@ -166,40 +170,40 @@ export async function export_profile_mrpack(
 // => [mods, resourcepacks]
 // allows selection for 'included_overrides' in export_profile_mrpack
 export async function get_pack_export_candidates(profilePath) {
-  return await invoke('plugin:profile|profile_get_pack_export_candidates', { profilePath })
+	return await invoke('plugin:profile|profile_get_pack_export_candidates', { profilePath })
 }
 
 // Run Minecraft using a pathed profile
 // Returns PID of child
 export async function run(path) {
-  return await invoke('plugin:profile|profile_run', { path })
+	return await invoke('plugin:profile|profile_run', { path })
 }
 
 export async function kill(path) {
-  return await invoke('plugin:profile|profile_kill', { path })
+	return await invoke('plugin:profile|profile_kill', { path })
 }
 
 // Edits a profile
 export async function edit(path, editProfile) {
-  return await invoke('plugin:profile|profile_edit', { path, editProfile })
+	return await invoke('plugin:profile|profile_edit', { path, editProfile })
 }
 
 // Edits a profile's icon
 export async function edit_icon(path, iconPath) {
-  return await invoke('plugin:profile|profile_edit_icon', { path, iconPath })
+	return await invoke('plugin:profile|profile_edit_icon', { path, iconPath })
 }
 
 export async function finish_install(instance) {
-  const { handleError } = injectNotificationManager()
-  if (instance.install_stage !== 'pack_installed') {
-    let linkedData = instance.linked_data
-    await install_to_existing_profile(
-      linkedData.project_id,
-      linkedData.version_id,
-      instance.name,
-      instance.path,
-    ).catch(handleError)
-  } else {
-    await install(instance.path, false).catch(handleError)
-  }
+	const { handleError } = injectNotificationManager()
+	if (instance.install_stage !== 'pack_installed') {
+		let linkedData = instance.linked_data
+		await install_to_existing_profile(
+			linkedData.project_id,
+			linkedData.version_id,
+			instance.name,
+			instance.path,
+		).catch(handleError)
+	} else {
+		await install(instance.path, false).catch(handleError)
+	}
 }

apps/app-frontend/src/helpers/rendering/batch-skin-renderer.ts

@@ -1,191 +1,192 @@
-import * as THREE from 'three'
-import type { Skin, Cape } from '../skins'
-import { get_normalized_skin_texture, determineModelType } from '../skins'
-import { reactive } from 'vue'
-import {
-  setupSkinModel,
-  disposeCaches,
-  loadTexture,
-  applyCapeTexture,
-  createTransparentTexture,
-} from '@modrinth/utils'
-import { skinPreviewStorage } from '../storage/skin-preview-storage'
-import { headStorage } from '../storage/head-storage'
 import { ClassicPlayerModel, SlimPlayerModel } from '@modrinth/assets'
+import {
+	applyCapeTexture,
+	createTransparentTexture,
+	disposeCaches,
+	loadTexture,
+	setupSkinModel,
+} from '@modrinth/utils'
+import * as THREE from 'three'
+import { reactive } from 'vue'
+
+import type { Cape, Skin } from '../skins'
+import { determineModelType, get_normalized_skin_texture } from '../skins'
+import { headStorage } from '../storage/head-storage'
+import { skinPreviewStorage } from '../storage/skin-preview-storage'
 
 export interface RenderResult {
-  forwards: string
-  backwards: string
+	forwards: string
+	backwards: string
 }
 
 export interface RawRenderResult {
-  forwards: Blob
-  backwards: Blob
+	forwards: Blob
+	backwards: Blob
 }
 
 class BatchSkinRenderer {
-  private renderer: THREE.WebGLRenderer | null = null
-  private scene: THREE.Scene | null = null
-  private camera: THREE.PerspectiveCamera | null = null
-  private currentModel: THREE.Group | null = null
-  private readonly width: number
-  private readonly height: number
+	private renderer: THREE.WebGLRenderer | null = null
+	private scene: THREE.Scene | null = null
+	private camera: THREE.PerspectiveCamera | null = null
+	private currentModel: THREE.Group | null = null
+	private readonly width: number
+	private readonly height: number
 
-  constructor(width: number = 360, height: number = 504) {
-    this.width = width
-    this.height = height
-  }
+	constructor(width: number = 360, height: number = 504) {
+		this.width = width
+		this.height = height
+	}
 
-  private initializeRenderer(): void {
-    if (this.renderer) return
+	private initializeRenderer(): void {
+		if (this.renderer) return
 
-    const canvas = document.createElement('canvas')
-    canvas.width = this.width
-    canvas.height = this.height
+		const canvas = document.createElement('canvas')
+		canvas.width = this.width
+		canvas.height = this.height
 
-    this.renderer = new THREE.WebGLRenderer({
-      canvas: canvas,
-      antialias: true,
-      alpha: true,
-      preserveDrawingBuffer: true,
-    })
+		this.renderer = new THREE.WebGLRenderer({
+			canvas: canvas,
+			antialias: true,
+			alpha: true,
+			preserveDrawingBuffer: true,
+		})
 
-    this.renderer.outputColorSpace = THREE.SRGBColorSpace
-    this.renderer.toneMapping = THREE.NoToneMapping
-    this.renderer.toneMappingExposure = 10.0
-    this.renderer.setClearColor(0x000000, 0)
-    this.renderer.setSize(this.width, this.height)
+		this.renderer.outputColorSpace = THREE.SRGBColorSpace
+		this.renderer.toneMapping = THREE.NoToneMapping
+		this.renderer.toneMappingExposure = 10.0
+		this.renderer.setClearColor(0x000000, 0)
+		this.renderer.setSize(this.width, this.height)
 
-    this.scene = new THREE.Scene()
-    this.camera = new THREE.PerspectiveCamera(20, this.width / this.height, 0.4, 1000)
+		this.scene = new THREE.Scene()
+		this.camera = new THREE.PerspectiveCamera(20, this.width / this.height, 0.4, 1000)
 
-    const ambientLight = new THREE.AmbientLight(0xffffff, 2)
-    const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2)
-    directionalLight.castShadow = true
-    directionalLight.position.set(2, 4, 3)
-    this.scene.add(ambientLight)
-    this.scene.add(directionalLight)
-  }
+		const ambientLight = new THREE.AmbientLight(0xffffff, 2)
+		const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2)
+		directionalLight.castShadow = true
+		directionalLight.position.set(2, 4, 3)
+		this.scene.add(ambientLight)
+		this.scene.add(directionalLight)
+	}
 
-  public async renderSkin(
-    textureUrl: string,
-    modelUrl: string,
-    capeUrl?: string,
-  ): Promise<RawRenderResult> {
-    this.initializeRenderer()
+	public async renderSkin(
+		textureUrl: string,
+		modelUrl: string,
+		capeUrl?: string,
+	): Promise<RawRenderResult> {
+		this.initializeRenderer()
 
-    this.clearScene()
+		this.clearScene()
 
-    await this.setupModel(modelUrl, textureUrl, capeUrl)
+		await this.setupModel(modelUrl, textureUrl, capeUrl)
 
-    const headPart = this.currentModel!.getObjectByName('Head')
-    let lookAtTarget: [number, number, number]
+		const headPart = this.currentModel!.getObjectByName('Head')
+		let lookAtTarget: [number, number, number]
 
-    if (headPart) {
-      const headPosition = new THREE.Vector3()
-      headPart.getWorldPosition(headPosition)
-      lookAtTarget = [headPosition.x, headPosition.y - 0.3, headPosition.z]
-    } else {
-      throw new Error("Failed to find 'Head' object in model.")
-    }
+		if (headPart) {
+			const headPosition = new THREE.Vector3()
+			headPart.getWorldPosition(headPosition)
+			lookAtTarget = [headPosition.x, headPosition.y - 0.3, headPosition.z]
+		} else {
+			throw new Error("Failed to find 'Head' object in model.")
+		}
 
-    const frontCameraPos: [number, number, number] = [-1.3, 1, 6.3]
-    const backCameraPos: [number, number, number] = [-1.3, 1, -2.5]
+		const frontCameraPos: [number, number, number] = [-1.3, 1, 6.3]
+		const backCameraPos: [number, number, number] = [-1.3, 1, -2.5]
 
-    const forwards = await this.renderView(frontCameraPos, lookAtTarget)
-    const backwards = await this.renderView(backCameraPos, lookAtTarget)
+		const forwards = await this.renderView(frontCameraPos, lookAtTarget)
+		const backwards = await this.renderView(backCameraPos, lookAtTarget)
 
-    return { forwards, backwards }
-  }
+		return { forwards, backwards }
+	}
 
-  private async renderView(
-    cameraPosition: [number, number, number],
-    lookAtPosition: [number, number, number],
-  ): Promise<Blob> {
-    if (!this.camera || !this.renderer || !this.scene) {
-      throw new Error('Renderer not initialized')
-    }
+	private async renderView(
+		cameraPosition: [number, number, number],
+		lookAtPosition: [number, number, number],
+	): Promise<Blob> {
+		if (!this.camera || !this.renderer || !this.scene) {
+			throw new Error('Renderer not initialized')
+		}
 
-    this.camera.position.set(...cameraPosition)
-    this.camera.lookAt(...lookAtPosition)
+		this.camera.position.set(...cameraPosition)
+		this.camera.lookAt(...lookAtPosition)
 
-    this.renderer.render(this.scene, this.camera)
+		this.renderer.render(this.scene, this.camera)
 
-    const dataUrl = this.renderer.domElement.toDataURL('image/webp', 0.9)
-    const response = await fetch(dataUrl)
-    return await response.blob()
-  }
+		const dataUrl = this.renderer.domElement.toDataURL('image/webp', 0.9)
+		const response = await fetch(dataUrl)
+		return await response.blob()
+	}
 
-  private async setupModel(modelUrl: string, textureUrl: string, capeUrl?: string): Promise<void> {
-    if (!this.scene) {
-      throw new Error('Renderer not initialized')
-    }
+	private async setupModel(modelUrl: string, textureUrl: string, capeUrl?: string): Promise<void> {
+		if (!this.scene) {
+			throw new Error('Renderer not initialized')
+		}
 
-    const { model } = await setupSkinModel(modelUrl, textureUrl)
+		const { model } = await setupSkinModel(modelUrl, textureUrl)
 
-    if (capeUrl) {
-      const capeTexture = await loadTexture(capeUrl)
-      applyCapeTexture(model, capeTexture)
-    } else {
-      const transparentTexture = createTransparentTexture()
-      applyCapeTexture(model, null, transparentTexture)
-    }
+		if (capeUrl) {
+			const capeTexture = await loadTexture(capeUrl)
+			applyCapeTexture(model, capeTexture)
+		} else {
+			const transparentTexture = createTransparentTexture()
+			applyCapeTexture(model, null, transparentTexture)
+		}
 
-    const group = new THREE.Group()
-    group.add(model)
-    group.position.set(0, 0.3, 1.95)
-    group.scale.set(0.8, 0.8, 0.8)
+		const group = new THREE.Group()
+		group.add(model)
+		group.position.set(0, 0.3, 1.95)
+		group.scale.set(0.8, 0.8, 0.8)
 
-    this.scene.add(group)
-    this.currentModel = group
-  }
+		this.scene.add(group)
+		this.currentModel = group
+	}
 
-  private clearScene(): void {
-    if (!this.scene) return
+	private clearScene(): void {
+		if (!this.scene) return
 
-    while (this.scene.children.length > 0) {
-      const child = this.scene.children[0]
-      this.scene.remove(child)
+		while (this.scene.children.length > 0) {
+			const child = this.scene.children[0]
+			this.scene.remove(child)
 
-      if (child instanceof THREE.Mesh) {
-        if (child.geometry) child.geometry.dispose()
-        if (child.material) {
-          if (Array.isArray(child.material)) {
-            child.material.forEach((material) => material.dispose())
-          } else {
-            child.material.dispose()
-          }
-        }
-      }
-    }
+			if (child instanceof THREE.Mesh) {
+				if (child.geometry) child.geometry.dispose()
+				if (child.material) {
+					if (Array.isArray(child.material)) {
+						child.material.forEach((material) => material.dispose())
+					} else {
+						child.material.dispose()
+					}
+				}
+			}
+		}
 
-    const ambientLight = new THREE.AmbientLight(0xffffff, 2)
-    const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2)
-    directionalLight.castShadow = true
-    directionalLight.position.set(2, 4, 3)
-    this.scene.add(ambientLight)
-    this.scene.add(directionalLight)
+		const ambientLight = new THREE.AmbientLight(0xffffff, 2)
+		const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2)
+		directionalLight.castShadow = true
+		directionalLight.position.set(2, 4, 3)
+		this.scene.add(ambientLight)
+		this.scene.add(directionalLight)
 
-    this.currentModel = null
-  }
+		this.currentModel = null
+	}
 
-  public dispose(): void {
-    if (this.renderer) {
-      this.renderer.dispose()
-    }
-    disposeCaches()
-  }
+	public dispose(): void {
+		if (this.renderer) {
+			this.renderer.dispose()
+		}
+		disposeCaches()
+	}
 }
 
 function getModelUrlForVariant(variant: string): string {
-  switch (variant) {
-    case 'SLIM':
-      return SlimPlayerModel
-    case 'CLASSIC':
-    case 'UNKNOWN':
-    default:
-      return ClassicPlayerModel
-  }
+	switch (variant) {
+		case 'SLIM':
+			return SlimPlayerModel
+		case 'CLASSIC':
+		case 'UNKNOWN':
+		default:
+			return ClassicPlayerModel
+	}
 }
 
 export const skinBlobUrlMap = reactive(new Map<string, RenderResult>())
@@ -194,253 +195,253 @@ const DEBUG_MODE = false
 
 let sharedRenderer: BatchSkinRenderer | null = null
 function getSharedRenderer(): BatchSkinRenderer {
-  if (!sharedRenderer) {
-    sharedRenderer = new BatchSkinRenderer()
-  }
-  return sharedRenderer
+	if (!sharedRenderer) {
+		sharedRenderer = new BatchSkinRenderer()
+	}
+	return sharedRenderer
 }
 
 export function disposeSharedRenderer(): void {
-  if (sharedRenderer) {
-    sharedRenderer.dispose()
-    sharedRenderer = null
-  }
+	if (sharedRenderer) {
+		sharedRenderer.dispose()
+		sharedRenderer = null
+	}
 }
 
 export async function cleanupUnusedPreviews(skins: Skin[]): Promise<void> {
-  const validKeys = new Set<string>()
-  const validHeadKeys = new Set<string>()
+	const validKeys = new Set<string>()
+	const validHeadKeys = new Set<string>()
 
-  for (const skin of skins) {
-    const key = `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`
-    const headKey = `${skin.texture_key}-head`
-    validKeys.add(key)
-    validHeadKeys.add(headKey)
-  }
+	for (const skin of skins) {
+		const key = `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`
+		const headKey = `${skin.texture_key}-head`
+		validKeys.add(key)
+		validHeadKeys.add(headKey)
+	}
 
-  try {
-    await skinPreviewStorage.cleanupInvalidKeys(validKeys)
-    await headStorage.cleanupInvalidKeys(validHeadKeys)
-  } catch (error) {
-    console.warn('Failed to cleanup unused skin previews:', error)
-  }
+	try {
+		await skinPreviewStorage.cleanupInvalidKeys(validKeys)
+		await headStorage.cleanupInvalidKeys(validHeadKeys)
+	} catch (error) {
+		console.warn('Failed to cleanup unused skin previews:', error)
+	}
 }
 
 export async function generatePlayerHeadBlob(skinUrl: string, size: number = 64): Promise<Blob> {
-  return new Promise((resolve, reject) => {
-    const img = new Image()
-    img.crossOrigin = 'anonymous'
+	return new Promise((resolve, reject) => {
+		const img = new Image()
+		img.crossOrigin = 'anonymous'
 
-    img.onload = () => {
-      try {
-        const sourceCanvas = document.createElement('canvas')
-        const sourceCtx = sourceCanvas.getContext('2d')
+		img.onload = () => {
+			try {
+				const sourceCanvas = document.createElement('canvas')
+				const sourceCtx = sourceCanvas.getContext('2d')
 
-        if (!sourceCtx) {
-          throw new Error('Could not get 2D context from source canvas')
-        }
+				if (!sourceCtx) {
+					throw new Error('Could not get 2D context from source canvas')
+				}
 
-        sourceCanvas.width = img.width
-        sourceCanvas.height = img.height
+				sourceCanvas.width = img.width
+				sourceCanvas.height = img.height
 
-        sourceCtx.drawImage(img, 0, 0)
+				sourceCtx.drawImage(img, 0, 0)
 
-        const outputCanvas = document.createElement('canvas')
-        const outputCtx = outputCanvas.getContext('2d')
+				const outputCanvas = document.createElement('canvas')
+				const outputCtx = outputCanvas.getContext('2d')
 
-        if (!outputCtx) {
-          throw new Error('Could not get 2D context from output canvas')
-        }
+				if (!outputCtx) {
+					throw new Error('Could not get 2D context from output canvas')
+				}
 
-        outputCanvas.width = size
-        outputCanvas.height = size
+				outputCanvas.width = size
+				outputCanvas.height = size
 
-        outputCtx.imageSmoothingEnabled = false
+				outputCtx.imageSmoothingEnabled = false
 
-        const headImageData = sourceCtx.getImageData(8, 8, 8, 8)
+				const headImageData = sourceCtx.getImageData(8, 8, 8, 8)
 
-        const headCanvas = document.createElement('canvas')
-        const headCtx = headCanvas.getContext('2d')
+				const headCanvas = document.createElement('canvas')
+				const headCtx = headCanvas.getContext('2d')
 
-        if (!headCtx) {
-          throw new Error('Could not get 2D context from head canvas')
-        }
+				if (!headCtx) {
+					throw new Error('Could not get 2D context from head canvas')
+				}
 
-        headCanvas.width = 8
-        headCanvas.height = 8
-        headCtx.putImageData(headImageData, 0, 0)
+				headCanvas.width = 8
+				headCanvas.height = 8
+				headCtx.putImageData(headImageData, 0, 0)
 
-        outputCtx.drawImage(headCanvas, 0, 0, 8, 8, 0, 0, size, size)
+				outputCtx.drawImage(headCanvas, 0, 0, 8, 8, 0, 0, size, size)
 
-        const hatImageData = sourceCtx.getImageData(40, 8, 8, 8)
+				const hatImageData = sourceCtx.getImageData(40, 8, 8, 8)
 
-        const hatCanvas = document.createElement('canvas')
-        const hatCtx = hatCanvas.getContext('2d')
+				const hatCanvas = document.createElement('canvas')
+				const hatCtx = hatCanvas.getContext('2d')
 
-        if (!hatCtx) {
-          throw new Error('Could not get 2D context from hat canvas')
-        }
+				if (!hatCtx) {
+					throw new Error('Could not get 2D context from hat canvas')
+				}
 
-        hatCanvas.width = 8
-        hatCanvas.height = 8
-        hatCtx.putImageData(hatImageData, 0, 0)
+				hatCanvas.width = 8
+				hatCanvas.height = 8
+				hatCtx.putImageData(hatImageData, 0, 0)
 
-        const hatPixels = hatImageData.data
-        let hasHat = false
+				const hatPixels = hatImageData.data
+				let hasHat = false
 
-        for (let i = 3; i < hatPixels.length; i += 4) {
-          if (hatPixels[i] > 0) {
-            hasHat = true
-            break
-          }
-        }
+				for (let i = 3; i < hatPixels.length; i += 4) {
+					if (hatPixels[i] > 0) {
+						hasHat = true
+						break
+					}
+				}
 
-        if (hasHat) {
-          outputCtx.drawImage(hatCanvas, 0, 0, 8, 8, 0, 0, size, size)
-        }
+				if (hasHat) {
+					outputCtx.drawImage(hatCanvas, 0, 0, 8, 8, 0, 0, size, size)
+				}
 
-        outputCanvas.toBlob(
-          (blob) => {
-            if (blob) {
-              resolve(blob)
-            } else {
-              reject(new Error('Failed to create blob from canvas'))
-            }
-          },
-          'image/webp',
-          0.9,
-        )
-      } catch (error) {
-        reject(error)
-      }
-    }
+				outputCanvas.toBlob(
+					(blob) => {
+						if (blob) {
+							resolve(blob)
+						} else {
+							reject(new Error('Failed to create blob from canvas'))
+						}
+					},
+					'image/webp',
+					0.9,
+				)
+			} catch (error) {
+				reject(error)
+			}
+		}
 
-    img.onerror = () => {
-      reject(new Error('Failed to load skin texture image'))
-    }
+		img.onerror = () => {
+			reject(new Error('Failed to load skin texture image'))
+		}
 
-    img.src = skinUrl
-  })
+		img.src = skinUrl
+	})
 }
 
 async function generateHeadRender(skin: Skin): Promise<string> {
-  const headKey = `${skin.texture_key}-head`
+	const headKey = `${skin.texture_key}-head`
 
-  if (headBlobUrlMap.has(headKey)) {
-    if (DEBUG_MODE) {
-      const url = headBlobUrlMap.get(headKey)!
-      URL.revokeObjectURL(url)
-      headBlobUrlMap.delete(headKey)
-    } else {
-      return headBlobUrlMap.get(headKey)!
-    }
-  }
+	if (headBlobUrlMap.has(headKey)) {
+		if (DEBUG_MODE) {
+			const url = headBlobUrlMap.get(headKey)!
+			URL.revokeObjectURL(url)
+			headBlobUrlMap.delete(headKey)
+		} else {
+			return headBlobUrlMap.get(headKey)!
+		}
+	}
 
-  const skinUrl = await get_normalized_skin_texture(skin)
-  const headBlob = await generatePlayerHeadBlob(skinUrl, 64)
-  const headUrl = URL.createObjectURL(headBlob)
+	const skinUrl = await get_normalized_skin_texture(skin)
+	const headBlob = await generatePlayerHeadBlob(skinUrl, 64)
+	const headUrl = URL.createObjectURL(headBlob)
 
-  headBlobUrlMap.set(headKey, headUrl)
+	headBlobUrlMap.set(headKey, headUrl)
 
-  try {
-    await headStorage.store(headKey, headBlob)
-  } catch (error) {
-    console.warn('Failed to store head render in persistent storage:', error)
-  }
+	try {
+		await headStorage.store(headKey, headBlob)
+	} catch (error) {
+		console.warn('Failed to store head render in persistent storage:', error)
+	}
 
-  return headUrl
+	return headUrl
 }
 
 export async function getPlayerHeadUrl(skin: Skin): Promise<string> {
-  return await generateHeadRender(skin)
+	return await generateHeadRender(skin)
 }
 
 export async function generateSkinPreviews(skins: Skin[], capes: Cape[]): Promise<void> {
-  try {
-    const skinKeys = skins.map(
-      (skin) => `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`,
-    )
-    const headKeys = skins.map((skin) => `${skin.texture_key}-head`)
+	try {
+		const skinKeys = skins.map(
+			(skin) => `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`,
+		)
+		const headKeys = skins.map((skin) => `${skin.texture_key}-head`)
 
-    const [cachedSkinPreviews, cachedHeadPreviews] = await Promise.all([
-      skinPreviewStorage.batchRetrieve(skinKeys),
-      headStorage.batchRetrieve(headKeys),
-    ])
+		const [cachedSkinPreviews, cachedHeadPreviews] = await Promise.all([
+			skinPreviewStorage.batchRetrieve(skinKeys),
+			headStorage.batchRetrieve(headKeys),
+		])
 
-    for (let i = 0; i < skins.length; i++) {
-      const skinKey = skinKeys[i]
-      const headKey = headKeys[i]
+		for (let i = 0; i < skins.length; i++) {
+			const skinKey = skinKeys[i]
+			const headKey = headKeys[i]
 
-      const rawCached = cachedSkinPreviews[skinKey]
-      if (rawCached) {
-        const cached: RenderResult = {
-          forwards: URL.createObjectURL(rawCached.forwards),
-          backwards: URL.createObjectURL(rawCached.backwards),
-        }
-        skinBlobUrlMap.set(skinKey, cached)
-      }
+			const rawCached = cachedSkinPreviews[skinKey]
+			if (rawCached) {
+				const cached: RenderResult = {
+					forwards: URL.createObjectURL(rawCached.forwards),
+					backwards: URL.createObjectURL(rawCached.backwards),
+				}
+				skinBlobUrlMap.set(skinKey, cached)
+			}
 
-      const cachedHead = cachedHeadPreviews[headKey]
-      if (cachedHead) {
-        headBlobUrlMap.set(headKey, URL.createObjectURL(cachedHead))
-      }
-    }
+			const cachedHead = cachedHeadPreviews[headKey]
+			if (cachedHead) {
+				headBlobUrlMap.set(headKey, URL.createObjectURL(cachedHead))
+			}
+		}
 
-    for (const skin of skins) {
-      const key = `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`
+		for (const skin of skins) {
+			const key = `${skin.texture_key}+${skin.variant}+${skin.cape_id ?? 'no-cape'}`
 
-      if (skinBlobUrlMap.has(key)) {
-        if (DEBUG_MODE) {
-          const result = skinBlobUrlMap.get(key)!
-          URL.revokeObjectURL(result.forwards)
-          URL.revokeObjectURL(result.backwards)
-          skinBlobUrlMap.delete(key)
-        } else continue
-      }
+			if (skinBlobUrlMap.has(key)) {
+				if (DEBUG_MODE) {
+					const result = skinBlobUrlMap.get(key)!
+					URL.revokeObjectURL(result.forwards)
+					URL.revokeObjectURL(result.backwards)
+					skinBlobUrlMap.delete(key)
+				} else continue
+			}
 
-      const renderer = getSharedRenderer()
+			const renderer = getSharedRenderer()
 
-      let variant = skin.variant
-      if (variant === 'UNKNOWN') {
-        try {
-          variant = await determineModelType(skin.texture)
-        } catch (error) {
-          console.error(`Failed to determine model type for skin ${key}:`, error)
-          variant = 'CLASSIC'
-        }
-      }
+			let variant = skin.variant
+			if (variant === 'UNKNOWN') {
+				try {
+					variant = await determineModelType(skin.texture)
+				} catch (error) {
+					console.error(`Failed to determine model type for skin ${key}:`, error)
+					variant = 'CLASSIC'
+				}
+			}
 
-      const modelUrl = getModelUrlForVariant(variant)
-      const cape: Cape | undefined = capes.find((_cape) => _cape.id === skin.cape_id)
-      const rawRenderResult = await renderer.renderSkin(
-        await get_normalized_skin_texture(skin),
-        modelUrl,
-        cape?.texture,
-      )
+			const modelUrl = getModelUrlForVariant(variant)
+			const cape: Cape | undefined = capes.find((_cape) => _cape.id === skin.cape_id)
+			const rawRenderResult = await renderer.renderSkin(
+				await get_normalized_skin_texture(skin),
+				modelUrl,
+				cape?.texture,
+			)
 
-      const renderResult: RenderResult = {
-        forwards: URL.createObjectURL(rawRenderResult.forwards),
-        backwards: URL.createObjectURL(rawRenderResult.backwards),
-      }
+			const renderResult: RenderResult = {
+				forwards: URL.createObjectURL(rawRenderResult.forwards),
+				backwards: URL.createObjectURL(rawRenderResult.backwards),
+			}
 
-      skinBlobUrlMap.set(key, renderResult)
+			skinBlobUrlMap.set(key, renderResult)
 
-      try {
-        await skinPreviewStorage.store(key, rawRenderResult)
-      } catch (error) {
-        console.warn('Failed to store skin preview in persistent storage:', error)
-      }
+			try {
+				await skinPreviewStorage.store(key, rawRenderResult)
+			} catch (error) {
+				console.warn('Failed to store skin preview in persistent storage:', error)
+			}
 
-      const headKey = `${skin.texture_key}-head`
-      if (!headBlobUrlMap.has(headKey)) {
-        await generateHeadRender(skin)
-      }
-    }
-  } finally {
-    disposeSharedRenderer()
-    await cleanupUnusedPreviews(skins)
+			const headKey = `${skin.texture_key}-head`
+			if (!headBlobUrlMap.has(headKey)) {
+				await generateHeadRender(skin)
+			}
+		}
+	} finally {
+		disposeSharedRenderer()
+		await cleanupUnusedPreviews(skins)
 
-    await skinPreviewStorage.debugCalculateStorage()
-    await headStorage.debugCalculateStorage()
-  }
+		await skinPreviewStorage.debugCalculateStorage()
+		await headStorage.debugCalculateStorage()
+	}
 }

apps/app-frontend/src/helpers/settings.ts

@@ -4,8 +4,9 @@
  *  and deserialized into a usable JS object.
  */
 import { invoke } from '@tauri-apps/api/core'
-import type { ColorTheme, FeatureFlag } from '@/store/theme.ts'
+
 import type { Hooks, MemorySettings, WindowSize } from '@/helpers/types'
+import type { ColorTheme, FeatureFlag } from '@/store/theme.ts'
 
 // Settings object
 /*
@@ -31,49 +32,49 @@ Memorysettings {
 */
 
 export type AppSettings = {
-  max_concurrent_downloads: number
-  max_concurrent_writes: number
+	max_concurrent_downloads: number
+	max_concurrent_writes: number
 
-  theme: ColorTheme
-  default_page: 'home' | 'library'
-  collapsed_navigation: boolean
-  hide_nametag_skins_page: boolean
-  advanced_rendering: boolean
-  native_decorations: boolean
-  toggle_sidebar: boolean
+	theme: ColorTheme
+	default_page: 'home' | 'library'
+	collapsed_navigation: boolean
+	hide_nametag_skins_page: boolean
+	advanced_rendering: boolean
+	native_decorations: boolean
+	toggle_sidebar: boolean
 
-  telemetry: boolean
-  discord_rpc: boolean
-  personalized_ads: boolean
+	telemetry: boolean
+	discord_rpc: boolean
+	personalized_ads: boolean
 
-  onboarded: boolean
+	onboarded: boolean
 
-  extra_launch_args: string[]
-  custom_env_vars: [string, string][]
-  memory: MemorySettings
-  force_fullscreen: boolean
-  game_resolution: WindowSize
-  hide_on_process_start: boolean
-  hooks: Hooks
+	extra_launch_args: string[]
+	custom_env_vars: [string, string][]
+	memory: MemorySettings
+	force_fullscreen: boolean
+	game_resolution: WindowSize
+	hide_on_process_start: boolean
+	hooks: Hooks
 
-  custom_dir?: string | null
-  prev_custom_dir?: string | null
-  migrated: boolean
+	custom_dir?: string | null
+	prev_custom_dir?: string | null
+	migrated: boolean
 
-  developer_mode: boolean
-  feature_flags: Record<FeatureFlag, boolean>
+	developer_mode: boolean
+	feature_flags: Record<FeatureFlag, boolean>
 }
 
 // Get full settings object
 export async function get() {
-  return (await invoke('plugin:settings|settings_get')) as AppSettings
+	return (await invoke('plugin:settings|settings_get')) as AppSettings
 }
 
 // Set full settings object
 export async function set(settings: AppSettings) {
-  return await invoke('plugin:settings|settings_set', { settings })
+	return await invoke('plugin:settings|settings_set', { settings })
 }
 
 export async function cancel_directory_change(): Promise<void> {
-  return await invoke('plugin:settings|cancel_directory_change')
+	return await invoke('plugin:settings|cancel_directory_change')
 }

apps/app-frontend/src/helpers/skins.ts

@@ -3,163 +3,163 @@ import { arrayBufferToBase64 } from '@modrinth/utils'
 import { invoke } from '@tauri-apps/api/core'
 
 export interface Cape {
-  id: string
-  name: string
-  texture: string
-  is_default: boolean
-  is_equipped: boolean
+	id: string
+	name: string
+	texture: string
+	is_default: boolean
+	is_equipped: boolean
 }
 
 export type SkinModel = 'CLASSIC' | 'SLIM' | 'UNKNOWN'
 export type SkinSource = 'default' | 'custom_external' | 'custom'
 
 export interface Skin {
-  texture_key: string
-  name?: string
-  variant: SkinModel
-  cape_id?: string
-  texture: string
-  source: SkinSource
-  is_equipped: boolean
+	texture_key: string
+	name?: string
+	variant: SkinModel
+	cape_id?: string
+	texture: string
+	source: SkinSource
+	is_equipped: boolean
 }
 
 export const DEFAULT_MODEL_SORTING = ['Steve', 'Alex'] as string[]
 
 export const DEFAULT_MODELS: Record<string, SkinModel> = {
-  Steve: 'CLASSIC',
-  Alex: 'SLIM',
-  Zuri: 'CLASSIC',
-  Sunny: 'CLASSIC',
-  Noor: 'SLIM',
-  Makena: 'SLIM',
-  Kai: 'CLASSIC',
-  Efe: 'SLIM',
-  Ari: 'CLASSIC',
+	Steve: 'CLASSIC',
+	Alex: 'SLIM',
+	Zuri: 'CLASSIC',
+	Sunny: 'CLASSIC',
+	Noor: 'SLIM',
+	Makena: 'SLIM',
+	Kai: 'CLASSIC',
+	Efe: 'SLIM',
+	Ari: 'CLASSIC',
 }
 
 export function filterSavedSkins(list: Skin[]) {
-  const customSkins = list.filter((s) => s.source !== 'default')
-  const { handleError } = injectNotificationManager()
-  fixUnknownSkins(customSkins).catch(handleError)
-  return customSkins
+	const customSkins = list.filter((s) => s.source !== 'default')
+	const { handleError } = injectNotificationManager()
+	fixUnknownSkins(customSkins).catch(handleError)
+	return customSkins
 }
 
 export async function determineModelType(texture: string): Promise<'SLIM' | 'CLASSIC'> {
-  return new Promise((resolve, reject) => {
-    const canvas = document.createElement('canvas')
-    const context = canvas.getContext('2d')
+	return new Promise((resolve, reject) => {
+		const canvas = document.createElement('canvas')
+		const context = canvas.getContext('2d')
 
-    if (!context) {
-      return reject(new Error('Failed to create canvas rendering context.'))
-    }
+		if (!context) {
+			return reject(new Error('Failed to create canvas rendering context.'))
+		}
 
-    const image = new Image()
-    image.crossOrigin = 'anonymous'
-    image.src = texture
+		const image = new Image()
+		image.crossOrigin = 'anonymous'
+		image.src = texture
 
-    image.onload = () => {
-      canvas.width = image.width
-      canvas.height = image.height
+		image.onload = () => {
+			canvas.width = image.width
+			canvas.height = image.height
 
-      context.drawImage(image, 0, 0)
+			context.drawImage(image, 0, 0)
 
-      const armX = 54
-      const armY = 20
-      const armWidth = 2
-      const armHeight = 12
-      const imageData = context.getImageData(armX, armY, armWidth, armHeight).data
-      for (let alphaIndex = 3; alphaIndex < imageData.length; alphaIndex += 4) {
-        if (imageData[alphaIndex] !== 0) {
-          resolve('CLASSIC')
-          return
-        }
-      }
+			const armX = 54
+			const armY = 20
+			const armWidth = 2
+			const armHeight = 12
+			const imageData = context.getImageData(armX, armY, armWidth, armHeight).data
+			for (let alphaIndex = 3; alphaIndex < imageData.length; alphaIndex += 4) {
+				if (imageData[alphaIndex] !== 0) {
+					resolve('CLASSIC')
+					return
+				}
+			}
 
-      canvas.remove()
-      resolve('SLIM')
-    }
+			canvas.remove()
+			resolve('SLIM')
+		}
 
-    image.onerror = () => {
-      canvas.remove()
-      reject(new Error('Failed to load the image.'))
-    }
-  })
+		image.onerror = () => {
+			canvas.remove()
+			reject(new Error('Failed to load the image.'))
+		}
+	})
 }
 
 export async function fixUnknownSkins(list: Skin[]) {
-  const unknownSkins = list.filter((s) => s.variant === 'UNKNOWN')
-  for (const unknownSkin of unknownSkins) {
-    unknownSkin.variant = await determineModelType(unknownSkin.texture)
-  }
+	const unknownSkins = list.filter((s) => s.variant === 'UNKNOWN')
+	for (const unknownSkin of unknownSkins) {
+		unknownSkin.variant = await determineModelType(unknownSkin.texture)
+	}
 }
 
 export function filterDefaultSkins(list: Skin[]) {
-  return list
-    .filter(
-      (s) =>
-        s.source === 'default' &&
-        (!s.name || !(s.name in DEFAULT_MODELS) || s.variant === DEFAULT_MODELS[s.name]),
-    )
-    .sort((a, b) => {
-      const aIndex = a.name ? DEFAULT_MODEL_SORTING.indexOf(a.name) : -1
-      const bIndex = b.name ? DEFAULT_MODEL_SORTING.indexOf(b.name) : -1
-      return (aIndex === -1 ? Infinity : aIndex) - (bIndex === -1 ? Infinity : bIndex)
-    })
+	return list
+		.filter(
+			(s) =>
+				s.source === 'default' &&
+				(!s.name || !(s.name in DEFAULT_MODELS) || s.variant === DEFAULT_MODELS[s.name]),
+		)
+		.sort((a, b) => {
+			const aIndex = a.name ? DEFAULT_MODEL_SORTING.indexOf(a.name) : -1
+			const bIndex = b.name ? DEFAULT_MODEL_SORTING.indexOf(b.name) : -1
+			return (aIndex === -1 ? Infinity : aIndex) - (bIndex === -1 ? Infinity : bIndex)
+		})
 }
 
 export async function get_available_capes(): Promise<Cape[]> {
-  return invoke('plugin:minecraft-skins|get_available_capes', {})
+	return invoke('plugin:minecraft-skins|get_available_capes', {})
 }
 
 export async function get_available_skins(): Promise<Skin[]> {
-  return invoke('plugin:minecraft-skins|get_available_skins', {})
+	return invoke('plugin:minecraft-skins|get_available_skins', {})
 }
 
 export async function add_and_equip_custom_skin(
-  textureBlob: Uint8Array,
-  variant: SkinModel,
-  capeOverride?: Cape,
+	textureBlob: Uint8Array,
+	variant: SkinModel,
+	capeOverride?: Cape,
 ): Promise<void> {
-  await invoke('plugin:minecraft-skins|add_and_equip_custom_skin', {
-    textureBlob,
-    variant,
-    capeOverride,
-  })
+	await invoke('plugin:minecraft-skins|add_and_equip_custom_skin', {
+		textureBlob,
+		variant,
+		capeOverride,
+	})
 }
 
 export async function set_default_cape(cape?: Cape): Promise<void> {
-  await invoke('plugin:minecraft-skins|set_default_cape', {
-    cape,
-  })
+	await invoke('plugin:minecraft-skins|set_default_cape', {
+		cape,
+	})
 }
 
 export async function equip_skin(skin: Skin): Promise<void> {
-  await invoke('plugin:minecraft-skins|equip_skin', {
-    skin,
-  })
+	await invoke('plugin:minecraft-skins|equip_skin', {
+		skin,
+	})
 }
 
 export async function remove_custom_skin(skin: Skin): Promise<void> {
-  await invoke('plugin:minecraft-skins|remove_custom_skin', {
-    skin,
-  })
+	await invoke('plugin:minecraft-skins|remove_custom_skin', {
+		skin,
+	})
 }
 
 export async function get_normalized_skin_texture(skin: Skin): Promise<string> {
-  const data = await normalize_skin_texture(skin.texture)
-  const base64 = arrayBufferToBase64(data)
-  return `data:image/png;base64,${base64}`
+	const data = await normalize_skin_texture(skin.texture)
+	const base64 = arrayBufferToBase64(data)
+	return `data:image/png;base64,${base64}`
 }
 
 export async function normalize_skin_texture(texture: Uint8Array | string): Promise<Uint8Array> {
-  return await invoke('plugin:minecraft-skins|normalize_skin_texture', { texture })
+	return await invoke('plugin:minecraft-skins|normalize_skin_texture', { texture })
 }
 
 export async function unequip_skin(): Promise<void> {
-  await invoke('plugin:minecraft-skins|unequip_skin')
+	await invoke('plugin:minecraft-skins|unequip_skin')
 }
 
 export async function get_dragged_skin_data(path: string): Promise<Uint8Array> {
-  const data = await invoke('plugin:minecraft-skins|get_dragged_skin_data', { path })
-  return new Uint8Array(data)
+	const data = await invoke('plugin:minecraft-skins|get_dragged_skin_data', { path })
+	return new Uint8Array(data)
 }

apps/app-frontend/src/helpers/state.js

@@ -8,12 +8,12 @@ import { invoke } from '@tauri-apps/api/core'
 // Initialize the theseus API state
 // This should be called during the initializion/opening of the launcher
 export async function initialize_state() {
-  return await invoke('initialize_state')
+	return await invoke('initialize_state')
 }
 
 // Gets active progress bars
 export async function progress_bars_list() {
-  return await invoke('plugin:utils|progress_bars_list')
+	return await invoke('plugin:utils|progress_bars_list')
 }
 
 // Get opening command
@@ -21,5 +21,5 @@ export async function progress_bars_list() {
 // This should be called once and only when the app is done booting up and ready to receive a command
 // Returns a Command struct- see events.js
 export async function get_opening_command() {
-  return await invoke('plugin:utils|get_opening_command')
+	return await invoke('plugin:utils|get_opening_command')
 }

apps/app-frontend/src/helpers/storage/head-storage.ts

@@ -1,229 +1,229 @@
 interface StoredHead {
-  blob: Blob
-  timestamp: number
+	blob: Blob
+	timestamp: number
 }
 
 export class HeadStorage {
-  private dbName = 'head-storage'
-  private version = 1
-  private db: IDBDatabase | null = null
+	private dbName = 'head-storage'
+	private version = 1
+	private db: IDBDatabase | null = null
 
-  async init(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, this.version)
+	async init(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.dbName, this.version)
 
-      request.onerror = () => reject(request.error)
-      request.onsuccess = () => {
-        this.db = request.result
-        resolve()
-      }
+			request.onerror = () => reject(request.error)
+			request.onsuccess = () => {
+				this.db = request.result
+				resolve()
+			}
 
-      request.onupgradeneeded = () => {
-        const db = request.result
-        if (!db.objectStoreNames.contains('heads')) {
-          db.createObjectStore('heads')
-        }
-      }
-    })
-  }
+			request.onupgradeneeded = () => {
+				const db = request.result
+				if (!db.objectStoreNames.contains('heads')) {
+					db.createObjectStore('heads')
+				}
+			}
+		})
+	}
 
-  async store(key: string, blob: Blob): Promise<void> {
-    if (!this.db) await this.init()
+	async store(key: string, blob: Blob): Promise<void> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readwrite')
-    const store = transaction.objectStore('heads')
+		const transaction = this.db!.transaction(['heads'], 'readwrite')
+		const store = transaction.objectStore('heads')
 
-    const storedHead: StoredHead = {
-      blob,
-      timestamp: Date.now(),
-    }
+		const storedHead: StoredHead = {
+			blob,
+			timestamp: Date.now(),
+		}
 
-    return new Promise((resolve, reject) => {
-      const request = store.put(storedHead, key)
+		return new Promise((resolve, reject) => {
+			const request = store.put(storedHead, key)
 
-      request.onsuccess = () => resolve()
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onsuccess = () => resolve()
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async retrieve(key: string): Promise<string | null> {
-    if (!this.db) await this.init()
+	async retrieve(key: string): Promise<string | null> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readonly')
-    const store = transaction.objectStore('heads')
+		const transaction = this.db!.transaction(['heads'], 'readonly')
+		const store = transaction.objectStore('heads')
 
-    return new Promise((resolve, reject) => {
-      const request = store.get(key)
+		return new Promise((resolve, reject) => {
+			const request = store.get(key)
 
-      request.onsuccess = () => {
-        const result = request.result as StoredHead | undefined
+			request.onsuccess = () => {
+				const result = request.result as StoredHead | undefined
 
-        if (!result) {
-          resolve(null)
-          return
-        }
+				if (!result) {
+					resolve(null)
+					return
+				}
 
-        const url = URL.createObjectURL(result.blob)
-        resolve(url)
-      }
-      request.onerror = () => reject(request.error)
-    })
-  }
+				const url = URL.createObjectURL(result.blob)
+				resolve(url)
+			}
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async batchRetrieve(keys: string[]): Promise<Record<string, Blob | null>> {
-    if (!this.db) await this.init()
+	async batchRetrieve(keys: string[]): Promise<Record<string, Blob | null>> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readonly')
-    const store = transaction.objectStore('heads')
-    const results: Record<string, Blob | null> = {}
+		const transaction = this.db!.transaction(['heads'], 'readonly')
+		const store = transaction.objectStore('heads')
+		const results: Record<string, Blob | null> = {}
 
-    return new Promise((resolve, _reject) => {
-      let completedRequests = 0
+		return new Promise((resolve, _reject) => {
+			let completedRequests = 0
 
-      if (keys.length === 0) {
-        resolve(results)
-        return
-      }
+			if (keys.length === 0) {
+				resolve(results)
+				return
+			}
 
-      for (const key of keys) {
-        const request = store.get(key)
+			for (const key of keys) {
+				const request = store.get(key)
 
-        request.onsuccess = () => {
-          const result = request.result as StoredHead | undefined
+				request.onsuccess = () => {
+					const result = request.result as StoredHead | undefined
 
-          if (result) {
-            results[key] = result.blob
-          } else {
-            results[key] = null
-          }
+					if (result) {
+						results[key] = result.blob
+					} else {
+						results[key] = null
+					}
 
-          completedRequests++
-          if (completedRequests === keys.length) {
-            resolve(results)
-          }
-        }
+					completedRequests++
+					if (completedRequests === keys.length) {
+						resolve(results)
+					}
+				}
 
-        request.onerror = () => {
-          results[key] = null
-          completedRequests++
-          if (completedRequests === keys.length) {
-            resolve(results)
-          }
-        }
-      }
-    })
-  }
+				request.onerror = () => {
+					results[key] = null
+					completedRequests++
+					if (completedRequests === keys.length) {
+						resolve(results)
+					}
+				}
+			}
+		})
+	}
 
-  async cleanupInvalidKeys(validKeys: Set<string>): Promise<number> {
-    if (!this.db) await this.init()
+	async cleanupInvalidKeys(validKeys: Set<string>): Promise<number> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readwrite')
-    const store = transaction.objectStore('heads')
-    let deletedCount = 0
+		const transaction = this.db!.transaction(['heads'], 'readwrite')
+		const store = transaction.objectStore('heads')
+		let deletedCount = 0
 
-    return new Promise((resolve, reject) => {
-      const request = store.openCursor()
+		return new Promise((resolve, reject) => {
+			const request = store.openCursor()
 
-      request.onsuccess = (event) => {
-        const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+			request.onsuccess = (event) => {
+				const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
 
-        if (cursor) {
-          const key = cursor.primaryKey as string
+				if (cursor) {
+					const key = cursor.primaryKey as string
 
-          if (!validKeys.has(key)) {
-            const deleteRequest = cursor.delete()
-            deleteRequest.onsuccess = () => {
-              deletedCount++
-            }
-            deleteRequest.onerror = () => {
-              console.warn('Failed to delete invalid head entry:', key)
-            }
-          }
+					if (!validKeys.has(key)) {
+						const deleteRequest = cursor.delete()
+						deleteRequest.onsuccess = () => {
+							deletedCount++
+						}
+						deleteRequest.onerror = () => {
+							console.warn('Failed to delete invalid head entry:', key)
+						}
+					}
 
-          cursor.continue()
-        } else {
-          resolve(deletedCount)
-        }
-      }
+					cursor.continue()
+				} else {
+					resolve(deletedCount)
+				}
+			}
 
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async debugCalculateStorage(): Promise<void> {
-    if (!this.db) await this.init()
+	async debugCalculateStorage(): Promise<void> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readonly')
-    const store = transaction.objectStore('heads')
+		const transaction = this.db!.transaction(['heads'], 'readonly')
+		const store = transaction.objectStore('heads')
 
-    let totalSize = 0
-    let count = 0
-    const entries: Array<{ key: string; size: number }> = []
+		let totalSize = 0
+		let count = 0
+		const entries: Array<{ key: string; size: number }> = []
 
-    return new Promise((resolve, reject) => {
-      const request = store.openCursor()
+		return new Promise((resolve, reject) => {
+			const request = store.openCursor()
 
-      request.onsuccess = (event) => {
-        const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+			request.onsuccess = (event) => {
+				const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
 
-        if (cursor) {
-          const key = cursor.primaryKey as string
-          const value = cursor.value as StoredHead
+				if (cursor) {
+					const key = cursor.primaryKey as string
+					const value = cursor.value as StoredHead
 
-          const entrySize = value.blob.size
-          totalSize += entrySize
-          count++
+					const entrySize = value.blob.size
+					totalSize += entrySize
+					count++
 
-          entries.push({
-            key,
-            size: entrySize,
-          })
+					entries.push({
+						key,
+						size: entrySize,
+					})
 
-          cursor.continue()
-        } else {
-          console.group('🗄️ Head Storage Debug Info')
-          console.log(`Total entries: ${count}`)
-          console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`)
-          console.log(
-            `Average size per entry: ${count > 0 ? (totalSize / count / 1024).toFixed(2) : 0} KB`,
-          )
+					cursor.continue()
+				} else {
+					console.group('🗄️ Head Storage Debug Info')
+					console.log(`Total entries: ${count}`)
+					console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`)
+					console.log(
+						`Average size per entry: ${count > 0 ? (totalSize / count / 1024).toFixed(2) : 0} KB`,
+					)
 
-          if (entries.length > 0) {
-            const sortedEntries = entries.sort((a, b) => b.size - a.size)
-            console.log(
-              'Largest entry:',
-              sortedEntries[0].key,
-              '(' + (sortedEntries[0].size / 1024).toFixed(2) + ' KB)',
-            )
-            console.log(
-              'Smallest entry:',
-              sortedEntries[sortedEntries.length - 1].key,
-              '(' + (sortedEntries[sortedEntries.length - 1].size / 1024).toFixed(2) + ' KB)',
-            )
-          }
+					if (entries.length > 0) {
+						const sortedEntries = entries.sort((a, b) => b.size - a.size)
+						console.log(
+							'Largest entry:',
+							sortedEntries[0].key,
+							'(' + (sortedEntries[0].size / 1024).toFixed(2) + ' KB)',
+						)
+						console.log(
+							'Smallest entry:',
+							sortedEntries[sortedEntries.length - 1].key,
+							'(' + (sortedEntries[sortedEntries.length - 1].size / 1024).toFixed(2) + ' KB)',
+						)
+					}
 
-          console.groupEnd()
-          resolve()
-        }
-      }
+					console.groupEnd()
+					resolve()
+				}
+			}
 
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async clearAll(): Promise<void> {
-    if (!this.db) await this.init()
+	async clearAll(): Promise<void> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['heads'], 'readwrite')
-    const store = transaction.objectStore('heads')
+		const transaction = this.db!.transaction(['heads'], 'readwrite')
+		const store = transaction.objectStore('heads')
 
-    return new Promise((resolve, reject) => {
-      const request = store.clear()
+		return new Promise((resolve, reject) => {
+			const request = store.clear()
 
-      request.onsuccess = () => resolve()
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onsuccess = () => resolve()
+			request.onerror = () => reject(request.error)
+		})
+	}
 }
 
 export const headStorage = new HeadStorage()

apps/app-frontend/src/helpers/storage/skin-preview-storage.ts

@@ -1,218 +1,218 @@
 import type { RawRenderResult } from '../rendering/batch-skin-renderer'
 
 interface StoredPreview {
-  forwards: Blob
-  backwards: Blob
-  timestamp: number
+	forwards: Blob
+	backwards: Blob
+	timestamp: number
 }
 
 export class SkinPreviewStorage {
-  private dbName = 'skin-previews'
-  private version = 1
-  private db: IDBDatabase | null = null
+	private dbName = 'skin-previews'
+	private version = 1
+	private db: IDBDatabase | null = null
 
-  async init(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, this.version)
+	async init(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.dbName, this.version)
 
-      request.onerror = () => reject(request.error)
-      request.onsuccess = () => {
-        this.db = request.result
-        resolve()
-      }
+			request.onerror = () => reject(request.error)
+			request.onsuccess = () => {
+				this.db = request.result
+				resolve()
+			}
 
-      request.onupgradeneeded = () => {
-        const db = request.result
-        if (!db.objectStoreNames.contains('previews')) {
-          db.createObjectStore('previews')
-        }
-      }
-    })
-  }
+			request.onupgradeneeded = () => {
+				const db = request.result
+				if (!db.objectStoreNames.contains('previews')) {
+					db.createObjectStore('previews')
+				}
+			}
+		})
+	}
 
-  async store(key: string, result: RawRenderResult): Promise<void> {
-    if (!this.db) await this.init()
+	async store(key: string, result: RawRenderResult): Promise<void> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['previews'], 'readwrite')
-    const store = transaction.objectStore('previews')
+		const transaction = this.db!.transaction(['previews'], 'readwrite')
+		const store = transaction.objectStore('previews')
 
-    const storedPreview: StoredPreview = {
-      forwards: result.forwards,
-      backwards: result.backwards,
-      timestamp: Date.now(),
-    }
+		const storedPreview: StoredPreview = {
+			forwards: result.forwards,
+			backwards: result.backwards,
+			timestamp: Date.now(),
+		}
 
-    return new Promise((resolve, reject) => {
-      const request = store.put(storedPreview, key)
+		return new Promise((resolve, reject) => {
+			const request = store.put(storedPreview, key)
 
-      request.onsuccess = () => resolve()
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onsuccess = () => resolve()
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async retrieve(key: string): Promise<RawRenderResult | null> {
-    if (!this.db) await this.init()
+	async retrieve(key: string): Promise<RawRenderResult | null> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['previews'], 'readonly')
-    const store = transaction.objectStore('previews')
+		const transaction = this.db!.transaction(['previews'], 'readonly')
+		const store = transaction.objectStore('previews')
 
-    return new Promise((resolve, reject) => {
-      const request = store.get(key)
+		return new Promise((resolve, reject) => {
+			const request = store.get(key)
 
-      request.onsuccess = () => {
-        const result = request.result as StoredPreview | undefined
+			request.onsuccess = () => {
+				const result = request.result as StoredPreview | undefined
 
-        if (!result) {
-          resolve(null)
-          return
-        }
+				if (!result) {
+					resolve(null)
+					return
+				}
 
-        resolve({ forwards: result.forwards, backwards: result.backwards })
-      }
-      request.onerror = () => reject(request.error)
-    })
-  }
+				resolve({ forwards: result.forwards, backwards: result.backwards })
+			}
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async batchRetrieve(keys: string[]): Promise<Record<string, RawRenderResult | null>> {
-    if (!this.db) await this.init()
+	async batchRetrieve(keys: string[]): Promise<Record<string, RawRenderResult | null>> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['previews'], 'readonly')
-    const store = transaction.objectStore('previews')
-    const results: Record<string, RawRenderResult | null> = {}
+		const transaction = this.db!.transaction(['previews'], 'readonly')
+		const store = transaction.objectStore('previews')
+		const results: Record<string, RawRenderResult | null> = {}
 
-    return new Promise((resolve, _reject) => {
-      let completedRequests = 0
+		return new Promise((resolve, _reject) => {
+			let completedRequests = 0
 
-      if (keys.length === 0) {
-        resolve(results)
-        return
-      }
+			if (keys.length === 0) {
+				resolve(results)
+				return
+			}
 
-      for (const key of keys) {
-        const request = store.get(key)
+			for (const key of keys) {
+				const request = store.get(key)
 
-        request.onsuccess = () => {
-          const result = request.result as StoredPreview | undefined
+				request.onsuccess = () => {
+					const result = request.result as StoredPreview | undefined
 
-          if (result) {
-            results[key] = { forwards: result.forwards, backwards: result.backwards }
-          } else {
-            results[key] = null
-          }
+					if (result) {
+						results[key] = { forwards: result.forwards, backwards: result.backwards }
+					} else {
+						results[key] = null
+					}
 
-          completedRequests++
-          if (completedRequests === keys.length) {
-            resolve(results)
-          }
-        }
+					completedRequests++
+					if (completedRequests === keys.length) {
+						resolve(results)
+					}
+				}
 
-        request.onerror = () => {
-          results[key] = null
-          completedRequests++
-          if (completedRequests === keys.length) {
-            resolve(results)
-          }
-        }
-      }
-    })
-  }
+				request.onerror = () => {
+					results[key] = null
+					completedRequests++
+					if (completedRequests === keys.length) {
+						resolve(results)
+					}
+				}
+			}
+		})
+	}
 
-  async cleanupInvalidKeys(validKeys: Set<string>): Promise<number> {
-    if (!this.db) await this.init()
+	async cleanupInvalidKeys(validKeys: Set<string>): Promise<number> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['previews'], 'readwrite')
-    const store = transaction.objectStore('previews')
-    let deletedCount = 0
+		const transaction = this.db!.transaction(['previews'], 'readwrite')
+		const store = transaction.objectStore('previews')
+		let deletedCount = 0
 
-    return new Promise((resolve, reject) => {
-      const request = store.openCursor()
+		return new Promise((resolve, reject) => {
+			const request = store.openCursor()
 
-      request.onsuccess = (event) => {
-        const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+			request.onsuccess = (event) => {
+				const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
 
-        if (cursor) {
-          const key = cursor.primaryKey as string
+				if (cursor) {
+					const key = cursor.primaryKey as string
 
-          if (!validKeys.has(key)) {
-            const deleteRequest = cursor.delete()
-            deleteRequest.onsuccess = () => {
-              deletedCount++
-            }
-            deleteRequest.onerror = () => {
-              console.warn('Failed to delete invalid entry:', key)
-            }
-          }
+					if (!validKeys.has(key)) {
+						const deleteRequest = cursor.delete()
+						deleteRequest.onsuccess = () => {
+							deletedCount++
+						}
+						deleteRequest.onerror = () => {
+							console.warn('Failed to delete invalid entry:', key)
+						}
+					}
 
-          cursor.continue()
-        } else {
-          resolve(deletedCount)
-        }
-      }
+					cursor.continue()
+				} else {
+					resolve(deletedCount)
+				}
+			}
 
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onerror = () => reject(request.error)
+		})
+	}
 
-  async debugCalculateStorage(): Promise<void> {
-    if (!this.db) await this.init()
+	async debugCalculateStorage(): Promise<void> {
+		if (!this.db) await this.init()
 
-    const transaction = this.db!.transaction(['previews'], 'readonly')
-    const store = transaction.objectStore('previews')
+		const transaction = this.db!.transaction(['previews'], 'readonly')
+		const store = transaction.objectStore('previews')
 
-    let totalSize = 0
-    let count = 0
-    const entries: Array<{ key: string; size: number }> = []
+		let totalSize = 0
+		let count = 0
+		const entries: Array<{ key: string; size: number }> = []
 
-    return new Promise((resolve, reject) => {
-      const request = store.openCursor()
+		return new Promise((resolve, reject) => {
+			const request = store.openCursor()
 
-      request.onsuccess = (event) => {
-        const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+			request.onsuccess = (event) => {
+				const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
 
-        if (cursor) {
-          const key = cursor.primaryKey as string
-          const value = cursor.value as StoredPreview
+				if (cursor) {
+					const key = cursor.primaryKey as string
+					const value = cursor.value as StoredPreview
 
-          const entrySize = value.forwards.size + value.backwards.size
-          totalSize += entrySize
-          count++
+					const entrySize = value.forwards.size + value.backwards.size
+					totalSize += entrySize
+					count++
 
-          entries.push({
-            key,
-            size: entrySize,
-          })
+					entries.push({
+						key,
+						size: entrySize,
+					})
 
-          cursor.continue()
-        } else {
-          console.group('🗄️ Skin Preview Storage Debug Info')
-          console.log(`Total entries: ${count}`)
-          console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`)
-          console.log(
-            `Average size per entry: ${count > 0 ? (totalSize / count / 1024).toFixed(2) : 0} KB`,
-          )
+					cursor.continue()
+				} else {
+					console.group('🗄️ Skin Preview Storage Debug Info')
+					console.log(`Total entries: ${count}`)
+					console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`)
+					console.log(
+						`Average size per entry: ${count > 0 ? (totalSize / count / 1024).toFixed(2) : 0} KB`,
+					)
 
-          if (entries.length > 0) {
-            const sortedEntries = entries.sort((a, b) => b.size - a.size)
-            console.log(
-              'Largest entry:',
-              sortedEntries[0].key,
-              '(' + (sortedEntries[0].size / 1024).toFixed(2) + ' KB)',
-            )
-            console.log(
-              'Smallest entry:',
-              sortedEntries[sortedEntries.length - 1].key,
-              '(' + (sortedEntries[sortedEntries.length - 1].size / 1024).toFixed(2) + ' KB)',
-            )
-          }
+					if (entries.length > 0) {
+						const sortedEntries = entries.sort((a, b) => b.size - a.size)
+						console.log(
+							'Largest entry:',
+							sortedEntries[0].key,
+							'(' + (sortedEntries[0].size / 1024).toFixed(2) + ' KB)',
+						)
+						console.log(
+							'Smallest entry:',
+							sortedEntries[sortedEntries.length - 1].key,
+							'(' + (sortedEntries[sortedEntries.length - 1].size / 1024).toFixed(2) + ' KB)',
+						)
+					}
 
-          console.groupEnd()
-          resolve()
-        }
-      }
+					console.groupEnd()
+					resolve()
+				}
+			}
 
-      request.onerror = () => reject(request.error)
-    })
-  }
+			request.onerror = () => reject(request.error)
+		})
+	}
 }
 
 export const skinPreviewStorage = new SkinPreviewStorage()

apps/app-frontend/src/helpers/tags.js

@@ -7,25 +7,25 @@ import { invoke } from '@tauri-apps/api/core'
 
 // Gets cached category tags
 export async function get_categories() {
-  return await invoke('plugin:tags|tags_get_categories')
+	return await invoke('plugin:tags|tags_get_categories')
 }
 
 // Gets cached loaders tags
 export async function get_loaders() {
-  return await invoke('plugin:tags|tags_get_loaders')
+	return await invoke('plugin:tags|tags_get_loaders')
 }
 
 // Gets cached game_versions tags
 export async function get_game_versions() {
-  return await invoke('plugin:tags|tags_get_game_versions')
+	return await invoke('plugin:tags|tags_get_game_versions')
 }
 
 // Gets cached donation_platforms tags
 export async function get_donation_platforms() {
-  return await invoke('plugin:tags|tags_get_donation_platforms')
+	return await invoke('plugin:tags|tags_get_donation_platforms')
 }
 
 // Gets cached licenses tags
 export async function get_report_types() {
-  return await invoke('plugin:tags|tags_get_report_types')
+	return await invoke('plugin:tags|tags_get_report_types')
 }

apps/app-frontend/src/helpers/types.d.ts

@@ -1,142 +1,142 @@
 import type { ModrinthId } from '@modrinth/utils'
 
 type GameInstance = {
-  path: string
-  install_stage: InstallStage
+	path: string
+	install_stage: InstallStage
 
-  name: string
-  icon_path?: string
+	name: string
+	icon_path?: string
 
-  game_version: string
-  loader: InstanceLoader
-  loader_version?: string
+	game_version: string
+	loader: InstanceLoader
+	loader_version?: string
 
-  groups: string[]
+	groups: string[]
 
-  linked_data?: LinkedData
+	linked_data?: LinkedData
 
-  created: Date
-  modified: Date
-  last_played?: Date
+	created: Date
+	modified: Date
+	last_played?: Date
 
-  submitted_time_played: number
-  recent_time_played: number
+	submitted_time_played: number
+	recent_time_played: number
 
-  java_path?: string
-  extra_launch_args?: string[]
-  custom_env_vars?: [string, string][]
+	java_path?: string
+	extra_launch_args?: string[]
+	custom_env_vars?: [string, string][]
 
-  memory?: MemorySettings
-  force_fullscreen?: boolean
-  game_resolution?: [number, number]
-  hooks: Hooks
+	memory?: MemorySettings
+	force_fullscreen?: boolean
+	game_resolution?: [number, number]
+	hooks: Hooks
 }
 
 type InstallStage =
-  | 'installed'
-  | 'minecraft_installing'
-  | 'pack_installed'
-  | 'pack_installing'
-  | 'not_installed'
+	| 'installed'
+	| 'minecraft_installing'
+	| 'pack_installed'
+	| 'pack_installing'
+	| 'not_installed'
 
 type LinkedData = {
-  project_id: ModrinthId
-  version_id: ModrinthId
+	project_id: ModrinthId
+	version_id: ModrinthId
 
-  locked: boolean
+	locked: boolean
 }
 
 type InstanceLoader = 'vanilla' | 'forge' | 'fabric' | 'quilt' | 'neoforge'
 
 type ContentFile = {
-  hash: string
-  file_name: string
-  size: number
-  metadata?: FileMetadata
-  update_version_id?: string
-  project_type: ContentFileProjectType
+	hash: string
+	file_name: string
+	size: number
+	metadata?: FileMetadata
+	update_version_id?: string
+	project_type: ContentFileProjectType
 }
 
 type FileMetadata = {
-  project_id: string
-  version_id: string
+	project_id: string
+	version_id: string
 }
 
 type ContentFileProjectType = 'mod' | 'datapack' | 'resourcepack' | 'shaderpack'
 
 type CacheBehaviour =
-  // Serve expired data. If fetch fails / launcher is offline, errors are ignored
-  | 'stale_while_revalidate_skip_offline'
-  // Serve expired data, revalidate in background
-  | 'stale_while_revalidate'
-  // Must revalidate if data is expired
-  | 'must_revalidate'
-  // Ignore cache- always fetch updated data from origin
-  | 'bypass'
+	// Serve expired data. If fetch fails / launcher is offline, errors are ignored
+	| 'stale_while_revalidate_skip_offline'
+	// Serve expired data, revalidate in background
+	| 'stale_while_revalidate'
+	// Must revalidate if data is expired
+	| 'must_revalidate'
+	// Ignore cache- always fetch updated data from origin
+	| 'bypass'
 
 type MemorySettings = {
-  maximum: number
+	maximum: number
 }
 
 type WindowSize = {
-  width: number
-  height: number
+	width: number
+	height: number
 }
 
 type Hooks = {
-  pre_launch?: string
-  wrapper?: string
-  post_exit?: string
+	pre_launch?: string
+	wrapper?: string
+	post_exit?: string
 }
 
 type Manifest = {
-  gameVersions: ManifestGameVersion[]
+	gameVersions: ManifestGameVersion[]
 }
 
 type ManifestGameVersion = {
-  id: string
-  stable: boolean
-  loaders: ManifestLoaderVersion[]
+	id: string
+	stable: boolean
+	loaders: ManifestLoaderVersion[]
 }
 
 type ManifestLoaderVersion = {
-  id: string
-  url: string
-  stable: boolean
+	id: string
+	url: string
+	stable: boolean
 }
 
 type AppSettings = {
-  max_concurrent_downloads: number
-  max_concurrent_writes: number
+	max_concurrent_downloads: number
+	max_concurrent_writes: number
 
-  theme: 'dark' | 'light' | 'oled'
-  default_page: 'Home' | 'Library'
-  collapsed_navigation: boolean
-  advanced_rendering: boolean
-  native_decorations: boolean
-  worlds_in_home: boolean
+	theme: 'dark' | 'light' | 'oled'
+	default_page: 'Home' | 'Library'
+	collapsed_navigation: boolean
+	advanced_rendering: boolean
+	native_decorations: boolean
+	worlds_in_home: boolean
 
-  telemetry: boolean
-  discord_rpc: boolean
-  developer_mode: boolean
-  personalized_ads: boolean
+	telemetry: boolean
+	discord_rpc: boolean
+	developer_mode: boolean
+	personalized_ads: boolean
 
-  onboarded: boolean
+	onboarded: boolean
 
-  extra_launch_args: string[]
-  custom_env_vars: [string, string][]
-  memory: MemorySettings
-  force_fullscreen: boolean
-  game_resolution: [number, number]
-  hide_on_process_start: boolean
-  hooks: Hooks
+	extra_launch_args: string[]
+	custom_env_vars: [string, string][]
+	memory: MemorySettings
+	force_fullscreen: boolean
+	game_resolution: [number, number]
+	hide_on_process_start: boolean
+	hooks: Hooks
 
-  custom_dir?: string
-  prev_custom_dir?: string
-  migrated: boolean
+	custom_dir?: string
+	prev_custom_dir?: string
+	migrated: boolean
 }
 
 export type InstanceSettingsTabProps = {
-  instance: GameInstance
-  offline?: boolean
+	instance: GameInstance
+	offline?: boolean
 }

apps/app-frontend/src/helpers/utils.js

@@ -1,62 +1,63 @@
-import { get_full_path, get_mod_full_path } from '@/helpers/profile'
 import { invoke } from '@tauri-apps/api/core'
 
+import { get_full_path, get_mod_full_path } from '@/helpers/profile'
+
 export async function isDev() {
-  return await invoke('is_dev')
+	return await invoke('is_dev')
 }
 
 // One of 'Windows', 'Linux', 'MacOS'
 export async function getOS() {
-  return await invoke('plugin:utils|get_os')
+	return await invoke('plugin:utils|get_os')
 }
 
 export async function openPath(path) {
-  return await invoke('plugin:utils|open_path', { path })
+	return await invoke('plugin:utils|open_path', { path })
 }
 
 export async function highlightInFolder(path) {
-  return await invoke('plugin:utils|highlight_in_folder', { path })
+	return await invoke('plugin:utils|highlight_in_folder', { path })
 }
 
 export async function showLauncherLogsFolder() {
-  return await invoke('plugin:utils|show_launcher_logs_folder', {})
+	return await invoke('plugin:utils|show_launcher_logs_folder', {})
 }
 
 // Opens a profile's folder in the OS file explorer
 export async function showProfileInFolder(path) {
-  const fullPath = await get_full_path(path)
-  return await openPath(fullPath)
+	const fullPath = await get_full_path(path)
+	return await openPath(fullPath)
 }
 
 export async function highlightModInProfile(profilePath, projectPath) {
-  const fullPath = await get_mod_full_path(profilePath, projectPath)
-  return await highlightInFolder(fullPath)
+	const fullPath = await get_mod_full_path(profilePath, projectPath)
+	return await highlightInFolder(fullPath)
 }
 
 export async function restartApp() {
-  return await invoke('restart_app')
+	return await invoke('restart_app')
 }
 
 /**
  * @deprecated This method is no longer needed, and just returns its parameter
  */
 export function sanitizePotentialFileUrl(url) {
-  return url
+	return url
 }
 
 export const releaseColor = (releaseType) => {
-  switch (releaseType) {
-    case 'release':
-      return 'green'
-    case 'beta':
-      return 'orange'
-    case 'alpha':
-      return 'red'
-    default:
-      return ''
-  }
+	switch (releaseType) {
+		case 'release':
+			return 'green'
+		case 'beta':
+			return 'orange'
+		case 'alpha':
+			return 'red'
+		default:
+			return ''
+	}
 }
 
 export async function copyToClipboard(text) {
-  await navigator.clipboard.writeText(text)
+	await navigator.clipboard.writeText(text)
 }

apps/app-frontend/src/helpers/worlds.ts

@@ -1,350 +1,351 @@
+import { autoToHTML } from '@geometrically/minecraft-motd-parser'
+import type { GameVersion } from '@modrinth/ui'
 import { invoke } from '@tauri-apps/api/core'
+import dayjs from 'dayjs'
+
 import { get_full_path } from '@/helpers/profile'
 import { openPath } from '@/helpers/utils'
-import { autoToHTML } from '@geometrically/minecraft-motd-parser'
-import dayjs from 'dayjs'
-import type { GameVersion } from '@modrinth/ui'
 
 type BaseWorld = {
-  name: string
-  last_played?: string
-  icon?: string
-  display_status: DisplayStatus
-  type: WorldType
+	name: string
+	last_played?: string
+	icon?: string
+	display_status: DisplayStatus
+	type: WorldType
 }
 
 export type WorldType = 'singleplayer' | 'server'
 export type DisplayStatus = 'normal' | 'hidden' | 'favorite'
 
 export type SingleplayerWorld = BaseWorld & {
-  type: 'singleplayer'
-  path: string
-  game_mode: SingleplayerGameMode
-  hardcore: boolean
-  locked: boolean
+	type: 'singleplayer'
+	path: string
+	game_mode: SingleplayerGameMode
+	hardcore: boolean
+	locked: boolean
 }
 
 export type ServerWorld = BaseWorld & {
-  type: 'server'
-  index: number
-  address: string
-  pack_status: ServerPackStatus
+	type: 'server'
+	index: number
+	address: string
+	pack_status: ServerPackStatus
 }
 
 export type World = SingleplayerWorld | ServerWorld
 
 export type WorldWithProfile = {
-  profile: string
+	profile: string
 } & World
 
 export type SingleplayerGameMode = 'survival' | 'creative' | 'adventure' | 'spectator'
 export type ServerPackStatus = 'enabled' | 'disabled' | 'prompt'
 
 export type ServerStatus = {
-  // https://minecraft.wiki/w/Text_component_format
-  description?: string | Chat
-  players?: {
-    max: number
-    online: number
-    sample: { name: string; id: string }[]
-  }
-  version?: {
-    name: string
-    protocol: number
-    legacy: boolean
-  }
-  favicon?: string
-  enforces_secure_chat: boolean
-  ping?: number
+	// https://minecraft.wiki/w/Text_component_format
+	description?: string | Chat
+	players?: {
+		max: number
+		online: number
+		sample: { name: string; id: string }[]
+	}
+	version?: {
+		name: string
+		protocol: number
+		legacy: boolean
+	}
+	favicon?: string
+	enforces_secure_chat: boolean
+	ping?: number
 }
 
 export interface Chat {
-  text: string
-  bold: boolean
-  italic: boolean
-  underlined: boolean
-  strikethrough: boolean
-  obfuscated: boolean
-  color?: string
-  extra: Chat[]
+	text: string
+	bold: boolean
+	italic: boolean
+	underlined: boolean
+	strikethrough: boolean
+	obfuscated: boolean
+	color?: string
+	extra: Chat[]
 }
 
 export type ServerData = {
-  refreshing: boolean
-  lastSuccessfulRefresh?: number
-  status?: ServerStatus
-  rawMotd?: string | Chat
-  renderedMotd?: string
+	refreshing: boolean
+	lastSuccessfulRefresh?: number
+	status?: ServerStatus
+	rawMotd?: string | Chat
+	renderedMotd?: string
 }
 
 export type ProtocolVersion = {
-  version: number
-  legacy: boolean
+	version: number
+	legacy: boolean
 }
 
 export async function get_recent_worlds(
-  limit: number,
-  displayStatuses?: DisplayStatus[],
+	limit: number,
+	displayStatuses?: DisplayStatus[],
 ): Promise<WorldWithProfile[]> {
-  return await invoke('plugin:worlds|get_recent_worlds', { limit, displayStatuses })
+	return await invoke('plugin:worlds|get_recent_worlds', { limit, displayStatuses })
 }
 
 export async function get_profile_worlds(path: string): Promise<World[]> {
-  return await invoke('plugin:worlds|get_profile_worlds', { path })
+	return await invoke('plugin:worlds|get_profile_worlds', { path })
 }
 
 export async function get_singleplayer_world(
-  instance: string,
-  world: string,
+	instance: string,
+	world: string,
 ): Promise<SingleplayerWorld> {
-  return await invoke('plugin:worlds|get_singleplayer_world', { instance, world })
+	return await invoke('plugin:worlds|get_singleplayer_world', { instance, world })
 }
 
 export async function set_world_display_status(
-  instance: string,
-  worldType: WorldType,
-  worldId: string,
-  displayStatus: DisplayStatus,
+	instance: string,
+	worldType: WorldType,
+	worldId: string,
+	displayStatus: DisplayStatus,
 ): Promise<void> {
-  return await invoke('plugin:worlds|set_world_display_status', {
-    instance,
-    worldType,
-    worldId,
-    displayStatus,
-  })
+	return await invoke('plugin:worlds|set_world_display_status', {
+		instance,
+		worldType,
+		worldId,
+		displayStatus,
+	})
 }
 
 export async function rename_world(
-  instance: string,
-  world: string,
-  newName: string,
+	instance: string,
+	world: string,
+	newName: string,
 ): Promise<void> {
-  return await invoke('plugin:worlds|rename_world', { instance, world, newName })
+	return await invoke('plugin:worlds|rename_world', { instance, world, newName })
 }
 
 export async function reset_world_icon(instance: string, world: string): Promise<void> {
-  return await invoke('plugin:worlds|reset_world_icon', { instance, world })
+	return await invoke('plugin:worlds|reset_world_icon', { instance, world })
 }
 
 export async function backup_world(instance: string, world: string): Promise<number> {
-  return await invoke('plugin:worlds|backup_world', { instance, world })
+	return await invoke('plugin:worlds|backup_world', { instance, world })
 }
 
 export async function delete_world(instance: string, world: string): Promise<void> {
-  return await invoke('plugin:worlds|delete_world', { instance, world })
+	return await invoke('plugin:worlds|delete_world', { instance, world })
 }
 
 export async function add_server_to_profile(
-  path: string,
-  name: string,
-  address: string,
-  packStatus: ServerPackStatus,
+	path: string,
+	name: string,
+	address: string,
+	packStatus: ServerPackStatus,
 ): Promise<number> {
-  return await invoke('plugin:worlds|add_server_to_profile', { path, name, address, packStatus })
+	return await invoke('plugin:worlds|add_server_to_profile', { path, name, address, packStatus })
 }
 
 export async function edit_server_in_profile(
-  path: string,
-  index: number,
-  name: string,
-  address: string,
-  packStatus: ServerPackStatus,
+	path: string,
+	index: number,
+	name: string,
+	address: string,
+	packStatus: ServerPackStatus,
 ): Promise<void> {
-  return await invoke('plugin:worlds|edit_server_in_profile', {
-    path,
-    index,
-    name,
-    address,
-    packStatus,
-  })
+	return await invoke('plugin:worlds|edit_server_in_profile', {
+		path,
+		index,
+		name,
+		address,
+		packStatus,
+	})
 }
 
 export async function remove_server_from_profile(path: string, index: number): Promise<void> {
-  return await invoke('plugin:worlds|remove_server_from_profile', { path, index })
+	return await invoke('plugin:worlds|remove_server_from_profile', { path, index })
 }
 
 export async function get_profile_protocol_version(path: string): Promise<ProtocolVersion | null> {
-  return await invoke('plugin:worlds|get_profile_protocol_version', { path })
+	return await invoke('plugin:worlds|get_profile_protocol_version', { path })
 }
 
 export async function get_server_status(
-  address: string,
-  protocolVersion: ProtocolVersion | null = null,
+	address: string,
+	protocolVersion: ProtocolVersion | null = null,
 ): Promise<ServerStatus> {
-  return await invoke('plugin:worlds|get_server_status', { address, protocolVersion })
+	return await invoke('plugin:worlds|get_server_status', { address, protocolVersion })
 }
 
 export async function start_join_singleplayer_world(path: string, world: string): Promise<unknown> {
-  return await invoke('plugin:worlds|start_join_singleplayer_world', { path, world })
+	return await invoke('plugin:worlds|start_join_singleplayer_world', { path, world })
 }
 
 export async function start_join_server(path: string, address: string): Promise<unknown> {
-  return await invoke('plugin:worlds|start_join_server', { path, address })
+	return await invoke('plugin:worlds|start_join_server', { path, address })
 }
 
 export async function showWorldInFolder(instancePath: string, worldPath: string) {
-  const fullPath = await get_full_path(instancePath)
-  return await openPath(fullPath + '/saves/' + worldPath)
+	const fullPath = await get_full_path(instancePath)
+	return await openPath(fullPath + '/saves/' + worldPath)
 }
 
 export function getWorldIdentifier(world: World) {
-  return world.type === 'singleplayer' ? world.path : world.address
+	return world.type === 'singleplayer' ? world.path : world.address
 }
 
 export function sortWorlds(worlds: World[]) {
-  worlds.sort((a, b) => {
-    if (!a.last_played) {
-      return 1
-    }
-    if (!b.last_played) {
-      return -1
-    }
-    return dayjs(b.last_played).diff(dayjs(a.last_played))
-  })
+	worlds.sort((a, b) => {
+		if (!a.last_played) {
+			return 1
+		}
+		if (!b.last_played) {
+			return -1
+		}
+		return dayjs(b.last_played).diff(dayjs(a.last_played))
+	})
 }
 
 export function isSingleplayerWorld(world: World): world is SingleplayerWorld {
-  return world.type === 'singleplayer'
+	return world.type === 'singleplayer'
 }
 
 export function isServerWorld(world: World): world is ServerWorld {
-  return world.type === 'server'
+	return world.type === 'server'
 }
 
 export async function refreshServerData(
-  serverData: ServerData,
-  protocolVersion: ProtocolVersion | null,
-  address: string,
+	serverData: ServerData,
+	protocolVersion: ProtocolVersion | null,
+	address: string,
 ): Promise<void> {
-  const refreshTime = Date.now()
-  serverData.refreshing = true
-  await get_server_status(address, protocolVersion)
-    .then((status) => {
-      if (serverData.lastSuccessfulRefresh && serverData.lastSuccessfulRefresh > refreshTime) {
-        // Don't update if there was a more recent successful refresh
-        return
-      }
-      serverData.lastSuccessfulRefresh = Date.now()
-      serverData.status = status
-      if (status.description) {
-        serverData.rawMotd = status.description
-        serverData.renderedMotd = autoToHTML(status.description)
-      }
-    })
-    .finally(() => {
-      serverData.refreshing = false
-    })
-    .catch((err) => {
-      console.error(`Refreshing addr ${address}`, protocolVersion, err)
-      if (!protocolVersion?.legacy) {
-        refreshServerData(serverData, { version: 74, legacy: true }, address)
-      }
-    })
+	const refreshTime = Date.now()
+	serverData.refreshing = true
+	await get_server_status(address, protocolVersion)
+		.then((status) => {
+			if (serverData.lastSuccessfulRefresh && serverData.lastSuccessfulRefresh > refreshTime) {
+				// Don't update if there was a more recent successful refresh
+				return
+			}
+			serverData.lastSuccessfulRefresh = Date.now()
+			serverData.status = status
+			if (status.description) {
+				serverData.rawMotd = status.description
+				serverData.renderedMotd = autoToHTML(status.description)
+			}
+		})
+		.finally(() => {
+			serverData.refreshing = false
+		})
+		.catch((err) => {
+			console.error(`Refreshing addr ${address}`, protocolVersion, err)
+			if (!protocolVersion?.legacy) {
+				refreshServerData(serverData, { version: 74, legacy: true }, address)
+			}
+		})
 }
 
 export function refreshServers(
-  worlds: World[],
-  serverData: Record<string, ServerData>,
-  protocolVersion: ProtocolVersion | null,
+	worlds: World[],
+	serverData: Record<string, ServerData>,
+	protocolVersion: ProtocolVersion | null,
 ) {
-  const servers = worlds.filter(isServerWorld)
-  servers.forEach((server) => {
-    if (!serverData[server.address]) {
-      serverData[server.address] = {
-        refreshing: true,
-      }
-    } else {
-      serverData[server.address].refreshing = true
-    }
-  })
+	const servers = worlds.filter(isServerWorld)
+	servers.forEach((server) => {
+		if (!serverData[server.address]) {
+			serverData[server.address] = {
+				refreshing: true,
+			}
+		} else {
+			serverData[server.address].refreshing = true
+		}
+	})
 
-  // noinspection ES6MissingAwait - handled with .then by refreshServerData already
-  Object.keys(serverData).forEach((address) =>
-    refreshServerData(serverData[address], protocolVersion, address),
-  )
+	// noinspection ES6MissingAwait - handled with .then by refreshServerData already
+	Object.keys(serverData).forEach((address) =>
+		refreshServerData(serverData[address], protocolVersion, address),
+	)
 }
 
 export async function refreshWorld(worlds: World[], instancePath: string, worldPath: string) {
-  const index = worlds.findIndex((w) => w.type === 'singleplayer' && w.path === worldPath)
-  const newWorld = await get_singleplayer_world(instancePath, worldPath)
-  if (index !== -1) {
-    worlds[index] = newWorld
-  } else {
-    console.info(`Adding new world at path: ${worldPath}.`)
-    worlds.push(newWorld)
-  }
-  sortWorlds(worlds)
+	const index = worlds.findIndex((w) => w.type === 'singleplayer' && w.path === worldPath)
+	const newWorld = await get_singleplayer_world(instancePath, worldPath)
+	if (index !== -1) {
+		worlds[index] = newWorld
+	} else {
+		console.info(`Adding new world at path: ${worldPath}.`)
+		worlds.push(newWorld)
+	}
+	sortWorlds(worlds)
 }
 
 export async function handleDefaultProfileUpdateEvent(
-  worlds: World[],
-  instancePath: string,
-  e: ProfileEvent,
+	worlds: World[],
+	instancePath: string,
+	e: ProfileEvent,
 ) {
-  if (e.event === 'world_updated') {
-    await refreshWorld(worlds, instancePath, e.world)
-  }
+	if (e.event === 'world_updated') {
+		await refreshWorld(worlds, instancePath, e.world)
+	}
 
-  if (e.event === 'server_joined') {
-    const world = worlds.find(
-      (w) =>
-        w.type === 'server' &&
-        (w.address === `${e.host}:${e.port}` || (e.port == 25565 && w.address == e.host)),
-    )
-    if (world) {
-      world.last_played = e.timestamp
-      sortWorlds(worlds)
-    } else {
-      console.error(`Could not find world for server join event: ${e.host}:${e.port}`)
-    }
-  }
+	if (e.event === 'server_joined') {
+		const world = worlds.find(
+			(w) =>
+				w.type === 'server' &&
+				(w.address === `${e.host}:${e.port}` || (e.port == 25565 && w.address == e.host)),
+		)
+		if (world) {
+			world.last_played = e.timestamp
+			sortWorlds(worlds)
+		} else {
+			console.error(`Could not find world for server join event: ${e.host}:${e.port}`)
+		}
+	}
 }
 
 export async function refreshWorlds(instancePath: string): Promise<World[]> {
-  const worlds = await get_profile_worlds(instancePath).catch((err) => {
-    console.error(`Error refreshing worlds for instance: ${instancePath}`, err)
-  })
-  if (worlds) {
-    sortWorlds(worlds)
-  }
+	const worlds = await get_profile_worlds(instancePath).catch((err) => {
+		console.error(`Error refreshing worlds for instance: ${instancePath}`, err)
+	})
+	if (worlds) {
+		sortWorlds(worlds)
+	}
 
-  return worlds ?? []
+	return worlds ?? []
 }
 
 export function hasServerQuickPlaySupport(gameVersions: GameVersion[], currentVersion: string) {
-  if (!gameVersions.length) {
-    return true
-  }
+	if (!gameVersions.length) {
+		return true
+	}
 
-  const versionIndex = gameVersions.findIndex((v) => v.version === currentVersion)
-  const targetIndex = gameVersions.findIndex((v) => v.version === 'a1.0.5_01')
+	const versionIndex = gameVersions.findIndex((v) => v.version === currentVersion)
+	const targetIndex = gameVersions.findIndex((v) => v.version === 'a1.0.5_01')
 
-  return versionIndex === -1 || targetIndex === -1 || versionIndex <= targetIndex
+	return versionIndex === -1 || targetIndex === -1 || versionIndex <= targetIndex
 }
 
 export function hasWorldQuickPlaySupport(gameVersions: GameVersion[], currentVersion: string) {
-  if (!gameVersions.length) {
-    return false
-  }
+	if (!gameVersions.length) {
+		return false
+	}
 
-  const versionIndex = gameVersions.findIndex((v) => v.version === currentVersion)
-  const targetIndex = gameVersions.findIndex((v) => v.version === '23w14a')
+	const versionIndex = gameVersions.findIndex((v) => v.version === currentVersion)
+	const targetIndex = gameVersions.findIndex((v) => v.version === '23w14a')
 
-  return versionIndex !== -1 && targetIndex !== -1 && versionIndex <= targetIndex
+	return versionIndex !== -1 && targetIndex !== -1 && versionIndex <= targetIndex
 }
 
 export type ProfileEvent = { profile_path_id: string } & (
-  | {
-      event: 'servers_updated'
-    }
-  | {
-      event: 'world_updated'
-      world: string
-    }
-  | {
-      event: 'server_joined'
-      host: string
-      port: number
-      timestamp: string
-    }
+	| {
+			event: 'servers_updated'
+	  }
+	| {
+			event: 'world_updated'
+			world: string
+	  }
+	| {
+			event: 'server_joined'
+			host: string
+			port: number
+			timestamp: string
+	  }
 )