@globalpayments/vega 2.18.1 → 2.20.0

package/dist/types/helpers/chart/renderers/canvasRenderer.d.ts

@@ -1,137 +0,0 @@
-import { ChartPosition, ChartExtend, ArcPathItem } from '../../../types/vegaChart';
-import { BaseRenderer } from './baseRenderer';
-/**
- * The CanvasRenderer class is a TypeScript class that extends the BaseRenderer class and provides
- * methods for drawing various shapes and elements on a canvas.
- */
-export declare class CanvasRenderer extends BaseRenderer<HTMLCanvasElement> {
-  /**
-   *  This property will hold the rendering context of the canvas element on which the shapes and elements will be drawn
-   */
-  protected context: HTMLCanvasElement;
-  /**
-   * declaring a private instance variable `canvasContext2d` of type `CanvasRenderingContext2D`.
-   */
-  private canvasContext2d;
-  /**
-   * The function sets the layout of a chart.
-   *
-   * @param {number} width - chart width
-   * @param {number} height - chart height
-   */
-  setLayout(width: number, height: number): void;
-  /**
-   * The function `drawLine` takes two `ChartPosition` parameters and draws a line between them.
-   *
-   * @param {ChartPosition} from - The starting position of the line on the chart. It is of type ChartPosition.
-   * @param {ChartPosition} to - The "to" parameter in the "drawLine" function is a ChartPosition object
-   * that represents the end point of the line to be drawn. It contains information about the x and y
-   * coordinates of the point on the chart where the line should end.
-   */
-  drawLine(from: ChartPosition, to: ChartPosition): void;
-  /**
-   * This function draws the X-axis on a chart and takes in a parameter of type ChartExtend.
-   *
-   * @param {ChartExtend<unknown>} extend - The parameter "extend" is of type "ChartExtend" which is a generic type that can
-   * take any data type as an argument. It is likely used to extend or modify the properties of the chart's X-axis
-   */
-  drawXAxis(extend: ChartExtend<unknown>): void;
-  /**
-   * This function draws the Y-axis on a chart.
-   *
-   * @param {ChartExtend<unknown>} extend - The parameter "extend" is of type ChartExtend, which is a generic type that
-   * represents the range of values for a chart axis. It contains information such as the minimum and
-   * maximum values for the axis
-   */
-  drawYAxis(extend: ChartExtend<unknown>): void;
-  /**
-   * The function `drawCircle` takes in a center position, radius, and color and draws a circle.
-   *
-   * @param {ChartPosition} center - The center of the circle, represented by a ChartPosition object
-   * that contains the x and y coordinates of the center point.
-   * @param {number} radius - The _radius parameter is a number that represents the radius of the
-   * circle to be drawn. The radius is the distance from the center of the circle to any point on its circumference.
-   * @param {string} fillColor - The _color,
-   * which is a type that represents a color value that can be used as a background color for a chart element
-   * @param {number} strokeWidth - the border width
-   * @param {string} strokeColor - the border color
-   */
-  drawCircle(center: ChartPosition, radius: number, fillColor: string, strokeWidth?: number, strokeColor?: string): void;
-  /**
-   * The function draws a legend on a chart with a circle and text at a specified position and color.
-   *
-   * @param {ChartPosition} position - ChartPosition is a type that represents the position of an
-   * element on a chart. It could be an object with properties like x and y coordinates or a string that
-   * represents a predefined position.
-   * @param {string} text - The text parameter is a string that represents the label or name of the
-   * legend that will be displayed on the chart.
-   * @param {string} color - color string
-   * represents a color for the legend. It could be a string or a number that corresponds to a specific
-   * color value.
-   * @returns {HTMLCanvasElement} chart canvas element
-   */
-  drawLegend(position: ChartPosition, text: string, color: string): HTMLCanvasElement;
-  /**
-   * The function `drawText` takes a position and a string of text as parameters and does not return anything.
-   *
-   * @param {ChartPosition} position - ChartPosition is a data type that represents the position of the
-   * text on a chart. It could be an object with properties such as x and y coordinates, or it could be
-   * a string that represents a pre-defined position on the chart (e.g. "top-left", "bottom-right",
-   * etc.).
-   * @param {string} text - The text parameter is a string that represents the text that needs to be drawn on the chart.
-   */
-  drawText(position: ChartPosition, text: string): void;
-  /**
-   * The function `drawRect` takes in a position, width, height, and optional color parameter to draw a rectangle.
-   *
-   * @param {ChartPosition} position - The position parameter is of type ChartPosition and represents
-   * the position of the rectangle on the chart. It could be an object with x and y properties
-   * representing the coordinates of the top-left corner of the rectangle.
-   * @param {number} width - The width parameter is a number that represents the width of the rectangle
-   * to be drawn. It determines how wide the rectangle will be on the chart.
-   * @param {number} height - The `height` parameter in the `drawRect` function specifies the height of
-   * the rectangle to be drawn. It is a required parameter and must be a number value.
-   * @param {string} [color] - The color parameter is an optional parameter that
-   * specifies the background color of the rectangle. It is of type string, which is
-   * a custom type that represents a color token
-   */
-  drawRect(position: ChartPosition, width: number, height: number, color: string): void;
-  /**
-   * The function `drawLinePath` takes in an array of `ChartPosition` objects and a `string` color and draws a path.
-   *
-   * @param {ChartPosition[]} positions - An array of ChartPosition objects that represent the
-   * coordinates of points on a chart. Each ChartPosition object has an x and y property that represent
-   * the horizontal and vertical position of the point on the chart.
-   * @param {string} color - The `color` parameter is of type
-   * `string` and represents the color of the path to be drawn. This parameter is
-   * used to set the background color of the chart.
-   */
-  drawLinePath(positions: ChartPosition[], color: string): void;
-  /**
-   * This function draws an arc path using D3 library and applies color and radius based on input parameters.
-   *
-   * @param {ChartPosition} center - arc center position
-   * @param {ArcPathItem} record - an object containing data for the arc path to be drawn
-   * @param {string} color - The color parameter
-   * and is used to set the fill color of the arc path.
-   * @param {number} outerRadius - The outer radius parameter is a number that determines the outer
-   * radius of the arc path being drawn.
-   * @param {number} innerRadius - The inner radius of the arc path, specified as a number.
-   * @returns {HTMLCanvasElement} chart canvas element.
-   */
-  drawArcPath(center: ChartPosition, record: ArcPathItem, color: string, outerRadius: number, innerRadius: number): HTMLCanvasElement;
-  /**
-   * The function "clear"
-   */
-  clear(): void;
-  /**
-   * This function initializes a 2D canvas context.
-   */
-  private initCanvasContext2d;
-  /**
-   * This function returns the canvas 2D rendering context and initializes it if it doesn't exist.
-   *
-   * @returns {CanvasRenderingContext2D} The function `getContext2d()` returns the `CanvasRenderingContext2D` object.
-   */
-  private getContext2d;
-}

