@globalpayments/vega 2.47.1 → 2.48.0

package/dist/collection/helpers/keyboard/keyboard-manager.js

@@ -1,4 +1,5 @@
 import { getDeepActiveElementInShadow, isParent } from '../../utils/ui';
+import { isNonNullable } from '../../types/type-guard';
 /**
  * It listens to the keyup event on the window and calls the appropriate method on the registered elements
  *
@@ -53,9 +54,8 @@ class KeyboardManager {
    * listener.
    */
   invokeListeners(eventName, event) {
-    const keyCode = event.code;
     this.listeners
-      .filter((listener) => listener.eventName === eventName && this.shouldInvokeListener(listener, keyCode))
+      .filter((listener) => listener.eventName === eventName && this.shouldInvokeListener(listener, event))
       .forEach((listener) => listener.callback(event));
   }
   /**
@@ -64,10 +64,11 @@ class KeyboardManager {
    *
    * @param {KeyboardEventListener} listener - KeyboardEventListener - the listener object that we're
    * checking
-   * @param {string} keyCode - The key code of the key that was pressed.
+   * @param {KeyboardEvent} event - The keyboard event that triggered the listener.
    * @returns {boolean} - should invoke
    */
-  shouldInvokeListener(listener, keyCode) {
+  shouldInvokeListener(listener, event) {
+    const keyCode = event.code;
     let activeElementInScope = [];
     let activeElementOutScope = [];
     const isKeyCodeAccepted = Array.isArray(listener.keyCode)
@@ -95,7 +96,26 @@ class KeyboardManager {
     const isActiveElementOutScope = listener.activeElementOutScope
       ? activeElementOutScope.every((element) => !isParent(getDeepActiveElementInShadow(), element))
       : true;
-    return isKeyCodeAccepted && isActiveElementInScope && isActiveElementOutScope;
+    const isExpectedModifierPressed = isNonNullable(listener.modifierPressed)
+      ? listener.modifierPressed === this.isModifierPressed(event)
+      : true;
+    const isExpectedShiftKeyPressed = isNonNullable(listener.shiftKey)
+      ? listener.shiftKey === event.shiftKey
+      : true;
+    return (isKeyCodeAccepted &&
+      isActiveElementInScope &&
+      isActiveElementOutScope &&
+      isExpectedModifierPressed &&
+      isExpectedShiftKeyPressed);
+  }
+  /**
+   * Checks if the platform modifier key (Meta on Mac, Ctrl on Windows) is pressed.
+   *
+   * @param {KeyboardEvent} e - The keyboard event to check.
+   * @returns {boolean} - True if the platform modifier key is pressed, false otherwise.
+   */
+  isModifierPressed(e) {
+    return /Mac|iPhone|iPad/.test(navigator.userAgent) ? e.metaKey : e.ctrlKey;
   }
 }
 export default new KeyboardManager();

package/dist/collection/helpers/keyboard/test/keyboard-manager.test.js

@@ -1,107 +1,206 @@
-const innerHTML = `
-<button class='button1'>test1</button>
-<button class='button2'>test2</button>
-<button class='button3'>test3</button>
-<div class='shadow'></div>
-`;
-document.body.innerHTML = innerHTML;
-const button1 = document.body.querySelector('.button1');
-const button2 = document.body.querySelector('.button2');
-const button3 = document.body.querySelector('.button3');
-const shadowComp = document.querySelector('.shadow');
-const shadowCompRoot = shadowComp.attachShadow({ mode: 'open' });
-const input = document.createElement('input');
-shadowCompRoot.appendChild(input);
-test('should proper while use KeyboardManager', () => {
-  /* eslint-disable-next-line */
-  const KeyboardManager = require('../keyboard-manager');
-  const callback1 = jest.fn();
-  const callback2 = jest.fn();
-  const callback3 = jest.fn();
-  KeyboardManager.default.register([
-    { keyCode: 'Tab', activeElementInScope: [button1], callback: callback1 },
-    { keyCode: ['ArrowUp', 'ArrowDown'], activeElementInScope: [button1], callback: callback2 },
-    { keyCode: 'Escape', activeElementInScope: [button1], callback: callback3 },
-  ]);
-  Object.assign(document, { activeElement: button1 });
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  expect(callback1).toBeCalledTimes(1);
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'ArrowUp' }));
-  expect(callback2).toBeCalledTimes(1);
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'ArrowDown' }));
-  expect(callback2).toBeCalledTimes(2);
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Escape' }));
-  expect(callback3).toBeCalledTimes(1);
-  const callback4 = jest.fn();
-  const callback5 = jest.fn();
-  const callback6 = jest.fn();
-  const listens = [
-    { keyCode: 'Tab', activeElementInScope: [button1], callback: callback4 },
-    { keyCode: 'Tab', activeElementInScope: [button2], callback: callback5 },
-    { keyCode: 'Tab', activeElementInScope: [button3], callback: callback6 },
-  ];
-  KeyboardManager.default.register(listens);
-  Object.assign(document, { activeElement: button2 });
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  expect(callback4).toBeCalledTimes(0);
-  expect(callback5).toBeCalledTimes(1);
-  expect(callback6).toBeCalledTimes(0);
-  const callback7 = jest.fn();
-  const callback8 = jest.fn();
-  const callback9 = jest.fn();
-  const callback10 = jest.fn();
-  KeyboardManager.default.register([
-    { keyCode: 'Tab', activeElementInScope: [button2], callback: callback7 },
-    { keyCode: 'Tab', activeElementOutScope: [button2], callback: callback8 },
-    { keyCode: 'Tab', activeElementOutScope: [button3], callback: callback9 },
-    {
-      keyCode: 'Tab',
-      activeElementOutScope: [button3],
-      callback: callback10,
-      eventName: 'keydown',
-    },
-  ]);
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  document.dispatchEvent(new KeyboardEvent('keydown', { code: 'Tab' }));
-  expect(callback4).toBeCalledTimes(0);
-  expect(callback5).toBeCalledTimes(2);
-  expect(callback6).toBeCalledTimes(0);
-  expect(callback7).toBeCalledTimes(1);
-  expect(callback8).toBeCalledTimes(0);
-  expect(callback9).toBeCalledTimes(1);
-  expect(callback10).toBeCalledTimes(1);
-  KeyboardManager.default.deregister(listens);
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  expect(callback4).toBeCalledTimes(0);
-  expect(callback5).toBeCalledTimes(2);
-  expect(callback6).toBeCalledTimes(0);
-  const callback11 = jest.fn();
-  const callback12 = jest.fn();
-  KeyboardManager.default.register([
-    { keyCode: 'Tab', activeElementInScope: [shadowCompRoot], callback: callback11 },
-    { keyCode: 'Tab', activeElementOutScope: [shadowCompRoot], callback: callback12 },
-  ]);
-  Object.assign(document, { activeElement: shadowCompRoot });
-  Object.assign(shadowCompRoot, { shadowRoot: { activeElement: input } });
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  expect(callback11).toBeCalledTimes(1);
-  expect(callback12).toBeCalledTimes(0);
-});
-test('while keyup, the callback should not effect next callback ', () => {
-  /* eslint-disable-next-line */
-  const KeyboardManager = require('../keyboard-manager');
-  const callback1 = () => {
+import KeyboardManager from '../keyboard-manager';
+import { setupUserAgent } from '../../../utils/test-utils';
+describe('KeyboardManager', () => {
+  let button1;
+  let button2;
+  let button3;
+  let shadowComp;
+  let shadowCompRoot;
+  let input;
+  beforeAll(() => {
+    const innerHTML = `
+			<button class='button1'>test1</button>
+			<button class='button2'>test2</button>
+			<button class='button3'>test3</button>
+			<div class='shadow'></div>
+		`;
+    document.body.innerHTML = innerHTML;
+    button1 = document.body.querySelector('.button1');
+    button2 = document.body.querySelector('.button2');
+    button3 = document.body.querySelector('.button3');
+    shadowComp = document.querySelector('.shadow');
+    shadowCompRoot = shadowComp.attachShadow({ mode: 'open' });
+    input = document.createElement('input');
+    shadowCompRoot.appendChild(input);
+  });
+  beforeEach(() => {
+    setupUserAgent('desktop');
+    KeyboardManager['listenKeyPress']();
+  });
+  test('should proper while use KeyboardManager', () => {
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    const callback3 = jest.fn();
+    KeyboardManager.register([
+      { keyCode: 'Tab', activeElementInScope: [button1], callback: callback1 },
+      { keyCode: ['ArrowUp', 'ArrowDown'], activeElementInScope: [button1], callback: callback2 },
+      { keyCode: 'Escape', activeElementInScope: [button1], callback: callback3 },
+    ]);
+    Object.assign(document, { activeElement: button1 });
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
+    expect(callback1).toBeCalledTimes(1);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'ArrowUp' }));
+    expect(callback2).toBeCalledTimes(1);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'ArrowDown' }));
+    expect(callback2).toBeCalledTimes(2);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Escape' }));
+    expect(callback3).toBeCalledTimes(1);
+    const callback4 = jest.fn();
+    const callback5 = jest.fn();
+    const callback6 = jest.fn();
+    const listens = [
+      { keyCode: 'Tab', activeElementInScope: [button1], callback: callback4 },
+      { keyCode: 'Tab', activeElementInScope: [button2], callback: callback5 },
+      { keyCode: 'Tab', activeElementInScope: [button3], callback: callback6 },
+    ];
+    KeyboardManager.register(listens);
     Object.assign(document, { activeElement: button2 });
-  };
-  const callback2 = jest.fn();
-  KeyboardManager.default.register([
-    { keyCode: 'Tab', activeElementInScope: [button1], callback: callback1 },
-  ]);
-  KeyboardManager.default.register([
-    { keyCode: 'Tab', activeElementInScope: [button2], callback: callback2 },
-  ]);
-  Object.assign(document, { activeElement: button1 });
-  document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
-  expect(callback2).toBeCalledTimes(0);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
+    expect(callback4).toBeCalledTimes(0);
+    expect(callback5).toBeCalledTimes(1);
+    expect(callback6).toBeCalledTimes(0);
+    const callback7 = jest.fn();
+    const callback8 = jest.fn();
+    const callback9 = jest.fn();
+    const callback10 = jest.fn();
+    KeyboardManager.register([
+      { keyCode: 'Tab', activeElementInScope: [button2], callback: callback7 },
+      { keyCode: 'Tab', activeElementOutScope: [button2], callback: callback8 },
+      { keyCode: 'Tab', activeElementOutScope: [button3], callback: callback9 },
+      {
+        keyCode: 'Tab',
+        activeElementOutScope: [button3],
+        callback: callback10,
+        eventName: 'keydown',
+      },
+    ]);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'Tab' }));
+    expect(callback4).toBeCalledTimes(0);
+    expect(callback5).toBeCalledTimes(2);
+    expect(callback6).toBeCalledTimes(0);
+    expect(callback7).toBeCalledTimes(1);
+    expect(callback8).toBeCalledTimes(0);
+    expect(callback9).toBeCalledTimes(1);
+    expect(callback10).toBeCalledTimes(1);
+    KeyboardManager.deregister(listens);
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
+    expect(callback4).toBeCalledTimes(0);
+    expect(callback5).toBeCalledTimes(2);
+    expect(callback6).toBeCalledTimes(0);
+    const callback11 = jest.fn();
+    const callback12 = jest.fn();
+    KeyboardManager.register([
+      { keyCode: 'Tab', activeElementInScope: [shadowComp], callback: callback11 },
+      { keyCode: 'Tab', activeElementOutScope: [shadowComp], callback: callback12 },
+    ]);
+    Object.assign(document, { activeElement: shadowComp });
+    Object.assign(shadowComp, { shadowRoot: { activeElement: input } });
+    document.dispatchEvent(new KeyboardEvent('keyup', { code: 'Tab' }));
+    expect(callback11).toBeCalledTimes(1);
+    expect(callback12).toBeCalledTimes(0);
+  });
+  test('should handle modifierPressed correctly', () => {
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    const callback3 = jest.fn();
+    KeyboardManager.register([
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback1,
+        modifierPressed: true,
+      },
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback2,
+        modifierPressed: false,
+      },
+      { keyCode: 'KeyZ', eventName: 'keydown', activeElementInScope: [button1], callback: callback3 },
+    ]);
+    Object.assign(document, { activeElement: button1 });
+    // Test with modifier keys pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', metaKey: true }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(0);
+    expect(callback3).toBeCalledTimes(1);
+    // Test with no modifier keys pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', metaKey: false }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(1);
+    expect(callback3).toBeCalledTimes(2);
+  });
+  test('should handle modifierPressed correctly on Windows', () => {
+    Object.defineProperty(window.navigator, 'userAgent', {
+      value: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36',
+      configurable: true,
+    });
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    const callback3 = jest.fn();
+    KeyboardManager.register([
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback1,
+        modifierPressed: true,
+      },
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback2,
+        modifierPressed: false,
+      },
+      { keyCode: 'KeyZ', eventName: 'keydown', activeElementInScope: [button1], callback: callback3 },
+    ]);
+    Object.assign(document, { activeElement: button1 });
+    // Test with modifier keys pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', ctrlKey: true }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(0);
+    expect(callback3).toBeCalledTimes(1);
+    // Test with no modifier keys pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', ctrlKey: false }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(1);
+    expect(callback3).toBeCalledTimes(2);
+  });
+  test('should handle shiftKey correctly', () => {
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+    const callback3 = jest.fn();
+    KeyboardManager.register([
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback1,
+        shiftKey: true,
+      },
+      {
+        keyCode: 'KeyZ',
+        eventName: 'keydown',
+        activeElementInScope: [button1],
+        callback: callback2,
+        shiftKey: false,
+      },
+      { keyCode: 'KeyZ', eventName: 'keydown', activeElementInScope: [button1], callback: callback3 },
+    ]);
+    Object.assign(document, { activeElement: button1 });
+    // Test with shift key pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', shiftKey: true }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(0);
+    expect(callback3).toBeCalledTimes(1);
+    // Test with no shift key pressed
+    document.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyZ', shiftKey: false }));
+    expect(callback1).toBeCalledTimes(1);
+    expect(callback2).toBeCalledTimes(1);
+    expect(callback3).toBeCalledTimes(2);
+  });
 });
