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

package/index.js

@@ -17,7 +17,7 @@ function isMusl() {
   // For Node 10
   if (!process.report || typeof process.report.getReport !== 'function') {
     try {
-      const lddPath = require('child_process').execSync('which ldd').toString().trim();
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
       return readFileSync(lddPath, 'utf8').includes('musl')
     } catch (e) {
       return true
@@ -224,14 +224,72 @@ switch (platform) {
         }
         break
       case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@rrule-rust/lib-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          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/lib-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@rrule-rust/lib-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'rrule-rust.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rrule-rust.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@rrule-rust/lib-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
         localFileExisted = existsSync(
-          join(__dirname, 'rrule-rust.linux-arm-gnueabihf.node')
+          join(__dirname, 'rrule-rust.linux-s390x-gnu.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./rrule-rust.linux-arm-gnueabihf.node')
+            nativeBinding = require('./rrule-rust.linux-s390x-gnu.node')
           } else {
-            nativeBinding = require('@rrule-rust/lib-linux-arm-gnueabihf')
+            nativeBinding = require('@rrule-rust/lib-linux-s390x-gnu')
           }
         } catch (e) {
           loadError = e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrule-rust",
-  "version": "2.0.0-next.3",
+  "version": "2.0.0-next.6",
   "main": "index.js",
   "types": "index.d.ts",
   "keywords": [
@@ -29,17 +29,19 @@
         "aarch64-unknown-linux-musl",
         "aarch64-pc-windows-msvc",
         "armv7-unknown-linux-gnueabihf",
+        "armv7-unknown-linux-musleabihf",
         "x86_64-unknown-linux-musl",
         "x86_64-unknown-freebsd",
         "i686-pc-windows-msvc",
         "armv7-linux-androideabi",
-        "universal-apple-darwin"
+        "universal-apple-darwin",
+        "riscv64gc-unknown-linux-gnu"
       ]
     }
   },
   "license": "MIT",
   "devDependencies": {
-    "@napi-rs/cli": "^2.15.1",
+    "@napi-rs/cli": "^2.18.2",
     "@semantic-release/git": "^10.0.1",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.5",
@@ -82,23 +84,25 @@
     "version": "napi version",
     "benchmark": "ts-node ./benchmark/index.ts",
     "lint": "cargo fmt --all -- --check && eslint \"**/*.{js,ts,json}\" --max-warnings=0",
-    "lint:fix": "cargo fmt --all && yarn lint --fix",
+    "lint:fix": "cargo fmt --all && npm run lint --fix",
     "lint:fix-staged": "lint-staged"
   },
   "optionalDependencies": {
-    "@rrule-rust/lib-win32-x64-msvc": "2.0.0-next.3",
-    "@rrule-rust/lib-darwin-x64": "2.0.0-next.3",
-    "@rrule-rust/lib-linux-x64-gnu": "2.0.0-next.3",
-    "@rrule-rust/lib-darwin-arm64": "2.0.0-next.3",
-    "@rrule-rust/lib-android-arm64": "2.0.0-next.3",
-    "@rrule-rust/lib-linux-arm64-gnu": "2.0.0-next.3",
-    "@rrule-rust/lib-linux-arm64-musl": "2.0.0-next.3",
-    "@rrule-rust/lib-win32-arm64-msvc": "2.0.0-next.3",
-    "@rrule-rust/lib-linux-arm-gnueabihf": "2.0.0-next.3",
-    "@rrule-rust/lib-linux-x64-musl": "2.0.0-next.3",
-    "@rrule-rust/lib-freebsd-x64": "2.0.0-next.3",
-    "@rrule-rust/lib-win32-ia32-msvc": "2.0.0-next.3",
-    "@rrule-rust/lib-android-arm-eabi": "2.0.0-next.3",
-    "@rrule-rust/lib-darwin-universal": "2.0.0-next.3"
+    "@rrule-rust/lib-win32-x64-msvc": "2.0.0-next.6",
+    "@rrule-rust/lib-darwin-x64": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-x64-gnu": "2.0.0-next.6",
+    "@rrule-rust/lib-darwin-arm64": "2.0.0-next.6",
+    "@rrule-rust/lib-android-arm64": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-arm64-gnu": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-arm64-musl": "2.0.0-next.6",
+    "@rrule-rust/lib-win32-arm64-msvc": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-arm-gnueabihf": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-arm-musleabihf": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-x64-musl": "2.0.0-next.6",
+    "@rrule-rust/lib-freebsd-x64": "2.0.0-next.6",
+    "@rrule-rust/lib-win32-ia32-msvc": "2.0.0-next.6",
+    "@rrule-rust/lib-android-arm-eabi": "2.0.0-next.6",
+    "@rrule-rust/lib-darwin-universal": "2.0.0-next.6",
+    "@rrule-rust/lib-linux-riscv64-gnu": "2.0.0-next.6"
   }
 }

