@globalpayments/vega 2.67.0 → 2.68.1

package/dist/esm/vega-calendar_4.entry.js

@@ -6,11 +6,11 @@ import { D as DomNodeSubjectObserverFactory, a as VegaClick, f as VegaChange, V
 import { a as VegaInternalIconManager } from './internal-icon-manager-f0486245.js';
 import { c as createEnterKeyHandlerToTriggerClick } from './accessibility-e5fd0fab.js';
 import { p as pad } from './date-c55b97f0.js';
-import { c as createEventEmitSlimmer } from './event-emit-slimmer-28fd360c.js';
+import { c as createEventEmitSlimmer } from './event-emit-slimmer-4e28e9f8.js';
 import { V as VegaInternalTranslation } from './translation-f10b1e19.js';
 import { s as stateBackgroundColorFormatter } from './state-background-color-formatter-0f01d27a.js';
 import { q as isBackgroundColorTokenType } from './type-guard-12f7654b.js';
-import { C as ChildNodesEventPreventSlimmer } from './child-nodes-event-prevent-slimmer-735cb880.js';
+import { C as ChildNodesEventPreventSlimmer } from './child-nodes-event-prevent-slimmer-76331524.js';
 import { y as VegaInternalCalendarMonthEventsChange, z as VegaInternalCalendarEventPreviewHide, A as VegaInternalCalendarEventPreviewClear, B as VegaInternalCalendarEventPreviewUpdate } from './vega-internal-event-id-5c3e5f7f.js';
 import { O as Observer } from './observer-3959f9dd.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
@@ -26,7 +26,7 @@ import { S as SubStateObserverSlimmer } from './sub-state-observer-slimmer-3504e
 import { b as parsePixelStringToNumber } from './pixel-f32c07ce.js';
 import { f as findParent } from './ui-bb99c0c2.js';
 import './dynamic-slimmer-90b8af32.js';
-import './internal-vega-event-manager-a5a5938d.js';
+import './internal-vega-event-manager-516aa721.js';
 import './try-get-document-bef0f526.js';
 import './static-subject-title-52f93124.js';
 import './breakpoints-d9faf11c.js';
@@ -748,70 +748,6 @@ var WeekdayLongNames;
   WeekdayLongNames["fri"] = "Friday";
   WeekdayLongNames["sat"] = "Saturday";
 })(WeekdayLongNames || (WeekdayLongNames = {}));