-export {};

package/dist/collection/helpers/validator/rules/max-number-rule.js

@@ -29,7 +29,7 @@ export class MaxNumberRule extends InternalFormFieldValidationRule {
     if (!this.isAcceptedInputType(input)) {
       throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
     }
-    const maxValue = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxValue) || Number.MAX_VALUE;
+    const maxValue = !isNaN((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxValue) ? this.config.maxValue : Number.MAX_VALUE;
     return {
       isValid: convertToNumber(input) <= maxValue,
       message: convertToNumber(input) <= maxValue

package/dist/collection/helpers/validator/rules/min-number-rule.js

@@ -29,7 +29,7 @@ export class MinNumberRule extends InternalFormFieldValidationRule {
     if (!this.isAcceptedInputType(input)) {
       throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
     }
-    const minValue = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.minValue) || 0;
+    const minValue = !isNaN((_a = this.config) === null || _a === void 0 ? void 0 : _a.minValue) ? this.config.minValue : 0;
     return {
       isValid: convertToNumber(input) >= minValue,
       message: convertToNumber(input) >= minValue

package/dist/collection/helpers/validator/test/rules/max-number-rule.test.js

@@ -45,7 +45,7 @@ test('return evaluate result as expect if input type is number and value less th
   });
 });
 test('return evaluate result as expect if input max value less than default MAX_VALUE', () => {
-  const rule = new MaxNumberRule({ maxValue: null });
+  const rule = new MaxNumberRule({ maxValue: NaN });
   const stringInput = rule.evaluate(1.79e308);
   expect(stringInput).toEqual({
     isValid: true,
@@ -53,7 +53,7 @@ test('return evaluate result as expect if input max value less than default MAX_
   });
 });
 test('return evaluate result as expect if input max value greater than default MAX_VALUE', () => {
-  const rule = new MaxNumberRule({ maxValue: null });
+  const rule = new MaxNumberRule({ maxValue: NaN });
   const stringInput = rule.evaluate(1.79e309);
   expect(stringInput).toEqual({
     isValid: false,

package/dist/collection/helpers/validator/test/rules/min-number-rule.test.js

@@ -45,7 +45,7 @@ test('return evaluate result as expect if input type is number and value less th
   });
 });
 test('return evaluate result as expect if input max value less than default MIN_VALUE', () => {
-  const rule = new MinNumberRule({ minValue: null });
+  const rule = new MinNumberRule({ minValue: NaN });
   const stringInput = rule.evaluate(-1);
   expect(stringInput).toEqual({
     isValid: false,
@@ -53,7 +53,7 @@ test('return evaluate result as expect if input max value less than default MIN_
   });
 });
 test('return evaluate result as expect if input max value greater than default MIN_VALUE', () => {
-  const rule = new MinNumberRule({ minValue: null });
+  const rule = new MinNumberRule({ minValue: NaN });
   const stringInput = rule.evaluate(0);
   expect(stringInput).toEqual({
     isValid: true,

package/dist/esm/{app-globals-53b6125a.js → app-globals-1bb57f5e.js}

@@ -6,10 +6,10 @@ import { V as VegaIconManager } from './icon-manager-638dd4d4.js';
 import './wait-for-vega-handler-b18eb955.js';
 import './ui-ed1283bb.js';
 import { V as VegaInternalTranslation, a as VegaTranslation, s as staticTranslations } from './translation-cf7f020a.js';
-import { V as VegaRTEContent } from './content-state-7437e069.js';
+import { V as VegaRTEContent } from './content-state-6dba6625.js';
 import { T as TypographyUrls } from './typography-396de03f.js';
 import { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-cc497bec.js';
-import { w as waitForVega } from './index-96374234.js';
+import { w as waitForVega } from './index-4aa167d6.js';
 import { U as UPDATE_TRANSLATION } from './static-subject-title-ca83d6b6.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { O as Observer } from './observer-3959f9dd.js';
@@ -312,7 +312,7 @@ function injectVegaRichTextEditorClassIntoGlobal() {
  * Inject VegaPublicValidationRules to global as a public api
  */
 function injectVegaPublicValidationRules() {
-  void import('./public-rules-cfc196c9.js').then((module) => {
+  void import('./public-rules-f9aaa527.js').then((module) => {
     Object.entries(module).forEach(([name, value]) => {
       globalThis[name] = value;
     });