functora-egui 0.2.0

shadcn/ui-inspired widget library for egui - buttons, inputs, selects, dialogs, and 70+ more components with light/dark theming
Documentation
pub use functora_core::storage::{
    find_or_init_key, get_json_value, read_json_object, set_json_value, update_key,
    write_json_object,
};

use crate::error::Error;
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::path::PathBuf;

#[derive(Debug, Clone, Copy)]
pub struct Storage {
    app: &'static str,
}

impl Storage {
    #[must_use]
    pub fn new(app: &'static str) -> Self {
        Self { app }
    }

    #[must_use]
    pub fn app(&self) -> &'static str {
        self.app
    }

    #[cfg(target_os = "android")]
    pub fn files_dir(&self) -> Result<PathBuf, Error> {
        crate::platform::android::files_dir()
    }

    #[cfg(all(not(target_os = "android"), target_arch = "wasm32"))]
    pub fn files_dir(&self) -> Result<PathBuf, Error> {
        Err(Error::JS("files_dir not available on wasm".into()))
    }

    #[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
    pub fn files_dir(&self) -> Result<PathBuf, Error> {
        app_data_dir(self.app)
    }

    #[must_use]
    pub fn load<T: DeserializeOwned>(&self, key: &str) -> Option<T> {
        #[cfg(target_arch = "wasm32")]
        {
            web_load(key)
        }
        #[cfg(all(not(target_arch = "wasm32"), target_os = "android"))]
        {
            android_load(key)
        }
        #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
        {
            desktop_load(self.app, key)
        }
    }

    pub fn persist<T: Serialize>(&self, key: &str, value: &T) {
        #[cfg(target_arch = "wasm32")]
        {
            web_persist(key, value);
        }
        #[cfg(all(not(target_arch = "wasm32"), target_os = "android"))]
        {
            android_persist(key, value);
        }
        #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
        {
            desktop_persist(self.app, key, value);
        }
    }

    pub fn persistent<T>(&self, key: &'static str, default: T) -> Persistent<T>
    where
        T: Serialize + DeserializeOwned + Clone,
    {
        let value = self.load(key).unwrap_or(default);
        Persistent {
            storage: *self,
            key,
            value,
        }
    }
}

#[cfg(target_os = "android")]
pub fn files_dir_for(_app: &str) -> Result<PathBuf, Error> {
    crate::platform::android::files_dir()
}

#[cfg(all(not(target_os = "android"), target_arch = "wasm32"))]
pub fn files_dir_for(_app: &str) -> Result<PathBuf, Error> {
    Err(Error::JS("files_dir not available on wasm".into()))
}

#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
pub fn files_dir_for(app: &str) -> Result<PathBuf, Error> {
    app_data_dir(app)
}

#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
pub fn app_data_dir(app: &str) -> Result<PathBuf, Error> {
    directories::ProjectDirs::from("io", "functora", app)
        .map(|d| d.data_dir().to_path_buf())
        .ok_or_else(|| Error::JS("No data dir".into()))
}

#[cfg(all(not(target_os = "android"), not(target_arch = "wasm32")))]
pub fn storage_file_for(app: &str) -> Result<PathBuf, Error> {
    let dir = app_data_dir(app)?;
    std::fs::create_dir_all(&dir)?;
    Ok(dir.join("storage.json"))
}

#[cfg(target_arch = "wasm32")]
fn web_load<T: DeserializeOwned>(key: &str) -> Option<T> {
    let raw = crate::platform::web::storage_get(key)?;
    serde_json::from_str(&raw)
        .inspect_err(|e| tracing::warn!("Storage parse error for key {key}: {e}"))
        .ok()
}

#[cfg(target_arch = "wasm32")]
fn web_persist<T: Serialize>(key: &str, value: &T) {
    if let Ok(json) = serde_json::to_string(value)
        && let Err(e) = crate::platform::web::storage_set(key, &json)
    {
        tracing::warn!("Storage persist error: {e}");
    }
}

#[cfg(all(not(target_arch = "wasm32"), target_os = "android"))]
fn android_load<T: DeserializeOwned>(key: &str) -> Option<T> {
    crate::platform::android::files_dir().ok().and_then(|p| {
        let json = read_json_object(p.join("storage.json")).ok()?;
        let value = json.get(key)?;
        serde_json::from_value(value.clone())
            .inspect_err(|e| tracing::warn!("Storage parse error for key {key}: {e}"))
            .ok()
    })
}

#[cfg(all(not(target_arch = "wasm32"), target_os = "android"))]
fn android_persist<T: Serialize>(key: &str, value: &T) {
    if let Ok(path) = crate::platform::android::files_dir().map(|p| p.join("storage.json"))
        && let Err(e) = update_key(&path, key, value)
    {
        tracing::error!("Storage persist error: {e}");
    }
}

#[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
fn desktop_load<T: DeserializeOwned>(app: &str, key: &str) -> Option<T> {
    storage_file_for(app).ok().and_then(|p| {
        let json = read_json_object(&p).ok()?;
        let value = json.get(key)?;
        serde_json::from_value(value.clone())
            .inspect_err(|e| tracing::warn!("Storage parse error for key {key}: {e}"))
            .ok()
    })
}

#[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
fn desktop_persist<T: Serialize>(app: &str, key: &str, value: &T) {
    if let Ok(path) = storage_file_for(app)
        && let Err(e) = update_key(&path, key, value)
    {
        tracing::error!("Storage persist error: {e}");
    }
}

#[derive(Debug)]
pub struct Persistent<T> {
    storage: Storage,
    key: &'static str,
    value: T,
}

impl<T> Persistent<T>
where
    T: Serialize + DeserializeOwned + Clone,
{
    #[must_use]
    pub fn get(&self) -> &T {
        &self.value
    }

    pub fn set(&mut self, value: T) {
        self.value = value;
        self.storage.persist(self.key, &self.value);
    }

    pub fn update(&mut self, f: impl FnOnce(&mut T)) {
        f(&mut self.value);
        self.storage.persist(self.key, &self.value);
    }

    #[must_use]
    pub fn into_inner(self) -> T {
        self.value
    }
}

#[cfg(all(
    any(target_arch = "wasm32", target_os = "android"),
    any(feature = "web", feature = "android")
))]
#[must_use]
pub fn load_from_eframe<T: DeserializeOwned>(
    storage: Option<&dyn eframe::Storage>,
    app: &'static str,
    key: &str,
) -> Option<T> {
    storage
        .and_then(|s| s.get_string(key))
        .and_then(|raw| {
            serde_json::from_str(&raw)
                .inspect_err(|e| tracing::warn!("Storage parse error for key {key}: {e}"))
                .ok()
        })
        .or_else(|| Storage::new(app).load(key))
}

#[cfg(all(
    any(target_arch = "wasm32", target_os = "android"),
    any(feature = "web", feature = "android")
))]
pub fn save_to_eframe<T: Serialize>(
    storage: &mut dyn eframe::Storage,
    app: &'static str,
    key: &str,
    value: &T,
) {
    if let Ok(json) = serde_json::to_string(value) {
        storage.set_string(key, json.clone());
        Storage::new(app).persist(key, value);
    }
}