package/.eslintrc.js

@@ -1,58 +0,0 @@
-module.exports = {
-  root: true,
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:prettier/recommended',
-    'plugin:import/recommended',
-    'plugin:import/typescript',
-    'plugin:eslint-comments/recommended',
-  ],
-  plugins: ['@typescript-eslint'],
-  ignorePatterns: ['node_modules', '/target', '/index.d.ts', '/index.js'],
-  env: {
-    node: true,
-  },
-  overrides: [
-    {
-      files: ['*.ts'],
-      extends: [
-        'eslint:recommended',
-        'plugin:@typescript-eslint/recommended',
-        'plugin:prettier/recommended',
-        'plugin:import/recommended',
-        'plugin:import/typescript',
-      ],
-      parserOptions: {
-        project: ['tsconfig.eslint.json'],
-      },
-      rules: {
-        '@typescript-eslint/interface-name-prefix': 'off',
-        '@typescript-eslint/explicit-function-return-type': 'off',
-        '@typescript-eslint/explicit-module-boundary-types': 'off',
-        '@typescript-eslint/no-explicit-any': 'off',
-        '@typescript-eslint/ban-ts-comment': 'off',
-        'import/no-cycle': 'error',
-        'import/no-unresolved': 'error',
-        '@typescript-eslint/no-for-in-array': 'error',
-        'no-implied-eval': 'off',
-        '@typescript-eslint/no-implied-eval': 'error',
-        '@typescript-eslint/no-misused-promises': 'error',
-        'require-await': 'off',
-        '@typescript-eslint/require-await': 'error',
-        '@typescript-eslint/restrict-plus-operands': 'error',
-        '@typescript-eslint/unbound-method': 'error',
-        'import/no-default-export': 'error',
-        'eslint-comments/require-description': 'error',
-        'eslint-comments/disable-enable-pair': 'off',
-        'eslint-comments/no-unlimited-disable': 'off',
-      },
-      settings: {
-        'import/parsers': {
-          '@typescript-eslint/parser': ['.ts'],
-        },
-      },
-      reportUnusedDisableDirectives: true,
-    },
-  ],
-};

package/.prettierrc

@@ -1,4 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all"
-}

package/.releaserc

