Add GetNamedTimeZoneTransition method to TimeZoneProvider trait (#203)

This PR adds the stubbed out method to the `TimeZoneProvider` trait, and
implements the baseline logic for
`ZonedDateTime::get_time_zone_transition`.

This PR also adds the `TransitionDirection` option that lives in the
provider module.

Author: nekevss

src/builtins/compiled/zoneddatetime.rs

@@ -1,4 +1,5 @@
 use crate::builtins::TZ_PROVIDER;
+use crate::provider::TransitionDirection;
 use crate::ZonedDateTime;
 use crate::{
     options::{
@@ -269,7 +270,10 @@ impl ZonedDateTime {
     }
 
     // TODO: Update direction to correct option
-    pub fn get_time_zone_transition(&self, direction: bool) -> TemporalResult<Self> {
+    pub fn get_time_zone_transition(
+        &self,
+        direction: TransitionDirection,
+    ) -> TemporalResult<Option<Self>> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;

src/builtins/core/zoneddatetime.rs

@@ -23,7 +23,7 @@ use crate::{
         self, parse_offset, FormattableOffset, FormattableTime, IxdtfStringBuilder, Precision,
     },
     partial::{PartialDate, PartialTime},
-    provider::TimeZoneProvider,
+    provider::{TimeZoneProvider, TransitionDirection},
     rounding::{IncrementRounder, Round},
     temporal_assert,
     time::EpochNanoseconds,
@@ -480,13 +480,31 @@ impl ZonedDateTime {
 // ==== HoursInDay accessor method implementation ====
 
 impl ZonedDateTime {
-    // TODO: Add direction parameter to either zoneddatetime.rs or option.rs
+    // TODO: implement and stabalize
     pub fn get_time_zone_transition_with_provider(
         &self,
-        _direction: bool,
-        _provider: &impl TimeZoneProvider,
-    ) -> TemporalResult<Self> {
-        Err(TemporalError::general("Not yet implemented"))
+        direction: TransitionDirection,
+        provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<Option<Self>> {
+        // 8. If IsOffsetTimeZoneIdentifier(timeZone) is true, return null.
+        let TimeZone::IanaIdentifier(identifier) = &self.tz else {
+            return Ok(None);
+        };
+        // 9. If direction is next, then
+        // a. Let transition be GetNamedTimeZoneNextTransition(timeZone, zonedDateTime.[[EpochNanoseconds]]).
+        // 10. Else,
+        // a. Assert: direction is previous.
+        // b. Let transition be GetNamedTimeZonePreviousTransition(timeZone, zonedDateTime.[[EpochNanoseconds]]).
+        let transition =
+            provider.get_named_tz_transition(identifier, self.epoch_nanoseconds(), direction)?;
+
+        // 11. If transition is null, return null.
+        // 12. Return ! CreateTemporalZonedDateTime(transition, timeZone, zonedDateTime.[[Calendar]]).
+        let result = transition
+            .map(|t| ZonedDateTime::try_new(t.0, self.calendar().clone(), self.tz.clone()))
+            .transpose()?;
+
+        Ok(result)
     }
 
     pub fn hours_in_day_with_provider(

src/provider.rs

@@ -1,5 +1,7 @@
 //! The `TimeZoneProvider` trait.
 
+use core::str::FromStr;
+
 use crate::{iso::IsoDateTime, time::EpochNanoseconds, TemporalResult};
 use alloc::vec::Vec;
 
@@ -12,6 +14,42 @@ pub struct TimeZoneOffset {
     pub offset: i64,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum TransitionDirection {
+    Next,
+    Previous,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ParseDirectionError;
+
+impl core::fmt::Display for ParseDirectionError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("provided string was not a valid direction.")
+    }
+}
+
+impl FromStr for TransitionDirection {
+    type Err = ParseDirectionError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "next" => Ok(Self::Next),
+            "previous" => Ok(Self::Previous),
+            _ => Err(ParseDirectionError),
+        }
+    }
+}
+
+impl core::fmt::Display for TransitionDirection {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Next => "next",
+            Self::Previous => "previous",
+        }
+        .fmt(f)
+    }
+}
+
 // NOTE: It may be a good idea to eventually move this into it's
 // own individual crate rather than having it tied directly into `temporal_rs`
 /// The `TimeZoneProvider` trait provides methods required for a provider
@@ -28,8 +66,16 @@ pub trait TimeZoneProvider {
     fn get_named_tz_offset_nanoseconds(
         &self,
         identifier: &str,
-        utc_epoch: i128,
+        epoch_nanoseconds: i128,
     ) -> TemporalResult<TimeZoneOffset>;
+
+    // TODO: implement and stabalize
+    fn get_named_tz_transition(
+        &self,
+        identifier: &str,
+        epoch_nanoseconds: i128,
+        direction: TransitionDirection,
+    ) -> TemporalResult<Option<EpochNanoseconds>>;
 }
 
 pub struct NeverProvider;
@@ -50,4 +96,13 @@ impl TimeZoneProvider for NeverProvider {
     fn get_named_tz_offset_nanoseconds(&self, _: &str, _: i128) -> TemporalResult<TimeZoneOffset> {
         unimplemented!()
     }
+
+    fn get_named_tz_transition(
+        &self,
+        _: &str,
+        _: i128,
+        _: TransitionDirection,
+    ) -> TemporalResult<Option<EpochNanoseconds>> {
+        unimplemented!()
+    }
 }

src/tzdb.rs

@@ -49,7 +49,7 @@ use tzif::{
 
 use crate::{
     iso::IsoDateTime,
-    provider::{TimeZoneOffset, TimeZoneProvider},
+    provider::{TimeZoneOffset, TimeZoneProvider, TransitionDirection},
     time::EpochNanoseconds,
     utils, TemporalError, TemporalResult,
 };
@@ -679,6 +679,15 @@ impl TimeZoneProvider for FsTzdbProvider {
         let seconds = (utc_epoch / 1_000_000_000) as i64;
         tzif.get(&Seconds(seconds))
     }
+
+    fn get_named_tz_transition(
+        &self,
+        _identifier: &str,
+        _epoch_nanoseconds: i128,
+        _direction: TransitionDirection,
+    ) -> TemporalResult<Option<EpochNanoseconds>> {
+        Err(TemporalError::general("Not yet implemented."))
+    }
 }
 
 #[inline]