rrule-rust 0.0.1-1

package/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

package/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+edition = "2021"
+name = "rrule-rust"
+version = "0.0.0"
+
+[lib]
+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"] }
+napi-derive = "2.11.0"
+replace_with = "0.1.7"
+rrule = { version = "0.10.0", features = ["exrule"] }
+
+[build-dependencies]
+napi-build = "2.0.1"
+
+[profile.release]
+lto = true

package/build.rs

@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+  napi_build::setup();
+}

package/index.d.ts

@@ -0,0 +1,82 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export const enum Frequency {
+  Yearly = 0,
+  Monthly = 1,
+  Weekly = 2,
+  Daily = 3,
+  Hourly = 4,
+  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,
+  March = 2,
+  April = 3,
+  May = 4,
+  June = 5,
+  July = 6,
+  August = 7,
+  September = 8,
+  October = 9,
+  November = 10,
+  December = 11
+}
+export type JsRRule = RRule
+export class RRule {
+  constructor(frequency: Frequency)
+  get frequency(): Frequency
+  get interval(): number
+  get count(): number | null
+  get byWeekday(): Weekday[]
+  get byHour(): Array<number>
+  get byMinute(): Array<number>
+  get bySecond(): Array<number>
+  get byMonthday(): Array<number>
+  get bySetpos(): Array<number>
+  get byMonth(): Month[]
+  get byWeekno(): Array<number>
+  get byYearday(): Array<number>
+  get weekstart(): Weekday
+  get until(): number | null
+  toString(): string
+  setInterval(interval: number): this
+  setCount(count: number): this
+  setByWeekday(weekdays: Weekday[]): this
+  setByHour(hours: Array<number>): this
+  setByMinute(minutes: Array<number>): this
+  setBySecond(seconds: Array<number>): this
+  setByMonthday(days: Array<number>): this
+  setBySetpos(poses: Array<number>): this
+  setByMonth(months: Month[]): this
+  setByWeekno(weekNumbers: Array<number>): this
+  setByYearday(days: Array<number>): this
+  getWeekstart(day: Weekday): this
+  setUntil(timestamp: number): this
+}
+export type JsRRuleSet = RRuleSet
+export class RRuleSet {
+  constructor(dtstart: number, tzid: string)
+  toString(): string
+  rrule(jsRrule: RRule): this
+  exrule(jsRrule: RRule): this
+  after(timestamp: number): this
+  before(timestamp: number): this
+  exdate(timestamp: number): this
+  getDtstart(): number
+  getTzid(): string
+  all(limit?: number | undefined | null): number[]
+}

package/index.js