package/dist/types/helpers/chart/renderers/rendererFactory.d.ts

@@ -1,14 +0,0 @@
-import { BaseRenderer } from './baseRenderer';
-/** The RendererFactory class provides a static method to create a renderer based on the type of context provided. */
-export declare class RendererFactory {
-  /**
-   * This function returns a renderer based on the type of context provided (SVG or Canvas).
-   *
-   * @param {SVGElement | HTMLCanvasElement} context - The `context` parameter is either an
-   * SVGElement or a HTMLCanvasElement. It is used to determine which renderer to instantiate and
-   * return
-   * @returns {BaseRenderer<SVGElement | HTMLCanvasElement> } based on the type of the `context` parameter. If
-   * the `context` is an instance of `SVGElement`, an `SVGRenderer` object is returned
-   */
-  static get(context: SVGElement | HTMLCanvasElement): BaseRenderer<SVGElement | HTMLCanvasElement>;
-}

package/dist/types/helpers/chart/renderers/svgRenderer.d.ts

@@ -1,144 +0,0 @@
-import { ChartPosition, ChartExtend, ArcPathItem, TextAnchorType } from '../../../types/vegaChart';
-import { BaseRenderer } from './baseRenderer';
-import { Selection } from '../../../types/vegaChart';
-export declare type SVGSelection = Selection<SVGElement, unknown, Element, unknown>;
-export declare type SVGGSelection = Selection<SVGGElement, unknown, Element, unknown>;
-/**  This class is used to render charts using SVG elements. */
-export declare class SVGRenderer extends BaseRenderer<SVGElement> {
-  /** This property is used to store a reference to the SVG element that will be used to render the chart*/
-  protected context: SVGElement;
-  /**
-   * The function sets the layout of a chart using D3 and SVG.
-   *
-   * @param {number} width - chart width
-   * @param {number} height - chart height
-   * @param {number} top - chart margin top
-   * @param {number} left - chart margin left
-   */
-  setLayout(width: number, height: number, top: number, left: number): void;
-  /**
-   * This function draws a line on a chart using D3.js library.
-   *
-   * @param {ChartPosition} from - The starting position of the line to be drawn on the chart. It is an
-   * object with two properties: x and y, representing the x and y coordinates of the starting point respectively.
-   * @param {ChartPosition} to - The "to" parameter is a ChartPosition object that represents the ending
-   * point of the line to be drawn. It contains the x and y coordinates of the point on the chart where the line should end.
-   * @param {string} color - The color of the line
-   */
-  drawLine(from: ChartPosition, to: ChartPosition, color: string): void;
-  /**
-   * This function draws an x-axis on a chart using D3 and a given scale and end point.
-   *
-   * @param {ChartExtend<unknown>} extend - which is an object that contains information about the chart's scale and end position on the y-axis. The `scale` property
-   * is a D3 scale object that maps data values to pixel positions on the x-axis
-   * @param {string} color - The stroke color of axis
-   * @param {string} textStyle - The text style of the axis
-   */
-  drawXAxis(extend: ChartExtend<unknown>, color: string, textStyle: string): void;
-  /**
-   * This function draws the Y-axis of a chart using D3 and a given scale.
-   *
-   * @param {ChartExtend<unknown>} extend -  It likely contains additional information or settings related to the chart being drawn, but without more context it's
-   * difficult to say exactly what it contains.
-   * @param {string} color - The stroke color of the axis
-   * @param {string} textStyle - The text style of the axis
-   */
-  drawYAxis(extend: ChartExtend<unknown>, color: string, textStyle: string): void;
-  /**
-   * This function draws a circle with a given center, radius, and color using D3.js.
-   *
-   * @param {ChartPosition} center - ChartPosition, which is an object containing the x and y coordinates of the center of the circle.
-   * @param {number} radius - The radius parameter is a number that specifies the radius of the circle to be drawn.
-   * @param {string} fillColor - The color parameter is a string that represents the color of the circle to be drawn
-   * @param {number} strokeWidth - the border width
-   * @param {string} strokeColor - the border color
-   */
-  drawCircle(center: ChartPosition, radius: number, fillColor: string, strokeWidth?: number, strokeColor?: string): void;
-  /**
-   * This function draws text on a chart at a specified position using D3.js.
-   *
-   * @param {ChartPosition} position - ChartPosition is an object that contains the x and y coordinates where the text will be positioned on the chart.
-   * @param {string} text - The text parameter is a string that represents the text that will be
-   * displayed on the chart. It is the content that will be added to the text element created by this function.
-   * @param {string} textStyle - The text style of the axis
-   * @param {TextAnchorType} textAnchor - text anchor
-   * @param {number} rotate - rotate of the text
-   */
-  drawText(position: ChartPosition, text: string, textStyle: string, textAnchor?: TextAnchorType, rotate?: number): void;
-  /**
-   * This function draws a legend item with a colored circle and text at a specified position on a chart.
-   *
-   * @param {ChartPosition} position - The position parameter is an object that contains the x and y
-   * coordinates where the legend should be placed on the chart.
-   * @param {string} text - The text to be displayed in the legend.
-   * @param {string} color - Background color token type, which is a type of color
-   * used in the chart's background.
-   * @param {string} textStyle - The text style of the axis
-   * @returns {SVGGElement} svg g element
-   */
-  drawLegend(position: ChartPosition, text: string, color: string, textStyle: string): SVGGElement;
-  /**
-   * This function draws a rectangle with a specified position, width, height, and optional color using D3.js.
-   *
-   * @param {ChartPosition} position - The position parameter is an object that contains the x and y coordinates of the top-left corner of the rectangle.
-   * @param {number} width - The width of the rectangle to be drawn.
-   * @param {number} height - The height parameter is a number that represents the height of the rectangle to be drawn.
-   * @param {string} [color] - The color parameter is an optional string that represents the color of the rectangle to be drawn. If it is not provided, the rectangle will have no fill color.
-   */
-  drawRect(position: ChartPosition, width: number, height: number, color: string): void;
-  /**
-   * This function draws a path on a chart using D3 and SVG based on the provided positions and color.
-   *
-   * @param {ChartPosition[]} positions - An array of ChartPosition objects that represent the
-   * coordinates of the points on the path to be drawn. Each ChartPosition object contains an x and y
-   * value that represent the position of the point on the chart.
-   * @param {string} color - line color
-   * represents a color value. It is likely used to specify the color of the path that will be drawn on the chart.
-   */
-  drawLinePath(positions: ChartPosition[], color: string): void;
-  /**
-   * This function draws an arc path using D3 library and applies color and radius based on input parameters.
-   *
-   * @param {ChartPosition} center - the arc center position
-   * @param {ArcPathItem} record - an object containing data for the arc path to be drawn
-   * @param {string} color - The color parameter
-   * and is used to set the fill color of the arc path.
-   * @param {number} outerRadius - The outer radius parameter is a number that determines the outer
-   * radius of the arc path being drawn.
-   * @param {number} innerRadius - The inner radius of the arc path, specified as a number.
-   * @returns {SVGPathElement} svg arc path element.
-   */
-  drawArcPath(center: ChartPosition, record: ArcPathItem, color: string, outerRadius: number, innerRadius: number): SVGPathElement;
-  /**
-   * This function clears all elements within two specific classes in a D3 selection.
-   */
-  clear(): void;
-  /**
-   * This TypeScript function creates and returns an SVG text element with the given position and text.
-   *
-   * @param {ChartPosition} position - The position parameter is an object that contains the x and y
-   * coordinates where the text element will be placed on the SVG canvas.
-   * @param {string} text - The text parameter is a string that represents the text content that will be
-   * displayed in the SVGTextElement.
-   * @param {string} textStyle - The text style of the axis
-   * @param {TextAnchorType} textAnchor - text anchor
-   * @param {number} rotate - rotate of the text
-   * @returns {SVGTextElement} an SVGTextElement node.
-   */
-  private getTextNode;
-  /**
-   * This TypeScript function creates an SVG circle element with a specified center, radius, and color.
-   *
-   * @param {ChartPosition} center - The center position of the circle on the chart, specified as an
-   * object with `x` and `y` properties.
-   * @param {number} radius - The radius parameter is a number that represents the radius of the circle
-   * to be created.
-   * @param {string} fillColor - The color parameter
-   * and is used to determine the fill color of the circle. It is likely an enum or string type that maps
-   * to a specific color value.
-   * @param {number} strokeWidth - the border width
-   * @param {string} strokeColor - the border color
-   * @returns {SVGCircleElement} an SVG circle element.
-   */
-  private getCircleNode;
-}

