add: icon resolver

add: config "no_track" file list option
add: rainbeam-shared -> tetratto-shared
add: l10n

crates/l10n/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tetratto-l10n"
+version = "0.1.0"
+edition = "2024"
+authors.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+pathbufd = "0.1.4"
+serde = { version = "1.0.219", features = ["derive"] }
+toml = "0.8.20"

crates/l10n/src/lib.rs

@@ -0,0 +1,95 @@
+use pathbufd::PathBufD;
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::HashMap,
+    fs::{read_dir, read_to_string},
+    sync::{LazyLock, RwLock},
+};
+
+pub static ENGLISH_US: LazyLock<RwLock<LangFile>> = LazyLock::new(RwLock::default);
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LangFile {
+    pub name: String,
+    pub version: String,
+    pub data: HashMap<String, String>,
+}
+
+impl Default for LangFile {
+    fn default() -> Self {
+        Self {
+            name: "com.tettrato.langs.testing:aa-BB".to_string(),
+            version: "0.0.0".to_string(),
+            data: HashMap::new(),
+        }
+    }
+}
+
+impl LangFile {
+    /// Check if a value exists in `data` (and isn't empty)
+    pub fn exists(&self, key: &str) -> bool {
+        if let Some(value) = self.data.get(key) {
+            if value.is_empty() {
+                return false;
+            }
+
+            return true;
+        }
+
+        false
+    }
+
+    /// Get a value from `data`, returns an empty string if it doesn't exist
+    pub fn get(&self, key: &str) -> String {
+        if !self.exists(key) {
+            if (self.name == "com.tettrato.langs.testing:aa-BB")
+                | (self.name == "com.tettrato.langs.testing:en-US")
+            {
+                return key.to_string();
+            } else {
+                // load english instead
+                let reader = ENGLISH_US
+                    .read()
+                    .expect("failed to pull reader for ENGLISH_US");
+                return reader.get(key);
+            }
+        }
+
+        self.data.get(key).unwrap().to_owned()
+    }
+}
+
+/// Read the `langs` directory and return a [`Hashmap`] containing all files
+pub fn read_langs() -> HashMap<String, LangFile> {
+    let mut out = HashMap::new();
+
+    let langs_dir = PathBufD::current().join("langs");
+    if let Ok(files) = read_dir(langs_dir) {
+        for file in files.into_iter() {
+            if file.is_err() {
+                continue;
+            }
+
+            let de: LangFile = match toml::from_str(&match read_to_string(file.unwrap().path()) {
+                Ok(f) => f,
+                Err(_) => continue,
+            }) {
+                Ok(de) => de,
+                Err(_) => continue,
+            };
+
+            if de.name.ends_with("en-US") {
+                let mut writer = ENGLISH_US
+                    .write()
+                    .expect("failed to pull writer for ENGLISH_US");
+                *writer = de.clone();
+                drop(writer);
+            }
+
+            out.insert(de.name.clone(), de);
+        }
+    }
+
+    // return
+    out
+}