@heartlandone/vega-sandbox-pr-1455-d20754632ba30d960fe2d750e022c5b897306226 2.28.0

package/dist/collection/components/vega-calendar/slimmers/common/helpers/repeat-pattern/calendar-event-weekly-repeat-pattern.js

@@ -0,0 +1,171 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { flatNestedArray } from '../../../../../../utils/array';
+import { CalendarEventBaseRepeatPattern } from './base-repeat-pattern';
+/** 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()) {
+        const newNextMatchDate = this.getNextRepeatStartDate(nextMatchDate);
+        //The below if block is used to break the infinite loop when the `getNextRepeatStartDate` method return unexpected result. such as when the date is greater than a certain value, it will be returned back 1900.
+        if (newNextMatchDate &&
+          newNextMatchDate[0] &&
+          newNextMatchDate[0].toDate() <= nextMatchDate[0].toDate()) {
+          this.cache.pop();
+          break;
+        }
+        nextMatchDate = newNextMatchDate;
+        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/repeat-pattern/calendar-event-yearly-repeat-pattern.js

@@ -0,0 +1,98 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { CalendarEventBaseRepeatPattern } from './base-repeat-pattern';
+/** 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()) {
+        const newNextMatchDate = this.getNextRepeatStartDate(nextMatchDate);
+        //The below if block is used to break the infinite loop when the `getNextRepeatStartDate` method return unexpected result. such as when the date is greater than a certain value, it will be returned back 1900.
+        if (newNextMatchDate && newNextMatchDate.toDate() <= nextMatchDate.toDate()) {
+          this.cache.pop();
+          break;
+        }
+        nextMatchDate = newNextMatchDate;
+        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/calendar-event-repeat-pattern-factory.test.js

@@ -0,0 +1,161 @@
+import { CalendarDate, DayPeriod, MonthPeriod } from '../../../../../../helpers/calendar';
+import calendarEventRepeatPatternFactory from '../repeat-pattern/calendar-event-repeat-pattern-factory';
+import { CalendarEventDailyRepeatPattern } from '../repeat-pattern/calendar-event-daily-repeat-pattern';
+import { CalendarEventMonthlyRepeatPattern } from '../repeat-pattern/calendar-event-monthly-repeat-pattern';
+import { CalendarEventWeeklyRepeatPattern } from '../repeat-pattern/calendar-event-weekly-repeat-pattern';
+import { CalendarEventYearlyRepeatPattern } from '../repeat-pattern/calendar-event-yearly-repeat-pattern';
+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();
+  });
+  it('dailyPattern#generateRepeatDateCacheUntilEndDate  boundary testing', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), {
+      frequency: 'daily',
+      interval: 1,
+      until: '01/04/2024',
+    });
+    spyOn(CalendarDate, 'from').and.callFake(function (item) {
+      return item.getDate() === 3
+        ? new CalendarDate(item.getFullYear(), 1, 1)
+        : new CalendarDate(item.getFullYear(), item.getMonth() + 1, item.getDate());
+    });
+    pattern['generateRepeatDateCacheUntilEndDate'](CalendarDate.from(new Date(2024, 1, 1)));
+    expect(pattern['cache'].length).toEqual(2);
+  });
+  it('monthlyPattern#generateRepeatDateCacheUntilEndDate boundary testing', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), {
+      frequency: 'monthly',
+      interval: 1,
+      until: '04/03/2024',
+    });
+    spyOn(CalendarDate, 'from').and.callFake(function (item) {
+      return item.getMonth() === 2
+        ? new CalendarDate(item.getFullYear(), 1, 1)
+        : new CalendarDate(item.getFullYear(), item.getMonth() + 1, item.getDate());
+    });
+    pattern['generateRepeatDateCacheUntilEndDate'](CalendarDate.from(new Date(2024, 4, 1)));
+    expect(pattern['cache'].length).toEqual(2);
+  });
+  it('yearlyPattern#generateRepeatDateCacheUntilEndDate boundary testing', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), {
+      frequency: 'yearly',
+      interval: 1,
+      until: '03/03/2027',
+    });
+    spyOn(CalendarDate, 'from').and.callFake(function (item) {
+      return item.getFullYear() === 2026
+        ? new CalendarDate(1900, 1, 1)
+        : new CalendarDate(item.getFullYear(), item.getMonth() + 1, item.getDate());
+    });
+    pattern['generateRepeatDateCacheUntilEndDate'](CalendarDate.from(new Date(2028, 1, 1)));
+    expect(pattern['cache'].length).toEqual(2);
+  });
+  it('weeklyPattern#generateRepeatDateCacheUntilEndDate boundary testing', () => {
+    const pattern = calendarEventRepeatPatternFactory.getPattern(new Date(2024, 0, 1), {
+      frequency: 'weekly',
+      interval: 1,
+      until: '02/01/2024',
+    });
+    spyOn(CalendarDate, 'from').and.callFake(function (item) {
+      return item.getDate() === 15
+        ? new CalendarDate(item.getFullYear(), 1, 1)
+        : new CalendarDate(item.getFullYear(), item.getMonth() + 1, item.getDate());
+    });
+    pattern['generateRepeatDateCacheUntilEndDate'](CalendarDate.from(new Date(2024, 3, 1)));
+    expect(pattern['cache'].length).toEqual(2);
+  });
+});

package/dist/collection/components/vega-calendar/slimmers/common/layout/base-event-layout-cell.js

@@ -0,0 +1,43 @@
+/** This code snippet is defining an abstract class named `VegaCalendarBaseEventLayoutCell`. Here's a breakdown of what it does: */
+export class VegaCalendarBaseEventLayoutCell {
+  /**
+   * This function retrieves a calendar event based on the slot index provided.
+   *
+   * @param {number} index - The `index` parameter is a number that represents the position of a slot in an array.
+   * @returns {CalendarEvent | null} The `getEventBySlotIndex` method is returning a `CalendarEvent` object from the `slots` array at the specified `index`.
+   */
+  getEventBySlotIndex(index) {
+    return this.slots[index];
+  }
+  /**
+   * The function `getEventStartIndex` returns the index of a given `CalendarEvent` object within an array of `CalendarEvent` objects.
+   *
+   * @param {CalendarEvent} eventItem - CalendarEvent
+   * @returns {number} The function `getEventStartIndex` returns the index of the `eventItem` within the `slots` array.
+   */
+  getEventStartIndex(eventItem) {
+    return this.slots.findIndex((item) => item === eventItem);
+  }
+  /**
+   * This TypeScript function calculates the end index of a calendar event within a specified range of slots.
+   *
+   * @param {CalendarEvent} eventItem - CalendarEvent - the event item for which we want to find the end index in the calendar.
+   * @returns {number} The `getEventEndIndex` function returns the index of the end of the calendar event in the `VegaCalendarLongEventLayoutRow.defaultSlots` array.
+   */
+  getEventEndIndex(eventItem) {
+    const startIndex = this.getEventStartIndex(eventItem);
+    let endIndex = startIndex;
+    if (startIndex >= 0) {
+      for (let i = startIndex + 1; i < this.slots.length; i++) {
+        if (this.slots[i] !== eventItem) {
+          endIndex = i - 1;
+          break;
+        }
+        else if (i === this.slots.length - 1) {
+          endIndex = i;
+        }
+      }
+    }
+    return endIndex;
+  }
+}

