rrule-rust 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/browser/rrule-set.js

@@ -1,7 +1,9 @@
 import { RRule } from './rrule';
 import { RRuleSet as Rust } from './lib';
-import { DateTime } from './datetime';
+import { DateTime, } from './datetime';
 import { DtStart } from './dtstart';
+import { ExDate } from './exdate';
+import { RDate } from './rdate';
 export class RRuleSet {
     constructor(optionsOrDtstart) {
         if ('dtstart' in optionsOrDtstart) {
@@ -23,16 +25,15 @@ export class RRuleSet {
      * Parses a string into an RRuleSet.
      */
     static parse(str) {
-        const rust = Rust.parse(str);
-        return this.fromRust(rust);
+        return this.fromRust(Rust.parse(str));
     }
     static fromPlain(plain) {
         return new RRuleSet({
             dtstart: DtStart.fromPlain(plain.dtstart),
             rrules: plain.rrules.map((rrule) => RRule.fromPlain(rrule)),
             exrules: plain.exrules.map((rrule) => RRule.fromPlain(rrule)),
-            exdates: plain.exdates.map((datetime) => DateTime.fromPlain(datetime)),
-            rdates: plain.rdates.map((datetime) => DateTime.fromPlain(datetime)),
+            exdates: plain.exdates.map((datetime) => ExDate.fromPlain(datetime)),
+            rdates: plain.rdates.map((datetime) => RDate.fromPlain(datetime)),
         });
     }
     /**
@@ -46,8 +47,8 @@ export class RRuleSet {
             }),
             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)),
+            exdates: rust.exdates.map((exdate) => ExDate.fromRust(exdate)),
+            rdates: rust.rdates.map((rdate) => RDate.fromRust(rdate)),
         });
         set.rust = rust;
         return set;
@@ -82,16 +83,16 @@ export class RRuleSet {
             exrules: rrules,
         });
     }
-    addExdate(datetime) {
+    addExdate(exdate) {
         return new RRuleSet({
             ...this.toOptions(),
-            exdates: [...this.exdates, datetime],
+            exdates: [...this.exdates, exdate],
         });
     }
-    setExdates(datetimes) {
+    setExdates(exdates) {
         return new RRuleSet({
             ...this.toOptions(),
-            exdates: datetimes,
+            exdates: exdates,
         });
     }
     addRdate(datetime) {
@@ -140,7 +141,7 @@ export class RRuleSet {
      * @internal
      */
     toRust() {
-        this.rust ??= new Rust(this.dtstart.datetime.toNumeric(), this.dtstart.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()));
+        this.rust ??= new Rust(this.dtstart.datetime.toNumeric(), this.dtstart.tzid, undefined, this.rrules.map((rrule) => rrule.toRust()), this.exrules.map((rrule) => rrule.toRust()), this.exdates.map((exdate) => exdate.toRust()), this.rdates.map((rdate) => rdate.toRust()));
         return this.rust;
     }
     toString() {

package/dist/browser/rrule.d.ts

@@ -1,4 +1,4 @@
-import { DateTime, type DateTimeLike } from './datetime';
+import { type Time, DateTime, type DateTimeLike, type DateLike } from './datetime';
 export interface NWeekday {
     /**
      * If set, this represents the nth occurrence of the weekday.
@@ -41,11 +41,11 @@ export declare enum Weekday {
     Saturday = 5,
     Sunday = 6
 }
-export interface RRuleOptions {
+export interface RRuleOptions<DT extends DateTime<Time> | DateTime<undefined>> {
     readonly frequency: Frequency;
     readonly interval?: number;
     readonly count?: number;
-    readonly until?: DateTime;
+    readonly until?: DT;
     readonly byWeekday?: readonly (NWeekday | Weekday)[];
     readonly byHour?: readonly number[];
     readonly byMinute?: readonly number[];
@@ -57,11 +57,11 @@ export interface RRuleOptions {
     readonly byYearday?: readonly number[];
     readonly weekstart?: Weekday;
 }
-export interface RRuleLike {
+export interface RRuleLike<DT extends DateTimeLike | DateLike> {
     readonly frequency: Frequency;
     readonly interval?: number;
     readonly count?: number;
-    readonly until?: DateTimeLike;
+    readonly until?: DT;
     readonly byWeekday: readonly (NWeekday | Weekday)[];
     readonly byHour: readonly number[];
     readonly byMinute: readonly number[];
@@ -73,10 +73,10 @@ export interface RRuleLike {
     readonly byYearday: readonly number[];
     readonly weekstart?: Weekday;
 }
-export declare class RRule {
+export declare class RRule<DT extends DateTime<Time> | DateTime<undefined> = DateTime<Time>> {
     readonly frequency: Frequency;
     readonly interval?: number;
-    readonly until?: DateTime;
+    readonly until?: DT;
     readonly count?: number;
     readonly byWeekday: readonly (NWeekday | Weekday)[];
     readonly byHour: readonly number[];
@@ -89,27 +89,28 @@ export declare class RRule {
     readonly byYearday: readonly number[];
     readonly weekstart?: Weekday;
     constructor(frequency: Frequency);
-    constructor(options: RRuleOptions);
+    constructor(options: RRuleOptions<DT>);
     /**
      * Parses a string into an RRule.
      */
-    static parse(str: string): RRule;
-    static fromPlain(rrule: RRuleLike): 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;
+    static parse<DT extends DateTime<Time> | DateTime<undefined>>(str: string): RRule<DT>;
+    static fromPlain(rrule: RRuleLike<DateTimeLike>): RRule<DateTime<Time>>;
+    static fromPlain(rrule: RRuleLike<DateLike>): RRule<DateTime<undefined>>;
+    setFrequency(frequency: Frequency): RRule<DT>;
+    setInterval(interval: number): RRule<DT>;
+    setCount(count: number): RRule<DT>;
+    setByWeekday(weekdays: readonly (NWeekday | Weekday)[]): RRule<DT>;
+    setByHour(hours: readonly number[]): RRule<DT>;
+    setByMinute(minutes: readonly number[]): RRule<DT>;
+    setBySecond(seconds: readonly number[]): RRule<DT>;
+    setByMonthday(days: readonly number[]): RRule<DT>;
+    setBySetpos(poses: readonly number[]): RRule<DT>;
+    setByMonth(months: readonly Month[]): RRule<DT>;
+    setByWeekno(weekNumbers: readonly number[]): RRule<DT>;
+    setByYearday(days: readonly number[]): RRule<DT>;
+    setWeekstart(day: Weekday): RRule<DT>;
+    setUntil(until: DT): RRule<DT>;
     toString(): string;
-    toPlain(): RRuleLike;
+    toPlain(): RRuleLike<DT extends DateTime<Time> ? DateTimeLike : DateLike>;
     private toOptions;
 }

package/dist/browser/rrule.js

@@ -1,4 +1,4 @@
-import { DateTime } from './datetime';
+import { DateTime, } from './datetime';
 import { RRule as Rust } from './lib';
 export var Frequency;
 (function (Frequency) {
@@ -40,9 +40,7 @@ export class RRule {
         if (typeof frequencyOrOptions === 'object' && frequencyOrOptions !== null) {
             this.frequency = frequencyOrOptions.frequency;
             this.interval = frequencyOrOptions.interval;
-            this.until =
-                frequencyOrOptions.until &&
-                    DateTime.fromPlain(frequencyOrOptions.until);
+            this.until = frequencyOrOptions.until;
             this.count = frequencyOrOptions.count;
             this.byWeekday = frequencyOrOptions.byWeekday ?? [];
             this.byHour = frequencyOrOptions.byHour ?? [];
@@ -155,8 +153,8 @@ export class RRule {
     setWeekstart(day) {
         return new RRule({ ...this.toOptions(), weekstart: day });
     }
-    setUntil(datetime) {
-        return new RRule({ ...this.toOptions(), until: datetime });
+    setUntil(until) {
+        return new RRule({ ...this.toOptions(), until });
     }
     toString() {
         return this.toRust().toString();

package/dist/node/datetime.d.ts

@@ -1,3 +1,8 @@
+export interface DateLike {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+}
 export interface DateTimeLike {
     readonly year: number;
     readonly month: number;
@@ -7,55 +12,64 @@ export interface DateTimeLike {
     readonly second: number;
     readonly utc: boolean;
 }
-export type DateTimeLikeWithoutUtc = Omit<DateTimeLike, 'utc'>;
-export interface ToPlainOptions {
+export interface Time {
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+    readonly utc: boolean;
+}
+export interface ToPlainDateTimeOptions {
     stripUtc?: boolean;
 }
 /**
  * Represents a date and time. Either local or UTC.
  */
-export declare class DateTime implements DateTimeLike {
-    private readonly numeric;
+export declare class DateTime<T extends Time | undefined> {
+    private readonly state;
     private constructor();
     get year(): number;
     get month(): number;
     get day(): number;
-    get hour(): number;
-    get minute(): number;
-    get second(): number;
-    get utc(): boolean;
+    get time(): T;
+    /**
+     * Creates a new DateTime object from the given date and time components.
+     */
+    static create(year: number, month: number, day: number): DateTime<undefined>;
+    static create(year: number, month: number, day: number, hour: number, minute: number, second: number, utc: boolean): DateTime<Time>;
     /**
      * 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;
+    static date(year: number, month: number, day: number): DateTime<undefined>;
     /**
      * 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;
+    static local(year: number, month: number, day: number, hour: number, minute: number, second: number): DateTime<Time>;
     /**
      * 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;
+    static utc(year: number, month: number, day: number, hour: number, minute: number, second: number): DateTime<Time>;
     /**
      * Creates a new DateTime object from the given plain object.
      */
-    static fromPlain(plain: DateTimeLike): DateTime;
+    static fromPlain(plain: DateTimeLike): DateTime<Time>;
+    static fromPlain(plain: DateLike): DateTime<undefined>;
     /**
      * Creates a new DateTime object from provided string representation of a date according to RFC 5545.
      */
-    static fromString(str: string): DateTime;
+    static fromString(str: string): DateTime<Time> | DateTime<undefined>;
     /**
      * Converts DateTime into a plain object.
      */
-    toPlain(options: {
+    toPlain<DTL extends DateTimeLike>(options?: ToPlainDateTimeOptions & {
         stripUtc: false;
-    } & ToPlainOptions): DateTimeLike;
-    toPlain(options: {
+    }): DTL;
+    toPlain<DTL extends Omit<DateTimeLike, 'utc'>>(options?: ToPlainDateTimeOptions & {
         stripUtc: true;
-    } & ToPlainOptions): DateTimeLikeWithoutUtc;
-    toPlain(): DateTimeLike;
+    }): DTL;
+    toPlain<DTL extends DateLike>(): DTL;
     /**
      * Converts DateTime into ISO 8601 string:
+     * * `YYYYMMDD` for date only
      * - `YYYYMMDDTHHMMSSZ` for UTC
      * - `YYYYMMDDTHHMMSS` for local
      */

package/dist/node/datetime.js

@@ -6,41 +6,64 @@ exports.DateTime = void 0;
  */
 class DateTime {
     constructor(numeric) {
-        this.numeric = numeric;
+        this.state = {
+            numeric,
+        };
     }
     get year() {
-        return Math.floor(this.numeric / 100000000000);
+        return (this.state.year ??= Math.floor(this.state.numeric / 100000000000));
     }
     get month() {
-        return Math.floor((this.numeric / 1000000000) % 100);
+        return (this.state.month ??= Math.floor((this.state.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);
+        return (this.state.day ??= Math.floor((this.state.numeric / 10000000) % 100));
     }
-    get second() {
-        return Math.floor((this.numeric / 10) % 100);
+    get time() {
+        // return cached time if available
+        if ('time' in this.state) {
+            return this.state.time;
+        }
+        const type = this.state.numeric % 10; // 0 – non utc, 1 – utc, 2 – date only
+        if (type == 2) {
+            // if it's date only, return undefined and cache it in state
+            return (this.state.time ??= undefined);
+        }
+        else {
+            // otherwise compute it from numeric representation and cache it in state
+            return (this.state.time ??= {
+                hour: Math.floor((this.state.numeric / 100000) % 100),
+                minute: Math.floor((this.state.numeric / 1000) % 100),
+                second: Math.floor((this.state.numeric / 10) % 100),
+                utc: this.state.numeric % 10 == 1,
+            });
+        }
     }
-    get utc() {
-        return this.numeric % 10 == 1;
+    static create(year, month, day, hour, minute, second, utc) {
+        let numeric = year * 100000000000 + month * 1000000000 + day * 10000000;
+        if (hour !== undefined &&
+            minute !== undefined &&
+            second !== undefined &&
+            utc !== undefined) {
+            numeric += hour * 100000;
+            numeric += minute * 1000;
+            numeric += second * 10;
+            numeric += utc ? 1 : 0;
+            return new DateTime(numeric);
+        }
+        else {
+            numeric += 100000;
+            numeric += 1000;
+            numeric += 10;
+            numeric += 2;
+            return new DateTime(numeric);
+        }
     }
     /**
      * 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);
+    static date(year, month, day) {
+        return this.create(year, month, day);
     }
     /**
      * This method is shorthand for `DateTime.create` with `utc` set to `false`.
@@ -54,69 +77,102 @@ class DateTime {
     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 fromPlain(plain) {
-        return DateTime.create(plain.year, plain.month, plain.day, plain.hour, plain.minute, plain.second, plain.utc);
+        if ('hour' in plain) {
+            return DateTime.create(plain.year, plain.month, plain.day, plain.hour, plain.minute, plain.second, plain.utc);
+        }
+        return DateTime.create(plain.year, plain.month, plain.day);
     }
     /**
      * Creates a new DateTime object from provided string representation of a date according to RFC 5545.
      */
+    // TODO: add template expression
     static fromString(str) {
-        const typeError = new TypeError('Invalid date time string');
-        if (str.length > 16 || str.length < 15) {
-            throw typeError;
+        if (!(str.length === 8 || (str.length <= 16 && str.length >= 15))) {
+            throw new TypeError('Invalid date time string');
         }
         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;
+        let hour = undefined;
+        let minute = undefined;
+        let second = undefined;
+        let utc = undefined;
+        if (isNaN(year) || isNaN(month) || isNaN(day)) {
+            throw new TypeError('Invalid date');
+        }
+        if (str.length > 8) {
+            hour = parseInt(str.slice(9, 11));
+            minute = parseInt(str.slice(11, 13));
+            second = parseInt(str.slice(13, 15));
+            utc = str.endsWith('Z');
+            if (isNaN(hour) || isNaN(minute) || isNaN(second)) {
+                throw new TypeError('Invalid time');
+            }
+            return DateTime.create(year, month, day, hour, minute, second, utc);
+        }
+        else {
+            return DateTime.create(year, month, day);
         }
-        return DateTime.create(year, month, day, hour, minute, second, utc);
     }
     /** @internal */
     static fromNumeric(numeric) {
         return new DateTime(numeric);
     }
     toPlain(options) {
-        return {
-            year: this.year,
-            month: this.month,
-            day: this.day,
-            hour: this.hour,
-            minute: this.minute,
-            second: this.second,
-            utc: options?.stripUtc ? undefined : this.utc,
-        };
+        let plain;
+        if (this.time) {
+            plain = options?.stripUtc
+                ? {
+                    year: this.year,
+                    month: this.month,
+                    day: this.day,
+                    hour: this.time.hour,
+                    minute: this.time.minute,
+                    second: this.time.second,
+                }
+                : {
+                    year: this.year,
+                    month: this.month,
+                    day: this.day,
+                    hour: this.time.hour,
+                    minute: this.time.minute,
+                    second: this.time.second,
+                    utc: this.time.utc,
+                };
+        }
+        else {
+            plain = {
+                year: this.year,
+                month: this.month,
+                day: this.day,
+            };
+        }
+        return plain;
     }
     /**
      * Converts DateTime into ISO 8601 string:
+     * * `YYYYMMDD` for date only
      * - `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' : ''}`;
+        let str = this.year.toString().padStart(4, '0') +
+            this.month.toString().padStart(2, '0') +
+            this.day.toString().padStart(2, '0');
+        if (this.time) {
+            str +=
+                'T' +
+                    this.time.hour.toString().padStart(2, '0') +
+                    this.time.minute.toString().padStart(2, '0') +
+                    this.time.second.toString().padStart(2, '0') +
+                    (this.time.utc ? 'Z' : '');
+        }
+        return str;
     }
     /** @internal */
     toNumeric() {
-        return this.numeric;
+        return this.state.numeric;
     }
 }
 exports.DateTime = DateTime;

package/dist/node/dtstart.d.ts

@@ -1,19 +1,20 @@
-import { DateTime, type DateTimeLike } from './datetime';
-export interface DtStartOptions {
-    datetime: DateTime;
+import { DateTime, type Time, type DateTimeLike, type DateLike } from './datetime';
+export interface DtStartOptions<DT extends DateTime<Time> | DateTime<undefined>> {
+    datetime: DT;
     tzid?: string;
 }
-export interface DtStartLike {
-    datetime: DateTimeLike;
+export interface DtStartLike<DT extends DateTimeLike | DateLike> {
+    datetime: DT;
     tzid?: string;
 }
-export declare class DtStart {
-    readonly datetime: DateTime;
+export declare class DtStart<DT extends DateTime<Time> | DateTime<undefined> = DateTime<Time>> {
+    readonly datetime: DT;
     readonly tzid?: string;
-    constructor(datetime: DateTime, tzid?: string);
-    constructor(options: DtStartOptions);
-    static fromPlain(plain: DtStartLike): DtStart;
-    setTzid(tzid: string): DtStart;
-    setDatetime(datetime: DateTime): DtStart;
-    toPlain(): DtStartLike;
+    constructor(datetime: DT, tzid?: string);
+    constructor(options: DtStartOptions<DT>);
+    static fromPlain(plain: DtStartLike<DateTimeLike>): DtStart<DateTime<Time>>;
+    static fromPlain(plain: DtStartLike<DateLike>): DtStart<DateTime<undefined>>;
+    setTzid(tzid: string | undefined): DtStart<DT>;
+    setDatetime<NDT extends DateTime<Time> | DateTime<undefined>>(datetime: NDT): DtStart<NDT>;
+    toPlain<DTL extends DateTimeLike | DateLike = DT extends DateTime<Time> ? DateTimeLike : DateLike>(): DtStartLike<DTL>;
 }

package/dist/node/dtstart.js

@@ -20,16 +20,10 @@ class DtStart {
         });
     }
     setTzid(tzid) {
-        return new DtStart({
-            datetime: this.datetime,
-            tzid,
-        });
+        return new DtStart(this.datetime, tzid);
     }
     setDatetime(datetime) {
-        return new DtStart({
-            datetime: datetime,
-            tzid: this.tzid,
-        });
+        return new DtStart(datetime, this.tzid);
     }
     toPlain() {
         return {

package/dist/node/exdate.d.ts

@@ -0,0 +1,20 @@
+import { DateTime, type Time, type DateTimeLike, type DateLike } from './datetime';
+export interface ExDateOptions<DT extends DateTime<Time> | DateTime<undefined>> {
+    values: DT[];
+    tzid?: string;
+}
+export interface ExDateLike<DT extends DateTimeLike | DateLike> {
+    values: DT[];
+    tzid?: string;
+}
+export declare class ExDate<DT extends DateTime<Time> | DateTime<undefined> = DateTime<Time>> {
+    readonly values: DT[];
+    readonly tzid?: string;
+    constructor(values: DT[], tzid?: string);
+    constructor(options: ExDateOptions<DT>);
+    static fromPlain(plain: ExDateLike<DateTimeLike>): ExDate<DateTime<Time>>;
+    static fromPlain(plain: ExDateLike<DateLike>): ExDate<DateTime<undefined>>;
+    setTzid(tzid: string | undefined): ExDate<DT>;
+    setValues<NDT extends DateTime<Time> | DateTime<undefined>>(datetimes: NDT[]): ExDate<NDT>;
+    toPlain<DTL extends DateTimeLike | DateLike = DT extends DateTime<Time> ? DateTimeLike : DateLike>(): ExDateLike<DTL>;
+}

package/dist/node/exdate.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExDate = void 0;
+const datetime_1 = require("./datetime");
+const lib_1 = require("./lib");
+class ExDate {
+    constructor(valuesOrOptions, tzid) {
+        if (!Array.isArray(valuesOrOptions)) {
+            this.values = valuesOrOptions.values;
+            this.tzid = valuesOrOptions.tzid;
+        }
+        else {
+            this.values = valuesOrOptions;
+            this.tzid = tzid;
+        }
+    }
+    /**
+     * @internal
+     */
+    static fromRust(rust) {
+        const rrule = new this(rust.values.map((dt) => datetime_1.DateTime.fromNumeric(dt)), rust.tzid ?? undefined);
+        rrule.rust = rust;
+        return rrule;
+    }
+    static fromPlain(plain) {
+        return new this({
+            values: plain.values.map((dt) => datetime_1.DateTime.fromPlain(dt)),
+            tzid: plain.tzid,
+        });
+    }
+    setTzid(tzid) {
+        return new ExDate(this.values, tzid);
+    }
+    setValues(datetimes) {
+        return new ExDate(datetimes, this.tzid);
+    }
+    toPlain() {
+        return {
+            values: this.values.map((dt) => dt.toPlain()),
+            tzid: this.tzid,
+        };
+    }
+    /**
+     * @internal
+     */
+    toRust() {
+        this.rust ??= new lib_1.ExDate(this.values.map((dt) => dt.toNumeric()), this.tzid);
+        return this.rust;
+    }
+}
+exports.ExDate = ExDate;

package/dist/node/index.d.ts

@@ -2,3 +2,5 @@ export * from './rrule-set';
 export * from './rrule';
 export * from './datetime';
 export * from './dtstart';
+export * from './exdate';
+export * from './rdate';

package/dist/node/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./rrule-set"), exports);
 __exportStar(require("./rrule"), exports);
 __exportStar(require("./datetime"), exports);
 __exportStar(require("./dtstart"), exports);
+__exportStar(require("./exdate"), exports);
+__exportStar(require("./rdate"), exports);

package/dist/node/lib/index.js

@@ -393,6 +393,8 @@ if (!nativeBinding) {
 }
 
 module.exports = nativeBinding
+module.exports.ExDate = nativeBinding.ExDate
+module.exports.RDate = nativeBinding.RDate
 module.exports.RRule = nativeBinding.RRule
 module.exports.RRuleSet = nativeBinding.RRuleSet
 module.exports.RRuleSetIterator = nativeBinding.RRuleSetIterator