@globalpayments/vega 2.13.1 → 2.15.0

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

@@ -0,0 +1,130 @@
+import { CalendarDate } from '../calendar-date';
+import { CalendarEvent } from '../calendar-event';
+const mockDate = new Date(2024, 5, 13, 13, 44);
+const mockStringDate = '06/13/2024';
+const rawEvent = {
+  key: '1',
+  title: 'Event title',
+  startDate: mockDate,
+  endDate: '',
+  startTime: '',
+  endTime: '14:44',
+  disabled: false,
+  repeat: 'none',
+  isAllDay: false,
+  variant: 'secondary',
+  color: 'red',
+};
+describe('calendar-event', () => {
+  it('should new a calendar event with value', () => {
+    const calendarEvent = new CalendarEvent(rawEvent);
+    expect(calendarEvent).not.toBeNull();
+    expect(calendarEvent.eventKey).not.toBeNull();
+    expect(calendarEvent.title).toEqual('Event title');
+    expect(calendarEvent.isAllDayEvent).toEqual(false);
+    expect(calendarEvent.startTime).toEqual('13:44');
+    expect(calendarEvent.endTime).toEqual('14:44');
+    expect(calendarEvent.startDate).toEqual(mockDate);
+    expect(calendarEvent.endDate.getDate()).toEqual(13);
+    expect(calendarEvent.endDate.getMonth()).toEqual(5);
+    expect(calendarEvent.isRepeatEvent).toEqual(false);
+    expect(calendarEvent.variant).toEqual('secondary');
+    expect(calendarEvent.disabled).toEqual(false);
+    expect(calendarEvent.color).toEqual('red');
+    expect(calendarEvent.event).toEqual(rawEvent);
+  });
+  it('should throw error when event options is incorrect', () => {
+    function wrongStartDate() {
+      new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '2024-06-13' }));
+    }
+    expect(wrongStartDate).toThrowError('Invalid calendar event item, the date format should be MM/DD/YYYY!');
+    function wrongEndDate() {
+      new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '2024-06-13' }));
+    }
+    expect(wrongEndDate).toThrowError('Invalid calendar event item, the date format should be MM/DD/YYYY!');
+    function wrongStartTime() {
+      new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startTime: '13-44' }));
+    }
+    expect(wrongStartTime).toThrowError('Invalid calendar event item, the time format should be HH:mm!');
+    function wrongEndTime() {
+      new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endTime: '14-44' }));
+    }
+    expect(wrongEndTime).toThrowError('Invalid calendar event item, the time format should be HH:mm!');
+    function emptyEndTime() {
+      new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endTime: '' }));
+    }
+    expect(emptyEndTime).toThrowError('Invalid calendar event item, the required field should not empty!');
+  });
+  it('should init start date and time field correct', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: mockStringDate }));
+    expect(calendarEvent1.startDate.getDate()).toEqual(13);
+    expect(calendarEvent1.startDate.getMonth()).toEqual(5);
+    expect(calendarEvent1.startDate.getFullYear()).toEqual(2024);
+    expect(calendarEvent1.startTime).toEqual('0:0');
+    expect(calendarEvent1.endDate.getDate()).toEqual(13);
+    expect(calendarEvent1.endDate.getMonth()).toEqual(5);
+    expect(calendarEvent1.endDate.getFullYear()).toEqual(2024);
+    expect(calendarEvent1.endTime).toEqual('14:44');
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startTime: '10:00' }));
+    expect(calendarEvent2.startTime).toEqual('10:00');
+  });
+  it('should init end date and time field correct', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00' }));
+    expect(calendarEvent1.endDate.getDate()).toEqual(14);
+    expect(calendarEvent1.endDate.getMonth()).toEqual(5);
+    expect(calendarEvent1.endDate.getFullYear()).toEqual(2024);
+    expect(calendarEvent1.endTime).toEqual('18:00');
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: new Date(2024, 5, 13, 15, 0), endTime: '' }));
+    expect(calendarEvent2.endDate.getDate()).toEqual(13);
+    expect(calendarEvent2.endDate.getMonth()).toEqual(5);
+    expect(calendarEvent2.endDate.getFullYear()).toEqual(2024);
+    expect(calendarEvent2.endTime).toEqual('15:0');
+  });
+  it('should get group event correct', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00' }));
+    expect(calendarEvent1.isGroupEvent()).toBeTruthy();
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00', repeat: 'daily' }));
+    expect(calendarEvent2.isGroupEvent()).toBeFalsy();
+  });
+  it('should check current day event correct with normal event', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', endTime: '18:00' }));
+    expect(calendarEvent1.isCurrentDayEvent(new CalendarDate(2024, 6, 14))).toBeTruthy();
+    expect(calendarEvent1.isCurrentDayEvent(new CalendarDate(2024, 6, 15))).toBeFalsy();
+  });
+  it('should check current day event correct with repeat event', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', repeat: 'daily' }));
+    expect(calendarEvent1.isCurrentDayEvent(new CalendarDate(2024, 6, 12))).toBeFalsy();
+    expect(calendarEvent1.isCurrentDayEvent(new CalendarDate(2024, 6, 13))).toBeTruthy();
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', repeat: 'weekly' }));
+    expect(calendarEvent2.isCurrentDayEvent(new CalendarDate(2024, 6, 19))).toBeFalsy();
+    expect(calendarEvent2.isCurrentDayEvent(new CalendarDate(2024, 6, 13))).toBeTruthy();
+    expect(calendarEvent2.isCurrentDayEvent(new CalendarDate(2024, 6, 20))).toBeTruthy();
+    const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', repeat: 'monthly' }));
+    expect(calendarEvent3.isCurrentDayEvent(new CalendarDate(2024, 6, 13))).toBeTruthy();
+    expect(calendarEvent3.isCurrentDayEvent(new CalendarDate(2024, 7, 12))).toBeFalsy();
+    expect(calendarEvent3.isCurrentDayEvent(new CalendarDate(2024, 7, 13))).toBeTruthy();
+    const calendarEvent4 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { endDate: '06/14/2024', repeat: 'yearly' }));
+    expect(calendarEvent4.isCurrentDayEvent(new CalendarDate(2024, 6, 13))).toBeTruthy();
+    expect(calendarEvent4.isCurrentDayEvent(new CalendarDate(2025, 6, 13))).toBeTruthy();
+    expect(calendarEvent4.isCurrentDayEvent(new CalendarDate(2024, 7, 14))).toBeFalsy();
+  });
+  it('should check current day event correct with repeat event', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '10:00', endTime: '11:00', endDate: '06/14/2024' }));
+    expect(calendarEvent1.getEventDuration()).toEqual(60);
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '23:00', endTime: '00:00', endDate: '06/14/2024' }));
+    expect(calendarEvent2.getEventDuration()).toEqual(60);
+    const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '00:00', endTime: '00:30', endDate: '06/14/2024' }));
+    expect(calendarEvent3.getEventDuration()).toEqual(30);
+  });
+  it('should init the event time correct when use 12-hour', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '12:00 am', endTime: '12:00 pm', endDate: '06/14/2024' }));
+    expect(calendarEvent1.startTime).toEqual('00:00');
+    expect(calendarEvent1.endTime).toEqual('12:00');
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '1:00 am', endTime: '2:00 am', endDate: '06/14/2024' }));
+    expect(calendarEvent2.startTime).toEqual('1:00');
+    expect(calendarEvent2.endTime).toEqual('2:00');
+    const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', startTime: '1:00 pm', endTime: '2:30 pm', endDate: '06/14/2024' }));
+    expect(calendarEvent3.startTime).toEqual('13:00');
+    expect(calendarEvent3.endTime).toEqual('14:30');
+  });
+});

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

