@globalpayments/vega 2.15.0 → 2.17.0

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[];
+};

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

@@ -6,7 +6,7 @@ import { VegaCalendarViewRenderer } from './slimmers/common/renderers/vega-calen
 import { VegaCalendarMonthViewRenderer } from './slimmers/month-view/renderers/vega-calendar-month-view-renderer';
 import { VegaCalendarViewWithTimeRenderer } from './slimmers/day-view/renderers/vega-calendar-view-with-time-renderer';
 import { VegaCalendarTimeLineRenderer } from './slimmers/day-view/renderers/vega-calendar-time-line-renderer';
-import { VegaCalendarChangeEventType, VegaCalendarEventClickInfo, VegaCalendarRawEvent, VegaCalendarViewModeType } from './types';
+import { VegaCalendarChangeEventType, VegaCalendarEventClickInfo, VegaCalendarDateClickInfo, VegaCalendarRawEvent, VegaCalendarViewModeType } from './types';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/eventEmitSlimmer';
 import { CalendarPeriod, CalendarView } from '../../helpers/calendar';
 import { VegaCalendarViewController } from './slimmers/common/controllers/vega-calendar-view-controller';
@@ -45,15 +45,19 @@ export declare class VegaCalendar {
   protected eventResponsiveController: VegaCalendarEventResponsiveController;
   protected changeEventEmitter: EventEmitSlimmerBase;
   protected eventClickEmitter: EventEmitSlimmerBase;
+  protected dateDblClickEmitter: EventEmitSlimmerBase;
   protected changeEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly timeFormatNotifySlimmer: SubStateNotifySlimmerBase;
   host: HTMLVegaCalendarElement;
   calendarView: CalendarView;
   currentPeriod: CalendarPeriod;
   /**
-   * watch the state calendar current period change
+   * Tracks changes to the current period state.
+   *
+   * @param {CalendarPeriod} newValue Specifies the new calendar period.
+   * @param {CalendarPeriod} oldValue Specifies the old calendar period.
    */
-  watchCurrentPeriodChange(): void;
+  watchCurrentPeriodChange(newValue: CalendarPeriod, oldValue: CalendarPeriod): void;
   calendarEvents: CalendarEvent[];
   /**
    * Specifies the current view mode of the calendar.
@@ -103,5 +107,13 @@ export declare class VegaCalendar {
    * An event emitter notifying that a component event item is clicked.
    */
   eventClick: EventEmitter<VegaCalendarEventClickInfo>;
+  /**
+   * An event emitter notifying that a calendar date item has been double-clicked.
+   */
+  vegaDateDblClick: EventEmitter<VegaCalendarDateClickInfo>;
+  /**
+   * An event emitter notifying that a calendar date item has been double-clicked.
+   */
+  dateDblClick: EventEmitter<VegaCalendarDateClickInfo>;
   render(): VegaCalendar;
 }

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-appender-controller.d.ts

@@ -19,7 +19,6 @@ export declare class VegaDropdownAppenderController extends ElementAppenderSlimm
   placement: VegaDropdown['placement'];
   alignment: VegaDropdown['alignment'];
   renderer: VegaDropdown['renderer'];
-  listRenderer: VegaDropdown['listRenderer'];
   searchRenderer: VegaDropdown['searchRenderer'];
   showEventEmitter: VegaDropdown['showEventEmitter'];
   hideEventEmitter: VegaDropdown['hideEventEmitter'];

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-children-controller.d.ts

@@ -67,4 +67,8 @@ export declare class VegaDropdownChildrenController extends VegaSlimmer {
    * The below method is e2e-test covered in @see{module:vega-dropdown-items-dom-change-e2e}
    */
   private clearDropdownCurrentData;
+  /**
+   * The function `notifyTemplateItemsChange` notifies changes to dropdown items within a container element.
+   */
+  private notifyTemplateItemsChange;
 }

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-scrollable-controller.d.ts