@@ -1,47 +0,0 @@
-{
-  "plugins": [
-    [
-      "@semantic-release/commit-analyzer",
-      {
-        "preset": "angular",
-        "releaseRules": [
-          { "type": "docs", "release": "patch" },
-          { "type": "perf", "release": "patch" },
-          { "type": "revert", "release": "patch" }
-        ]
-      }
-    ], 
-    [
-      "@semantic-release/release-notes-generator",
-      {
-        "parserOpts": {
-          "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES", "BREAKING"]
-        },
-        "preset": "conventionalcommits",
-        "presetConfig": {
-          "types": [
-            { "type": "build", "section": "Build System", "hidden": false },
-            { "type": "chore", "section": "Build System", "hidden": false },
-            { "type": "chore", "scope": "merge", "section": "Build System", "hidden": true },
-            { "type": "ci", "section": "Continuous Integration", "hidden": false },
-            { "type": "docs", "section": "Documentation", "hidden": false },
-            { "type": "feat", "section": "Features", "hidden": false },
-            { "type": "fix", "section": "Bug Fixes", "hidden": false },
-            { "type": "perf", "section": "Performance Improvements", "hidden": false },
-            { "type": "refactor", "section": "Code Refactoring", "hidden": false },
-            { "type": "revert", "section": "Reverted Changes", "hidden": false },
-            { "type": "style", "section": "Styles", "hidden": false },
-            { "type": "test", "section": "Tests", "hidden": false }
-          ]
-        },
-        "writerOpts": {
-          "commitsSort": ["subject", "scope"]
-        }
-      }
-    ],
-    "@semantic-release/npm", 
-    "@semantic-release/git",
-    "@semantic-release/github"
-  ],
-  "branches": ["+([0-9])?(.{+([0-9]),x}).x", "master", {"name": "next", "prerelease": true}]
-}

package/.yarnrc.yml

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

package/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-edition = "2021"
-name = "rrule-rust"
-version = "0.0.0"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-chrono = "0.4.24"
-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.12.0", features = ["exrule"] }
-
-[build-dependencies]
-napi-build = "2.0.1"
-
-[profile.release]
-lto = true

package/benchmark/.gitignore

@@ -1,3 +0,0 @@
-*
-!index.ts
-!.gitignore

package/benchmark/index.ts

@@ -1,59 +0,0 @@
-import b from 'benny';
-import * as node from 'rrule';
-import * as rust from '../';
-
-b.suite(
-  'UTC TZ',
-  b.add('rrule-rust', () => {
-    const rrule = new rust.RRule(rust.Frequency.Daily)
-      .setCount(30)
-      .setInterval(1);
-    const set = new rust.RRuleSet(
-      new rust.RRuleDateTime(new Date(1679428740000), 'UTC'),
-    ).addRrule(rrule);
-
-    set.all();
-  }),
-  b.add('rrule', () => {
-    const rrule = new node.RRule({
-      freq: node.RRule.DAILY,
-      dtstart: new Date(Date.UTC(2023, 2, 21, 23, 59, 0)),
-      tzid: 'UTC',
-      count: 30,
-      interval: 1,
-    });
-
-    rrule.all();
-  }),
-
-  b.cycle(),
-  b.complete(),
-);
-
-b.suite(
-  'Other TZ',
-  b.add('rrule-rust', () => {
-    const rrule = new rust.RRule(rust.Frequency.Daily)
-      .setCount(30)
-      .setInterval(1);
-    const set = new rust.RRuleSet(
-      new rust.RRuleDateTime(new Date(1679428740000), 'Pacific/Kiritimati'),
-    ).addRrule(rrule);
-
-    set.all();
-  }),
-  b.add('rrule', () => {
-    const rrule = new node.RRule({
-      freq: node.RRule.DAILY,
-      dtstart: new Date(Date.UTC(2023, 2, 21, 23, 59, 0)),
-      tzid: 'Pacific/Kiritimati',
-      count: 30,
-      interval: 1,
-    });
-
-    rrule.all();
-  }),
-
-  b.cycle(),
-  b.complete(),
-);

package/build.rs

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

package/jest.config.ts

@@ -1,7 +0,0 @@
-/* eslint-disable import/no-default-export -- Required by jest */
-import { Config } from 'jest';
-
-export default {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-} satisfies Config;

package/src/js/frequency.rs

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

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

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

@@ -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()))
-  }
-}

package/src/js/weekday.rs

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

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

package/src/lib.rs

@@ -1 +0,0 @@
-mod js;

package/tsconfig.eslint.json

@@ -1,6 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  }
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "es2017",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./",
-    "incremental": true,
-    "removeComments": true,
-    "allowUnreachableCode": false,
-    "allowUnusedLabels": false,
-    "noFallthroughCasesInSwitch": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "strict": true
-  }
-}