@globalpayments/vega 2.13.1 → 2.14.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/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.14.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.14.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.14.0';
     this.framework = FrameworkEnum.VanillaJs;
   }
   /**

package/dist/esm/{app-globals-f49e68bc.js → app-globals-cf903368.js}

@@ -1,8 +1,8 @@
-import { F as FeatureFlag } from './featureFlagController-9df5a1a3.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, v as vegaEnvManager, w as waitForVega } from './index-41dc8dc1.js';
+import { F as FeatureFlag } from './featureFlagController-816491ad.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, v as vegaEnvManager, w as waitForVega } from './index-dd06e5e7.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-16fd7452.js';
 import { V as VegaDialog } from './vegaDialogController-f96ee430.js';
-import './internalVegaEventManager-501f9eb9.js';
+import './internalVegaEventManager-e1501923.js';
 import './ui-28499aab.js';
 import { T as TypographyUrls } from './typography-a8fc4764.js';
 import { V as VegaIconManager } from './iconManager-48bebc43.js';
@@ -244,7 +244,7 @@ function injectValidCreditCardNumberRuleIntoGlobal() {
 function initRuntimeMetricsTelemetryCollection() {
   globalThis.VegaEnvInfo = vegaEnvManager.getVegaEnv();
   // eslint-disable-next-line spellcheck/spell-checker
-  void import('./index-27e4eb43.js').then((
+  void import('./index-4126a006.js').then((
   // eslint-disable-next-line spellcheck/spell-checker
   module) => {
     module['default']['init'](FeatureFlag);

package/dist/esm/{childNodesEventPreventSlimmer-86a1593c.js → childNodesEventPreventSlimmer-ca73e6c1.js}

@@ -1,5 +1,5 @@
 import { a as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-16fd7452.js';
-import { I as InternalVegaEventManager, j as jqueryDelegatedStrategyController } from './internalVegaEventManager-501f9eb9.js';
+import { I as InternalVegaEventManager, j as jqueryDelegatedStrategyController } from './internalVegaEventManager-e1501923.js';
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;

package/dist/esm/{componentUsageRuntimeMetrics-9f888049.js → componentUsageRuntimeMetrics-4f08dec8.js}

@@ -70,7 +70,7 @@ class VegaComponentUsageRuntimeMetricsSlimmer extends VegaSlimmer {
    */
   sendUsagePayloadToTelemetry() {
     // eslint-disable-next-line spellcheck/spell-checker
-    void import('./index-27e4eb43.js').then((
+    void import('./index-4126a006.js').then((
     // eslint-disable-next-line spellcheck/spell-checker
     module) => {
       try {