@globalpayments/vega 2.13.1 → 2.14.0

package/dist/collection/components/vega-calendar/vega-calendar.js

@@ -0,0 +1,345 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, h, Element, Host, State, Prop, Watch, Event } from '@stencil/core';
+import { sanitizeVegaComponent } from '../../utils/component';
+import { InjectVegaGlobalSlimmer, InjectVegaSlimmer, methodPlaceholder, } from 'vega-slimmer/core';
+import { VegaCalendarRenderer } from './slimmers/common/renderers/vega-calendar-renderer';
+import { VegaCalendarSwitchPanelRenderer } from './slimmers/common/renderers/vega-calendar-switch-panel';
+import { VegaCalendarViewRenderer } from './slimmers/common/renderers/vega-calendar-view-renderer';
+import { VegaCalendarMonthViewRenderer } from './slimmers/month-view/renderers/vega-calendar-month-view-renderer';
+import { VegaCalendarViewWithTimeRenderer } from './slimmers/day-view/renderers/vega-calendar-view-with-time-renderer';
+import { VegaCalendarTimeLineRenderer } from './slimmers/day-view/renderers/vega-calendar-time-line-renderer';
+import { createEventEmitSlimmer, } from '../../helpers/event-manager/slimmers/eventEmitSlimmer';
+import { VegaChange, VegaEventClick } from '../../helpers/event-manager/eventID/vegaEventId';
+import { VegaCalendarViewController } from './slimmers/common/controllers/vega-calendar-view-controller';
+import { VegaCalendarCurrentPeriodController } from './slimmers/common/controllers/vega-calendar-current-period-controller';
+import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/childNodesEventPreventSlimmer';
+import { VegaCalendarMonthEventRenderer } from './slimmers/month-view/renderers/vega-calendar-month-event-renderer';
+import { VegaCalendarEventController } from './slimmers/common/controllers/vega-calendar-event-controller';
+import { VegaCalendarEventResponsiveController } from './slimmers/common/controllers/vega-calendar-event-responsive-controller';
+import { VegaCalendarFullDayEventRenderer } from './slimmers/day-view/renderers/full-day-event/vega-calendar-full-day-event-renderer';
+import { VegaCalendarEventItemRenderer } from './slimmers/common/renderers/vega-calendar-event-item-renderer';
+import { VegaCalendarDayViewEventLayoutRenderer } from './slimmers/day-view/renderers/timed-event/vega-calendar-day-event-layout-renderer';
+import { VegaCalendarTimedEventRenderer } from './slimmers/day-view/renderers/timed-event/vega-calendar-timed-event-renderer';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/componentUsageRuntimeMetrics';
+import { VegaCalendarFullDayEventLayoutRenderer } from './slimmers/common/renderers/vega-calendar-full-day-event-layout-renderer';
+import { createSubStateNotifySlimmer } from '../../helpers/slimmers/sub-state/subStateNotifySlimmer';
+export class VegaCalendar {
+  constructor() {
+    this.globalSlimmer = {};
+    this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
+    this.renderer = new VegaCalendarRenderer();
+    this.switchPanelRenderer = new VegaCalendarSwitchPanelRenderer();
+    this.viewRenderer = new VegaCalendarViewRenderer();
+    this.monthViewRenderer = new VegaCalendarMonthViewRenderer();
+    this.viewWithTimeRenderer = new VegaCalendarViewWithTimeRenderer();
+    this.timeLineRenderer = new VegaCalendarTimeLineRenderer();
+    this.monthEventRenderer = new VegaCalendarMonthEventRenderer();
+    //The  current period controller  should be before the calendar view controller because the initial current period should be before the initial calendar view
+    this.currentPeriodController = new VegaCalendarCurrentPeriodController();
+    this.calendarViewController = new VegaCalendarViewController();
+    this.dayViewFullDayEventRenderer = new VegaCalendarFullDayEventRenderer();
+    this.dayViewTimedEventRenderer = new VegaCalendarTimedEventRenderer();
+    this.eventItemRenderer = new VegaCalendarEventItemRenderer();
+    this.dayViewEventLayoutRenderer = new VegaCalendarDayViewEventLayoutRenderer();
+    this.fullDayEventLayoutRenderer = new VegaCalendarFullDayEventLayoutRenderer();
+    this.calendarEventController = new VegaCalendarEventController();
+    this.eventResponsiveController = new VegaCalendarEventResponsiveController();
+    this.changeEventEmitter = createEventEmitSlimmer(VegaCalendar, VegaChange);
+    this.eventClickEmitter = createEventEmitSlimmer(VegaCalendar, VegaEventClick);
+    this.changeEventPrevent = new ChildNodesEventPreventSlimmer([VegaChange], () => this.switchPanelRenderer.getSwitchPanelRef());
+    this.timeFormatNotifySlimmer = createSubStateNotifySlimmer(VegaCalendar, 'timeFormat', 'watchTimeFormat');
+    this.calendarEvents = [];
+    /**
+     * Specifies the current view mode of the calendar.
+     */
+    /* eslint-disable @stencil/strict-mutable */
+    this.viewMode = 'month';
+    /**
+     * Specifies the time format of the calendar.
+     */
+    this.timeFormat = '24-hour';
+  }
+  /**
+   * watch the state calendar current period change
+   */
+  watchCurrentPeriodChange() {
+    methodPlaceholder();
+  }
+  /**
+   * Watch the view mode change
+   *
+   * @param {VegaCalendarViewModeType} newValue the new value of view mode
+   */
+  watchViewModeChange(newValue) {
+    methodPlaceholder(newValue);
+  }
+  /**
+   * Watch the calendar events change
+   *
+   * @param {VegaCalendarRawEvent[]} newValue
+   */
+  watchEventsChange(newValue) {
+    methodPlaceholder(newValue);
+  }
+  /**
+   * Watches changes in the calendar's time format.
+   *
+   * @param {TimeFormat} newValue
+   */
+  watchTimeFormat(newValue) {
+    methodPlaceholder(newValue);
+  }
+  render() {
+    return sanitizeVegaComponent(h(Host, null, this.renderer.render()), this.host);
+  }
+  static get is() { return "vega-calendar"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["vega-calendar.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["vega-calendar.css"]
+  }; }
+  static get properties() { return {
+    "viewMode": {
+      "type": "string",
+      "mutable": true,
+      "complexType": {
+        "original": "VegaCalendarViewModeType",
+        "resolved": "\"day\" | \"month\" | \"week\"",
+        "references": {
+          "VegaCalendarViewModeType": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Specifies the current view mode of the calendar."
+      },
+      "attribute": "view-mode",
+      "reflect": false,
+      "defaultValue": "'month'"
+    },
+    "events": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "VegaCalendarRawEvent[]",
+        "resolved": "VegaCalendarRawEvent[]",
+        "references": {
+          "VegaCalendarRawEvent": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Specifies the events of the calendar."
+      }
+    },
+    "timeFormat": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "TimeFormat",
+        "resolved": "\"12-hour\" | \"24-hour\"",
+        "references": {
+          "TimeFormat": {
+            "location": "import",
+            "path": "../../types/general"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Specifies the time format of the calendar."
+      },
+      "attribute": "time-format",
+      "reflect": false,
+      "defaultValue": "'24-hour'"
+    }
+  }; }
+  static get states() { return {
+    "calendarView": {},
+    "currentPeriod": {},
+    "calendarEvents": {}
+  }; }
+  static get events() { return [{
+      "method": "vegaChange",
+      "name": "vegaChange",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "An event emitter notifying the component view content change after a switch panel click."
+      },
+      "complexType": {
+        "original": "VegaCalendarChangeEventType",
+        "resolved": "{ currentPeriod: { year: number; month: number; startDate: VegaCalendarDateType; endDate: VegaCalendarDateType; }; viewMode: VegaCalendarViewModeType; }",
+        "references": {
+          "VegaCalendarChangeEventType": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      }
+    }, {
+      "method": "change",
+      "name": "change",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "eventSemantics",
+            "text": "namespace:native"
+          }],
+        "text": "An event emitter notifying the component view content change after a switch panel click."
+      },
+      "complexType": {
+        "original": "VegaCalendarChangeEventType",
+        "resolved": "{ currentPeriod: { year: number; month: number; startDate: VegaCalendarDateType; endDate: VegaCalendarDateType; }; viewMode: VegaCalendarViewModeType; }",
+        "references": {
+          "VegaCalendarChangeEventType": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      }
+    }, {
+      "method": "vegaEventClick",
+      "name": "vegaEventClick",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "An event emitter notifying that a component event item is clicked."
+      },
+      "complexType": {
+        "original": "VegaCalendarEventClickInfo",
+        "resolved": "{ rawEvent: VegaCalendarRawEvent; }",
+        "references": {
+          "VegaCalendarEventClickInfo": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      }
+    }, {
+      "method": "eventClick",
+      "name": "eventClick",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "An event emitter notifying that a component event item is clicked."
+      },
+      "complexType": {
+        "original": "VegaCalendarEventClickInfo",
+        "resolved": "{ rawEvent: VegaCalendarRawEvent; }",
+        "references": {
+          "VegaCalendarEventClickInfo": {
+            "location": "import",
+            "path": "./types"
+          }
+        }
+      }
+    }]; }
+  static get elementRef() { return "host"; }
+  static get watchers() { return [{
+      "propName": "currentPeriod",
+      "methodName": "watchCurrentPeriodChange"
+    }, {
+      "propName": "viewMode",
+      "methodName": "watchViewModeChange"
+    }, {
+      "propName": "events",
+      "methodName": "watchEventsChange"
+    }, {
+      "propName": "timeFormat",
+      "methodName": "watchTimeFormat"
+    }]; }
+}
+__decorate([
+  InjectVegaGlobalSlimmer()
+], VegaCalendar.prototype, "globalSlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "renderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "switchPanelRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "viewRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "monthViewRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "viewWithTimeRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "timeLineRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "monthEventRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "currentPeriodController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "calendarViewController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "dayViewFullDayEventRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "dayViewTimedEventRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "eventItemRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "dayViewEventLayoutRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "fullDayEventLayoutRenderer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "calendarEventController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "eventResponsiveController", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "changeEventEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "eventClickEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "changeEventPrevent", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaCalendar.prototype, "timeFormatNotifySlimmer", void 0);

