formatjs_temporal 1.0.0

Temporal calendar, date, time and timezone primitives
use crate::{Error, MAX_EPOCH_NANOSECONDS, NANOSECONDS_PER_DAY};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct IsoDateTime {
    pub year: i32,
    pub month: u8,
    pub day: u8,
    pub hour: u8,
    pub minute: u8,
    pub second: u8,
    pub nanosecond: u32,
}
impl IsoDateTime {
    pub fn to_epoch_nanoseconds(self) -> Result<i128, Error> {
        let leap = self.year % 4 == 0 && (self.year % 100 != 0 || self.year % 400 == 0);
        let days = match self.month {
            2 => {
                if leap {
                    29
                } else {
                    28
                }
            }
            4 | 6 | 9 | 11 => 30,
            1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
            _ => return Err(Error::InvalidDateTime),
        };
        if self.day == 0
            || self.day > days
            || self.hour > 23
            || self.minute > 59
            || self.second > 59
            || self.nanosecond >= 1_000_000_000
        {
            return Err(Error::InvalidDateTime);
        }
        let epoch_day = i128::from(epoch_day_from_iso(self.year, self.month, self.day));
        let value = epoch_day * NANOSECONDS_PER_DAY
            + (i128::from(self.hour) * 3600
                + i128::from(self.minute) * 60
                + i128::from(self.second))
                * 1_000_000_000
            + i128::from(self.nanosecond);
        check_local(value)?;
        Ok(value)
    }
    pub fn from_epoch_nanoseconds(value: i128) -> Result<Self, Error> {
        check_local(value)?;
        Ok(iso_from_epoch_nanoseconds_raw(value))
    }
}

// Calendar differences may round across public date limits.
pub(crate) fn iso_from_epoch_nanoseconds_raw(value: i128) -> IsoDateTime {
    let days = value.div_euclid(NANOSECONDS_PER_DAY);
    let time = value.rem_euclid(NANOSECONDS_PER_DAY);
    let (year, month, day) = crate::calendar::iso_fields(days as i64);
    IsoDateTime {
        year,
        month,
        day,
        hour: (time / 3_600_000_000_000) as u8,
        minute: (time / 60_000_000_000 % 60) as u8,
        second: (time / 1_000_000_000 % 60) as u8,
        nanosecond: (time % 1_000_000_000) as u32,
    }
}

pub(crate) fn epoch_day_from_iso(year: i32, month: u8, day: u8) -> i64 {
    crate::calendar::iso_day(year, month, day)
}

fn check_local(value: i128) -> Result<(), Error> {
    let bound = MAX_EPOCH_NANOSECONDS + NANOSECONDS_PER_DAY;
    if value <= -bound || value >= bound {
        return Err(Error::OutOfRange);
    }
    Ok(())
}