@heartlandone/vega-sandbox-pr-1525-a1131d0b9c266e13a8d224ec5db9f11524d2d02c 2.28.0

package/dist/types/helpers/notify/vega-notify-controller.d.ts

@@ -0,0 +1,54 @@
+import { VegaNotifyOption } from './vega-notify';
+import { PageResizeObserverSlimmer } from '../slimmers/page-resize-observer-slimmer';
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
+/**
+ * The page notification controller
+ */
+declare class VegaNotifyController {
+  protected readonly resizeObserverSlimmer: PageResizeObserverSlimmer;
+  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
+  private container;
+  /**
+   * 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
+   */
+  open(options: VegaNotifyOption): Promise<string>;
+  /**
+   * It closes all notifications
+   *
+   * @vegaVersion 1.17.0
+   */
+  closeAll(): Promise<void>;
+  /**
+   * It closes the notification with the given id
+   *
+   * @param {string} id - The id of the notification to close.
+   * @vegaVersion 1.17.0
+   */
+  close(id: string): Promise<void>;
+  /**
+   * The function "connectResizeObserver" is used to connect a resize observer.
+   *
+   * @vegaVersion 1.17.0
+   */
+  connectResizeObserver(): void;
+  /**
+   * 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.
+   */
+  private createPageNotification;
+  /**
+   * 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.
+   */
+  private getContainer;
+}
+export declare const VegaNotify: VegaNotifyController;
+export {};

package/dist/types/helpers/notify/vega-notify.d.ts

@@ -0,0 +1,13 @@
+import {
+	VegaPageNotificationActionButtonConfig,
+	VegaPageNotificationTypes,
+} from '../../components/vega-page-notification/types';
+
+export type VegaNotifyOption = {
+	title?: string;
+	message: string;
+	type?: VegaPageNotificationTypes;
+	duration?: number;
+	showCloseButton?: boolean;
+	actionButtons?: VegaPageNotificationActionButtonConfig[];
+};

package/dist/types/helpers/paginator/test/value-paginator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/paginator/value-paginator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * It takes an array of items, an array of values, and a capacity, and returns an array of arrays of
+ * items, where each array of items has a total value less than or equal to the capacity
+ */
+export declare class ValuePaginator<T> {
+  /**
+   * It takes an array of items, a function that returns a number for each item, and a number or a
+   * function that returns a number, and returns an array of arrays of items
+   *
+   * @typedef T generic type  parameter
+   * @param {T[]} items - T[] - the items to paginate
+   * @param {(input: T, index: number) => number} valueGetter - (input: T, index: number) => number
+   * @param {number | ((startIndex: number, values: number[]) => number)} currentPageCapacity - number |
+   * ((startIndex: number, values: number[]) => number)
+   * @returns {T[][]} An array of arrays of items.
+   */
+  paginate(items: T[], valueGetter: (input: T, index: number) => number, currentPageCapacity: number | ((startIndex: number, values: number[]) => number)): T[][];
+  /**
+   * It takes an array of items, an array of values, and a capacity, and returns an array of arrays of
+   * items, where each array of items is a page, and the number of items in each page is determined by
+   * the capacity
+   *
+   * @typedef T generic type  parameter
+   * @param {T[]} items - T[]
+   * @param {number[]} values - number[]
+   * @param {number | ((startIndex: number, values: number[]) => number)} currentPageCapacity - number |
+   * ((startIndex: number, values: number[]) => number)
+   * @returns {T[][]} An array of arrays of items.
+   */
+  private doPaginateByCapacity;
+  /**
+   * "Given a start index, an array of values, and a capacity, return the number of elements that can fit
+   * in the capacity."
+   *
+   * The function is a bit more complicated than that, but that's the gist of it
+   *
+   * @param {number} startIndex - The index of the first element in the page.
+   * @param {number[]} values - number[] - an array of numbers that represent the height of each element
+   * in the list.
+   * @param {number | ((startIndex: number, values: number[]) => number)} currentPageCapacity - number |
+   * ((startIndex: number, values: number[]) => number)
+   * @returns {number} The number of elements that can fit on a page.
+   */
+  private valueSum;
+}

package/dist/types/helpers/public-api.d.ts

