@globalpayments/vega 2.32.0 → 2.34.0

package/dist/collection/helpers/slimmers/test/dark-mode-state-controller.test.js

@@ -0,0 +1,65 @@
+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 '../../../polyfill/test-polyfill/unit/index';
+import { InjectVegaSlimmer, MapToComponentField } from 'vega-slimmer/core';
+import { DarkModeStateControllerSlimmer } from '../dark-mode-state-controller-slimmer';
+import { MockHTMLElement } from '@stencil/core/mock-doc';
+import { VegaThemeManager } from '../../public-api';
+describe('DarkModeStateControllerSlimmer', () => {
+  const mockedComponentConnectedCallbackMethod = jest.fn();
+  const mockedComponentDisconnectedCallbackMethod = jest.fn();
+  beforeEach(() => {
+    mockedComponentDisconnectedCallbackMethod.mockClear();
+    mockedComponentConnectedCallbackMethod.mockClear();
+  });
+  describe('DarkModeStateControllerSlimmer should work proper', () => {
+    class MockedDarkModeStateController extends DarkModeStateControllerSlimmer {
+      constructor() {
+        super();
+      }
+    }
+    __decorate([
+      MapToComponentField({ writable: true })
+    ], MockedDarkModeStateController.prototype, "isInDarkMode", void 0);
+    __decorate([
+      MapToComponentField()
+    ], MockedDarkModeStateController.prototype, "host", void 0);
+    class MockedComponent {
+      constructor() {
+        this.isInDarkMode = false;
+        this.controller = new MockedDarkModeStateController();
+      }
+      connectedCallback() {
+        mockedComponentConnectedCallbackMethod();
+      }
+      disconnectedCallback() {
+        mockedComponentDisconnectedCallbackMethod();
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockedComponent.prototype, "controller", void 0);
+    test('should set isInDarkMode proper to true', () => {
+      const mockedComponent = new MockedComponent();
+      const host = new MockHTMLElement('body', 'div');
+      mockedComponent.host = host;
+      mockedComponent.connectedCallback();
+      expect(mockedComponentConnectedCallbackMethod).toBeCalledTimes(1);
+      VegaThemeManager.toggleDarkMode(true);
+      expect(mockedComponent.isInDarkMode).toEqual(true);
+    });
+    test('should set isInDarkMode proper to false', () => {
+      const mockedComponent = new MockedComponent();
+      const host = new MockHTMLElement('body', 'div');
+      mockedComponent.host = host;
+      mockedComponent.disconnectedCallback();
+      expect(mockedComponentDisconnectedCallbackMethod).toBeCalledTimes(1);
+      VegaThemeManager.toggleDarkMode(false);
+      expect(mockedComponent.isInDarkMode).toEqual(false);
+    });
+  });
+});

package/dist/collection/helpers/theme/controllers/dark-mode-style-controller.js

@@ -2,6 +2,9 @@ import { DarkModeColorTokens } from '../../../constants/tokens/themes/dark-mode-
 import { DarkModeBorderTokens } from '../../../constants/tokens/themes/dark-mode-border-tokens';
 import { DarkModeShadowTokens } from '../../../constants/tokens/themes/dark-mode-shadow-tokens';
 import { DarkModeRingTokens } from '../../../constants/tokens/themes/dark-mode-ring-tokens';
+import { DARK_MODE_CHANGE } from '../../change-manager/subject/static-subject/static-subject-title';
+import ChangeManager from '../../change-manager/change-manager';
+import { Observer } from '../../change-manager/observer/observer';
 // TODO: Remove this after the token add in vega design.
 const CustomDarkModeColorTokens = {
   'bg-backdrop-loading': '0, 0, 0, 0.5',
@@ -16,15 +19,37 @@ const CustomDarkModeColorTokens = {
  * Vega components dark mode style controller
  */
 class DarkModeStyleController {
+  constructor() {
+    this.dynamicCustomDarkModeColor = {};
+    this.darkModeColorAllTokens = {};
+    this.observer = new Observer(this.isAcceptObserver.bind(this), (isDark) => {
+      if (isDark) {
+        this.generateDarkModeStyle();
+      }
+      else {
+        this.removeDarkModeStyleContainer();
+      }
+    });
+    ChangeManager.register(DARK_MODE_CHANGE, this.observer);
+  }
+  /**
+   * This method dynamically registers a custom dark color.
+   *
+   * @param {Record<string, string>} customDarkModeColor - custom dark mode color
+   */
+  registerCustomDarkModeColor(customDarkModeColor) {
+    this.dynamicCustomDarkModeColor = Object.assign(Object.assign({}, this.dynamicCustomDarkModeColor), customDarkModeColor);
+    this.generateDarkModeStyle();
+  }
   /**
    * It generates a CSS style for dark mode to override the style.
    */
   generateDarkModeStyle() {
-    const tokens = Object.assign(DarkModeColorTokens, DarkModeBorderTokens, DarkModeRingTokens, DarkModeShadowTokens, CustomDarkModeColorTokens);
-    const keys = Object.keys(tokens);
+    this.darkModeColorAllTokens = Object.assign(DarkModeColorTokens, DarkModeBorderTokens, DarkModeRingTokens, DarkModeShadowTokens, CustomDarkModeColorTokens, this.dynamicCustomDarkModeColor);
+    const keys = Object.keys(this.darkModeColorAllTokens);
     this.getDarkModeStyleContainer().innerHTML = `
 html.dark {
-\t\t${keys.map((key) => `--v-${key}: ${tokens[key]};`).join('\n\t\t')}`;
+\t\t${keys.map((key) => `--v-${key}: ${this.darkModeColorAllTokens[key]};`).join('\n\t\t')}}`;
   }
   /**
    * It creates a `vegaDarkModeStyle` style tag in the head of the document if it doesn't exist, and returns it.
@@ -40,5 +65,22 @@ html.dark {
     }
     return vegaDarkModeStyleContainer;
   }
+  /**
+   * Remove the vegaDarkModeStyle style element.
+   */
+  removeDarkModeStyleContainer() {
+    const vegaDarkModeStyleContainer = document.head.querySelector(`#vegaDarkModeStyle`);
+    if (vegaDarkModeStyleContainer) {
+      vegaDarkModeStyleContainer.remove();
+    }
+  }
+  /**
+   * Determines whether the observer should accept changes.
+   *
+   * @returns {boolean} Always returns true in the current implementation.
+   */
+  isAcceptObserver() {
+    return true;
+  }
 }
 export const VegaDarkModeStyleController = new DarkModeStyleController();

package/dist/collection/helpers/theme/tests/theme-manager-controller.test.js

@@ -1,5 +1,5 @@
 import { VegaThemeManager } from '../theme-manager';
-import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
+import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/index';
 import { sleep } from '../../../utils/test-utils';
 const parseResultToArray = (textContent) => {
   return textContent === null || textContent === void 0 ? void 0 : textContent.trim().replace(/\n|\t|:root {|}/g, '').split(';').map((item) => item.split(': ')).filter((item) => item.length === 2).sort();
@@ -505,7 +505,7 @@ describe('Dark mode', () => {
 				--v-bg-textarea-counter-exceed-max-length: 255, 87, 114;
 				--v-regular-credit-card-bg: 252, 252, 252, 1;
 				--v-regular-credit-card-top: 4, 4, 28, 1;
-				--v-regular-credit-card-bottom: 255, 255, 255, 1;"
+				--v-regular-credit-card-bottom: 255, 255, 255, 1;}"
 	`);
   });
 });

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

@@ -9,6 +9,8 @@ import { VegaDarkModeStyleController } from './controllers/dark-mode-style-contr
 import { InjectVegaTelemetrySlimmer } from 'vega-slimmer/core';
 import { createPublicAPIRuntimeMetricsSlimmer } from '../slimmers/runtime-metrics/create-public-api-runtime-metrics-slimmer';
 import { ThemeManagerRuntimeMetricsPayloadDefinition } from '../../constants/runtime-metrics-payload-definition/public-api/ThemeManager/runtime-metrics-payload-definition';
+import ChangeManager from '../change-manager/change-manager';
+import { DARK_MODE_CHANGE } from '../change-manager/subject/static-subject/static-subject-title';
 /**
  * Vega components theme manager
  */
@@ -50,6 +52,7 @@ class ThemeManager {
     else {
       document.documentElement.classList.remove('dark');
     }
+    ChangeManager.notify(DARK_MODE_CHANGE, darkMode);
   }
   /**
    * The function checks if the HTML element has a class of "dark" and returns a boolean value accordingly.

package/dist/collection/helpers/validator/rules/{file-uploader-required-rule.js → object-array-required-rule.js}

@@ -1,12 +1,12 @@
 import { RequiredFieldRule } from './required-field-rule';
 /**
- * A rule that checks if file-uploader value is empty or not
+ * A rule that checks the value is empty or not which value type is object array
  */
-export class FileUploaderRequiredRule extends RequiredFieldRule {
+export class ObjectArrayRequiredRule extends RequiredFieldRule {
   constructor() {
     super(...arguments);
     /**
-     * re-define the file object array check item type method
+     * re-define the object array check item type method
      *
      * @param {unknown} item the array item
      * @returns {boolean} true or false

package/dist/collection/helpers/validator/rules/required-field-rule.js

@@ -74,6 +74,7 @@ export class RequiredFieldRule {
       typeof input === 'number' ||
       typeof input === 'boolean' ||
       (Array.isArray(input) && input.every(this.checkArrayItemType)) ||
-      input === null);
+      input === null ||
+      input === undefined);
   }
 }

package/dist/collection/helpers/validator/rules/rich-text-editor-required-rule.js

@@ -0,0 +1,57 @@
+import { VegaRTEContent } from '../../../components/vega-rich-text-editor/dto/content-state';
+/**
+ * A rule that checks if input range is empty or not
+ *
+ * @implements {FormFieldValidationRule<string[]>}
+ */
+export class RichTextEditorRequiredRule {
+  /**
+   * It checks if the input is a valid value.
+   *
+   * @param {string[]} input - The value of the input field.
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    var _a;
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Invalid value ${input} for rich text editor`);
+    }
+    const isValid = ((_a = input === null || input === void 0 ? void 0 : input.blocks) === null || _a === void 0 ? void 0 : _a.length) > 0 && input.blocks.some((block) => block.isNotEmpty());
+    return {
+      isValid,
+      message: isValid ? '' : 'This field is required',
+    };
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is undefined or null, return true, otherwise return true if the input is a VegaRTEContent.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} A boolean.
+   */
+  isAcceptedInputType(input) {
+    if (input === undefined || input === null)
+      return true;
+    return input instanceof VegaRTEContent;
+  }
+}

