rrule-rust 2.0.0-alpha.4 → 2.0.0-next.10

package/src/js/rrule.rs

@@ -1,275 +0,0 @@
-use super::{Frequency, Month, NWeekday, RRuleDateTime, Weekday};
-use chrono::DateTime;
-use napi::{bindgen_prelude::Array, Either, Env};
-use napi_derive::napi;
-use replace_with::replace_with_or_abort;
-
-#[napi(js_name = "RRule")]
-pub struct RRule {
-  rrule: rrule::RRule<rrule::Unvalidated>,
-}
-
-#[napi]
-impl RRule {
-  #[napi(constructor)]
-  pub fn new(frequency: Frequency) -> Self {
-    let rrule = rrule::RRule::new(frequency.into());
-
-    RRule { rrule }
-  }
-
-  #[napi(factory, ts_return_type = "RRule")]
-  pub fn parse(str: String) -> napi::Result<Self> {
-    let rrule: rrule::RRule<rrule::Unvalidated> = str
-      .parse()
-      .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?;
-
-    Ok(RRule { rrule })
-  }
-
-  #[napi(getter)]
-  pub fn frequency(&self) -> napi::Result<Frequency> {
-    Ok(Frequency::from(self.rrule.get_freq()))
-  }
-
-  #[napi(getter)]
-  pub fn interval(&self) -> napi::Result<u16> {
-    Ok(self.rrule.get_interval())
-  }
-
-  #[napi(getter)]
-  pub fn count(&self) -> napi::Result<Option<u32>> {
-    Ok(self.rrule.get_count())
-  }
-
-  #[napi(getter, ts_return_type = "NWeekday[]")]
-  pub fn by_weekday(&self) -> Vec<NWeekday> {
-    return self
-      .rrule
-      .get_by_weekday()
-      .iter()
-      .map(|nday| NWeekday::from(*nday))
-      .collect();
-  }
-
-  #[napi(getter)]
-  pub fn by_hour(&self) -> napi::Result<Vec<u8>> {
-    Ok(self.rrule.get_by_hour().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn by_minute(&self) -> napi::Result<Vec<u8>> {
-    Ok(self.rrule.get_by_minute().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn by_second(&self) -> napi::Result<Vec<u8>> {
-    Ok(self.rrule.get_by_second().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn by_monthday(&self) -> napi::Result<Vec<i8>> {
-    Ok(self.rrule.get_by_month_day().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn by_setpos(&self) -> napi::Result<Vec<i32>> {
-    Ok(self.rrule.get_by_set_pos().to_vec())
-  }
-
-  #[napi(getter, ts_return_type = "Month[]")]
-  pub fn by_month(&self, env: Env) -> napi::Result<Array> {
-    let months = self.rrule.get_by_month();
-    let mut arr = env.create_array(0)?;
-
-    for month in months.iter() {
-      arr.insert(Month::from(month))?;
-    }
-
-    Ok(arr)
-  }
-
-  #[napi(getter)]
-  pub fn by_weekno(&self) -> napi::Result<Vec<i8>> {
-    Ok(self.rrule.get_by_week_no().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn by_yearday(&self) -> napi::Result<Vec<i16>> {
-    Ok(self.rrule.get_by_year_day().to_vec())
-  }
-
-  #[napi(getter)]
-  pub fn weekstart(&self) -> napi::Result<Weekday> {
-    Ok(Weekday::from(self.rrule.get_week_start()))
-  }
-
-  #[napi(getter)]
-  pub fn until(&self) -> napi::Result<Option<RRuleDateTime>> {
-    Ok(match self.rrule.get_until() {
-      Some(until) => Some(RRuleDateTime::new_with_date_time(until.clone())),
-      None => None,
-    })
-  }
-
-  #[napi]
-  pub fn to_string(&self) -> napi::Result<String> {
-    Ok(self.rrule.to_string())
-  }
-
-  #[napi]
-  pub fn set_interval(&mut self, interval: u16) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.interval(interval));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_count(&mut self, count: u32) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.count(count));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_weekday(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<NWeekday | Weekday>")] weekdays: Vec<
-      Either<NWeekday, Weekday>,
-    >,
-  ) -> napi::Result<&Self> {
-    let by_weekday = weekdays
-      .into_iter()
-      .map(|weekday| match weekday {
-        Either::A(nday) => nday.into(),
-        Either::B(weekday) => rrule::NWeekday::Every(weekday.into()),
-      })
-      .collect();
-
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_weekday(by_weekday));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_hour(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] hours: Vec<u8>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_hour(hours));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_minute(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] minutes: Vec<u8>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_minute(minutes));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_second(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] seconds: Vec<u8>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_second(seconds));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_monthday(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] days: Vec<i8>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_month_day(days));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_setpos(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] poses: Vec<i32>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_set_pos(poses));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_month(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<Month>")] months: Array,
-  ) -> napi::Result<&Self> {
-    let mut vec: Vec<chrono::Month> = Vec::new();
-
-    for i in 0..months.len() {
-      let month: Month = months.get(i).unwrap().unwrap();
-
-      vec.push(month.into());
-    }
-
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_month(&vec));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_weekno(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] week_numbers: Vec<i8>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_week_no(week_numbers));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_by_yearday(
-    &mut self,
-    #[napi(ts_arg_type = "ReadonlyArray<number>")] days: Vec<i16>,
-  ) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.by_year_day(days));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_weekstart(&mut self, day: Weekday) -> napi::Result<&Self> {
-    replace_with_or_abort(&mut self.rrule, |self_| self_.week_start(day.into()));
-
-    Ok(self)
-  }
-
-  #[napi]
-  pub fn set_until(
-    &mut self,
-    date_time: napi::Either<&RRuleDateTime, napi::JsDate>,
-  ) -> napi::Result<&Self> {
-    let date_time = RRuleDateTime::from(date_time);
-    replace_with_or_abort(&mut self.rrule, |self_| self_.until(date_time.into()));
-
-    Ok(self)
-  }
-
-  pub fn validate(&self, dt_start: DateTime<rrule::Tz>) -> napi::Result<rrule::RRule> {
-    return Ok(
-      self
-        .rrule
-        .clone()
-        .validate(dt_start)
-        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?,
-    );
-  }
-}
-
-impl From<rrule::RRule<rrule::Unvalidated>> for RRule {
-  fn from(rrule: rrule::RRule<rrule::Unvalidated>) -> Self {
-    Self { rrule }
-  }
-}

package/src/js/rrule_datetime.rs

@@ -1,128 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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()))
-  }
-}