@globalpayments/vega 2.47.0 → 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/slimmers/brand-switch-state-controller-slimmer.js

@@ -0,0 +1,46 @@
+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 { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+import { GP_BRAND_CHANGE } from '../change-manager/subject/static-subject/static-subject-title';
+import { Observer } from '../change-manager/observer/observer';
+import ChangeManager from '../change-manager/change-manager';
+/** The `BrandSwitchControllerSlimmer` class monitors brand changes and updates the color, logo and footer content accordingly. */
+export class BrandSwitchControllerSlimmer extends VegaSlimmer {
+  /**
+   * Component lifecycle - [connectedCallback]
+   * Register an observer to watch for current branding updates, which will cause the component to update.
+   */
+  connectedCallback() {
+    this.observer = new Observer(this.isAcceptObserver.bind(this), (currentBranding) => {
+      this.currentBranding = currentBranding;
+    });
+    ChangeManager.register(GP_BRAND_CHANGE, this.observer);
+  }
+  /**
+   * cancel dark mode observer when disconnectedCallback
+   */
+  disconnectResizeObserver() {
+    ChangeManager.unregister(GP_BRAND_CHANGE, this.observer);
+  }
+  /**
+   * Determines whether the observer should accept changes.
+   *
+   * @returns {boolean} Always returns true in the current implementation.
+   */
+  isAcceptObserver() {
+    return true;
+  }
+}
+__decorate([
+  MapToComponentField({ writable: true })
+], BrandSwitchControllerSlimmer.prototype, "currentBranding", void 0);
+__decorate([
+  MapToComponentMethod('connectedCallback')
+], BrandSwitchControllerSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], BrandSwitchControllerSlimmer.prototype, "disconnectResizeObserver", null);

package/dist/collection/helpers/slimmers/test/brand-switch-state-controller-slimmer.test.js

