rrule-rust 3.0.0-alpha.1 → 3.0.0-alpha.3

package/README.md

@@ -16,14 +16,12 @@
   npm i rrule-rust
 ```
 
-If you need a browser-compatible version with WASM support, install it from the `alpha` channel:
+If you need a browser-compatible version with WASM support:
 
 ```
-  npm i rrule-rust@alpha
+  npm i rrule-rust --cpu "wasm32"
 ```
 
-> The WebAssembly (WASM) version is currently available on the `alpha` channel, as it relies on an alpha release of [napi.rs](https://napi.rs/). Once napi.rs v3 is officially released, WASM support will be included in the main (`latest`) release channel.
-
 For more usage examples and advanced scenarios, see the [tests directory](https://github.com/lsndr/rrule-rust/tree/master/tests) in the repository.
 
 ```typescript

package/dist/browser/datetime.js

@@ -0,0 +1,120 @@
+/**
+ * Represents a date and time. Either local or UTC.
+ */
+export class DateTime {
+    constructor(numeric) {
+        this.numeric = numeric;
+    }
+    get year() {
+        return Math.floor(this.numeric / 100000000000);
+    }
+    get month() {
+        return Math.floor((this.numeric / 1000000000) % 100);
+    }
+    get day() {
+        return Math.floor((this.numeric / 10000000) % 100);
+    }
+    get hour() {
+        return Math.floor((this.numeric / 100000) % 100);
+    }
+    get minute() {
+        return Math.floor((this.numeric / 1000) % 100);
+    }
+    get second() {
+        return Math.floor((this.numeric / 10) % 100);
+    }
+    get utc() {
+        return this.numeric % 10 == 1;
+    }
+    /**
+     * Creates a new DateTime object from the given date and time components.
+     */
+    static create(year, month, day, hour, minute, second, utc) {
+        const numeric = year * 100000000000 +
+            month * 1000000000 +
+            day * 10000000 +
+            hour * 100000 +
+            minute * 1000 +
+            second * 10 +
+            (utc ? 1 : 0);
+        return new DateTime(numeric);
+    }
+    /**
+     * This method is shorthand for `DateTime.create` with `utc` set to `false`.
+     */
+    static local(year, month, day, hour, minute, second) {
+        return DateTime.create(year, month, day, hour, minute, second, false);
+    }
+    /**
+     * This method is shorthand for `DateTime.create` with `utc` set to `true`.
+     */
+    static utc(year, month, day, hour, minute, second) {
+        return DateTime.create(year, month, day, hour, minute, second, true);
+    }
+    /**
+     * Creates a new DateTime object from the given plain object.
+     */
+    static fromObject(object, options) {
+        return DateTime.create(object.year, object.month, object.day, object.hour, object.minute, object.second, !!options?.utc);
+    }
+    /**
+     * Creates a new DateTime object from provided string representation of a date according to RFC 5545.
+     */
+    static fromString(str) {
+        const typeError = new TypeError('Invalid date time string');
+        if (str.length > 16 || str.length < 15) {
+            throw typeError;
+        }
+        const year = parseInt(str.slice(0, 4));
+        const month = parseInt(str.slice(4, 6));
+        const day = parseInt(str.slice(6, 8));
+        const hour = parseInt(str.slice(9, 11));
+        const minute = parseInt(str.slice(11, 13));
+        const second = parseInt(str.slice(13, 15));
+        const utc = str.endsWith('Z');
+        if (isNaN(year) ||
+            isNaN(month) ||
+            isNaN(day) ||
+            isNaN(hour) ||
+            isNaN(minute) ||
+            isNaN(second)) {
+            throw typeError;
+        }
+        return DateTime.create(year, month, day, hour, minute, second, utc);
+    }
+    /** @internal */
+    static fromNumeric(numeric) {
+        return new DateTime(numeric);
+    }
+    /**
+     * Converts DateTime into a plain object.
+     */
+    toObject() {
+        return {
+            year: this.year,
+            month: this.month,
+            day: this.day,
+            hour: this.hour,
+            minute: this.minute,
+            second: this.second,
+        };
+    }
+    /**
+     * Converts DateTime into ISO 8601 string:
+     * - `YYYYMMDDTHHMMSSZ` for UTC
+     * - `YYYYMMDDTHHMMSS` for local
+     */
+    toString() {
+        const year = this.year.toString().padStart(4, '0');
+        const month = this.month.toString().padStart(2, '0');
+        const day = this.day.toString().padStart(2, '0');
+        const hour = this.hour.toString().padStart(2, '0');
+        const minute = this.minute.toString().padStart(2, '0');
+        const second = this.second.toString().padStart(2, '0');
+        return `${year}${month}${day}T${hour}${minute}${second}${this.utc ? 'Z' : ''}`;
+    }
+    /** @internal */
+    toNumeric() {
+        return this.numeric;
+    }
+}

