effindom-native-packaging 0.1.5

SDK-neutral native packaging primitives for EffinDOM applications
Documentation
use crate::{Error, Result};
use serde::Deserialize;
use std::fs;
use std::path::{Path, PathBuf};

pub const FUI_CONFIG_SCHEMA_VERSION: u32 = 1;
pub const FUI_CONFIG_FILE: &str = "fui-config.json";
pub const FUI_CONFIG_SCHEMA: &str = include_str!("../fui-config.schema.json");

#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct FuiConfig {
    #[serde(rename = "$schema")]
    pub schema: Option<String>,
    pub version: u32,
    pub application: Option<FuiApplicationConfig>,
    pub web: Option<FuiWebConfig>,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct FuiApplicationConfig {
    pub page_zoom: Option<FuiPageZoomMode>,
}

#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum FuiPageZoomMode {
    Disabled,
    Enabled,
}

#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct FuiWebConfig {
    pub loading: Option<FuiWebLoadingConfig>,
    pub dev_tools: Option<FuiWebDevToolsConfig>,
}

#[derive(Clone, Debug, Deserialize, PartialEq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct FuiWebLoadingConfig {
    pub delay_ms: Option<f64>,
    pub minimum_visible_ms: Option<f64>,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct FuiWebDevToolsConfig {
    pub dom_mirror: Option<FuiDevToolsDomMirrorMode>,
}

#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum FuiDevToolsDomMirrorMode {
    Disabled,
    Enabled,
    OnRequested,
}

pub fn decode_fui_config(bytes: &[u8]) -> Result<FuiConfig> {
    let config: FuiConfig = serde_json::from_slice(bytes).map_err(Error::ParseFuiConfig)?;
    validate_fui_config(config)
}

pub fn load_fui_config(path: impl AsRef<Path>) -> Result<FuiConfig> {
    let path = path.as_ref();
    let bytes = fs::read(path).map_err(|source| Error::ReadFile {
        path: PathBuf::from(path),
        source,
    })?;
    decode_fui_config(&bytes)
}

fn validate_fui_config(config: FuiConfig) -> Result<FuiConfig> {
    if config.version != FUI_CONFIG_SCHEMA_VERSION {
        return Err(Error::InvalidFuiConfig(format!(
            "version must be {FUI_CONFIG_SCHEMA_VERSION}, got {}",
            config.version
        )));
    }
    if let Some(loading) = config.web.as_ref().and_then(|web| web.loading.as_ref()) {
        validate_duration(loading.delay_ms, "web.loading.delayMs")?;
        validate_duration(loading.minimum_visible_ms, "web.loading.minimumVisibleMs")?;
    }
    Ok(config)
}

fn validate_duration(value: Option<f64>, field: &'static str) -> Result<()> {
    if value.is_some_and(|value| !value.is_finite() || value < 0.0) {
        return Err(Error::InvalidFuiConfig(format!(
            "{field} must be a finite non-negative number"
        )));
    }
    Ok(())
}