rrule-rust 2.0.0-next.1 → 2.0.0-next.3

package/src/js/rrule_datetime.rs

@@ -0,0 +1,128 @@
+use super::RRuleTimezone;
+use chrono::DateTime;
+use chrono::Datelike;
+use chrono::TimeZone;
+use chrono::Timelike;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::str::FromStr;
+
+#[napi(js_name = "RRuleDateTime")]
+pub struct RRuleDateTime {
+  date_time: chrono::DateTime<rrule::Tz>,
+}
+
+#[napi]
+impl RRuleDateTime {
+  #[napi(constructor)]
+  pub fn new_with_js_date(
+    date: napi::Either<napi::JsDate, f64>,
+    timezone: Option<String>,
+  ) -> napi::Result<Self> {
+    let timestamp = match date {
+      Either::A(date) => date.value_of(),
+      Either::B(date) => Ok(date),
+    }?;
+
+    let mut date_time = rrule::Tz::LOCAL.timestamp_nanos((timestamp * 1_000_000f64) as i64);
+    if let Some(timezone) = timezone {
+      let tz: rrule::Tz = RRuleTimezone::from_str(&timezone)?.into();
+
+      date_time = date_time.with_timezone(&tz);
+    }
+
+    Ok(RRuleDateTime::new_with_date_time(date_time))
+  }
+
+  pub fn new_with_date_time(date_time: DateTime<rrule::Tz>) -> Self {
+    RRuleDateTime { date_time }
+  }
+
+  #[napi(getter)]
+  pub fn timestamp(&self) -> i64 {
+    self.date_time.timestamp_millis()
+  }
+
+  #[napi(getter)]
+  pub fn timezone(&self) -> RRuleTimezone {
+    RRuleTimezone::new_with_tz(self.date_time.timezone())
+  }
+
+  #[napi(getter)]
+  pub fn day(&self) -> u32 {
+    self.date_time.day()
+  }
+
+  #[napi(getter)]
+  pub fn month(&self) -> u32 {
+    self.date_time.month()
+  }
+
+  #[napi(getter)]
+  pub fn year(&self) -> i32 {
+    self.date_time.year()
+  }
+
+  #[napi(getter)]
+  pub fn hour(&self) -> u32 {
+    self.date_time.hour()
+  }
+
+  #[napi(getter)]
+  pub fn minute(&self) -> u32 {
+    self.date_time.minute()
+  }
+
+  #[napi(getter)]
+  pub fn second(&self) -> u32 {
+    self.date_time.second()
+  }
+
+  #[napi(getter)]
+  pub fn millisecond(&self) -> u32 {
+    let nanoseconds = self.date_time.nanosecond();
+    nanoseconds / 1_000_000
+  }
+
+  #[napi(getter)]
+  pub fn to_string(&self) -> String {
+    self.date_time.to_string()
+  }
+
+  #[napi(ts_return_type = "Date")]
+  pub fn to_date(&self, env: Env) -> napi::Result<napi::JsDate> {
+    env.create_date(self.date_time.timestamp_millis() as f64)
+  }
+
+  #[napi(ts_return_type = "Date")]
+  pub fn to_utc_date(&self, env: Env) -> napi::Result<napi::JsDate> {
+    env.create_date(self.date_time.naive_utc().and_utc().timestamp_millis() as f64)
+  }
+}
+
+impl From<DateTime<rrule::Tz>> for RRuleDateTime {
+  fn from(date_time: DateTime<rrule::Tz>) -> Self {
+    RRuleDateTime::new_with_date_time(date_time)
+  }
+}
+
+impl Into<DateTime<rrule::Tz>> for RRuleDateTime {
+  fn into(self) -> DateTime<rrule::Tz> {
+    self.date_time
+  }
+}
+
+impl From<napi::JsDate> for RRuleDateTime {
+  fn from(date: napi::JsDate) -> Self {
+    RRuleDateTime::new_with_js_date(napi::Either::A(date), None).unwrap()
+  }
+}
+
+impl From<napi::Either<&RRuleDateTime, napi::JsDate>> for RRuleDateTime {
+  fn from(date: napi::Either<&RRuleDateTime, napi::JsDate>) -> Self {
+    match date {
+      Either::A(date) => RRuleDateTime::new_with_date_time(date.date_time),
+      Either::B(date) => RRuleDateTime::new_with_js_date(napi::Either::A(date), None).unwrap(),
+    }
+  }
+}