@@ -0,0 +1,65 @@
+import { DayPeriod } from '../../calendar-period/day-period';
+import { CalendarDate } from '../../calendar-date';
+describe('day-period', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2022-04-05'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should new a day period as expected by default', () => {
+    const today = CalendarDate.from(new Date());
+    const { current, count, startDate, endDate } = new DayPeriod();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 1,
+      current: today,
+      startDate: today,
+      endDate: today,
+    });
+  });
+  it('should go to date when call goTo method', () => {
+    const dayPeriod = new DayPeriod();
+    const newDate = new CalendarDate(2024, 2, 3);
+    const { current, count, startDate, endDate } = dayPeriod.goTo(newDate);
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 1,
+      current: newDate,
+      startDate: newDate,
+      endDate: newDate,
+    });
+  });
+  it('should go to now when call now method', () => {
+    const dayPeriod = new DayPeriod();
+    const { current, count, startDate, endDate } = dayPeriod.now();
+    const today = CalendarDate.from(new Date());
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 1,
+      current: today,
+      startDate: today,
+      endDate: today,
+    });
+  });
+  it('should go to next day when call next', () => {
+    const dayPeriod = new DayPeriod();
+    const nextDate = new CalendarDate(2022, 4, 6);
+    const { current, count, startDate, endDate } = dayPeriod.next();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 1,
+      current: nextDate,
+      startDate: nextDate,
+      endDate: nextDate,
+    });
+  });
+  it('should go to previous day when call previous', () => {
+    const dayPeriod = new DayPeriod();
+    const previousDate = new CalendarDate(2022, 4, 4);
+    const { current, count, startDate, endDate } = dayPeriod.previous();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 1,
+      current: previousDate,
+      startDate: previousDate,
+      endDate: previousDate,
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { CalendarDate } from '../../calendar-date';
+import { MonthPeriod } from '../../calendar-period/month-period';
+describe('month-period', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2020-04-03'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should new a month period as expected by default', () => {
+    const { current, count, startDate, endDate } = new MonthPeriod();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 42,
+      current: new CalendarDate(2020, 4, 1),
+      startDate: new CalendarDate(2020, 3, 29),
+      endDate: new CalendarDate(2020, 5, 9),
+    });
+  });
+  it('should go to date when call goTo method', () => {
+    const monthPeriod = new MonthPeriod();
+    const { current, count, startDate, endDate } = monthPeriod.goTo(new CalendarDate(2024, 2, 1));
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 42,
+      current: new CalendarDate(2024, 2, 1),
+      startDate: new CalendarDate(2024, 1, 28),
+      endDate: new CalendarDate(2024, 3, 9),
+    });
+  });
+  it('should go to now when call now method', () => {
+    const monthPeriod = new MonthPeriod();
+    const { current, count, startDate, endDate } = monthPeriod.now();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 42,
+      current: new CalendarDate(2020, 4, 1),
+      startDate: new CalendarDate(2020, 3, 29),
+      endDate: new CalendarDate(2020, 5, 9),
+    });
+  });
+  it('should go to next month when call next', () => {
+    const monthPeriod = new MonthPeriod();
+    const { current, count, startDate, endDate } = monthPeriod.next();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 42,
+      current: new CalendarDate(2020, 5, 1),
+      startDate: new CalendarDate(2020, 4, 26),
+      endDate: new CalendarDate(2020, 6, 6),
+    });
+  });
+  it('should go to previous month when call previous', () => {
+    const monthPeriod = new MonthPeriod();
+    const { current, count, startDate, endDate } = monthPeriod.previous();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 42,
+      current: new CalendarDate(2020, 3, 1),
+      startDate: new CalendarDate(2020, 3, 1),
+      endDate: new CalendarDate(2020, 4, 11),
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { WeekPeriod } from '../../calendar-period/week-period';
+import { CalendarDate } from '../../calendar-date';
+describe('week-period', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2020-04-03'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should new a week period as expected by default', () => {
+    const { current, count, startDate, endDate } = new WeekPeriod();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 7,
+      current: new CalendarDate(2020, 4, 3),
+      startDate: new CalendarDate(2020, 3, 29),
+      endDate: new CalendarDate(2020, 4, 4),
+    });
+  });
+  it('should go to date when call goTo method', () => {
+    const weekPeriod = new WeekPeriod();
+    const { current, count, startDate, endDate } = weekPeriod.goTo(new CalendarDate(2024, 2, 1));
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 7,
+      current: new CalendarDate(2024, 2, 1),
+      startDate: new CalendarDate(2024, 1, 28),
+      endDate: new CalendarDate(2024, 2, 3),
+    });
+  });
+  it('should go to now when call now method', () => {
+    const weekPeriod = new WeekPeriod();
+    const { current, count, startDate, endDate } = weekPeriod.now();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 7,
+      current: new CalendarDate(2020, 4, 3),
+      startDate: new CalendarDate(2020, 3, 29),
+      endDate: new CalendarDate(2020, 4, 4),
+    });
+  });
+  it('should go to next month when call next', () => {
+    const weekPeriod = new WeekPeriod();
+    const { current, count, startDate, endDate } = weekPeriod.next();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 7,
+      current: new CalendarDate(2020, 4, 5),
+      startDate: new CalendarDate(2020, 4, 5),
+      endDate: new CalendarDate(2020, 4, 11),
+    });
+  });
+  it('should go to previous month when call previous', () => {
+    const weekPeriod = new WeekPeriod();
+    const { current, count, startDate, endDate } = weekPeriod.previous();
+    expect({ current, count, startDate, endDate }).toEqual({
+      count: 7,
+      current: new CalendarDate(2020, 3, 22),
+      startDate: new CalendarDate(2020, 3, 22),
+      endDate: new CalendarDate(2020, 3, 28),
+    });
+  });
+});

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

