@globalpayments/vega 2.16.0 → 2.17.0

package/dist/esm/{vegaInternalEventId-600b3751.js → vegaInternalEventId-bde5d617.js}

@@ -25,5 +25,6 @@ const VegaInternalLeftNavLinkClick = new VegaInternalEventID('leftNavLinkClick')
 const VegaInternalSubStatePull = new VegaInternalEventID('subStatePull');
 const VegaInternalSubStatePush = new VegaInternalEventID('subStatePush');
 const VegaInternalCalendarMonthEventsChange = new VegaInternalEventID('monthEventsChange');
+const VegaInternalDropdownTemplateItemsChange = new VegaInternalEventID('dropdownTemplateItemsChange');
 
-export { VegaInternalFieldErrorStateChange as V, VegaInternalValid as a, VegaInternalVirtualScrollToBottom as b, VegaInternalButtonGroupClick as c, VegaInternalSubStatePull as d, VegaInternalSubStatePush as e, VegaInternalCalendarMonthEventsChange as f, VegaInternalLeftNavLinkClick as g };
+export { VegaInternalFieldErrorStateChange as V, VegaInternalValid as a, VegaInternalDropdownTemplateItemsChange as b, VegaInternalVirtualScrollToBottom as c, VegaInternalButtonGroupClick as d, VegaInternalSubStatePull as e, VegaInternalSubStatePush as f, VegaInternalCalendarMonthEventsChange as g, VegaInternalLeftNavLinkClick as h };

package/dist/types/components/vega-button/slimmers/renderers/vega-button-loading-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaButton } from '../../vega-button';
+import { Nullable } from '../../../../types/general';
+/** This code snippet defines a TypeScript class named `VegaButtonLoadingRenderer` that extends `VegaSlimmer`. It includes several class properties (`loading`, `loadingMode`, `size`, `danger`) that are mapped to fields of a `VegaButton` component. The `render` method of this class is responsible for rendering a loading indicator component (`vega-loading-indicator`) based on the values of the class properties. */
+export declare class VegaButtonLoadingRenderer extends VegaSlimmer {
+  protected loading: VegaButton['loading'];
+  /**
+   * renders a loading indicator component based on the values of certain properties (`loading`) of the class instance.
+   *
+   * @returns {Nullable<HTMLVegaLoadingIndicatorElement>} Loading element if the property loading set to true
+   */
+  render(): Nullable<HTMLVegaLoadingIndicatorElement>;
+}

package/dist/types/components/vega-button/vega-button.d.ts