package/src/js/rrule_set.rs

@@ -0,0 +1,258 @@
+use super::{RRule, RRuleDateTime};
+use chrono::DateTime;
+use napi::{
+  bindgen_prelude::{Reference, SharedReference},
+  iterator::Generator,
+  Env,
+};
+use napi_derive::napi;
+use replace_with::replace_with_or_abort;
+
+#[napi(js_name = "RRuleSet")]
+pub struct RRuleSet {
+  rrule_set: rrule::RRuleSet,
+}
+
+#[napi]
+impl RRuleSet {
+  #[napi(constructor)]
+  pub fn new(dtstart: napi::Either<&RRuleDateTime, napi::JsDate>) -> napi::Result<Self> {
+    let rrule_set = rrule::RRuleSet::new(RRuleDateTime::from(dtstart).into());
+
+    Ok(RRuleSet { rrule_set })
+  }
+
+  #[napi(factory, ts_return_type = "RRuleSet")]
+  pub fn parse(str: String) -> napi::Result<Self> {
+    let rrule_set: rrule::RRuleSet = str
+      .parse()
+      .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?;
+
+    Ok(RRuleSet { rrule_set })
+  }
+
+  #[napi]
+  pub fn to_string(&self) -> napi::Result<String> {
+    Ok(self.rrule_set.to_string())
+  }
+
+  #[napi]
+  pub fn add_rrule(&mut self, js_rrule: &RRule) -> napi::Result<&Self> {
+    let dt_start = self.rrule_set.get_dt_start().clone();
+    let rrule = js_rrule.validate(dt_start)?;
+
+    replace_with_or_abort(&mut self.rrule_set, |self_| self_.rrule(rrule));
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn add_exrule(&mut self, js_rrule: &RRule) -> napi::Result<&Self> {
+    let rrule = js_rrule.validate(*self.rrule_set.get_dt_start())?;
+
+    replace_with_or_abort(&mut self.rrule_set, |self_| self_.exrule(rrule));
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn add_exdate(
+    &mut self,
+    date_time: napi::Either<&RRuleDateTime, napi::JsDate>,
+  ) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule_set, |self_| {
+      self_.exdate(RRuleDateTime::from(date_time).into())
+    });
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn add_rdate(
+    &mut self,
+    date_time: napi::Either<&RRuleDateTime, napi::JsDate>,
+  ) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule_set, |self_| {
+      self_.rdate(RRuleDateTime::from(date_time).into())
+    });
+
+    Ok(self)
+  }
+
+  #[napi(getter)]
+  pub fn dtstart(&self) -> RRuleDateTime {
+    RRuleDateTime::new_with_date_time(self.rrule_set.get_dt_start().clone())
+  }
+
+  #[napi]
+  pub fn get_rrules(&self) -> Vec<RRule> {
+    return self
+      .rrule_set
+      .get_rrule()
+      .iter()
+      .map(|rrule| RRule::from(to_unvalidated(rrule)))
+      .collect();
+  }
+
+  #[napi]
+  pub fn get_exrules(&self) -> Vec<RRule> {
+    return self
+      .rrule_set
+      .get_exrule()
+      .iter()
+      .map(|rrule| RRule::from(to_unvalidated(rrule)))
+      .collect();
+  }
+
+  #[napi]
+  pub fn get_exdates(&self) -> Vec<RRuleDateTime> {
+    return self
+      .rrule_set
+      .get_exdate()
+      .iter()
+      .map(|date| RRuleDateTime::new_with_date_time(date.clone()))
+      .collect();
+  }
+
+  #[napi]
+  pub fn get_rdates(&self) -> Vec<RRuleDateTime> {
+    return self
+      .rrule_set
+      .get_rdate()
+      .iter()
+      .map(|date| RRuleDateTime::new_with_date_time(date.clone()))
+      .collect();
+  }
+
+  fn is_after(
+    &self,
+    timestamp: DateTime<rrule::Tz>,
+    after_timestamp: DateTime<rrule::Tz>,
+    inclusive: Option<bool>,
+  ) -> bool {
+    let inclusive = inclusive.unwrap_or(false);
+
+    if inclusive && timestamp < after_timestamp {
+      return false;
+    } else if !inclusive && timestamp <= after_timestamp {
+      return false;
+    }
+
+    true
+  }
+
+  fn is_before(
+    &self,
+    timestamp: DateTime<rrule::Tz>,
+    before_timestamp: DateTime<rrule::Tz>,
+    inclusive: Option<bool>,
+  ) -> bool {
+    let inclusive = inclusive.unwrap_or(false);
+
+    if inclusive && timestamp > before_timestamp {
+      return false;
+    } else if !inclusive && timestamp >= before_timestamp {
+      return false;
+    }
+
+    true
+  }
+
+  #[napi]
+  pub fn all(&self, limit: Option<u32>) -> Vec<RRuleDateTime> {
+    let iter = self.rrule_set.into_iter();
+    if let Some(limit) = limit {
+      return iter
+        .take(limit as usize)
+        .map(|date| RRuleDateTime::new_with_date_time(date))
+        .collect();
+    } else {
+      return iter
+        .map(|date| RRuleDateTime::new_with_date_time(date))
+        .collect();
+    }
+  }
+
+  #[napi]
+  pub fn between(
+    &self,
+    after: napi::Either<&RRuleDateTime, napi::JsDate>,
+    before: napi::Either<&RRuleDateTime, napi::JsDate>,
+    inclusive: Option<bool>,
+  ) -> napi::Result<Vec<RRuleDateTime>> {
+    let _after = RRuleDateTime::from(after).into();
+    let _before = RRuleDateTime::from(before).into();
+    return Ok(
+      self
+        .rrule_set
+        .into_iter()
+        .take_while(|date| {
+          let is_before = self.is_before(*date, _before, inclusive);
+
+          is_before
+        })
+        .filter(|date| {
+          let is_after = self.is_after(*date, _after, inclusive);
+
+          is_after
+        })
+        .map(|date| RRuleDateTime::new_with_date_time(date))
+        .collect::<Vec<_>>(),
+    );
+  }
+
+  #[napi]
+  pub fn occurrences(&self, this: Reference<RRuleSet>, env: Env) -> napi::Result<Occurrences> {
+    let iter = this.share_with(env, |set| Ok(set.rrule_set.into_iter()))?;
+    Ok(Occurrences { iter })
+  }
+}
+
+#[napi(iterator)]
+pub struct Occurrences {
+  iter: SharedReference<RRuleSet, rrule::RRuleSetIter<'static>>,
+}
+
+#[napi]
+impl Generator for Occurrences {
+  type Yield = RRuleDateTime;
+  type Next = ();
+  type Return = ();
+
+  fn next(&mut self, _next: Option<Self::Next>) -> Option<Self::Yield> {
+    self
+      .iter
+      .next()
+      .map(|date| RRuleDateTime::new_with_date_time(date))
+  }
+}
+
+fn to_unvalidated(rrule: &rrule::RRule) -> rrule::RRule<rrule::Unvalidated> {
+  let by_month = rrule
+    .get_by_month()
+    .iter()
+    .map(|m| chrono::Month::try_from(*m).unwrap())
+    .collect::<Vec<_>>();
+  let mut unvalidated = rrule::RRule::new(rrule.get_freq())
+    .interval(rrule.get_interval())
+    .week_start(rrule.get_week_start())
+    .by_set_pos(rrule.get_by_set_pos().to_vec())
+    .by_month(&by_month)
+    .by_month_day(rrule.get_by_month_day().to_vec())
+    .by_year_day(rrule.get_by_year_day().to_vec())
+    .by_week_no(rrule.get_by_week_no().to_vec())
+    .by_weekday(rrule.get_by_weekday().to_vec())
+    .by_hour(rrule.get_by_hour().to_vec())
+    .by_minute(rrule.get_by_minute().to_vec())
+    .by_second(rrule.get_by_second().to_vec());
+
+  if let Some(count) = rrule.get_count() {
+    unvalidated = unvalidated.count(count);
+  }
+
+  if let Some(until) = rrule.get_until() {
+    unvalidated = unvalidated.until(*until);
+  }
+
+  unvalidated
+}