package/dist/collection/components/vega-calendar/slimmers/common/layout/base-event-layout-generator.js

@@ -0,0 +1,23 @@
+/** This code snippet is defining an abstract class named `VegaCalendarBaseEventLayoutGenerator` in TypeScript. The class contains an abstract method `generate` that must be implemented by any class that extends `VegaCalendarBaseEventLayoutGenerator`. */
+export class VegaCalendarBaseEventLayoutGenerator {
+  /**
+   * The function `addCurrentEventToLayout` adds a long event view to a layout row without overlapping with existing events.
+   *
+   * @param {VegaCalendarBaseEventLayoutCell[]} layoutCells - The `layoutCells` parameter is an array of
+   * `VegaCalendarBaseEventLayoutCell` objects. These objects represent rows in a layout where long events are displayed without overlapping each other.
+   * @param {unknown} input - The `currentView` parameter represents the current long event view that you want to add to the layout rows without overlapping with existing events. The function `addCurrentEventToLayoutRow` searches for a layout row that does not have any overlap with the current view. If such a row is found,
+   */
+  addCurrentEventToLayout(layoutCells, input) {
+    let noOverlapCell = layoutCells.find((layoutCell) => {
+      return !layoutCell.hasOverlapEvent(input);
+    });
+    if (!noOverlapCell) {
+      noOverlapCell = this.createNewLayoutCell();
+      noOverlapCell.updateSlots(input);
+      layoutCells.push(noOverlapCell);
+    }
+    else {
+      noOverlapCell.updateSlots(input);
+    }
+  }
+}

