path: root/src/files.rs

use base64::{prelude::BASE64_STANDARD, Engine};
use filamento::files::{opfs::OPFSError, FileStore, FilesMem, FilesOPFS};

#[derive(Clone, Debug)]
pub enum Files {
    Mem(FilesMem),
    Opfs(FilesOPFS),
}

impl FileStore for Files {
    type Err = OPFSError;

    async fn is_stored(&self, name: &str) -> Result<bool, Self::Err> {
        match self {
            Files::Mem(files_mem) => Ok(files_mem.is_stored(name).await.unwrap()),
            Files::Opfs(files_opfs) => Ok(files_opfs.is_stored(name).await?),
        }
    }

    async fn store(&self, name: &str, data: &[u8]) -> Result<(), Self::Err> {
        match self {
            Files::Mem(files_mem) => Ok(files_mem.store(name, data).await.unwrap()),
            Files::Opfs(files_opfs) => Ok(files_opfs.store(name, data).await?),
        }
    }

    async fn delete(&self, name: &str) -> Result<(), Self::Err> {
        match self {
            Files::Mem(files_mem) => Ok(files_mem.delete(name).await.unwrap()),
            Files::Opfs(files_opfs) => Ok(files_opfs.delete(name).await?),
        }
    }
}

impl Files {
    pub async fn get_src(&self, file_name: &str) -> Option<String> {
        match self {
            Files::Mem(files_mem) => {
                if let Some(data) = files_mem.get_file(file_name).await {
                    let data = BASE64_STANDARD.encode(data);
                    Some(format!("data:image/jpg;base64, {}", data))
                } else {
                    None
                }
            }
            Files::Opfs(files_opfs) => files_opfs.get_src(file_name).await.ok(),
        }
    }
}