@globalpayments/vega 2.16.0 → 2.17.0

package/dist/collection/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventRepeatPatternFactory.js

@@ -0,0 +1,60 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { CalendarEventDailyRepeatPattern } from '../repeatPattern/calendarEventDailyRepeatPattern';
+import { CalendarEventMonthlyRepeatPattern } from '../repeatPattern/calendarEventMonthlyRepeatPattern';
+import { CalendarEventWeeklyRepeatPattern } from '../repeatPattern/calendarEventWeeklyRepeatPattern';
+import { CalendarEventYearlyRepeatPattern } from '../repeatPattern/calendarEventYearlyRepeatPattern';
+/** This code snippet defines a TypeScript class `CalendarEventRepeatPatternFactory` that serves as a factory for creating different types of repeat patterns for calendar events. Here's a breakdown of what the class and its methods are doing: */
+class CalendarEventRepeatPatternFactory {
+  /**
+   * This `getPattern` method within the `CalendarEventRepeatPatternFactory` class is a public method that is responsible for creating and returning a specific type of repeat pattern for a calendar event based on the input parameters provided. Here's a breakdown of what this method is doing:
+   *
+   * @param {Date} startDate repeat start date
+   * @param {VegaCalendarEventRepeatOptions|undefined} repeatOptions repeat options
+   * @returns {CalendarEventBaseRepeatPattern} the match repeat pattern
+   */
+  getPattern(startDate, repeatOptions) {
+    const repeatStartDate = CalendarDate.from(startDate);
+    const { frequency, interval = 1, byWeekDay, until, count, } = repeatOptions;
+    const repeatEndDate = this.initDate(until);
+    return this.initRepeatPattern(frequency, repeatStartDate, interval < 1 ? 1 : interval, count, repeatEndDate, byWeekDay);
+  }
+  /**
+   * The `initDate` function initializes a `CalendarDate` object based on the input date string or Date object provided.
+   *
+   * @param {Nullable<string | Date>} date - The `date` parameter can be either a string or a Date object.
+   * @returns {Nullable<CalendarDate>} The function `initDate` returns a `Nullable<CalendarDate>`, which means it can return either a `CalendarDate` object or `null`.
+   */
+  initDate(date) {
+    if (date && typeof date === 'object') {
+      return CalendarDate.from(date);
+    }
+    else if (date && typeof date === 'string') {
+      const [month, day, year] = date.split('/');
+      return new CalendarDate(Number(year), Number(month), Number(day));
+    }
+  }
+  /**
+   * The function `initRepeatPattern` initializes a repeat pattern based on the frequency specified for a calendar event.
+   *
+   * @param {VegaCalendarEventRepeatType} frequency event frequency
+   * @param {CalendarDate} repeatStartDate event start date
+   * @param {number} interval event repeat interval
+   * @param {Nullable<number>} count the event repeat count
+   * @param {Nullable<CalendarDate>} repeatEndDate repeat end date
+   * @param {Nullable<VegaCalendarWeekDayType[]>} byWeekDay weekly week days
+   * @returns {CalendarEventBaseRepeatPattern} calendar event repeat pattern instance
+   */
+  initRepeatPattern(frequency, repeatStartDate, interval, count, repeatEndDate, byWeekDay) {
+    switch (frequency) {
+      case 'daily':
+        return new CalendarEventDailyRepeatPattern(repeatStartDate, interval, count, repeatEndDate);
+      case 'weekly':
+        return new CalendarEventWeeklyRepeatPattern(repeatStartDate, interval, count, repeatEndDate, byWeekDay);
+      case 'monthly':
+        return new CalendarEventMonthlyRepeatPattern(repeatStartDate, interval, count, repeatEndDate);
+      default:
+        return new CalendarEventYearlyRepeatPattern(repeatStartDate, interval, count, repeatEndDate);
+    }
+  }
+}
+export default new CalendarEventRepeatPatternFactory();

package/dist/collection/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventWeeklyRepeatPattern.js

@@ -0,0 +1,163 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { flatNestedArray } from '../../../../../../utils/array';
+import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
+/** The `CalendarEventWeeklyRepeatPattern` class in TypeScript represents a weekly repeat pattern for calendar events, allowing for matching dates based on specific weekdays and generating future dates with optional constraints. */
+export class CalendarEventWeeklyRepeatPattern extends CalendarEventBaseRepeatPattern {
+  /**
+   * This TypeScript constructor initializes a calendar date range with specified parameters including start date, end date, interval, count, until date, and an array of week days.
+   *
+   * @param {CalendarDate} startDate - The `startDate` parameter represents the starting date of the
+   * calendar event or schedule. It is of type `CalendarDate`, which likely includes the year, month, and day components of a date.
+   * @param {number} interval - The `interval` parameter represents the frequency of the recurrence. For
+   * example, if `interval` is set to 1, the event will occur every week. If it's set to 2, the event
+   * will occur every two weeks.
+   * @param {Nullable<number>} count - The `count` parameter specifies the number of occurrences of the rule. If `count` is
+   * provided, the recurrence will generate at most that many occurrences. If `count` is not provided,
+   * the recurrence will continue indefinitely based on other parameters like `endDate` or `until`.
+   * @param {Nullable<CalendarDate>} until - The `until` parameter specifies the end date for the recurrence rule. If provided,
+   * the recurrence will continue until this date. If not provided, the recurrence will continue
+   * indefinitely based on other parameters like `count` or `interval`.
+   * @param {Nullable<VegaCalendarWeekDayType[]>} byWeekDay - The `byWeekDay` parameter is an array of
+   * `VegaCalendarWeekDayType` values, which represent the days of the week for which the event should occur.
+   */
+  constructor(startDate, interval, count, until, byWeekDay) {
+    super(startDate, interval, count, until);
+    this.byWeekDay = this.sortWeekDay(byWeekDay);
+    this.initCache();
+  }
+  /**
+   * The function `getRepeatSeries` retrieves a series of repeated events within a specified calendar period.
+   *
+   * @param {CalendarPeriod} period - The `period` parameter in the `getRepeatSeries` method represents
+   * a specific time period in the form of a `CalendarPeriod` object. This object typically contains a
+   * `startDate` and an `endDate`, which define the range of dates for which you want to generate repeat series.
+   * @param {number} eventSpansDays - the current repeat series cross days, default value is one
+   * @returns {CalendarDate[]} repeat start date array
+   */
+  getRepeatSeries(period, eventSpansDays = 1) {
+    this.generateRepeatDateCacheUntilEndDate(period.endDate);
+    return this.getValidCache().filter((item) => {
+      return this.isSeriesInPeriod(item, eventSpansDays, period);
+    });
+  }
+  /**
+   * This function generates repeated dates and caches them until a specified end date.
+   *
+   * @param {CalendarDate} endDate - The `endDate` parameter is a `CalendarDate` object that represents
+   * the date until which the repeat date cache needs to be generated. The function
+   * `generateRepeatDateCacheUntilEndDate` generates repeat dates until this specified end date.
+   */
+  generateRepeatDateCacheUntilEndDate(endDate) {
+    const lastMatchDate = this.cache[this.cache.length - 1];
+    if (lastMatchDate[0].toDate() < endDate.toDate() &&
+      (!this.count || (typeof this.count === 'number' && this.cache.length < this.count))) {
+      let nextMatchDate = this.getNextRepeatStartDate(lastMatchDate);
+      while (nextMatchDate && nextMatchDate[0].toDate() < endDate.toDate()) {
+        nextMatchDate = this.getNextRepeatStartDate(nextMatchDate);
+        if (typeof this.count === 'number' && this.getValidCache().length >= this.count) {
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * The function getNextRepeatStartDate calculates the next start dates based on a given array of CalendarDate objects and returns them if certain conditions are met.
+   *
+   * @param {CalendarDate[]} dates - The `dates` parameter is an array of `CalendarDate` objects.
+   * @returns {Nullable<CalendarDate[]>} The `getNextRepeatStartDate` function returns a nullable array of `CalendarDate` objects.
+   * If there are no next dates available or if the cache count exceeds a specified limit, it returns
+   * `null`. Otherwise, it returns an array of `CalendarDate` objects representing the next start dates.
+   */
+  getNextRepeatStartDate(dates) {
+    const nextDate = this.getNextStartDates(dates);
+    if (nextDate.length === 0 ||
+      (typeof this.count === 'number' && this.getValidCache().length >= this.count)) {
+      return null;
+    }
+    else {
+      const nextCalendarDates = nextDate.map((item) => CalendarDate.from(item));
+      this.cache.push(nextCalendarDates);
+      return nextCalendarDates;
+    }
+  }
+  /**
+   * The function `getNextStartDates` takes an array of `CalendarDate` objects, calculates the next dates based on a specified interval, and filters out dates that are after a specified end date.
+   *
+   * @param {CalendarDate[]} dates - The `dates` parameter is an array of `CalendarDate` objects
+   * representing specific dates in a calendar. Each `CalendarDate` object has properties for the year,
+   * month, and date.
+   * @returns {Date[]} The `getNextStartDates` function returns an array of `Date` objects representing the next
+   * start dates based on the input `CalendarDate` array. The function calculates the next start dates
+   * by adding a specific interval (multiplied by 7 to represent weeks) to each date in the input array.
+   * Finally, it filters out any dates that are after a specified `until` date, if provided.
+   */
+  getNextStartDates(dates) {
+    const nextDates = dates.map((dateItem) => new Date(dateItem.year, dateItem.month - 1, dateItem.date + this.interval * 7));
+    return nextDates.filter((item) => !this.until || item <= this.until.toDate());
+  }
+  /**
+   * The `initCache` function initializes a cache of calendar dates based on the start date and weekly repeat pattern.
+   */
+  initCache() {
+    const result = [];
+    const currentWeekDayIndex = this.getCurrentDayIndex(this.repeatStartDate);
+    this.byWeekDay.forEach((day) => {
+      const index = CalendarEventWeeklyRepeatPattern.weekDay.indexOf(day);
+      const days = index - currentWeekDayIndex;
+      const { year, month, date } = this.repeatStartDate;
+      const dateItem = CalendarDate.from(new Date(year, month - 1, date + days));
+      result.push(dateItem);
+    });
+    this.cache = [result];
+  }
+  /**
+   * The function `sortWeekDay` sorts an array of week days based on their position in a predefined list.
+   *
+   * @param {boolean} weekDay - The `weekDay` parameter is an array of week day values that need to be sorted in a
+   * specific order. The function `sortWeekDay` takes this array and sorts it based on a predefined
+   * order specified in `CalendarEventWeeklyRepeatPattern.weekDay`.
+   * @returns {VegaCalendarWeekDayType[]} The `sortWeekDay` function is returning the `weekDay` array sorted based on the index of
+   * each `VegaCalendarWeekDayType` item in the `CalendarEventWeeklyRepeatPattern.weekDay` array.
+   */
+  sortWeekDay(weekDay) {
+    if (weekDay && weekDay.length) {
+      return weekDay
+        .map((item) => item.toLocaleLowerCase())
+        .sort((itemA, itemB) => {
+        return (CalendarEventWeeklyRepeatPattern.weekDay.indexOf(itemA) -
+          CalendarEventWeeklyRepeatPattern.weekDay.indexOf(itemB));
+      });
+    }
+    else {
+      return [CalendarEventWeeklyRepeatPattern.weekDay[this.getCurrentDayIndex(this.repeatStartDate)]];
+    }
+  }
+  /**
+   * This function returns the index of the current day in a week, with Sunday represented as 0.
+   *
+   * @param {CalendarDate} date - The `date` parameter in the `getCurrentDayIndex` function is of type
+   * `CalendarDate`, which is a custom data type representing a date in a calendar.
+   * @returns {number} The function `getCurrentDayIndex` returns the index of the current day in the week, with
+   * Sunday being represented as 0 and Saturday being represented as 6.
+   */
+  getCurrentDayIndex(date) {
+    return date.toDate().getDay();
+  }
+  /**
+   * The function `getValidCache` returns a filtered and concatenated array of CalendarDate objects from the cache based on a start date.
+   *
+   * @returns {CalendarDate[]} The `getValidCache` method returns an array of `CalendarDate` objects that meet the
+   * condition of having a date greater than or equal to the `startDate` property. The method first
+   * flattens a nested array of `CalendarDate` objects stored in the `cache` property, then filters out
+   * the `CalendarDate` objects that do not meet the condition, and finally concatenates the filtered
+   * array
+   */
+  getValidCache() {
+    const flatArr = flatNestedArray(this.cache.slice(1));
+    return this.cache[0]
+      .filter((item) => item.toDate() >= this.repeatStartDate.toDate())
+      .concat(flatArr)
+      .slice(0, typeof this.count === 'number' ? this.count : undefined);
+  }
+}
+CalendarEventWeeklyRepeatPattern.weekDay = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].map((item) => item.toLowerCase());

package/dist/collection/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventYearlyRepeatPattern.js

@@ -0,0 +1,92 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
+/** The `CalendarEventYearlyRepeatPattern` class defines a yearly repeat pattern for calendar events, checking for matches and generating future dates based on specified criteria. */
+export class CalendarEventYearlyRepeatPattern extends CalendarEventBaseRepeatPattern {
+  /**
+   * The constructor initializes a new instance with specified start and end dates, interval, count, and until date.
+   *
+   * @param {CalendarDate} startDate - The `startDate` parameter is of type `CalendarDate` and
+   * represents the starting date of a calendar event or interval.
+   * @param {number} interval - The `interval` parameter represents the frequency at which the event
+   * occurs. For example, if the interval is set to 2, the event will occur every 2 units of time (days,
+   * weeks, months, etc.).
+   * @param {Nullable<number>} count - The `count` parameter specifies the number of occurrences of the event. If `count`
+   * is provided, the event will repeat `count` times within the specified interval. If `count` is not
+   * provided, the event will repeat indefinitely based on the other parameters like `endDate` or
+   * `until`.
+   * @param {Nullable<CalendarDate>} until - The `until` parameter in the constructor is of type `Nullable<CalendarDate>`. This
+   * means that it can either accept a `CalendarDate` object or be `null`. It is used to specify a date
+   * until which the recurring event should repeat. If `until` is provided, the event
+   */
+  constructor(startDate, interval, count, until) {
+    super(startDate, interval, count, until);
+    this.matchDay = this.repeatStartDate.date;
+    this.matchMonth = this.repeatStartDate.month;
+    this.initCache();
+  }
+  /**
+   * The function generates repeat dates and caches them until reaching the specified end date.
+   *
+   * @param {CalendarDate} endDate - The `endDate` parameter in the
+   * `generateRepeatDateCacheUntilEndDate` function is a CalendarDate object that represents the date
+   * until which the repeat date cache should be generated. The function checks if the last date in the
+   * cache is before the `endDate`, and if so, it generates additional repeat dates
+   */
+  generateRepeatDateCacheUntilEndDate(endDate) {
+    const lastMatchDate = this.cache[this.cache.length - 1];
+    if (lastMatchDate.toDate() < endDate.toDate() &&
+      (!this.count || (typeof this.count === 'number' && this.cache.length < this.count))) {
+      let nextMatchDate = this.getNextRepeatStartDate(lastMatchDate);
+      while (nextMatchDate && nextMatchDate.toDate() < endDate.toDate()) {
+        nextMatchDate = this.getNextRepeatStartDate(nextMatchDate);
+        if (typeof this.count === 'number' && this.cache.length >= this.count) {
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * The function getNextRepeatStartDate calculates the next repeat start date based on a given date and certain conditions.
+   *
+   * @param {CalendarDate} date - The `date` parameter represents the current date for which you want to
+   * calculate the next repeat start date. It is of type `CalendarDate`, which seems to be a custom
+   * class or structure that holds year, month, and day information.
+   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns either a `CalendarDate` object or `null`
+   * based on certain conditions. If the next date exceeds the `until` date or the count limit has been
+   * reached, it returns `null`. Otherwise, it adds the next date to the cache and returns it as a
+   * `CalendarDate`.
+   */
+  getNextRepeatStartDate(date) {
+    const nextDate = this.getNextStartDate(date.year + this.interval);
+    const nextCalendarDate = CalendarDate.from(nextDate);
+    if ((this.until && nextDate > this.until.toDate()) ||
+      (typeof this.count === 'number' && this.cache.length >= this.count)) {
+      return null;
+    }
+    else {
+      this.cache.push(nextCalendarDate);
+      return nextCalendarDate;
+    }
+  }
+  /**
+   * get the new date with fixed month and fixed date, if the date.getDate() not equal the fixed date or fixed month, find the next year
+   *
+   * @param {number} year year
+   * @returns {Date} the new date
+   */
+  getNextStartDate(year) {
+    const nextDate = new Date(year, this.matchMonth - 1, this.matchDay);
+    if (nextDate.getDate() === this.matchDay && nextDate.getMonth() + 1 === this.matchMonth) {
+      return nextDate;
+    }
+    else {
+      return this.getNextStartDate(year + 1);
+    }
+  }
+  /**
+   * The function `initCache` initializes a cache array with the `startDate` value.
+   */
+  initCache() {
+    this.cache = [this.repeatStartDate];
+  }
+}

package/dist/collection/components/vega-calendar/slimmers/common/helpers/test/calendarEventRepeatPatternFactory.test.js

@@ -0,0 +1,105 @@
+import { CalendarDate, DayPeriod, MonthPeriod } from '../../../../../../helpers/calendar';
+import calendarEventRepeatPatternFactory from '../repeatPattern/calendarEventRepeatPatternFactory';
+import { CalendarEventDailyRepeatPattern } from '../repeatPattern/calendarEventDailyRepeatPattern';
+import { CalendarEventMonthlyRepeatPattern } from '../repeatPattern/calendarEventMonthlyRepeatPattern';
+import { CalendarEventWeeklyRepeatPattern } from '../repeatPattern/calendarEventWeeklyRepeatPattern';
+import { CalendarEventYearlyRepeatPattern } from '../repeatPattern/calendarEventYearlyRepeatPattern';
+const dailyRepeatOptions = {
+  frequency: 'daily',
+  interval: 1,
+  until: '01/02/2024',
+};
+const weeklyRepeatOptions = {
+  frequency: 'weekly',
+  interval: 1,
+  count: 2,
+  byWeekDay: ['Mon', 'Wed'],
+};
+const monthlyRepeatOptions = {
+  frequency: 'monthly',
+  interval: 1,
+  count: 2,
+};
+const yearlyRepeatOptions = {
+  frequency: 'yearly',
+  interval: 1,
+  count: 2,
+};
+describe('calendarEventRepeatPatternFactory', () => {
+  it('calendarEventRepeatPatternFactory#dailyPattern', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), dailyRepeatOptions);
+    expect(pattern instanceof CalendarEventDailyRepeatPattern).toBeTruthy();
+    const result = pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 1, 1)));
+    expect(result.length).toEqual(2);
+    expect(result[0].date).toEqual(1);
+    expect(result[1].date).toEqual(2);
+  });
+  it('calendarEventRepeatPatternFactory#dailyPattern in default options', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), { frequency: 'daily' });
+    expect(pattern instanceof CalendarEventDailyRepeatPattern).toBeTruthy();
+    expect(pattern['interval']).toEqual(1);
+  });
+  it('calendarEventRepeatPatternFactory#dailyPattern interval set to zero', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), { frequency: 'daily', interval: 0 });
+    expect(pattern instanceof CalendarEventDailyRepeatPattern).toBeTruthy();
+    expect(pattern['interval']).toEqual(1);
+  });
+  it('calendarEventRepeatPatternFactory#weeklyPattern', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), weeklyRepeatOptions);
+    expect(pattern instanceof CalendarEventWeeklyRepeatPattern).toBeTruthy();
+    const result = pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 1, 1)));
+    expect(result.length).toEqual(2);
+    expect(result[0].date).toEqual(1);
+    expect(result[1].date).toEqual(3);
+  });
+  it('calendarEventRepeatPatternFactory#weeklyPattern', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), {
+      frequency: 'weekly',
+      interval: 1,
+    });
+    expect(pattern instanceof CalendarEventWeeklyRepeatPattern).toBeTruthy();
+    expect(pattern['byWeekDay']).toEqual(['Mon'.toLowerCase()]);
+  });
+  it('calendarEventRepeatPatternFactory#monthlyPattern', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), Object.assign(Object.assign({}, monthlyRepeatOptions), { interval: 2 }));
+    expect(pattern instanceof CalendarEventMonthlyRepeatPattern).toBeTruthy();
+    const result = pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 1, 1)), 2);
+    expect(result.length).toEqual(1);
+    expect(result[0]).toEqual(new CalendarDate(2024, 1, 1));
+  });
+  it('calendarEventRepeatPatternFactory#yearlyPattern', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), yearlyRepeatOptions);
+    expect(pattern instanceof CalendarEventYearlyRepeatPattern).toBeTruthy();
+    const result = pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 1, 1)), 2);
+    expect(result.length).toEqual(1);
+    expect(result[0]).toEqual(new CalendarDate(2024, 1, 1));
+  });
+  it('calendarEventRepeatPatternFactory#yearlyPattern getRepeatSeries', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 6, 1), { frequency: 'weekly', interval: 1, until: '07/08/2024' });
+    expect(pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 7, 1)), 2)).toEqual([
+      CalendarDate.from(new Date(2024, 6, 1)),
+      CalendarDate.from(new Date(2024, 6, 8)),
+    ]);
+  });
+  it('calendarEventRepeatPatternFactory#dailyPattern getRepeatSeries', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 5, 30), { frequency: 'daily', interval: 3, until: '07/12/2024' });
+    expect(pattern.getRepeatSeries(new MonthPeriod(new CalendarDate(2024, 7, 1)), 2)).toEqual([
+      CalendarDate.from(new Date(2024, 5, 30)),
+      CalendarDate.from(new Date(2024, 6, 3)),
+      CalendarDate.from(new Date(2024, 6, 6)),
+      CalendarDate.from(new Date(2024, 6, 9)),
+      CalendarDate.from(new Date(2024, 6, 12)),
+    ]);
+  });
+  it('calendarEventRepeatPatternFactory#dailyPattern isSeriesInPeriod monthPeriod', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 6, 27), { frequency: 'monthly', interval: 1, count: 2 });
+    const monthPeriod = new MonthPeriod(new CalendarDate(2024, 8, 1));
+    expect(pattern['isSeriesInPeriod'](new CalendarDate(2024, 7, 27), 3, monthPeriod)).toBeTruthy();
+    expect(pattern['isSeriesInPeriod'](new CalendarDate(2024, 8, 27), 3, monthPeriod)).toBeTruthy();
+  });
+  it('calendarEventRepeatPatternFactory#dailyPattern isSeriesInPeriod dayPeriod', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 6, 31), { frequency: 'monthly', interval: 1, count: 2 });
+    const dayPeriod = new DayPeriod(new CalendarDate(2024, 8, 1));
+    expect(pattern['isSeriesInPeriod'](new CalendarDate(2024, 7, 31), 3, dayPeriod)).toBeTruthy();
+  });
+});