-/**
- * Format display time
- *
- * @param {TimeFormat} timeFormat - The time format (24-hour or 12-hour)
- * @param {string} timeString - The time string to format
- * @returns {string} - The formatted time string
- */
-const formatDisplayTime = (timeFormat, timeString) => {
-  const [hour, minutes] = timeString.split(':');
-  if (timeFormat === '24-hour') {
-    return `${hour.padStart(2, '0')}:${minutes.padStart(2, '0')}`;
-  }
-  else {
-    const hourNum = Number(hour);
-    const amPm = hourNum >= 12 ? 'pm' : 'am';
-    const minutesResult = minutes.padStart(2, '0');
-    if (hourNum > 12) {
-      return `${hourNum - 12}:${minutesResult} ${VegaInternalTranslation.t('pm')}`;
-    }
-    else if (hourNum === 0) {
-      return `12:${minutesResult} ${VegaInternalTranslation.t('am')}`;
-    }
-    else {
-      return `${hourNum}:${minutesResult} ${VegaInternalTranslation.t(amPm)}`;
-    }
-  }
-};
-/**
- * Gets current date parts in the specified timezone
- *
- * @param {string} timezone - The IANA timezone identifier
- * @param {Date} date - The date to get parts for
- * @returns {DateParts} - An object with year, month, and date properties for the specified timezone
- */
-function getCurrentDatePartsInTimezone(timezone, date) {
-  if (timezone && timezone !== getSystemTimezone()) {
-    try {
-      const formatter = new Intl.DateTimeFormat([], {
-        timeZone: timezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-      });
-      const parts = formatter.formatToParts(date);
-      const yearPart = parts.find((part) => part.type === 'year');
-      const monthPart = parts.find((part) => part.type === 'month');
-      const dayPart = parts.find((part) => part.type === 'day');
-      if (yearPart && monthPart && dayPart) {
-        const year = parseInt(yearPart.value, 10);
-        const month = parseInt(monthPart.value, 10);
-        const date = parseInt(dayPart.value, 10);
-        return { year, month, date };
-      }
-    }
-    catch (_a) {
-      LogUtility.warn('Invalid timezone:', timezone);
-    }
-  }
-  return {
-    year: date.getFullYear(),
-    month: date.getMonth() + 1,
-    date: date.getDate(),
-  };
-}
 /**
  * Get the system timezone identifier
  *
@@ -900,6 +836,259 @@ class DayViewGenerator extends CalendarViewGenerator {
   }
 }
 
+/**
+ * CalendarTime represents hours/minutes in 24-hour format and centralizes parsing/formatting logic.
+ */
+class CalendarTime {
+  constructor(hours, minutes) {
+    this._hours = hours;
+    this._minutes = minutes;
+  }
+  /**
+   * Parse a raw time string into a CalendarTime instance.
+   *
+   * @param {string} rawTime - Source time value such as "9:00" or "9am".
+   * @returns {CalendarTime} Parsed time.
+   */
+  static fromString(rawTime) {
+    const normalized = this.convertTimeTo24Hour(rawTime);
+    const [hourPart, minutePart] = normalized.split(':');
+    return new CalendarTime(Number(hourPart), Number(minutePart));
+  }
+  /**
+   * Build a CalendarTime from a Date instance while preserving hours/minutes.
+   *
+   * @param {Date} date - The source date.
+   * @returns {CalendarTime} Time representation extracted from the date.
+   */
+  static fromDate(date) {
+    return new CalendarTime(date.getHours(), date.getMinutes());
+  }
+  /**
+   * Calculate the duration in the requested precision between two CalendarTime values, accounting for overnight spans.
+   *
+   * @param {CalendarTime} start - Start time of the interval.
+   * @param {CalendarTime} end - End time of the interval.
+   * @param {'minutes' | 'hours'} precision - Desired unit of measure for the result (defaults to minutes).
+   * @returns {number} Duration expressed in the requested precision.
+   */
+  static calculateDuration(start, end, precision = 'minutes') {
+    const startMinutes = start.totalMinutes;
+    let endMinutes = end.totalMinutes;
+    if (end.hours === 0 && start.hours !== 0) {
+      endMinutes += 24 * 60;
+    }
+    const durationMinutes = endMinutes - startMinutes;
+    return precision === 'hours' ? durationMinutes / 60 : durationMinutes;
+  }
+  /**
+   * Normalize various time inputs (e.g. 9am, 9:30 PM) to a 24-hour HH:mm string.
+   *
+   * @param {string} timeString - User supplied time value.
+   * @returns {string} 24-hour formatted string.
+   */
+  static convertTimeTo24Hour(timeString) {
+    const normalized = timeString.toLocaleLowerCase();
+    if (normalized.includes('am') || normalized.includes('pm')) {
+      const isAm = normalized.includes('am');
+      const cleaned = normalized.replace('am', '').replace('pm', '').trim();
+      const [rawHour, rawMinutes] = cleaned.split(':');
+      const minutes = rawMinutes.padStart(2, '0');
+      if (isAm) {
+        return `${rawHour === '12' ? '00' : rawHour}:${minutes}`;
+      }
+      else {
+        const convertedHour = rawHour === '12' ? '12' : `${Number(rawHour) + 12}`;
+        return `${convertedHour}:${minutes}`;
+      }
+    }
+    return timeString;
+  }
+  /**
+   * Hour component in 24-hour clock.
+   *
+   * @returns {number} Hours between 0-23.
+   */
+  get hours() {
+    return this._hours;
+  }
+  /**
+   * Minute component.
+   *
+   * @returns {number} Minutes between 0-59.
+   */
+  get minutes() {
+    return this._minutes;
+  }
+  /**
+   * Total minutes elapsed since midnight for this time value.
+   *
+   * @returns {number} Minutes from 00:00.
+   */
+  get totalMinutes() {
+    return this._hours * 60 + this._minutes;
+  }
+  /**
+   * Format the time into a string using a simple formatter.
+   *
+   * @param {TimeStringFormat} format - time string Format. Defaults to 'hh:mm'.
+   * @returns {string} Formatted time string.
+   */
+  toString(format = 'hh:mm') {
+    const defaultHours = this._hours.toString().padStart(2, '0');
+    const defaultMinutes = this._minutes.toString().padStart(2, '0');
+    const normalizedFormat = format.toLowerCase();
+    switch (normalizedFormat) {
+      case 'hh:m':
+        return `${defaultHours}:${this._minutes}`;
+      case 'h:mm':
+        return `${this._hours}:${defaultMinutes}`;
+      case 'h:m':
+        return `${this._hours}:${this._minutes}`;
+      case '12-hour': {
+        const amPm = this._hours >= 12 ? 'pm' : 'am';
+        const hour12 = this._hours % 12 || 12;
+        return `${hour12}:${defaultMinutes} ${VegaInternalTranslation.t(amPm)}`;
+      }
+      default:
+        return `${defaultHours}:${defaultMinutes}`;
+    }
+  }
+}
+
+/**
+ * CalendarDateTime centralizes timezone-aware conversions between native Date instances and calendar helpers.
+ */
+class CalendarDateTime {
+  constructor(date, timezone) {
+    this.originalDate = date;
+    this.timezone = timezone;
+    this.syncDateTime();
+  }
+  /**
+   * Build a CalendarDateTime from a native Date while the specific timezone.
+   *
+   * @param {Date} date - The native Date object to convert.
+   * @param {string} timezone - The timezone to apply.
+   * @returns {CalendarDateTime} A timezone-aware CalendarDateTime instance.
+   */
+  static fromDate(date, timezone) {
+    return new CalendarDateTime(date, timezone);
+  }
+  /**
+   * Build a CalendarDateTime from a date input (Date or string) and optional time metadata.
+   *
+   * @param {string | Date} date - The input date value (string or Date).
+   * @param {CalendarDateTimeOptions} options - Additional options for time, timezone, seconds, etc.
+   * @returns {CalendarDateTime} A timezone-aware CalendarDateTime instance.
+   */
+  static fromInitDataSource(date, options) {
+    const baseDate = new Date(date);
+    if (options.time) {
+      const calendarTime = CalendarTime.fromString(options.time);
+      baseDate.setHours(calendarTime.hours, calendarTime.minutes, 0, 0);
+    }
+    else if (options.endTimeMissing) {
+      baseDate.setHours(23, 59, 59, 0);
+    }
+    return CalendarDateTime.fromDate(baseDate, options.timezone);
+  }
+  /**
+   * Get the CalendarDate instance representing the date portion.
+   *
+   * @returns {CalendarDate} The CalendarDate object.
+   */
+  get calendarDate() {
+    return this.date;
+  }
+  /**
+   * Get the CalendarTime instance representing the time portion.
+   *
+   * @returns {CalendarTime} The CalendarTime object.
+   */
+  get calendarTime() {
+    return this.time;
+  }
+  /**
+   * Get a native Date object representing this CalendarDateTime.
+   *
+   * @returns {Date} The native Date object.
+   */
+  toDate() {
+    return this.date.toDate();
+  }
+  /**
+   * Set a new timezone and update CalendarDate/CalendarTime accordingly.
+   *
+   * @param {string} newTimezone - The new timezone to set.
+   */
+  setTimezone(newTimezone) {
+    this.timezone = newTimezone;
+    this.syncDateTime();
+  }
+  /**
+   * Sync CalendarDate and CalendarTime with the current originalDate and timezone.
+   */
+  syncDateTime() {
+    const normalized = this.convertDateToTimezone(this.originalDate);
+    this.date = new CalendarDate(normalized.getFullYear(), normalized.getMonth() + 1, normalized.getDate());
+    this.time = CalendarTime.fromDate(normalized);
+  }
+  /**
+   * Convert a Date to the specific timezone.
+   *
+   * @param {Date} date - The date to convert.
+   * @returns {Date} The date adjusted to the specific timezone.
+   */
+  convertDateToTimezone(date) {
+    if (this.timezone === getSystemTimezone()) {
+      return date;
+    }
+    try {
+      const formatter = new Intl.DateTimeFormat([], {
+        timeZone: this.timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+      });
+      const parts = formatter.formatToParts(date);
+      const yearPart = this.findDateTimeFormatPart(parts, 'year');
+      const monthPart = this.findDateTimeFormatPart(parts, 'month');
+      const dayPart = this.findDateTimeFormatPart(parts, 'day');
+      const hourPart = this.findDateTimeFormatPart(parts, 'hour');
+      const minutePart = this.findDateTimeFormatPart(parts, 'minute');
+      const secondPart = this.findDateTimeFormatPart(parts, 'second');
+      if (yearPart && monthPart && dayPart && hourPart && minutePart && secondPart) {
+        const year = parseInt(yearPart.value, 10);
+        const month = parseInt(monthPart.value, 10);
+        const day = parseInt(dayPart.value, 10);
+        const hour = parseInt(hourPart.value, 10);
+        const minute = parseInt(minutePart.value, 10);
+        const second = parseInt(secondPart.value, 10);
+        return new Date(year, month - 1, day, hour, minute, second);
+      }
+    }
+    catch (_a) {
+      LogUtility.warn('Invalid timezone:', this.timezone);
+    }
+    return date;
+  }
+  /**
+   * Find a specific part in the Intl.DateTimeFormatPart array.
+   *
+   * @param {Intl.DateTimeFormatPart[]} parts - The array of date/time format parts.
+   * @param {DateTimeFormatPartType} type - The type of part to find (e.g., 'year', 'month').
+   * @returns {Intl.DateTimeFormatPart | undefined} The matching part, if found.
+   */
+  findDateTimeFormatPart(parts, type) {
+    return parts.find((part) => part.type === type);
+  }
+}
+
 /**
  * Calendar date class
  */