@@ -0,0 +1,17 @@
+import VegaEnvManager, { FrameworkEnum } from './vega-telemetry-helper/vega-env-manager';
+import VegaEventManager from './event-manager/vega-event-manager';
+export { default as VegaZIndexManager } from './zindex/vega-z-index-manager';
+export { FeatureFlag } from './feature-control/feature-flag-controller';
+export { VegaLoader } from './loading-indicator/vega-loader-controller';
+export { VegaNotify } from './notify/vega-notify-controller';
+export { VegaThemeManager } from './theme/theme-manager';
+export { setVegaLogLevel } from '../utils/log';
+export { VegaDialog } from './dialog/vega-dialog-controller';
+export { VegaEnvManager, FrameworkEnum, VegaEventManager };
+export { BaseStrategy as VegaJQueryDelegatedEventStrategy } from './event-manager/event-delegated/base-strategy';
+export { VegaIconManager } from './icon/icon-manager';
+export { ValidCreditCardNumberRule } from './validator/rules/valid-credit-card-number-rule';
+export { waitForVega } from './common';
+export { IconPayload } from './icon/interface';
+export { VegaSkeletonLoader } from './skeleton-loader/vega-skeleton-loader-controller';
+export { VegaTranslation, en as VegaTranslationResourceEN } from './translation';

package/dist/types/helpers/queue/queue.d.ts

@@ -0,0 +1,4 @@
+export interface Queue<T> {
+	queue: T[];
+	enqueue(item: T): void;
+}

package/dist/types/helpers/queue/synchronize-task-queue.d.ts

@@ -0,0 +1,24 @@
+import { Queue } from './queue';
+export declare type Task = {
+  run: () => Promise<void>;
+};
+/**
+ * This queue runs tasks in the order they are added to the queue
+ *
+ * @implements {Queue<Task>}
+ * @property {Task[]} queue used to be stored tasks pending for executing
+ */
+export declare class SynchronizeTaskQueue implements Queue<Task> {
+  queue: Task[];
+  /**
+   * If immediatelyRun is true, run the task immediately while the queue is empty. Otherwise, add it to the queue.
+   * If immediatelyRun is false, add it to the queue.
+   *
+   * @param {Task} item - Task - The task to be added to the queue.
+   */
+  enqueue(item: Task, immediatelyRun?: boolean): Promise<void>;
+  /**
+   * Run the first task in the queue, then remove it from the queue and run the next task if there is one
+   */
+  runTask(): Promise<void>;
+}

package/dist/types/helpers/queue/test/synchronize-task-queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/remote-invocation/remote-invocation-registry.d.ts

@@ -0,0 +1,39 @@
+import { Nullable } from '../../types/general';
+import { DomNodeSubject } from '../change-manager/subject/dom-node-subject/dom-node-subject';
+/**
+ * The `RemoteInvocationRegistry` provides methods for performing remote invocation calls
+ * and registering remote invocation handlers.
+ */
+export declare class RemoteInvocationRegistry {
+  /**
+   * This function performs a remote invocation call and returning the result.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   * @param {unknown[]} args - The `args` parameter of specific method.
+   * @returns {unknown} The result of call `remoteInvocation`.
+   */
+  call<T>(subject: DomNodeSubject, ...args: unknown[]): Nullable<T>;
+  /**
+   * The function registers a remote invocation handler.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   * @param {Function}remoteInvocationHandler - The method that is ultimately called.
+   */
+  register<T>(subject: DomNodeSubject, remoteInvocationHandler: (...args: unknown[]) => T): void;
+  /**
+   * The function un-registers a remote invocation call handler.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   */
+  unRegister(subject: DomNodeSubject): void;
+  /**
+   * The function isAcceptableObserver checks if the input matches a specified type T.
+   *
+   * @param {unknown} _input - The `_input` parameter is of type `unknown`, which means it can hold any
+   * value.
+   * @returns {boolean} The `isAcceptableObserver` function is returning `true`.
+   */
+  private isAcceptableObserver;
+}
+declare const _default: RemoteInvocationRegistry;
+export default _default;

package/dist/types/helpers/remote-invocation/remote-invocation-registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/skeleton-loader/interface.d.ts

@@ -0,0 +1,16 @@
+import { VegaComponentInterface } from '../../types/ui.type';
+
+export type VegaSkeletonLoaderItem = Partial<
+	Pick<VegaComponentInterface<HTMLVegaSkeletonElement>, 'type' | 'width' | 'height'>
+>;
+
+export type VegaSkeletonLoaderLayout = {
+	props?: Partial<VegaComponentInterface<HTMLVegaFlexElement>>;
+	style?: Partial<CSSStyleDeclaration>;
+};
+
+export type VegaSkeletonLoaderConfig = {
+	target: string;
+	items?: VegaSkeletonLoaderItem[];
+	layout?: VegaSkeletonLoaderLayout;
+} & VegaSkeletonLoaderItem;

