formatjs_temporal 1.0.0

Temporal calendar, date, time and timezone primitives
use crate::rounding::round_instant;
use crate::{Error, Instant, IsoDateTime, NANOSECONDS_PER_DAY, RoundingMode};
use core::fmt;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Precision {
    Auto,
    Minute,
    Digits(u8),
}

pub struct FormattedInstant {
    fields: IsoDateTime,
    precision: Precision,
    offset: Option<i64>,
}
impl Instant {
    pub fn format(
        self,
        precision: Precision,
        mode: RoundingMode,
        offset_nanoseconds: Option<i64>,
    ) -> Result<FormattedInstant, Error> {
        let quantum = match precision {
            Precision::Auto => 1,
            Precision::Minute => 60_000_000_000,
            Precision::Digits(digits) if digits <= 9 => 10i128.pow(u32::from(9 - digits)),
            _ => return Err(Error::InvalidRoundingOptions),
        };
        let offset = i128::from(offset_nanoseconds.unwrap_or(0));
        if !(-NANOSECONDS_PER_DAY + 1..NANOSECONDS_PER_DAY).contains(&offset) {
            return Err(Error::InvalidDateTime);
        }
        let rounded = round_instant(self.epoch_nanoseconds(), quantum, mode);
        Ok(FormattedInstant {
            fields: IsoDateTime::from_epoch_nanoseconds(rounded + offset)?,
            precision,
            offset: offset_nanoseconds,
        })
    }
}
impl fmt::Display for Instant {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.format(Precision::Auto, RoundingMode::Trunc, None)
            .map_err(|_| fmt::Error)?
            .fmt(f)
    }
}
impl fmt::Display for FormattedInstant {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let fields = self.fields;
        if (0..=9999).contains(&fields.year) {
            write!(f, "{:04}", fields.year)?;
        } else {
            write!(f, "{:+07}", fields.year)?;
        }
        write!(
            f,
            "-{:02}-{:02}T{:02}:{:02}",
            fields.month, fields.day, fields.hour, fields.minute
        )?;
        if self.precision != Precision::Minute {
            write!(f, ":{:02}", fields.second)?;
            let (value, digits) = match self.precision {
                Precision::Auto => {
                    let (mut value, mut digits) = (fields.nanosecond, 9usize);
                    while digits > 0 && value % 10 == 0 {
                        value /= 10;
                        digits -= 1;
                    }
                    (value, digits)
                }
                Precision::Digits(digits) => (
                    fields.nanosecond / 10u32.pow(u32::from(9 - digits)),
                    usize::from(digits),
                ),
                Precision::Minute => unreachable!(),
            };
            if digits > 0 {
                write!(f, ".{value:0digits$}")?;
            }
        }
        match self.offset {
            None => f.write_str("Z"),
            Some(offset) => write_offset(f, i128::from(offset)),
        }
    }
}

pub(crate) fn offset_minutes(offset: i128) -> i128 {
    offset.signum() * ((offset.abs() + 30_000_000_000) / 60_000_000_000)
}
pub(crate) fn write_offset(f: &mut fmt::Formatter<'_>, offset: i128) -> fmt::Result {
    let minutes = offset_minutes(offset);
    write!(
        f,
        "{}{:02}:{:02}",
        if minutes < 0 { '-' } else { '+' },
        minutes.abs() / 60,
        minutes.abs() % 60
    )
}