ferric-alpha-render 0.1.0

Native rendering for Ferric Alpha alphalens-style tear-sheet reports
Documentation
use serde::{Deserialize, Serialize};

use crate::{RenderError, RenderResult};

pub const MIN_WIDTH: u32 = 720;
pub const MAX_WIDTH: u32 = 4096;
pub const MAX_PHYSICAL_SIDE: u32 = 8_192;
pub const MAX_LOGICAL_HEIGHT: u32 = 32_768;
pub const MAX_PANELS: usize = 256;
pub const MAX_PNG_PIXELS: u64 = 16_000_000;
pub const MAX_PNG_BYTES: usize = 64 * 1024 * 1024;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RenderTheme {
    Light,
    Dark,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RenderOptions {
    pub width: u32,
    pub scale: f64,
    pub theme: RenderTheme,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PhysicalSize {
    pub width: u32,
    pub height: u32,
}

impl Default for RenderOptions {
    fn default() -> Self {
        Self {
            width: 1200,
            scale: 1.0,
            theme: RenderTheme::Light,
        }
    }
}

impl RenderOptions {
    pub fn validate(&self, logical_height: u32) -> RenderResult<PhysicalSize> {
        if !(MIN_WIDTH..=MAX_WIDTH).contains(&self.width) {
            return Err(RenderError::InvalidOption {
                option: "width",
                reason: "must be in 720..=4096",
            });
        }
        if !self.scale.is_finite() || !(0.5..=4.0).contains(&self.scale) {
            return Err(RenderError::InvalidOption {
                option: "scale",
                reason: "must be finite and in 0.5..=4.0",
            });
        }
        if logical_height > MAX_LOGICAL_HEIGHT {
            return Err(RenderError::LayoutOverflow);
        }

        let physical_width = checked_physical_dimension(self.width, self.scale)?;
        let physical_height = checked_physical_dimension(logical_height, self.scale)?;
        if physical_width > MAX_PHYSICAL_SIDE || physical_height > MAX_PHYSICAL_SIDE {
            return Err(RenderError::LayoutOverflow);
        }

        let pixels = u64::from(physical_width)
            .checked_mul(u64::from(physical_height))
            .ok_or(RenderError::LayoutOverflow)?;
        if pixels > MAX_PNG_PIXELS {
            return Err(RenderError::LayoutOverflow);
        }

        Ok(PhysicalSize {
            width: physical_width,
            height: physical_height,
        })
    }
}

fn checked_physical_dimension(logical: u32, scale: f64) -> RenderResult<u32> {
    let scaled = f64::from(logical) * scale;
    if !scaled.is_finite() || scaled < 0.0 || scaled > f64::from(u32::MAX) {
        return Err(RenderError::LayoutOverflow);
    }
    Ok(scaled.round() as u32)
}