@@ -917,8 +1106,7 @@ class CalendarDate {
    * @returns {CalendarDate} - Return a CalendarDate object
    */
   static from(currentDate, timezone = getSystemTimezone()) {
-    const { year, month, date } = getCurrentDatePartsInTimezone(timezone, currentDate);
-    return new CalendarDate(year, month, date);
+    return CalendarDateTime.fromDate(currentDate, timezone).calendarDate;
   }
   /**
    * The year of the calendar date
@@ -960,7 +1148,13 @@ class CalendarDate {
    * @returns {boolean} - Return true if the calendar date is today. Otherwise, return false.
    */
   isToday(timezone = getSystemTimezone()) {
-    const { year, month, date } = getCurrentDatePartsInTimezone(timezone, new Date());
+    if (timezone === getSystemTimezone()) {
+      const today = new Date();
+      return (today.getFullYear() === this.year &&
+        today.getMonth() + 1 === this.month &&
+        today.getDate() === this.date);
+    }
+    const { year, month, date } = CalendarDateTime.fromDate(new Date(), timezone).calendarDate;
     return year === this.year && month === this.month && date === this.date;
   }
   /**
@@ -2515,7 +2709,7 @@ class CalendarEvent {
    * @returns {Date} The `startDate` property of type `Date` is being returned.
    */
   get startDate() {
-    return this._startDate;
+    return this._startDateTime.toDate();
   }
   /**
    * The function returns the end date property of an object.
@@ -2523,23 +2717,23 @@ class CalendarEvent {
    * @returns {Date} The `endDate` property of type `Date` is being returned.
    */
   get endDate() {
-    return this._endDate;
+    return this._endDateTime.toDate();
   }
   /**
-   * This function returns the start time as a string.
+   * This function returns the start time as a CalendarTime.
    *
-   * @returns {string} The `_startTime` property, which is a string, is being returned.
+   * @returns {CalendarTime} The event start time.
    */
   get startTime() {
-    return this._startTime;
+    return this._startDateTime.calendarTime;
   }
   /**
-   * This function returns the end time as a string.
+   * This function returns the end time as a CalendarTime.
    *
-   * @returns {string} The `_endTime` property, which is a string, is being returned.
+   * @returns {CalendarTime} The event end time.
    */
   get endTime() {
-    return this._endTime;
+    return this._endDateTime.calendarTime;
   }
   /**
    * This function returns the number of days that an event spans.
@@ -2564,7 +2758,7 @@ class CalendarEvent {
     const endDate = this._eventSpansDays > 1
       ? new Date(startDate.year, startDate.month - 1, startDate.date + (this._eventSpansDays - 1))
       : startDate.toDate();
-    const result = new CalendarEvent(Object.assign(Object.assign({}, this._event), { startDate: startDate.toDate(), endDate: endDate, startTime: this.startTime, endTime: this.endTime }), eventKey);
+    const result = new CalendarEvent(Object.assign(Object.assign({}, this._event), { startDate: startDate.toDate(), endDate: endDate, startTime: this.startTime.toString(), endTime: this.endTime.toString() }), eventKey);
     return result;
   }
   /**
@@ -2607,8 +2801,8 @@ class CalendarEvent {
    */
   generateDateTimeString(viewDate, timeFormat) {
     const weekDay = VegaInternalTranslation.t(Object.values(WeekdayLongNames)[viewDate.toDate().getDay()]);
-    const startTime = formatDisplayTime(timeFormat, this.startTime);
-    const endTime = formatDisplayTime(timeFormat, this.endTime);
+    const startTime = this.startTime.toString(timeFormat);
+    const endTime = this.endTime.toString(timeFormat);
     return `${weekDay}, ${viewDate.date} ${viewDate.getMonthName(true)} ${viewDate.year} ${startTime} - ${endTime}`;
   }
   /**
@@ -2616,13 +2810,8 @@ class CalendarEvent {
    *
    * @returns {number} the minutes
    */
-  getEventDuration() {
-    const [startHour, startMinutes] = this.startTime.split(':');
-    const [endHour, endMinutes] = this.endTime.split(':');
-    const now = CalendarDate.from(new Date(), this._timezone);
-    const startDate = new Date(now.year, now.month, now.date, Number(startHour), Number(startMinutes));
-    const endDate = new Date(now.year, now.month, now.date, Number(endHour) === 0 && Number(startHour) !== 0 ? 24 : Number(endHour), Number(endMinutes));
-    return (endDate.valueOf() - startDate.valueOf()) / (60 * 1000);
+  getEventMinutes() {
+    return CalendarTime.calculateDuration(this.startTime, this.endTime, 'minutes');
   }
   /**
    * This function returns an array of repeat series based on a given calendar period.
@@ -2646,36 +2835,8 @@ class CalendarEvent {
    */
   updateTimezone(timezone) {
     this._timezone = timezone;
-    this.initDate(this._event);
-    this.initEventSpansDays();
-    this.initRepeatPattern();
-  }
-  /**
-   * The function `convertTimeTo24Hour` converts a time string from 12-hour format to 24-hour format in TypeScript.
-   *
-   * @param {string} timeString - The `convertTimeTo24Hour` function you provided is used to convert a
-   * time string from 12-hour format to 24-hour format. The function checks if the input time string is
-   * in 12-hour format and contains either 'am' or 'pm'.
-   * @returns {string} The `convertTimeTo24Hour` function returns a string representing the input time string
-   * converted to 24-hour format. If the input time string is in 12-hour format and contains 'am' or
-   * 'pm', it converts it to 24-hour format. If the input time string is not in 12-hour format or does
-   * not contain 'am' or 'pm', it returns the original input
-   */
-  convertTimeTo24Hour(timeString) {
-    timeString = timeString.toLocaleLowerCase();
-    if (timeString.indexOf('am') > 0 || timeString.indexOf('pm') > 0) {
-      if (timeString.indexOf('am') > 0) {
-        timeString = timeString.replace('am', '').trim();
-        const [hour, minutes] = timeString.split(':');
-        return `${hour === '12' ? '00' : hour}:${minutes}`;
-      }
-      else {
-        timeString = timeString.replace('pm', '').trim();
-        const [hour, minutes] = timeString.split(':');
-        return `${hour === '12' ? '12' : Number(hour) + 12}:${minutes}`;
-      }
-    }
-    return timeString;
+    this._startDateTime.setTimezone(timezone);
+    this._endDateTime.setTimezone(timezone);
   }
   /**
    * The function `checkEventRequireField` validates the required fields of a calendar event item in TypeScript.
@@ -2707,164 +2868,41 @@ class CalendarEvent {
    */
   initDate(eventOptions) {
     const { startDate, startTime, endDate, endTime } = eventOptions;
-    const originalDateParts = this.processStartDate(startDate, startTime || '');
-    this._startTime = this.formatTimeForDisplay(this._startDate, startTime || '');
-    this.processEndDate(endDate || '', endTime || '', originalDateParts);
-    this._endTime = this.formatTimeForDisplay(this._endDate, endTime || '');
+    this.processStartDate(startDate, startTime);
+    this.processEndDate(endDate, endTime, startDate);
   }
   /**
-   * Process start date
+   * Parse the supplied start date/time, normalize into calendar wrappers.
    *
-   * @param {string | Date} startDate - Start date (string or Date object)
-   * @param {string} startTime - Start time string
-   * @returns {DateParts | undefined} originalDateParts information
+   * @param {string | Date} startDate - Raw start date value from the event payload.
+   * @param {string} startTime - Optional textual time component to parse.
    */
   processStartDate(startDate, startTime) {
-    let originalDateParts;
-    let tempDate;
-    if (startDate && typeof startDate === 'object') {
-      originalDateParts = {
-        year: startDate.getFullYear(),
-        month: startDate.getMonth(),
-        date: startDate.getDate(),
-      };
-      tempDate = startDate;
-    }
-    else if (startDate && typeof startDate === 'string') {
-      const [month, day, year] = startDate.split('/');
-      originalDateParts = {
-        year: Number(year),
-        month: Number(month) - 1,
-        date: Number(day),
-      };
-      tempDate = new Date(originalDateParts.year, originalDateParts.month, originalDateParts.date);
-    }
-    if (startTime && originalDateParts && tempDate) {
-      const { timeHours, timeMinutes } = this.getCurrentHourAndMinutes(startTime);
-      tempDate = new Date(originalDateParts.year, originalDateParts.month, originalDateParts.date, timeHours, timeMinutes, 0);
-    }
-    if (tempDate) {
-      this._startDate = this.convertDateToTimezone(tempDate);
-    }
-    return originalDateParts;
-  }
-  /**
-   * Process end date
-   *
-   * @param {string | Date} endDate - End date (string or Date object)
-   * @param {string} endTime - End time string
-   * @param {DateParts | undefined} fallbackDateParts - Default date parts to use when endDate is empty
-   */
-  processEndDate(endDate, endTime, fallbackDateParts) {
-    let tempDate;
-    if (endDate && typeof endDate === 'object') {
-      tempDate = endDate;
-    }
-    else if (endDate && typeof endDate === 'string') {
-      const [month, day, year] = endDate.split('/');
-      tempDate = new Date(Number(year), Number(month) - 1, Number(day), 23, 59, 59);
-    }
-    else {
-      if (fallbackDateParts) {
-        tempDate = new Date(fallbackDateParts.year, fallbackDateParts.month, fallbackDateParts.date, 23, 59, 59);
-      }
-    }
-    if (endTime && tempDate) {
-      const { timeHours, timeMinutes } = this.getCurrentHourAndMinutes(endTime, 23, 59);
-      tempDate = new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate(), timeHours, timeMinutes, 59);
-    }
-    if (tempDate) {
-      this._endDate = this.convertDateToTimezone(tempDate);
-    }
-  }
-  /**
-   * Format time for display
-   *
-   * @param {Date} date - Date object
-   * @param {string} originalTime - Original time string
-   * @returns {string} Formatted time string
-   */
-  formatTimeForDisplay(date, originalTime) {
-    const shouldUseOriginalTime = Boolean(originalTime) && this._timezone === getSystemTimezone();
-    if (shouldUseOriginalTime) {
-      const convertedTime = this.convertTimeTo24Hour(originalTime);
-      const [hour, minutes] = convertedTime.split(':');
-      return `${date.getHours().toString().padStart(hour.length, '0')}:${date
-        .getMinutes()
-        .toString()
-        .padStart(minutes.length, '0')}`;
-    }
-    else {
-      return `${date.getHours()}:${date.getMinutes()}`;
-    }
-  }
-  /**
-   * Parses a time string and extracts hour and minute values.
-   * If the time string is empty or invalid, returns the provided default values.
-   *
-   * @param {string} time - The time string to parse (e.g., "14:30", "2:30 PM")
-   * @param {number} defaultHours - Default hour value to use when time is empty (default: 0)
-   * @param {number} defaultMinutes - Default minute value to use when time is empty (default: 0)
-   * @returns {CalendarTimeHourMinutes} An object containing timeHours and timeMinutes as numbers
-   */
-  getCurrentHourAndMinutes(time, defaultHours = 0, defaultMinutes = 0) {
-    let timeHours = defaultHours;
-    let timeMinutes = defaultMinutes;
-    if (time) {
-      const timeString = this.convertTimeTo24Hour(time).split(':');
-      timeHours = Number(timeString[0]);
-      timeMinutes = Number(timeString[1]);
-    }
-    return { timeHours, timeMinutes };
+    this._startDateTime = CalendarDateTime.fromInitDataSource(startDate, {
+      timezone: this._timezone,
+      time: startTime,
+    });
   }
   /**
-   * Converts a Date object to the target timezone
+   * Parse the supplied end date/time, normalize into calendar wrappers.
    *
-   * @param {Date} date - The Date object to convert
-   * @returns {Date} A Date object representing the date/time in the target timezone
+   * @param {string | Date | undefined} endDate - The raw end date value from the event payload.
+   * @param {string | undefined} endTime - The optional textual end time component to parse.
+   * @param {string | Date} originStartDate - The start date value to use as fallback if endDate is missing.
    */
-  convertDateToTimezone(date) {
-    if (this._timezone && this._timezone !== getSystemTimezone()) {
-      try {
-        const targetFormatter = new Intl.DateTimeFormat([], {
-          timeZone: this._timezone,
-          year: 'numeric',
-          month: '2-digit',
-          day: '2-digit',
-          hour: '2-digit',
-          minute: '2-digit',
-          second: '2-digit',
-          hour12: false,
-        });
-        const targetParts = targetFormatter.formatToParts(date);
-        const getYear = targetParts.find((part) => part.type === 'year');
-        const getMonth = targetParts.find((part) => part.type === 'month');
-        const getDay = targetParts.find((part) => part.type === 'day');
-        const getHour = targetParts.find((part) => part.type === 'hour');
-        const getMinute = targetParts.find((part) => part.type === 'minute');
-        const getSecond = targetParts.find((part) => part.type === 'second');
-        if (getYear && getMonth && getDay && getHour && getMinute && getSecond) {
-          const year = parseInt(getYear.value, 10);
-          const month = parseInt(getMonth.value, 10);
-          const day = parseInt(getDay.value, 10);
-          const hour = parseInt(getHour.value, 10);
-          const minute = parseInt(getMinute.value, 10);
-          const second = parseInt(getSecond.value, 10);
-          return new Date(year, month - 1, day, hour, minute, second);
-        }
-      }
-      catch (error) {
-        LogUtility.warn('Invalid timezone:', this._timezone);
-      }
-    }
-    return date;
+  processEndDate(endDate, endTime, originStartDate) {
+    this._endDateTime = CalendarDateTime.fromInitDataSource(endDate || originStartDate, {
+      timezone: this._timezone,
+      time: endTime,
+      endTimeMissing: !endTime && !endDate,
+    });
   }
   /**
    * The function initializes a repeat pattern controller for a calendar event with specified start and end dates and repeat options.
    */
   initRepeatPattern() {
     if (this._event.repeatOptions && this._event.repeatOptions.frequency) {
-      this.repeatPattern = calendarEventRepeatPatternFactory.getPattern(this._startDate, this._event.repeatOptions, this._timezone);
+      this.repeatPattern = calendarEventRepeatPatternFactory.getPattern(this.startDate, this._event.repeatOptions, this._timezone);
     }
   }
   /**
@@ -3037,7 +3075,7 @@ class VegaCalendarEventItemRenderer extends VegaSlimmer {
    * @returns {HTMLVegaCalendarEventElement} calendar event element
    */
   render(item, classMap, targetCalendarViewDate, isGroupEvent = false) {
-    return (h("vega-calendar-event", { "data-calendar-ref": this.host, key: `${item.eventKey}-${item.startTime}-${item.endTime}`, calendarEvent: item, class: classMap, onKeyDown: createEnterKeyHandlerToTriggerClick(), 
+    return (h("vega-calendar-event", { "data-calendar-ref": this.host, key: `${item.eventKey}-${item.startTime.toString()}-${item.endTime.toString()}`, calendarEvent: item, class: classMap, onKeyDown: createEnterKeyHandlerToTriggerClick(), 
       // eslint-disable-next-line react/jsx-no-bind
       onClick: () => {
         this.handleEventClick(item);
@@ -3282,7 +3320,7 @@ class VegaCalendarDayViewEventLayoutRenderer extends VegaSlimmer {
     layoutColumns.forEach((columns, index) => {
       let renderEvent = columns.getEventBySlotIndex(0);
       let start = 0;
-      for (let i = 0; i < VegaCalendarDayViewEventLayoutRenderer.totalNumberOfCells; i++) {
+      for (let i = 0; i <= VegaCalendarDayViewEventLayoutRenderer.TOTAL_NUMBER_OF_CELLS; i++) {
         const currentEvent = columns.getEventBySlotIndex(i);
         if (currentEvent !== renderEvent) {
           if (renderEvent) {
@@ -3317,14 +3355,14 @@ class VegaCalendarDayViewEventLayoutRenderer extends VegaSlimmer {
     return {
       position: 'absolute',
       left: `${left * 100}%`,
-      top: `${(100 / VegaCalendarDayViewEventLayoutRenderer.totalNumberOfCells) * startIndex}%`,
+      top: `${(100 / VegaCalendarDayViewEventLayoutRenderer.TOTAL_NUMBER_OF_CELLS) * startIndex}%`,
       width: `calc(100% - ${left * 100}%)`,
-      height: `${(100 / VegaCalendarDayViewEventLayoutRenderer.totalNumberOfCells) * (endIndex - startIndex)}%`,
+      height: `${(100 / VegaCalendarDayViewEventLayoutRenderer.TOTAL_NUMBER_OF_CELLS) * (endIndex - startIndex)}%`,
       zIndex: columnIndex > 0 ? `${columnIndex}` : undefined,
     };
   }
 }
-VegaCalendarDayViewEventLayoutRenderer.totalNumberOfCells = 24 * 4;
+VegaCalendarDayViewEventLayoutRenderer.TOTAL_NUMBER_OF_CELLS = 24 * 4;
 __decorate$h([
   MapToComponentField()
 ], VegaCalendarDayViewEventLayoutRenderer.prototype, "eventItemRenderer", void 0);
@@ -3491,7 +3529,9 @@ class VegaCalendarDayViewTimedEventLayoutColumn extends VegaCalendarBaseEventLay
    */
   getIndexRangeFromEvent(eventItem) {
     const { startTime, endTime } = eventItem;
-    return [getTimeIndex(startTime), getTimeIndex(endTime)];
+    const startIndex = getTimeIndex(startTime.toString());
+    const endIndex = getTimeIndex(endTime.toString());
+    return [startIndex, Math.max(endIndex, startIndex + 1)];
   }
 }
 VegaCalendarDayViewTimedEventLayoutColumn.defaultSlots = Array(96).fill(null);
@@ -3575,10 +3615,10 @@ class VegaCalendarEventSorter {
    */
   sortCalendarEventByTime(events) {
     return events.sort((eventA, eventB) => {
-      const eventAStartIndex = getTimeIndex(eventA.startTime);
-      const eventBStartIndex = getTimeIndex(eventB.startTime);
+      const eventAStartIndex = getTimeIndex(eventA.startTime.toString());
+      const eventBStartIndex = getTimeIndex(eventB.startTime.toString());
       if (eventAStartIndex === eventBStartIndex) {
-        return getTimeIndex(eventB.endTime) - getTimeIndex(eventA.endTime);
+        return getTimeIndex(eventB.endTime.toString()) - getTimeIndex(eventA.endTime.toString());
       }
       else {
         return eventAStartIndex - eventBStartIndex;
@@ -4779,7 +4819,7 @@ class VegaCalendarEventRenderer extends VegaSlimmer {
         this.slotMode ? this.getSlotElement() : this.defaultNormalMonthEventContentRender()));
     }
     else {
-      const eventDuration = this.calendarEvent.getEventDuration();
+      const eventDuration = this.calendarEvent.getEventMinutes();
       return (h("div", { part: "event-container", class: Object.assign(Object.assign({}, classMap), { 'vertical': eventDuration > 30, 'duration-half-an-hour': eventDuration === 30, 'event-bg-color': !disabled, 'bg-disabled': disabled }), role: "button", tabIndex: 0, ref: (node) => (this.slotContainerRef = node) },
         !this.slotMode && this.renderEventStatus(),
         h("div", { class: "cover-block" }),
@@ -4813,7 +4853,7 @@ class VegaCalendarEventRenderer extends VegaSlimmer {
    */
   defaultNormalMonthEventContentRender() {
     const { startTime, title } = this.calendarEvent;
-    return h("div", { class: "event-title" }, `${formatDisplayTime(this.timeFormat, startTime)} ${title}`);
+    return h("div", { class: "event-title" }, `${startTime.toString(this.timeFormat)} ${title}`);
   }
   /**
    * Render the day view timed event.
@@ -4830,7 +4870,7 @@ class VegaCalendarEventRenderer extends VegaSlimmer {
         }, ref: (node) => (this.eventTitleContainerRef = node) }, title),
       h("div", { class: "event-time" },
         h("vega-icon", { size: "size-12", icon: VegaInternalIconManager.getIconKey('clock-three') }),
-        h("span", null, `${formatDisplayTime(this.timeFormat, startTime)} - ${formatDisplayTime(this.timeFormat, endTime)}`))));
+        h("span", null, `${startTime.toString(this.timeFormat)} - ${endTime.toString(this.timeFormat)}`))));
   }
   /**
    * Return a slot element if the calendar is not a repeat event