package/dist/collection/components/vega-table/vega-table-row/slimmers/controllers/vega-table-row-click-controller.js

@@ -38,11 +38,13 @@ export class VegaTableRowClickController extends VegaSlimmer {
   initRowClickObserver() {
     this.rowClickObserver = new Observer(isAcceptableTableRowObserver.bind(this), (payload) => {
       this.clicked = payload.host === this.host;
-      if (this.selectionType === 'single' && payload.host === this.host) {
-        this.vegaTableRowSelectionController.setChecked(!this.checked);
-      }
-      else {
-        this.vegaTableRowSelectionController.setChecked(false);
+      if (this.selectionType === 'single') {
+        if (payload.host === this.host) {
+          this.vegaTableRowSelectionController.setChecked(!this.checked);
+        }
+        else {
+          this.vegaTableRowSelectionController.setChecked(false);
+        }
       }
     });
     ChangeManager.register(TABLE_ROW_CLICK, this.rowClickObserver);

package/dist/collection/constants/ui.js

@@ -67,6 +67,8 @@ export const VegaNativeEventName = [
   'dropdownHide',
   'dropdownSearch',
   'actionClick',
+  'eventClick',
+  'dateClick',
 ];
 // eslint-disable-next-line @typescript-eslint/typedef
 export const CssStates = ['default', 'hover', 'active', 'focus-visible'];

package/dist/collection/global/icons/chevron-left.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M9.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l192 192c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L77.3 256 246.6 86.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-192 192z"/></svg>`,
+};

package/dist/collection/global/icons/chevron-right.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M310.6 233.4c12.5 12.5 12.5 32.8 0 45.3l-192 192c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L242.7 256 73.4 86.6c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l192 192z"/></svg>`,
+};

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

@@ -0,0 +1,103 @@
+/**
+ * Calendar date class
+ */
+export 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} date - The Date object
+   * @returns {CalendarDate} - Return a CalendarDate object
+   */
+  static from(date) {
+    return new CalendarDate(date.getFullYear(), date.getMonth() + 1, date.getDate());
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Verify whether the calendar date is today
+   *
+   * @returns {boolean} - Return true if the calendar date is today. Otherwise, return false.
+   */
+  isToday() {
+    const today = new Date();
+    return (today.getFullYear() === this.year &&
+      today.getMonth() + 1 === this.month &&
+      today.getDate() === 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;
+  }
+}