Add isFinite, first & last to rrule & rruleset

src/parseoptions.ts

@@ -33,6 +33,15 @@ export function parseOptions (options: Partial<Options>) {
 
   if (!opts.dtstart) opts.dtstart = new Date(new Date().setMilliseconds(0))
 
+  // infinite count is handled by null
+  if (isNumber(opts.count)) {
+    if (opts.count === Number.POSITIVE_INFINITY) {
+      opts.count = null
+    } else if (!Number.isSafeInteger(opts.count)) {
+      throw new Error('Invalid option: Count can only be a safe integer, null, or positive infinity')
+    }
+  }
+
   if (!isPresent(opts.wkst)) {
     opts.wkst = RRule.MO.weekday
   } else if (isNumber(opts.wkst)) {

src/rrule.ts

@@ -158,6 +158,10 @@ export default class RRule implements QueryMethods {
       return this._iter(new CallbackIterResult('all', {}, iterator))
     }
 
+    if (!this.isFinite()) {
+      throw new Error('Calling RRule.all() without an iterator on this RRule would result in an infinite loop as its recurrence set is not finite')
+    }
+
     let result = this._cacheGet('all') as Date[] | false
     if (result === false) {
       result = this._iter(new IterResult('all', {}))
@@ -234,11 +238,51 @@ export default class RRule implements QueryMethods {
     return result as Date
   }
 
+  /**
+   * Returns the very first occurrence of this rrule if it exists, null otherwise
+   *
+   * @returns {Date | null}
+   */
+  first (): Date | null {
+    return this.after(this.options.dtstart, true) || null
+  }
+
+  /**
+   * Returns the last occurrence of this rrule if it exists, null otherwise
+   * @returns {Date | null}
+   */
+  last (): Date | null {
+    if (!this.isFinite()) {
+      return null
+    }
+
+    if (this.options.until) {
+      return this.before(this.options.until, true)
+    }
+
+    const allDates = this.all()
+    return allDates[allDates.length - 1] || null
+  }
+
+  /**
+   * Returns whether the number of recurrence in this set is finite.
+   * @returns {boolean}
+   */
+  isFinite (): boolean {
+    return this.options.until != null || this.options.count != null || this.options.interval === 0
+  }
+
   /**
    * Returns the number of recurrences in this set. It will have go trough
    * the whole recurrence, if this hasn't been done before.
+   *
+   * If the number of recurrence in this set is infinite, Positive infinity will be returned.
    */
   count (): number {
+    if (!this.isFinite()) {
+      return Number.POSITIVE_INFINITY
+    }
+
     return this.all().length
   }
 

src/rruleset.ts

@@ -136,6 +136,59 @@ export default class RRuleSet extends RRule {
     return this._exdate.map(e => new Date(e.getTime()))
   }
 
+  /**
+   * Returns the very first occurrence of this rrule set if it exists, null otherwise
+   *
+   * @returns {Date | null}
+   */
+  first (): Date | null {
+    let earliestDate = null
+    for (const rrule of this._rrule) {
+      if (!earliestDate || rrule.options.dtstart < earliestDate) {
+        earliestDate = rrule.options.dtstart
+      }
+    }
+
+    for (const rdate of this._rdate) {
+      if (!earliestDate || rdate < earliestDate) {
+        earliestDate = rdate
+      }
+    }
+
+    if (earliestDate == null) {
+      return null
+    }
+
+    return this.after(earliestDate, true)
+  }
+
+  /**
+   * Returns the last occurrence of this rrule set if it exists, null otherwise
+   * @returns {Date | null}
+   */
+  last (): Date | null {
+    if (!this.isFinite()) {
+      return null
+    }
+
+    const allDates = this.all()
+    return allDates[allDates.length - 1] || null
+  }
+
+  /**
+   * Returns whether the number of recurrence in this set is finite.
+   * @returns {boolean}
+   */
+  isFinite (): boolean {
+    for (const rrule of this._rrule) {
+      if (!rrule.isFinite()) {
+        return false
+      }
+    }
+
+    return true
+  }
+
   valueOf () {
     let result: string[] = []
 

test/lib/utils.ts

@@ -17,8 +17,8 @@ const assertDatesEqual = function (actual: Date | Date[], expected: Date | Date[
   for (let i = 0; i < expected.length; i++) {
     const act = actual[i]
     const exp = expected[i]
-    expect(exp instanceof Date ? exp.toString() : exp).to.equal(
-      act.toString(), msg + (i + 1) + '/' + expected.length)
+    expect(act.toString()).to.equal(
+      exp instanceof Date ? exp.toString() : exp, msg + (i + 1) + '/' + expected.length)
   }
 }
 

test/rrule.test.ts

@@ -35,7 +35,10 @@ describe('RRule', function () {
     'FREQ=HOURLY;INTERVAL=0;BYSETPOS=1;BYDAY=MO',
     'FREQ=MINUTELY;INTERVAL=0;BYSETPOS=1;BYDAY=MO',
     'FREQ=SECONDLY;INTERVAL=0;BYSETPOS=1;BYDAY=MO']
-    .map((s) => expect(rrulestr(s).count()).to.equal(0))
+    .map((s) => {
+      expect(rrulestr(s).count()).to.equal(0);
+      expect(rrulestr(s).isFinite()).to.equal(true);
+    })
   })
 
   it('does not mutate the passed-in options object', function () {
@@ -156,6 +159,76 @@ describe('RRule', function () {
     ]
   )
 
+  testRecurring('testFirst',
+    {
+      rrule: new RRule({
+        freq: RRule.DAILY,
+        dtstart: parse('19970902T090000')
+      }),
+      method: 'first'
+    },
+    [
+      datetime(1997, 9, 2, 9, 0)
+    ]
+  )
+
+  it('testLastZeroInterval', () => {
+    const rrule = new RRule({
+      freq: RRule.DAILY,
+      dtstart: parse('19970902T090000'),
+      interval: 0
+    })
+
+    expect(rrule.first()).to.equal(null)
+  })
+
+  testRecurring('testLastFiniteCount',
+    {
+      rrule: new RRule({
+        freq: RRule.DAILY,
+        dtstart: parse('19970902T090000'),
+        count: 4
+      }),
+      method: 'last'
+    },
+    [
+      datetime(1997, 9, 5, 9, 0)
+    ]
+  )
+
+  testRecurring('testLastFiniteUntil',
+    {
+      rrule: new RRule({
+        freq: RRule.DAILY,
+        dtstart: parse('19970902T090000'),
+        until: parse('19970910T090000')
+      }),
+      method: 'last'
+    },
+    [
+      datetime(1997, 9, 10, 9, 0)
+    ]
+  )
+
+  it('testLastInfinite', () => {
+    const rrule = new RRule({
+      freq: RRule.DAILY,
+      dtstart: parse('19970902T090000')
+    })
+
+    expect(rrule.last()).to.equal(null)
+  })
+
+  it('testLastZeroInterval', () => {
+    const rrule = new RRule({
+      freq: RRule.DAILY,
+      dtstart: parse('19970902T090000'),
+      interval: 0
+    })
+
+    expect(rrule.last()).to.equal(null)
+  })
+
   testRecurring('testYearly',
     new RRule({
       freq: RRule.YEARLY,