package/dist/types/helpers/event-manager/event-delegated/baseStrategy.d.ts

@@ -1,60 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { JQueryDelegatedEventStrategy } from './jqueryDelegatedEventStrategy';
-/** The code is defining an abstract class called `BaseStrategy` that implements the `JQueryDelegatedEventStrategy` interface. */
-export declare abstract class BaseStrategy implements JQueryDelegatedEventStrategy {
-  /**
-   * The vega component tag name
-   */
-  abstract vegaComponentName: VegaComponentName;
-  /**
-   * The native event name, such as `click`, `change`, `focus`, `blur`
-   */
-  abstract eventName: VegaNativeEventNameType;
-  /**
-   * The function "getHostName" returns the VegaComponentName.
-   *
-   * @returns {VegaComponentName} The method is returning the value of the variable "vegaComponentName" of type VegaComponentName.
-   */
-  getHostName(): VegaComponentName;
-  /**
-   * The function "getEventName" returns the name of an event as a string.
-   *
-   * @returns {VegaNativeEventNameType} a string value, which is the eventName.
-   */
-  getEventName(): VegaNativeEventNameType;
-  /**
-   * The function handles a click event on a specified element and dispatches a custom event with an optional detail.
-   *
-   * @param {HTMLElement} vegaHost - The `vegaHost` parameter is an HTMLElement that represents the host element where the event will be dispatched.
-   * @param {unknown} [detail] - The `detail` parameter is an optional argument that represents additional information or data that can be passed along with the event. It can be of any type, as it is defined as `unknown`.
-   * @returns {Event} a custom event of type `Event`.
-   */
-  handle(vegaHost: HTMLElement, detail?: unknown): Event;
-  /**
-   * The function copies attributes from one HTML element to another, excluding attributes starting with "on", "id".
-   *
-   * @param {HTMLElement} element - The `element` parameter is an HTMLElement object that represents the
-   * source element from which the attributes will be copied.
-   * @param {HTMLElement} target - The target parameter is an HTMLElement where the attributes of the
-   * element parameter will be copied to.
-   */
-  protected copyAttributesToTarget(element: HTMLElement, target: HTMLElement): void;
-  /**
-   * The function creates and returns a new event object based on the given event name.
-   *
-   * @param {VegaNativeEventNameType} eventName - The eventName parameter is the name of the event that
-   * you want to create. It can be any valid event name, such as "click", "keydown", "mouseover", etc.
-   * @returns {Event} a cloned event object.
-   */
-  protected createEvent(eventName: VegaNativeEventNameType): Event;
-  /**
-   * The method need to create an element which should be delegated from vega component
-   *
-   * @param {HTMLElement} delegatedTarget The vega component element
-   * @returns {HTMLElement} The event target
-   * @example $('vega-button').on('click','button',()=>{})
-   * vega-button: The delegated target element
-   * button: The element should be return
-   */
-  abstract createEventTarget(delegatedTarget: HTMLElement): HTMLElement;
-}

