@globalpayments/vega 2.13.1 → 2.14.0

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

@@ -0,0 +1,256 @@
+import { generateUUID } from '../../utils/misc';
+import { CalendarDate } from './calendar-date';
+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. */
+export class CalendarEvent {
+  /**
+   * The constructor initializes a VegaCalendarRawEvent object and performs validation checks on required fields.
+   *
+   * @param {VegaCalendarRawEvent} eventOptions - The `eventOptions` parameter in the constructor
+   * represents the raw event data for a Vega calendar event. It contains information such as the event
+   * title, start and end dates, location, description, and any other relevant details about the event.
+   */
+  constructor(eventOptions) {
+    this._event = eventOptions;
+    this._eventKey = generateUUID();
+    this.checkEventRequireField(eventOptions);
+    this.initDate(eventOptions);
+  }
+  /**
+   * The function returns the raw event data for a VegaCalendar event.
+   *
+   * @returns {VegaCalendarRawEvent} The `get event()` method is returning a `VegaCalendarRawEvent` object, which is stored in the `_event` property.
+   */
+  get event() {
+    return this._event;
+  }
+  /**
+   * This function returns the key of an event in TypeScript.
+   *
+   * @returns {string} event key
+   */
+  get eventKey() {
+    return this._eventKey;
+  }
+  /**
+   * This function returns the title of an event in TypeScript.
+   *
+   * @returns {string} The title of the event.
+   */
+  get title() {
+    return this._event.title;
+  }
+  /**
+   * This function returns the disabled of an event in TypeScript.
+   *
+   * @returns {boolean} The disabled of the event.
+   */
+  get disabled() {
+    return !!this._event.disabled;
+  }
+  /**
+   * This function returns the variant of an event in TypeScript.
+   *
+   * @returns {VegaCalendarEventVariantType|null} The variant of the event.
+   */
+  get variant() {
+    return this._event.variant;
+  }
+  /**
+   * This function returns the color of an event in TypeScript.
+   *
+   * @returns {string|null} The color of the event.
+   */
+  get color() {
+    return this._event.color;
+  }
+  /**
+   * The function isAllDayEvent returns a boolean value indicating whether the event is an all-day event.
+   *
+   * @returns {boolean} The method `isAllDayEvent()` is returning a boolean value indicating whether the event is an all-day event or not. It returns `true` if the event is an all-day event, and `false` if it is not.
+   */
+  get isAllDayEvent() {
+    return !!this._event.isAllDay;
+  }
+  /**
+   * The function isRepeatEvent returns a boolean value based on whether the event's repeat property is not equal to 'none'.
+   *
+   * @returns {boolean} The method `isRepeatEvent` returns a boolean value indicating whether the `_event` has a repeat value other than 'none'.
+   */
+  get isRepeatEvent() {
+    return this._event.repeat !== 'none';
+  }
+  /**
+   * The function returns the start date property of an object.
+   *
+   * @returns {Date} The `startDate` property of type `Date` is being returned.
+   */
+  get startDate() {
+    return this._startDate;
+  }
+  /**
+   * The function returns the end date property of an object.
+   *
+   * @returns {Date} The `endDate` property of type `Date` is being returned.
+   */
+  get endDate() {
+    return this._endDate;
+  }
+  /**
+   * This function returns the start time as a string.
+   *
+   * @returns {string} The `_startTime` property, which is a string, is being returned.
+   */
+  get startTime() {
+    return this._startTime;
+  }
+  /**
+   * This function returns the end time as a string.
+   *
+   * @returns {string} The `_endTime` property, which is a string, is being returned.
+   */
+  get endTime() {
+    return this._endTime;
+  }
+  /**
+   * Check the event is a group event or not
+   *
+   * @returns {boolean} true or false
+   */
+  isGroupEvent() {
+    const { year: startYear, month: startMonth, date: startDay, } = CalendarDate.from(this.startDate);
+    const { year: endYear, month: endMonth, date: endDay, } = CalendarDate.from(this.endDate);
+    return (!(startYear === endYear && startMonth === endMonth && startDay === endDay) &&
+      this._event.repeat !== 'daily');
+  }
+  /**
+   * This TypeScript function checks if a given date falls within the range of a calendar event based on its start and end dates, considering different repeat types like daily, weekly, monthly, and yearly.
+   *
+   * @param {CalendarDate} date - The `date` parameter represents the current date for which you want to
+   * check if it falls within the range of the `calendarEvent`. It is of type `CalendarDate`.
+   * @returns {boolean} a boolean value, either `true` or `false`, based on whether the `calendarEvent` falls on the `date` provided.
+   */
+  isCurrentDayEvent(date) {
+    const { startDate, endDate } = this;
+    const startCalendarDate = CalendarDate.from(startDate);
+    const endCalendarDate = CalendarDate.from(new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate() + 1));
+    const repeat = this._event.repeat;
+    const currentDate = date.toDate();
+    if (startCalendarDate.toDate() <= currentDate) {
+      switch (repeat) {
+        case 'daily':
+          return true;
+        case 'weekly':
+          return currentDate.getDay() === startDate.getDay();
+        case 'monthly':
+          return date.date === startCalendarDate.date;
+        case 'yearly':
+          return date.month === startCalendarDate.month && date.date === startCalendarDate.date;
+        default:
+          return endCalendarDate.toDate() > currentDate;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get the number of minutes the event lasted
+   *
+   * @returns {number} the minutes
+   */
+  getEventDuration() {
+    const [startHour, startMinutes] = this.startTime.split(':');
+    const [endHour, endMinutes] = this.endTime.split(':');
+    const now = CalendarDate.from(new Date());
+    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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * The function `checkEventRequireField` validates the required fields of a calendar event item in TypeScript.
+   *
+   * @param {VegaCalendarRawEvent} eventOptions - The `eventOptions` parameter is an object of type
+   * `VegaCalendarRawEvent` that contains information about a calendar event
+   */
+  checkEventRequireField(eventOptions) {
+    const { title, startDate, endDate, startTime, endTime } = eventOptions;
+    if ((startDate && typeof startDate === 'string' && !CalendarDateFormatReg.test(startDate)) ||
+      (endDate && typeof endDate === 'string' && !CalendarDateFormatReg.test(endDate))) {
+      throw new Error('Invalid calendar event item, the date format should be MM/DD/YYYY!');
+    }
+    if ((startTime && typeof startTime === 'string' && !CalendarTimeFormatReg.test(startTime)) ||
+      (endTime && typeof endTime === 'string' && !CalendarTimeFormatReg.test(endTime))) {
+      throw new Error('Invalid calendar event item, the time format should be HH:mm!');
+    }
+    if (!title || !startDate || (!endDate && !endTime)) {
+      throw new Error('Invalid calendar event item, the required field should not empty!');
+    }
+  }
+  /**
+   * The `initDate` function in TypeScript initializes start and end dates and times for a calendar event based on the provided options.
+   *
+   * @param {VegaCalendarRawEvent} eventOptions - The `initDate` method you provided is used to
+   * initialize the start and end dates for a calendar event based on the options provided in the
+   * `eventOptions` object. The `eventOptions` object contains properties such as `startDate`,
+   * `startTime`, `endDate`, and `endTime` which are used
+   */
+  initDate(eventOptions) {
+    const { startDate, startTime, endDate, endTime } = eventOptions;
+    if (startDate && typeof startDate === 'object') {
+      this._startDate = startDate;
+    }
+    else if (startDate && typeof startDate === 'string') {
+      const [month, day, year] = startDate.split('/');
+      this._startDate = new Date(Number(year), Number(month) - 1, Number(day));
+    }
+    if (!startTime) {
+      this._startTime = `${this._startDate.getHours()}:${this._startDate.getMinutes()}`;
+    }
+    else {
+      this._startTime = this.convertTimeTo24Hour(startTime);
+    }
+    if (endDate && typeof endDate === 'object') {
+      this._endDate = endDate;
+    }
+    else if (endDate && typeof endDate === 'string') {
+      const [month, day, year] = endDate.split('/');
+      this._endDate = new Date(Number(year), Number(month) - 1, Number(day), 23, 59, 59);
+    }
+    else {
+      this._endDate = new Date(this._startDate.getFullYear(), this._startDate.getMonth(), this._startDate.getDate(), 23, 59, 59);
+    }
+    if (!endTime) {
+      this._endTime = `${this._endDate.getHours()}:${this._endDate.getMinutes()}`;
+    }
+    else {
+      this._endTime = this.convertTimeTo24Hour(endTime);
+    }
+  }
+}

package/dist/collection/helpers/calendar/calendar-period/calendar-period.abstract.js

@@ -0,0 +1,75 @@
+import { CalendarDate } from '../calendar-date';
+import { getWeekdays } from '../utils';
+/**
+ * CalendarPeriod is an abstract class that represents a period of date for calendar.
+ */
+export class CalendarPeriod {
+  constructor(count, current) {
+    this._count = count;
+    this._current = current ? current : CalendarDate.from(new Date());
+    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;
+  }
+  /**
+   * 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()));
+  }
+  /**
+   * 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);
+  }
+}

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

@@ -0,0 +1,33 @@
+import { CalendarPeriod } from './calendar-period.abstract';
+import { CalendarDate } from '../calendar-date';
+/**
+ * Period of day.
+ */
+export class DayPeriod extends CalendarPeriod {
+  constructor(current) {
+    super(DayPeriod.DISPLAY_DATE_COUNT, current);
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const nextDate = this.current.toDate();
+    nextDate.setDate(nextDate.getDate() + 1);
+    return this.createBy(CalendarDate.from(nextDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const previousDate = this.current.toDate();
+    previousDate.setDate(previousDate.getDate() - 1);
+    return this.createBy(CalendarDate.from(previousDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new DayPeriod(current);
+  }
+}
+DayPeriod.DISPLAY_DATE_COUNT = 1;

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

@@ -0,0 +1,35 @@
+import { CalendarPeriod } from './calendar-period.abstract';
+import { CalendarDate } from '../calendar-date';
+/**
+ * Period of month
+ */
+export class MonthPeriod extends CalendarPeriod {
+  constructor(current) {
+    const date = current || CalendarDate.from(new Date());
+    const firstDayOfMonth = new CalendarDate(date.year, date.month, 1);
+    super(MonthPeriod.DISPLAY_DATE_COUNT, firstDayOfMonth);
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const next = this.current.toDate();
+    next.setMonth(next.getMonth() + 1);
+    return this.createBy(CalendarDate.from(next));
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const previous = this.current.toDate();
+    previous.setMonth(previous.getMonth() - 1);
+    return this.createBy(CalendarDate.from(previous));
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new MonthPeriod(current);
+  }
+}
+MonthPeriod.DISPLAY_DATE_COUNT = 6 * 7;

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

@@ -0,0 +1,34 @@
+import { CalendarPeriod } from './calendar-period.abstract';
+import { getWeekdays } from '../utils';
+import { CalendarDate } from '../calendar-date';
+/**
+ * Period of the week
+ */
+export class WeekPeriod extends CalendarPeriod {
+  constructor(current) {
+    super(WeekPeriod.DISPLAY_DATE_COUNT, current);
+  }
+  /**
+   * @inheritDoc
+   */
+  next() {
+    const nextWeekStartDate = this.current.toDate();
+    nextWeekStartDate.setDate(nextWeekStartDate.getDate() - getWeekdays().indexOf(nextWeekStartDate.getDay()) + 7);
+    return this.createBy(CalendarDate.from(nextWeekStartDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  previous() {
+    const previousWeekStartDate = this.current.toDate();
+    previousWeekStartDate.setDate(previousWeekStartDate.getDate() - getWeekdays().indexOf(previousWeekStartDate.getDay()) - 7);
+    return this.createBy(CalendarDate.from(previousWeekStartDate));
+  }
+  /**
+   * @inheritDoc
+   */
+  createBy(current) {
+    return new WeekPeriod(current);
+  }
+}
+WeekPeriod.DISPLAY_DATE_COUNT = 7;

package/dist/collection/helpers/calendar/calendar-view-generator/calendar-view-generator.abstract.js

@@ -0,0 +1,41 @@
+import { getWeekdays } from '../utils';
+/**
+ * Calendar view generator abstract class.
+ */
+export class CalendarViewGenerator {
+  constructor() {
+    this.WEEKDAYS_SHORT = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    this.weekdays = getWeekdays();
+  }
+  /**
+   * Get weekday names.
+   *
+   * @returns {string[]} - The weekday strings
+   */
+  getWeekdayNames() {
+    return this.WEEKDAYS_SHORT;
+  }
+  /**
+   * Generate calendar dates
+   *
+   * @param {CalendarPeriod} period - The calendar period
+   * @returns {Date[]} - The date result
+   */
+  generateDates(period) {
+    const cursor = period.startDate.toDate();
+    const dates = [];
+    for (let i = 0; i < period.count; i++) {
+      dates.push(new Date(cursor));
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    return dates;
+  }
+  /**
+   * Generate calendar head
+   *
+   * @returns {string[]} - The data of week head
+   */
+  generateWeekHead() {
+    return this.weekdays.map((day) => this.getWeekdayNames()[day]);
+  }
+}

package/dist/collection/helpers/calendar/calendar-view-generator/day-view-generator.js

@@ -0,0 +1,13 @@
+import { CalendarViewGenerator } from './calendar-view-generator.abstract';
+import { CalendarView } from '../calendar-view';
+/**
+ * Day view calendar generator
+ */
+export class DayViewGenerator extends CalendarViewGenerator {
+  /**
+   * @inheritDoc
+   */
+  generate(period) {
+    return new CalendarView([this.generateWeekHead()[period.current.toDate().getDay()]], [[period.current]]);
+  }
+}

package/dist/collection/helpers/calendar/calendar-view-generator/month-view-generator.js

@@ -0,0 +1,24 @@
+import { CalendarViewGenerator } from './calendar-view-generator.abstract';
+import { CalendarDate } from '../calendar-date';
+import { CalendarView } from '../calendar-view';
+/**
+ * Calendar month view generator
+ */
+export class MonthViewGenerator extends CalendarViewGenerator {
+  /**
+   * @inheritDoc
+   */
+  generate(period) {
+    const calendarDates = [];
+    let week = [];
+    const dates = this.generateDates(period);
+    dates.forEach((date, i) => {
+      if (!(i % 7)) {
+        calendarDates[i / 7] = week = [];
+      }
+      const item = CalendarDate.from(date);
+      week.push(item);
+    });
+    return new CalendarView(this.generateWeekHead(), calendarDates);
+  }
+}

package/dist/collection/helpers/calendar/calendar-view-generator/week-view-generator.js

@@ -0,0 +1,15 @@
+import { CalendarViewGenerator } from './calendar-view-generator.abstract';
+import { CalendarDate } from '../calendar-date';
+import { CalendarView } from '../calendar-view';
+/**
+ * Calendar week view generator
+ */
+export class WeekViewGenerator extends CalendarViewGenerator {
+  /**
+   * @inheritDoc
+   */
+  generate(period) {
+    const dates = this.generateDates(period);
+    return new CalendarView(this.generateWeekHead(), [dates.map(CalendarDate.from)]);
+  }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Calendar view
+ */
+export class CalendarView {
+  constructor(weekdays, dateItems) {
+    this._weekdays = weekdays;
+    this._dateItems = dateItems;
+  }
+  /**
+   * The week head of the calendar view
+   *
+   * @type {string[]}
+   */
+  get weekdays() {
+    return this._weekdays;
+  }
+  /**
+   * The date items of the calendar view
+   *
+   * @type {CalendarDate[][]}
+   */
+  get dateItems() {
+    return this._dateItems;
+  }
+}

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

@@ -0,0 +1,10 @@
+export { CalendarViewGenerator } from './calendar-view-generator/calendar-view-generator.abstract';
+export { DayViewGenerator } from './calendar-view-generator/day-view-generator';
+export { WeekViewGenerator } from './calendar-view-generator/week-view-generator';
+export { MonthViewGenerator } from './calendar-view-generator/month-view-generator';
+export { CalendarPeriod } from './calendar-period/calendar-period.abstract';
+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 { CalendarView } from './calendar-view';

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

@@ -0,0 +1,71 @@
+import { CalendarDate } from '../calendar-date';
+describe('calendar-date', () => {
+  it('should new a calendar date with value', () => {
+    const calendarDate = new CalendarDate(2024, 2, 10);
+    const { year, month, date } = calendarDate;
+    expect({ year, month, date }).toEqual({
+      year: 2024,
+      month: 2,
+      date: 10,
+    });
+  });
+  it('should new a calendar date by from a date', () => {
+    const today = new Date();
+    const calendarDate = CalendarDate.from(today);
+    const { year, month, date } = calendarDate;
+    expect({ year, month, date }).toEqual({
+      year: today.getFullYear(),
+      month: today.getMonth() + 1,
+      date: today.getDate(),
+    });
+  });
+  it('should change the date value by setter', () => {
+    const calendarDate = new CalendarDate(2024, 2, 10);
+    calendarDate.year = 2022;
+    calendarDate.month = 5;
+    calendarDate.date = 4;
+    const { year, month, date } = calendarDate;
+    expect({ year, month, date }).toEqual({
+      year: 2022,
+      month: 5,
+      date: 4,
+    });
+  });
+  it('should return as expected when call isToday', () => {
+    expect(new CalendarDate(2024, 2, 10).isToday()).toBeFalsy();
+    expect(CalendarDate.from(new Date()).isToday()).toBeTruthy();
+  });
+  it('should return a date object when call toDate', () => {
+    expect(new CalendarDate(2024, 2, 10).toDate()).toEqual(new Date(2024, 1, 10));
+  });
+  it('should return compare result when call compare', () => {
+    const calendarDate = new CalendarDate(2024, 2, 10);
+    const nextMonths = [
+      [2024, 3, 10],
+      [2025, 2, 10],
+    ];
+    const previousMonths = [
+      [2024, 1, 10],
+      [2023, 2, 10],
+    ];
+    nextMonths.forEach((date) => {
+      expect(calendarDate.compare(new CalendarDate(...date))).toEqual({
+        inMonth: false,
+        isNextMonth: false,
+        isPreviousMonth: true,
+      });
+    });
+    previousMonths.forEach((date) => {
+      expect(calendarDate.compare(new CalendarDate(...date))).toEqual({
+        inMonth: false,
+        isNextMonth: true,
+        isPreviousMonth: false,
+      });
+    });
+    expect(calendarDate.compare(new CalendarDate(2024, 2, 3))).toEqual({
+      inMonth: true,
+      isNextMonth: false,
+      isPreviousMonth: false,
+    });
+  });
+});