@@ -0,0 +1,19 @@
+import { DayViewGenerator } from '../../calendar-view-generator/day-view-generator';
+import { DayPeriod } from '../../calendar-period/day-period';
+import { CalendarDate } from '../../calendar-date';
+describe('day-view-generator', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2022-04-05'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should generate a day view calendar', () => {
+    const generator = new DayViewGenerator();
+    expect(generator.generate(new DayPeriod())).toEqual({
+      _dateItems: [[new CalendarDate(2022, 4, 5)]],
+      _weekdays: ['Tue'],
+    });
+  });
+});

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

@@ -0,0 +1,73 @@
+import { MonthViewGenerator } from '../../calendar-view-generator/month-view-generator';
+import { MonthPeriod } from '../../calendar-period/month-period';
+describe('month-view-generator', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2022-04-05'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should generate a month view calendar', () => {
+    const generator = new MonthViewGenerator();
+    expect(generator.generate(new MonthPeriod())).toEqual({
+      _dateItems: [
+        [
+          { _date: 27, _month: 3, _year: 2022 },
+          { _date: 28, _month: 3, _year: 2022 },
+          { _date: 29, _month: 3, _year: 2022 },
+          { _date: 30, _month: 3, _year: 2022 },
+          { _date: 31, _month: 3, _year: 2022 },
+          { _date: 1, _month: 4, _year: 2022 },
+          { _date: 2, _month: 4, _year: 2022 },
+        ],
+        [
+          { _date: 3, _month: 4, _year: 2022 },
+          { _date: 4, _month: 4, _year: 2022 },
+          { _date: 5, _month: 4, _year: 2022 },
+          { _date: 6, _month: 4, _year: 2022 },
+          { _date: 7, _month: 4, _year: 2022 },
+          { _date: 8, _month: 4, _year: 2022 },
+          { _date: 9, _month: 4, _year: 2022 },
+        ],
+        [
+          { _date: 10, _month: 4, _year: 2022 },
+          { _date: 11, _month: 4, _year: 2022 },
+          { _date: 12, _month: 4, _year: 2022 },
+          { _date: 13, _month: 4, _year: 2022 },
+          { _date: 14, _month: 4, _year: 2022 },
+          { _date: 15, _month: 4, _year: 2022 },
+          { _date: 16, _month: 4, _year: 2022 },
+        ],
+        [
+          { _date: 17, _month: 4, _year: 2022 },
+          { _date: 18, _month: 4, _year: 2022 },
+          { _date: 19, _month: 4, _year: 2022 },
+          { _date: 20, _month: 4, _year: 2022 },
+          { _date: 21, _month: 4, _year: 2022 },
+          { _date: 22, _month: 4, _year: 2022 },
+          { _date: 23, _month: 4, _year: 2022 },
+        ],
+        [
+          { _date: 24, _month: 4, _year: 2022 },
+          { _date: 25, _month: 4, _year: 2022 },
+          { _date: 26, _month: 4, _year: 2022 },
+          { _date: 27, _month: 4, _year: 2022 },
+          { _date: 28, _month: 4, _year: 2022 },
+          { _date: 29, _month: 4, _year: 2022 },
+          { _date: 30, _month: 4, _year: 2022 },
+        ],
+        [
+          { _date: 1, _month: 5, _year: 2022 },
+          { _date: 2, _month: 5, _year: 2022 },
+          { _date: 3, _month: 5, _year: 2022 },
+          { _date: 4, _month: 5, _year: 2022 },
+          { _date: 5, _month: 5, _year: 2022 },
+          { _date: 6, _month: 5, _year: 2022 },
+          { _date: 7, _month: 5, _year: 2022 },
+        ],
+      ],
+      _weekdays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    });
+  });
+});

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