package/dist/browser/index.js

@@ -0,0 +1,3 @@
+export * from './rrule-set';
+export * from './rrule';
+export * from './datetime';

package/dist/browser/lib/index.js

@@ -0,0 +1 @@
+export * from '@rrule-rust/lib-wasm32-wasi'

package/dist/browser/rrule-set.js

@@ -0,0 +1,185 @@
+import { RRule } from './rrule';
+import { RRuleSet as Rust } from './lib';
+import { DateTime } from './datetime';
+export class RRuleSet {
+    constructor(setOrDtstart, tzid) {
+        if (!(setOrDtstart instanceof DateTime)) {
+            if (setOrDtstart?.dtstart) {
+                this.dtstart = setOrDtstart?.dtstart;
+            }
+            else {
+                const date = new Date();
+                this.dtstart = DateTime.create(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), true);
+            }
+            this.tzid = setOrDtstart?.tzid ?? 'UTC';
+            this.rrules = setOrDtstart?.rrules ?? [];
+            this.exrules = setOrDtstart?.exrules ?? [];
+            this.exdates = setOrDtstart?.exdates ?? [];
+            this.rdates = setOrDtstart?.rdates ?? [];
+        }
+        else if (setOrDtstart instanceof DateTime && typeof tzid === 'string') {
+            this.dtstart = setOrDtstart;
+            this.tzid = tzid;
+            this.rrules = [];
+            this.exrules = [];
+            this.exdates = [];
+            this.rdates = [];
+        }
+        else {
+            throw new TypeError('Invalid arguments');
+        }
+    }
+    /**
+     * Parses a string into an RRuleSet.
+     */
+    static parse(str) {
+        const rust = Rust.parse(str);
+        return this.fromRust(rust);
+    }
+    /**
+     * @internal
+     */
+    static fromRust(rust) {
+        const set = new RRuleSet({
+            dtstart: DateTime.fromNumeric(rust.dtstart),
+            tzid: rust.tzid ?? undefined,
+            rrules: rust.rrules.map((rrule) => RRule.fromRust(rrule)),
+            exrules: rust.exrules.map((rrule) => RRule.fromRust(rrule)),
+            exdates: rust.exdates.map((datetime) => DateTime.fromNumeric(datetime)),
+            rdates: rust.rdates.map((datetime) => DateTime.fromNumeric(datetime)),
+        });
+        set.rust = rust;
+        return set;
+    }
+    setDtstart(dtstart) {
+        return new RRuleSet({
+            ...this.toObject(),
+            dtstart: dtstart,
+        });
+    }
+    setTzid(tzid) {
+        return new RRuleSet({
+            ...this.toObject(),
+            tzid: tzid,
+        });
+    }
+    addRrule(rrule) {
+        return new RRuleSet({
+            ...this.toObject(),
+            rrules: [...this.rrules, rrule],
+        });
+    }
+    setRrules(rrules) {
+        return new RRuleSet({
+            ...this.toObject(),
+            rrules: rrules,
+        });
+    }
+    addExrule(rrule) {
+        return new RRuleSet({
+            ...this.toObject(),
+            exrules: [...this.exrules, rrule],
+        });
+    }
+    setExrules(rrules) {
+        return new RRuleSet({
+            ...this.toObject(),
+            exrules: rrules,
+        });
+    }
+    addExdate(datetime) {
+        return new RRuleSet({
+            ...this.toObject(),
+            exdates: [...this.exdates, datetime],
+        });
+    }
+    setExdates(datetimes) {
+        return new RRuleSet({
+            ...this.toObject(),
+            exdates: datetimes,
+        });
+    }
+    addRdate(datetime) {
+        return new RRuleSet({
+            ...this.toObject(),
+            rdates: [...this.rdates, datetime],
+        });
+    }
+    setRdates(datetimes) {
+        return new RRuleSet({
+            ...this.toObject(),
+            rdates: datetimes,
+        });
+    }
+    /**
+     * Returns all the occurrences of the rrule.
+     *
+     * @param limit - The maximum number of occurrences to return.
+     */
+    all(limit) {
+        return this.toRust()
+            .all(limit)
+            .map((datetime) => DateTime.fromNumeric(datetime));
+    }
+    /**
+     * Returns all the occurrences of the rrule between after and before.
+     *
+     * @param after - The lower bound date.
+     * @param before - The upper bound date.
+     * @param inclusive - Whether to include after and before in the list of occurrences.
+     */
+    between(after, before, inclusive) {
+        return this.toRust()
+            .between(after.toNumeric(), before.toNumeric(), inclusive)
+            .map((datetime) => DateTime.fromNumeric(datetime));
+    }
+    /**
+     * Sets the RRuleSet from a string.
+     *
+     * @param str - The string to parse.
+     */
+    setFromString(str) {
+        return RRuleSet.fromRust(this.toRust().setFromString(str));
+    }
+    /**
+     * @internal
+     */
+    toRust() {
+        this.rust ??= new Rust(this.dtstart.toNumeric(), this.tzid, this.rrules.map((rrule) => rrule.toRust()), this.exrules.map((rrule) => rrule.toRust()), this.exdates.map((datetime) => datetime.toNumeric()), this.rdates.map((datetime) => datetime.toNumeric()));
+        return this.rust;
+    }
+    toString() {
+        return this.toRust().toString();
+    }
+    /**
+     * Converts the RRuleSet to a plain object.
+     */
+    toObject() {
+        return {
+            dtstart: this.dtstart,
+            tzid: this.tzid,
+            rrules: this.rrules,
+            exrules: this.exrules,
+            exdates: this.exdates,
+            rdates: this.rdates,
+        };
+    }
+    [Symbol.iterator]() {
+        const iter = this.toRust().iterator();
+        return {
+            next: () => {
+                const result = iter.next();
+                if (result === null) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                return {
+                    done: false,
+                    value: DateTime.fromNumeric(result),
+                };
+            },
+        };
+    }
+}

