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

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: DateTime<Time> | DateTime<undefined>, 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/rrule-set.d.ts

@@ -1,48 +1,49 @@
 import { RRule, type RRuleLike } from './rrule';
-import { DateTime, type DateTimeLike } from './datetime';
+import { type Time, DateTime, type DateTimeLike, type DateLike } from './datetime';
 import { DtStart, type DtStartLike } from './dtstart';
-export interface RRuleSetOptions {
-    readonly dtstart: DtStart;
-    readonly rrules?: readonly RRule[];
-    readonly exrules?: readonly RRule[];
-    readonly exdates?: readonly DateTime[];
-    readonly rdates?: readonly DateTime[];
+export interface RRuleSetOptions<DT extends DateTime<Time> | DateTime<undefined> = DateTime<Time>> {
+    readonly dtstart: DtStart<DT>;
+    readonly rrules?: readonly RRule<DT>[];
+    readonly exrules?: readonly RRule<DT>[];
+    readonly exdates?: readonly DT[];
+    readonly rdates?: readonly DT[];
 }
-export interface RRuleSetLike {
-    readonly dtstart: DtStartLike;
-    readonly rrules: readonly RRuleLike[];
-    readonly exrules: readonly RRuleLike[];
-    readonly exdates: readonly DateTimeLike[];
-    readonly rdates: readonly DateTimeLike[];
+export interface RRuleSetLike<DT extends DateTimeLike | DateLike> {
+    readonly dtstart: DtStartLike<DT>;
+    readonly rrules: readonly RRuleLike<DT>[];
+    readonly exrules: readonly RRuleLike<DT>[];
+    readonly exdates: readonly DT[];
+    readonly rdates: readonly DT[];
 }
-export declare class RRuleSet implements Iterable<DateTime> {
-    readonly dtstart: DtStart;
-    readonly rrules: readonly RRule[];
-    readonly exrules: readonly RRule[];
-    readonly exdates: readonly DateTime[];
-    readonly rdates: readonly DateTime[];
-    constructor(dtstart: DtStart);
-    constructor(options: RRuleSetOptions);
+export declare class RRuleSet<DT extends DateTime<Time> | DateTime<undefined>> implements Iterable<DateTime<Time> | DateTime<undefined>> {
+    readonly dtstart: DtStart<DT>;
+    readonly rrules: readonly RRule<DT>[];
+    readonly exrules: readonly RRule<DT>[];
+    readonly exdates: readonly DT[];
+    readonly rdates: readonly DT[];
+    constructor(dtstart: DtStart<DT>);
+    constructor(options: RRuleSetOptions<DT>);
     /**
      * Parses a string into an RRuleSet.
      */
-    static parse(str: string): RRuleSet;
-    static fromPlain(plain: RRuleSetLike): RRuleSet;
-    setDtstart(dtstart: DtStart): 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;
+    static parse<DT extends DateTime<Time> | DateTime<undefined>>(str: string): RRuleSet<DT>;
+    static fromPlain(plain: RRuleSetLike<DateTimeLike>): RRuleSet<DateTime<Time>>;
+    static fromPlain(plain: RRuleSetLike<DateLike>): RRuleSet<DateTime<undefined>>;
+    setDtstart(dtstart: DtStart<DT>): RRuleSet<DT>;
+    addRrule<RRDT extends DT>(rrule: RRule<RRDT>): RRuleSet<DT>;
+    setRrules(rrules: readonly RRule<DT>[]): RRuleSet<DT>;
+    addExrule(rrule: RRule<DT>): RRuleSet<DT>;
+    setExrules(rrules: readonly RRule<DT>[]): RRuleSet<DT>;
+    addExdate(datetime: DT): RRuleSet<DT>;
+    setExdates(datetimes: readonly DT[]): RRuleSet<DT>;
+    addRdate(datetime: DT): RRuleSet<DT>;
+    setRdates(datetimes: readonly DT[]): RRuleSet<DT>;
     /**
      * Returns all the occurrences of the rrule.
      *
      * @param limit - The maximum number of occurrences to return.
      */
-    all(limit?: number): DateTime[];
+    all(limit?: number): DT[];
     /**
      * Returns all the occurrences of the rrule between after and before.
      *
@@ -50,18 +51,18 @@ export declare class RRuleSet implements Iterable<DateTime> {
      * @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[];
+    between(after: DT, before: DT, inclusive?: boolean): DT[];
     /**
      * Sets the RRuleSet from a string.
      *
      * @param str - The string to parse.
      */
-    setFromString(str: string): RRuleSet;
+    setFromString<NDT extends DateTime<Time> | DateTime<undefined> = DT>(str: string): RRuleSet<NDT>;
     toString(): string;
     /**
      * Converts the RRuleSet to a plain object.
      */
-    toPlain(): RRuleSetLike;
-    [Symbol.iterator](): Iterator<DateTime, any, any>;
+    toPlain(): RRuleSetLike<DT extends DateTime<Time> ? DateTimeLike : DateLike>;
+    [Symbol.iterator](): Iterator<DT, any, any>;
     private toOptions;
 }

package/dist/node/rrule-set.js

@@ -26,8 +26,7 @@ class RRuleSet {
      * Parses a string into an RRuleSet.
      */
     static parse(str) {
-        const rust = lib_1.RRuleSet.parse(str);
-        return this.fromRust(rust);
+        return this.fromRust(lib_1.RRuleSet.parse(str));
     }
     static fromPlain(plain) {
         return new RRuleSet({
@@ -143,7 +142,7 @@ class RRuleSet {
      * @internal
      */
     toRust() {
-        this.rust ??= new lib_1.RRuleSet(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 lib_1.RRuleSet(this.dtstart.datetime.toNumeric(), this.dtstart.tzid, undefined, 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() {

package/dist/node/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/node/rrule.js

@@ -43,9 +43,7 @@ class RRule {
         if (typeof frequencyOrOptions === 'object' && frequencyOrOptions !== null) {
             this.frequency = frequencyOrOptions.frequency;
             this.interval = frequencyOrOptions.interval;
-            this.until =
-                frequencyOrOptions.until &&
-                    datetime_1.DateTime.fromPlain(frequencyOrOptions.until);
+            this.until = frequencyOrOptions.until;
             this.count = frequencyOrOptions.count;
             this.byWeekday = frequencyOrOptions.byWeekday ?? [];
             this.byHour = frequencyOrOptions.byHour ?? [];
@@ -158,8 +156,8 @@ 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();