rrule-rust 1.2.0 → 2.0.0-alpha.2

package/.releaserc

@@ -39,9 +39,9 @@
         }
       }
     ],
-    "@semantic-release/github", 
     "@semantic-release/npm", 
-    "@semantic-release/git"
+    "@semantic-release/git",
+    "@semantic-release/github"
   ],
-  "branches": ["+([0-9])?(.{+([0-9]),x}).x", "master", {"name": "next", "prerelease": true}]
+  "branches": ["+([0-9])?(.{+([0-9]),x}).x", "master", {"name": "next", "prerelease": true}, {"name": "alpha", "prerelease": true}]
 }

package/Cargo.toml

@@ -8,11 +8,12 @@ crate-type = ["cdylib"]
 
 [dependencies]
 chrono = "0.4.24"
-# Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
-napi = { version = "2.11.1", default-features = false, features = ["napi4"] }
+chrono-tz = "0.8.5"
+# Default enable napi5 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
+napi = { version = "2.11.1", default-features = false, features = ["napi5"] }
 napi-derive = "2.11.0"
 replace_with = "0.1.7"
-rrule = { version = "0.11.0", features = ["exrule"] }
+rrule = { version = "0.12.0", features = ["exrule"] }
 
 [build-dependencies]
 napi-build = "2.0.1"

package/benchmark/index.ts

@@ -8,7 +8,9 @@ b.suite(
     const rrule = new rust.RRule(rust.Frequency.Daily)
       .setCount(30)
       .setInterval(1);
-    const set = new rust.RRuleSet(1679428740000, 'UTC').addRrule(rrule);
+    const set = new rust.RRuleSet(
+      new rust.RRuleDateTime(new Date(1679428740000), 'UTC'),
+    ).addRrule(rrule);
 
     set.all();
   }),
@@ -34,9 +36,9 @@ b.suite(
     const rrule = new rust.RRule(rust.Frequency.Daily)
       .setCount(30)
       .setInterval(1);
-    const set = new rust.RRuleSet(1679428740000, 'Pacific/Kiritimati').addRrule(
-      rrule,
-    );
+    const set = new rust.RRuleSet(
+      new rust.RRuleDateTime(new Date(1679428740000), 'Pacific/Kiritimati'),
+    ).addRrule(rrule);
 
     set.all();
   }),

package/index.d.ts

@@ -12,15 +12,6 @@ export const enum Frequency {
   Minutely = 5,
   Secondly = 6
 }