package/dist/browser/rrule.js

@@ -0,0 +1,169 @@
+import { DateTime } from './datetime';
+import { RRule as Rust } from './lib';
+export var Frequency;
+(function (Frequency) {
+    Frequency[Frequency["Yearly"] = 0] = "Yearly";
+    Frequency[Frequency["Monthly"] = 1] = "Monthly";
+    Frequency[Frequency["Weekly"] = 2] = "Weekly";
+    Frequency[Frequency["Daily"] = 3] = "Daily";
+    Frequency[Frequency["Hourly"] = 4] = "Hourly";
+    Frequency[Frequency["Minutely"] = 5] = "Minutely";
+    Frequency[Frequency["Secondly"] = 6] = "Secondly";
+})(Frequency || (Frequency = {}));
+export var Month;
+(function (Month) {
+    Month[Month["January"] = 1] = "January";
+    Month[Month["February"] = 2] = "February";
+    Month[Month["March"] = 3] = "March";
+    Month[Month["April"] = 4] = "April";
+    Month[Month["May"] = 5] = "May";
+    Month[Month["June"] = 6] = "June";
+    Month[Month["July"] = 7] = "July";
+    Month[Month["August"] = 8] = "August";
+    Month[Month["September"] = 9] = "September";
+    Month[Month["October"] = 10] = "October";
+    Month[Month["November"] = 11] = "November";
+    Month[Month["December"] = 12] = "December";
+})(Month || (Month = {}));
+export var Weekday;
+(function (Weekday) {
+    Weekday[Weekday["Monday"] = 0] = "Monday";
+    Weekday[Weekday["Tuesday"] = 1] = "Tuesday";
+    Weekday[Weekday["Wednesday"] = 2] = "Wednesday";
+    Weekday[Weekday["Thursday"] = 3] = "Thursday";
+    Weekday[Weekday["Friday"] = 4] = "Friday";
+    Weekday[Weekday["Saturday"] = 5] = "Saturday";
+    Weekday[Weekday["Sunday"] = 6] = "Sunday";
+})(Weekday || (Weekday = {}));
+export class RRule {
+    constructor(rruleOrFrequency = {}) {
+        if (typeof rruleOrFrequency === 'object' && rruleOrFrequency !== null) {
+            this.frequency = rruleOrFrequency.frequency ?? Frequency.Daily;
+            this.interval = rruleOrFrequency.interval;
+            this.until = rruleOrFrequency.until;
+            this.count = rruleOrFrequency.count;
+            this.byWeekday = rruleOrFrequency.byWeekday ?? [];
+            this.byHour = rruleOrFrequency.byHour ?? [];
+            this.byMinute = rruleOrFrequency.byMinute ?? [];
+            this.bySecond = rruleOrFrequency.bySecond ?? [];
+            this.byMonthday = rruleOrFrequency.byMonthday ?? [];
+            this.bySetpos = rruleOrFrequency.bySetpos ?? [];
+            this.byMonth = rruleOrFrequency.byMonth ?? [];
+            this.byWeekno = rruleOrFrequency.byWeekno ?? [];
+            this.byYearday = rruleOrFrequency.byYearday ?? [];
+            this.weekstart = rruleOrFrequency.weekstart;
+        }
+        else {
+            this.frequency = rruleOrFrequency;
+            this.byWeekday = [];
+            this.byHour = [];
+            this.byMinute = [];
+            this.bySecond = [];
+            this.byMonthday = [];
+            this.bySetpos = [];
+            this.byMonth = [];
+            this.byWeekno = [];
+            this.byYearday = [];
+        }
+    }
+    /**
+     * Parses a string into an RRule.
+     */
+    static parse(str) {
+        const rust = Rust.parse(str);
+        return this.fromRust(rust);
+    }
+    /**
+     * @internal
+     */
+    static fromRust(rust) {
+        const rrule = new this({
+            frequency: rust.frequency,
+            interval: rust.interval ?? undefined,
+            until: rust.until === null ? undefined : DateTime.fromNumeric(rust.until),
+            count: rust.count ?? undefined,
+            byWeekday: rust.byWeekday,
+            byHour: rust.byHour,
+            byMinute: rust.byMinute,
+            bySecond: rust.bySecond,
+            byMonthday: rust.byMonthday,
+            bySetpos: rust.bySetpos,
+            byMonth: rust.byMonth,
+            byWeekno: rust.byWeekno,
+            byYearday: rust.byYearday,
+            weekstart: rust.weekstart ?? undefined,
+        });
+        rrule.rust = rust;
+        return rrule;
+    }
+    setFrequency(frequency) {
+        return new RRule({ ...this.toObject(), frequency });
+    }
+    setInterval(interval) {
+        return new RRule({ ...this.toObject(), interval });
+    }
+    setCount(count) {
+        return new RRule({ ...this.toObject(), count });
+    }
+    setByWeekday(weekdays) {
+        return new RRule({ ...this.toObject(), byWeekday: weekdays });
+    }
+    setByHour(hours) {
+        return new RRule({ ...this.toObject(), byHour: hours });
+    }
+    setByMinute(minutes) {
+        return new RRule({ ...this.toObject(), byMinute: minutes });
+    }
+    setBySecond(seconds) {
+        return new RRule({ ...this.toObject(), bySecond: seconds });
+    }
+    setByMonthday(days) {
+        return new RRule({ ...this.toObject(), byMonthday: days });
+    }
+    setBySetpos(poses) {
+        return new RRule({ ...this.toObject(), bySetpos: poses });
+    }
+    setByMonth(months) {
+        return new RRule({ ...this.toObject(), byMonth: months });
+    }
+    setByWeekno(weekNumbers) {
+        return new RRule({ ...this.toObject(), byWeekno: weekNumbers });
+    }
+    setByYearday(days) {
+        return new RRule({ ...this.toObject(), byYearday: days });
+    }
+    setWeekstart(day) {
+        return new RRule({ ...this.toObject(), weekstart: day });
+    }
+    setUntil(datetime) {
+        return new RRule({ ...this.toObject(), until: datetime });
+    }
+    toString() {
+        return this.toRust().toString();
+    }
+    /**
+     * @internal
+     */
+    toRust() {
+        this.rust ??= new Rust(this.frequency, this.interval, this.count, this.weekstart, this.until?.toNumeric(), this.byWeekday, this.byHour, this.byMinute, this.bySecond, this.byMonthday, this.bySetpos, this.byMonth, this.byWeekno, this.byYearday);
+        return this.rust;
+    }
+    toObject() {
+        return {
+            frequency: this.frequency,
+            interval: this.interval,
+            count: this.count,
+            byWeekday: this.byWeekday,
+            byHour: this.byHour,
+            byMinute: this.byMinute,
+            bySecond: this.bySecond,
+            byMonthday: this.byMonthday,
+            bySetpos: this.bySetpos,
+            byMonth: this.byMonth,
+            byWeekno: this.byWeekno,
+            byYearday: this.byYearday,
+            weekstart: this.weekstart,
+            until: this.until,
+        };
+    }
+}

