Implement ZonedDateTime::offset and `ZonedDateTime::offset_nanoseco…

…nds` (#185)

Per title, this implements the accessor methods for returning
`ZonedDateTime`'s offset and offsetNanoseconds values.

src/builtins/compiled/zoneddatetime.rs

@@ -125,6 +125,22 @@ impl ZonedDateTime {
 
         self.millisecond_with_provider(&*provider)
     }
+
+    /// Returns the current offset as a formatted offset string.
+    pub fn offset(&self) -> TemporalResult<String> {
+        let provider = TZ_PROVIDER
+            .lock()
+            .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
+        self.offset_with_provider(&*provider)
+    }
+
+    /// Returns the current offset in nanoseconds
+    pub fn offset_nanoseconds(&self) -> TemporalResult<i64> {
+        let provider = TZ_PROVIDER
+            .lock()
+            .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
+        self.offset_nanoseconds_with_provider(&*provider)
+    }
 }
 
 // ==== Experimental TZ_PROVIDER calendar method implementations ====

src/builtins/core/zoneddatetime.rs

@@ -19,7 +19,7 @@ use crate::{
         ResolvedRoundingOptions, RoundingIncrement, TemporalRoundingMode, TemporalUnit,
         ToStringRoundingOptions,
     },
-    parsers::{self, IxdtfStringBuilder},
+    parsers::{self, FormattableOffset, FormattableTime, IxdtfStringBuilder, Precision},
     partial::{PartialDate, PartialTime},
     provider::TimeZoneProvider,
     rounding::{IncrementRounder, Round},
@@ -542,6 +542,54 @@ impl ZonedDateTime {
         let iso = self.tz.get_iso_datetime_for(&self.instant, provider)?;
         Ok(iso.time.nanosecond)
     }
+
+    pub fn offset_with_provider(&self, provider: &impl TimeZoneProvider) -> TemporalResult<String> {
+        let offset = self
+            .tz
+            .get_offset_nanos_for(self.epoch_nanoseconds(), provider)?;
+        Ok(nanoseconds_to_formattable_offset(offset).to_string())
+    }
+
+    pub fn offset_nanoseconds_with_provider(
+        &self,
+        provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<i64> {
+        let offset = self
+            .tz
+            .get_offset_nanos_for(self.epoch_nanoseconds(), provider)?;
+        Ok(offset as i64)
+    }
+}
+
+pub(crate) fn nanoseconds_to_formattable_offset(nanoseconds: i128) -> FormattableOffset {
+    let sign = if nanoseconds >= 0 {
+        Sign::Positive
+    } else {
+        Sign::Negative
+    };
+    let nanos = nanoseconds.unsigned_abs();
+    let hour = (nanos / 3_600_000_000_000) as u8;
+    let minute = ((nanos / 60_000_000_000) % 60) as u8;
+    let second = ((nanos / 1_000_000_000) % 60) as u8;
+    let nanosecond = (nanos % 1_000_000_000) as u32;
+
+    let precision = if second == 0 && nanosecond == 0 {
+        Precision::Minute
+    } else {
+        Precision::Auto
+    };
+
+    FormattableOffset {
+        sign,
+        time: FormattableTime {
+            hour,
+            minute,
+            second,
+            nanosecond,
+            precision,
+            include_sep: true,
+        },
+    }
 }
 
 // ==== Core calendar method implementations ====