package/src/js/rrule_timezone.rs

@@ -0,0 +1,52 @@
+use napi_derive::napi;
+use std::str::FromStr;
+
+#[derive(Debug)]
+#[napi(js_name = "RRuleTimezone")]
+pub struct RRuleTimezone {
+  tz: rrule::Tz,
+}
+
+#[napi]
+impl RRuleTimezone {
+  #[napi(constructor)]
+  pub fn new(tz: String) -> napi::Result<Self> {
+    Ok(tz.parse()?)
+  }
+
+  pub fn new_with_tz(tz: rrule::Tz) -> Self {
+    RRuleTimezone { tz }
+  }
+
+  /**
+   * The name of the timezone. If the timezone is local, it will return "Local".
+   */
+  #[napi(getter)]
+  pub fn name(&self) -> String {
+    self.tz.name().to_string()
+  }
+
+  #[napi(getter)]
+  pub fn is_local(&self) -> bool {
+    self.tz.is_local()
+  }
+}
+
+impl Into<rrule::Tz> for RRuleTimezone {
+  fn into(self) -> rrule::Tz {
+    self.tz
+  }
+}
+
+impl FromStr for RRuleTimezone {
+  type Err = napi::Error;
+
+  fn from_str(str: &str) -> Result<Self, Self::Err> {
+    str
+      .parse::<chrono_tz::Tz>()
+      .map(|tz| RRuleTimezone {
+        tz: rrule::Tz::Tz(tz),
+      })
+      .map_err(|err| napi::Error::new(napi::Status::GenericFailure, err.to_string()))
+  }
+}