package/dist/node/datetime.d.ts

@@ -0,0 +1,55 @@
+export interface DateTimeLike {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+}
+export interface FromObjectOptions {
+    utc?: boolean;
+}
+/**
+ * Represents a date and time. Either local or UTC.
+ */
+export declare class DateTime implements DateTimeLike {
+    private readonly numeric;
+    private constructor();
+    get year(): number;
+    get month(): number;
+    get day(): number;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get utc(): boolean;
+    /**
+     * Creates a new DateTime object from the given date and time components.
+     */
+    static create(year: number, month: number, day: number, hour: number, minute: number, second: number, utc: boolean): DateTime;
+    /**
+     * This method is shorthand for `DateTime.create` with `utc` set to `false`.
+     */
+    static local(year: number, month: number, day: number, hour: number, minute: number, second: number): DateTime;
+    /**
+     * This method is shorthand for `DateTime.create` with `utc` set to `true`.
+     */
+    static utc(year: number, month: number, day: number, hour: number, minute: number, second: number): DateTime;
+    /**
+     * Creates a new DateTime object from the given plain object.
+     */
+    static fromObject(object: DateTimeLike, options?: FromObjectOptions): DateTime;
+    /**
+     * Creates a new DateTime object from provided string representation of a date according to RFC 5545.
+     */
+    static fromString(str: string): DateTime;
+    /**
+     * Converts DateTime into a plain object.
+     */
+    toObject(): DateTimeLike;
+    /**
+     * Converts DateTime into ISO 8601 string:
+     * - `YYYYMMDDTHHMMSSZ` for UTC
+     * - `YYYYMMDDTHHMMSS` for local
+     */
+    toString(): string;
+}