@@ -0,0 +1,57 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaDropdown } from '../../vega-dropdown';
+/**
+ * The `VegaDropdownScrollableController` class in TypeScript manages the behavior of a scrollable dropdown component,
+ * adjusting list container height and scrolling to specific indexes based on render mode and selected source key.
+ */
+export declare class VegaDropdownScrollableController extends VegaSlimmer {
+  isDropdownShow: VegaDropdown['isDropdownShow'];
+  renderModeController: VegaDropdown['renderModeController'];
+  sourceForRender: VegaDropdown['sourceForRender'];
+  selectType: VegaDropdown['selectType'];
+  selectedSourceKey: VegaDropdown['selectedSourceKey'];
+  searchable: VegaDropdown['searchable'];
+  listRenderer: VegaDropdown['listRenderer'];
+  renderer: VegaDropdown['renderer'];
+  /**
+   * The function `watchIsDropdownShow` adjusts the list container height and scrolls to a specific index
+   * if the dropdown is shown in a certain render mode.
+   */
+  watchIsDropdownShow(): Promise<void>;
+  /**
+   * The function scrollToSelected asynchronously scrolls to a selected index based on the render mode.
+   */
+  private scrollToSelectedIndex;
+  /**
+   * The function scrollToVirtualIndex asynchronously scrolls to a specific index in a virtual list based
+   * on the selected key.
+   */
+  private scrollToVirtualIndex;
+  /**
+   * The function scrollToTemplateIndex scrolls the dropdown content box to the selected item key.
+   */
+  private scrollToTemplateIndex;
+  /**
+   * The function `getSelectedKey` returns the selected key based on the `selectType` condition.
+   *
+   * @returns {string} The `getSelectedKey` method returns a string value. If `this.selectType` is equal to
+   * 'multiple', it returns the first element of the `selectedSourceKey` array as a string. Otherwise, it
+   * returns the `selectedSourceKey` value as a string.
+   */
+  private getSelectedKey;
+  /**
+   * we only calculate surplus space of bottom, we should calculate maxHeight more accurately here.
+   * such as minus the gap of dropdown, the dropdown padding top and bottom, the gap of bottom.
+   * if with searchable, we should minus the height of searchable.
+   * if the dropdown in the top of host, we should only minus top of distance from vega-dropdown to vega-dropdown-container.
+   */
+  private adjustListContainerMaxHeight;
+  /**
+   * The function `setItemsContainerMaxHeight` adjusts the maximum height of the items container based on
+   * the render mode.
+   *
+   * @param {number} maxHeight - The `maxHeight` parameter is a number that represents the maximum height
+   * in pixels that the items container should have.
+   */
+  private setItemsContainerMaxHeight;
+}

package/dist/types/components/vega-dropdown/slimmers/renderers/vega-dropdown-list-renderer.d.ts

@@ -1,38 +1,28 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaDropdown } from '../../vega-dropdown';
 export declare class VegaDropdownListRenderer extends VegaSlimmer {
+  host: VegaDropdown['host'];
   isLoading: VegaDropdown['isLoading'];
   searchString: VegaDropdown['searchString'];
-  selectType: VegaDropdown['selectType'];
-  searchable: VegaDropdown['searchable'];
-  selectedSourceKey: VegaDropdown['selectedSourceKey'];
   itemDisplayRule: VegaDropdown['itemDisplayRule'];
-  maxHeightOfItemsContainer: VegaDropdown['maxHeightOfItemsContainer'];
   sourceForRender: VegaDropdown['sourceForRender'];
   itemLevelRenderer: VegaDropdown['itemLevelRenderer'];
   groupLevelRenderer: VegaDropdown['groupLevelRenderer'];
-  renderer: VegaDropdown['renderer'];
   isLazyLoading: VegaDropdown['isLazyLoading'];
+  isDropdownShow: VegaDropdown['isDropdownShow'];
+  renderModeController: VegaDropdown['renderModeController'];
   private virtualScrollRef;
-  scrollToIndex(): Promise<void>;
+  private templateContainerRef;
+  private defaultMaxHeightOfItemsContainer;
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-dropdown-keyboard-control-e2e}
    */
-  getVirtualScrollRef(): HTMLElement;
+  getVirtualScrollRef(): HTMLVegaVirtualScrollElement;
+  getTemplateContainerRef(): HTMLUListElement;
   renderBySource(): HTMLElement;
   renderBySlot(): HTMLElement;
   private renderLoading;
   private renderDropdownListBySource;
   private renderDropdownListBySlot;
-  /**
-   * we only calculate surplus space of bottom, we should calculate maxHeight more accurately here.
-   * such as minus the gap of dropdown, the dropdown padding top and bottom, the gap of bottom.
-   * if with searchable, we should minus the height of searchable.
-   * if the dropdown in the top of host, we should only minus top of distance from vega-dropdown to vega-dropdown-container.
-   * The below method is e2e-test covered in
-   * @see{module:vega-dropdown-with-matchContainerHeight-e2e}
-   * @see{module:vega-dropdown-without-matchContainerHeight-e2e}
-   */
-  private adjustListContainerMaxHeight;
 }

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

