How to use the rrule.RRule function in rrule

function returnDatesArrayByRepeatRule(event, startDate, endDate) {
  const rule = new RRule(createRRule(event));
  try {
    let eventDuration = event.end_time_utc - event.start_time_utc;
    let adjustedStartDate = new Date(
      moment(startDate).add(
        -1 * eventDuration - 1 * 1000 * 60 * 60,
        'milliseconds',
      ), // we are subtracting one hour because RRule has not been accounting for Daylight Savings Time properly - may need to consider rewriting to remove Rrule implementation with something that's more transparent about how it handles DST
    ); //between searches on START times, and we want to get anything in progress in this date range, so subtract the event duration from the start time

    let events = rule.between(adjustedStartDate, new Date(endDate));

    return events;
  } catch (e) {
    console.log('Error in returnDatesArrayByRepeatRule');
    console.log(e);
    return null;

input_frequency = RRule.MONTHLY;
                break;
              case 2:
                input_frequency = RRule.WEEKLY;
                break;
              case 3:
                input_frequency = RRule.DAILY;
                break;
            }

            if(isNaN(start_year) == false || isNaN(end_year) == false) {
              // TODO Might be Deprecated -- IF RRule Breaks, this is where it will happen
              // TODO remove tzid from rule object
              let date_start = new Date(Date.UTC(start_year, start_month - 1, start_day, start_hour, start_minute))
              let until = new Date(Date.UTC(end_year, end_month - 1, end_day, end_hour, end_minute))
              const rule = new RRule({
                freq: input_frequency,
                count: this.selected_count,
                byweekday: this.selected_weekdays,
                dtstart: date_start,
                until: until,
                tzid: Intl.DateTimeFormat().resolvedOptions().timeZone,
              })
              let array = rule.all()
              this.rrule_text = rule.toText()

              array.forEach(date => {
                let formatted_start_date = moment(date).clone().set({hour: local_start_hour}).format('YYYY-MM-DD HH:mm:ssZ')
                let formatted_end_date = moment(date).clone().set({hour: local_start_hour}).add(duration_minutes, 'minutes').format('YYYY-MM-DD HH:mm:ssZ')
                local_dates_array.push({start: formatted_start_date, end: formatted_end_date})
              })
            }

case 2:
              booking_input_frequency = RRule.WEEKLY;
              break;
            case 3:
              booking_input_frequency = RRule.DAILY;
              break;
          }

          if(isNaN(start_year) == false || isNaN(end_year) == false){

            // TODO Might be Deprecated -- IF RRule Breaks, this is where it will happen
            // Removed hours and minutes from date_start and until
            let date_start = new Date(Date.UTC(start_year, start_month -1, start_day))
            let until = new Date(Date.UTC(end_year, end_month -1, end_day))

            const rule = new RRule({
              freq: booking_input_frequency,
              count: this.selected_booking_count,
              byweekday: this.selected_booking_weekdays,
              dtstart: date_start,
              until: until,
            })

            let array = rule.all()
            this.booking_rrule_text = rule.toText()
            array.forEach(date => {
              // created date_with_offset to fix pst -> utc 5pm bug
              let date_with_offset = moment(date).clone().set({hour: local_start_hour, minute: start_minute}).add(new Date().getTimezoneOffset(), 'minutes')
              if(local_start_hour >= 8 && local_start_hour < 15){
                date_with_offset.add(1, 'day')
              }
              let formatted_start_date = moment(date_with_offset).clone().set({hour: local_start_hour, minute: start_minute}).format('YYYY-MM-DD HH:mm:ssZ')

if (typeof refined.until === 'string') {
            refined.until = dateEnv.createMarker(refined.until);
        }
        if (refined.freq != null) {
            refined.freq = convertConstant(refined.freq);
        }
        if (refined.wkst != null) {
            refined.wkst = convertConstant(refined.wkst);
        }
        else {
            refined.wkst = (dateEnv.weekDow - 1 + 7) % 7; // convert Sunday-first to Monday-first
        }
        if (refined.byweekday != null) {
            refined.byweekday = convertConstants(refined.byweekday); // the plural version
        }
        rrule = new RRule(refined);
    }
    if (rrule) {
        return { rrule: rrule, allDayGuess: allDayGuess };
    }
    return null;
}
function convertConstants(input) {

input_frequency = RRule.MONTHLY;
            break;
          case 2:
            input_frequency = RRule.WEEKLY;
            break;
          case 3:
            input_frequency = RRule.DAILY;
            break;
        }

        if(isNaN(start_year) == false || isNaN(end_year) == false){
          // TODO Might be Deprecated -- IF RRule Breaks, this is where it will happen
          let date_start = new Date(Date.UTC(start_year, start_month-1, start_day))
          let until = new Date(Date.UTC(end_year, end_month-1, end_day))

          const rule = new RRule({
            freq: input_frequency,
            count: this.other_selected_count,
            byweekday: this.other_selected_weekdays,
            dtstart: date_start,
            until: until
          })

          let array = rule.all()
          this.other_rrule_text = rule.toText()
          // TODO For the night is dark and full of terror
          let first_event_start_day = moment(this.startTime).clone().set({hour: local_start_hour, minute: local_start_minute}).add(new Date(this.startTime).getTimezoneOffset(), 'minutes')
          let num_days = Math.floor(moment.duration(first_event_start_day.diff(moment(new Date()))).asDays())

          array.forEach(date => {
            // TODO For the night is dark and full of terror
            let date_with_offset = moment(date).clone().set({hour: local_start_hour, minute: local_start_minute}).add(new Date(date).getTimezoneOffset(), 'minutes')

},
    'bar': {
      type: 'VEVENT',
      summary: 'Test2',
      start: new Date(2018, 0, 30, 11, 0, 0, 0),
      end: new Date(2018, 0, 30, 11, 15, 0, 0),
    }
  };

  const recurringEvent = {
    'foo': {
      type: 'VEVENT',
      summary: 'Test',
      start: new Date(2018, 0, 30, 10, 0, 0, 0),
      end: new Date(2018, 0, 30, 10, 15, 0, 0),
      rrule: new RRule({
        freq: RRule.DAILY,
        dtstart: new Date(2018, 0, 30, 10, 0),
        until: new Date(new Date().getFullYear() + 1, 0, 30, 10, 0)
      })
    }
  };

  it('Builds a start and end action for a single non-recurring event', () => {

    const expectedActions = [
      {
        date: oneEvent.foo.start,
        expires: oneEvent.foo.end,
        state: true,
        summary: oneEvent.foo.summary
      }, {

const oneEvent = {
    'foo': {
      type: 'VEVENT',
      summary: 'Test',
      start: new Date(2018, 0, 30, 10, 0, 0, 0),
      end: new Date(2018, 0, 30, 10, 15, 0, 0),
    }
  };

  const recurringEvent = {
    'foo': {
      type: 'VEVENT',
      summary: 'Test',
      start: new Date(2018, 0, 30, 10, 0, 0, 0),
      end: new Date(2018, 0, 30, 10, 15, 0, 0),
      rrule: new RRule({
        freq: RRule.DAILY,
        dtstart: new Date(2018, 0, 30, 10, 0),
        until: new Date(new Date().getFullYear() + 1, 0, 30, 10, 0)
      })
    }
  };

  it('Move start of non-recurring event for 2d offset', () => {
    const expectedActions = [
      {
        date: new Date(2018, 0, 28, 10, 0, 0, 0),
        expires: oneEvent.foo.end,
        state: true,
        summary: oneEvent.foo.summary
      }, {
        date: oneEvent.foo.end,

IcalFile.prototype.getRrule = function(event)
{
    if (undefined === event.getProperty('RRULE')) {
        return null;
    }

    let RRule = require('rrule').RRule;

    let options = RRule.parseString(event.getProperty('RRULE').format()[0].substr(6));
    options.dtstart = event.getProperty('DTSTART').value;

    return new RRule(options);
};

setRecurringFrequency(frequency: number): void {
        if (frequency === -1) {
            if (this.rrule) {
                this.rrule = undefined;
            }
        } else {
            const ruleOpts = this.rrule ? this.rrule.origOptions
                                        : { dtstart: this.dtstart.toDate() };
            ruleOpts.freq  = frequency;
            this.rrule     = new RRule(ruleOpts);
        }
    }

)
                ? (recurrenceRuleOptions.byweekday as Weekday[])
                : [];
            const idx = selectedWeekDays.indexOf(weekday);

            const newSelectedWeekDays =
                idx === -1
                    ? [...selectedWeekDays, weekday]
                    : selectedWeekDays.filter(item => item !== weekday);

            const newRecurrenceRuleOptions = {
                ...recurrenceRuleOptions,
                byweekday: newSelectedWeekDays
            };

            const rruleStr = new RRule(newRecurrenceRuleOptions).toString();

            if (
                typeof props.onAccrualPeriodicityRecurrenceRuleChange ===
                "function"
            ) {
                props.onAccrualPeriodicityRecurrenceRuleChange(rruleStr);
            }
        };
    };