package/dist/node/index.d.ts

@@ -0,0 +1,3 @@
+export * from './rrule-set';
+export * from './rrule';
+export * from './datetime';

package/dist/node/lib/rrule-rust.wasi.cjs

@@ -0,0 +1,116 @@
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const __nodeFs = require('node:fs')
+const __nodePath = require('node:path')
+const { WASI: __nodeWASI } = require('node:wasi')
+const { Worker } = require('node:worker_threads')
+
+const {
+  createOnMessage: __wasmCreateOnMessageForFsProxy,
+  getDefaultContext: __emnapiGetDefaultContext,
+  instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync,
+} = require('@napi-rs/wasm-runtime')
+
+const __rootDir = __nodePath.parse(process.cwd()).root
+
+const __wasi = new __nodeWASI({
+  version: 'preview1',
+  env: process.env,
+  preopens: {
+    [__rootDir]: __rootDir,
+  }
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 4000,
+  maximum: 65536,
+  shared: true,
+})
+
+let __wasmFilePath = __nodePath.join(__dirname, 'rrule-rust.wasm32-wasi.wasm')
+const __wasmDebugFilePath = __nodePath.join(__dirname, 'rrule-rust.wasm32-wasi.debug.wasm')
+
+if (__nodeFs.existsSync(__wasmDebugFilePath)) {
+  __wasmFilePath = __wasmDebugFilePath
+} else if (!__nodeFs.existsSync(__wasmFilePath)) {
+  try {
+    __wasmFilePath = __nodePath.resolve('@rrule-rust/lib-wasm32-wasi')
+  } catch {
+    throw new Error('Cannot find rrule-rust.wasm32-wasi.wasm file, and @rrule-rust/lib-wasm32-wasi package is not installed.')
+  }
+}
+
+const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__wasmFilePath), {
+  context: __emnapiContext,
+  asyncWorkPoolSize: (function() {
+    const threadsSizeFromEnv = Number(process.env.NAPI_RS_ASYNC_WORK_POOL_SIZE ?? process.env.UV_THREADPOOL_SIZE)
+    // NaN > 0 is false
+    if (threadsSizeFromEnv > 0) {
+      return threadsSizeFromEnv
+    } else {
+      return 4
+    }
+  })(),
+  reuseWorker: true,
+  wasi: __wasi,
+  onCreateWorker() {
+    const worker = new Worker(__nodePath.join(__dirname, 'wasi-worker.mjs'), {
+      env: process.env,
+    })
+    worker.onmessage = ({ data }) => {
+      __wasmCreateOnMessageForFsProxy(__nodeFs)(data)
+    }
+
+    // The main thread of Node.js waits for all the active handles before exiting.
+    // But Rust threads are never waited without `thread::join`.
+    // So here we hack the code of Node.js to prevent the workers from being referenced (active).
+    // According to https://github.com/nodejs/node/blob/19e0d472728c79d418b74bddff588bea70a403d0/lib/internal/worker.js#L415,
+    // a worker is consist of two handles: kPublicPort and kHandle.
+    {
+      const kPublicPort = Object.getOwnPropertySymbols(worker).find(s =>
+        s.toString().includes("kPublicPort")
+      );
+      if (kPublicPort) {
+        worker[kPublicPort].ref = () => {};
+      }
+
+      const kHandle = Object.getOwnPropertySymbols(worker).find(s =>
+        s.toString().includes("kHandle")
+      );
+      if (kHandle) {
+        worker[kHandle].ref = () => {};
+      }
+
+      worker.unref();
+    }
+    return worker
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    for (const name of Object.keys(instance.exports)) {
+      if (name.startsWith('__napi_register__')) {
+        instance.exports[name]()
+      }
+    }
+  },
+})
+module.exports = __napiModule.exports
+module.exports.RRule = __napiModule.exports.RRule
+module.exports.RRuleSet = __napiModule.exports.RRuleSet
+module.exports.RRuleSetIterator = __napiModule.exports.RRuleSetIterator
+module.exports.Frequency = __napiModule.exports.Frequency
+module.exports.Month = __napiModule.exports.Month
+module.exports.Weekday = __napiModule.exports.Weekday

