@heartlandone/vega 2.71.0 → 2.72.0-RTE-table-preview

package/dist/esm/{type-guard-12f7654b.js → type-guard-b48aec98.js}

@@ -1,6 +1,8 @@
 import { B as Breakpoints } from './breakpoints-d9faf11c.js';
-import { a as BorderStyle, F as FlexDirections, b as FlexAlignItem, c as FlexJustifyContent, d as FlexWrap, e as BoxDisplay, T as TextAlign, C as CssStates } from './ui-8424715a.js';
+import { B as BorderStyle, C as CssStates, F as FlexDirections, a as FlexAlignItem, b as FlexJustifyContent, c as FlexWrap, d as BoxDisplay, T as TextAlign } from './ui-28fd4193.js';
 import { a as TypographyKeys } from './typography-396de03f.js';
+import { V as VegaInternalTranslation } from './translation-96e5debd.js';
+import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
 
 const GridRowsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
 const GridColumnsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
@@ -8,6 +10,7 @@ const VisaRegex = /^4/;
 const MasterCardRegex = /^(5[1-5]|677189)|^(222[1-9]|2[3-6]\d{2}|27[0-1]\d|2720)/;
 const AmexRegex = /^3[47]/;
 const DiscoverRegex = /^(6011|65|64[4-9]|622)/;
+const DateFormatParserRegex = /(\\)?(Y{2,4}|M{1,4}|D{1,2}|d{1,4})/g;
 
 /* This file is generated by vega-design 2.0.77 */
 /* eslint-disable */
@@ -310,6 +313,1196 @@ const BorderMap = {
   'border-notification-btn-black': '2px solid rgba(var(--v-border-notification-btn-black, 32, 54, 69, 1))'
 };
 