package/dist/types/helpers/skeleton-loader/tests/vega-skeleton-loader-controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/skeleton-loader/vega-skeleton-loader-controller.d.ts

@@ -0,0 +1,54 @@
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
+import { VegaSkeletonLoaderConfig } from './interface';
+/**
+ * Vega Skeleton Loader Controller to show skeletons in the target elements
+ */
+declare class VegaSkeletonLoaderController {
+  private static readonly LOADER_DATA_SET_KEY;
+  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
+  private loaderMap;
+  /**
+   * 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, width, height, items, layout }: VegaSkeletonLoaderConfig): string;
+  /**
+   * Remove the skeletons from the dom.
+   *
+   * @param {string} key - The key returned from {@link VegaSkeletonLoaderController.load}.
+   * @vegaVersion 2.16.0
+   */
+  unLoad(key: string): void;
+  /**
+   * Remove all the skeletons from the dom.
+   *
+   * @vegaVersion 2.16.0
+   */
+  unLoadAll(): void;
+  /**
+   * Create a skeleton item. The skeleton animated always be true
+   *
+   * @param {VegaSkeletonLoaderItem} config - Configuration for the skeleton item.
+   * @returns {HTMLElement} - Skeleton item.
+   */
+  private createSkeleton;
+  /**
+   * 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.
+   */
+  private wrapLayout;
+}
+export declare const VegaSkeletonLoader: VegaSkeletonLoaderController;
+export {};

package/dist/types/helpers/slimmers/component-global-style-slimmer.d.ts

@@ -0,0 +1,33 @@
+import { VegaSlimmer } from '../../vega-slimmer/vega-slimmer-core';
+import { HTMLStencilElement } from '../../stencil-public-runtime';
+/**
+ * Component global style slimmer
+ */
+export declare class ComponentGlobalStyleSlimmer<T extends HTMLStencilElement> extends VegaSlimmer {
+  private static connectedComponents;
+  host: T;
+  private id;
+  private readonly style;
+  /**
+   * Component lifecycle - [connectedCallback]
+   */
+  connectedCallback(): void;
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   */
+  disconnectedCallback(): void;
+  /**
+   * Component lifecycle - [componentWillLoad]
+   */
+  componentWillLoad(): void;
+  /**
+   * The constructor of the slimmer
+   *
+   * @param {string} styles - The style string that will be appended to the document head.
+   */
+  constructor(styles: string);
+  /**
+   * @returns {Nullable<HTMLStyleElement>} - The style element
+   */
+  private getStyleElement;
+}

package/dist/types/helpers/slimmers/component-usage-runtime-metrics.d.ts

@@ -0,0 +1,43 @@
+import { VegaSlimmer } from '../../vega-slimmer/vega-slimmer-core';
+export declare type ComponentUsageRuntimeMetricsDefinition<T extends HTMLElement> = {
+  payloadKey: string;
+  payloadValue: (host: T) => boolean;
+  payloadDescription?: string;
+};
+/**
+ * The `VegaComponentUsageRuntimeMetricsSlimmer` class is used for sending usage
+ * telemetry data to a telemetry service based on defined usage metrics for a specific component.
+ * We did not use global slimmer because each component introduces all the definitions of other components during the did load
+ */
+export declare class VegaComponentUsageRuntimeMetricsSlimmer<T extends HTMLElement> extends VegaSlimmer {
+  private readonly usageDefinitions?;
+  static baseUsageKey: string;
+  host: T;
+  /**
+   * The constructor initializes a private readonly property with an optional array of
+   * ComponentUsageRuntimeMetricsDefinition.
+   *
+   * @param {ComponentUsageRuntimeMetricsDefinition[]} [usageDefinitions] - The `usageDefinitions`
+   * parameter in the constructor is of type `ComponentUsageRuntimeMetricsDefinition<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(usageDefinitions?: ComponentUsageRuntimeMetricsDefinition<T>[]);
+  /**
+   * register the observer when the slimmer method called
+   */
+  sendUsagePayloadToTelemetry(): void;
+  /**
+   * The function `getComponentUsageMetricsPayload` generates a payload containing component usage
+   * metrics data.
+   *
+   * @returns {Record<string, unknown>} The `getComponentUsageMetricsPayload` method returns an object with the following
+   * structure:
+   * {
+   * 	componentName: string, // The tag name of the host component in uppercase
+   * 	data: { // An object containing payload data with keys and boolean values
+   * 		'COMPONENT_USED': true,
+   * }
+   */
+  private getComponentUsageMetricsPayload;
+}