package/dist/node/rrule-set.d.ts

@@ -0,0 +1,60 @@
+import { RRule } from './rrule';
+import { DateTime } from './datetime';
+export interface RRuleSetLike {
+    readonly dtstart: DateTime;
+    readonly tzid?: string;
+    readonly rrules: readonly RRule[];
+    readonly exrules: readonly RRule[];
+    readonly exdates: readonly DateTime[];
+    readonly rdates: readonly DateTime[];
+}
+export declare class RRuleSet implements Iterable<DateTime> {
+    readonly dtstart: DateTime;
+    readonly tzid: string;
+    readonly rrules: readonly RRule[];
+    readonly exrules: readonly RRule[];
+    readonly exdates: readonly DateTime[];
+    readonly rdates: readonly DateTime[];
+    constructor(dtstart: DateTime, tzid?: string);
+    constructor(options: Partial<RRuleSetLike>);
+    /**
+     * Parses a string into an RRuleSet.
+     */
+    static parse(str: string): RRuleSet;
+    setDtstart(dtstart: DateTime): RRuleSet;
+    setTzid(tzid: string): RRuleSet;
+    addRrule(rrule: RRule): RRuleSet;
+    setRrules(rrules: readonly RRule[]): RRuleSet;
+    addExrule(rrule: RRule): RRuleSet;
+    setExrules(rrules: readonly RRule[]): RRuleSet;
+    addExdate(datetime: DateTime): RRuleSet;
+    setExdates(datetimes: readonly DateTime[]): RRuleSet;
+    addRdate(datetime: DateTime): RRuleSet;
+    setRdates(datetimes: readonly DateTime[]): RRuleSet;
+    /**
+     * Returns all the occurrences of the rrule.
+     *
+     * @param limit - The maximum number of occurrences to return.
+     */
+    all(limit?: number): DateTime[];
+    /**
+     * Returns all the occurrences of the rrule between after and before.
+     *
+     * @param after - The lower bound date.
+     * @param before - The upper bound date.
+     * @param inclusive - Whether to include after and before in the list of occurrences.
+     */
+    between(after: DateTime, before: DateTime, inclusive?: boolean): DateTime[];
+    /**
+     * Sets the RRuleSet from a string.
+     *
+     * @param str - The string to parse.
+     */
+    setFromString(str: string): RRuleSet;
+    toString(): string;
+    /**
+     * Converts the RRuleSet to a plain object.
+     */
+    toObject(): RRuleSetLike;
+    [Symbol.iterator](): Iterator<DateTime, any, any>;
+}

package/dist/node/rrule.d.ts