package/dist/collection/components/vega-calendar/slimmers/common/layout/base-event-layout.js

@@ -0,0 +1,11 @@
+/** This TypeScript code snippet defines an abstract class `VegaCalendarBaseEventLayout` that serves as a base for event layout functionality in a calendar application. */
+export class VegaCalendarBaseEventLayout {
+  /**
+   * The function returns an array of VegaCalendarBaseEventLayoutCell objects.
+   *
+   * @returns {VegaCalendarBaseEventLayoutCell[]} An array of VegaCalendarLongEventLayoutRow objects is being returned.
+   */
+  get eventLayoutCells() {
+    return this.cells;
+  }
+}

package/dist/collection/components/vega-calendar/slimmers/common/layout/full-day-event-layout-generator.js

@@ -0,0 +1,84 @@
+import { VegaCalendarBaseEventLayoutGenerator } from './base-event-layout-generator';
+import { VegaCalendarFullDayEventLayout } from './full-day-event-layout';
+import { VegaCalendarFullDayEventLayoutRow } from './full-day-event-layout-row';
+/** The `VegaCalendarLongEventLayoutGenerator` class in TypeScript generates a layout for long calendar events with overlapping prevention logic. */
+export class VegaCalendarFullDayEventLayoutGenerator extends VegaCalendarBaseEventLayoutGenerator {
+  /**
+   * The function generates a long event layout for a calendar based on the input calendar events.
+   *
+   * @param {CalendarEvent[][]} calendarEvents - CalendarEvent[][] is a two-dimensional array where each
+   * element represents a day in the calendar and contains an array of CalendarEvent objects representing events on that day.
+   * @returns {VegaCalendarFullDayEventLayout} A new instance of `VegaCalendarFullDayEventLayout` is being returned, which is constructed
+   * using the `layoutRows` array containing `VegaCalendarFullDayEventLayoutRow` objects.
+   */
+  generate(calendarEvents) {
+    const allShouldOrderLongEvents = this.collectAllShouldOrderLongEvents(calendarEvents);
+    const layoutRows = [this.createNewLayoutCell()];
+    allShouldOrderLongEvents.forEach((eventView) => {
+      this.addCurrentEventToLayout(layoutRows, eventView);
+    });
+    return new VegaCalendarFullDayEventLayout(layoutRows);
+  }
+  /**
+   * The function creates a new instance of VegaCalendarFullDayEventLayoutRow.
+   *
+   * @returns {VegaCalendarFullDayEventLayoutRow} An instance of the class `VegaCalendarFullDayEventLayoutRow` is being returned.
+   */
+  createNewLayoutCell() {
+    return new VegaCalendarFullDayEventLayoutRow();
+  }
+  /**
+   * Filter the all should order group event from event list
+   *
+   * @param {CalendarEvent[][]} allEvents all event list
+   * @returns {VegaCalendarFullDayEventView[]} the group event view list
+   */
+  collectAllShouldOrderLongEvents(allEvents) {
+    const allLongEventViews = {};
+    allEvents.forEach((items, index) => {
+      const longEvents = items.filter((item) => item && item.isGroupEvent());
+      longEvents.forEach((groupEvent) => {
+        if (!allLongEventViews[groupEvent.eventKey]) {
+          allLongEventViews[groupEvent.eventKey] = {
+            start: index,
+            end: index,
+            event: groupEvent,
+          };
+        }
+        else {
+          allLongEventViews[groupEvent.eventKey] = Object.assign(Object.assign({}, allLongEventViews[groupEvent.eventKey]), { end: index, start: index - allLongEventViews[groupEvent.eventKey].end !== 1
+              ? index
+              : allLongEventViews[groupEvent.eventKey].start });
+        }
+      });
+    });
+    const shouldSortLongEventViews = Object.values(allLongEventViews);
+    return this.sortLongEventViews(shouldSortLongEventViews);
+  }
+  /**
+   * This function sorts an array of VegaCalendarFullDayEventView objects based on their start and end times.
+   *
+   * @param {VegaCalendarFullDayEventView[]} eventViews - The `eventViews` parameter is an array of
+   * `VegaCalendarFullDayEventView` objects that represent long events in a calendar. The function
+   * `sortLongEventViews` takes this array as input and sorts it based on the start and end times of the events.
+   * @returns {VegaCalendarFullDayEventView[]} The function `sortLongEventViews` is returning an array of `VegaCalendarFullDayEventView`
+   * objects that have been sorted based on the comparison logic provided in the sorting function. The sorting is done based on the `start` and `end` properties of the objects in the array.
+   */
+  sortLongEventViews(eventViews) {
+    return eventViews.sort((itemA, itemB) => {
+      const { startDate: startA, endDate: endA } = itemA.event;
+      const { startDate: startB, endDate: endB } = itemB.event;
+      startA.setHours(0, 0, 0);
+      startB.setHours(0, 0, 0);
+      endA.setHours(23, 59, 59);
+      endB.setHours(23, 59, 59);
+      const num = endB.valueOf() - startB.valueOf() - (endA.valueOf() - startA.valueOf());
+      if (startA.valueOf() !== startB.valueOf()) {
+        return startA.valueOf() - startB.valueOf();
+      }
+      else {
+        return num;
+      }
+    });
+  }
+}

