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

package/dist/cjs/{type-guard-f12b5bae.js → type-guard-69d2cf01.js}

@@ -3,6 +3,8 @@
 const breakpoints = require('./breakpoints-ebde4837.js');
 const ui = require('./ui-32e69595.js');
 const typography = require('./typography-4560e7f1.js');
+const translation = require('./translation-5f9f9c0c.js');
+const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 
 const GridRowsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
 const GridColumnsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
@@ -10,6 +12,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 */
@@ -312,6 +315,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);
+};
+exports.WeekdayLongNames = void 0;
+(function (WeekdayLongNames) {
+  WeekdayLongNames["sun"] = "Sunday";
+  WeekdayLongNames["mon"] = "Monday";
+  WeekdayLongNames["tue"] = "Tuesday";
+  WeekdayLongNames["wed"] = "Wednesday";
+  WeekdayLongNames["thu"] = "Thursday";
+  WeekdayLongNames["fri"] = "Friday";
+  WeekdayLongNames["sat"] = "Saturday";
+})(exports.WeekdayLongNames || (exports.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} ${translation.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) {
+      globalSlimmerRegistry.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 {
+    globalSlimmerRegistry.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 translation.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 {
+      globalSlimmerRegistry.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.
  *
@@ -690,6 +1883,15 @@ 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;
+};
 
 exports.AmexRegex = AmexRegex;
 exports.BackgroundColorMap = BackgroundColorMap;
@@ -699,17 +1901,35 @@ exports.BorderColors = BorderColors;
 exports.BorderMap = BorderMap;
 exports.BorderRadius = BorderRadius;
 exports.Borders = Borders;
+exports.CalendarDate = CalendarDate;
+exports.CalendarDateTime = CalendarDateTime;
+exports.CalendarTime = CalendarTime;
 exports.Colors = Colors;
+exports.DayPeriod = DayPeriod;
 exports.DiscoverRegex = DiscoverRegex;
 exports.FillBackgroundColors = FillBackgroundColors;
 exports.MasterCardRegex = MasterCardRegex;
+exports.MonthPeriod = MonthPeriod;
 exports.ShadowMap = ShadowMap;
 exports.Shadows = Shadows;
 exports.Spacing = Spacing;
+exports.StateBackgroundColorFormatter = StateBackgroundColorFormatter$1;
+exports.StateVariantFormatter = StateVariantFormatter;
 exports.StrokeBackgroundColors = StrokeBackgroundColors;
 exports.TextColorMap = TextColorMap;
 exports.TextColors = TextColors;
 exports.VisaRegex = VisaRegex;
+exports.WeekPeriod = WeekPeriod;
+exports.compareIsAfter = compareIsAfter;
+exports.compareIsBefore = compareIsBefore;
+exports.compareIsSameOrBefore = compareIsSameOrBefore;
+exports.convert12HourTo24HourFormat = convert12HourTo24HourFormat;
+exports.getCalendarEventSlotName = getCalendarEventSlotName;
+exports.getClosestWorkday = getClosestWorkday;
+exports.getEventStatusBgColorStyle = getEventStatusBgColorStyle;
+exports.getSystemTimezone = getSystemTimezone;
+exports.getTimeIndex = getTimeIndex;
+exports.getWeekdays = getWeekdays;
 exports.isAccordionObserverPayload = isAccordionObserverPayload;
 exports.isArrayOfType = isArrayOfType;
 exports.isBackgroundColorTokenType = isBackgroundColorTokenType;
@@ -720,6 +1940,8 @@ exports.isBorderTokenType = isBorderTokenType;
 exports.isBoxDisplayType = isBoxDisplayType;
 exports.isBreakpointsForPrefixType = isBreakpointsForPrefixType;
 exports.isBreakpointsTokenType = isBreakpointsTokenType;
+exports.isCalendarDateType = isCalendarDateType;
+exports.isDateStr = isDateStr;
 exports.isDirectionalBorderRadiusType = isDirectionalBorderRadiusType;
 exports.isDirectionalSpacingType = isDirectionalSpacingType;
 exports.isDropdownSourceItemType = isDropdownSourceItemType;
@@ -734,9 +1956,10 @@ exports.isResponsiveType = isResponsiveType;
 exports.isSelectSourceItemType = isSelectSourceItemType;
 exports.isShadowsTokenType = isShadowsTokenType;
 exports.isSpacingTokenType = isSpacingTokenType;
-exports.isStateVariantTokenType = isStateVariantTokenType;
 exports.isTextAlignType = isTextAlignType;
 exports.isTextColorTokenType = isTextColorTokenType;
+exports.isTimeStr = isTimeStr;
 exports.isTranslocationType = isTranslocationType;
 exports.isTypographyTokenType = isTypographyTokenType;
 exports.isVegaTableColumnGroupingModelType = isVegaTableColumnGroupingModelType;
+exports.pad = pad;