package/dist/types/helpers/slimmers/deprecated-property-slimmer.d.ts

@@ -0,0 +1,34 @@
+import { VegaSlimmer } from '../../vega-slimmer/vega-slimmer-core';
+import { ClassPrototype } from '../../types/class.type';
+import { DynamicMapFromClass } from './types';
+/** DeprecatedPropertySlimmer compares new property with default value, if they are different, return new property; otherwise, return old property */
+export declare class DeprecatedPropertySlimmerBase<T> extends VegaSlimmer {
+  host: HTMLElement;
+  newPropertyName: string;
+  oldPropertyName: string;
+  defaultValue: T;
+  constructor({ newPropertyName, oldPropertyName, defaultValue, }: {
+    newPropertyName: string;
+    oldPropertyName: string;
+    defaultValue: T;
+  });
+  /**
+   * The `getValue` function returns either the old property or the new property based on a deep equality
+   * check.
+   *
+   * @returns {unknown} The `getValue` method returns either the `oldProperty` or `newProperty` based on the result
+   * of the `deepEqual` comparison between them. If `newProperty` is deeply equal to `oldProperty`, then
+   * `oldProperty` is returned; otherwise, `newProperty` is returned.
+   */
+  getValue(): T;
+}
+/**
+ * Create dynamic deprecated property slimmer
+ *
+ * @param {ClassPrototype} mapFromClass - It represents the class that you want to map from.
+ * @param {string} newPropertyName - The new prop name or name path
+ * @param {string} oldPropertyName - The old prop name or name path
+ * @param {unknown} defaultValue - The default value of the prop
+ * @returns {DeprecatedPropertySlimmerBase<unknown>} - deprecated property slimmer
+ */
+export declare function createDeprecatedPropertySlimmer<T extends DynamicMapFromClass, K>(mapFromClass: ClassPrototype<T>, newPropertyName: string, oldPropertyName: string, defaultValue: unknown): DeprecatedPropertySlimmerBase<K>;

package/dist/types/helpers/slimmers/element-appender-container/default-wrapper.d.ts

@@ -0,0 +1,20 @@
+import { ElementAppenderShowConfig } from '../../ui/element-appender';
+import { ElementAppenderContainerRetriever } from './element-appender-container-controller';
+/**
+ * This class is is used to retrieve the body element of document.
+ */
+export declare class DefaultWrapper implements ElementAppenderContainerRetriever {
+  showConfig: ElementAppenderShowConfig;
+  /**
+   * The canRetrieve function return is always true.
+   *
+   * @returns {boolean} the boolean type.
+   */
+  canRetrieve: () => boolean;
+  /**
+   * The retrieve function get the body element of document.
+   *
+   * @returns {HTMLElement} the element.
+   */
+  retrieve: () => HTMLElement;
+}

package/dist/types/helpers/slimmers/element-appender-container/element-appender-container-controller.d.ts

@@ -0,0 +1,33 @@
+import { VegaSlimmer } from '../../../vega-slimmer/vega-slimmer-core';
+import { ElementAppenderShowConfig } from '../../ui/element-appender';
+import { DefaultWrapper } from './default-wrapper';
+import { PositionRelativeToWrapper } from './position-relative-to-wrapper';
+import { VegaModalWrapper } from './vega-modal-wrapper';
+import { VegaPopoverWrapper } from './vega-popover-wrapper';
+export interface ElementAppenderContainerRetriever {
+  canRetrieve: () => boolean;
+  retrieve: () => HTMLElement;
+}
+/**
+ * This class is responsible for setting the container element for appending an element based on certain conditions.
+ *
+ * @property {HTMLElement} container the container
+ * @property {HTMLElement} showConfig the show config
+ */
+export declare class ElementAppenderContainerController extends VegaSlimmer {
+  container: HTMLElement;
+  showConfig: ElementAppenderShowConfig;
+  protected readonly positionRelativeToWrapper: PositionRelativeToWrapper;
+  protected readonly vegaPopoverWrapper: VegaPopoverWrapper;
+  protected readonly vegaModalWrapper: VegaModalWrapper;
+  protected readonly defaultWrapper: DefaultWrapper;
+  private containerRetrievers;
+  /**
+   * The function sets the container element by iterating through a list of retrievers, defaulting to the document body.
+   */
+  setContainer(): void;
+  /**
+   * The function sets up an array of container retrievers based on certain conditions.
+   */
+  private setContainerRetrievers;
+}