package/dist/types/helpers/event-manager/event-delegated/jqueryDelegatedStrategyController.d.ts

@@ -1,44 +0,0 @@
-import { Nullable } from '../../../types/general';
-import { VegaEventID } from '../eventID/vegaEventId';
-import { EventSemanticsConfig } from '../internalVegaEventManager';
-import { JQueryDelegatedEventStrategy } from './jqueryDelegatedEventStrategy';
-export declare type DelegatedStrategyMapType = Map<string, JQueryDelegatedEventStrategy>;
-/** The `JQueryDelegatedStrategyController` class manages delegated event strategies for different HTML elements in a TypeScript application. */
-declare class JQueryDelegatedStrategyController {
-  private strategyRegistry;
-  /**
-   * The constructor initializes a registry of update strategies for various input events in a Vega application.
-   */
-  constructor();
-  /**
-   * The function checks if a given event on a specific HTML element is supported for delegation.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement, which represents the element on which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event.
-   * @returns {boolean} a boolean value.
-   */
-  isSupportDelegated(host: HTMLElement, eventId: VegaEventID): boolean;
-  /**
-   * The function updates the strategy registry with custom strategies based on the event semantics configuration.
-   *
-   * @param {EventSemanticsConfig} eventSemantics - The parameter `eventSemantics` is of type `EventSemanticsConfig`. It is an object that contains two properties: `global` and `components`.
-   */
-  updateRegistryFromEventSemantics(eventSemantics: EventSemanticsConfig): void;
-  /**
-   * The function returns a delegated event strategy based on the host element and event name.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the element on
-   * which the event strategy is being applied. It is the element to which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event for which you want to retrieve the strategy.
-   * @returns {Nullable<JQueryDelegatedEventStrategy>} a Nullable<JQueryDelegatedEventStrategy>.
-   */
-  getStrategy(host: HTMLElement, eventId: VegaEventID): Nullable<JQueryDelegatedEventStrategy>;
-  /**
-   * The function `overrideCurrentStrategy` updates the strategy registry with a new strategy for a specific host and event.
-   *
-   * @param {JQueryDelegatedEventStrategy[]} strategies - The parameter "strategy" is of type "JQueryDelegatedEventStrategy".
-   */
-  private updateStrategyRegistry;
-}
-declare const _default: JQueryDelegatedStrategyController;
-export default _default;

