@globalpayments/vega 2.45.0 → 2.47.0

package/dist/collection/helpers/event-manager/test/event-emit-slimmer.test.js

@@ -4,10 +4,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
   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 { createEventEmitSlimmer } from '../slimmers/event-emit-slimmer';
+import { createEventEmitSlimmer, } from '../slimmers/event-emit-slimmer';
 import { InjectVegaSlimmer, methodPlaceholder } from 'vega-slimmer/core';
 import { VegaClick } from '../event-id/vega-event-id';
 import InternalVegaEventManager from '../internal-vega-event-manager';
+import { DomNodeSubjectObserverFactory } from '../../change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
 describe('EventEmitSlimmer ', () => {
   class MockedComponent {
     constructor() {
@@ -32,6 +33,16 @@ describe('EventEmitSlimmer ', () => {
   __decorate([
     InjectVegaSlimmer()
   ], MockedComponentForAlias.prototype, "eventEmitter", void 0);
+  class MockedComponentForEventPrevent {
+    constructor() {
+      this.mockEvent = new CustomEvent('vegaClick');
+      this.vegaClick = { emit: () => this.mockEvent };
+      this.eventEmitter = createEventEmitSlimmer(MockedComponentForEventPrevent, VegaClick);
+    }
+  }
+  __decorate([
+    InjectVegaSlimmer()
+  ], MockedComponentForEventPrevent.prototype, "eventEmitter", void 0);
   it('should call removeObserverFromHost when component disconnected', () => {
     const component = new MockedComponent();
     spyOn(component['eventEmitter'], 'removeObserverFromHost');
@@ -104,4 +115,20 @@ describe('EventEmitSlimmer ', () => {
     const jqueryEvent = component['eventEmitter'].emit(undefined, new CustomEvent('click', { bubbles: true, cancelable: true }));
     expect(jqueryEvent.type).toEqual('click');
   });
+  it('should call prevent the default properly', () => {
+    const component = new MockedComponentForEventPrevent();
+    const host = document.createElement('vega-button');
+    component['host'] = host;
+    spyOn(component['mockEvent'], 'preventDefault');
+    let click = jest.fn();
+    DomNodeSubjectObserverFactory.addUniqueObserverToNode(host, VegaClick, click);
+    component['eventEmitter'].emit();
+    expect(click).toBeCalledTimes(1);
+    expect(component['mockEvent'].preventDefault).toBeCalledTimes(0);
+    click = jest.fn((input) => input.preventDefault());
+    DomNodeSubjectObserverFactory.addUniqueObserverToNode(host, VegaClick, click);
+    component['eventEmitter'].emit();
+    expect(click).toBeCalledTimes(1);
+    expect(component['mockEvent'].preventDefault).toBeCalledTimes(1);
+  });
 });

package/dist/collection/helpers/event-manager/test/vega-event-manager.test.js

@@ -1,5 +1,5 @@
 import { VegaEventManager } from '../../public-api';
-import { VegaBlur, VegaChange, VegaCreate, VegaDropdownClick, VegaDropdownHide, VegaDropdownSearch, VegaDropdownShow, VegaFocus, VegaLabelButtonClick, VegaSearchTrigger, } from '../event-id/vega-event-id';
+import { VegaBlur, VegaChange, VegaCreate, VegaDropdownClick, VegaDropdownHide, VegaDropdownSearch, VegaDropdownShow, VegaFocus, VegaLabelButtonClick, VegaReset, VegaSearchTrigger, } from '../event-id/vega-event-id';
 import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/index';
 import { sleep } from '../../../utils/test-utils';
 describe('VegaEventManager', () => {
@@ -28,6 +28,7 @@ describe('VegaEventManager', () => {
       VegaDropdownShow,
       VegaDropdownHide,
       VegaDropdownClick,
+      VegaReset,
       VegaCreate,
       VegaDropdownSearch,
       VegaSearchTrigger,

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

@@ -12,6 +12,16 @@ class InternalIconManager {
   getIconKey(name) {
     return this.generateIconKeyWithNamespace(name, InternalIconManager.INTERNAL_ICON_NAMESPACE);
   }
+  /**
+   *  Check if the internal icon manager has an icon by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {boolean} returns true if the icon exists
+   * @vegaVersion 2.46.0
+   */
+  hasIcon(name) {
+    return VegaIconManager.hasIcon(this.getIconKey(name));
+  }
   /**
    * Register internal icons
    *

package/dist/collection/helpers/slimmers/form-field-controller-slimmer.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, MapToComponentMethod, InjectVegaSlimmer, VegaSlimmer, methodPlaceholder, } from 'vega-slimmer/core';
 import { camelToDashCase } from '../../utils/string';
-import { FormFieldController } from '../validator/form-field-controller';
+import { FormFieldController, } from '../validator/form-field-controller';
 import { FieldErrorControllerSlimmer } from './field-error-controller-silmmer';
 import changeManager from '../change-manager/change-manager';
 import { FORM_ELEMENT_VALIDATE } from '../change-manager/subject/static-subject/static-subject-title';
@@ -14,6 +14,7 @@ import { FormFieldValidInvokeSlimmer } from './form-field-valid-invoke-slimmer';
 import { MutationObserverSlimmer } from './mutation-observer/mutation-observer-slimmer';
 import { AttributeOldValueMutationFilter } from './mutation-observer/mutation-observer-filters';
 import { isArrayEqual } from '../../utils/array';
+import { FormFieldStateControllerSlimmer } from './form-field-state-controller-slimmer';
 /**
  * The `FormFieldControllerSlimmer` class is a TypeScript class that extends `VegaSlimmer` and provides functionality for managing form field components.
  * TODO:
@@ -32,6 +33,7 @@ export class FormFieldControllerSlimmer extends VegaSlimmer {
     super();
     this.fieldErrorSlimmer = new FieldErrorControllerSlimmer();
     this.formFieldValidInvokeSlimmer = new FormFieldValidInvokeSlimmer();
+    this.formFormStateController = new FormFieldStateControllerSlimmer();
     this.mutationObserverCallBack = () => {
       if (this.validator) {
         this.setDefaultRules();
@@ -193,6 +195,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], FormFieldControllerSlimmer.prototype, "mutationObserverSlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], FormFieldControllerSlimmer.prototype, "formFormStateController", void 0);
 __decorate([
   MapToComponentMethod('connectedCallback')
 ], FormFieldControllerSlimmer.prototype, "connectedCallback", null);

package/dist/collection/helpers/slimmers/form-field-state-controller-slimmer.js

@@ -0,0 +1,45 @@
+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 } from 'vega-slimmer/core';
+import { SubStateObserverSlimmer } from '../slimmers/sub-state/sub-state-observer-slimmer';
+/**
+ * Controller for the form field states
+ */
+export class FormFieldStateControllerSlimmer extends SubStateObserverSlimmer {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  constructor() {
+    super({
+      parent: 'vega-form',
+      subStates: [
+        {
+          subStateName: 'disableBlurValidation',
+          parentStateName: 'disableBlurValidation',
+          // eslint-disable-next-line jsdoc/require-jsdoc
+          callback: (disableBlurValidation) => {
+            var _a;
+            (_a = this.validator) === null || _a === void 0 ? void 0 : _a.updateDisableBlurValidation(disableBlurValidation);
+          },
+        },
+      ],
+    });
+  }
+  /**
+   * Component lifecycle - componentWillLoad
+   */
+  componentWillLoad() {
+    super.componentWillLoad();
+  }
+}
+__decorate([
+  MapToComponentField()
+], FormFieldStateControllerSlimmer.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], FormFieldStateControllerSlimmer.prototype, "validator", void 0);
+__decorate([
+  MapToComponentMethod('setInjectFormFieldHelper')
+], FormFieldStateControllerSlimmer.prototype, "componentWillLoad", null);

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

@@ -1,3 +1,7 @@
+import { DarkModeColorTokens as NewBrandingDarkModeColorTokens } from '../../../constants/tokens/themes/v2-new-brand/dark-mode-color-tokens';
+import { DarkModeBorderTokens as NewBrandingDarkModeBorderTokens } from '../../../constants/tokens/themes/v2-new-brand/dark-mode-border-tokens';
+import { DarkModeShadowTokens as NewBrandingDarkModeRingTokens } from '../../../constants/tokens/themes/v2-new-brand/dark-mode-shadow-tokens';
+import { DarkModeRingTokens as NewBrandingDarkModeShadowTokens } from '../../../constants/tokens/themes/v2-new-brand/dark-mode-ring-tokens';
 import { DarkModeColorTokens } from '../../../constants/tokens/themes/dark-mode-color-tokens';
 import { DarkModeBorderTokens } from '../../../constants/tokens/themes/dark-mode-border-tokens';
 import { DarkModeShadowTokens } from '../../../constants/tokens/themes/dark-mode-shadow-tokens';
@@ -5,6 +9,8 @@ import { DarkModeRingTokens } from '../../../constants/tokens/themes/dark-mode-r
 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';
+import { VegaInternalThemeManager } from '../internal-theme-manager';
+import { StyleControllerAbstract } from './style-controller.abstract';
 // TODO: Remove this after the token add in vega design.
 const CustomDarkModeColorTokens = {
   'bg-backdrop-loading': '0, 0, 0, 0.5',
@@ -18,16 +24,18 @@ const CustomDarkModeColorTokens = {
 /**
  * Vega components dark mode style controller
  */
-class DarkModeStyleController {
+class DarkModeStyleController extends StyleControllerAbstract {
   constructor() {
+    super();
     this.dynamicCustomDarkModeColor = {};
+    this.themeStyleContainerKey = 'vegaDarkModeStyle';
     this.darkModeColorAllTokens = {};
     this.observer = new Observer(this.isAcceptObserver.bind(this), (isDark) => {
       if (isDark) {
-        this.generateDarkModeStyle();
+        this.generateThemeStyle();
       }
       else {
-        this.removeDarkModeStyleContainer();
+        this.reset(this.themeStyleContainerKey);
       }
     });
     ChangeManager.register(DARK_MODE_CHANGE, this.observer);
@@ -39,41 +47,20 @@ class DarkModeStyleController {
    */
   registerCustomDarkModeColor(customDarkModeColor) {
     this.dynamicCustomDarkModeColor = Object.assign(Object.assign({}, this.dynamicCustomDarkModeColor), customDarkModeColor);
-    this.generateDarkModeStyle();
+    this.generateThemeStyle();
   }
   /**
    * It generates a CSS style for dark mode to override the style.
    */
-  generateDarkModeStyle() {
-    this.darkModeColorAllTokens = Object.assign(DarkModeColorTokens, DarkModeBorderTokens, DarkModeRingTokens, DarkModeShadowTokens, CustomDarkModeColorTokens, this.dynamicCustomDarkModeColor);
+  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);
     const keys = Object.keys(this.darkModeColorAllTokens);
-    this.getDarkModeStyleContainer().innerHTML = `
+    this.getStyleContainer(this.themeStyleContainerKey).innerHTML = `
 html.dark {
 \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.
-   *
-   * @returns {Element} The `vegaDarkModeStyleContainer` is being returned.
-   */
-  getDarkModeStyleContainer() {
-    let vegaDarkModeStyleContainer = document.head.querySelector(`#vegaDarkModeStyle`);
-    if (!vegaDarkModeStyleContainer) {
-      vegaDarkModeStyleContainer = document.createElement('style');
-      vegaDarkModeStyleContainer.id = 'vegaDarkModeStyle';
-      document.head.append(vegaDarkModeStyleContainer);
-    }
-    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.
    *

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

@@ -0,0 +1,50 @@
+import { LightModeBorderTokens } from '../../../constants/tokens/themes/v2-new-brand/light-mode-border-tokens';
+import { LightModeShadowTokens } from '../../../constants/tokens/themes/v2-new-brand/light-mode-shadow-tokens';
+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 { VegaInternalThemeManager } from '../internal-theme-manager';
+import { StyleControllerAbstract } from './style-controller.abstract';
+/**
+ * Vega components new brand style controller
+ */
+class NewBrandStyleController extends StyleControllerAbstract {
+  constructor() {
+    super();
+    this.tokens = {};
+    this.themeStyleContainerKey = 'vega-new-brand-theme';
+    this.observer = new Observer(this.isAcceptObserver.bind(this), (options) => {
+      if (options) {
+        this.generateThemeStyle();
+      }
+      else {
+        this.reset(this.themeStyleContainerKey);
+      }
+      const isDarkMode = VegaInternalThemeManager.isDarkMode();
+      if (isDarkMode) {
+        ChangeManager.notify(DARK_MODE_CHANGE, isDarkMode);
+      }
+    });
+    ChangeManager.register(GP_NEW_BRAND_CHANGE, this.observer);
+  }
+  /**
+   * It generates a CSS style for light mode to override the style.
+   */
+  generateThemeStyle() {
+    this.tokens = Object.assign(LightModeColorTokens, LightModeBorderTokens, LightModeShadowTokens);
+    const keys = Object.keys(this.tokens);
+    this.getStyleContainer(this.themeStyleContainerKey).innerHTML = `
+:root {
+\t\t${keys.map((key) => `--v-${key}: ${this.tokens[key]};`).join('\n\t\t')}}`;
+  }
+  /**
+   * Determines whether the observer should accept changes.
+   *
+   * @returns {boolean} Always returns true in the current implementation.
+   */
+  isAcceptObserver() {
+    return true;
+  }
+}
+export const VegaNewBrandStyleController = new NewBrandStyleController();

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

@@ -0,0 +1,31 @@
+/**
+ * StyleController Abstract class control the theme style controller
+ */
+export class StyleControllerAbstract {
+  /**
+   * It creates a style tag in the head of the document if it doesn't exist, and returns it.
+   *
+   * @param {string} themeStyleContainerKey - custom dark mode color
+   * @returns {Element} The style element is being returned.
+   */
+  getStyleContainer(themeStyleContainerKey) {
+    let vegaThemeStyleContainer = document.head.querySelector(`#${themeStyleContainerKey}`);
+    if (!vegaThemeStyleContainer) {
+      vegaThemeStyleContainer = document.createElement('style');
+      vegaThemeStyleContainer.id = themeStyleContainerKey;
+      document.head.append(vegaThemeStyleContainer);
+    }
+    return vegaThemeStyleContainer;
+  }
+  /**
+   * Remove the style element.
+   *
+   * @param {string} themeStyleContainerKey - theme style container key.
+   */
+  reset(themeStyleContainerKey) {
+    const vegaThemeStyleContainer = document.head.querySelector(`#${themeStyleContainerKey}`);
+    if (vegaThemeStyleContainer) {
+      vegaThemeStyleContainer.remove();
+    }
+  }
+}

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

@@ -0,0 +1,68 @@
+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';
+/**
+ * Vega components controller to control the internal theme manager
+ */
+class InternalThemeManager {
+  /**
+   * It takes the colors you passed in, parses them into the correct format, and then applies them to the theme
+   *
+   * @param {VegaThemeOverrideColors} overrideColors - OverrideColors - This is the object that you pass to the function.
+   */
+  overrideColors(overrideColors) {
+    const overrideThemes = VegaColorSchemaOverridingController.generateOverrideThemes(overrideColors);
+    VegaColorSchemaOverridingController.applyTheme(overrideThemes);
+  }
+  /**
+   * It removes all the custom override theme styles from the DOM
+   */
+  reset() {
+    VegaColorSchemaOverridingController.getOverrideThemeContainer().innerHTML = '';
+  }
+  /**
+   * This function toggles the dark mode of a webpage by adding or removing a 'dark' class to the HTML element.
+   *
+   * @param {boolean | undefined} darkMode - A boolean or undefined value that determines whether to enable or disable dark mode.
+   * If it is true, dark mode is enabled.
+   * If it is false, dark mode is disabled.
+   */
+  toggleDarkMode(darkMode) {
+    if (darkMode) {
+      document.documentElement.classList.add('dark');
+    }
+    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.
+   *
+   * @returns {boolean} A boolean value indicating whether the HTML element has a class of "dark", which is
+   * typically used to indicate that the website is in dark mode.
+   */
+  isDarkMode() {
+    return document.documentElement.classList.contains('dark');
+  }
+  /**
+   * This function return the new brand name.
+   *
+   * @returns {NewBrandOptions} return the new brand options.
+   */
+  getNewBrandOptions() {
+    return this.newBrandOptions;
+  }
+  /**
+   * This function switches the Vega theme to a new brand theme based on the provided options.
+   *
+   * @param {NewBrandOptions} options - The options includes 'gp' and 'genius' options
+   */
+  applyBranding(options) {
+    this.newBrandOptions = options;
+    ChangeManager.notify(GP_NEW_BRAND_CHANGE, options);
+  }
+}
+export const VegaInternalThemeManager = new InternalThemeManager();

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

@@ -563,3 +563,20 @@ describe('Send Telemetry', () => {
     });
   });
 });
+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();
+  });
+  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);
+    expect((_b = document.head.querySelector('#vegaDarkModeStyle')) === null || _b === void 0 ? void 0 : _b.textContent).toMatchSnapshot();
+  });
+});

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

@@ -4,19 +4,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
   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 { VegaColorSchemaOverridingController } from './controllers/color-schema-overriding-controller';
-import { VegaDarkModeStyleController } from './controllers/dark-mode-style-controller';
+import './controllers/dark-mode-style-controller';
 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';
+import { VegaInternalThemeManager } from './internal-theme-manager';
 /**
  * Vega components theme manager
  */
 class ThemeManager {
   constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(ThemeManager, ['overrideColors', 'reset', 'toggleDarkMode', 'isDarkMode'], ThemeManagerRuntimeMetricsPayloadDefinition);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(ThemeManager, ['overrideColors', 'reset', 'toggleDarkMode', 'isDarkMode', 'applyBranding'], ThemeManagerRuntimeMetricsPayloadDefinition);
   }
   /**
    * It takes the colors you passed in, parses them into the correct format, and then applies them to the theme
@@ -25,8 +23,7 @@ class ThemeManager {
    * @vegaVersion 1.20.0
    */
   async overrideColors(overrideColors) {
-    const overrideThemes = VegaColorSchemaOverridingController.generateOverrideThemes(overrideColors);
-    VegaColorSchemaOverridingController.applyTheme(overrideThemes);
+    void VegaInternalThemeManager.overrideColors(overrideColors);
   }
   /**
    * It removes all the custom override theme styles from the DOM
@@ -34,7 +31,7 @@ class ThemeManager {
    * @vegaVersion 1.20.0
    */
   async reset() {
-    VegaColorSchemaOverridingController.getOverrideThemeContainer().innerHTML = '';
+    void VegaInternalThemeManager.reset();
   }
   /**
    * This function toggles the dark mode of a webpage by adding or removing a 'dark' class to the HTML element.
@@ -45,14 +42,7 @@ class ThemeManager {
    * @vegaVersion 1.32.0
    */
   toggleDarkMode(darkMode) {
-    if (darkMode) {
-      document.documentElement.classList.add('dark');
-      VegaDarkModeStyleController.generateDarkModeStyle();
-    }
-    else {
-      document.documentElement.classList.remove('dark');
-    }
-    ChangeManager.notify(DARK_MODE_CHANGE, darkMode);
+    VegaInternalThemeManager.toggleDarkMode(darkMode);
   }
   /**
    * The function checks if the HTML element has a class of "dark" and returns a boolean value accordingly.
@@ -62,7 +52,16 @@ class ThemeManager {
    * @vegaVersion 1.32.0
    */
   isDarkMode() {
-    return document.documentElement.classList.contains('dark');
+    return VegaInternalThemeManager.isDarkMode();
+  }
+  /**
+   * This function switches the Vega theme to a new brand theme based on the provided options.
+   *
+   * @param {NewBrandOptions} options - The options includes 'gp' and 'genius' options
+   * @vegaVersion 2.47.0
+   */
+  applyBranding(options) {
+    VegaInternalThemeManager.applyBranding(options);
   }
 }
 __decorate([

package/dist/collection/helpers/translation/locales/en.js

@@ -107,5 +107,6 @@ export const staticTranslations = {
   'Heading 2': 'Heading 2',
   'Heading 3': 'Heading 3',
   'Paragraph': 'Paragraph',
+  'Reset Selection': 'Reset Selection',
 };
 export default staticTranslations;

package/dist/collection/helpers/translation/tests/internal-translation-controller.test.js

@@ -197,6 +197,7 @@ describe('VegaTranslationController', () => {
       'Heading 2': 'Heading 2',
       'Heading 3': 'Heading 3',
       'Paragraph': 'Paragraph',
+      'Reset Selection': 'Reset Selection',
     });
     /* eslint-enable @typescript-eslint/naming-convention,spellcheck/spell-checker */
   });

package/dist/collection/helpers/validator/form-field-controller.js

@@ -198,6 +198,14 @@ export class FormFieldController {
   connectResizeObserver() {
     methodPlaceholder();
   }
+  /**
+   * Updates the `disableBlurValidation.
+   *
+   * @param {boolean} disableBlurValidation - From parent vega form.
+   */
+  updateDisableBlurValidation(disableBlurValidation) {
+    this.disableBlurValidation = disableBlurValidation;
+  }
   /**
    * The function "updateValidationHandlers" initializes the validation rule handler chain with the rules obtained from the "getRules" function.
    */
@@ -247,7 +255,7 @@ export class FormFieldController {
   updateIsTouched(touched) {
     const prevIsTouched = this.isTouched;
     this.isTouched = touched;
-    if (this.isAutoValidationEnabled()) {
+    if (!this.disableBlurValidation && this.isAutoValidationEnabled()) {
       void this.valid(prevIsTouched === touched ? [] : ['touched']);
     }
   }