@@ -7,6 +7,7 @@ import { PageResizeObserverSlimmer } from '../../helpers/slimmers/pageResizeObse
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/eventEmitSlimmer';
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/childNodesEventPreventSlimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/componentUsageRuntimeMetrics';
+import { VegaButtonLoadingRenderer } from './slimmers/renderers/vega-button-loading-renderer';
 export declare class VegaButton {
   protected readonly globalSlimmers: GlobalSlimmers;
   /**
@@ -17,6 +18,7 @@ export declare class VegaButton {
   protected clickEventEmitter: EventEmitSlimmerBase;
   protected eventPrevent: ChildNodesEventPreventSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaButtonElement>;
+  protected vegaButtonLoadingRenderer: VegaButtonLoadingRenderer;
   host: HTMLVegaButtonElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
@@ -62,6 +64,12 @@ export declare class VegaButton {
    *    form submission and data reset.
    */
   type: VegaButtonType;
+  /**
+   * Specifies whether the button is in a loading state. When `true`,
+   *     the button is disabled and an indeterminate loading indicator
+   *     is displayed within the button.
+   */
+  loading: boolean;
   /**
    * An event emitter notifying the click event of the button.
    */
@@ -78,4 +86,12 @@ export declare class VegaButton {
   private renderLabel;
   private renderIcon;
   private handleClick;
+  /**
+   * The function `isDisabledButton` returns true if either the `disabled` or `loading` property is true.
+   *
+   * @returns {boolean} The method `isDisabledButton()` is returning a boolean value, which is determined by the
+   * logical OR operation between `this.disabled` and `this.loading`. If either `this.disabled` or
+   * `this.loading` is true, the method will return `true`, indicating that the button is disabled.
+   */
+  private isDisabledButton;
 }

package/dist/types/components/vega-calendar/slimmers/common/controllers/vega-calendar-current-period-controller.d.ts

@@ -1,6 +1,6 @@
 import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { VegaCalendar } from '../../../vega-calendar';
-import { CalendarPeriod } from '../../../../../helpers/calendar';
+import { CalendarDate, CalendarPeriod } from '../../../../../helpers/calendar';
 import { VegaCalendarViewModeType } from '../../../types';
 /** This TypeScript class `VegaCalendarCurrentPeriodController` updates the current period based on the view mode in a calendar component. */
 export declare class VegaCalendarCurrentPeriodController extends VegaSlimmer {
@@ -13,6 +13,13 @@ export declare class VegaCalendarCurrentPeriodController extends VegaSlimmer {
    * @param {CalendarPeriod} newPeriod new value
    */
   setCurrentPeriod(newPeriod: CalendarPeriod): void;
+  /**
+   * set new current period by the view mode and the current date
+   *
+   * @param {VegaCalendarViewModeType} viewMode view mode value
+   * @param {CalendarDate} date current date
+   */
+  updateCalendarPeriod(viewMode: VegaCalendarViewModeType, date: CalendarDate): void;
   /**
    * default current period is month period, re-create period if the default view mode is not month
    * set default calendar view
@@ -20,8 +27,11 @@ export declare class VegaCalendarCurrentPeriodController extends VegaSlimmer {
   protected initialCurrentPeriod(): void;
   /**
    * emit period change event
+   *
+   * @param {CalendarPeriod} newValue the new calendar period
+   * @param {CalendarPeriod} oldValue the prev calendar period
    */
-  protected emitChangeEvent(): void;
+  protected emitChangeEvent(newValue: CalendarPeriod, oldValue: CalendarPeriod): void;
   /**
    * update the current period when view mode change
    *
@@ -35,11 +45,4 @@ export declare class VegaCalendarCurrentPeriodController extends VegaSlimmer {
    * start date and end date.
    */
   private getCurrentPeriodSummary;
-  /**
-   * set new current period by the view mode and the current date
-   *
-   * @param {VegaCalendarViewModeType} viewMode view mode value
-   * @param {CalendarDate} date current date
-   */
-  private initCalendarPeriod;
 }

package/dist/types/components/vega-calendar/slimmers/common/controllers/vega-calendar-event-controller.d.ts

@@ -6,7 +6,9 @@ import { CalendarDate } from '../../../../../helpers/calendar';
 /** The `VegaCalendarEventController` class in TypeScript manages calendar events, initializes event layouts, retrieves events for the current date, and checks if a date falls within the range of a calendar event. */
 export declare class VegaCalendarEventController extends VegaSlimmer {
   protected calendarEvents: VegaCalendar['calendarEvents'];
+  protected currentPeriod: VegaCalendar['currentPeriod'];
   protected events: VegaCalendar['events'];
+  private repeatEventMap;
   /**
    * The function `getCurrentDateEvent` returns an array of calendar events for the current date, including both normal events and group events.
    *
@@ -33,4 +35,22 @@ export declare class VegaCalendarEventController extends VegaSlimmer {
    * @param {VegaCalendarRawEvent[]} newEvents new event options array
    */
   private initCalendarEvents;
+  /**
+   * We need generate new calendar event from the full-day repeat calendar event, so we can render those event as normal full-day event
+   *
+   * @returns {CalendarEvent[]} The `handleRepeatEvents` method returns an array of `CalendarEvent` objects.
+   */
+  private createRepeatEvents;
+  /**
+   * This function generates a calendar event based on a repeat series and stores it in a map to avoid duplicate creation.
+   *
+   * @param {CalendarEvent} calendarEvent - The `calendarEvent` parameter represents a single event on
+   * a calendar. It contains information such as the event's start date, end date, and other details.
+   * @param {CalendarDate} series - The repeat start date
+   * @returns {CalendarEvent} The function `generateCalendarEventByRepeatSeries` returns a `CalendarEvent` object. If
+   * the event key already exists in the `repeatEventMap`, it returns the corresponding `CalendarEvent`
+   * object from the map. Otherwise, it creates a new `CalendarEvent` object based on the input
+   * `calendarEvent` and `series` parameters, adds it to the `repeatEventMap`, and then
+   */
+  private generateCalendarEventByRepeatSeries;
 }

package/dist/types/components/vega-calendar/slimmers/common/controllers/vega-calendar-view-controller.d.ts

@@ -1,35 +1,31 @@
 import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { VegaCalendar } from '../../../vega-calendar';
-import { VegaCalendarViewModeType } from '../../../types';
+import { CalendarPeriod } from '../../../../../helpers/calendar';
 /** The `VegaCalendarViewController` class manages the calendar view based on the current period and view mode in TypeScript. */
 export declare class VegaCalendarViewController extends VegaSlimmer {
   calendarView: VegaCalendar['calendarView'];
-  viewMode: VegaCalendar['viewMode'];
   currentPeriod: VegaCalendar['currentPeriod'];
   currentPeriodController: VegaCalendar['currentPeriodController'];
   private monthViewGenerator;
   private weekViewGenerator;
   private dayViewGenerator;
-  /**
-   * Update the view mode by param
-   *
-   * @param {VegaCalendarViewModeType} viewMode view mode string
-   */
-  setViewMode(viewMode: VegaCalendarViewModeType): void;
   /**
    * set default calendar view
    */
   protected initialCalendarView(): void;
   /**
    * generator new calendar view if the calendar current period changes
+   *
+   * @param {CalendarPeriod} newValue the new calendar period
    */
-  protected generateCalendarView(): void;
+  protected generateCalendarView(newValue: CalendarPeriod): void;
   /**
-   * The function `getCalendarViewByViewMode` returns a specific calendar view based on the current view mode.
+   * The function `getCalendarViewByPeriod` returns a specific calendar view based on the current period.
    *
-   * @returns {CalendarView} get the match calendar view by the view mode
+   * @param {CalendarPeriod} newPeriod the new period
+   * @returns {CalendarView} get the match calendar view by the period
    */
-  private getCalendarViewByViewMode;
+  private getCalendarViewByPeriod;
   /**
    * update the calendar view
    *

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/baseRepeatPattern.d.ts

@@ -0,0 +1,50 @@
+import { CalendarDate, CalendarPeriod } from '../../../../../../helpers/calendar';
+import { Nullable } from '../../../../../../types/general';
+/** The above code defines an abstract class `CalendarEventBaseRepeatPattern` in TypeScript that represents a repeat pattern for calendar events. Here is a summary of what the code is doing: */
+export declare abstract class CalendarEventBaseRepeatPattern {
+  protected static daySeconds: number;
+  protected repeatStartDate: CalendarDate;
+  protected interval: number;
+  protected count: Nullable<number>;
+  protected until: Nullable<CalendarDate>;
+  protected cache: (CalendarDate | CalendarDate[])[];
+  /**
+   * The constructor initializes the current date for a given date range and interval.
+   *
+   * @param {CalendarDate} repeatStartDate - The `repeatStartDate` parameter represents the starting date of a
+   * calendar event or interval. It is of type `CalendarDate`, which likely contains information such as
+   * the year, month, and day of the event.
+   * @param {number} interval - The `interval` parameter represents the frequency at which the event
+   * occurs. For example, if the interval is set to 2, it means the event occurs every 2 units of time
+   * (e.g., every 2 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
+   * `null`, the event will repeat indefinitely until the `until` date is reached.
+   * @param {Nullable<CalendarDate>} until - The `until` parameter in the constructor represents a date until which the recurring
+   * event will occur. If this date is reached, the recurring event will stop.
+   */
+  constructor(repeatStartDate: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
+  /**
+   * 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: CalendarPeriod, eventSpansDays?: number): CalendarDate[];
+  /**
+   * The function `isSeriesInPeriod` checks if a series of dates falls within a specified date range.
+   *
+   * @param {CalendarDate} series - The `series` parameter represents a specific date in the form of a
+   * `CalendarDate` object.
+   * @param {number} seriesSpansDays - The `seriesSpansDays` parameter represents the number of days
+   * that the series spans. It is used to calculate the end date of the series based on the start date.
+   * @param {CalendarPeriod} period - Date period
+   * @returns {boolean} a boolean value indicating whether the given series falls within the specified date
+   * range.
+   */
+  protected isSeriesInPeriod(series: CalendarDate, seriesSpansDays: number, period: CalendarPeriod): boolean;
+  protected abstract generateRepeatDateCacheUntilEndDate(date: CalendarDate): void;
+}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventDailyRepeatPattern.d.ts

@@ -0,0 +1,43 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { Nullable } from '../../../../../../types/general';
+import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
+/** The `CalendarEventDailyRepeatPattern` class in TypeScript represents a daily repeating pattern for calendar events. */
+export declare 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: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
+  /**
+   * 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
+   */
+  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
+  /**
+   * The function `initCache` initializes a cache array with the `startDate` value.
+   */
+  private initCache;
+  /**
+   * 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.
+   */
+  private getNextRepeatStartDate;
+}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventMonthlyRepeatPattern.d.ts

@@ -0,0 +1,55 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { Nullable } from '../../../../../../types/general';
+import { CalendarEventBaseRepeatPattern } from './baseRepeatPattern';
+/** The `CalendarEventMonthlyRepeatPattern` class in TypeScript represents a monthly repeat pattern for calendar events. */
+export declare class CalendarEventMonthlyRepeatPattern extends CalendarEventBaseRepeatPattern {
+  private byMonthDay;
+  /**
+   * 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: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
+  /**
+   * 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
+   */
+  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
+  /**
+   * The function `initCache` initializes a cache array with the startDate value.
+   */
+  private initCache;
+  /**
+   * 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).
+   */
+  private getNextRepeatStartDate;
+  /**
+   * 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
+   */
+  private getNextStartDate;
+}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventRepeatPatternFactory.d.ts

@@ -0,0 +1,34 @@
+import { VegaCalendarEventRepeatOptions } from '../../../../types';
+import { CalendarEventBaseRepeatPattern } from '../repeatPattern/baseRepeatPattern';
+/** 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: */
+declare 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: Date, repeatOptions: VegaCalendarEventRepeatOptions): CalendarEventBaseRepeatPattern;
+  /**
+   * 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`.
+   */
+  private initDate;
+  /**
+   * 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
+   */
+  private initRepeatPattern;
+}
+declare const _default: CalendarEventRepeatPatternFactory;
+export default _default;

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventWeeklyRepeatPattern.d.ts

@@ -0,0 +1,99 @@
+import { CalendarDate, CalendarPeriod } from '../../../../../../helpers/calendar';
+import { Nullable } from '../../../../../../types/general';
+import { VegaCalendarWeekDayType } from '../../../../types';
+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 declare class CalendarEventWeeklyRepeatPattern extends CalendarEventBaseRepeatPattern {
+  private static weekDay;
+  private byWeekDay;
+  /**
+   * 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: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>, byWeekDay: Nullable<VegaCalendarWeekDayType[]>);
+  /**
+   * 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: CalendarPeriod, eventSpansDays?: number): CalendarDate[];
+  /**
+   * 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.
+   */
+  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
+  /**
+   * 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.
+   */
+  private getNextRepeatStartDate;
+  /**
+   * 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.
+   */
+  private getNextStartDates;
+  /**
+   * The `initCache` function initializes a cache of calendar dates based on the start date and weekly repeat pattern.
+   */
+  private initCache;
+  /**
+   * 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.
+   */
+  private sortWeekDay;
+  /**
+   * 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.
+   */
+  private getCurrentDayIndex;
+  /**
+   * 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
+   */
+  private getValidCache;
+}

package/dist/types/components/vega-calendar/slimmers/common/helpers/repeatPattern/calendarEventYearlyRepeatPattern.d.ts

@@ -0,0 +1,57 @@
+import { CalendarDate } from '../../../../../../helpers/calendar';
+import { Nullable } from '../../../../../../types/general';
+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 declare class CalendarEventYearlyRepeatPattern extends CalendarEventBaseRepeatPattern {
+  private matchMonth;
+  private matchDay;
+  /**
+   * 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: CalendarDate, interval: number, count: Nullable<number>, until: Nullable<CalendarDate>);
+  /**
+   * 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
+   */
+  protected generateRepeatDateCacheUntilEndDate(endDate: CalendarDate): void;
+  /**
+   * 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`.
+   */
+  private getNextRepeatStartDate;
+  /**
+   * 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
+   */
+  private getNextStartDate;
+  /**
+   * The function `initCache` initializes a cache array with the `startDate` value.
+   */
+  private initCache;
+}

package/dist/types/components/vega-calendar/slimmers/common/helpers/test/calendarEventRepeatPatternFactory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/vega-calendar/slimmers/day-view/renderers/vega-calendar-view-with-time-renderer.d.ts

@@ -8,6 +8,7 @@ export declare class VegaCalendarViewWithTimeRenderer extends VegaSlimmer {
   protected dayViewFullDayEventRenderer: VegaCalendar['dayViewFullDayEventRenderer'];
   protected calendarView: VegaCalendar['calendarView'];
   protected calendarViewController: VegaCalendar['calendarViewController'];
+  protected dateDblClickEmitter: VegaCalendar['dateDblClickEmitter'];
   /**
    * The render function in TypeScript React returns an array of HTMLElements containing the week calendar view for a specific day.
    *
@@ -31,7 +32,14 @@ export declare 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.
    */
   private renderHourBlock;
+  /**
+   * emit vega click event when click the date block
+   *
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  private handleDateBlockClick;
 }

package/dist/types/components/vega-calendar/slimmers/month-view/renderers/vega-calendar-month-view-renderer.d.ts

@@ -6,7 +6,9 @@ export declare class VegaCalendarMonthViewRenderer extends VegaSlimmer {
   protected calendarView: VegaCalendar['calendarView'];
   protected currentPeriod: VegaCalendar['currentPeriod'];
   protected calendarViewController: VegaCalendar['calendarViewController'];
+  protected currentPeriodController: VegaCalendar['currentPeriodController'];
   protected monthEventRenderer: VegaCalendar['monthEventRenderer'];
+  protected dateDblClickEmitter: VegaCalendar['dateDblClickEmitter'];
   /**
    * the HTML elements that represent the month view of a calendar component.
    *
@@ -26,4 +28,25 @@ export declare class VegaCalendarMonthViewRenderer extends VegaSlimmer {
    * @returns {HTMLElement} the date block element
    */
   private renderDateBlock;
+  /**
+   * switch to current date day view
+   *
+   * @param {MouseEvent} e the double click event object
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  private goToCurrentDayView;
+  /**
+   * emit vega click event when click the date block
+   *
+   * @param {MouseEvent} e the mouse event object
+   * @param {CalendarDate} calendarDate the calendar date object
+   */
+  private handleDateBlockClick;
+  /**
+   * determine if the clicked element is blank area
+   *
+   * @param {HTMLElement} element the target element
+   * @returns {boolean} true or false
+   */
+  private isMonthBlockBlankArea;
 }

package/dist/types/components/vega-calendar/types.d.ts

@@ -19,7 +19,7 @@ export type VegaCalendarChangeEventType = {
 	viewMode: VegaCalendarViewModeType;
 };
 
-export type VegaCalendarEventRepeatType = 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+export type VegaCalendarEventRepeatType = 'daily' | 'weekly' | 'monthly' | 'yearly';
 
 export type VegaCalendarEventVariantType = 'primary' | 'secondary' | 'tertiary';
 
@@ -32,15 +32,17 @@ export interface VegaCalendarRawEvent {
 	startTime?: string;
 	endTime?: string;
 	isAllDay?: boolean;
-	repeat?: VegaCalendarEventRepeatType;
 	color?: string | BackgroundColorsTokenType;
 	disabled?: boolean;
+	repeatOptions?: VegaCalendarEventRepeatOptions;
 }
 
 export type VegaCalendarEventClickInfo = {
 	rawEvent: VegaCalendarRawEvent;
 };
 
+export type VegaCalendarDateClickInfo = VegaCalendarDateType & { hour: number };
+
 export type VegaCalendarEventStyle = {
 	position: 'absolute';
 	left: string;
@@ -56,3 +58,13 @@ export type VegaCalendarFullDayEventView = {
 	start: number;
 	end: number;
 };
+
+export type VegaCalendarWeekDayType = 'Sun' | 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat';
+
+export type VegaCalendarEventRepeatOptions = {
+	frequency: VegaCalendarEventRepeatType;
+	interval?: number;
+	count?: number;
+	until?: string | Date;
+	byWeekDay?: VegaCalendarWeekDayType[];
+};