-export const enum Weekday {
-  Monday = 0,
-  Tuesday = 1,
-  Wednesday = 2,
-  Thursday = 3,
-  Friday = 4,
-  Saturday = 5,
-  Sunday = 6
-}
 export const enum Month {
   January = 0,
   February = 1,
@@ -35,14 +26,32 @@ export const enum Month {
   November = 10,
   December = 11
 }
-export type JsRRule = RRule
+export interface NWeekday {
+  /**
+   * If set, this represents the nth occurrence of the weekday.
+   * Otherwise it represents every occurrence of the weekday.
+   *
+   * A negative value represents nth occurrence from the end.
+   */
+  n?: number
+  weekday: Weekday
+}
+export const enum Weekday {
+  Monday = 0,
+  Tuesday = 1,
+  Wednesday = 2,
+  Thursday = 3,
+  Friday = 4,
+  Saturday = 5,
+  Sunday = 6
+}
 export class RRule {
   constructor(frequency: Frequency)
   static parse(str: string): RRule
   get frequency(): Frequency
   get interval(): number
   get count(): number | null
-  get byWeekday(): Weekday[]
+  get byWeekday(): NWeekday[]
   get byHour(): Array<number>
   get byMinute(): Array<number>
   get bySecond(): Array<number>
@@ -52,11 +61,11 @@ export class RRule {
   get byWeekno(): Array<number>
   get byYearday(): Array<number>
   get weekstart(): Weekday
-  get until(): number | null
+  get until(): RRuleDateTime | null
   toString(): string
   setInterval(interval: number): this
   setCount(count: number): this
-  setByWeekday(weekdays: ReadonlyArray<Weekday>): this
+  setByWeekday(weekdays: ReadonlyArray<NWeekday | Weekday>): this
   setByHour(hours: ReadonlyArray<number>): this
   setByMinute(minutes: ReadonlyArray<number>): this
   setBySecond(seconds: ReadonlyArray<number>): this
@@ -66,27 +75,48 @@ export class RRule {
   setByWeekno(weekNumbers: ReadonlyArray<number>): this
   setByYearday(days: ReadonlyArray<number>): this
   setWeekstart(day: Weekday): this
-  setUntil(timestamp: number): this
+  setUntil(dateTime: RRuleDateTime | Date): this
+}
+export class RRuleDateTime {
+  constructor(date: Date | number, timezone?: string | undefined | null)
+  get timestamp(): number
+  get timezone(): RRuleTimezone
+  get day(): number
+  get month(): number
+  get year(): number
+  get hour(): number
+  get minute(): number
+  get second(): number
+  get millisecond(): number
+  get toString(): string
+  toDate(): Date
+  toUtcDate(): Date
 }
-export type JsRRuleSet = RRuleSet
 export class RRuleSet {
-  constructor(dtstart: number, tzid: string)
+  constructor(dtstart: RRuleDateTime | Date)
   static parse(str: string): RRuleSet
   toString(): string
   addRrule(jsRrule: RRule): this
   addExrule(jsRrule: RRule): this
-  addExdate(timestamp: number): this
-  addRdate(timestamp: number): this
-  get dtstart(): number
-  get tzid(): string
+  addExdate(dateTime: RRuleDateTime | Date): this
+  addRdate(dateTime: RRuleDateTime | Date): this
+  get dtstart(): RRuleDateTime
   getRrules(): Array<RRule>
   getExrules(): Array<RRule>
-  getExdates(): Array<number>
-  getRdates(): Array<number>
-  all(limit?: number | undefined | null): number[]
-  between(after: number, before: number, inclusive?: boolean | undefined | null): number[]
+  getExdates(): Array<RRuleDateTime>
+  getRdates(): Array<RRuleDateTime>
+  all(limit?: number | undefined | null): Array<RRuleDateTime>
+  between(after: RRuleDateTime | Date, before: RRuleDateTime | Date, inclusive?: boolean | undefined | null): Array<RRuleDateTime>
   occurrences(): Occurrences
 }
 export class Occurrences {
-  [Symbol.iterator](): Iterator<number, void, void>
+  [Symbol.iterator](): Iterator<RRuleDateTime, void, void>
+}
+export class RRuleTimezone {
+  constructor(tz: string)
+  /**
+  * The name of the timezone. If the timezone is local, it will return "Local".
+  */
+  get name(): string
+  get isLocal(): boolean
 }

package/index.js

@@ -252,11 +252,13 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { Frequency, Weekday, Month, RRule, RRuleSet, Occurrences } = nativeBinding
+const { Frequency, Month, RRule, RRuleDateTime, RRuleSet, Occurrences, RRuleTimezone, Weekday } = nativeBinding
 
 module.exports.Frequency = Frequency
-module.exports.Weekday = Weekday
 module.exports.Month = Month
 module.exports.RRule = RRule
+module.exports.RRuleDateTime = RRuleDateTime
 module.exports.RRuleSet = RRuleSet
 module.exports.Occurrences = Occurrences
+module.exports.RRuleTimezone = RRuleTimezone
+module.exports.Weekday = Weekday

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrule-rust",
-  "version": "1.2.0",
+  "version": "2.0.0-alpha.2",
   "main": "index.js",
   "types": "index.d.ts",
   "keywords": [
@@ -46,6 +46,7 @@
     "@typescript-eslint/eslint-plugin": "^5.50.0",
     "@typescript-eslint/parser": "^5.50.0",
     "benny": "^3.7.1",
+    "conventional-changelog-conventionalcommits": "^7.0.2",
     "eslint": "^8.33.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
@@ -75,7 +76,7 @@
     "artifacts": "napi artifacts",
     "build": "napi build --platform --release --js-package-name @rrule-rust/lib",
     "build:debug": "napi build --platform",
-    "prepublishOnly": "napi prepublish -t npm",
+    "prepublishOnly": "napi prepublish --skip-gh-release",
     "test": "jest",
     "universal": "napi universal",
     "version": "napi version",
@@ -84,23 +85,20 @@
     "lint:fix": "cargo fmt --all && yarn lint --fix",
     "lint:fix-staged": "lint-staged"
   },
-  "dependencies": {
-    "conventional-changelog-conventionalcommits": "^7.0.2"
-  },
   "optionalDependencies": {
-    "@rrule-rust/lib-win32-x64-msvc": "1.2.0",
-    "@rrule-rust/lib-darwin-x64": "1.2.0",
-    "@rrule-rust/lib-linux-x64-gnu": "1.2.0",
-    "@rrule-rust/lib-darwin-arm64": "1.2.0",
-    "@rrule-rust/lib-android-arm64": "1.2.0",
-    "@rrule-rust/lib-linux-arm64-gnu": "1.2.0",
-    "@rrule-rust/lib-linux-arm64-musl": "1.2.0",
-    "@rrule-rust/lib-win32-arm64-msvc": "1.2.0",
-    "@rrule-rust/lib-linux-arm-gnueabihf": "1.2.0",
-    "@rrule-rust/lib-linux-x64-musl": "1.2.0",
-    "@rrule-rust/lib-freebsd-x64": "1.2.0",
-    "@rrule-rust/lib-win32-ia32-msvc": "1.2.0",
-    "@rrule-rust/lib-android-arm-eabi": "1.2.0",
-    "@rrule-rust/lib-darwin-universal": "1.2.0"
+    "@rrule-rust/lib-win32-x64-msvc": "2.0.0-alpha.2",
+    "@rrule-rust/lib-darwin-x64": "2.0.0-alpha.2",
+    "@rrule-rust/lib-linux-x64-gnu": "2.0.0-alpha.2",
+    "@rrule-rust/lib-darwin-arm64": "2.0.0-alpha.2",
+    "@rrule-rust/lib-android-arm64": "2.0.0-alpha.2",
+    "@rrule-rust/lib-linux-arm64-gnu": "2.0.0-alpha.2",
+    "@rrule-rust/lib-linux-arm64-musl": "2.0.0-alpha.2",
+    "@rrule-rust/lib-win32-arm64-msvc": "2.0.0-alpha.2",
+    "@rrule-rust/lib-linux-arm-gnueabihf": "2.0.0-alpha.2",
+    "@rrule-rust/lib-linux-x64-musl": "2.0.0-alpha.2",
+    "@rrule-rust/lib-freebsd-x64": "2.0.0-alpha.2",
+    "@rrule-rust/lib-win32-ia32-msvc": "2.0.0-alpha.2",
+    "@rrule-rust/lib-android-arm-eabi": "2.0.0-alpha.2",
+    "@rrule-rust/lib-darwin-universal": "2.0.0-alpha.2"
   }
 }

package/src/js/frequency.rs

@@ -0,0 +1,40 @@
+use napi_derive::napi;
+
+#[napi(js_name = "Frequency")]
+pub enum Frequency {
+  Yearly,
+  Monthly,
+  Weekly,
+  Daily,
+  Hourly,
+  Minutely,
+  Secondly,
+}
+
+impl From<rrule::Frequency> for Frequency {
+  fn from(freq: rrule::Frequency) -> Self {
+    match freq {
+      rrule::Frequency::Daily => Frequency::Daily,
+      rrule::Frequency::Hourly => Frequency::Hourly,
+      rrule::Frequency::Minutely => Frequency::Minutely,
+      rrule::Frequency::Monthly => Frequency::Monthly,
+      rrule::Frequency::Secondly => Frequency::Secondly,
+      rrule::Frequency::Weekly => Frequency::Weekly,
+      rrule::Frequency::Yearly => Frequency::Yearly,
+    }
+  }
+}
+
+impl Into<rrule::Frequency> for Frequency {
+  fn into(self) -> rrule::Frequency {
+    match self {
+      Frequency::Daily => rrule::Frequency::Daily,
+      Frequency::Hourly => rrule::Frequency::Hourly,
+      Frequency::Minutely => rrule::Frequency::Minutely,
+      Frequency::Monthly => rrule::Frequency::Monthly,
+      Frequency::Secondly => rrule::Frequency::Secondly,
+      Frequency::Weekly => rrule::Frequency::Weekly,
+      Frequency::Yearly => rrule::Frequency::Yearly,
+    }
+  }
+}

package/src/js/month.rs

@@ -0,0 +1,56 @@
+use napi_derive::napi;
+
+#[napi(js_name = "Month")]
+pub enum Month {
+  January,
+  February,
+  March,
+  April,
+  May,
+  June,
+  July,
+  August,
+  September,
+  October,
+  November,
+  December,
+}
+
+impl From<&u8> for Month {
+  fn from(month: &u8) -> Self {
+    match month {
+      0 => Month::January,
+      1 => Month::February,
+      2 => Month::March,
+      3 => Month::April,
+      4 => Month::May,
+      5 => Month::June,
+      6 => Month::July,
+      7 => Month::August,
+      8 => Month::September,
+      9 => Month::October,
+      10 => Month::November,
+      11 => Month::December,
+      _ => panic!("Unknown month index: {}", month),
+    }
+  }
+}
+
+impl Into<chrono::Month> for Month {
+  fn into(self) -> chrono::Month {
+    match self {
+      Month::January => chrono::Month::January,
+      Month::February => chrono::Month::February,
+      Month::March => chrono::Month::March,
+      Month::April => chrono::Month::April,
+      Month::May => chrono::Month::May,
+      Month::June => chrono::Month::June,
+      Month::July => chrono::Month::July,
+      Month::August => chrono::Month::August,
+      Month::September => chrono::Month::September,
+      Month::October => chrono::Month::October,
+      Month::November => chrono::Month::November,
+      Month::December => chrono::Month::December,
+    }
+  }
+}

package/src/js/n_weekday.rs

@@ -0,0 +1,36 @@
+use super::weekday::Weekday;
+use napi_derive::napi;
+
+#[napi(object, js_name = "NWeekday")]
+pub struct NWeekday {
+  /// If set, this represents the nth occurrence of the weekday.
+  /// Otherwise it represents every occurrence of the weekday.
+  ///
+  /// A negative value represents nth occurrence from the end.
+  pub n: Option<i16>,
+  pub weekday: Weekday,
+}
+
+impl From<rrule::NWeekday> for NWeekday {
+  fn from(nday: rrule::NWeekday) -> Self {
+    match nday {
+      rrule::NWeekday::Every(weekday) => NWeekday {
+        n: None,
+        weekday: Weekday::from(weekday),
+      },
+      rrule::NWeekday::Nth(n, weekday) => NWeekday {
+        n: Some(n),
+        weekday: weekday.into(),
+      },
+    }
+  }
+}
+
+impl Into<rrule::NWeekday> for NWeekday {
+  fn into(self) -> rrule::NWeekday {
+    match self.n {
+      Some(n) => rrule::NWeekday::Nth(n, self.weekday.into()),
+      None => rrule::NWeekday::Every(self.weekday.into()),
+    }
+  }
+}

package/src/js/rrule.rs

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