@globalpayments/vega 2.21.0 → 2.23.0

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

@@ -1,4 +1,4 @@
-import { G as GlobalSlimmersRegistry, c as createSetterForVegaSlimmerField, C as ConsumerSlimmers, b as createGetterForVegaSlimmerField, a as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer, L as LogUtility } from './global-slimmer-registry-16fd7452.js';
+import { G as GlobalSlimmersRegistry, d as createSetterForVegaSlimmerField, C as ConsumerSlimmers, e as createGetterForVegaSlimmerField, c as MapToComponentField, M as MapToComponentMethod, V as VegaSlimmer, L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
 
 /**
  * The function `InjectVegaGlobalSlimmer` is a TypeScript decorator that registers a property as a Vega
@@ -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-0863eec6.js').then(function (n) { return n.i; }).then((
     // eslint-disable-next-line spellcheck/spell-checker
     module) => {
       try {

package/dist/esm/create-public-api-runtime-metrics-slimmer-dc9af92b.js

@@ -0,0 +1,168 @@
+import { C as ConsumerSlimmers, S as SlimmerConsumedBy, a as SlimmerMappedMethod, b as CurrentlyInvokedMethodName, V as VegaSlimmer, L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
+import { i as isObjectEmpty } from './misc-9fdbcfbb.js';
+
+/**
+ * This decorator is used to re-define a field in a public API controller
+ * which will be used for injecting the VegaSlimmer into the public API controller.
+ *
+ * @returns {Function} The decorator function.
+ */
+function InjectVegaTelemetrySlimmer() {
+  return function (publicAPIPrototype, propertyKey) {
+    Object.defineProperty(publicAPIPrototype, propertyKey, {
+      set: createSetterForVegaTelemetrySlimmerField(propertyKey),
+    });
+  };
+}
+/**
+ * Creates a setter for a vega slimmer field which will be used for injecting the VegaSlimmer into the public API controller.
+ *
+ * @param {string} fieldName The name of the field to inject the VegaSlimmer into.
+ * @returns {Function} A setter for the vega slimmer field.
+ */
+function createSetterForVegaTelemetrySlimmerField(fieldName) {
+  return function (slimmer) {
+    if (!this[ConsumerSlimmers]) {
+      this[ConsumerSlimmers] = new Map();
+    }
+    this[ConsumerSlimmers].set(fieldName, slimmer);
+    slimmer[SlimmerConsumedBy] = this;
+    registerSlimMethodsToTelemetry(slimmer, this);
+  };
+}
+/**
+ * Given a VegaSlimmer and a public API controller, register the slimmer methods to the public API controller.
+ * This is done by appending the slimmer methods to the end of the corresponding public API controller method.
+ *
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {ClassPrototype<unknown>} publicAPIController The public API controller to register the slimmer method to.
+ * @returns {void}
+ */
+function registerSlimMethodsToTelemetry(slimmer, publicAPIController) {
+  const slimmerPrototype = slimmer.constructor.prototype;
+  if (slimmerPrototype[SlimmerMappedMethod]) {
+    for (const entry of slimmerPrototype[SlimmerMappedMethod]) {
+      publicAPIController[entry.componentMethodName] = createRegisteredSlimMethod(publicAPIController, slimmer, publicAPIController[entry.componentMethodName], entry);
+    }
+  }
+}
+/**
+ * Append the slimmer methods to the end of the corresponding public API controller method.
+ * Which means the slimmer method will be called when the original method is invoked in the public API controller.
+ *
+ * @param {ClassPrototype<unknown>} publicAPIController The public API controller to register the slimmer method to.
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {Function} originalMethod The original method to override.
+ * @param {SlimmerMappedMethodEntry} mapEntry The map entry for the slimmer method.
+ * @returns {Function} The registered slimmer method.
+ */
+function createRegisteredSlimMethod(publicAPIController, slimmer, originalMethod, mapEntry) {
+  return function (...args) {
+    const result = originalMethod.apply(publicAPIController, args);
+    slimmer[CurrentlyInvokedMethodName] = mapEntry.componentMethodName;
+    if (result && typeof result.then === 'function') {
+      result.then(() => slimmer[mapEntry.slimmerMethodName].call(slimmer, ...args));
+    }
+    else {
+      slimmer[mapEntry.slimmerMethodName].call(slimmer, ...args);
+    }
+    return result;
+  };
+}
+
+/**
+ * The `VegaPublicAPIRuntimeMetricsSlimmerBase` class is used for sending
+ * telemetry data to a telemetry service based on defined usage metrics for a public api.
+ */
+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
+   */
+  sendPublicAPIPayloadToTelemetry(args) {
+    try {
+      const publicAPIMetricsPayload = this.getPublicAPIMetricsPayload(args);
+      if (publicAPIMetricsPayload) {
+        // eslint-disable-next-line spellcheck/spell-checker
+        void import('./index-0863eec6.js').then(function (n) { return n.i; }).then((
+        // eslint-disable-next-line spellcheck/spell-checker
+        module) => {
+          module['default']['emit']('publicAPIMetrics', publicAPIMetricsPayload);
+        });
+      }
+    }
+    catch (error) {
+      LogUtility.log('Public API payload failed to emit telemetry:', error);
+    }
+  }
+  /**
+   * The function `getPublicAPIMetricsPayload` generates a payload containing public api
+   * metrics data.
+   * The `CurrentlyInvokedMethodName` is a public API method name, it comes from the `InjectVegaTelemetrySlimmer` definition and assignment
+   *
+   * @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(args) {
+    const payloadData = {};
+    this.usageDefinitions
+      .filter((definitions) => definitions.canAccept(this.className, this[CurrentlyInvokedMethodName], args))
+      .forEach((definitions) => {
+      payloadData[definitions.payloadKey] = definitions.payloadValue(args);
+    });
+    if (isObjectEmpty(payloadData)) {
+      return null;
+    }
+    return {
+      publicAPIName: this.className,
+      data: payloadData,
+    };
+  }
+}
+
+/**
+ * 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.
+ */
+function createPublicAPIRuntimeMetricsSlimmer(mapFromClass, watchMethodNames, initData) {
+  const methodsMap = [];
+  watchMethodNames.map((watchMethodName) => methodsMap.push({
+    mapFrom: watchMethodName,
+    mapTo: 'sendPublicAPIPayloadToTelemetry',
+  }));
+  return createDynamicSlimmer(mapFromClass, VegaPublicAPIRuntimeMetricsSlimmerBase, [], methodsMap, [mapFromClass.name, initData]);
+}
+
+export { InjectVegaTelemetrySlimmer as I, createPublicAPIRuntimeMetricsSlimmer as c };

package/dist/esm/{date-97fc22a5.js → date-732bc749.js}

@@ -1,4 +1,4 @@
-import { L as LogUtility } from './global-slimmer-registry-16fd7452.js';
+import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
 
 /**
  * It returns true if the input is a valid date string, and false otherwise

package/dist/esm/{deprecated-property-slimmer-4b33f760.js → deprecated-property-slimmer-43d184b3.js}

@@ -1,5 +1,5 @@
-import { V as VegaSlimmer } from './global-slimmer-registry-16fd7452.js';
-import { c as createDynamicSlimmer } from './dynamic-slimmer-ef83e258.js';
+import { V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { g as getValueByPath, d as deepEqual } from './object-261e7344.js';
 
 /** DeprecatedPropertySlimmer compares new property with default value, if they are different, return new property; otherwise, return old property */

package/dist/esm/{design-token-ee750507.js → design-token-abcaac42.js}

@@ -1,9 +1,9 @@
 import { i as isBorderColorTokenType, b as BorderColors, e as BorderColorMap, j as isShadowsTokenType, f as Shadows, g as ShadowMap, k as isBorderTokenType, l as Borders, m as BorderMap, n as isSpacingTokenType, o as isBorderRadiusTokenType, p as isBackgroundColorTokenType, q as isTextColorTokenType, r as isBreakpointsTokenType, h as Spacing, s as isBorderStyleType, B as BorderRadius, C as Colors, t as isTypographyTokenType } from './type-guard-4bc3fbf5.js';
 import { B as Breakpoints } from './breakpoints-e59edf8d.js';
-import { L as LogUtility } from './global-slimmer-registry-16fd7452.js';
-import { R as ResponsiveFormatFacade } from './responsive-format-facade-b96ca811.js';
+import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
+import { R as ResponsiveFormatFacade } from './responsive-format-facade-2fcb7c02.js';
 import { b as TypographyKeys } from './typography-a8fc4764.js';
-import { S as StateVariantFormatter, s as stateBackgroundColorFormatter } from './state-background-color-formatter-d758cb7b.js';
+import { S as StateVariantFormatter, s as stateBackgroundColorFormatter } from './state-background-color-formatter-0f86292d.js';
 import { a as BorderStyle } from './ui-df46cc20.js';
 
 /**

package/dist/esm/{dom-node-subject-observer-factory-4c0f1048.js → dom-node-subject-observer-factory-926991a9.js}

@@ -1,4 +1,4 @@
-import { C as ChangeManager } from './change-manager-8ddd9afe.js';
+import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 
 /**
  *  An Observer is a class that has a listener method that accepts a value of type T

package/dist/esm/{dynamic-slimmer-ef83e258.js → dynamic-slimmer-90b8af32.js}

@@ -1,4 +1,4 @@
-import { a as MapToComponentField, M as MapToComponentMethod } from './global-slimmer-registry-16fd7452.js';
+import { c as MapToComponentField, M as MapToComponentMethod } from './global-slimmer-registry-17c4efd4.js';
 
 /**
  * The `createDynamicSlimmer` function creates an instance of a dynamically generated class based on

package/dist/esm/{element-appender-slimmer-4b08a52e.js → element-appender-slimmer-f740e51a.js}

@@ -1,11 +1,11 @@
-import { L as LogUtility, a as MapToComponentField, I as InjectVegaSlimmer, V as VegaSlimmer, M as MapToComponentMethod } from './global-slimmer-registry-16fd7452.js';
+import { L as LogUtility, c as MapToComponentField, I as InjectVegaSlimmer, V as VegaSlimmer, M as MapToComponentMethod } from './global-slimmer-registry-17c4efd4.js';
 import { P as Placements, A as Alignments } from './ui-df46cc20.js';
 import { z as isTranslocationType } from './type-guard-4bc3fbf5.js';
-import { R as ResponsiveFormatFacade } from './responsive-format-facade-b96ca811.js';
-import { f as findParent, i as isElementVisible, c as isParent } from './ui-28499aab.js';
-import { Z as ZIndexManager } from './z-index-manager-7179cb75.js';
-import { c as createDynamicSlimmer } from './dynamic-slimmer-ef83e258.js';
-import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-e2e9f248.js';
+import { R as ResponsiveFormatFacade } from './responsive-format-facade-2fcb7c02.js';
+import { f as findParent, i as isElementVisible, c as isParent } from './ui-153f4ae7.js';
+import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-0553458e.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
+import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-8caeb03b.js';
 
 /**
  * Get the position of the element in the container according to the target element and the placement
@@ -703,7 +703,7 @@ class ElementAppender {
       return;
     this.toggleShow(false);
     this.resetContainerPosition();
-    ZIndexManager.removeZIndex(this.showConfig.appendableElement, 'base');
+    InternalVegaZIndexManager.removeZIndex(this.showConfig.appendableElement, 'base');
   }
   /* istanbul ignore next */
   /**
@@ -714,7 +714,7 @@ class ElementAppender {
     if (!this.showConfig)
       return;
     this.removeVisibleAppendElement(this.showConfig.appendableElement);
-    ZIndexManager.removeZIndex(this.showConfig.appendableElement, 'base');
+    InternalVegaZIndexManager.removeZIndex(this.showConfig.appendableElement, 'base');
     this.showConfig.appendableElement.remove();
     this.disconnectResizeObserver();
   }
@@ -891,7 +891,7 @@ class ElementAppender {
    * @returns {void}
    */
   setZIndex() {
-    ZIndexManager.setZIndex(this.showConfig.appendableElement, 'base');
+    InternalVegaZIndexManager.setZIndex(this.showConfig.appendableElement, 'base');
   }
   /**
    * If the showConfigCallback is a function, call it and return the result, otherwise return the

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

@@ -1,8 +1,8 @@
-import { a as MapToComponentField, V as VegaSlimmer, I as InjectVegaSlimmer } from './global-slimmer-registry-16fd7452.js';
-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 { c as MapToComponentField, V as VegaSlimmer, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
+import { C as ChangeManager } from './change-manager-6a7eb88c.js';
+import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-926991a9.js';
+import { j as jqueryDelegatedStrategyController, i as internalVegaEventManager } from './internal-vega-event-manager-a131803b.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-9be58397.js}

@@ -1,5 +1,5 @@
-import { L as LogUtility } from './global-slimmer-registry-16fd7452.js';
-import { V as VegaTelemetryRuntimeMetricsManager } from './index-dc8f8d91.js';
+import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
+import { V as VegaTelemetryRuntimeMetricsManager } from './index-0863eec6.js';
 
 /**
  * The concrete feature flag map that we are going to use to determine if a feature is enabled or not.
@@ -173,6 +173,11 @@ const FeatureFlagsMap = {
     createdAtVersion: '2.18.1',
     disabledByDefault: true,
   },
+  'VEGA_TELEMETRY.ENABLE_COLLECT_PUBLIC_API': {
+    description: `Feature flag to enable the collection of public api.`,
+    createdTimestamp: 1727232497961,
+    createdAtVersion: '2.21.0',
+  },
 };
 const FeatureFlagsMap$1 = Object.freeze(FeatureFlagsMap);
 

package/dist/esm/{form-field-controller-slimmer-b237bb58.js → form-field-controller-slimmer-9372f752.js}

@@ -1,15 +1,15 @@
-import { a as MapToComponentField, V as VegaSlimmer, I as InjectVegaSlimmer, M as MapToComponentMethod } from './global-slimmer-registry-16fd7452.js';
+import { c as MapToComponentField, V as VegaSlimmer, I as InjectVegaSlimmer, M as MapToComponentMethod } from './global-slimmer-registry-17c4efd4.js';
 import { c as camelToDashCase } from './string-be824360.js';
-import { C as ChangeManager } from './change-manager-8ddd9afe.js';
-import { d as domNodeSubjectFactory, O as Observer, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-4c0f1048.js';
+import { C as ChangeManager } from './change-manager-6a7eb88c.js';
+import { d as domNodeSubjectFactory, O as Observer, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-926991a9.js';
 import { c as FORM_FIELD_PENDING_VALID_CHANGE, d as FORM_FIELD_ELEMENT_DISCONNECTED, b as FORM_ELEMENT_VALUE_CHANGE, e as FORM_RESET_OPERATION_TRIGGERED, F as FORM_SUBMIT, f as FIELD_ERROR_MESSAGE_CHANGE, g as FORM_ELEMENT_VALIDATE } from './static-subject-title-2e153754.js';
-import { f as findParent, i as isElementVisible } from './ui-28499aab.js';
-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 { f as findParent, i as isElementVisible } from './ui-153f4ae7.js';
+import { a as isAsyncFunction, g as generateUUID } from './misc-9fdbcfbb.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
+import { V as VegaInternalFieldErrorStateChange, a as VegaInternalValid } from './vega-internal-event-id-c0904e43.js';
+import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-8caeb03b.js';
+import { M as MutationObserverSlimmer } from './mutation-observer-slimmer-6cef9549.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/{global-slimmer-registry-16fd7452.js → global-slimmer-registry-17c4efd4.js}

@@ -101,6 +101,7 @@ LogUtility.LOG_PREFIX_STYLE = 'font-weight: bold';
 const SlimmerMappedMethod = Symbol('ProcessorInternalCallback');
 const SlimmerConsumedBy = Symbol('SlimmerConsumedBy');
 const ConsumerSlimmers = Symbol('ConsumerSlimmers');
+const CurrentlyInvokedMethodName = Symbol('CurrentlyInvokedMethodName');
 
 /**
  * Decorator to map a slimmer field to a component field, which means:
@@ -279,4 +280,4 @@ class GlobalSlimmersRegistry {
 }
 GlobalSlimmersRegistry.globalSlimmers = [];
 
-export { ConsumerSlimmers as C, GlobalSlimmersRegistry as G, InjectVegaSlimmer as I, LogUtility$1 as L, MapToComponentMethod as M, VegaSlimmer as V, MapToComponentField as a, createGetterForVegaSlimmerField as b, createSetterForVegaSlimmerField as c, setVegaLogLevel as s };
+export { ConsumerSlimmers as C, GlobalSlimmersRegistry as G, InjectVegaSlimmer as I, LogUtility$1 as L, MapToComponentMethod as M, SlimmerConsumedBy as S, VegaSlimmer as V, SlimmerMappedMethod as a, CurrentlyInvokedMethodName as b, MapToComponentField as c, createSetterForVegaSlimmerField as d, createGetterForVegaSlimmerField as e, setVegaLogLevel as s };

package/dist/esm/icon-manager-754cda3f.js

@@ -0,0 +1,117 @@
+import './global-slimmer-registry-17c4efd4.js';
+import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer } from './create-public-api-runtime-metrics-slimmer-dc9af92b.js';
+
+const VegaIconManagerRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_REGISTER_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method register of public API IconManager is called',
+    /**
+     * Indicate whether the method is collected when the method been called .
+     *
+     * @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
+     */
+    canAccept: (scope, methodName) => scope === 'IconManager' && methodName === 'register',
+    /**
+     * The function checks if the method name is load.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_GETICON_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method getIcon of public API IconManager is called',
+    /**
+     * Indicate whether the method is collected when the method been called .
+     *
+     * @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
+     */
+    canAccept: (scope, methodName) => scope === 'IconManager' && methodName === 'getIcon',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_HASICON_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method hasIcon of public API IconManager is called',
+    /**
+     * Indicate whether the method is collected when the method been called .
+     *
+     * @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
+     */
+    canAccept: (scope, methodName) => scope === 'IconManager' && methodName === 'hasIcon',
+    /**
+     * The function checks if the method name is unLoadAll.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+];
+
+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;
+  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;
+};
+/**
+ * Internal icon manager controller.
+ */
+class IconManager {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(IconManager, ['register', 'getIcon', 'hasIcon'], VegaIconManagerRuntimeMetricsPayloadDefinition);
+    this.icons = new Map();
+  }
+  /**
+   * Registers the icons into the map.
+   *
+   * @param {Record<string, string>} icons - icon records
+   */
+  register(icons) {
+    for (const key in icons) {
+      if (!this.icons.has(key)) {
+        this.icons.set(key, icons[key]);
+      }
+    }
+  }
+  /**
+   * Get an internal icon by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {Nullable<string>} returns the icon svg or null if not found
+   */
+  getIcon(name) {
+    return this.icons.get(name);
+  }
+  /**
+   *  Check if the icon manager has an icon by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {boolean} returns true if the icon exists
+   */
+  hasIcon(name) {
+    return this.icons.has(name);
+  }
+}
+__decorate([
+  InjectVegaTelemetrySlimmer()
+], IconManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaIconManager = new IconManager();
+
+export { VegaIconManager as V };

package/dist/esm/{index-dc8f8d91.js → index-0863eec6.js}

@@ -866,6 +866,7 @@ var RuntimeMetricsPayloadTypeEnum;
 (function (RuntimeMetricsPayloadTypeEnum) {
     RuntimeMetricsPayloadTypeEnum["ComponentUsagePayload"] = "componentUsage";
     RuntimeMetricsPayloadTypeEnum["FeatureFlagOverriddenPayload"] = "featureFlagOverridden";
+    RuntimeMetricsPayloadTypeEnum["PublicAPIMetricsPayload"] = "publicAPIMetrics";
 })(RuntimeMetricsPayloadTypeEnum || (RuntimeMetricsPayloadTypeEnum = {}));
 var RuntimeMetricsTriggerEventEnum;
 (function (RuntimeMetricsTriggerEventEnum) {
@@ -876,6 +877,7 @@ var RuntimeMetricsTriggerEventEnum;
 var FeatureFlagKeyEnum;
 (function (FeatureFlagKeyEnum) {
     FeatureFlagKeyEnum["ENABLE_COLLECT_COMPONENTS_USAGE"] = "VEGA_TELEMETRY.ENABLE_COLLECT_COMPONENTS_USAGE";
+    FeatureFlagKeyEnum["ENABLE_COLLECT_PUBLIC_API"] = "VEGA_TELEMETRY.ENABLE_COLLECT_PUBLIC_API";
     FeatureFlagKeyEnum["ENABLE_COLLECT_FEATURE_FLAG_OVERRIDDEN"] = "VEGA_TELEMETRY.ENABLE_COLLECT_FEATURE_FLAG_OVERRIDDEN";
 })(FeatureFlagKeyEnum || (FeatureFlagKeyEnum = {}));
 
@@ -907,18 +909,24 @@ class MetricsDispatcher {
         return null;
     }
     filterRuntimeMetrics() {
+        return MetricsCollector$1.getRuntimeMetrics().filter((runtimeMetrics) => this.canDispatch(runtimeMetrics) &&
+            !MetricsDeDuplicator$1.checkByStrategies(runtimeMetrics));
+    }
+    canDispatch(runtimeMetrics) {
         const featureFlagController = MetricsDispatcherRegister$1.getFeatureFlagController();
-        if (featureFlagController) {
-            return MetricsCollector$1.getRuntimeMetrics().filter((runtimeMetrics) => {
-                const canDispatch = runtimeMetrics.payload.type ===
-                    RuntimeMetricsPayloadTypeEnum.ComponentUsagePayload
-                    ? featureFlagController.isEnabled(FeatureFlagKeyEnum.ENABLE_COLLECT_COMPONENTS_USAGE)
-                    : featureFlagController.isEnabled(FeatureFlagKeyEnum.ENABLE_COLLECT_FEATURE_FLAG_OVERRIDDEN);
-                return (canDispatch &&
-                    !MetricsDeDuplicator$1.checkByStrategies(runtimeMetrics));
-            });
+        if (!featureFlagController)
+            return false;
+        switch (runtimeMetrics.payload.type) {
+            case RuntimeMetricsPayloadTypeEnum.ComponentUsagePayload: {
+                return featureFlagController.isEnabled(FeatureFlagKeyEnum.ENABLE_COLLECT_COMPONENTS_USAGE);
+            }
+            case RuntimeMetricsPayloadTypeEnum.FeatureFlagOverriddenPayload: {
+                return featureFlagController.isEnabled(FeatureFlagKeyEnum.ENABLE_COLLECT_FEATURE_FLAG_OVERRIDDEN);
+            }
+            case RuntimeMetricsPayloadTypeEnum.PublicAPIMetricsPayload: {
+                return featureFlagController.isEnabled(FeatureFlagKeyEnum.ENABLE_COLLECT_PUBLIC_API);
+            }
         }
-        return [];
     }
 }
 const MetricsDispatcher$1 = new MetricsDispatcher();
@@ -953,6 +961,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 +983,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

@@ -1,30 +1,31 @@
 export { B as Breakpoints, g as getCurrentBreakpoint } from './breakpoints-e59edf8d.js';
-export { L as LogUtility, s as setVegaLogLevel } from './global-slimmer-registry-16fd7452.js';
-export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-ee750507.js';
+export { L as LogUtility, s as setVegaLogLevel } from './global-slimmer-registry-17c4efd4.js';
+export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-abcaac42.js';
 export { c as camelToDashCase } from './string-be824360.js';
 export { d as BackgroundColorMap, a as BackgroundColors, e as BorderColorMap, b as BorderColors, B as BorderRadius, C as Colors, F as FillBackgroundColors, g as ShadowMap, f as Shadows, h as Spacing, S as StrokeBackgroundColors, c as TextColorMap, T as TextColors } from './type-guard-4bc3fbf5.js';
 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 { V as VegaDialog } from './vega-dialog-controller-1f5923a6.js';
-export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-b0d04798.js';
-export { V as VegaIconManager } from './icon-manager-6ac84741.js';
+export { c as VegaEventManager, V as VegaLoader, a as VegaNotify, e as VegaSkeletonLoader, b as VegaThemeManager, d as VegaZIndexManager, w as waitForVega } from './vega-skeleton-loader-controller-7c490d69.js';
+export { F as FeatureFlag } from './feature-flag-controller-9be58397.js';
+export { V as VegaDialog } from './vega-dialog-controller-fb1a8e21.js';
+export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-a131803b.js';
+export { V as VegaIconManager } from './icon-manager-754cda3f.js';
 export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-232f2986.js';
-import './responsive-format-facade-b96ca811.js';
+import './responsive-format-facade-2fcb7c02.js';
 import './number-e2519d1c.js';
 import './pixel-f32c07ce.js';
-import './state-background-color-formatter-d758cb7b.js';
+import './state-background-color-formatter-0f86292d.js';
 import './regex-dfe11abf.js';
-import './misc-c21a85c9.js';
-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 './vega-event-id-13e22d1e.js';
+import './misc-9fdbcfbb.js';
+import './ui-153f4ae7.js';
+import './create-public-api-runtime-metrics-slimmer-dc9af92b.js';
+import './dynamic-slimmer-90b8af32.js';
+import './internal-vega-z-index-manager-0553458e.js';
+import './page-resize-observer-slimmer-8caeb03b.js';
+import './index-0863eec6.js';
+import './vega-event-id-783f8cfb.js';
 
 /* This file is generated by vega-design 2.0.77 */
 /* eslint-disable */

package/dist/esm/{inject-keyboard-manager-09215243.js → inject-keyboard-manager-d2a96e14.js}

@@ -1,4 +1,4 @@
-import { K as KeyboardManager } from './keyboard-manager-bf9284d2.js';
+import { K as KeyboardManager } from './keyboard-manager-477122e6.js';
 
 /**
  * It takes a function that returns an array of keyboard event listeners, and returns a decorator

package/dist/esm/{internal-icon-manager-ca269960.js → internal-icon-manager-ebe6ecf4.js}

@@ -1,4 +1,4 @@
-import { V as VegaIconManager } from './icon-manager-6ac84741.js';
+import { V as VegaIconManager } from './icon-manager-754cda3f.js';
 
 /**
  * Internal icon manager