@@ -0,0 +1,97 @@
+import { DateTime } from './datetime';
+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 declare enum Frequency {
+    Yearly = 0,
+    Monthly = 1,
+    Weekly = 2,
+    Daily = 3,
+    Hourly = 4,
+    Minutely = 5,
+    Secondly = 6
+}
+export declare enum Month {
+    January = 1,
+    February = 2,
+    March = 3,
+    April = 4,
+    May = 5,
+    June = 6,
+    July = 7,
+    August = 8,
+    September = 9,
+    October = 10,
+    November = 11,
+    December = 12
+}
+export declare enum Weekday {
+    Monday = 0,
+    Tuesday = 1,
+    Wednesday = 2,
+    Thursday = 3,
+    Friday = 4,
+    Saturday = 5,
+    Sunday = 6
+}
+export interface RRuleLike {
+    readonly frequency: Frequency;
+    readonly interval?: number;
+    readonly count?: number;
+    readonly until?: DateTime;
+    readonly byWeekday: readonly (NWeekday | Weekday)[];
+    readonly byHour: readonly number[];
+    readonly byMinute: readonly number[];
+    readonly bySecond: readonly number[];
+    readonly byMonthday: readonly number[];
+    readonly bySetpos: readonly number[];
+    readonly byMonth: readonly Month[];
+    readonly byWeekno: readonly number[];
+    readonly byYearday: readonly number[];
+    readonly weekstart?: Weekday;
+}
+export declare class RRule {
+    readonly frequency: Frequency;
+    readonly interval?: number;
+    readonly until?: DateTime;
+    readonly count?: number;
+    readonly byWeekday: readonly (NWeekday | Weekday)[];
+    readonly byHour: readonly number[];
+    readonly byMinute: readonly number[];
+    readonly bySecond: readonly number[];
+    readonly byMonthday: readonly number[];
+    readonly bySetpos: readonly number[];
+    readonly byMonth: readonly Month[];
+    readonly byWeekno: readonly number[];
+    readonly byYearday: readonly number[];
+    readonly weekstart?: Weekday;
+    constructor(frequency: Frequency);
+    constructor(rrule?: Partial<RRuleLike>);
+    /**
+     * Parses a string into an RRule.
+     */
+    static parse(str: string): RRule;
+    setFrequency(frequency: Frequency): RRule;
+    setInterval(interval: number): RRule;
+    setCount(count: number): RRule;
+    setByWeekday(weekdays: readonly (NWeekday | Weekday)[]): RRule;
+    setByHour(hours: readonly number[]): RRule;
+    setByMinute(minutes: readonly number[]): RRule;
+    setBySecond(seconds: readonly number[]): RRule;
+    setByMonthday(days: readonly number[]): RRule;
+    setBySetpos(poses: readonly number[]): RRule;
+    setByMonth(months: readonly Month[]): RRule;
+    setByWeekno(weekNumbers: readonly number[]): RRule;
+    setByYearday(days: readonly number[]): RRule;
+    setWeekstart(day: Weekday): RRule;
+    setUntil(datetime: DateTime): RRule;
+    toString(): string;
+    toObject(): RRuleLike;
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "rrule-rust",
-  "version": "3.0.0-alpha.1",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "3.0.0-alpha.3",
+  "main": "dist/node/index.js",
+  "browser": "dist/browser/index.js",
   "keywords": [
     "rrule",
     "icalendar",
     "rust",
+    "wasm",
     "rs"
   ],
-  "description": "RRule implementation for Node.js written in Rust",
+  "description": "RRule implementation for browsers and Node.js written in Rust",
   "repository": "lsndr/rrule-rust",
   "author": {
     "name": "lsndr",
@@ -32,11 +33,13 @@
       "x86_64-unknown-freebsd",
       "aarch64-unknown-linux-musl",
       "aarch64-pc-windows-msvc",
-      "armv7-linux-androideabi"
+      "armv7-linux-androideabi",
+      "wasm32-wasip1-threads"
     ]
   },
   "license": "MIT",
   "devDependencies": {
+    "@atao60/fse-cli": "^0.1.9",
     "@commitlint/cli": "^19.3.0",
     "@commitlint/config-conventional": "^19.2.2",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
@@ -49,7 +52,6 @@
     "@types/node": "^22.1.0",
     "benny": "^3.7.1",
     "conventional-changelog-conventionalcommits": "^7.0.2",
-    "cpy-cli": "^5.0.0",
     "cross-env": "^7.0.3",
     "eslint": "^9.27.0",
     "eslint-config-prettier": "^10.1.5",
@@ -72,12 +74,15 @@
     "node": ">= 10"
   },
   "scripts": {
-    "artifacts": "napi artifacts",
+    "artifacts": "napi artifacts --build-output-dir src/lib",
     "build:lib": "napi build --no-const-enum --platform --release --output-dir src/lib",
-    "prebuild": "rimraf ./dist && npm run build:lib",
-    "build": "tsc -p ./tsconfig.build.json",
+    "prebuild": "fse remove --quiet ./dist",
+    "build": "npm run build:lib && npm run build:node && npm run build:browser",
+    "prebuild:node": "fse remove --quiet ./dist/node",
+    "build:node": "tsc -p ./tsconfig.node.json && fse copy --quiet ./src/lib/index.js ./dist/node/lib/index.js && fse copy --quiet ./src/lib/rrule-rust.wasi.cjs ./dist/node/lib/rrule-rust.wasi.cjs",
+    "prebuild:browser": "fse remove --quiet ./dist/browser",
+    "build:browser": "tsc -p ./tsconfig.browser.json && fse copy --quiet ./src/lib/browser.js ./dist/browser/lib/index.js",
     "build:tests": "tsc -p ./tsconfig.test.json",
-    "postbuild": "cpy ./src/lib/* ./dist/lib --flat",
     "test": "cross-env TZ=Europe/Moscow jest --testPathIgnorePatterns=\\.e2e\\.spec\\.ts",
     "test:e2e": "jest --testMatch='**/*.e2e.spec.ts' --runInBand",
     "universal": "napi universal",
@@ -91,18 +96,19 @@
     "prepublishOnly": "npm run build && napi prepublish -t npm"
   },
   "optionalDependencies": {
-    "@rrule-rust/lib-win32-x64-msvc": "3.0.0-alpha.1",
-    "@rrule-rust/lib-darwin-x64": "3.0.0-alpha.1",
-    "@rrule-rust/lib-linux-x64-gnu": "3.0.0-alpha.1",
-    "@rrule-rust/lib-linux-x64-musl": "3.0.0-alpha.1",
-    "@rrule-rust/lib-linux-arm64-gnu": "3.0.0-alpha.1",
-    "@rrule-rust/lib-win32-ia32-msvc": "3.0.0-alpha.1",
-    "@rrule-rust/lib-linux-arm-gnueabihf": "3.0.0-alpha.1",
-    "@rrule-rust/lib-darwin-arm64": "3.0.0-alpha.1",
-    "@rrule-rust/lib-android-arm64": "3.0.0-alpha.1",
-    "@rrule-rust/lib-freebsd-x64": "3.0.0-alpha.1",
-    "@rrule-rust/lib-linux-arm64-musl": "3.0.0-alpha.1",
-    "@rrule-rust/lib-win32-arm64-msvc": "3.0.0-alpha.1",
-    "@rrule-rust/lib-android-arm-eabi": "3.0.0-alpha.1"
+    "@rrule-rust/lib-win32-x64-msvc": "3.0.0-alpha.3",
+    "@rrule-rust/lib-darwin-x64": "3.0.0-alpha.3",
+    "@rrule-rust/lib-linux-x64-gnu": "3.0.0-alpha.3",
+    "@rrule-rust/lib-linux-x64-musl": "3.0.0-alpha.3",
+    "@rrule-rust/lib-linux-arm64-gnu": "3.0.0-alpha.3",
+    "@rrule-rust/lib-win32-ia32-msvc": "3.0.0-alpha.3",
+    "@rrule-rust/lib-linux-arm-gnueabihf": "3.0.0-alpha.3",
+    "@rrule-rust/lib-darwin-arm64": "3.0.0-alpha.3",
+    "@rrule-rust/lib-android-arm64": "3.0.0-alpha.3",
+    "@rrule-rust/lib-freebsd-x64": "3.0.0-alpha.3",
+    "@rrule-rust/lib-linux-arm64-musl": "3.0.0-alpha.3",
+    "@rrule-rust/lib-win32-arm64-msvc": "3.0.0-alpha.3",
+    "@rrule-rust/lib-android-arm-eabi": "3.0.0-alpha.3",
+    "@rrule-rust/lib-wasm32-wasi": "3.0.0-alpha.3"
   }
 }