package/dist/types/helpers/slimmers/element-appender-container/position-relative-to-wrapper.d.ts

@@ -0,0 +1,22 @@
+import { ElementAppenderShowConfig } from '../../ui/element-appender';
+import { ElementAppenderContainerRetriever } from './element-appender-container-controller';
+/**
+ * This class is is used to retrieve an HTML element based on a specified selector.
+ *
+ * @property {HTMLElement} showConfig the show config
+ */
+export declare class PositionRelativeToWrapper implements ElementAppenderContainerRetriever {
+  showConfig: ElementAppenderShowConfig;
+  /**
+   * The canRetrieve function just determines whether the showConfig contains the positionRelativeTo object.
+   *
+   * @returns {boolean} the boolean type.
+   */
+  canRetrieve: () => boolean;
+  /**
+   * The retrieve function query the element of positionRelativeTo in showConfig.
+   *
+   * @returns {HTMLElement} the element.
+   */
+  retrieve: () => HTMLElement;
+}

package/dist/types/helpers/slimmers/element-appender-container/vega-modal-wrapper.d.ts

@@ -0,0 +1,35 @@
+import { ElementAppenderShowConfig } from '../../ui/element-appender';
+import { ElementAppenderContainerRetriever } from './element-appender-container-controller';
+/**
+ * This class is is used to get vega-modal element as a container and store the element appender element to slot.
+ *
+ * @property {HTMLElement} showConfig the show config
+ */
+export declare class VegaModalWrapper implements ElementAppenderContainerRetriever {
+  showConfig: ElementAppenderShowConfig;
+  /**
+   * The canRetrieve function just determines whether the target of showConfig has the `vega-modal` element. If not, search upwards layer by layer.
+   *
+   * @returns {boolean} the boolean type.
+   */
+  canRetrieve: () => boolean;
+  /**
+   * The retrieve function get the slot position of vega-modal element.
+   *
+   * @returns {HTMLElement} the element.
+   */
+  retrieve: () => HTMLElement;
+  /**
+   * This function `getVegaModalContentWithoutScroll` determines whether vega-modal has a slot whose name is `content` or `modal-content`. If there is a component rendered in the modal, the elementAppender added to the corresponding slot attribute is added. If not, the elementAppender is not directly appended to the root directory of vega-modal.
+   *
+   * @param {Nullable<HTMLElement>} parentModal The parentModal is vega-modal element.
+   * @param {Nullable<HTMLElement>} element The parentModal is vega-modal element.
+   */
+  private setElementSlot;
+  /**
+   * The function "getShowConfigContainer" returns the appended element container. If the modal content can be scrolled, the container is the div element that wraps the append element. Otherwise, the container is the modal dialog itself.
+   *
+   * @returns {HTMLElement} the `scrollContainer` element.
+   */
+  private getVegaModalShowConfigContainer;
+}

package/dist/types/helpers/slimmers/element-appender-container/vega-popover-wrapper.d.ts

@@ -0,0 +1,22 @@
+import { ElementAppenderShowConfig } from '../../ui/element-appender';
+import { ElementAppenderContainerRetriever } from './element-appender-container-controller';
+/**
+ * This class is used to get the class `vega-popover` as a container and store the element appender element.
+ *
+ * @property {HTMLElement} showConfig the show config
+ */
+export declare class VegaPopoverWrapper implements ElementAppenderContainerRetriever {
+  showConfig: ElementAppenderShowConfig;
+  /**
+   * The canRetrieve function just determine whether the target of showConfig has the class `vega-popover`. If not, search upwards layer by layer.
+   *
+   * @returns {boolean} the boolean type.
+   */
+  canRetrieve: () => boolean;
+  /**
+   * The retrieve function get the element that if the target of showConfig does not have the class vega-popover, search upwards layer by layer until this element is found.
+   *
+   * @returns {HTMLElement} the element.
+   */
+  retrieve: () => HTMLElement;
+}

