@becollective/utils 1.10.2 → 2.0.0

package/tests/rrule/parsing.test.ts

@@ -0,0 +1,12 @@
+import { toRruleStr } from '../../lib/rrule/parsing';
+
+it('removes null or undefined fields', () => {
+  expect(
+    toRruleStr({
+      DTSTART: '20120201T023000Z',
+      DURATION: '1h',
+      COUNT: null,
+      UNTIL: undefined,
+    })
+  ).toEqual('DTSTART=20120201T023000Z;DURATION=1h');
+});

package/tests/rrule.test.ts

@@ -0,0 +1,625 @@
+/* eslint-disable jest/no-conditional-expect */
+import { RRule } from 'rrule';
+import { DateTime } from 'luxon';
+
+import {
+  recurrencesBetween,
+  recurrencesBetweenV2,
+  recurrenceToText,
+  toRruleObj,
+  toRruleStr,
+  parse,
+  isValidRrule,
+  buildBcRruleString,
+} from '../lib/rrule';
+
+const RULE_CONFIG = {
+  'RRULE:FREQ': 'WEEKLY',
+  DTSTART: '20170703T125800Z',
+  UNTIL: '20170703T130200Z',
+  INTERVAL: '1',
+  BYDAY: 'WE,TU',
+};
+const RULE = 'RRULE:FREQ=WEEKLY;UNTIL=20170703T130200Z;INTERVAL=1;DTSTART=20170703T125800Z;BYDAY=WE,TU';
+
+const date = (str) => DateTime.fromFormat(str, 'YYYY-MM-DD').toJSDate();
+
+const validateDay = (timezone, { from, to }) => {
+  const VALID_DAYS = ['Tue', 'Wed'];
+  expect(VALID_DAYS.includes(DateTime.fromJSDate(from).setZone(timezone).toFormat('ddd'))).toBeTruthy();
+};
+
+const validateTime = (timezone, startTime, endTime, { from, to }) => {
+  const TIME_FORMAT = 'HH:mm';
+  const start = DateTime.fromJSDate(from).setZone(timezone).toFormat(TIME_FORMAT);
+  const end = DateTime.fromJSDate(to).setZone(timezone).toFormat(TIME_FORMAT);
+
+  expect(start).toEqual(startTime);
+  expect(end).toEqual(endTime);
+};
+
+describe('Recurrences between', () => {
+  it('validates DTSTART is earlier or equal to than UNTIL', () => {
+    const rrule = 'RRULE:FREQ=MONTHLY;INTERVAL=1;DTSTART=20180110T050000Z;UNTIL=20180110T030000Z;BYDAY=1SA;BYMONTHDAY=';
+    const rruleObj = toRruleObj(rrule);
+    expect(isValidRrule(rruleObj)).toBe(false);
+  });
+
+  it('gets the start time correct consistently', () => {
+    const melbourne = 'Australia/Melbourne';
+    const start = new Date('2017-01-01');
+    const end = new Date('2017-12-31');
+    const DATE_FORMAT = 'YYYYMMDD';
+    let recurrences = recurrencesBetween(start, end, RULE, melbourne);
+    recurrences.forEach(validateDay.bind(null, melbourne));
+    recurrences.forEach(validateTime.bind(null, melbourne, '22:58', '23:02'));
+
+    const taipei = 'Asia/Taipei';
+    recurrences = recurrencesBetween(start, end, RULE, taipei);
+    recurrences.forEach(validateDay.bind(null, taipei));
+    recurrences.forEach(validateTime.bind(null, taipei, '20:58', '21:02'));
+  });
+
+  it("doesn't enter an infinite loop when INTERVAL is empty", () => {
+    const recurrences = recurrencesBetween(
+      new Date('2018-01-11T07:25:47.871Z'),
+      new Date('2019-01-10T13:00:00.000Z'),
+      'RRULE:FREQ=MONTHLY;INTERVAL=;DTSTART=20180110T020000Z;UNTIL=20180110T050000Z;BYDAY=1SA;BYMONTHDAY=',
+      'Australia/Melbourne'
+    );
+  });
+});
+
+describe('Recurrence to text', () => {
+  it('displays a consistent start time irrespective of daylight savings', () => {
+    // Test when there is no daylight savings
+    const rule = `${RULE};DURATION=4M`;
+    const melbourne = 'Australia/Melbourne';
+    let display = recurrenceToText(rule, melbourne);
+    expect(display.time).toEqual('10:58 PM to 11:02 PM');
+
+    // Test when daylight savings is active
+    display = recurrenceToText(rule, melbourne);
+    expect(display.time).toEqual('10:58 PM to 11:02 PM');
+  });
+  it('display text with two lines rrule', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 10, 20, 14, 0)),
+        freq: RRule.WEEKLY,
+        bymonthday: [1, 2],
+        interval: 1,
+        until: new Date(Date.UTC(2020, 12, 31, 12, 59)),
+      }),
+      '2H'
+    );
+
+    const melbourne = 'Australia/Melbourne';
+    const auckland = 'Pacific/Auckland';
+
+    const display = recurrenceToText(rruleStr, melbourne);
+    expect(display.time).toEqual('1:00 AM to 3:00 AM');
+    expect(display.text).toEqual('Every week on the 1st and 2nd until January 31, 2021');
+    const display2 = recurrenceToText(rruleStr, auckland);
+    expect(display2.time).toEqual('3:00 AM to 5:00 AM');
+    expect(display2.text).toEqual('Every week on the 1st and 2nd until February 1, 2021');
+  });
+  it('display text with flexible type opportunity', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 10, 20, 14, 0)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2020, 12, 31, 12, 59)),
+      }),
+      '2H'
+    );
+
+    const melbourne = 'Australia/Melbourne';
+    const auckland = 'Pacific/Auckland';
+
+    const display = recurrenceToText(rruleStr, melbourne, true);
+    expect(display.text).toEqual('2 hours every week until January 31, 2021');
+    const display2 = recurrenceToText(rruleStr, auckland, true);
+    expect(display2.text).toEqual('2 hours every week until February 1, 2021');
+  });
+
+  it('display text with non-repeating opportunity', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 10, 20, 14, 0)),
+        freq: RRule.YEARLY,
+        count: 1,
+        until: new Date(Date.UTC(2020, 12, 31, 12, 59)),
+      }),
+      '2H'
+    );
+
+    const melbourne = 'Australia/Melbourne';
+    const auckland = 'Pacific/Auckland';
+
+    const display = recurrenceToText(rruleStr, melbourne, true);
+    expect(display.text).toEqual('2 hours in total by January 31, 2021');
+    const display2 = recurrenceToText(rruleStr, auckland, true);
+    expect(display2.text).toEqual('2 hours in total by February 1, 2021');
+  });
+});
+
+describe('Parsing', () => {
+  it('parses an empty string', () => {
+    const config = toRruleObj('');
+    expect(Object.keys(config)).toHaveLength(0);
+  });
+
+  it('parses duration handle not exist', () => {
+    const { duration } = parse(RULE);
+    expect(duration).toEqual(0);
+  });
+
+  it('parses duration provided', () => {
+    const { duration } = parse(`${RULE};DURATION=1H`);
+    expect(duration).toEqual(3600000);
+  });
+
+  it('parses fraction duration provided', () => {
+    const { duration } = parse(`${RULE};DURATION=1.5H`);
+    expect(duration).toEqual(5400000);
+  });
+
+  it('do not bomb on dtend - backward no bomb test', () => {
+    const { duration, dtend } = parse(`${RULE};DTEND=20180110T050000Z`);
+    expect(duration).not.toEqual(0);
+    expect(dtend).toEqual('20180110T050000Z');
+  });
+
+  it('converts rrule string to object', () => {
+    const config = toRruleObj(RULE);
+    expect(config).toEqual(RULE_CONFIG);
+  });
+
+  it('converts to rrule string', () => {
+    const rrule = toRruleStr(RULE_CONFIG);
+    expect(rrule.indexOf('RRULE:FREQ=WEEKLY;')).toEqual(0);
+    expect(rrule.includes('UNTIL=20170703T130200Z')).toBeTruthy();
+    expect(rrule.includes('DTSTART=20170703T125800Z')).toBeTruthy();
+    expect(rrule.includes('INTERVAL=1')).toBeTruthy();
+    expect(rrule.includes('BYDAY=WE,TU')).toBeTruthy();
+  });
+});
+
+describe('buildBcRuleString', () => {
+  it('should work for weekly', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 7, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    expect(rruleStr.indexOf('RRULE:FREQ=WEEKLY;')).toEqual(25);
+    expect(rruleStr.includes('UNTIL=20170813T130200Z')).toBeTruthy();
+    expect(rruleStr.includes('DTSTART:20170803T130200Z')).toBeTruthy();
+    expect(rruleStr.includes('INTERVAL=1')).toBeTruthy();
+    expect(rruleStr.includes('DURATION=1H')).toBeTruthy();
+  });
+
+  it('should work for yearly', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+        freq: RRule.YEARLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 7, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    expect(rruleStr.indexOf('RRULE:FREQ=YEARLY;')).toEqual(25);
+    expect(rruleStr.includes('UNTIL=20170813T130200Z')).toBeTruthy();
+    expect(rruleStr.includes('DTSTART:20170803T130200Z')).toBeTruthy();
+    expect(rruleStr.includes('INTERVAL=1')).toBeTruthy();
+    expect(rruleStr.includes('DURATION=1H')).toBeTruthy();
+  });
+
+  it('should fail for secondly', () => {
+    try {
+      const rruleStr = buildBcRruleString(
+        new RRule({
+          dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+          freq: RRule.SECONDLY,
+          interval: 1,
+          until: new Date(Date.UTC(2017, 7, 13, 13, 2)),
+        }),
+        '1H'
+      );
+    }
+    catch (err: any) {
+      expect(JSON.parse(err.message)[0]).toBe('Please enter a Frequency (Month/Weekly/Yearly)');
+    }
+  });
+
+  it('should fail for weekly until', () => {
+    try {
+      const rruleStr = buildBcRruleString(
+        new RRule({
+          dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+          freq: RRule.WEEKLY,
+          interval: 1,
+          until: new Date(Date.UTC(2017, 7, 13, 13, 2)),
+        })
+      );
+    }
+    catch (err: any) {
+      expect(JSON.parse(err.message)[0]).toBe('Please enter a Duration');
+    }
+  });
+
+  it('should fail for weekly', () => {
+    try {
+      const rruleStr = buildBcRruleString(
+        new RRule({
+          dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+          freq: RRule.WEEKLY,
+          interval: 1,
+        }),
+        '1H'
+      );
+    }
+    catch (err: any) {
+      expect(JSON.parse(err.message)[0]).toBe('Please enter a Until');
+    }
+  });
+});
+
+describe('recurrencesBetweenV2', () => {
+  it('should not bomb when 0 occurences', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 9, 13, 13, 2)),
+        count: 0,
+      }),
+      '1H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne);
+    expect(result).toHaveLength(0);
+  });
+
+  it('should work entering into +11 from +10 in Australia/Melbourne timezone', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 9, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.length).toBe(11);
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2017-08-03T13:02:00.000Z',
+      '2017-08-10T13:02:00.000Z',
+      '2017-08-17T13:02:00.000Z',
+      '2017-08-24T13:02:00.000Z',
+      '2017-08-31T13:02:00.000Z',
+      '2017-09-07T13:02:00.000Z',
+      '2017-09-14T13:02:00.000Z',
+      '2017-09-21T13:02:00.000Z',
+      '2017-09-28T13:02:00.000Z',
+      '2017-10-05T12:02:00.000Z',
+      '2017-10-12T12:02:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2017-08-03T14:02:00.000Z',
+      '2017-08-10T14:02:00.000Z',
+      '2017-08-17T14:02:00.000Z',
+      '2017-08-24T14:02:00.000Z',
+      '2017-08-31T14:02:00.000Z',
+      '2017-09-07T14:02:00.000Z',
+      '2017-09-14T14:02:00.000Z',
+      '2017-09-21T14:02:00.000Z',
+      '2017-09-28T14:02:00.000Z',
+      '2017-10-05T13:02:00.000Z',
+      '2017-10-12T13:02:00.000Z',
+    ]);
+  });
+
+  it('should work with a start date including only portion of date range', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 7, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 9, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date(Date.UTC(2017, 7, 17, 13, 2)));
+    expect(result.length).toBe(9);
+  });
+
+  it('should work entering into +10 from +11 in Australia/Melbourne timezone', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 2, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 4, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2017-03-03T13:02:00.000Z',
+      '2017-03-10T13:02:00.000Z',
+      '2017-03-17T13:02:00.000Z',
+      '2017-03-24T13:02:00.000Z',
+      '2017-03-31T13:02:00.000Z',
+      '2017-04-07T14:02:00.000Z',
+      '2017-04-14T14:02:00.000Z',
+      '2017-04-21T14:02:00.000Z',
+      '2017-04-28T14:02:00.000Z',
+      '2017-05-05T14:02:00.000Z',
+      '2017-05-12T14:02:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2017-03-03T14:02:00.000Z',
+      '2017-03-10T14:02:00.000Z',
+      '2017-03-17T14:02:00.000Z',
+      '2017-03-24T14:02:00.000Z',
+      '2017-03-31T14:02:00.000Z',
+      '2017-04-07T15:02:00.000Z',
+      '2017-04-14T15:02:00.000Z',
+      '2017-04-21T15:02:00.000Z',
+      '2017-04-28T15:02:00.000Z',
+      '2017-05-05T15:02:00.000Z',
+      '2017-05-12T15:02:00.000Z',
+    ]);
+  });
+
+  it('should work entering into +12 from +13 in Pacific/Auckland', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2017, 8, 3, 13, 2)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2017, 9, 13, 13, 2)),
+      }),
+      '1H'
+    );
+    const auckland = 'Pacific/Auckland';
+    const result = recurrencesBetweenV2(rruleStr, auckland, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2017-09-03T13:02:00.000Z',
+      '2017-09-10T13:02:00.000Z',
+      '2017-09-17T13:02:00.000Z',
+      '2017-09-24T12:02:00.000Z',
+      '2017-10-01T12:02:00.000Z',
+      '2017-10-08T12:02:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2017-09-03T14:02:00.000Z',
+      '2017-09-10T14:02:00.000Z',
+      '2017-09-17T14:02:00.000Z',
+      '2017-09-24T13:02:00.000Z',
+      '2017-10-01T13:02:00.000Z',
+      '2017-10-08T13:02:00.000Z',
+    ]);
+  });
+
+  it('should ignore shifts with to date over the until bound', () => {
+    const until = new Date(Date.UTC(2021, 3, 14, 3, 5, 8));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 8, 23, 3, 5, 8)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until,
+        byweekday: RRule.WE,
+      }),
+      '10H'
+    );
+    const auckland = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, auckland);
+    const resultsInBound = result.filter(({ to }) => DateTime.fromISO(to) < DateTime.fromJSDate(until));
+    expect(resultsInBound.length).toBe(result.length);
+  });
+
+  it('should pick all the wednesdays 13hrs Melbourne time', () => {
+    const until = new Date(Date.UTC(2020, 9, 13, 3, 5, 8));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 8, 23, 3, 5, 8)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until,
+        byweekday: RRule.WE,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-09-23T03:05:08.000Z',
+      '2020-09-30T03:05:08.000Z',
+      '2020-10-07T02:05:08.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-09-23T13:05:08.000Z',
+      '2020-09-30T13:05:08.000Z',
+      '2020-10-07T12:05:08.000Z',
+    ]);
+  });
+
+  it('should pick all the wednesdays 9hrs Melbourne time', () => {
+    const until = new Date(Date.UTC(2020, 9, 12, 23, 5, 8));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 8, 22, 23, 5, 8)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until,
+        byweekday: RRule.WE,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-09-22T23:05:08.000Z',
+      '2020-09-29T23:05:08.000Z',
+      '2020-10-06T22:05:08.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-09-23T09:05:08.000Z',
+      '2020-09-30T09:05:08.000Z',
+      '2020-10-07T08:05:08.000Z',
+    ]);
+  });
+
+  it('should pick all first day of the month 9hrs Melbourne time', () => {
+    const until = new Date(Date.UTC(2020, 10, 1, 23, 5, 8));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 6, 30, 23, 5, 8)),
+        freq: RRule.MONTHLY,
+        interval: 1,
+        until,
+        bymonthday: 1,
+        byhour: 9,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-07-31T23:05:08.000Z',
+      '2020-08-31T23:05:08.000Z',
+      '2020-09-30T23:05:08.000Z',
+      '2020-10-31T22:05:08.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-08-01T09:05:08.000Z',
+      '2020-09-01T09:05:08.000Z',
+      '2020-10-01T09:05:08.000Z',
+      '2020-11-01T08:05:08.000Z',
+    ]);
+  });
+
+  it('should pick last day of the month 9hrs Melbourne time', () => {
+    const until = new Date(Date.UTC(2020, 11, 1, 23, 0, 0));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 6, 31, 10, 23, 0, 0)),
+        freq: RRule.MONTHLY,
+        interval: 1,
+        until,
+        bymonthday: [30, 31],
+        bysetpos: -1,
+        byhour: 9,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-08-30T23:23:00.000Z',
+      '2020-09-29T23:23:00.000Z',
+      '2020-10-30T22:23:00.000Z',
+      '2020-11-29T22:23:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-08-31T09:23:00.000Z',
+      '2020-09-30T09:23:00.000Z',
+      '2020-10-31T08:23:00.000Z',
+      '2020-11-30T08:23:00.000Z',
+    ]);
+  });
+
+  it('should pick last day of the month 9hrs Melbourne time without by hour', () => {
+    const until = new Date(Date.UTC(2020, 11, 1, 23, 0, 0));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 6, 30, 23, 23, 0, 0)),
+        freq: RRule.MONTHLY,
+        interval: 1,
+        until,
+        bymonthday: [30, 31],
+        bysetpos: -1,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-07-30T23:23:00.000Z',
+      '2020-08-30T23:23:00.000Z',
+      '2020-09-29T23:23:00.000Z',
+      '2020-10-30T22:23:00.000Z',
+      '2020-11-29T22:23:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-07-31T09:23:00.000Z',
+      '2020-08-31T09:23:00.000Z',
+      '2020-09-30T09:23:00.000Z',
+      '2020-10-31T08:23:00.000Z',
+      '2020-11-30T08:23:00.000Z',
+    ]);
+  });
+
+  it('should pick last day of the month 9hrs Melbourne time without by hour until next year', () => {
+    const until = new Date(Date.UTC(2021, 11, 1, 23, 0, 0));
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2020, 6, 30, 23, 23, 0, 0)),
+        freq: RRule.MONTHLY,
+        interval: 3,
+        until,
+        bymonthday: [],
+        byweekday: RRule.WE,
+        bysetpos: 1,
+      }),
+      '10H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date('2017-01-01'));
+    expect(result.map((range) => range.from.toISOString())).toEqual([
+      '2020-10-06T22:23:00.000Z',
+      '2021-01-05T22:23:00.000Z',
+      '2021-04-06T23:23:00.000Z',
+      '2021-07-06T23:23:00.000Z',
+      '2021-10-05T22:23:00.000Z',
+    ]);
+    expect(result.map((range) => range.to.toISOString())).toEqual([
+      '2020-10-07T08:23:00.000Z',
+      '2021-01-06T08:23:00.000Z',
+      '2021-04-07T09:23:00.000Z',
+      '2021-07-07T09:23:00.000Z',
+      '2021-10-06T08:23:00.000Z',
+    ]);
+  });
+
+  it('should return flexible recurrences use end date', () => {
+    const rruleStr = buildBcRruleString(
+      new RRule({
+        dtstart: new Date(Date.UTC(2021, 7, 21, 14)),
+        freq: RRule.WEEKLY,
+        interval: 1,
+        until: new Date(Date.UTC(2021, 9, 13, 13, 59, 59)),
+      }),
+      '1H'
+    );
+    const melbourne = 'Australia/Melbourne';
+    const result = recurrencesBetweenV2(rruleStr, melbourne, new Date(Date.UTC(2021, 7, 21, 14)), true);
+    expect(result).toHaveLength(8);
+    expect(result[0].to.toISOString()).toBe(DateTime.fromJSDate(result[1].from).minus({ seconds: 1 }).toUTC().toISO());
+  });
+});

package/tsconfig.json

@@ -1,17 +1,20 @@
 {
   "compilerOptions": {
-    "lib": ["es2017"],
-    "esModuleInterop": true,
+    "lib": ["es2020"],
+    "target": "es2020",
+    "module": "commonjs",
     "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "sourceMap": true,
-    "target": "es2017",
-    "outDir": "lib"
+    "isolatedModules": true,
+    "module": "node20",
+    "moduleResolution": "node16",
+    "declaration": true,
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": false,
+    "types": ["node","jest"],
+    "esModuleInterop": true
   },
-  "exclude": ["node_modules", "setup.ts"]
+  "include": ["src"],
+  "exclude": ["node_modules", "**/tests/*", "setup.ts"]
 }