package/src/js/weekday.rs

@@ -0,0 +1,40 @@
+use napi_derive::napi;
+
+#[napi(js_name = "Weekday")]
+pub enum Weekday {
+  Monday,
+  Tuesday,
+  Wednesday,
+  Thursday,
+  Friday,
+  Saturday,
+  Sunday,
+}
+
+impl From<rrule::Weekday> for Weekday {
+  fn from(weekday: rrule::Weekday) -> Self {
+    match weekday {
+      rrule::Weekday::Mon => Weekday::Monday,
+      rrule::Weekday::Tue => Weekday::Tuesday,
+      rrule::Weekday::Wed => Weekday::Wednesday,
+      rrule::Weekday::Thu => Weekday::Thursday,
+      rrule::Weekday::Fri => Weekday::Friday,
+      rrule::Weekday::Sat => Weekday::Saturday,
+      rrule::Weekday::Sun => Weekday::Sunday,
+    }
+  }
+}
+
+impl Into<rrule::Weekday> for Weekday {
+  fn into(self) -> rrule::Weekday {
+    match self {
+      Weekday::Monday => rrule::Weekday::Mon,
+      Weekday::Tuesday => rrule::Weekday::Tue,
+      Weekday::Wednesday => rrule::Weekday::Wed,
+      Weekday::Thursday => rrule::Weekday::Thu,
+      Weekday::Friday => rrule::Weekday::Fri,
+      Weekday::Saturday => rrule::Weekday::Sat,
+      Weekday::Sunday => rrule::Weekday::Sun,
+    }
+  }
+}

package/src/js.rs

@@ -0,0 +1,17 @@
+mod frequency;
+mod month;
+mod n_weekday;
+mod rrule;
+mod rrule_datetime;
+mod rrule_set;
+mod rrule_timezone;
+mod weekday;
+
+pub use frequency::Frequency;
+pub use month::Month;
+pub use n_weekday::NWeekday;
+pub use rrule::RRule;
+pub use rrule_datetime::RRuleDateTime;
+pub use rrule_set::RRuleSet;
+pub use rrule_timezone::RRuleTimezone;
+pub use weekday::Weekday;