+/**
+ * Get a week days array
+ *
+ * @param {number} firstWeekDay - The first week day (0: Sunday, 1: Monday, ...)
+ * @returns {number[]} - The week days array
+ */
+const getWeekdays = (firstWeekDay = 0) => {
+  const weekdays = [0, 1, 2, 3, 4, 5, 6];
+  return weekdays.concat(weekdays).slice(firstWeekDay, firstWeekDay + 7);
+};
+var WeekdayLongNames;
+(function (WeekdayLongNames) {
+  WeekdayLongNames["sun"] = "Sunday";
+  WeekdayLongNames["mon"] = "Monday";
+  WeekdayLongNames["tue"] = "Tuesday";
+  WeekdayLongNames["wed"] = "Wednesday";
+  WeekdayLongNames["thu"] = "Thursday";
+  WeekdayLongNames["fri"] = "Friday";
+  WeekdayLongNames["sat"] = "Saturday";
+})(WeekdayLongNames || (WeekdayLongNames = {}));
+/**
+ * Get the system timezone identifier
+ *
+ * @returns {string} - The system timezone identifier (e.g., "America/New_York")
+ */
+const getSystemTimezone = () => {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+};
+
+/**
+ * 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);
+  }
+}
+
+// TODO: Need rename calendar-date as vega-date to manage all date operation in vega project
+// https://gethired.atlassian.net/browse/VD-5918
+/**
+ * It returns true if the input is a valid date string, and false otherwise.
+ * Note:
+ *  This is not a strict date validation, it just use Date.parse to check the input string can be parsed to a valid date or not.
+ *  For strict date validation, please use CalendarDate.fromString method in calendar-date.ts
+ *  Example:
+ *      For Chrome: Date.parse('Jan/08/2026') => 1767801600000
+ *      For Safari: Date.parse('Jan/08/2026') => NaN
+ *      Format is DD/MM/YYYY: Date.parse('20/11/2024') => NaN
+ *
+ * @param {string} input - The string to check.
+ * @returns {boolean} is a valid date string or not
+ */
+const isDateStr = (input) => !isNaN(Date.parse(input));
+/**
+ * Compare if the firstDate is after the secondDate
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare to.
+ * @returns {boolean} Return true if the firstDate is after the secondDate, otherwise it returns false.
+ */
+const compareIsAfter = (firstDate, secondDate) => {
+  return firstDate.getTime() > secondDate.getTime();
+};
+/**
+ * Compare if the firstDate is before the secondDate
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare to.
+ * @returns {boolean} Return true if the firstDate is before the secondDate, otherwise it returns false.
+ */
+const compareIsBefore = (firstDate, secondDate) => {
+  return firstDate.getTime() < secondDate.getTime();
+};
+/**
+ * Compare if the first date is before or the same as the second date.
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare against.
+ * @returns {boolean} Return true if the firstDate is before or the same as the secondDate, otherwise it returns false.
+ */
+const compareIsSameOrBefore = (firstDate, secondDate) => {
+  return firstDate.getTime() <= secondDate.getTime();
+};
+/**
+ * It returns true if the input string is a valid time string in the format specified by the timeFormat parameter
+ *
+ * @param {string} input - The string to be tested.
+ * @param {TimeFormat} timeFormat - '12-hour' | '24-hour'
+ * @returns {boolean} A boolean value.
+ */
+const isTimeStr = (input, timeFormat) => {
+  return timeFormat === '12-hour'
+    ? new RegExp(/^(1[012]|0[1-9]):[0-5][0-9] ([AP][M])$/).test(input)
+    : new RegExp(/^([0-1][0-9]|2[0-3]):[0-5][0-9]$/).test(input);
+};
+/**
+ * It takes a number and returns a string
+ *
+ * @param {number} number - number - The number to pad
+ * @param {number} [length=2] - The length of the resulting string.
+ * @param {string} [padChar='0'] - The character to pad the number with.
+ * @returns {Nullable<string>} A function that takes a number as an argument and returns a nullable string.
+ */
+const pad = (number, length = 2, padChar = '0') => {
+  if (number || number === 0) {
+    return number.toString().padStart(length, padChar);
+  }
+  else {
+    LogUtility.error(`The input should be a number`);
+  }
+};
+/**
+ * The `convert12HourTo24HourFormat` function takes a time string in 12-hour format and converts it to 24-hour format.
+ *
+ * @param {string} time the time string need to convert, the time string should be 12-hour or 24-hour format
+ * @returns {string} 24 hour format time string
+ */
+const convert12HourTo24HourFormat = (time) => {
+  if (isTimeStr(time, '12-hour')) {
+    const [hour, minute, amPm] = time.replace(' ', ':').split(':');
+    let convertedHour = parseInt(hour, 10);
+    if (amPm === 'PM' && convertedHour !== 12) {
+      convertedHour += 12;
+    }
+    else if (amPm === 'AM' && convertedHour === 12) {
+      convertedHour = 0;
+    }
+    return `${pad(convertedHour)}:${minute}`;
+  }
+  return time;
+};
+
+// TODO: Need rename calendar-date as vega-date to manage all date operation in vega project
+// https://gethired.atlassian.net/browse/VD-5918
+/**
+ * Calendar date class
+ */
+class CalendarDate {
+  constructor(year, month, date) {
+    this._date = date;
+    this._month = month;
+    this._year = year;
+  }
+  /**
+   * Create a calendar date from a Date object
+   *
+   * @param {Date} currentDate - The Date object to create CalendarDate from
+   * @param {string} timezone - Timezone identifier for timezone-aware date creation. If not provided, uses system timezone.
+   * @returns {CalendarDate} - Return a CalendarDate object
+   */
+  static from(currentDate, timezone = getSystemTimezone()) {
+    return CalendarDateTime.fromDate(currentDate, timezone).calendarDate;
+  }
+  /**
+   * Converts a date string to CalendarDate with optional format and timezone parameters.
+   *
+   * @param {string} dateString - The string date.
+   * @param {string} [format] - The format of string date
+   * @param {string} [lang] - lang
+   * @returns {Nullable<CalendarDate>} - CalendarDate.
+   */
+  static fromString(dateString, format = 'MM/DD/YYYY', lang = 'en-us') {
+    if (!dateString)
+      return null;
+    const formatMatchers = [];
+    let formatMatcher = null;
+    // Analyze the format and find the corresponding positions for year, month, and day.
+    // Data: formatMatchers = [['DD', index: 0, ...], ['MM', index: 3, ...], ['YYYY', index: 7, ...]]
+    while ((formatMatcher = DateFormatParserRegex.exec(format)) != null) {
+      if (formatMatcher[1] === '\\')
+        continue;
+      formatMatchers.push(formatMatcher);
+    }
+    if (formatMatchers.length) {
+      const datePattern = {
+        year: undefined,
+        month: undefined,
+        shortMonth: undefined,
+        longMonth: undefined,
+        day: undefined,
+        value: '',
+      };
+      const firstMatcher = formatMatchers[0];
+      if (firstMatcher && firstMatcher.index > 0) {
+        datePattern.value += '.*?';
+      }
+      // According `matchers` to generate a new regex which can parse the date by corresponding year, month and day
+      // Data: dateRegex = "(\d{2}).*?(\d{2}).*?(\d{4}).*?"
+      //       datePattern = {day: 1, longMonth: null, month: 2, shortMonth: null, year: 3, value: "(\d{2}).*?(\d{2}).*?(\d{4}).*?"}
+      for (const [k, match] of Object.entries(formatMatchers)) {
+        const key = Number(k);
+        if (match) {
+          const { group, pattern } = this.getPatternByFormatToken(match[0], lang);
+          datePattern[group] = key + 1;
+          datePattern.value += pattern;
+          datePattern.value += '.*?';
+        }
+      }
+      const dateRegex = new RegExp(`^${datePattern.value}$`);
+      if (dateRegex.test(dateString)) {
+        // Parse the date
+        // Example: parsedDate = ['08-02-2020', '08', '02', '2020']
+        const parsedDate = dateRegex.exec(dateString);
+        if (parsedDate &&
+          datePattern.year &&
+          (datePattern.month || datePattern.shortMonth || datePattern.longMonth) &&
+          datePattern.day) {
+          const year = Number(parsedDate[datePattern.year]);
+          let month = 1;
+          if (datePattern.month) {
+            month = Number(parsedDate[datePattern.month]) - 1;
+          }
+          else if (datePattern.shortMonth) {
+            month = this.shortMonths(lang).indexOf(parsedDate[datePattern.shortMonth]);
+          }
+          else if (datePattern.longMonth) {
+            month = this.longMonths(lang).indexOf(parsedDate[datePattern.longMonth]);
+          }
+          const day = Number(parsedDate[datePattern.day]);
+          const fullYear = Number(pad(year, 4, `${new Date().getFullYear()}`.slice(0, 2)));
+          if (isNaN(Date.parse(`${fullYear}-${pad(month + 1)}-${pad(day)}`)))
+            return null;
+          return this.from(new Date(fullYear, month, day, 0, 0, 0, 0));
+        }
+      }
+    }
+    return this.from(new Date(dateString));
+  }
+  /**
+   * Get regex pattern by format token.
+   *
+   * @param {string} token - The format token.
+   * @param {string} lang - Language.
+   * @returns {FormatPatternType} - regex pattern.
+   */
+  static getPatternByFormatToken(token, lang) {
+    switch (token) {
+      case 'YY':
+      case 'YYYY':
+        return {
+          group: 'year',
+          pattern: `(\\d{${token.length}})`,
+        };
+      case 'M':
+        return {
+          group: 'month',
+          pattern: '(\\d{1,2})',
+        };
+      case 'MM':
+        return {
+          group: 'month',
+          pattern: '(\\d{2})',
+        };
+      case 'MMM':
+        return {
+          group: 'shortMonth',
+          pattern: `(${this.shortMonths(lang).join('|')})`,
+        };
+      case 'MMMM':
+        return {
+          group: 'longMonth',
+          pattern: `(${this.longMonths(lang).join('|')})`,
+        };
+      case 'D':
+        return {
+          group: 'day',
+          pattern: '(\\d{1,2})',
+        };
+      case 'DD':
+        return {
+          group: 'day',
+          pattern: '(\\d{2})',
+        };
+      /* istanbul ignore next */
+      default: {
+        return {
+          group: 'unknown',
+          pattern: '(.*)',
+        };
+      }
+    }
+  }
+  /**
+   * Shorts months.
+   *
+   * @param {string} lang - Language
+   * @returns {string[]} - Shorts months.
+   */
+  static shortMonths(lang) {
+    return this.MONTHS.map((month) => new Date(2019, month).toLocaleString(lang, { month: 'short' }));
+  }
+  /**
+   * Long months.
+   *
+   * @param {string} lang - Language
+   * @returns {string[]} - Long months.
+   */
+  static longMonths(lang) {
+    return this.MONTHS.map((month) => new Date(2019, month).toLocaleString(lang, { month: 'long' }));
+  }
+  /**
+   * The year of the calendar date
+   *
+   * @type {number}
+   */
+  get year() {
+    return this._year;
+  }
+  set year(value) {
+    this._year = value;
+  }
+  /**
+   * The month of the calendar date
+   *
+   * @type {number}
+   */
+  get month() {
+    return this._month;
+  }
+  set month(value) {
+    this._month = value;
+  }
+  /**
+   * The date of the calendar date
+   *
+   * @type {number}
+   */
+  get date() {
+    return this._date;
+  }
+  set date(value) {
+    this._date = value;
+  }
+  /**
+   * Converts CalendarDate to a string with an optional format specifier.
+   *
+   * @param {string} [format] - The format of string date
+   * @param {string} [lang] - Language
+   * @returns {string} The string date.
+   */
+  toString(format = 'MM/DD/YYYY', lang = 'en-us') {
+    let result = '';
+    const formatMatchers = [];
+    let formatMatcher = null;
+    while ((formatMatcher = DateFormatParserRegex.exec(format)) != null) {
+      if (formatMatcher[1] === '\\')
+        continue;
+      formatMatchers.push(formatMatcher);
+    }
+    if (formatMatchers.length) {
+      // add start line of tokens are not at the beginning
+      const firstMatcher = formatMatchers[0];
+      if (firstMatcher && firstMatcher.index > 0) {
+        result += format.substring(0, firstMatcher.index);
+      }
+      for (const [k, match] of Object.entries(formatMatchers)) {
+        const key = Number(k);
+        if (match) {
+          result += this.getDateItemByFormatToken(match[0], lang);
+          const nextMatch = formatMatchers[key + 1];
+          if (nextMatch) {
+            result += format.substring(match.index + match[0].length, nextMatch.index);
+          }
+          if (key === formatMatchers.length - 1) {
+            result += format.substring(match.index + match[0].length);
+          }
+        }
+      }
+    }
+    return result.replace(/\\/g, '');
+  }
+  /**
+   * Verify whether the calendar date is today
+   *
+   * @param {string} timezone - Timezone to consider when checking today's date. If not provided, uses system timezone.
+   * @returns {boolean} - Return true if the calendar date is today. Otherwise, return false.
+   */
+  isToday(timezone = getSystemTimezone()) {
+    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;
+  }
+  /**
+   * Convert the calendar date to a Date object
+   *
+   * @returns {Date} - Return a Date object
+   */
+  toDate() {
+    return new Date(this.year, this.month - 1, this.date);
+  }
+  /**
+   * Compare with another calendar date
+   *
+   * @param {CalendarDate} date - The calendar date to compare with
+   * @returns {DateCompareResult} - Return a DateCompareResult object
+   */
+  compare(date) {
+    const { year, month } = date;
+    const result = {
+      isPreviousMonth: false,
+      inMonth: false,
+      isNextMonth: false,
+    };
+    if (this.year === year) {
+      if (this.month < month) {
+        result.isPreviousMonth = true;
+      }
+      else if (this.month > month) {
+        result.isNextMonth = true;
+      }
+      else {
+        result.inMonth = true;
+      }
+    }
+    else if (this.year > year) {
+      result.isNextMonth = true;
+    }
+    else {
+      result.isPreviousMonth = true;
+    }
+    return result;
+  }
+  /**
+   * The function "equal" compares the year, month, and date of two CalendarDate objects and returns  true if they are equal.
+   *
+   * @param {Nullable<CalendarDate>} calendarDate - The `equal` method in the code snippet is a function that compares the year, month, and date of the current `CalendarDate` object with another
+   * `CalendarDate` object passed as a parameter. The method returns `true` if all three values (year, month, date) are equal
+   * @returns {boolean} The date is same day with current
+   */
+  equal(calendarDate) {
+    if (!calendarDate)
+      return false;
+    const { year, month, date } = calendarDate;
+    return this._year === year && this._month === month && this._date === date;
+  }
+  /**
+   * Get month name.
+   *
+   * @param {boolean} isShortName - Whether to get the short name or long name of the month
+   * @returns {string} The name of the month
+   */
+  getMonthName(isShortName = false) {
+    return VegaInternalTranslation.t(this.toDate().toLocaleDateString('en-US', {
+      month: isShortName ? 'short' : 'long',
+    }));
+  }
+  /**
+   * To determine if it is larger than a given `CalendarDate`.
+   *
+   * @param {Nullable<CalendarDate>} calendarDate - A `CalendarDate`
+   * @returns {boolean} - Compared result
+   */
+  isAfter(calendarDate) {
+    if (!calendarDate)
+      return false;
+    return compareIsAfter(this.toDate(), calendarDate.toDate());
+  }
+  /**
+   * To determine if it is less than a given `CalendarDate`.
+   *
+   * @param {Nullable<CalendarDate>} calendarDate - A `CalendarDate`
+   * @returns {boolean} - Compared result
+   */
+  isBefore(calendarDate) {
+    if (!calendarDate)
+      return false;
+    return compareIsBefore(this.toDate(), calendarDate.toDate());
+  }
+  /**
+   * Get first day of month.
+   *
+   * @returns {CalendarDate} - First day of month.
+   */
+  firstDateOfMonth() {
+    return CalendarDate.from(new Date(this.year, this.month - 1, 1));
+  }
+  /**
+   * Get last day of month.
+   *
+   * @returns {CalendarDate} - Last day of month.
+   */
+  lastDateOfMonth() {
+    return CalendarDate.from(new Date(this.year, this.month, 0));
+  }
+  /**
+   * Adjusts the calendar date by adding the specified number of years, months, and days.
+   *
+   * @param {number} [years=0] - The number of years to add.
+   * @param {number} [months=0] - The number of months to add.
+   * @param {number} [days=0] - The number of days to add.
+   * @returns {CalendarDate} - A new CalendarDate object with the adjusted date.
+   */
+  add(years = 0, months = 0, days = 0) {
+    const currentDate = this.toDate();
+    const adjustedDate = new Date(currentDate.getFullYear() + years, currentDate.getMonth() + months, currentDate.getDate() + days);
+    return CalendarDate.from(adjustedDate);
+  }
+  /**
+   * Get year, month and day value by format token.
+   *
+   * @param {string} token - The format token.
+   * @param {string} lang - Language.
+   * @returns {string} - year, month and day value.
+   */
+  getDateItemByFormatToken(token, lang) {
+    switch (token) {
+      case 'YY':
+        return String(this.year).slice(-2);
+      case 'YYYY':
+        return String(this.year);
+      case 'M':
+        return String(this.month);
+      case 'MM':
+        return `0${this.month}`.slice(-2);
+      case 'MMM':
+        return CalendarDate.shortMonths(lang)[this.month - 1];
+      case 'MMMM':
+        return CalendarDate.longMonths(lang)[this.month - 1];
+      case 'D':
+        return String(this.date);
+      case 'DD':
+        return `0${this.date}`.slice(-2);
+      default:
+        return '';
+    }
+  }
+}
+CalendarDate.MONTHS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+
+/**
+ * CalendarPeriod is an abstract class that represents a period of date for calendar.
+ */
+class CalendarPeriod {
+  constructor(count, current, timezone) {
+    this._count = count;
+    this._timezone = timezone || getSystemTimezone();
+    this._current = current ? current : CalendarDate.from(new Date(), this._timezone);
+    this.calculatePeriod(this._current);
+  }
+  /**
+   * The current date of the period.
+   *
+   * @type {CalendarDate}
+   */
+  get current() {
+    return this._current;
+  }
+  /**
+   * The start date of the period
+   *
+   * @type {CalendarDate}
+   */
+  get startDate() {
+    return this._startDate;
+  }
+  /**
+   * The end date of the period
+   *
+   * @type {CalendarDate}
+   */
+  get endDate() {
+    return this._endDate;
+  }
+  /**
+   * The count of the period
+   *
+   * @type {number}
+   */
+  get count() {
+    return this._count;
+  }
+  /**
+   * This function returns the type of the object.
+   *
+   * @type {string}
+   */
+  get type() {
+    return this._type;
+  }
+  /**
+   * This function returns the showWeekends of the object.
+   *
+   * @type {boolean}
+   */
+  get showWeekends() {
+    return this._showWeekends;
+  }
+  /**
+   * The timezone of the period.
+   *
+   * @type {string | undefined}
+   */
+  get timezone() {
+    return this._timezone;
+  }
+  /**
+   * Go to a specific date.
+   *
+   * @param {CalendarDate} date - The date to go to.
+   * @returns {this} - The current period.
+   */
+  goTo(date) {
+    return this.createBy(date);
+  }
+  /**
+   * Go to now.
+   *
+   * @returns {this} - The current period.
+   */
+  now() {
+    return this.createBy(CalendarDate.from(new Date(), this._timezone));
+  }
+  /**
+   * Check the give period is equal to current period
+   *
+   * @param {CalendarPeriod} [period] - Give period to compare
+   * @returns {boolean} compare result
+   */
+  equal(period) {
+    return this.startDate.equal(period.startDate) && this.endDate.equal(period.endDate);
+  }
+  /**
+   * Calculate the period start date and end date.
+   *
+   * @param {CalendarDate} date - The date to calculate the period from.
+   */
+  calculatePeriod(date) {
+    const cursor = date.toDate();
+    if (this.count > 1) {
+      cursor.setDate(cursor.getDate() - getWeekdays().indexOf(cursor.getDay()));
+    }
+    this._startDate = CalendarDate.from(cursor);
+    cursor.setDate(cursor.getDate() + this.count - 1);
+    this._endDate = CalendarDate.from(cursor);
+  }
+}
+
+/**
+ * StateVariantFormatter: Format state token to CSS styles
+ */
+class StateVariantFormatter {
+  /**
+   * The function `format` takes an input state variant type and returns formatted CSS styles based on
+   * the input.
+   *
+   * @param {StateVariantType} input - The `format` function takes an `input` parameter of type
+   * `StateVariantType<ManagedStateScopeInput[Flag], State>`. This means that the `input` parameter
+   * should be an object that contains styles for different states, where the keys are state names and
+   * the values are the corresponding styles
+   * @returns {string} The `format` function returns a string that contains CSS styles based on the input
+   * provided. If the input is determined to be a state variant token type, the function generates CSS
+   * styles for each state in the input and returns them joined by newlines. If the input is not a state
+   * variant token type, the function generates CSS styles for the default state and returns them.
+   */
+  format(input) {
+    if (isStateVariantTokenType(input)) {
+      const stateStyles = [];
+      this.getStates().forEach((state) => {
+        const style = this.formatToken(input[state]);
+        if (style) {
+          stateStyles.push(`:host${state === 'default' ? '' : `(:${state})`}{\n\t${style}\n}`);
+        }
+      });
+      return stateStyles.join('\n');
+    }
+    else {
+      const style = this.formatToken(input);
+      return `:host{\n\t${style}\n}`;
+    }
+  }
+}
+
+/**
+ * The `StateBackgroundColorFormatter` class in TypeScript formats background color tokens
+ * and handles different CSS states.
+ */
+class StateBackgroundColorFormatter extends StateVariantFormatter {
+  constructor() {
+    super(...arguments);
+    this.states = ['default', 'hover', 'active', 'focus-visible'];
+  }
+  /**
+   * The function `formatToken` takes a `BackgroundColorsTokenType` input, checks if it is a valid
+   * background color token type, and returns the corresponding CSS background color value or logs a
+   * warning if the input is invalid.
+   *
+   * @param {BackgroundColorsTokenType} input - The `input` parameter is of type
+   * `BackgroundColorsTokenType`, which is used to represent different background color tokens.
+   * @returns {string} The `formatToken` function takes a `BackgroundColorsTokenType` input and checks if it is a
+   * valid background color token type. If it is valid, it retrieves the corresponding color value from
+   * the `BackgroundColorMap` and returns a CSS style string with the background color. If the input is
+   * not valid, it logs a warning message using `LogUtility.warn` and returns an empty string.
+   */
+  formatToken(input) {
+    if (isBackgroundColorTokenType(input)) {
+      const tokenValue = BackgroundColorMap[input];
+      return `background-color: ${tokenValue};`;
+    }
+    else {
+      LogUtility.warn(`The backgroundColor value ${input} is invalid, it must be a value of: `, BackgroundColors);
+      return '';
+    }
+  }
+  /**
+   * The function `getStates` returns an array of `CssStatesType` objects.
+   *
+   * @returns {CssStatesType[]} An array of objects of type CssStatesType, which represents the states stored in the
+   * variable this.states.
+   */
+  getStates() {
+    return this.states;
+  }
+}
+const StateBackgroundColorFormatter$1 = new StateBackgroundColorFormatter();
+
+var DateDirection;
+(function (DateDirection) {
+  DateDirection["PREVIOUS"] = "-1";
+  DateDirection["NEXT"] = "1";
+})(DateDirection || (DateDirection = {}));
+/**
+ * The function `getTimeIndex` calculates the index of a given time string based on a specified time unit.
+ *
+ * @param {string} timeString - A string representing a time in the format "HH:MM", where HH is the hour and MM is the minutes.
+ * @param {number} [unit=15] - The `unit` parameter in the `getTimeIndex` function is used to specify
+ * the interval in minutes for dividing the day. By default, it is set to 15 minutes, meaning that the
+ * day will be divided into 15-minute intervals.
+ * @returns {number} the index of the given time string based on the specified time unit.
+ */
+function getTimeIndex(timeString, unit = 15) {
+  const [hour, minutes] = timeString.split(':');
+  return Math.round((Number(hour) * 60 + Number(minutes)) / unit);
+}
+/**
+ * Returns a string that includes the event key for a calendar event slot.
+ *
+ * @param {string} eventKey - represents the key or identifier of a calendar event.
+ * @returns {string} a string that is a concatenation of 'vega-calendar-event-slot-' and the eventKey parameter.
+ */
+function getCalendarEventSlotName(eventKey) {
+  return 'vega-calendar-event-slot-' + eventKey;
+}
+/**
+ * Returns the closest workday to a given calendar date based on a specified direction.
+ *
+ * @param {Date} date - The starting date from which you want to find the closest workday.
+ * @param {'-1' | '1'} [direction=1] - Determines whether to find the closest workday in the past or future. It can have two possible values:
+ * @returns {CalendarDate} The closest workday to the input date
+ */
+function getClosestWorkday(date, direction = DateDirection.NEXT) {
+  const day = date.toDate().getDay();
+  if (day === 0 || day === 6) {
+    let nextWorkdayGap = day === 0 ? 1 : 2;
+    if (direction === DateDirection.PREVIOUS) {
+      nextWorkdayGap = day === 0 ? -2 : -1;
+    }
+    return CalendarDate.from(new Date(date.year, date.month - 1, date.date + nextWorkdayGap));
+  }
+  return date;
+}
+/**
+ * Get event status background color.
+ *
+ * @param {Nullable<string | BackgroundColorsTokenType>} color the background color
+ * @returns {string} background color style string
+ */
+function getEventStatusBgColorStyle(color = 'bg-accent6-primary') {
+  if (isBackgroundColorTokenType(color)) {
+    return `.event-bg-color{${StateBackgroundColorFormatter$1.formatToken(color)}}`;
+  }
+  else {
+    return `.event-bg-color{background-color:${color}}`;
+  }
+}
+
+/**
+ * Period of day.
+ */
+class DayPeriod extends CalendarPeriod {
+  constructor(current, showWeekends, timezone) {
+    super(DayPeriod.DISPLAY_DATE_COUNT, current, timezone);
+    this._type = 'day';
+    this._showWeekends = true;
+    this._showWeekends = showWeekends === false ? false : true;
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const nextDate = this.current.toDate();
+    nextDate.setDate(nextDate.getDate() + 1);
+    let calendarDate = CalendarDate.from(nextDate);
+    if (this._showWeekends === false) {
+      calendarDate = getClosestWorkday(calendarDate);
+    }
+    return this.createBy(calendarDate);
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const previousDate = this.current.toDate();
+    previousDate.setDate(previousDate.getDate() - 1);
+    let calendarDate = CalendarDate.from(previousDate);
+    if (this._showWeekends === false) {
+      calendarDate = getClosestWorkday(calendarDate, DateDirection.PREVIOUS);
+    }
+    return this.createBy(calendarDate);
+  }
+  /**
+   * Go to now.
+   *
+   * @returns {this} - The current period.
+   */
+  now() {
+    let calendarDate = CalendarDate.from(new Date(), this.timezone);
+    if (this._showWeekends === false) {
+      calendarDate = getClosestWorkday(calendarDate);
+    }
+    return this.createBy(calendarDate);
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new DayPeriod(current, this._showWeekends, this.timezone);
+  }
+}
+DayPeriod.DISPLAY_DATE_COUNT = 1;
+
+/**
+ * Period of the week
+ */
+class WeekPeriod extends CalendarPeriod {
+  constructor(current, showWeekends, timezone) {
+    super(WeekPeriod.DISPLAY_DATE_COUNT, current, timezone);
+    this._type = 'week';
+    this._showWeekends = true;
+    this._showWeekends = showWeekends === false ? false : true;
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const currentDate = this.current.toDate();
+    currentDate.setDate(currentDate.getDate() + 7);
+    return this.createBy(CalendarDate.from(currentDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const currentDate = this.current.toDate();
+    currentDate.setDate(currentDate.getDate() - 7);
+    return this.createBy(CalendarDate.from(currentDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new WeekPeriod(current, this._showWeekends, this.timezone);
+  }
+}
+WeekPeriod.DISPLAY_DATE_COUNT = 7;
+
+/**
+ * Period of month
+ */
+class MonthPeriod extends CalendarPeriod {
+  constructor(current, showWeekends, timezone) {
+    super(MonthPeriod.DISPLAY_DATE_COUNT, current, timezone);
+    this._type = 'month';
+    this._showWeekends = true;
+    this._showWeekends = showWeekends === false ? false : true;
+  }
+  /**
+   * The function `getMonthFirstDay` returns the first day of a given month in a calendar.
+   *
+   * @param {CalendarDate} [calendarDate] - The `calendarDate` parameter is an optional parameter of
+   * type `CalendarDate`. It represents a specific date in the calendar. If a `calendarDate` is
+   * provided, the function will use that date to determine the first day of the month. If no
+   * `calendarDate` is provided, the function will use the current date considering timezone.
+   * @param {string} [timezone] - The timezone to use when no calendarDate is provided
+   * @returns {CalendarDate} A new `CalendarDate` object representing the first day of the month from the provided
+   * `calendarDate` parameter or the current date if no parameter is provided.
+   */
+  static getMonthFirstDay(calendarDate, timezone) {
+    const date = calendarDate || CalendarDate.from(new Date(), timezone);
+    return new CalendarDate(date.year, date.month, 1);
+  }
+  /**
+   * Calculate the period start date and end date.
+   *
+   * @param {CalendarDate} date - The date to calculate the period from.
+   */
+  calculatePeriod(date) {
+    const firstDay = MonthPeriod.getMonthFirstDay(date);
+    const cursor = firstDay.toDate();
+    cursor.setDate(cursor.getDate() - getWeekdays().indexOf(cursor.getDay()));
+    this._startDate = CalendarDate.from(cursor);
+    cursor.setDate(cursor.getDate() + this.count - 1);
+    this._endDate = CalendarDate.from(cursor);
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const current = this.current.toDate();
+    const year = current.getFullYear();
+    const month = current.getMonth() + 1;
+    const day = current.getDate();
+    // Get the last day of the next month
+    const lastDayOfNextMonth = new Date(year, month + 1, 0).getDate();
+    const nextDay = Math.min(day, lastDayOfNextMonth);
+    const next = new Date(year, month, nextDay);
+    return this.createBy(CalendarDate.from(next));
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const current = this.current.toDate();
+    const year = current.getFullYear();
+    const month = current.getMonth() - 1;
+    const day = current.getDate();
+    // Get the last day of the previous month
+    const lastDayOfPreviousMonth = new Date(year, month + 1, 0).getDate();
+    const previousDay = Math.min(day, lastDayOfPreviousMonth);
+    const previous = new Date(year, month, previousDay);
+    return this.createBy(CalendarDate.from(previous));
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new MonthPeriod(current, this._showWeekends, this.timezone);
+  }
+}
+MonthPeriod.DISPLAY_DATE_COUNT = 6 * 7;
+
 /**
  * Returns true if the input is a string that is one of the four directions.
  *
@@ -688,5 +1881,14 @@ const isVegaTableColumnGroupingModelType = (input) => {
     'label' in input &&
     typeof input.label === 'string');
 };
+/**
+ * Check is calendar date type
+ *
+ * @param {unknown} input - Value to test.
+ * @returns {input is CalendarDate} True when input matches the calendar date type.
+ */
+const isCalendarDateType = (input) => {
+  return input instanceof CalendarDate;
+};
 
-export { AmexRegex as A, BorderRadius as B, Colors as C, DiscoverRegex as D, isTranslocationType as E, FillBackgroundColors as F, isFlexDirectionType as G, isFlexAlignItemType as H, isFlexJustifyContentType as I, isFlexWrapType as J, isBoxDisplayType as K, isDirectionalBorderRadiusType as L, MasterCardRegex as M, isTextAlignType as N, isStateVariantTokenType as O, isAccordionObserverPayload as P, isArrayOfType as Q, isDropdownSourceItemType as R, StrokeBackgroundColors as S, TextColors as T, isSelectSourceItemType as U, VisaRegex as V, isVegaTableColumnGroupingModelType as W, BackgroundColors as a, BorderColors as b, TextColorMap as c, BackgroundColorMap as d, BorderColorMap as e, Shadows as f, ShadowMap as g, Spacing as h, isNonNullable as i, isBorderColorTokenType as j, isShadowsTokenType as k, isBorderTokenType as l, Borders as m, BorderMap as n, isSpacingTokenType as o, isBorderRadiusTokenType as p, isBackgroundColorTokenType as q, isTextColorTokenType as r, isBreakpointsTokenType as s, isBorderStyleType as t, isTypographyTokenType as u, isResponsiveType as v, isBreakpointsForPrefixType as w, isDirectionalSpacingType as x, isGridColumnsType as y, isGridRowsType as z };
+export { compareIsAfter as $, AmexRegex as A, BorderRadius as B, Colors as C, DiscoverRegex as D, isGridColumnsType as E, FillBackgroundColors as F, isGridRowsType as G, isTranslocationType as H, isFlexDirectionType as I, isFlexAlignItemType as J, isFlexJustifyContentType as K, isFlexWrapType as L, MasterCardRegex as M, isBoxDisplayType as N, isDirectionalBorderRadiusType as O, isTextAlignType as P, isDateStr as Q, isTimeStr as R, StrokeBackgroundColors as S, TextColors as T, isAccordionObserverPayload as U, VisaRegex as V, isArrayOfType as W, isDropdownSourceItemType as X, isSelectSourceItemType as Y, compareIsSameOrBefore as Z, compareIsBefore as _, BackgroundColors as a, CalendarDate as a0, MonthPeriod as a1, isCalendarDateType as a2, getWeekdays as a3, pad as a4, convert12HourTo24HourFormat as a5, getClosestWorkday as a6, DayPeriod as a7, WeekPeriod as a8, WeekdayLongNames as a9, getSystemTimezone as aa, CalendarTime as ab, CalendarDateTime as ac, getCalendarEventSlotName as ad, getTimeIndex as ae, getEventStatusBgColorStyle as af, isVegaTableColumnGroupingModelType as ag, BorderColors as b, TextColorMap as c, BackgroundColorMap as d, BorderColorMap as e, Shadows as f, ShadowMap as g, Spacing as h, isNonNullable as i, StateVariantFormatter as j, isBorderColorTokenType as k, isShadowsTokenType as l, isBorderTokenType as m, Borders as n, BorderMap as o, StateBackgroundColorFormatter$1 as p, isSpacingTokenType as q, isBorderRadiusTokenType as r, isBackgroundColorTokenType as s, isTextColorTokenType as t, isBreakpointsTokenType as u, isBorderStyleType as v, isTypographyTokenType as w, isResponsiveType as x, isBreakpointsForPrefixType as y, isDirectionalSpacingType as z };