@@ -18,6 +18,9 @@ export declare class VegaDropdownRenderer extends VegaSlimmer {
   getVirtualContainerRef(): HTMLElement;
   getNextActiveItem(code: 'ArrowUp' | 'ArrowDown'): Nullable<HTMLVegaDropdownItemElement>;
   render(): HTMLElement;
+  /**
+   * TODO: We will use no-named slot for both template and source render mode. And will deprecate slot dropdown-content
+   */
   private renderContentSlot;
   private renderDropdown;
   private setVirtualContainer;

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

@@ -20,6 +20,7 @@ import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event
 import { ChildNodesNotifyObserverSlimmer } from '../../helpers/event-manager/slimmers/childNodesNotifyObserverSlimmer';
 import { VegaDropdownItemClickEvent } from './vega-dropdown-item/types';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/componentUsageRuntimeMetrics';
+import { VegaDropdownScrollableController } from './slimmers/controllers/vega-dropdown-scrollable-controller';
 export declare class VegaDropdown {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected readonly renderer: VegaDropdownRenderer;
@@ -39,6 +40,7 @@ export declare class VegaDropdown {
   protected readonly childrenController: VegaDropdownChildrenController;
   protected readonly selectedController: VegaDropdownSelectedController;
   protected readonly renderModeController: VegaDropdownRenderModeController;
+  protected readonly scrollableController: VegaDropdownScrollableController;
   protected readonly selectTypeNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly selectedSourceKeyNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly prefixIconSlotNotifySlimmer: SubStateNotifySlimmerBase;
@@ -52,7 +54,6 @@ export declare class VegaDropdown {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaDropdownElement>;
   host: HTMLVegaDropdownElement;
   searchString: string;
-  maxHeightOfItemsContainer: number;
   isDropdownShow: boolean;
   sourceForRender: VegaDropdownSourceItem[];
   watchIsDropdownShow(): void;

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-dropdown-controller.d.ts

@@ -1,38 +1,21 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { SelectSourceItem } from '../../types';
 import { VegaInputSelect } from '../../vega-input-select';
 /** The `VegaInputSelectDropdownController` class is a TypeScript React component that controls the behavior of a dropdown select input. */
 export declare class VegaInputSelectDropdownController extends VegaSlimmer {
-  source: VegaInputSelect['source'];
-  dropdownSource: VegaInputSelect['dropdownSource'];
   isDropdownShow: VegaInputSelect['isDropdownShow'];
   vegaSearch: VegaInputSelect['vegaSearch'];
   searchEventEmitter: VegaInputSelect['searchEventEmitter'];
   vegaInputSelectValueController: VegaInputSelect['vegaInputSelectValueController'];
-  /**
-   * call the method when component componentWillLoad call
-   */
-  handleWillLoad(): void;
-  /**
-   * convert the dropdown source when the component watchSource call
-   */
-  handleSourceChange: () => void;
+  sourceController: VegaInputSelect['sourceController'];
+  source: VegaInputSelect['source'];
   /** The `onDropdownShow` function is setting the `isDropdownShow` property of the`VegaInputSelectDropdownController` class to `true`. This function is called when the dropdown select input is shown. */
   onDropdownShow: () => void;
   /** The `onDropdownHide` function is setting the `isDropdownShow` property of the `VegaInputSelectDropdownController` class to `false`. This function is called when the dropdown select input is hidden. */
   onDropdownHide: () => void;
-  /**
-   * Append items to source
-   *
-   * @param {SelectSourceItem[]} items - Appendable items
-   */
-  appendSourceItems(items: SelectSourceItem[]): void;
   /**
    * The function `addDropdownObserver` adds event observers to a dropdown element.
    *
    * @param {HTMLElement} dropdownRef - The `dropdownRef` parameter is a reference to the HTML element representing the dropdown component.
    */
   addDropdownObserver(dropdownRef: HTMLVegaDropdownElement): void;
-  /** update the dropdown list by source value */
-  private convertToDropdownSource;
 }

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-items-slot-controler.d.ts

@@ -0,0 +1,19 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-observer/mutationObserverSlimmer';
+/**
+ * The class `VegaInputSelectItemsSlotController` extends `VegaSlimmer` and manages
+ * appending host items to a dropdown element.
+ */
+export declare class VegaInputSelectItemsSlotController extends VegaSlimmer {
+  protected mutationObserver: MutationObserverSlimmer;
+  private host;
+  private vegaInputSelectDropdownRenderer;
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad(): void;
+  /**
+   * The function appends host items to a dropdown element.
+   */
+  private appendHostItemsToDropdown;
+}

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-lazy-load-controller.d.ts

@@ -6,7 +6,7 @@ import { VegaInputSelect } from '../../vega-input-select';
 export declare class VegaInputSelectLazyLoadController extends VegaSlimmer {
   sourceLazyLoadCallback: VegaInputSelect['sourceLazyLoadCallback'];
   isLazyLoading: VegaInputSelect['isLazyLoading'];
-  vegaInputSelectDropdownController: VegaInputSelect['vegaInputSelectDropdownController'];
+  sourceController: VegaInputSelect['sourceController'];
   vegaInputSelectDropdownRenderer: VegaInputSelect['vegaInputSelectDropdownRenderer'];
   private hasMore;
   /**

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-source-controller.d.ts

@@ -0,0 +1,29 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { SelectSourceItem, SelectType, SelectValueType } from '../../types';
+import { Nullable } from '../../../../types/general';
+/**
+ * The `VegaInputSelectSourceController` class manages the source data for
+ * a dropdown input component in TypeScript.
+ */
+export declare class VegaInputSelectSourceController extends VegaSlimmer {
+  private source;
+  /**
+   * convert the dropdown source when the component watchSource call
+   */
+  handleSourceChange: () => void;
+  /**
+   * Append items to source
+   *
+   * @param {SelectSourceItem[]} items - Appendable items
+   */
+  appendSourceItems(items: SelectSourceItem[]): void;
+  /**
+   * This TypeScript function retrieves an item from a source array based on its ID.
+   *
+   * @param {SelectValueType<SelectType>} id - The `id` parameter in the `getItem` function is of type `SelectValueType<SelectType>`,
+   * which means it can accept a value that corresponds to the `SelectType` defined in the function.
+   * @returns { Nullable<SelectSourceItem>} The `getItem` function is returning a `SelectSourceItem` object that matches the provided
+   * `id`, or `null` if no matching item is found in the `source` array.
+   */
+  getItem(id: SelectValueType<SelectType>): Nullable<SelectSourceItem>;
+}

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-value-controller.d.ts

@@ -4,9 +4,9 @@ import { SelectType, SelectValueType } from '../../types';
 export declare class VegaInputSelectValueController extends VegaSlimmer {
   private value;
   private selectType;
-  private source;
   private changeEventEmitter;
   private host;
+  private sourceController;
   /**
    * handle the value change when the component watchValue call
    *

package/dist/types/components/vega-input-select/slimmers/renderers/vega-input-select-dropdown-renderer.d.ts

@@ -1,24 +1,29 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { Nullable } from '../../../../types/general';
 /** The `VegaInputSelectDropdownRenderer` class is a TypeScript React component that renders a dropdown select input with various customization options. */
 export declare class VegaInputSelectDropdownRenderer extends VegaSlimmer {
   private dropdown;
   private inputSelectContainer;
+  private itemsSlotRef;
   private value;
   private source;
+  private host;
   private selectType;
   private isDropdownShow;
   private vegaDropdownProps;
-  private dropdownSource;
   private prefixIcon;
   private placeholder;
   private selectedLabel;
   private isLazyLoading;
   private vegaInputSelectDropdownController;
+  private sourceController;
   show(): Promise<void>;
   hide(): Promise<void>;
   getDropdownRef(): HTMLVegaDropdownElement;
   getInputSelectContainerRef(): HTMLDivElement;
+  getItemsSlotRef(): Nullable<HTMLElement>;
   render(): HTMLVegaDropdownElement;
+  private renderItemsSlot;
   private renderContainer;
   private renderPrefixIcon;
   private renderToggleIcon;
@@ -27,4 +32,5 @@ export declare class VegaInputSelectDropdownRenderer extends VegaSlimmer {
   private renderSingleSelected;
   private preventBlur;
   private getVegaDropdownProperties;
+  private getDropdownSource;
 }