package/dist/lib/index.d.ts

@@ -1,81 +0,0 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
-export declare class RRule {
-  constructor(frequency: Frequency, interval?: number | undefined | null, count?: number | undefined | null, weekstart?: Weekday | undefined | null, until?: number | undefined | null, byWeekday?: (readonly (NWeekday | Weekday)[]) | undefined | null, byHour?: (readonly number[]) | undefined | null, byMinute?: (readonly number[]) | undefined | null, bySecond?: (readonly number[]) | undefined | null, byMonthday?: (readonly number[]) | undefined | null, bySetpos?: (readonly number[]) | undefined | null, byMonth?: (readonly number[]) | undefined | null, byWeekno?: (readonly number[]) | undefined | null, byYearday?: (readonly number[]) | undefined | null)
-  static parse(str: string): RRule
-  get frequency(): Frequency
-  get interval(): number | null
-  get count(): number | null
-  get byWeekday(): NWeekday[]
-  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 | null
-  get until(): number | null
-  toString(): string
-}
-
-export declare class RRuleSet {
-  constructor(dtstart: number, tzid?: string | undefined | null, rrules?: (readonly RRule[]) | undefined | null, exrules?: (readonly RRule[]) | undefined | null, exdates?: (readonly number[]) | undefined | null, rdates?: (readonly number[]) | undefined | null)
-  get tzid(): string | null
-  get dtstart(): number
-  get rrules(): RRule[]
-  get exrules(): RRule[]
-  get exdates(): number[]
-  get rdates(): number[]
-  static parse(str: string): RRuleSet
-  all(limit?: number | undefined | null): number[]
-  between(afterDatetime: number, beforeDatetime: number, inclusive?: boolean | undefined | null): number[]
-  setFromString(str: string): this
-  toString(): string
-  iterator(): RRuleSetIterator
-}
-
-export declare class RRuleSetIterator {
-  next(): number | null
-}
-
-export declare enum Frequency {
-  Yearly = 0,
-  Monthly = 1,
-  Weekly = 2,
-  Daily = 3,
-  Hourly = 4,
-  Minutely = 5,
-  Secondly = 6
-}
-
-export declare enum Month {
-  January = 1,
-  February = 2,
-  March = 3,
-  April = 4,
-  May = 5,
-  June = 6,
-  July = 7,
-  August = 8,
-  September = 9,
-  October = 10,
-  November = 11,
-  December = 12
-}
-
-export interface NWeekday {
-  n?: number
-  weekday: Weekday
-}
-
-export declare enum Weekday {
-  Monday = 0,
-  Tuesday = 1,
-  Wednesday = 2,
-  Thursday = 3,
-  Friday = 4,
-  Saturday = 5,
-  Sunday = 6
-}