package/dist/collection/helpers/validator/test/rules/object-array-required-rule.test.js

@@ -0,0 +1,7 @@
+import { ObjectArrayRequiredRule } from '../../rules/object-array-required-rule';
+test('return result as expect when call ObjectArrayRequiredRule#checkArrayItemType', () => {
+  const rule = new ObjectArrayRequiredRule();
+  expect(rule.checkArrayItemType({ key: '1', name: 'test.svg', url: '' })).toBeTruthy();
+  expect(rule.checkArrayItemType(null)).toBeFalsy();
+  expect(rule.checkArrayItemType('Test')).toBeFalsy();
+});

package/dist/collection/helpers/validator/test/rules/required-field-rule.test.js

@@ -113,3 +113,14 @@ test('should not show error message if status is not touched or not modified', (
     visible: true,
   })).toEqual(false);
 });
+test('return evaluate result as expect if input is empty', () => {
+  const rule = new RequiredFieldRule();
+  expect(rule.evaluate(null)).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+  expect(rule.evaluate(undefined)).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+});

package/dist/collection/helpers/validator/test/rules/rich-text-editor-required-rule.test.js

@@ -0,0 +1,317 @@
+import { RichTextEditorRequiredRule } from '../../rules/rich-text-editor-required-rule';
+import { VegaRTEContent } from '../../../../components/vega-rich-text-editor/dto/content-state';
+import { generateUUID } from '../../../../utils/misc';
+test('return result as expect if input can evaluate', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.canEvaluate(undefined)).toEqual(true);
+  expect(rule.canEvaluate(null)).toEqual(true);
+  expect(rule.canEvaluate(VegaRTEContent.createEmptyContent())).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.canEvaluate(123)).toEqual(false);
+  expect(rule.canEvaluate(false)).toEqual(false);
+  expect(rule.canEvaluate(['1', '2'], {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: false,
+  })).toEqual(false);
+  expect(rule.canEvaluate(VegaRTEContent.createEmptyContent(), {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: false,
+  })).toEqual(false);
+});
+test('return evaluate result as expect', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.evaluate(null)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(undefined)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(VegaRTEContent.createEmptyContent())).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'paragraph',
+      nodes: [
+        {
+          id: generateUUID(),
+          type: 'text',
+          text: 'This is a paragraph',
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'paragraph',
+      nodes: [
+        {
+          id: generateUUID(),
+          type: 'text',
+          text: '',
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'image',
+      nodes: [
+        {
+          id: generateUUID(),
+          type: 'image',
+          // eslint-disable-next-line spellcheck/spell-checker
+          url: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0OCIgaGVpZ2h0PSI0OCIgdmlld0JveD0iMCAwIDQ4IDQ4IiBmaWxsPSJub25lIj48cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTQ4IDI0QzQ4IDM3LjI1NDggMzcuMjU0OCA0OCAyNCA0OEMxMC43NDUyIDQ4IDAgMzcuMjU0OCAwIDI0QzAgMTAuNzQ1MiAxMC43NDUyIDAgMjQgMEMzNy4yNTQ4IDAgNDggMTAuNzQ1MiA0OCAyNFpNMTYuMDAxIDEzLjkxMjVWMzQuNzgyMkgxOS44OTY2VjI1LjY2OUgyNy42ODhWMzQuNzgyMkgzMS41ODM2VjEzLjkxMjVIMjcuNjg4VjIxLjcwMzhIMTkuODk2NlYxMy45MTI1SDE2LjAwMVoiIGZpbGw9IiM1OTYwNjMiLz48L3N2Zz4=',
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+  // Bullet list
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: 'This is a list-item 1.',
+            },
+          ],
+        },
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: 'This is a list-item 2.',
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: '',
+            },
+          ],
+          children: [
+            {
+              id: generateUUID(),
+              type: 'bullet-list',
+              blocks: [
+                {
+                  id: generateUUID(),
+                  type: 'list-item',
+                  nodes: [
+                    {
+                      id: generateUUID(),
+                      type: 'text',
+                      text: 'This is a list item 3-1.',
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'bullet-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: '',
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  // Number list
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'number-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: 'This is a list-item 1.',
+            },
+          ],
+        },
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: 'This is a list-item 2.',
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'number-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: '',
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(VegaRTEContent.fromJSON([
+    {
+      id: generateUUID(),
+      type: 'number-list',
+      blocks: [
+        {
+          id: generateUUID(),
+          type: 'list-item',
+          nodes: [
+            {
+              id: generateUUID(),
+              type: 'text',
+              text: '',
+            },
+          ],
+          children: [
+            {
+              id: generateUUID(),
+              type: 'number-list',
+              blocks: [
+                {
+                  id: generateUUID(),
+                  type: 'list-item',
+                  nodes: [
+                    {
+                      id: generateUUID(),
+                      type: 'text',
+                      text: 'This is a list item 3-1.',
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ]))).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});
+test('throw error as expect if set a error value', () => {
+  const rule = new RichTextEditorRequiredRule();
+  expect(() => {
+    rule.evaluate('1');
+  }).toThrow('Invalid value 1 for rich text editor');
+});

package/dist/collection/helpers/zindex/test/vega-z-index-manager.test.js

@@ -1,5 +1,5 @@
 import VegaZIndexManager from '../vega-z-index-manager';
-import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
+import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/index';
 import { sleep } from '../../../utils/test-utils';
 import InternalVegaZIndexManager from '../internal-vega-z-index-manager';
 test('VegaZIndexManager should work proper', () => {