rrule-rust/dist/rrule-set.js

RRule implementation for Node.js written in Rust

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RRuleSet = void 0;
const rrule_1 = require("./rrule");
const lib_1 = require("./lib");
const datetime_1 = require("./datetime");
class RRuleSet {
    constructor(setOrDtstart, tzid) {
        if (!(setOrDtstart instanceof datetime_1.DateTime)) {
            if (setOrDtstart?.dtstart) {
                this.dtstart = setOrDtstart?.dtstart;
            }
            else {
                const date = new Date();
                this.dtstart = datetime_1.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_1.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 = lib_1.RRuleSet.parse(str);
        return this.fromRust(rust);
    }
    /**
     * @internal
     */
    static fromRust(rust) {
        const set = new RRuleSet({
            dtstart: datetime_1.DateTime.fromNumeric(rust.dtstart),
            tzid: rust.tzid ?? undefined,
            rrules: rust.rrules.map((rrule) => rrule_1.RRule.fromRust(rrule)),
            exrules: rust.exrules.map((rrule) => rrule_1.RRule.fromRust(rrule)),
            exdates: rust.exdates.map((datetime) => datetime_1.DateTime.fromNumeric(datetime)),
            rdates: rust.rdates.map((datetime) => datetime_1.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_1.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_1.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 lib_1.RRuleSet(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_1.DateTime.fromNumeric(result),
                };
            },
        };
    }
}
exports.RRuleSet = RRuleSet;