package/dist/types/helpers/slimmers/element-appender-slimmer.d.ts

@@ -0,0 +1,56 @@
+import { VegaSlimmer } from '../../vega-slimmer/vega-slimmer-core';
+import { ElementAppender, ElementAppenderShowConfig } from '../ui/element-appender';
+import { Nullable } from '../../types/general';
+declare type ShowConfigFactoryType = () => ElementAppenderShowConfig;
+/**
+ * - click: means the dropdown show/hide by click, it also listen global area click. example: VegaPopover
+ * - hover: means the dropdown show/hide by hover, it also listen global area click. example: VegaDropdown VegaAppHeaderButton
+ * - none: means element appender not listens any event, you should control the dropdown show/hide in component. example: VegaDatePicker
+ * - custom: means element appender only listen the outer area click. when clicked the dropdown will hide. example: VegaTimePicker
+ */
+declare type TriggerType = 'click' | 'hover' | 'none' | 'custom';
+declare type GetTriggerType = () => TriggerType;
+declare type DisableInteractiveGetter = () => boolean;
+export declare class ElementAppenderSlimmer extends VegaSlimmer {
+  private static readonly DELAY_HIDE_TIME;
+  private showConfigFactory;
+  private getTrigger;
+  private isDropdownShowName;
+  private showConfig;
+  private delayHideTimer;
+  private elementAppender;
+  /**
+   * appendableElement is interactive by default (to pass [WCAG 2.1 success criterion 1.4.13](https://www.w3.org/TR/WCAG21/#content-on-hover-or-focus))
+   */
+  private disableInteractiveGetter;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  componentDidLoad(): void;
+  constructor(showConfigFactory: ShowConfigFactoryType, getTrigger: GetTriggerType, isDropdownShowName?: string, disableInteractiveGetter?: DisableInteractiveGetter);
+  getElementAppender(): Nullable<ElementAppender>;
+  show(): void;
+  hide(): void;
+  destroy(): void;
+  private setElementAppender;
+  private isShowing;
+  private setShowConfig;
+  /**
+   * It adds event listeners to the target and the appendable element
+   */
+  private registerElementAppenderListener;
+  /**
+   * It removes all event listeners that were added in the `register()` function
+   */
+  private unRegisterElementAppenderListener;
+  private targetClickHandler;
+  private targetMouseEnterHandler;
+  private targetMouseLeaveHandler;
+  private targetFocusoutHandler;
+  private elementMouseEnterHandler;
+  private elementMouseLeaveHandler;
+  private globalMouseDownHandler;
+  private createDelayHideTimer;
+  private clearDelayHideTimer;
+  private shouldListenerWork;
+}
+export {};

package/dist/types/helpers/slimmers/field-error-controller-silmmer.d.ts

@@ -0,0 +1,31 @@
+import { VegaSlimmer } from '../../vega-slimmer/vega-slimmer-core';
+import { FormFieldOptionForSlimmer } from './form-field-controller-slimmer';
+import { FieldErrorUIControllerSlimmer } from './field-error-ui-controller-slimmer';
+/** The `FieldBoxControllerSlimmer` class is a TypeScript class that extends the `VegaSlimmer` class and provides methods for handling error UI in a field error component. */
+export declare class FieldErrorControllerSlimmer extends VegaSlimmer {
+  host: HTMLElement;
+  options: FormFieldOptionForSlimmer<unknown>;
+  protected readonly fieldErrorUIController: FieldErrorUIControllerSlimmer;
+  private fieldErrorMessageChangeObserver;
+  /**
+   * register the observer when the slimmer method called
+   */
+  handleComponentWillLoadByFieldErrorSlimmer(): void;
+  /**
+   * unregister the observer when the slimmer method called
+   */
+  handleUnregisterObserver(): void;
+  /**
+   * The function checks if the host element is the parent of the field box.
+   *
+   * @param {FieldErrorEventPayload} payload - The payload parameter is of type FieldErrorEventPayload.
+   * @returns {boolean} a boolean value.
+   */
+  private canAcceptFieldErrorMessageUpdate;
+  /**
+   * call the method when observer trigger
+   *
+   * @param {FieldErrorEventPayload} payload payload param
+   */
+  private handleFieldErrorMessageUpdate;
+}