package/dist/collection/components/vega-calendar/slimmers/common/layout/test/longEventLayoutGenerator.test.js

@@ -9,7 +9,6 @@ const mockEvents1 = [
     startTime: '10:00',
     endTime: '11:00',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
   },
@@ -21,7 +20,6 @@ const mockEvents1 = [
     startTime: '10:00',
     endTime: '10:15',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
     color: '#73E6DC',
@@ -36,7 +34,6 @@ const mockEvents2 = [
     startTime: '10:00',
     endTime: '11:00',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
   },
@@ -48,7 +45,6 @@ const mockEvents2 = [
     startTime: '10:30',
     endTime: '11:30',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'secondary',
     color: '#806BFF',
@@ -63,7 +59,6 @@ const mockEvent4 = [
     startTime: '10:00',
     endTime: '10:15',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
     color: '#73E6DC',

package/dist/collection/components/vega-calendar/slimmers/common/renderers/vega-calendar-switch-panel.js

@@ -22,7 +22,7 @@ export class VegaCalendarSwitchPanelRenderer extends VegaSlimmer {
      * @param {NotifyObserverPayload<VegaCalendarViewModeType>} input mark which view should be selected
      */
     this.handleViewChange = (input) => {
-      this.calendarViewController.setViewMode(input.detail);
+      this.currentPeriodController.updateCalendarPeriod(input.detail, this.currentPeriod.current);
     };
     /**
      * reset view content to today

package/dist/collection/components/vega-calendar/slimmers/day-view/renderers/timed-event/layout/test/dayViewEventLayoutGenerator.test.js

@@ -9,7 +9,6 @@ const mockEvents = [
     startTime: '10:00',
     endTime: '11:00',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
   },
@@ -21,7 +20,6 @@ const mockEvents = [
     startTime: '10:00',
     endTime: '10:15',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'primary',
     color: '#73E6DC',
@@ -34,7 +32,6 @@ const mockEvents = [
     startTime: '10:30',
     endTime: '11:30',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'secondary',
     color: '#806BFF',
@@ -47,7 +44,6 @@ const mockEvents = [
     startTime: '10:45',
     endTime: '11:00',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'secondary',
     color: '#806BFF',
@@ -60,7 +56,6 @@ const mockEvents = [
     startTime: '11:00',
     endTime: '12:00',
     isAllDay: false,
-    repeat: 'none',
     disabled: false,
     variant: 'secondary',
     color: '#806BFF',

package/dist/collection/components/vega-calendar/slimmers/day-view/renderers/vega-calendar-view-with-time-renderer.js

@@ -51,7 +51,7 @@ export class VegaCalendarViewWithTimeRenderer extends VegaSlimmer {
         h("div", { class: "calendar-view-content" }, source.map((item) => {
           return (h("div", { class: "grid-col border-divider-left", key: item.date },
             h("div", { class: "hour-empty border-divider-top" }),
-            this.renderHourBlock()));
+            this.renderHourBlock(item)));
         })),
         this.dayViewTimedEventRenderer.render(),
         this.timeLineRenderer.renderTimeMarker(source))));
@@ -59,14 +59,28 @@ export class VegaCalendarViewWithTimeRenderer extends VegaSlimmer {
   /**
    * The function `renderHourBlock` returns an array of HTML elements representing hour blocks with time information.
    *
+   * @param {CalendarDate} calendarDate then current calendar date object
    * @returns {HTMLElement[]} An array of HTMLElements is being returned. Each HTMLElement represents an hour block with a time value inside a div element.
    */
-  renderHourBlock() {
+  renderHourBlock(calendarDate) {
     const timeLineSource = Array(24).fill('');
-    return timeLineSource.map(() => {
-      return h("div", { class: "grid-cell border-divider-top" });
+    return timeLineSource.map((_item, index) => {
+      return (h("div", { class: "grid-cell border-divider-top", 
+        // eslint-disable-next-line react/jsx-no-bind
+        onDblClick: () => {
+          this.handleDateBlockClick(calendarDate, index);
+        } }));
     });
   }
+  /**
+   * emit vega click event when click the date block
+   *
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  handleDateBlockClick(calendarDate, hour) {
+    const { year, month, date } = calendarDate;
+    this.dateDblClickEmitter.emit({ year, month, date, hour });
+  }
 }
 __decorate([
   MapToComponentField()
@@ -86,3 +100,6 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaCalendarViewWithTimeRenderer.prototype, "calendarViewController", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCalendarViewWithTimeRenderer.prototype, "dateDblClickEmitter", void 0);

package/dist/collection/components/vega-calendar/slimmers/month-view/renderers/vega-calendar-month-view-renderer.js

@@ -37,7 +37,9 @@ export class VegaCalendarMonthViewRenderer extends VegaSlimmer {
             'current-month-day': item.compare(currentDate).inMonth,
             'active': item.isToday(),
             'disabled': false,
-          }, key: `${item.month}-${item.date}` },
+          }, key: `${item.month}-${item.date}`, 
+          // eslint-disable-next-line react/jsx-no-bind
+          onDblClick: (e) => this.handleDateBlockClick(e, item) },
           this.renderDateBlock(item),
           this.monthEventRenderer.render(item, eventsArray[itemIndex], displayEventsArray[itemIndex], itemIndex)));
       })));
@@ -53,7 +55,42 @@ export class VegaCalendarMonthViewRenderer extends VegaSlimmer {
     const isMonthFirstDay = item.date === 1;
     return (h("div", { class: "date" },
       isMonthFirstDay && h("div", { class: "month-block" }, getMonthName(item.toDate(), true)),
-      h("div", { role: "button", tabIndex: 0, class: "grid-col" }, item.date)));
+      h("div", { role: "button", tabIndex: 0, class: "grid-col", 
+        // eslint-disable-next-line react/jsx-no-bind
+        onDblClick: (e) => this.goToCurrentDayView(e, item) }, item.date)));
+  }
+  /**
+   * switch to current date day view
+   *
+   * @param {MouseEvent} e the double click event object
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  goToCurrentDayView(e, calendarDate) {
+    e.stopPropagation();
+    this.currentPeriodController.updateCalendarPeriod('day', calendarDate);
+  }
+  /**
+   * emit vega click event when click the date block
+   *
+   * @param {MouseEvent} e the mouse event object
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  handleDateBlockClick(e, calendarDate) {
+    const target = e.target;
+    if (this.isMonthBlockBlankArea(target)) {
+      const { year, month, date } = calendarDate;
+      this.dateDblClickEmitter.emit({ year, month, date, hour: 0 });
+    }
+  }
+  /**
+   * determine if the clicked element is blank area
+   *
+   * @param {HTMLElement} element the target element
+   * @returns {boolean} true or false
+   */
+  isMonthBlockBlankArea(element) {
+    // the more button and the calendar event component should not trigger dateDblClick event
+    return !element.classList.contains('more-button') && element.tagName !== 'VEGA-CALENDAR-EVENT';
   }
 }
 __decorate([
@@ -68,6 +105,12 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaCalendarMonthViewRenderer.prototype, "calendarViewController", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCalendarMonthViewRenderer.prototype, "currentPeriodController", void 0);
 __decorate([
   MapToComponentField()
 ], VegaCalendarMonthViewRenderer.prototype, "monthEventRenderer", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCalendarMonthViewRenderer.prototype, "dateDblClickEmitter", void 0);

package/dist/collection/components/vega-calendar/vega-calendar.css

@@ -336,7 +336,6 @@
   }
 }
 .calendar-view-container .calendar-view-title .week-day {
-  cursor: pointer;
   color: rgba(var(--v-text-primary, 32, 54, 69, 1));
   font-family: "Inter", sans-serif;
   font-size: 20px;