@@ -0,0 +1,75 @@
+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 { MockHTMLElement } from '@stencil/core/mock-doc';
+import { BrandSwitchControllerSlimmer } from '../brand-switch-state-controller-slimmer';
+import { VegaInternalThemeManager } from '../../theme/internal-theme-manager';
+describe('BrandSwitchControllerSlimmer', () => {
+  const mockedComponentConnectedCallbackMethod = jest.fn();
+  const mockedComponentDisconnectedCallbackMethod = jest.fn();
+  beforeEach(() => {
+    mockedComponentDisconnectedCallbackMethod.mockClear();
+    mockedComponentConnectedCallbackMethod.mockClear();
+  });
+  describe('BrandSwitchControllerSlimmer should work proper', () => {
+    class MockedBrandSwitchControllerSlimmer extends BrandSwitchControllerSlimmer {
+      constructor() {
+        super();
+      }
+    }
+    __decorate([
+      MapToComponentField({ writable: true })
+    ], MockedBrandSwitchControllerSlimmer.prototype, "currentBranding", void 0);
+    __decorate([
+      MapToComponentField()
+    ], MockedBrandSwitchControllerSlimmer.prototype, "host", void 0);
+    class MockedComponent {
+      constructor() {
+        this.currentBranding = 'heartland';
+        this.controller = new MockedBrandSwitchControllerSlimmer();
+      }
+      connectedCallback() {
+        mockedComponentConnectedCallbackMethod();
+      }
+      disconnectedCallback() {
+        mockedComponentDisconnectedCallbackMethod();
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockedComponent.prototype, "controller", void 0);
+    test('should get brand name when apply branding to "gp"', () => {
+      const mockedComponent = new MockedComponent();
+      const host = new MockHTMLElement('body', 'div');
+      mockedComponent.host = host;
+      mockedComponent.connectedCallback();
+      expect(mockedComponentConnectedCallbackMethod).toBeCalledTimes(1);
+      expect(mockedComponent.currentBranding).toEqual('heartland');
+      VegaInternalThemeManager.applyBranding('gp');
+      expect(mockedComponent.currentBranding).toEqual('gp');
+    });
+    test('should get brand name when apply branding to "genius"', () => {
+      const mockedComponent = new MockedComponent();
+      const host = new MockHTMLElement('body', 'div');
+      mockedComponent.host = host;
+      mockedComponent.connectedCallback();
+      expect(mockedComponentConnectedCallbackMethod).toBeCalledTimes(1);
+      VegaInternalThemeManager.applyBranding('genius');
+      expect(mockedComponent.currentBranding).toEqual('genius');
+    });
+    test('should not get brand name when disconnectedCallback is called', () => {
+      const mockedComponent = new MockedComponent();
+      const host = new MockHTMLElement('body', 'div');
+      mockedComponent.host = host;
+      mockedComponent.disconnectedCallback();
+      expect(mockedComponentDisconnectedCallbackMethod).toBeCalledTimes(1);
+      VegaInternalThemeManager.applyBranding('genius');
+      expect(mockedComponent.currentBranding).toEqual('heartland');
+    });
+  });
+});

package/dist/collection/helpers/theme/controllers/{new-brand-style-controller.js → brand-style-controller.js}

@@ -3,30 +3,30 @@ import { LightModeShadowTokens } from '../../../constants/tokens/themes/v2-new-b
 import { LightModeColorTokens } from '../../../constants/tokens/themes/v2-new-brand/light-mode-color-tokens';
 import { Observer } from '../../change-manager/observer/observer';
 import ChangeManager from '../../change-manager/change-manager';
-import { DARK_MODE_CHANGE, GP_NEW_BRAND_CHANGE, } from '../../change-manager/subject/static-subject/static-subject-title';
+import { DARK_MODE_CHANGE, GP_BRAND_CHANGE, } from '../../change-manager/subject/static-subject/static-subject-title';
 import { VegaInternalThemeManager } from '../internal-theme-manager';
 import { StyleControllerAbstract } from './style-controller.abstract';
 /**
- * Vega components new brand style controller
+ * Vega components brand style controller
  */
-class NewBrandStyleController extends StyleControllerAbstract {
+class BrandStyleController extends StyleControllerAbstract {
   constructor() {
     super();
     this.tokens = {};
-    this.themeStyleContainerKey = 'vega-new-brand-theme';
+    this.themeStyleContainerKey = 'vega-brand-theme';
     this.observer = new Observer(this.isAcceptObserver.bind(this), (options) => {
-      if (options) {
-        this.generateThemeStyle();
+      if (options === 'heartland') {
+        this.reset(this.themeStyleContainerKey);
       }
       else {
-        this.reset(this.themeStyleContainerKey);
+        this.generateThemeStyle();
       }
       const isDarkMode = VegaInternalThemeManager.isDarkMode();
       if (isDarkMode) {
         ChangeManager.notify(DARK_MODE_CHANGE, isDarkMode);
       }
     });
-    ChangeManager.register(GP_NEW_BRAND_CHANGE, this.observer);
+    ChangeManager.register(GP_BRAND_CHANGE, this.observer);
   }
   /**
    * It generates a CSS style for light mode to override the style.
@@ -47,4 +47,4 @@ class NewBrandStyleController extends StyleControllerAbstract {
     return true;
   }
 }
-export const VegaNewBrandStyleController = new NewBrandStyleController();
+export const VegaBrandStyleController = new BrandStyleController();

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

@@ -55,7 +55,7 @@ class DarkModeStyleController extends StyleControllerAbstract {
   generateThemeStyle() {
     const newBrandTokens = Object.assign(NewBrandingDarkModeColorTokens, NewBrandingDarkModeBorderTokens, NewBrandingDarkModeRingTokens, NewBrandingDarkModeShadowTokens);
     const oldTokens = Object.assign(DarkModeColorTokens, DarkModeBorderTokens, DarkModeRingTokens, DarkModeShadowTokens);
-    this.darkModeColorAllTokens = Object.assign(VegaInternalThemeManager.getNewBrandOptions() ? newBrandTokens : oldTokens, CustomDarkModeColorTokens, this.dynamicCustomDarkModeColor);
+    this.darkModeColorAllTokens = Object.assign(VegaInternalThemeManager.getBranding() === 'heartland' ? oldTokens : newBrandTokens, CustomDarkModeColorTokens, this.dynamicCustomDarkModeColor);
     const keys = Object.keys(this.darkModeColorAllTokens);
     this.getStyleContainer(this.themeStyleContainerKey).innerHTML = `
 html.dark {

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

@@ -1,12 +1,15 @@
 import { VegaColorSchemaOverridingController } from './controllers/color-schema-overriding-controller';
 import './controllers/dark-mode-style-controller';
 import ChangeManager from '../change-manager/change-manager';
-import { DARK_MODE_CHANGE, GP_NEW_BRAND_CHANGE, } from '../change-manager/subject/static-subject/static-subject-title';
-import './controllers/new-brand-style-controller';
+import { DARK_MODE_CHANGE, GP_BRAND_CHANGE, } from '../change-manager/subject/static-subject/static-subject-title';
+import './controllers/brand-style-controller';
 /**
  * Vega components controller to control the internal theme manager
  */
 class InternalThemeManager {
+  constructor() {
+    this.currentBranding = 'heartland';
+  }
   /**
    * It takes the colors you passed in, parses them into the correct format, and then applies them to the theme
    *
@@ -50,19 +53,19 @@ class InternalThemeManager {
   /**
    * This function return the new brand name.
    *
-   * @returns {NewBrandOptions} return the new brand options.
+   * @returns {BrandOptions} return the new brand options.
    */
-  getNewBrandOptions() {
-    return this.newBrandOptions;
+  getBranding() {
+    return this.currentBranding;
   }
   /**
-   * This function switches the Vega theme to a new brand theme based on the provided options.
+   * This function switches the Vega theme to a brand theme based on the provided options.
    *
-   * @param {NewBrandOptions} options - The options includes 'gp' and 'genius' options
+   * @param {BrandOptions} options - The options includes 'gp', 'genius' and 'heartland' options
    */
   applyBranding(options) {
-    this.newBrandOptions = options;
-    ChangeManager.notify(GP_NEW_BRAND_CHANGE, options);
+    this.currentBranding = options;
+    ChangeManager.notify(GP_BRAND_CHANGE, options);
   }
 }
 export const VegaInternalThemeManager = new InternalThemeManager();

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

@@ -567,16 +567,16 @@ describe('New Brand Theme', () => {
   it('should enable the new brand theme when set useNewColor: true', () => {
     var _a;
     VegaThemeManager.applyBranding('gp');
-    expect((_a = document.head.querySelector('#vega-new-brand-theme')) === null || _a === void 0 ? void 0 : _a.textContent).toMatchSnapshot();
-    VegaThemeManager.applyBranding(undefined);
-    expect(document.head.querySelector('#vega-new-brand-theme')).toBeNull();
+    expect((_a = document.head.querySelector('#vega-brand-theme')) === null || _a === void 0 ? void 0 : _a.textContent).toMatchSnapshot();
+    VegaThemeManager.applyBranding('heartland');
+    expect(document.head.querySelector('#vega-brand-theme')).toBeNull();
   });
   it('should enable the dark mode with the new brand theme', () => {
     var _a, _b;
     VegaThemeManager.applyBranding('gp');
     VegaThemeManager.toggleDarkMode(true);
     expect((_a = document.head.querySelector('#vegaDarkModeStyle')) === null || _a === void 0 ? void 0 : _a.textContent).toMatchSnapshot();
-    VegaThemeManager.applyBranding(undefined);
+    VegaThemeManager.applyBranding('heartland');
     expect((_b = document.head.querySelector('#vegaDarkModeStyle')) === null || _b === void 0 ? void 0 : _b.textContent).toMatchSnapshot();
   });
 });

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

@@ -55,9 +55,9 @@ class ThemeManager {
     return VegaInternalThemeManager.isDarkMode();
   }
   /**
-   * This function switches the Vega theme to a new brand theme based on the provided options.
+   * This function switches the Vega theme to a brand theme based on the provided options.
    *
-   * @param {NewBrandOptions} options - The options includes 'gp' and 'genius' options
+   * @param {BrandOptions} options - The options includes 'gp', 'genius' and 'heartland' options
    * @vegaVersion 2.47.0
    */
   applyBranding(options) {

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