@@ -0,0 +1,255 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim();
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rrule-rust.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.android-arm64.node')
+          } else {
+            nativeBinding = require('rrule-rust-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rrule-rust.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('rrule-rust-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rrule-rust.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('rrule-rust-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'rrule-rust.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('rrule-rust-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rrule-rust.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('rrule-rust-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'rrule-rust.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rrule-rust.darwin-universal.node')
+      } else {
+        nativeBinding = require('rrule-rust-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rrule-rust.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.darwin-x64.node')
+          } else {
+            nativeBinding = require('rrule-rust-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'rrule-rust.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.darwin-arm64.node')
+          } else {
+            nativeBinding = require('rrule-rust-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'rrule-rust.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rrule-rust.freebsd-x64.node')
+      } else {
+        nativeBinding = require('rrule-rust-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('rrule-rust-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('rrule-rust-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('rrule-rust-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('rrule-rust-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'rrule-rust.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rrule-rust.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('rrule-rust-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Frequency, Weekday, Month, RRule, RRuleSet } = nativeBinding
+
+module.exports.Frequency = Frequency
+module.exports.Weekday = Weekday
+module.exports.Month = Month
+module.exports.RRule = RRule
+module.exports.RRuleSet = RRuleSet

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "rrule-rust",
+  "version": "0.0.1-1",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "rrule-rust",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-linux-android",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "aarch64-pc-windows-msvc",
+        "armv7-unknown-linux-gnueabihf",
+        "x86_64-unknown-linux-musl",
+        "x86_64-unknown-freebsd",
+        "i686-pc-windows-msvc",
+        "armv7-linux-androideabi",
+        "universal-apple-darwin"
+      ]
+    }
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.14.8",
+    "ava": "^5.1.1"
+  },
+  "ava": {
+    "timeout": "3m"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "ava",
+    "universal": "napi universal",
+    "version": "napi version"
+  },
+  "optionalDependencies": {
+    "rrule-rust-win32-x64-msvc": "0.0.1-1",
+    "rrule-rust-darwin-x64": "0.0.1-1",
+    "rrule-rust-linux-x64-gnu": "0.0.1-1",
+    "rrule-rust-darwin-arm64": "0.0.1-1",
+    "rrule-rust-android-arm64": "0.0.1-1",
+    "rrule-rust-linux-arm64-gnu": "0.0.1-1",
+    "rrule-rust-linux-arm64-musl": "0.0.1-1",
+    "rrule-rust-win32-arm64-msvc": "0.0.1-1",
+    "rrule-rust-linux-arm-gnueabihf": "0.0.1-1",
+    "rrule-rust-linux-x64-musl": "0.0.1-1",
+    "rrule-rust-freebsd-x64": "0.0.1-1",
+    "rrule-rust-win32-ia32-msvc": "0.0.1-1",
+    "rrule-rust-android-arm-eabi": "0.0.1-1",
+    "rrule-rust-darwin-universal": "0.0.1-1"
+  }
+}

package/src/lib.rs

@@ -0,0 +1,496 @@
+#![deny(clippy::all)]
+
+use chrono::{DateTime, Month, TimeZone, Weekday};
+use napi::bindgen_prelude::*;
+use replace_with::replace_with_or_abort;
+use rrule::{Frequency, NWeekday, RRule, RRuleSet, Tz, Unvalidated};
+
+#[macro_use]
+extern crate napi_derive;
+
+#[napi(js_name = "Frequency")]
+pub enum JsFrequency {
+  Yearly,
+  Monthly,
+  Weekly,
+  Daily,
+  Hourly,
+  Minutely,
+  Secondly,
+}
+
+#[napi(js_name = "Weekday")]
+pub enum JsWeekday {
+  Monday,
+  Tuesday,
+  Wednesday,
+  Thursday,
+  Friday,
+  Saturday,
+  Sunday,
+}
+
+#[napi(js_name = "Month")]
+pub enum JsMonth {
+  January,
+  February,
+  March,
+  April,
+  May,
+  June,
+  July,
+  August,
+  September,
+  October,
+  November,
+  December,
+}
+
+#[napi(js_name = "RRule")]
+pub struct JsRRule {
+  rrule: RRule<Unvalidated>,
+}
+
+#[napi]
+impl JsRRule {
+  #[napi(constructor)]
+  pub fn new(frequency: JsFrequency) -> Self {
+    let rrule = RRule::new(map_js_frequency(frequency));
+
+    JsRRule { rrule }
+  }
+
+  #[napi(getter)]
+  pub fn frequency(&self) -> napi::Result<JsFrequency> {
+    Ok(map_rust_frequency(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 = "Weekday[]")]
+  pub fn by_weekday(&self, env: Env) -> napi::Result<Array> {
+    let ndays = self.rrule.get_by_weekday();
+    let mut arr = env.create_array(0).unwrap();
+
+    for nday in ndays.iter() {
+      let day = match nday {
+        NWeekday::Every(day) => *day,
+        _ => panic!("Unsupported"),
+      };
+
+      arr.insert(map_rust_weekday(day)).unwrap();
+    }
+
+    Ok(arr)
+  }
+
+  #[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).unwrap();
+
+    for month in months.iter() {
+      arr.insert(map_rust_month(month)).unwrap();
+    }
+
+    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<JsWeekday> {
+    Ok(map_rust_weekday(self.rrule.get_week_start()))
+  }
+
+  #[napi(getter)]
+  pub fn until(&self) -> napi::Result<Option<i64>> {
+    Ok(match self.rrule.get_until() {
+      Some(until) => Some(until.timestamp_millis()),
+      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 = "Weekday[]")] weekdays: Array,
+  ) -> napi::Result<&Self> {
+    let mut vec: Vec<NWeekday> = Vec::new();
+
+    for i in 0..weekdays.len() {
+      let day: JsWeekday = weekdays.get(i).unwrap().unwrap();
+      let day = NWeekday::Every(map_js_weekday(day));
+
+      vec.push(day);
+    }
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn set_by_hour(&mut self, 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, 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, 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, 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, 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 = "Month[]")] months: Array,
+  ) -> napi::Result<&Self> {
+    let mut vec: Vec<Month> = Vec::new();
+
+    for i in 0..months.len() {
+      let month: JsMonth = months.get(i).unwrap().unwrap();
+
+      vec.push(map_js_month(month));
+    }
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn set_by_weekno(&mut self, 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, days: Vec<i16>) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule, |self_| self_.by_year_day(days));
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn get_weekstart(&mut self, day: JsWeekday) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule, |self_| {
+      self_.week_start(map_js_weekday(day))
+    });
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn set_until(&mut self, timestamp: i64) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule, |self_| {
+      self_.until(Tz::UTC.timestamp_millis_opt(timestamp).unwrap())
+    });
+
+    Ok(self)
+  }
+
+  pub fn validate(&self, dt_start: DateTime<Tz>) -> RRule {
+    self.rrule.clone().validate(dt_start).unwrap()
+  }
+}
+
+#[napi(js_name = "RRuleSet")]
+pub struct JsRRuleSet {
+  tz: Tz,
+  rrule_set: RRuleSet,
+}
+
+#[napi]
+impl JsRRuleSet {
+  #[napi(constructor)]
+  pub fn new(dtstart: i64, tzid: String) -> Self {
+    let tz = map_js_tz(&tzid);
+    let date = timestamp_to_date_with_tz(dtstart, &tz);
+    let rrule_set = RRuleSet::new(date);
+
+    JsRRuleSet { rrule_set, tz }
+  }
+
+  #[napi]
+  pub fn to_string(&self) -> napi::Result<String> {
+    Ok(self.rrule_set.to_string())
+  }
+
+  #[napi]
+  pub fn rrule(&mut self, js_rrule: &JsRRule) -> 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 exrule(&mut self, js_rrule: &JsRRule) -> 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 after(&mut self, timestamp: i64) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule_set, |self_| {
+      self_.after(timestamp_to_date_with_tz(timestamp, &self.tz))
+    });
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn before(&mut self, timestamp: i64) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule_set, |self_| {
+      self_.before(timestamp_to_date_with_tz(timestamp, &self.tz))
+    });
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn exdate(&mut self, timestamp: i64) -> napi::Result<&Self> {
+    replace_with_or_abort(&mut self.rrule_set, |self_| {
+      self_.exdate(timestamp_to_date_with_tz(timestamp, &self.tz))
+    });
+
+    Ok(self)
+  }
+
+  #[napi]
+  pub fn get_dtstart(&self) -> napi::Result<i64> {
+    Ok(self.rrule_set.get_dt_start().timestamp_millis())
+  }
+
+  #[napi]
+  pub fn get_tzid(&self) -> napi::Result<String> {
+    Ok(String::from(self.tz.name()))
+  }
+
+  /*#[napi(ts_return_type="RRule[]")]
+  pub fn get_rrules(&self, env: Env) -> napi::Result<Array> {
+    let mut arr = env.create_array(0).unwrap();
+    let rrules = self.rrule_set.get_rrule();
+
+    for rrule in rrules.iter() {
+      arr.insert(JsRRule {
+        freq: map_rust_frequency(rrule.get_freq())
+      }).unwrap();
+    }
+
+    Ok(arr)
+  }*/
+
+  #[napi(ts_return_type = "number[]")]
+  pub fn all(&self, env: Env, limit: Option<u32>) -> napi::Result<Array> {
+    let mut arr = env.create_array(0).unwrap();
+    let iter = self.rrule_set.into_iter();
+    let mut left = match limit {
+      Some(number) => number,
+      None => 0,
+    };
+
+    for date in iter {
+      if left > 0 {
+        left = left - 1;
+      } else if limit.is_some() {
+        break;
+      }
+
+      arr.insert(date.timestamp_millis()).unwrap();
+    }
+
+    Ok(arr)
+  }
+}
+
+fn map_rust_frequency(freq: Frequency) -> JsFrequency {
+  match freq {
+    Frequency::Daily => JsFrequency::Daily,
+    Frequency::Hourly => JsFrequency::Hourly,
+    Frequency::Minutely => JsFrequency::Minutely,
+    Frequency::Monthly => JsFrequency::Monthly,
+    Frequency::Secondly => JsFrequency::Secondly,
+    Frequency::Weekly => JsFrequency::Weekly,
+    Frequency::Yearly => JsFrequency::Yearly,
+  }
+}
+
+fn map_js_frequency(freq: JsFrequency) -> Frequency {
+  match freq {
+    JsFrequency::Daily => Frequency::Daily,
+    JsFrequency::Hourly => Frequency::Hourly,
+    JsFrequency::Minutely => Frequency::Minutely,
+    JsFrequency::Monthly => Frequency::Monthly,
+    JsFrequency::Secondly => Frequency::Secondly,
+    JsFrequency::Weekly => Frequency::Weekly,
+    JsFrequency::Yearly => Frequency::Yearly,
+  }
+}
+
+/*fn map_rust_rrule (rrule: RRule) -> JsRRule {
+  JsRRule {
+    freq: map_rust_frequency(rrule.get_freq()),
+    interval: Some(rrule.get_interval()),
+    count: rrule.get_count(),
+    by_weekday:
+  }
+}*/
+
+fn map_js_weekday(weekday: JsWeekday) -> Weekday {
+  match weekday {
+    JsWeekday::Monday => Weekday::Mon,
+    JsWeekday::Tuesday => Weekday::Tue,
+    JsWeekday::Wednesday => Weekday::Wed,
+    JsWeekday::Thursday => Weekday::Thu,
+    JsWeekday::Friday => Weekday::Fri,
+    JsWeekday::Saturday => Weekday::Sat,
+    JsWeekday::Sunday => Weekday::Sun,
+  }
+}
+
+fn map_rust_weekday(weekday: Weekday) -> JsWeekday {
+  match weekday {
+    Weekday::Mon => JsWeekday::Monday,
+    Weekday::Tue => JsWeekday::Tuesday,
+    Weekday::Wed => JsWeekday::Wednesday,
+    Weekday::Thu => JsWeekday::Thursday,
+    Weekday::Fri => JsWeekday::Friday,
+    Weekday::Sat => JsWeekday::Saturday,
+    Weekday::Sun => JsWeekday::Sunday,
+  }
+}
+
+fn map_js_month(month: JsMonth) -> Month {
+  match month {
+    JsMonth::January => Month::January,
+    JsMonth::February => Month::February,
+    JsMonth::March => Month::March,
+    JsMonth::April => Month::April,
+    JsMonth::May => Month::May,
+    JsMonth::June => Month::June,
+    JsMonth::July => Month::July,
+    JsMonth::August => Month::August,
+    JsMonth::September => Month::September,
+    JsMonth::October => Month::October,
+    JsMonth::November => Month::November,
+    JsMonth::December => Month::December,
+  }
+}
+
+fn map_rust_month(month: &u8) -> JsMonth {
+  match month {
+    0 => JsMonth::January,
+    1 => JsMonth::February,
+    2 => JsMonth::March,
+    3 => JsMonth::April,
+    4 => JsMonth::May,
+    5 => JsMonth::June,
+    6 => JsMonth::July,
+    7 => JsMonth::August,
+    8 => JsMonth::September,
+    9 => JsMonth::October,
+    10 => JsMonth::November,
+    11 => JsMonth::December,
+    _ => panic!("Unkown month index: {}", month),
+  }
+}
+
+fn map_js_tz(tz: &str) -> Tz {
+  let chrono_tz = tz.parse().unwrap();
+  Tz::Tz(chrono_tz)
+}
+
+fn timestamp_to_date_with_tz(timestamp: i64, tz: &Tz) -> DateTime<Tz> {
+  Tz::UTC
+    .timestamp_millis_opt(timestamp)
+    .unwrap()
+    .with_timezone(tz)
+}