@globalpayments/vega 2.33.0 → 2.34.0

package/dist/esm/block-annotation.abstract-b0554e2b.js

@@ -0,0 +1,868 @@
+import { I as InjectVegaTelemetrySlimmer, c as createPublicAPIRuntimeMetricsSlimmer, g as generateUUID } from './create-public-api-runtime-metrics-slimmer-14cb4599.js';
+import { a as arrayToClassString, g as getDeviceType, D as DeviceType } from './ui-5600b48f.js';
+import { L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-6887a59f.js';
+import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-89e8b6f5.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-85746483.js';
+import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-8589ebc8.js';
+import { i as internalVegaEventManager } from './internal-vega-event-manager-3a3815d3.js';
+import { A as Annotation } from './node.abstract-93746055.js';
+
+const VegaLoaderRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_LOAD_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method load of public API VegaLoaderController 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 === 'VegaLoaderController' && methodName === 'load',
+    /**
+     * The function checks if the method name is load.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_CLOSE_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method close of public API VegaLoaderController 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 === 'VegaLoaderController' && methodName === 'close',
+    /**
+     * The function checks if the method name is close.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+];
+
+var __decorate$4 = (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;
+};
+/**
+ * Vega loader controller to control the loading indicator
+ */
+class VegaLoaderController {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaLoaderController, ['load', 'close'], VegaLoaderRuntimeMetricsPayloadDefinition);
+  }
+  /**
+   * Create a loading indicator and append it to the container
+   *
+   * @param {VegaLoaderIndicatorOptions} options - VegaLoaderOptions = {} options of the method
+   * @returns {string} The uuid of the loader.
+   * @vegaVersion 1.16.0
+   */
+  load(options = {}) {
+    const containerSelector = options.containerSelector || 'body';
+    const containerElement = document.querySelector(containerSelector);
+    if (!containerElement) {
+      LogUtility.error('Container is not found by selector: ', containerSelector);
+      return null;
+    }
+    const loadingIndicator = this.createLoadingIndicator(options.indicatorOptions);
+    const loader = this.createLoader(containerSelector);
+    loader.append(loadingIndicator);
+    return this.appendLoader(loader, containerElement);
+  }
+  /**
+   * Close the loader by id
+   *
+   * @param {string} id - The id of the loader.
+   * @vegaVersion 1.16.0
+   */
+  close(id) {
+    const loader = this.findLoader(id);
+    if (loader) {
+      if (loader.dataset.container) {
+        const container = document.querySelector(loader.dataset.container);
+        if (container) {
+          container.style.position = container.dataset['vegaLoaderOriginPosition'] || 'static';
+        }
+      }
+      loader.remove();
+    }
+  }
+  /**
+   * Find loader by id, if the id include '>>>' it will find inside shadowRoot
+   *
+   * @param {string} id - The id of the loader.
+   * @returns {string} The loader found by id.
+   */
+  findLoader(id) {
+    var _a, _b;
+    let loader;
+    if (id.includes('>>>')) {
+      const [containerSelector, loaderSelector] = id.split('>>>');
+      loader = (_b = (_a = document.querySelector(containerSelector)) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.getElementById(loaderSelector);
+    }
+    else {
+      loader = document.getElementById(id);
+    }
+    return loader;
+  }
+  /**
+   * Create a loader for loading indicator
+   *
+   * @param {string} containerSelector The container which you want to append
+   * @returns {HTMLElement} a wrapper for loader
+   */
+  createLoader(containerSelector) {
+    const loader = document.createElement('vega-loader-wrapper');
+    loader.className = arrayToClassString([
+      containerSelector === 'body' ? 'fixed-wrapper' : 'absolute-wrapper',
+    ]);
+    loader.dataset['container'] = containerSelector;
+    loader.id = `vega-loader-${generateUUID()}`;
+    return loader;
+  }
+  /**
+   * Create a loading indicator
+   *
+   * @param {VegaLoaderIndicatorOptions} indicatorOptions the props of vega loading indicator
+   * @returns {HTMLElement} vega-loading-indicator component template
+   */
+  createLoadingIndicator(indicatorOptions = {}) {
+    const loadingIndicator = document.createElement('vega-loading-indicator');
+    Object.assign(loadingIndicator, indicatorOptions);
+    return loadingIndicator;
+  }
+  /**
+   * Append the loader to the container
+   *
+   * @param {HTMLElement} loader A loader with loading indicator
+   * @param {string} containerElement The container which you want to append the loader to
+   * @returns {string} The uuid of the loader.
+   */
+  appendLoader(loader, containerElement) {
+    containerElement.dataset['vegaLoaderOriginPosition'] = containerElement.style.position;
+    containerElement.style.position = 'relative';
+    if (containerElement.shadowRoot) {
+      containerElement.shadowRoot.append(loader);
+      return `${loader.dataset['container']}>>>${loader.id}`;
+    }
+    else {
+      containerElement.append(loader);
+      return loader.id;
+    }
+  }
+}
+__decorate$4([
+  InjectVegaTelemetrySlimmer()
+], VegaLoaderController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaLoader = new VegaLoaderController();
+
+const VegaNotifyRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_OPEN_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method open of public API VegaNotifyController 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 === 'VegaNotifyController' && methodName === 'open',
+    /**
+     * The function checks if the method name is open.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_CLOSE_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method close of public API VegaNotifyController 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 === 'VegaNotifyController' && methodName === 'close',
+    /**
+     * The function checks if the method name is close.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_CLOSEALL_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method closeAll of public API VegaNotifyController 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 === 'VegaNotifyController' && methodName === 'closeAll',
+    /**
+     * The function checks if the method name is closeAll.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+];
+
+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;
+  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;
+};
+/**
+ * The page notification controller
+ */
+class VegaNotifyController {
+  constructor() {
+    this.resizeObserverSlimmer = createDynamicSlimmer(VegaNotifyController, PageResizeObserverSlimmer, [], [{ mapFrom: 'connectResizeObserver', mapTo: 'connectResizeObserver' }], [
+      {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        callback: (entries) => {
+          var _a;
+          const currentVisible = entries[0].contentRect.height > 0;
+          if (!currentVisible && ((_a = this.container) === null || _a === void 0 ? void 0 : _a.classList.contains('hydrated'))) {
+            InternalVegaZIndexManager.removeZIndex(this.container, 'top');
+            this.container.remove();
+            this.container = null;
+          }
+        },
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        target: () => this.container,
+      },
+    ]);
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaNotifyController, ['open', 'close', 'closeAll'], VegaNotifyRuntimeMetricsPayloadDefinition);
+  }
+  /**
+   * It creates a new notification element, adds it to the container, and returns the notification's ID
+   *
+   * @param {VegaNotifyOption} options - VegaNotifyProps
+   * @returns {string} The ID of the notification.
+   * @vegaVersion 1.17.0
+   */
+  async open(options) {
+    const pageNotification = this.createPageNotification(options);
+    this.getContainer().append(pageNotification);
+    return pageNotification.id;
+  }
+  /**
+   * It closes all notifications
+   *
+   * @vegaVersion 1.17.0
+   */
+  async closeAll() {
+    this.container &&
+      Array.from(this.container.children).forEach((item) => {
+        void item.close();
+      });
+  }
+  /**
+   * It closes the notification with the given id
+   *
+   * @param {string} id - The id of the notification to close.
+   * @vegaVersion 1.17.0
+   */
+  async close(id) {
+    await document.getElementById(id).close();
+  }
+  /**
+   * The function "connectResizeObserver" is used to connect a resize observer.
+   *
+   * @vegaVersion 1.17.0
+   */
+  connectResizeObserver() {
+  }
+  /**
+   * It creates a new page notification element, sets its properties, and returns it
+   *
+   * @param {VegaNotifyOption} props - VegaNotifyProps - the properties of the notification
+   * @returns {HTMLElement} A function that takes in a props object and returns a pageNotification element.
+   */
+  createPageNotification(props) {
+    const pageNotification = document.createElement('vega-page-notification');
+    Object.keys(props).forEach((propName) => {
+      props[propName] !== undefined && (pageNotification[propName] = props[propName]);
+    });
+    pageNotification.style.marginBottom = getDeviceType() === DeviceType.MOBILE ? '12px' : '16px';
+    pageNotification.id = `vega-page-notification-${generateUUID()}`;
+    return pageNotification;
+  }
+  /**
+   * It creates a div element, sets its z-index to be on top of everything else, adds a class to it, and
+   * then adds it to the body of the page
+   *
+   * @returns {HTMLElement} The container is being returned.
+   */
+  getContainer() {
+    if (this.container) {
+      return this.container;
+    }
+    this.container = document.createElement('vega-page-notification-list');
+    InternalVegaZIndexManager.setZIndex(this.container, 'top');
+    if (getDeviceType() === DeviceType.MOBILE) {
+      this.container.classList.add('vega-page-notification-list-bottom');
+    }
+    else {
+      this.container.classList.add('vega-page-notification-list-topRight');
+    }
+    document.body.append(this.container);
+    this.connectResizeObserver();
+    return this.container;
+  }
+}
+__decorate$3([
+  InjectVegaSlimmer()
+], VegaNotifyController.prototype, "resizeObserverSlimmer", void 0);
+__decorate$3([
+  InjectVegaTelemetrySlimmer()
+], VegaNotifyController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaNotify = new VegaNotifyController();
+
+/* istanbul ignore next */
+const VegaEventManagerRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_SETSEMANTICS_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method setSemantics of public API VegaEventManager 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_GETSEMANTICS_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method getSemantics of public API VegaEventManager 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 === 'VegaEventManager' && methodName === 'getSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_GETENABLEDEVENTIDSBYCOMPONENT_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method getEnabledEventIdsByComponent of public API VegaEventManager 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 === 'VegaEventManager' && methodName === 'getEnabledEventIdsByComponent',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'globalEventIsNative',
+    payloadDescription: 'Indicate if the vega components will emit events without the vega prefix',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      return !!(config.global && config.global.namespace === 'native');
+    },
+  },
+  {
+    payloadKey: 'eventOfSpecificComponentsIsNative',
+    payloadDescription: 'Indicate if the vega components will emit events with the vega prefix, but special components will emit events without vega prefix',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      if (config.components) {
+        const specialComponents = Object.keys(config.components);
+        return !!(specialComponents.length > 0 &&
+          config.components[specialComponents[0]].namespace === 'native');
+      }
+      return false;
+    },
+  },
+  {
+    payloadKey: 'eventOfSpecificComponentsIsVega',
+    payloadDescription: 'Indicate if the vega components will emit events without the vega prefix, but special components will emit events with vega prefix',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      if (config.global && config.components) {
+        const specialComponents = Object.keys(config.components);
+        return !!(config.global.namespace === 'native' &&
+          specialComponents.length > 0 &&
+          config.components[specialComponents[0]].namespace === 'vega');
+      }
+      return false;
+    },
+  },
+  {
+    payloadKey: 'globalJqueryDelegatedEventIsTrue',
+    payloadDescription: 'Indicate if the use jQuery with event delegation',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      return !!(config.global && config.global.jqueryDelegatedEvent === true);
+    },
+  },
+  {
+    payloadKey: 'jqueryDelegatedEventIsCustomStrategy',
+    payloadDescription: 'Indicate if the use jQuery with event delegation',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      return !!(config.global &&
+        Array.isArray(config.global.jqueryDelegatedEvent) &&
+        config.global.jqueryDelegatedEvent.length > 0);
+    },
+  },
+  {
+    payloadKey: 'jqueryDelegatedEventOfSpecialComponentsIsTrue',
+    payloadDescription: 'Indicate if the use jQuery with event delegation',
+    /**
+     * 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 === 'VegaEventManager' && methodName === 'setSemantics',
+    /**
+     * The function checks if the method is been called.
+     *
+     * @param {unknown[]} args - The args parameter is an object
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      const config = args;
+      if (config.components) {
+        const specialComponents = Object.keys(config.components);
+        return !!(specialComponents.length > 0 &&
+          config.components[specialComponents[0]].jqueryDelegatedEvent === true);
+      }
+      return false;
+    },
+  },
+];
+
+var __decorate$2 = (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;
+};
+/**
+ * The VegaEventManager class provides methods for setting and retrieving event semantics configuration,
+ * as well as getting the corresponding native event name for a given event.
+ */
+class VegaEventManager {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaEventManager, ['setSemantics', 'getSemantics', 'getEnabledEventIdsByComponent'], VegaEventManagerRuntimeMetricsPayloadDefinition);
+  }
+  /**
+   * The function sets the semantics configuration for event management.
+   *
+   * @param {EventSemanticsConfig} config - The config parameter is an object that contains the
+   * configuration settings for the event semantics. It may include properties such as the event type,
+   * event source, event target, event data, and any other relevant information for setting up the
+   * semantics of the event.
+   * @vegaVersion 2.0.0
+   */
+  setSemantics(config) {
+    internalVegaEventManager.setSemantics(config);
+  }
+  /**
+   * The function "getSemantics" returns the event semantics of an HTML element.
+   *
+   * @param {HTMLElement} host - The host parameter is an HTMLElement, which represents an HTML element
+   * in the DOM (Document Object Model). It can be any valid HTML element such as a div, span, button,
+   * etc.
+   * @returns {EventSemantics} an object of type EventSemantics.
+   * @vegaVersion 2.0.0
+   */
+  getSemantics(host) {
+    return internalVegaEventManager.getSemantics(host);
+  }
+  /**
+   * The function "getEnabledEventIdsByComponent" returns the all eventIds in component.
+   *
+   * @param {VegaComponentName} componentName - The component name,
+   * etc.
+   * @returns {Nullable<VegaEventID[]>} All eventIds.
+   * @vegaVersion 2.0.0
+   */
+  getEnabledEventIdsByComponent(componentName) {
+    return internalVegaEventManager.getEnabledEventIdsByComponent(componentName);
+  }
+}
+__decorate$2([
+  InjectVegaTelemetrySlimmer()
+], VegaEventManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaEventManager$1 = new VegaEventManager();
+
+const ZIndexManagerRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_OVERRIDEZINDEXBASICVALUES_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method overrideZIndexBasicValues of public API ZIndexManager 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 === 'VegaZIndexManager' && methodName === 'overrideZIndexBasicValues',
+    /**
+     * The function checks if the method name is load.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'zIndexBasicValuesGreatThanTenThousand',
+    payloadDescription: 'Indicate if the basic z-index value is great than ten thousand',
+    /**
+     * 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 === 'VegaZIndexManager' && methodName === 'overrideZIndexBasicValues',
+    /**
+     * The function checks if the method name is load.
+     *
+     * @param {unknown[]} args - The parameter of slimmer method
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: (args) => {
+      return args['base'] > 10000;
+    },
+  },
+];
+
+var __decorate$1 = (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;
+};
+/**
+ * The VegaZIndexManager class calls a method in the ZIndexManager class to
+ * change z-index values based on the input.
+ */
+class VegaZIndexManager {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaZIndexManager, ['overrideZIndexBasicValues'], ZIndexManagerRuntimeMetricsPayloadDefinition);
+  }
+  /**
+   * The function "overrideZIndexBasicValues" calls a method in the "ZIndexManager" class to change the
+   * z-index values based on the input.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is of type ZIndexBasicValues.
+   * @vegaVersion 2.3.0
+   */
+  overrideZIndexBasicValues(input) {
+    InternalVegaZIndexManager.overrideZIndexBasicValues(input);
+  }
+}
+__decorate$1([
+  InjectVegaTelemetrySlimmer()
+], VegaZIndexManager.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaZIndexManager$1 = new VegaZIndexManager();
+
+const VegaSkeletonRuntimeMetricsPayloadDefinition = [
+  {
+    payloadKey: 'IS_LOAD_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method load of public API VegaSkeletonLoaderController 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 === 'VegaSkeletonLoaderController' && methodName === 'load',
+    /**
+     * The function checks if the method name is load.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_UNLOAD_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method unLoad of public API VegaSkeletonLoaderController 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 === 'VegaSkeletonLoaderController' && methodName === 'unLoad',
+    /**
+     * The function checks if the method name is unLoad.
+     *
+     * @returns {boolean} A boolean value
+     */
+    payloadValue: () => {
+      return true;
+    },
+  },
+  {
+    payloadKey: 'IS_UNLOADALL_METHOD_CALLED',
+    payloadDescription: 'Indicate if the method unLoadAll of public API VegaSkeletonLoaderController 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 === 'VegaSkeletonLoaderController' && methodName === 'unLoadAll',
+    /**
+     * 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;
+};
+/**
+ * Vega Skeleton Loader Controller to show skeletons in the target elements
+ */
+class VegaSkeletonLoaderController {
+  constructor() {
+    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(VegaSkeletonLoaderController, ['load', 'unLoad', 'unLoadAll'], VegaSkeletonRuntimeMetricsPayloadDefinition);
+    this.loaderMap = new Map();
+  }
+  /**
+   * Load the skeletons in the target elements
+   *
+   * @param { VegaSkeletonLoaderConfig } config - Configuration for the loading function
+   * @param {string} config.target - Target elements to show the skeletons.
+   * @param {VegaSkeletonLoaderConfig.type} [config.type = 'text'] - Type of the skeleton.
+   * @param {VegaSkeletonLoaderConfig.width} config.width - Width of the skeleton.
+   * @param {VegaSkeletonLoaderConfig.height} config.height - Height of the skeleton.
+   * @param {VegaSkeletonLoaderConfig.items} config.items - Configuration for multiple skeleton items.
+   * @param {VegaSkeletonLoaderConfig.layout} config.layout - Layout of the skeleton items.
+   * @returns { string } - Key of the loaded skeleton items.
+   * @vegaVersion 2.16.0
+   */
+  load({ target, type = 'text', width, height, items, layout }) {
+    const targets = Array.from(document.body.querySelectorAll(target));
+    const key = `vega-skeleton-loader-${generateUUID()}`;
+    const loaderItems = [];
+    targets.forEach((target) => {
+      const skeletonsLoaders = !items
+        ? [this.createSkeleton({ type, width, height })]
+        : items.map(this.createSkeleton);
+      const itemsWithKey = (layout ? [this.wrapLayout(skeletonsLoaders, layout)] : skeletonsLoaders).map((item) => {
+        item.dataset[VegaSkeletonLoaderController.LOADER_DATA_SET_KEY] = key;
+        return item;
+      });
+      loaderItems.push(...itemsWithKey);
+      target.append(...itemsWithKey);
+    });
+    this.loaderMap.set(key, loaderItems);
+    return key;
+  }
+  /**
+   * Remove the skeletons from the dom.
+   *
+   * @param {string} key - The key returned from {@link VegaSkeletonLoaderController.load}.
+   * @vegaVersion 2.16.0
+   */
+  unLoad(key) {
+    if (this.loaderMap.has(key)) {
+      this.loaderMap.get(key).forEach((item) => item.remove());
+      this.loaderMap.delete(key);
+    }
+  }
+  /**
+   * Remove all the skeletons from the dom.
+   *
+   * @vegaVersion 2.16.0
+   */
+  unLoadAll() {
+    for (const items of this.loaderMap.values()) {
+      items.forEach((item) => item.remove());
+    }
+    this.loaderMap.clear();
+  }
+  /**
+   * Create a skeleton item. The skeleton animated always be true
+   *
+   * @param {VegaSkeletonLoaderItem} config - Configuration for the skeleton item.
+   * @returns {HTMLElement} - Skeleton item.
+   */
+  createSkeleton(config) {
+    const { type, width, height } = config;
+    const skeleton = document.createElement('vega-skeleton');
+    Object.assign(skeleton, { animated: true, type, width, height });
+    return skeleton;
+  }
+  /**
+   * Wrap the flex layout for the skeletons.
+   *
+   * @param {HTMLElement[]} skeletons - Skeleton elements of the loader.
+   * @param {VegaSkeletonLoaderLayout} layout - Flex properties for the layout.
+   * @returns {HTMLElement} - Container wrapping the skeletons in the specified flex layout.
+   */
+  wrapLayout(skeletons, layout) {
+    const skeletonContainer = document.createElement('vega-flex');
+    Object.assign(skeletonContainer, Object.assign({ className: 'vega-skeleton-loader-template-container' }, layout.props));
+    Object.assign(skeletonContainer.style, layout.style);
+    skeletonContainer.append(...skeletons);
+    return skeletonContainer;
+  }
+}
+VegaSkeletonLoaderController.LOADER_DATA_SET_KEY = 'vegaSkeletonLoaderKey';
+__decorate([
+  InjectVegaTelemetrySlimmer()
+], VegaSkeletonLoaderController.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+const VegaSkeletonLoader = new VegaSkeletonLoaderController();
+
+var BlockAnnotationTypeEnum;
+(function (BlockAnnotationTypeEnum) {
+  BlockAnnotationTypeEnum["ALIGNMENT"] = "ALIGNMENT";
+  BlockAnnotationTypeEnum["TEXT_STYLE"] = "TEXT_STYLE";
+  BlockAnnotationTypeEnum["INDENT"] = "INDENT";
+})(BlockAnnotationTypeEnum || (BlockAnnotationTypeEnum = {}));
+/**
+ * BlockAnnotation is an abstract class that represents a block annotation.
+ */
+class BlockAnnotation extends Annotation {
+}
+
+export { BlockAnnotation as B, VegaLoader as V, VegaNotify as a, VegaEventManager$1 as b, VegaZIndexManager$1 as c, VegaSkeletonLoader as d, BlockAnnotationTypeEnum as e };