package/dist/types/helpers/event-manager/event-delegated/vegaButtonClickStrategy.d.ts

@@ -1,16 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaButtonClickStrategy class is responsible for creating a button element when a click event is triggered on a VegaButton component. */
-export declare class VegaButtonClickStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * The function creates a new HTML button element based on the properties of a delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaButtonElement, which is a custom element that extends the HTMLButtonElement. It represents
-   * the target button element that will be delegated to create a new button element.
-   * @returns {HTMLButtonElement} an HTMLButtonElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaButtonElement): HTMLButtonElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaCheckboxChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaCheckboxChangeStrategy class is responsible for creating an event target and handling the change event for Vega checkboxes. */
-export declare class VegaCheckboxChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * The function creates and returns a checkbox input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaCheckboxElement, which is a custom element representing a checkbox component in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaCheckboxElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaInputSelectChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaInputSelectChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for Vega input select components. */
-export declare class VegaInputSelectChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * The function creates a new HTML select element and sets its name attribute based on the name attribute of the delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaInputSelectElement, which is a custom element that represents an input select element in the Vega framework.
-   * @returns {HTMLSelectElement} an HTMLSelectElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaInputSelectElement): HTMLSelectElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaInputStrategy.d.ts

@@ -1,23 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaInputBlurStrategy class is responsible for creating an input element when a blur event is triggered on a VegaInput component. */
-export declare class VegaInputStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * The constructor function initializes an instance of a class with a given eventName.
-   *
-   * @param {VegaNativeEventNameType} eventName - The eventName parameter is a string that represents the name of the event.
-   */
-  constructor(eventName: VegaNativeEventNameType);
-  /**
-   * The function creates a new HTML input element with the same type as the provided delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaInputElement, which is a custom type or interface that represents an input element in the
-   * Vega framework. It likely has properties and methods specific to the Vega framework that are not
-   * present in the standard HTMLInputElement.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaInputElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaRadioChangeStrategy.d.ts

@@ -1,15 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaRadioChangeStrategy class is responsible for creating an input element for radio buttons and handling the 'change' event. */
-export declare class VegaRadioChangeStrategy extends BaseStrategy {
-  eventName: VegaNativeEventNameType;
-  vegaComponentName: VegaComponentName;
-  /**
-   * The function creates and returns a radio input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaRadioElement, which is a custom element that represents a radio button in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaRadioElement): HTMLInputElement;
-}

package/dist/types/helpers/event-manager/event-delegated/vegaTextareaChangeStrategy.d.ts

@@ -1,14 +0,0 @@
-import { VegaComponentName, VegaNativeEventNameType } from '../../../types/ui.type';
-import { BaseStrategy } from './baseStrategy';
-/** The VegaTextareaChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for a VegaTextarea component. */
-export declare class VegaTextareaChangeStrategy extends BaseStrategy {
-  vegaComponentName: VegaComponentName;
-  eventName: VegaNativeEventNameType;
-  /**
-   * The function creates a textarea element and sets its name attribute based on the name attribute of a delegated target element.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an HTMLVegaTextElement, which is an element that represents a text input field in the Vega visualization library.
-   * @returns {HTMLTextAreaElement} an HTMLTextAreaElement.
-   */
-  createEventTarget(delegatedTarget: HTMLVegaTextareaElement): HTMLTextAreaElement;
-}

package/dist/types/helpers/event-manager/eventID/componentEventIdMap.d.ts

@@ -1,3 +0,0 @@
-import { VegaComponentName } from '../../../types/ui.type';
-import { VegaEventID } from './vegaEventId';
-export declare const VEGA_COMPONENT_EVENT_MAP: Map<VegaComponentName, VegaEventID[]>;

package/dist/types/helpers/event-manager/eventID/vegaEventId.d.ts

@@ -1,84 +0,0 @@
-import { EventSemantics } from '../internalVegaEventManager';
-import { VegaNativeEventNameType } from '../../../types/ui.type';
-import { VegaEventIDInterface } from './vegaEventIdInterface';
-/** The VegaEventID class represents an event ID with both a Vega name and a native name. */
-export declare class VegaEventID implements VegaEventIDInterface {
-  private vegaName;
-  private nativeName;
-  /**
-   * The constructor function takes two parameters, vegaName and nativeName, and assigns them to private properties of the same names.
-   *
-   * @param {string} vegaName - The vegaName parameter is a private property of type string. It is used to store the name of a star in the Vega system.
-   * @param {VegaNativeEventNameType} nativeName - The `nativeName` parameter is a string that represents the name of the object in its native language or format.
-   */
-  constructor(vegaName: string, nativeName: VegaNativeEventNameType);
-  /**
-   * The function `getName` returns the name of an object using the `getVegaName` method.
-   *
-   * @returns {string} The `getName` method is returning the result of calling the `getVegaName` method.
-   */
-  getName(): string;
-  /**
-   * use the Event Name Manager API to determined to return the vega name of the native name
-   *
-   * @param {EventSemantics} eventSemantics object define namespace and jqueryDelegatedEvent properties
-   * @returns {string} The method is returning the value of the variable "vegaName" or "nativeName" as a string.
-   */
-  getCurrentName(eventSemantics: EventSemantics): string;
-  /**
-   * The function returns the value of the variable "vegaName" as a string.
-   *
-   * @returns {string} The method is returning the value of the variable "vegaName" as a string.
-   */
-  getVegaName(): string;
-  /**
-   * The function returns the value of the variable "nativeName" as a string.
-   *
-   * @returns {string} The method is returning the value of the variable "nativeName" as a string.
-   */
-  getNativeName(): string;
-  /**
-   * The function checks if the current event is a raw event in a browser environment.
-   *
-   * @returns {boolean} a boolean value.
-   */
-  isBrowserRawEvent(): boolean;
-}
-export declare const VegaChange: VegaEventID;
-export declare const VegaClick: VegaEventID;
-export declare const VegaFocus: VegaEventID;
-export declare const VegaBlur: VegaEventID;
-export declare const VegaClose: VegaEventID;
-export declare const VegaOpen: VegaEventID;
-export declare const VegaValidate: VegaEventID;
-export declare const VegaFormSubmit: VegaEventID;
-export declare const VegaFormReset: VegaEventID;
-export declare const VegaRowClick: VegaEventID;
-export declare const VegaSelectChange: VegaEventID;
-export declare const VegaSelectAllChange: VegaEventID;
-export declare const VegaPageSizeChange: VegaEventID;
-export declare const VegaDropdownClick: VegaEventID;
-export declare const VegaCreate: VegaEventID;
-export declare const VegaSearch: VegaEventID;
-export declare const VegaHide: VegaEventID;
-export declare const VegaShow: VegaEventID;
-export declare const VegaPopoverShow: VegaEventID;
-export declare const VegaPopoverHide: VegaEventID;
-export declare const VegaCancel: VegaEventID;
-export declare const VegaRemove: VegaEventID;
-export declare const VegaPageUpdate: VegaEventID;
-export declare const VegaCurrentStepUpdate: VegaEventID;
-export declare const VegaToggleStatus: VegaEventID;
-export declare const VegaStateUpdate: VegaEventID;
-export declare const VegaGroupClick: VegaEventID;
-export declare const VegaMenuClick: VegaEventID;
-export declare const VegaExpand: VegaEventID;
-export declare const VegaDropdownShow: VegaEventID;
-export declare const VegaDropdownHide: VegaEventID;
-export declare const VegaDropdownSearch: VegaEventID;
-export declare const VegaActionClick: VegaEventID;
-export declare const VegaEventClick: VegaEventID;
-export declare const VegaDateDblClick: VegaEventID;
-export declare const VegaCountryChange: VegaEventID;
-export declare const VegaActionButtonClick: VegaEventID;
-export declare const HTMLNativeEventIds: VegaEventID[];

package/dist/types/helpers/event-manager/eventID/vegaInternalEventId.d.ts

@@ -1,26 +0,0 @@
-import { VegaEventIDInterface } from './vegaEventIdInterface';
-/** The class VegaInternalEventID implements the VegaEventIDInterface and provides a method to get the current name. */
-export declare class VegaInternalEventID implements VegaEventIDInterface {
-  private name;
-  /**
-   * This TypeScript constructor function takes a string parameter and assigns it to a private property called "name".
-   *
-   * @param {string} name - It is used to initialize an instance of the class with a specific name value.
-   */
-  constructor(name: string);
-  /**
-   * This TypeScript function returns the name stored in the object.
-   *
-   * @returns {string} The `name` property of the current object is being returned as a string.
-   */
-  getName(): string;
-}
-export declare const VegaInternalValid: VegaInternalEventID;
-export declare const VegaInternalFieldErrorStateChange: VegaInternalEventID;
-export declare const VegaInternalVirtualScrollToBottom: VegaInternalEventID;
-export declare const VegaInternalButtonGroupClick: VegaInternalEventID;
-export declare const VegaInternalLeftNavLinkClick: VegaInternalEventID;
-export declare const VegaInternalSubStatePull: VegaInternalEventID;
-export declare const VegaInternalSubStatePush: VegaInternalEventID;
-export declare const VegaInternalCalendarMonthEventsChange: VegaInternalEventID;
-export declare const VegaInternalDropdownTemplateItemsChange: VegaInternalEventID;