package/dist/collection/components/vega-calendar/slimmers/common/layout/full-day-event-layout-row.js

@@ -0,0 +1,41 @@
+import { VegaCalendarBaseEventLayoutCell } from './base-event-layout-cell';
+/** The `VegaCalendarLongEventLayoutRow` class in TypeScript manages the layout of long events in a calendar by updating slots and checking for overlaps. */
+export class VegaCalendarFullDayEventLayoutRow extends VegaCalendarBaseEventLayoutCell {
+  constructor() {
+    super(...arguments);
+    this.slots = VegaCalendarFullDayEventLayoutRow.defaultSlots;
+  }
+  /**
+   * The function `updateRowSlots` updates a row of slots in a calendar view with a long event.
+   *
+   * @param {VegaCalendarFullDayEventView} eventView - The `eventView` parameter in the `updateRowSlots` method is of type `VegaCalendarFullDayEventView`. It contains information about a long event in a
+   */
+  updateSlots(eventView) {
+    const { start, end } = eventView;
+    this.slots = this.slots
+      .slice(0, start)
+      .concat(Array(end - start + 1).fill(eventView.event), this.slots.slice(end + 1));
+  }
+  /**
+   * The function checks if a given event overlaps with existing events in a calendar view.
+   *
+   * @param {VegaCalendarFullDayEventView} eventView - The `eventView` parameter in the `hasOverlapEvent`
+   * function represents a view of a long event in a Vega calendar. It contains the `start` and `end`
+   * properties which specify the start and end times of the event. The function checks if there is any
+   * overlap with existing events in
+   * @returns {boolean} The function `hasOverlapEvent` returns a boolean value indicating whether there is an
+   * overlap in the slots between the start and end times of the given `VegaCalendarFullDayEventView` event.
+   */
+  hasOverlapEvent(eventView) {
+    const { start, end } = eventView;
+    let overlapFlag = false;
+    for (let i = start; i < end + 1; i++) {
+      if (this.slots[i]) {
+        overlapFlag = true;
+        break;
+      }
+    }
+    return overlapFlag;
+  }
+}
+VegaCalendarFullDayEventLayoutRow.defaultSlots = Array(7).fill(null);