@globalpayments/vega 2.18.1 → 2.20.0

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

@@ -1,70 +0,0 @@
-import { CalendarDate } from '../../../../../../helpers/calendar';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** The `CalendarEventDailyRepeatPattern` class in TypeScript represents a daily repeating pattern for calendar events. */
-export class CalendarEventDailyRepeatPattern extends CalendarEventBaseRepeatPattern {
-  /**
-   * The constructor initializes the current date for a given date range and interval.
-   *
-   * @param {CalendarDate} startDate - The `startDate` parameter is of type `CalendarDate` and represents the starting date for a specific interval or range.
-   * @param {number} interval - The `interval` parameter represents the frequency at which the event
-   * occurs. For example, if the interval is set to 1, it means the event occurs every day. If the
-   * interval is set to 2, it means the event occurs every other day.
-   * @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
-   * `null`, the event will repeat indefinitely until the `until` date is reached.
-   * @param {Nullable<CalendarDate>} until - The `until` parameter in the constructor is of type `Nullable<CalendarDate>`, which
-   * means it can either accept a `CalendarDate` object or be `null`. This parameter 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.initCache();
-  }
-  /**
-   * The function generates and caches repeated dates before a specified end date.
-   *
-   * @param {CalendarDate} endDate - The `endDate` parameter represents the date until which you want to
-   * generate repeat dates in the cache. The function `generateRepeatDateCacheBeforeEndDate` is
-   * responsible for populating the cache with repeat dates until the specified `endDate`. It checks the
-   * last date in the cache and generates subsequent repeat dates until
-   */
-  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 `initCache` initializes a cache array with the `startDate` value.
-   */
-  initCache() {
-    this.cache = [this.repeatStartDate];
-  }
-  /**
-   * 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 an instance of the `CalendarDate` class.
-   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns either a `CalendarDate` object if certain
-   * conditions are met, or `null` if the conditions are not met.
-   */
-  getNextRepeatStartDate(date) {
-    const nextDate = new Date(date.year, date.month - 1, date.date + 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;
-    }
-  }
-}

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

@@ -1,90 +0,0 @@
-import { CalendarDate } from '../../../../../../helpers/calendar';
-import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
-/** The `CalendarEventMonthlyRepeatPattern` class in TypeScript represents a monthly repeat pattern for calendar events. */
-export class CalendarEventMonthlyRepeatPattern extends CalendarEventBaseRepeatPattern {
-  /**
-   * The constructor initializes the event with specified start and end dates, interval, count, and until date, and sets the byMonthDay property to the start date's day.
-   *
-   * @param {CalendarDate} startDate - The `startDate` parameter represents the starting date of the
-   * event or interval. It is of type `CalendarDate`, which likely includes the year, month, and day
-   * components of the date.
-   * @param {number} interval - The `interval` parameter specifies the frequency of the recurring
-   * events. 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 (or is `null`), the event will repeat indefinitely based on the other parameters like `
-   * @param {Nullable<CalendarDate>} until - The `until` parameter is a nullable `CalendarDate` that specifies the end date for
-   * the recurring event. If provided, the event will repeat until this date. If not provided, the event
-   * will repeat indefinitely based on the other parameters like `count` or `endDate`.
-   */
-  constructor(startDate, interval, count, until) {
-    super(startDate, interval, count, until);
-    this.byMonthDay = this.repeatStartDate.date;
-    this.initCache();
-  }
-  /**
-   * This function generates and caches repeated dates before a specified end date.
-   *
-   * @param {CalendarDate} endDate - The `endDate` parameter in the
-   * `generateRepeatDateCacheUntilEndDate` function is a CalendarDate object that represents the end
-   * date until which the repeat dates need to be generated and cached. The function checks if the last
-   * cached date is before the `endDate` and generates additional repeat dates until it reaches
-   */
-  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 `initCache` initializes a cache array with the startDate value.
-   */
-  initCache() {
-    this.cache = [this.repeatStartDate];
-  }
-  /**
-   * The getNextRepeatStartDate function calculates the next start date based on a given date and interval, considering constraints such as end date and count limit.
-   *
-   * @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`.
-   * @returns {Nullable<CalendarDate>} The function `getNextRepeatStartDate` returns a nullable `CalendarDate`. It either returns
-   * the next calculated `CalendarDate` based on the input date and interval, or it returns `null` if
-   * certain conditions are met (such as reaching the specified end date or count limit).
-   */
-  getNextRepeatStartDate(date) {
-    const nextDate = this.getNextStartDate(date.year, date.month - 1 + 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 date, if the date.getDate() not equal the fixed date, find the next month
-   *
-   * @param {number} year year
-   * @param {number} month month
-   * @returns {Date} the new date
-   */
-  getNextStartDate(year, month) {
-    const nextDate = new Date(year, month, this.byMonthDay);
-    if (nextDate.getDate() === this.byMonthDay) {
-      return nextDate;
-    }
-    else {
-      return this.getNextStartDate(year, month + 1);
-    }
-  }
-}

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

@@ -1,60 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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/fullDayEventLayout.js

@@ -1,42 +0,0 @@
-import { VegaCalendarBaseEventLayout } from './baseEventLayout';
-/** The VegaCalendarLongEventLayout class manages the layout of long events in a calendar by organizing them into rows. */
-export class VegaCalendarFullDayEventLayout extends VegaCalendarBaseEventLayout {
-  /**
-   * The constructor function initializes a VegaCalendarFullDayEventLayoutRow array in TypeScript.
-   *
-   * @param {VegaCalendarFullDayEventLayoutRow[]} rows - An array of VegaCalendarFullDayEventLayoutRow objects.
-   */
-  constructor(rows) {
-    super();
-    this.cells = rows;
-  }
-  /**
-   * This TypeScript function returns the index of a row containing a specific calendar event.
-   *
-   * @param {CalendarEvent} eventItem - The `eventItem` parameter is a `CalendarEvent` object that represents an event in a calendar.
-   * @returns {number} The function `getEventRowsIndex` returns the index of the row in the `rows` array where the `eventItem` is found based on the condition specified in the `findIndex` method.
-   */
-  getEventRowsIndex(eventItem) {
-    return this.cells.findIndex((row) => row.getEventStartIndex(eventItem) >= 0);
-  }
-  /**
-   * This function retrieves CalendarEvents from each row in a calendar layout based on a specified index.
-   *
-   * @param {number} index - The `index` parameter in the `getEventsByIndex` method is a number that
-   * represents the slot index for which you want to retrieve calendar events. The method iterates
-   * through each row in the `rows` array and retrieves the calendar event at the specified slot index from each row. The method
-   * @returns {(Nullable<CalendarEvent>)[]} An array of CalendarEvent objects is being returned.
-   */
-  getEventsByIndex(index) {
-    const result = [];
-    let lastItemIndex = 0;
-    this.cells.forEach((row, rowIndex) => {
-      const currentEvent = row.getEventBySlotIndex(index);
-      result.push(currentEvent);
-      if (currentEvent) {
-        lastItemIndex = rowIndex;
-      }
-    });
-    return result.slice(0, lastItemIndex + 1);
-  }
-}