@globalpayments/vega 2.21.0 → 2.22.0

package/dist/collection/helpers/slimmers/mutation-observer/test/mutation-observer-slimmer.test.js

@@ -8,7 +8,7 @@ import { MockHTMLElement } from '@stencil/core/mock-doc';
 import { InjectVegaSlimmer } from 'vega-slimmer/core';
 import { MutationObserverSlimmer } from '../mutation-observer-slimmer';
 import { MockedMutationObserver } from '../../../../utils/spec-utils';
-import { AttributeOldValueMutationFilter, TagNameMutationFilter } from '../mutation-observer-filters';
+import { AttributeOldValueMutationFilter, TagNameAndAttributeMutationFilter, TagNameMutationFilter, } from '../mutation-observer-filters';
 describe('mutationObserverSlimmer', () => {
   const mockedConnectedCallback = jest.fn();
   const mockedDisconnectedCallback = jest.fn();
@@ -91,6 +91,58 @@ describe('mutationObserverSlimmer', () => {
     expect(mockedMutationCallback).toBeCalledTimes(1);
     mockedComponent.disconnectedCallback();
   });
+  it('slimmer callback should be called when observer attributes and child list', () => {
+    const mockedComponent = new MockedComponent();
+    mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({
+      target: () => mockedComponent.host,
+      options: { attributes: true, attributeFilter: ['disabled'], childList: true, subtree: true },
+      mutationFilter: TagNameAndAttributeMutationFilter('MOCKED-NODE'),
+      callback: () => {
+        mockedMutationCallback();
+      },
+    }));
+    mockedComponent.connectedCallback();
+    mockedComponent.componentDidLoad();
+    const node = document.createElement('mocked-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [node],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(1);
+    node.setAttribute('disabled', 'true');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        attributeName: 'disabled',
+        oldValue: 'false',
+        addedNodes: [],
+        removedNodes: [],
+        target: node,
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+    mockedComponent.disconnectedCallback();
+    const noListenNode = document.createElement('no-listen-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [noListenNode],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+    noListenNode.setAttribute('disabled', 'true');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        attributeName: 'disabled',
+        oldValue: 'false',
+        addedNodes: [],
+        removedNodes: [],
+        target: noListenNode,
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+  });
   it('should work proper while component disconnected', () => {
     const mockedComponent = new MockedComponent();
     mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({

package/dist/collection/helpers/slimmers/runtime-metrics/create-public-api-runtime-metrics-slimmer.js

@@ -0,0 +1,23 @@
+import { createDynamicSlimmer } from 'vega-slimmer/core';
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from './public-api-runtime-metrics-slimmer-base';
+/**
+ * The function `createComponentUsageRuntimeMetricsSlimmer` creates a slimmer version of a component
+ * usage runtime metrics object based on a given class prototype and optional method names to watch.
+ *
+ * @param {ClassPrototype} mapFromClass - The `mapFromClass` parameter is a ClassPrototype that represents the class
+ * from which the dynamic map will be created.
+ * @param {MethodKeysOf[]} [watchMethodNames] - The `watchMethodNames` parameter
+ * is an optional array of method names that you want to watch for in the component.
+ * @param {unknown[]} [initData] - The `initData` parameter allows you to
+ * pass an array of initial data to be used during the initialization of the component usage runtime
+ * metrics slimmer.
+ * @returns {VegaPublicAPIRuntimeMetricsSlimmerBase} The function creates a dynamic public api runtime metrics slimmer.
+ */
+export function createPublicAPIRuntimeMetricsSlimmer(mapFromClass, watchMethodNames, initData) {
+  const methodsMap = [];
+  watchMethodNames.map((watchMethodName) => methodsMap.push({
+    mapFrom: watchMethodName,
+    mapTo: 'sendPublicAPIPayloadToTelemetry',
+  }));
+  return createDynamicSlimmer(mapFromClass, VegaPublicAPIRuntimeMetricsSlimmerBase, [], methodsMap, [mapFromClass.name, initData]);
+}

package/dist/collection/helpers/slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base.js

@@ -0,0 +1,68 @@
+import { VegaSlimmer } from 'vega-slimmer/core';
+import { LogUtility } from '../../../utils/log';
+/**
+ * The `VegaPublicAPIRuntimeMetricsSlimmerBase` class is used for sending
+ * telemetry data to a telemetry service based on defined usage metrics for a public api.
+ */
+export class VegaPublicAPIRuntimeMetricsSlimmerBase extends VegaSlimmer {
+  /**
+   * The constructor initializes a private readonly property with an optional array of
+   * PublicAPIRuntimeMetricsDefinition.
+   *
+   * @param {string} [className] - The parameter show the class name of public api.
+   * @param {PublicAPIRuntimeMetricsDefinition[]} [usageDefinitions] - The `usageDefinitions`
+   * parameter in the constructor is of type `PublicAPIRuntimeMetricsDefinition<T>[]`, which is an
+   * array of `ComponentUsageRuntimeMetricsDefinition` objects. This parameter is optional as it is
+   * marked with a question mark `?`, meaning it can be omitted when creating an instance of
+   */
+  constructor(className, usageDefinitions) {
+    super();
+    this.className = className;
+    this.usageDefinitions = usageDefinitions;
+  }
+  /**
+   * register the observer when the slimmer method called
+   *
+   * @param {unknown[]} [args] - The `args` parameter passed in when the slimmer method is executed
+   * @param {string} [methodName] - The `methodName` parameter is the actual method name of the public API call.
+   */
+  sendPublicAPIPayloadToTelemetry(args, methodName) {
+    // eslint-disable-next-line spellcheck/spell-checker
+    void import('@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index.js').then((
+    // eslint-disable-next-line spellcheck/spell-checker
+    module) => {
+      try {
+        module['default']['emit']('publicAPIMetrics', this.getPublicAPIMetricsPayload(methodName, args));
+      }
+      catch (error) {
+        LogUtility.log('Public API payload failed to emit telemetry:', error);
+      }
+    });
+  }
+  /**
+   * The function `getPublicAPIMetricsPayload` generates a payload containing public api
+   * metrics data.
+   *
+   * @param {string} [methodName] - The `methodName` parameter is the actual method name of the public API call.
+   * @param {unknown[]} [args] - The `args` parameter passed in when the slimmer method is executed
+   * @returns {Record<string, unknown>} The `getPublicAPIMetricsPayload` method returns an object with the following
+   * structure:
+   * {
+   * 	publicAPIName: string, // The public api name
+   * 	data: { // An object containing payload data with keys and boolean values
+   * 		'waitForVegaRenderFinished': true,
+   * }
+   */
+  getPublicAPIMetricsPayload(methodName, args) {
+    const payloadData = {};
+    this.usageDefinitions
+      .filter((definitions) => definitions.canAccept(this.className, methodName, args))
+      .forEach((definitions) => {
+      payloadData[definitions.payloadKey] = definitions.payloadValue(this.className, methodName, args);
+    });
+    return {
+      publicAPIName: this.className,
+      data: payloadData,
+    };
+  }
+}

package/dist/collection/helpers/slimmers/runtime-metrics/test/public-api-runtime-metrics-slimmer-base.test.js

@@ -0,0 +1,89 @@
+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 { InjectVegaSlimmer } from '../../../../../../vega-slimmer/src/decorators/inject-vega-slimmer';
+import { createPublicAPIRuntimeMetricsSlimmer } from '../create-public-api-runtime-metrics-slimmer';
+import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
+import { sleep } from '../../../../utils/test-utils';
+const MockPublicAPIRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_TEST_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method test of public API MockPublicAPI is called',
+    /**
+     * Indicate whether the method is collected when the method been called .
+     *
+     * @returns {boolean} A boolean value
+     */
+    canAccept: () => true,
+    /**
+     * The function checks if the method name is test.
+     *
+     * @param {string} scope - The class name of public api
+     * @param {string} methodName - The method name called by the public api
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (scope, methodName) => {
+      return scope === 'MockPublicAPI' && methodName === 'test';
+    },
+  },
+];
+class MockPublicAPI {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(MockPublicAPI, ['test'], MockPublicAPIRuntimeMetricsPayloadDefinition);
+  }
+  /**
+   * Load the skeletons in the target elements
+   *
+   * @param { unknown } parameter - Configuration for the loading function
+   */
+  test(parameter) {
+    console.log('parameter', parameter);
+  }
+}
+__decorate([
+  InjectVegaSlimmer()
+], MockPublicAPI.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const mockPublicAPI = new MockPublicAPI();
+describe('VegaPublicAPIRuntimeMetricsSlimmerBase', () => {
+  it('should call the emit method of VegaTelemetryRuntimeMetricsManager ', () => {
+    class MockPublicAPI {
+      constructor() {
+        this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(MockPublicAPI, ['test'], 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        '');
+      }
+      /**
+       * Load the skeletons in the target elements
+       *
+       * @param { unknown } parameter - Configuration for the loading function
+       */
+      test(parameter) {
+        console.log('parameter', parameter);
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockPublicAPI.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+    const mockPublicAPI = new MockPublicAPI();
+    jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
+    mockPublicAPI.test('test');
+    void Promise.resolve(sleep(100)).then(async () => {
+      expect(VegaTelemetryRuntimeMetricsManager.emit).not.toBeCalled();
+    });
+  });
+  it('should call the emit method of VegaTelemetryRuntimeMetricsManager ', () => {
+    jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
+    mockPublicAPI.test('test');
+    void Promise.resolve(sleep(100)).then(async () => {
+      expect(VegaTelemetryRuntimeMetricsManager.emit).toHaveBeenCalledWith('publicAPIMetrics', {
+        publicAPIName: 'MockPublicAPI',
+        data: {
+          IS_TEST_METHOD_CALLED: true,
+        },
+      });
+    });
+  });
+});

package/dist/collection/helpers/slimmers/test/component-usage-runtime-metrics.test.js

@@ -9,11 +9,7 @@ import { InjectVegaSlimmer } from 'vega-slimmer/core';
 import { MockHTMLElement } from '@stencil/core/mock-doc';
 import { VegaComponentUsageRuntimeMetricsSlimmer, } from '../component-usage-runtime-metrics';
 import VegaTelemetryRuntimeMetricsManager from '@globalpayments/vega-telemetry-runtime-metrics/runtime-metrics/src/index';
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
+import { sleep } from '../../../utils/test-utils';
 describe('VegaComponentUsageRuntimeMetricsSlimmer', () => {
   const mockedComponentDidRenderMethod = jest.fn();
   const mockComponentRuntimeMetricsPayloadDefinition = [

package/dist/collection/helpers/vega-telemetry-helper/test/vega-env-manager.test.js

@@ -4,7 +4,7 @@ test('should return the correct vega environment parameters', () => {
   const vegaEnv = VegaEnvManager.getVegaEnv();
   expect(vegaEnv).toEqual({
     framework: 'vanilla-js',
-    version: '2.21.0',
+    version: '2.22.0',
   });
 });
 test('should return the correct vega framework', () => {

package/dist/collection/helpers/vega-telemetry-helper/vega-env-manager.js

@@ -9,9 +9,9 @@ export var FrameworkEnum;
 /** The VegaEnvManager class manages vega environment parameters. */
 class VegaEnvManager {
   constructor() {
-    // The `2.21.0` will be replaced to a version string when running publish script.
+    // The `2.22.0` will be replaced to a version string when running publish script.
     // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-    this.vegaVersion = '2.21.0';
+    this.vegaVersion = '2.22.0';
     this.framework = FrameworkEnum.VanillaJs;
   }
   /**

package/dist/collection/utils/test-utils.js

@@ -120,3 +120,15 @@ export function mockChartElement(svg) {
   }
   catch (e) { }
 }
+/**
+ * NOTE: This const is only for **SPEC** test cases.
+ * This method allows the program to stay for a period of time.
+ *
+ * @param {number} [ms] - The `ms` milliseconds of stay.
+ * @returns {Promise<void>} - promise used to signal the process is done
+ */
+export function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}

package/dist/collection/value-model-adapters/angular-ng-model-accessor-adapter.js

@@ -13,6 +13,7 @@ export const AngularAccessorAdapter = [
       'vega-input-range',
       'vega-input-select',
       'vega-radio-group',
+      'vega-selection-chip-group',
       'vega-selection-tile-group',
       'vega-signature-capture',
       'vega-stepper',

package/dist/collection/value-model-adapters/vue-component-v-model-adaptor.js

@@ -15,6 +15,7 @@ export const VueComponentVModelAdaptor = [
       'vega-input-range',
       'vega-input-select',
       'vega-radio-group',
+      'vega-selection-chip-group',
       'vega-selection-tile-group',
       'vega-signature-capture',
       'vega-stepper',

package/dist/esm/{app-globals-565328e2.js → app-globals-68551d56.js}

@@ -1,9 +1,9 @@
-import { F as FeatureFlag } from './feature-flag-controller-9818c025.js';
-import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, w as waitForVega, d as VegaSkeletonLoader } from './vega-skeleton-loader-controller-7378a2e4.js';
+import { F as FeatureFlag } from './feature-flag-controller-afaa4a79.js';
+import { V as VegaLoader, a as VegaNotify, b as VegaThemeManager, c as VegaEventManager, w as waitForVega, d as VegaSkeletonLoader } from './vega-skeleton-loader-controller-64cb8447.js';
 import { M as MapToComponentMethod, V as VegaSlimmer, s as setVegaLogLevel, G as GlobalSlimmersRegistry } from './global-slimmer-registry-16fd7452.js';
 import { V as VegaDialog } from './vega-dialog-controller-1f5923a6.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
-import './internal-vega-event-manager-b0d04798.js';
+import './internal-vega-event-manager-ae6359d6.js';
 import './ui-28499aab.js';
 import { T as TypographyUrls } from './typography-a8fc4764.js';
 import { V as VegaIconManager } from './icon-manager-6ac84741.js';
@@ -246,7 +246,7 @@ function injectValidCreditCardNumberRuleIntoGlobal() {
 function initRuntimeMetricsTelemetryCollection() {
   globalThis.VegaEnvInfo = vegaEnvManager.getVegaEnv();
   // eslint-disable-next-line spellcheck/spell-checker
-  void import('./index-dc8f8d91.js').then(function (n) { return n.i; }).then((
+  void import('./index-0f54aaaa.js').then(function (n) { return n.i; }).then((
   // eslint-disable-next-line spellcheck/spell-checker
   module) => {
     module['default']['init'](FeatureFlag);

package/dist/esm/{child-nodes-event-prevent-slimmer-75851864.js → child-nodes-event-prevent-slimmer-00abe396.js}

@@ -1,7 +1,7 @@
 import { a as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-16fd7452.js';
-import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-b0d04798.js';
+import { i as internalVegaEventManager, j as jqueryDelegatedStrategyController } from './internal-vega-event-manager-ae6359d6.js';
 import { v as vegaEnvManager } from './vega-env-manager-8f8dc473.js';
-import { F as FeatureFlag } from './feature-flag-controller-9818c025.js';
+import { F as FeatureFlag } from './feature-flag-controller-afaa4a79.js';
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;

package/dist/esm/{component-usage-runtime-metrics-ac372454.js → component-usage-runtime-metrics-eaffdd1e.js}

@@ -70,7 +70,7 @@ class VegaComponentUsageRuntimeMetricsSlimmer extends VegaSlimmer {
    */
   sendUsagePayloadToTelemetry() {
     // eslint-disable-next-line spellcheck/spell-checker
-    void import('./index-dc8f8d91.js').then(function (n) { return n.i; }).then((
+    void import('./index-0f54aaaa.js').then(function (n) { return n.i; }).then((
     // eslint-disable-next-line spellcheck/spell-checker
     module) => {
       try {

package/dist/esm/{event-emit-slimmer-929b3e70.js → event-emit-slimmer-46b254b4.js}

@@ -2,7 +2,7 @@ import { a as MapToComponentField, V as VegaSlimmer, I as InjectVegaSlimmer } fr
 import { c as createDynamicSlimmer } from './dynamic-slimmer-ef83e258.js';
 import { C as ChangeManager } from './change-manager-8ddd9afe.js';
 import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-4c0f1048.js';
-import { j as jqueryDelegatedStrategyController, i as internalVegaEventManager } from './internal-vega-event-manager-b0d04798.js';
+import { j as jqueryDelegatedStrategyController, i as internalVegaEventManager } from './internal-vega-event-manager-ae6359d6.js';
 
 var __decorate$3 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;

package/dist/esm/{feature-flag-controller-9818c025.js → feature-flag-controller-afaa4a79.js}

@@ -1,5 +1,5 @@
 import { L as LogUtility } from './global-slimmer-registry-16fd7452.js';
-import { V as VegaTelemetryRuntimeMetricsManager } from './index-dc8f8d91.js';
+import { V as VegaTelemetryRuntimeMetricsManager } from './index-0f54aaaa.js';
 
 /**
  * The concrete feature flag map that we are going to use to determine if a feature is enabled or not.

package/dist/esm/{form-field-controller-slimmer-b237bb58.js → form-field-controller-slimmer-19b99b7e.js}

@@ -8,8 +8,8 @@ import { i as isAsyncFunction, g as generateUUID } from './misc-c21a85c9.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-ef83e258.js';
 import { V as VegaInternalFieldErrorStateChange, a as VegaInternalValid } from './vega-internal-event-id-3c684f5c.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e2e9f248.js';
-import { M as MutationObserverSlimmer } from './mutation-observer-slimmer-a4dbad26.js';
-import { A as AttributeOldValueMutationFilter } from './mutation-observer-filters-a484f098.js';
+import { M as MutationObserverSlimmer } from './mutation-observer-slimmer-151b4b90.js';
+import { A as AttributeOldValueMutationFilter } from './mutation-observer-filters-9086b5cc.js';
 import { i as isArrayEqual } from './array-506b88b9.js';
 
 /** The `FormFieldValidationRuleHandler` class is responsible for handling the validation rules for a form field. */

package/dist/esm/{index-dc8f8d91.js → index-0f54aaaa.js}

@@ -866,6 +866,7 @@ var RuntimeMetricsPayloadTypeEnum;
 (function (RuntimeMetricsPayloadTypeEnum) {
     RuntimeMetricsPayloadTypeEnum["ComponentUsagePayload"] = "componentUsage";
     RuntimeMetricsPayloadTypeEnum["FeatureFlagOverriddenPayload"] = "featureFlagOverridden";
+    RuntimeMetricsPayloadTypeEnum["PublicAPIMetricsPayload"] = "publicAPIMetrics";
 })(RuntimeMetricsPayloadTypeEnum || (RuntimeMetricsPayloadTypeEnum = {}));
 var RuntimeMetricsTriggerEventEnum;
 (function (RuntimeMetricsTriggerEventEnum) {
@@ -953,6 +954,14 @@ class FeatureFlagOverriddenMetricsPayloadEmitDto {
     }
 }
 
+class PublicAPIMetricsPayloadEmitDto {
+    constructor(type, publicAPIName, data) {
+        this.type = type;
+        this.publicAPIName = publicAPIName;
+        this.data = data;
+    }
+}
+
 class VegaTelemetryRuntimeMetricsManager {
     emit(runtimeMetricsPayloadType, runtimeMetricsPayload) {
         requestIdleCallback(() => {
@@ -967,6 +976,10 @@ class VegaTelemetryRuntimeMetricsManager {
                             Emittor.emit(new FeatureFlagOverriddenMetricsPayloadEmitDto(runtimeMetricsPayloadType, runtimeMetricsPayload['featureFlagName'], runtimeMetricsPayload['featureFlagOverriddenValue']));
                             break;
                         }
+                        case RuntimeMetricsPayloadTypeEnum.PublicAPIMetricsPayload: {
+                            Emittor.emit(new PublicAPIMetricsPayloadEmitDto(runtimeMetricsPayloadType, runtimeMetricsPayload['publicAPIName'], runtimeMetricsPayload['data']));
+                            break;
+                        }
                         default: {
                             throw new Error(`Unknown runtime metrics payload type: ${runtimeMetricsPayloadType}`);
                         }

package/dist/esm/{index-c3505689.js → index-187f71d1.js}

@@ -773,6 +773,9 @@ const dispatchHooks = (hostRef, isInitialLoad) => {
             promise = safeCall(instance, 'componentWillLoad');
         }
     }
+    {
+        promise = then(promise, () => safeCall(instance, 'componentWillRender'));
+    }
     endSchedule();
     return then(promise, () => updateComponent(hostRef, instance, isInitialLoad));
 };
@@ -1637,6 +1640,10 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
           return import(
             /* webpackMode: "lazy" */
             './vega-selection-tile_2.entry.js').then(processMod, consoleError);
+        case 'vega-selection-chip_2':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-selection-chip_2.entry.js').then(processMod, consoleError);
         case 'vega-calendar_3':
           return import(
             /* webpackMode: "lazy" */

package/dist/esm/index.js

@@ -7,10 +7,10 @@ export { I as Icons, g as getIconFromToken } from './icons-8627925e.js';
 export { a as Typography, b as TypographyKeys, T as TypographyUrls } from './typography-a8fc4764.js';
 export { B as BreakpointKeys } from './ui-df46cc20.js';
 export { F as FrameworkEnum, v as VegaEnvManager } from './vega-env-manager-8f8dc473.js';
-export { c as VegaEventManager, V as VegaLoader, a as VegaNotify, d as VegaSkeletonLoader, b as VegaThemeManager, w as waitForVega } from './vega-skeleton-loader-controller-7378a2e4.js';
-export { F as FeatureFlag } from './feature-flag-controller-9818c025.js';
+export { c as VegaEventManager, V as VegaLoader, a as VegaNotify, d as VegaSkeletonLoader, b as VegaThemeManager, w as waitForVega } from './vega-skeleton-loader-controller-64cb8447.js';
+export { F as FeatureFlag } from './feature-flag-controller-afaa4a79.js';
 export { V as VegaDialog } from './vega-dialog-controller-1f5923a6.js';
-export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-b0d04798.js';
+export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-ae6359d6.js';
 export { V as VegaIconManager } from './icon-manager-6ac84741.js';
 export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-232f2986.js';
 import './responsive-format-facade-b96ca811.js';
@@ -23,7 +23,7 @@ import './ui-28499aab.js';
 import './z-index-manager-7179cb75.js';
 import './dynamic-slimmer-ef83e258.js';
 import './page-resize-observer-slimmer-e2e9f248.js';
-import './index-dc8f8d91.js';
+import './index-0f54aaaa.js';
 import './vega-event-id-13e22d1e.js';
 
 /* This file is generated by vega-design 2.0.77 */

package/dist/esm/{internal-vega-event-manager-b0d04798.js → internal-vega-event-manager-ae6359d6.js}

@@ -43,6 +43,8 @@ const entries = [
   ['vega-radio', [VegaChange, VegaFocus, VegaBlur]],
   ['vega-radio-group', [VegaChange]],
   ['vega-segment-control', [VegaChange]],
+  ['vega-selection-chip', [VegaChange]],
+  ['vega-selection-chip-group', [VegaChange]],
   ['vega-selection-tile', [VegaChange]],
   ['vega-selection-tile-group', [VegaChange]],
   ['vega-signature-capture', [VegaChange]],