@globalpayments/vega 2.66.0 → 2.68.0

package/dist/collection/helpers/calendar/calendar-event.js

@@ -2,8 +2,9 @@ import calendarEventRepeatPatternFactory from '../../components/vega-calendar/sl
 import { generateUUID } from '../../utils/misc';
 import { VegaInternalTranslation } from '../translation';
 import { CalendarDate } from './calendar-date';
-import { formatDisplayTime, getSystemTimezone, WeekdayLongNames } from './utils';
-import { LogUtility } from '../../utils/log';
+import { CalendarTime } from './calendar-time';
+import { CalendarDateTime } from './calendar-date-time';
+import { getSystemTimezone, WeekdayLongNames } from './utils';
 const CalendarDateFormatReg = /^\d{1,2}\/\d{1,2}\/\d{4}/;
 const CalendarTimeFormatReg = /^\d{1,2}:\d{1,2}/;
 /** The `CalendarEvent` class in TypeScript represents a calendar event with methods to validate required fields, initialize dates and times, and determine if it is a group event. */
@@ -101,7 +102,7 @@ export 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.
@@ -109,23 +110,23 @@ export 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.
@@ -150,7 +151,7 @@ export 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;
   }
   /**
@@ -193,8 +194,8 @@ export 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}`;
   }
   /**
@@ -202,13 +203,8 @@ export 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.
@@ -232,36 +228,8 @@ export 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.
@@ -293,164 +261,41 @@ export 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);
     }
   }
   /**

package/dist/collection/helpers/calendar/calendar-time.js

@@ -0,0 +1,120 @@
+import { VegaInternalTranslation } from '../translation';
+/**
+ * CalendarTime represents hours/minutes in 24-hour format and centralizes parsing/formatting logic.
+ */
+export 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}`;
+    }
+  }
+}

package/dist/collection/helpers/calendar/index.js

@@ -7,4 +7,6 @@ export { DayPeriod } from './calendar-period/day-period';
 export { WeekPeriod } from './calendar-period/week-period';
 export { MonthPeriod } from './calendar-period/month-period';
 export { CalendarDate } from './calendar-date';
+export { CalendarDateTime } from './calendar-date-time';
+export { CalendarTime } from './calendar-time';
 export { CalendarView } from './calendar-view';

package/dist/collection/helpers/calendar/test/calendar-date-time.test.js

@@ -0,0 +1,27 @@
+import { CalendarDateTime } from '../index';
+describe('calendar-date-time', () => {
+  it('normalizes native dates into timezone aware date and time', () => {
+    const sourceDate = new Date(2025, 5, 14, 10, 5, 30);
+    const dateTime = CalendarDateTime.fromDate(sourceDate, 'UTC');
+    const calendarDate = dateTime.calendarDate;
+    const calendarTime = dateTime.calendarTime;
+    expect(calendarDate.year).toBe(2025);
+    expect(calendarDate.month).toBe(6);
+    expect(calendarDate.date).toBe(14);
+    expect(calendarTime.toString()).toBe('10:05');
+  });
+  it('supports composing from input date and time string', () => {
+    const dateTime = CalendarDateTime.fromInitDataSource('2025-10-29', {
+      time: '1:30 pm',
+      timezone: 'UTC',
+    });
+    expect(dateTime.calendarTime.toString()).toBe('13:30');
+  });
+  it('falls back to end of day when requested', () => {
+    const dateTime = CalendarDateTime.fromInitDataSource('2025-10-29', {
+      endTimeMissing: true,
+      timezone: 'UTC',
+    });
+    expect(dateTime.calendarTime.toString()).toBe('23:59');
+  });
+});

package/dist/collection/helpers/calendar/test/calendar-event.test.js

@@ -25,9 +25,11 @@ describe('calendar-event', () => {
     expect(calendarEvent.eventKey).not.toBeNull();
     expect(calendarEvent.title).toEqual('Event title');
     expect(calendarEvent.isAllDayEvent).toEqual(false);
-    expect(calendarEvent.startTime).toEqual('13:44');
-    expect(calendarEvent.endTime).toEqual('14:44');
-    expect(calendarEvent.startDate).toEqual(mockDate);
+    expect(calendarEvent.startTime.toString()).toEqual('13:44');
+    expect(calendarEvent.endTime.toString()).toEqual('14:44');
+    expect(calendarEvent.startDate.getFullYear()).toEqual(mockDate.getFullYear());
+    expect(calendarEvent.startDate.getMonth()).toEqual(mockDate.getMonth());
+    expect(calendarEvent.startDate.getDate()).toEqual(mockDate.getDate());
     expect(calendarEvent.endDate.getDate()).toEqual(13);
     expect(calendarEvent.endDate.getMonth()).toEqual(5);
     expect(calendarEvent.isRepeatEvent).toEqual(false);
@@ -65,25 +67,25 @@ describe('calendar-event', () => {
     expect(calendarEvent1.startDate.getDate()).toEqual(13);
     expect(calendarEvent1.startDate.getMonth()).toEqual(5);
     expect(calendarEvent1.startDate.getFullYear()).toEqual(2024);
-    expect(calendarEvent1.startTime).toEqual('0:0');
+    expect(calendarEvent1.startTime.toString('h:m')).toEqual('0:0');
     expect(calendarEvent1.endDate.getDate()).toEqual(13);
     expect(calendarEvent1.endDate.getMonth()).toEqual(5);
     expect(calendarEvent1.endDate.getFullYear()).toEqual(2024);
-    expect(calendarEvent1.endTime).toEqual('14:44');
+    expect(calendarEvent1.endTime.toString()).toEqual('14:44');
     const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startTime: '10:00' }));
-    expect(calendarEvent2.startTime).toEqual('10:00');
+    expect(calendarEvent2.startTime.toString()).toEqual('10:00');
   });
   it('should init end date and time field correct', () => {
     const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00' }));
     expect(calendarEvent1.endDate.getDate()).toEqual(14);
     expect(calendarEvent1.endDate.getMonth()).toEqual(5);
     expect(calendarEvent1.endDate.getFullYear()).toEqual(2024);
-    expect(calendarEvent1.endTime).toEqual('18:00');
+    expect(calendarEvent1.endTime.toString()).toEqual('18:00');
     const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: new Date(2024, 5, 13, 15, 0), endTime: '' }));
     expect(calendarEvent2.endDate.getDate()).toEqual(13);
     expect(calendarEvent2.endDate.getMonth()).toEqual(5);
     expect(calendarEvent2.endDate.getFullYear()).toEqual(2024);
-    expect(calendarEvent2.endTime).toEqual('15:0');
+    expect(calendarEvent2.endTime.toString('hh:m')).toEqual('15:0');
   });
   it('should get group event correct', () => {
     const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00' }));
@@ -101,22 +103,22 @@ describe('calendar-event', () => {
   });
   it('should get event duration correct', () => {
     const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '10:00', endTime: '11:00', endDate: '06/14/2024' }));
-    expect(calendarEvent1.getEventDuration()).toEqual(60);
+    expect(calendarEvent1.getEventMinutes()).toEqual(60);
     const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '23:00', endTime: '00:00', endDate: '06/14/2024' }));
-    expect(calendarEvent2.getEventDuration()).toEqual(60);
+    expect(calendarEvent2.getEventMinutes()).toEqual(60);
     const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '00:00', endTime: '00:30', endDate: '06/14/2024' }));
-    expect(calendarEvent3.getEventDuration()).toEqual(30);
+    expect(calendarEvent3.getEventMinutes()).toEqual(30);
   });
   it('should init the event time correct when use 12-hour', () => {
     const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '12:00 am', endTime: '12:00 pm', endDate: '06/14/2024' }));
-    expect(calendarEvent1.startTime).toEqual('00:00');
-    expect(calendarEvent1.endTime).toEqual('12:00');
+    expect(calendarEvent1.startTime.toString()).toEqual('00:00');
+    expect(calendarEvent1.endTime.toString()).toEqual('12:00');
     const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '1:00 am', endTime: '2:00 am', endDate: '06/14/2024' }));
-    expect(calendarEvent2.startTime).toEqual('1:00');
-    expect(calendarEvent2.endTime).toEqual('2:00');
+    expect(calendarEvent2.startTime.toString('h:mm')).toEqual('1:00');
+    expect(calendarEvent2.endTime.toString('h:mm')).toEqual('2:00');
     const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '1:00 pm', endTime: '2:30 pm', endDate: '06/14/2024' }));
-    expect(calendarEvent3.startTime).toEqual('13:00');
-    expect(calendarEvent3.endTime).toEqual('14:30');
+    expect(calendarEvent3.startTime.toString()).toEqual('13:00');
+    expect(calendarEvent3.endTime.toString()).toEqual('14:30');
   });
   it('should create event correct when call copyTo', () => {
     const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', endDate: '06/15/2024', startTime: '12:00 am', endTime: '12:00 pm', repeatOptions: {
@@ -214,13 +216,13 @@ describe('calendar event with timezone', () => {
     await page.waitForChanges();
     expect(component.calendarEvents).toHaveLength(1);
     const calendarEvent = component.calendarEvents[0];
-    expect(calendarEvent.startTime).toBe('09:00');
+    expect(calendarEvent.startTime.toString()).toBe('09:00');
     calendarElement.timezone = 'Asia/Shanghai';
-    expect(calendarEvent.startTime).toBe('17:0');
-    expect(calendarEvent.endTime).toBe('1:0');
+    expect(calendarEvent.startTime.toString('hh:m')).toBe('17:0');
+    expect(calendarEvent.endTime.toString('h:m')).toBe('1:0');
     calendarElement.timezone = 'America/New_York';
-    expect(calendarEvent.startTime).toBe('5:0');
-    expect(calendarEvent.endTime).toBe('13:0');
+    expect(calendarEvent.startTime.toString('h:m')).toBe('5:0');
+    expect(calendarEvent.endTime.toString('hh:m')).toBe('13:0');
   });
   it('should handle timezone conversion with invalid timezone gracefully', async () => {
     const testEvents = [

package/dist/collection/helpers/calendar/test/calendar-period/day-period.test.js

@@ -93,8 +93,8 @@ describe('DayPeriod Timezone', () => {
     expect(dayPeriod.endDate).toEqual(new CalendarDate(2025, 10, 29));
   });
   it('should create day period with timezone Asia/Shanghai', () => {
-    jest.setSystemTime(new Date('2025-10-29T16:00:00Z'));
-    const dayPeriod = new DayPeriod(undefined, true, 'Asia/Shanghai');
+    const shanghaiDate = new CalendarDate(2025, 10, 30);
+    const dayPeriod = new DayPeriod(shanghaiDate, true, 'Asia/Shanghai');
     expect(dayPeriod.current).toEqual(new CalendarDate(2025, 10, 30));
     expect(dayPeriod.startDate).toEqual(new CalendarDate(2025, 10, 30));
     expect(dayPeriod.endDate).toEqual(new CalendarDate(2025, 10, 30));

package/dist/collection/helpers/calendar/test/calendar-period/month-period.test.js

@@ -80,8 +80,8 @@ describe('MonthPeriod Timezone', () => {
     expect(monthPeriod.endDate.month).toBe(11);
   });
   it('should create month period with timezone Asia/Shanghai', () => {
-    jest.setSystemTime(new Date('2025-10-31T16:00:00Z'));
-    const monthPeriod = new MonthPeriod(undefined, true, 'Asia/Shanghai');
+    const shanghaiDate = new CalendarDate(2025, 11, 1);
+    const monthPeriod = new MonthPeriod(shanghaiDate, true, 'Asia/Shanghai');
     expect(monthPeriod.current).toEqual(new CalendarDate(2025, 11, 1));
     expect(monthPeriod.startDate.month).toBe(10);
     expect(monthPeriod.endDate.month).toBe(12);

package/dist/collection/helpers/calendar/test/calendar-period/week-period.test.js

@@ -73,8 +73,8 @@ describe('WeekPeriod Timezone', () => {
     expect(weekPeriod.endDate).toEqual(new CalendarDate(2025, 11, 1));
   });
   it('should create week period with timezone Asia/Shanghai', () => {
-    jest.setSystemTime(new Date('2025-10-27T16:00:00Z'));
-    const weekPeriod = new WeekPeriod(undefined, true, 'Asia/Shanghai');
+    const shanghaiDate = new CalendarDate(2025, 10, 28);
+    const weekPeriod = new WeekPeriod(shanghaiDate, true, 'Asia/Shanghai');
     expect(weekPeriod.current).toEqual(new CalendarDate(2025, 10, 28));
     expect(weekPeriod.startDate).toEqual(new CalendarDate(2025, 10, 26));
     expect(weekPeriod.endDate).toEqual(new CalendarDate(2025, 11, 1));
@@ -87,12 +87,12 @@ describe('WeekPeriod Timezone', () => {
     expect(nextWeek.endDate).toEqual(new CalendarDate(2025, 11, 8));
   });
   it('should go to now with timezone America/New_York', () => {
-    jest.setSystemTime(new Date('2025-11-02T04:00:00Z'));
+    jest.setSystemTime(new Date('2025-12-15T12:00:00Z'));
     const weekPeriod = new WeekPeriod(undefined, true, 'America/New_York');
     const nowPeriod = weekPeriod.now();
-    expect(nowPeriod.current).toEqual(new CalendarDate(2025, 11, 2));
-    expect(nowPeriod.startDate).toEqual(new CalendarDate(2025, 11, 2));
-    expect(nowPeriod.endDate).toEqual(new CalendarDate(2025, 11, 8));
+    expect(nowPeriod.current).toEqual(new CalendarDate(2025, 12, 15));
+    expect(nowPeriod.startDate).toEqual(new CalendarDate(2025, 12, 14));
+    expect(nowPeriod.endDate).toEqual(new CalendarDate(2025, 12, 20));
   });
   it('should handle week period at year boundary', () => {
     const weekPeriod = new WeekPeriod(new CalendarDate(2025, 12, 31));