@@ -0,0 +1,28 @@
+import { WeekViewGenerator } from '../../calendar-view-generator/week-view-generator';
+import { WeekPeriod } from '../../calendar-period/week-period';
+describe('week-view-generator', () => {
+  beforeAll(() => {
+    jest.useFakeTimers('modern');
+    jest.setSystemTime(new Date('2022-04-05'));
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  it('should generate a week view calendar', () => {
+    const generator = new WeekViewGenerator();
+    expect(generator.generate(new WeekPeriod())).toEqual({
+      _dateItems: [
+        [
+          { _date: 3, _month: 4, _year: 2022 },
+          { _date: 4, _month: 4, _year: 2022 },
+          { _date: 5, _month: 4, _year: 2022 },
+          { _date: 6, _month: 4, _year: 2022 },
+          { _date: 7, _month: 4, _year: 2022 },
+          { _date: 8, _month: 4, _year: 2022 },
+          { _date: 9, _month: 4, _year: 2022 },
+        ],
+      ],
+      _weekdays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    });
+  });
+});

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

@@ -0,0 +1,9 @@
+import { CalendarView } from '../calendar-view';
+import { CalendarDate } from '../calendar-date';
+describe('calendar-view', () => {
+  it('should new a calendar view as expected', () => {
+    const calendarView = new CalendarView(['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], [[new CalendarDate(2024, 1, 2)]]);
+    expect(calendarView.weekdays).toEqual(['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']);
+    expect(calendarView.dateItems).toEqual([[new CalendarDate(2024, 1, 2)]]);
+  });
+});

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

@@ -0,0 +1,13 @@
+import { CalendarViewGenerator, DayViewGenerator, WeekViewGenerator, MonthViewGenerator, CalendarPeriod, DayPeriod, WeekPeriod, MonthPeriod, CalendarDate, CalendarView, } from '../index';
+it('should export as expected', () => {
+  expect(CalendarViewGenerator).toBeDefined();
+  expect(DayViewGenerator).toBeDefined();
+  expect(WeekViewGenerator).toBeDefined();
+  expect(MonthViewGenerator).toBeDefined();
+  expect(CalendarPeriod).toBeDefined();
+  expect(DayPeriod).toBeDefined();
+  expect(WeekPeriod).toBeDefined();
+  expect(MonthPeriod).toBeDefined();
+  expect(CalendarDate).toBeDefined();
+  expect(CalendarView).toBeDefined();
+});

package/dist/collection/helpers/calendar/test/utils.test.js

@@ -0,0 +1,9 @@
+import { getWeekdays } from '../utils';
+describe('utils', () => {
+  it('should return weekdays as expected by default', () => {
+    expect(getWeekdays()).toEqual([0, 1, 2, 3, 4, 5, 6]);
+  });
+  it('should return weekdays as expected when change the firstWeekDay', () => {
+    expect(getWeekdays(1)).toEqual([1, 2, 3, 4, 5, 6, 0]);
+  });
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Get a week days array
+ *
+ * @param {number} firstWeekDay - The first week day (0: Sunday, 1: Monday, ...)
+ * @returns {number[]} - The week days array
+ */
+export const getWeekdays = (firstWeekDay = 0) => {
+  const weekdays = [0, 1, 2, 3, 4, 5, 6];
+  return weekdays.concat(weekdays).slice(firstWeekDay, firstWeekDay + 7);
+};

package/dist/collection/helpers/event-manager/eventID/componentEventIdMap.js

@@ -1,4 +1,4 @@
-import { VegaExpand, VegaClick, VegaDropdownClick, VegaClose, VegaPageUpdate, VegaChange, VegaCreate, VegaSearch, VegaDropdownShow, VegaDropdownHide, VegaDropdownSearch, VegaFormSubmit, VegaFormReset, VegaValidate, VegaRemove, VegaCancel, VegaFocus, VegaBlur, VegaToggleStatus, VegaOpen, VegaStateUpdate, VegaGroupClick, VegaMenuClick, VegaActionClick, VegaPageSizeChange, VegaPopoverShow, VegaPopoverHide, VegaCurrentStepUpdate, VegaSelectChange, VegaSelectAllChange, VegaRowClick, } from './vegaEventId';
+import { VegaExpand, VegaClick, VegaDropdownClick, VegaClose, VegaChange, VegaEventClick, VegaPageUpdate, VegaCreate, VegaSearch, VegaDropdownShow, VegaDropdownHide, VegaDropdownSearch, VegaFormSubmit, VegaFormReset, VegaValidate, VegaRemove, VegaCancel, VegaFocus, VegaBlur, VegaToggleStatus, VegaOpen, VegaStateUpdate, VegaGroupClick, VegaMenuClick, VegaActionClick, VegaPageSizeChange, VegaPopoverShow, VegaPopoverHide, VegaCurrentStepUpdate, VegaSelectChange, VegaSelectAllChange, VegaRowClick, } from './vegaEventId';
 const entries = [
   ['vega-accordion', [VegaExpand]],
   ['vega-app-header-button', [VegaClick, VegaDropdownClick]],
@@ -8,6 +8,7 @@ const entries = [
   ['vega-button-circle', [VegaClick]],
   ['vega-button-group', [VegaClick]],
   ['vega-button-link', [VegaClick]],
+  ['vega-calendar', [VegaChange, VegaEventClick]],
   ['vega-carousel', [VegaPageUpdate]],
   ['vega-checkbox', [VegaChange]],
   ['vega-checkbox-group', [VegaChange]],

package/dist/collection/helpers/event-manager/eventID/vegaEventId.js

@@ -85,4 +85,6 @@ export const VegaDropdownShow = new VegaEventID('vegaShow', 'dropdownShow');
 export const VegaDropdownHide = new VegaEventID('vegaHide', 'dropdownHide');
 export const VegaDropdownSearch = new VegaEventID('vegaSearch', 'dropdownSearch');
 export const VegaActionClick = new VegaEventID('vegaActionClick', 'actionClick');
+export const VegaEventClick = new VegaEventID('vegaEventClick', 'eventClick');
+export const VegaDateClick = new VegaEventID('vegaDateClick', 'dateClick');
 export const HTMLNativeEventIds = [VegaChange, VegaClick, VegaFocus, VegaBlur];

package/dist/collection/helpers/event-manager/eventID/vegaInternalEventId.js

@@ -24,3 +24,4 @@ export const VegaInternalButtonGroupClick = new VegaInternalEventID('buttonGroup
 export const VegaInternalLeftNavLinkClick = new VegaInternalEventID('leftNavLinkClick');
 export const VegaInternalSubStatePull = new VegaInternalEventID('subStatePull');
 export const VegaInternalSubStatePush = new VegaInternalEventID('subStatePush');
+export const VegaInternalCalendarMonthEventsChange = new VegaInternalEventID('monthEventsChange');

package/dist/collection/helpers/formatter/responsive-map-formatter/responsiveWidthAndHeightFormatter.js

@@ -1,6 +1,6 @@
 import { isResponsiveType } from '../../../types/typeGuard';
 import { getCurrentBreakpoint, createCompleteResponsiveMap } from '../../../utils/breakpoints';
-import { Spacing } from '../../../../design_tokens/js/spacing.js';
+import { parseToPixelString } from '../../../utils/pixel';
 /**
  * A class for format WidthType and HeightType
  *
@@ -20,32 +20,10 @@ export class ResponsiveWidthAndHeightFormatter {
     const breakpoint = getCurrentBreakpoint();
     if (isResponsiveType(input)) {
       input = createCompleteResponsiveMap(input);
-      return this.formatWidthAndHeight(input[breakpoint]);
+      return parseToPixelString(input[breakpoint]);
     }
     else {
-      return this.formatWidthAndHeight(input);
-    }
-  }
-  /**
-   * The function `formatWidthAndHeight` takes an input of type `WidthType` or `HeightType` and returns a
-   * string representation with 'px' appended if the input is a number or a string that can be converted
-   * to a number, otherwise it returns the input as is.
-   *
-   * @param {WidthType | HeightType} input - The `input` parameter in the `formatWidthAndHeight` function
-   * can be either a `number`, a `string` that can be converted to a number, or a key from the `Spacing`
-   * object.
-   * @returns {string} The `formatWidthAndHeight` function takes an input of type `WidthType` or `HeightType` and
-   * returns a string.
-   */
-  formatWidthAndHeight(input) {
-    if (!isNaN(Number(input))) {
-      return `${input}px`;
-    }
-    else if (Object.keys(Spacing).includes(input)) {
-      return `${Spacing[input]}px`;
-    }
-    else {
-      return input;
+      return parseToPixelString(input);
     }
   }
 }

package/dist/collection/helpers/slimmers/mutation-observer/mutationObserverSlimmer.js

@@ -60,7 +60,10 @@ export class MutationObserverSlimmer extends VegaSlimmer {
    * MutationObserver.
    */
   observeMutationObserver() {
-    this.mutationObserver.observe(this.observerEntry.target ? this.observerEntry.target() : this.host, this.observerEntry.options);
+    const target = this.observerEntry.target ? this.observerEntry.target() : this.host;
+    if (target) {
+      this.mutationObserver.observe(target, this.observerEntry.options);
+    }
   }
 }
 __decorate([

package/dist/collection/helpers/slimmers/stringInputFormatterSlimmer.js

@@ -33,6 +33,7 @@ export class StringInputFormatterSlimmer extends VegaSlimmer {
      * @param {InputEvent} e - blur event
      */
     this.onBlur = (e) => {
+      this.blurFlag = false;
       if (this.blurFormatStrategy) {
         const target = e.target;
         const rawValue = target.value;
@@ -51,6 +52,7 @@ export class StringInputFormatterSlimmer extends VegaSlimmer {
      * @param {InputEvent} e - input event
      */
     this.onKeyDown = (e) => {
+      this.inputFlag = false;
       const target = e.target;
       const rawValue = target.value;
       const caretPosition = target.selectionStart; // selectionStart is nullable, link https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-textarea/input-selectionstart

package/dist/collection/helpers/vega-telemetry-helper/test/vegaEnvManager.test.js

@@ -4,7 +4,7 @@ test('should return the correct vega environment parameters', () => {
   const vegaEnv = VegaEnvManager.getVegaEnv();
   expect(vegaEnv).toEqual({
     framework: 'vanilla-js',
-    version: '2.13.1',
+    version: '2.15.0',
   });
 });
 test('should return the correct vega framework', () => {

package/dist/collection/helpers/vega-telemetry-helper/vegaEnvManager.js

@@ -9,9 +9,9 @@ export var FrameworkEnum;
 /** The VegaEnvManager class manages vega environment parameters. */
 class VegaEnvManager {
   constructor() {
-    // The `2.13.1` will be replaced to a version string when running publish script.
+    // The `2.15.0` will be replaced to a version string when running publish script.
     // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    this.vegaVersion = '2.13.1';
+    this.vegaVersion = '2.15.0';
     this.framework = FrameworkEnum.VanillaJs;
   }
   /**

package/dist/collection/utils/e2eUtils.js

@@ -310,5 +310,6 @@ export const injectE2EFontAwesomeLib = async (page) => {
   await page.addStyleTag({ path: './node_modules/@fortawesome/fontawesome-free/css/fontawesome.css' });
   await page.addStyleTag({ path: './node_modules/@fortawesome/fontawesome-free/css/solid.css' });
   await page.addStyleTag({ path: './src/test-assets/testFontawesomeSolidFontBase64.css' });
-  await page.waitForTimeout(300); // Note: Waiting for fontawesome.css loaded by addStyleTag
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await new Promise((r) => setTimeout(r, 300)); // Note: Waiting for fontawesome.css loaded by addStyleTag
 };

package/dist/collection/utils/pixel.js

@@ -1,3 +1,4 @@
+import { Spacing } from '../../design_tokens/js/spacing';
 /**
  * The function parses a string representing a pixel value to a number, or returns the input if it is already a number.
  *
@@ -25,3 +26,23 @@ export function parsePixelStringToNumber(input) {
 export function parseNumberToPixelString(input) {
   return typeof input === 'number' ? input + 'px' : input;
 }
+/**
+ * This function takes an input parameter and returns a string.
+ * - If the input is a number, it returns a string with 'px'.
+ * - If the input is a string, it returns the input string as is.
+ * - If the input is a {@link SpacingTokenType}, it returns a parsed value string with 'px'.
+ *
+ * @param {number | string | SpacingTokenType} input - The input parameter can be either a number or a string. If it is a
+ * @returns {string} returns a string that represents a CSS pixel value
+ */
+export function parseToPixelString(input) {
+  if (!isNaN(Number(input))) {
+    return `${input}px`;
+  }
+  else if (Object.keys(Spacing).includes(input)) {
+    return `${Spacing[input]}px`;
+  }
+  else {
+    return input;
+  }
+}