@heartlandone/vega-sandbox-pr-1517-a0a4ed91f893a88f6f92ae44ec0c52a37fef9e51 2.28.0

package/dist/types/helpers/formatter/string-formatter/string-mask-strategy.d.ts

@@ -0,0 +1,94 @@
+import { Nullable } from '../../../types/general';
+import { StringFormatStrategy } from './string-format-strategy';
+export declare type MaskConfig = {
+  mask: string;
+  slot: string | RegExp;
+  accept: RegExp;
+  insertMode?: boolean;
+  overrideValue?: boolean;
+  triggerAtInit?: boolean;
+};
+/**
+ * A class for formatting string with the given mask format
+ *
+ * @augments StringFormatStrategy
+ */
+export declare class StringMaskStrategy implements StringFormatStrategy {
+  static PHONE_MASK: StringMaskStrategy;
+  static ZIPCODE_MASK: StringMaskStrategy;
+  static TAX_ID_MASK: StringMaskStrategy;
+  private maskConfig;
+  private slotRegex;
+  private acceptRegex;
+  /**
+   * The insert mode means adding some special character in the input string, will replace part of input string if insertMode set to false.
+   *
+   * @example
+   * mask: ****9999
+   * slot: 9
+   * value = 12345678
+   *
+   * insertMode=true The mask value should be ****1234
+   * insertMode=false The mask value should be ****5678
+   */
+  private insertMode;
+  /**
+   * It creates a new instance of the Mask class.
+   *
+   * @param {MaskConfig} maskConfig - MaskConfig
+   */
+  constructor(maskConfig: MaskConfig);
+  /**
+   * Given a string, it replaces the mask with the matched input slot value
+   *
+   * @param {string} input - The input string that needs to be formatted.
+   * @param {number} caretPosition - The current position of caret
+   * @returns {string} The formatted string.
+   */
+  format(input: string, caretPosition?: Nullable<number>): string;
+  /**
+   * Get the position of
+   *
+   * @param {string} input - The input string
+   * @param {number} caretPosition - The current position of caret
+   * @returns {number} The new position of caret
+   */
+  calculateCaretPosition(input: string, caretPosition: Nullable<number>): Nullable<number>;
+  /**
+   * This TypeScript function determines whether a component value should be overridden based on the mask configuration.
+   *
+   * @returns {boolean} The result overrideValue controls whether the component value same as the internal input value after the input blur
+   * return false if property overrideValue is not exist or set to true, return false if maskConfig is not exist
+   */
+  shouldOverrideComponentValueAfterBlur(): boolean;
+  /**
+   * The function shouldTriggerAtInit returns true if the maskConfig is defined and its triggerAtInit
+   * property is set to true, otherwise it returns false.
+   *
+   * @returns {boolean} The function shouldTriggerAtInit() returns a boolean value. If the condition is met
+   * (this.maskConfig is truthy and this.maskConfig.triggerAtInit is true), it returns true. Otherwise,
+   * it returns false.
+   */
+  shouldTriggerAtInit(): boolean;
+  /**
+   * Get the length limit by mask
+   *
+   * @returns {number} the max limit length
+   */
+  private getLengthLimit;
+  /**
+   * Given a string, return an array of all the digits in that string
+   *
+   * @param {string} input - The input string to be parsed.
+   * @returns {string[]} - An array of strings.
+   */
+  private getMatchedInputSlotValue;
+  /**
+   * Replace the mask with the matched input slots
+   *
+   * @param {string} input - The input string that is being typed by the user.
+   * @param {string[]} matchedInputSlot - an array of the input slots that were matched by the mask.
+   * @returns {string} The result string builder.
+   */
+  private replaceMaskWithMatchedInputSlots;
+}

package/dist/types/helpers/formatter/string-formatter/thousand-comma-strategy.d.ts

@@ -0,0 +1,23 @@
+import { StringFormatStrategy } from './string-format-strategy';
+/**
+ * A class for formatting string with the "," as the thousand separator
+ *
+ * @augments StringFormatStrategy
+ */
+export declare class ThousandCommaStrategy implements StringFormatStrategy {
+  /**
+   * If the input is a number, format it as a string
+   *
+   * @param {string} input - string
+   * @returns {string} The input string, but with commas as thousands separator.
+   */
+  format(input: string): string;
+  /**
+   * Get the position of caret
+   *
+   * @param {string} input - The input string
+   * @param {number} caretPosition - The current caret position
+   * @returns {number} The new position of caret
+   */
+  calculateCaretPosition(input: string, caretPosition: number): number;
+}

package/dist/types/helpers/formatter/style-formatter.d.ts

@@ -0,0 +1,14 @@
+import { FlexType, FlexGrowType, FlexShrinkType, FlexBasisType, Nullable } from '../../types/components.type';
+import { ResponsiveType } from '../../types/ui.type';
+/**
+ * Fomatter flex styles.
+ *
+ * @param {Nullable<ResponsiveType<FlexType>>} flex - flex
+ * @param {Nullable<ResponsiveType<FlexGrowType>>} flexGrow - flex-grow
+ * @param {Nullable<ResponsiveType<FlexShrinkType>>} flexShrink - flex-shrink
+ * @param {Nullable<ResponsiveType<FlexBasisType>>} flexBasis - flex-basis
+ * @returns {object} - formatted styles
+ */
+export declare function formatFlexStyles(flex: Nullable<ResponsiveType<FlexType>>, flexGrow: Nullable<ResponsiveType<FlexGrowType>>, flexShrink: Nullable<ResponsiveType<FlexShrinkType>>, flexBasis: Nullable<ResponsiveType<FlexBasisType>>): {
+  [key: string]: string | undefined;
+};

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-border-radius-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-box-display-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-custom-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-display-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-flex-direction-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-flex-wrap-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-format-mediator.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-gap-formatter.ts.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-grid-column-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-grid-row-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-margin-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-padding-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-size-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-text-align-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-translocation-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/responsive-map-formatter/responsive-width-and-height-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/state-formatter/state-background-color-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/state-formatter/state-border-color-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/state-formatter/state-border-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/state-formatter/state-format-facade.test.d.ts

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

package/dist/types/helpers/formatter/test/state-formatter/state-shadow-formatter.test.d.ts

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

package/dist/types/helpers/formatter/test/string-formatter/custom-formatter-strategy.test.d.ts

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

package/dist/types/helpers/formatter/test/string-formatter/number-mask-strategy.test.d.ts

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

package/dist/types/helpers/formatter/test/string-formatter/number-thousand-comma-mask-strategy.test.d.ts

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

package/dist/types/helpers/formatter/test/string-formatter/string-mask-strategy.test.d.ts

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

package/dist/types/helpers/formatter/test/string-formatter/thousand-comma-strategy.test.d.ts

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

package/dist/types/helpers/formatter/test/style-formatter.test.d.ts

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

package/dist/types/helpers/icon/icon-manager.d.ts

@@ -0,0 +1,35 @@
+import { Nullable } from '../../types/general';
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
+import { IconPayload } from './interface';
+/**
+ * Internal icon manager controller.
+ */
+declare class IconManager {
+  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
+  private icons;
+  /**
+   * Registers the icons into the map.
+   *
+   * @param {Record<string, string>} icons - icon records
+   * @vegaVersion 2.13.0
+   */
+  register(icons: Record<string, IconPayload>): void;
+  /**
+   * Get an internal icon by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {Nullable<string>} returns the icon svg or null if not found
+   * @vegaVersion 2.13.0
+   */
+  getIcon(name: string): Nullable<IconPayload>;
+  /**
+   *  Check if the icon manager has an icon by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {boolean} returns true if the icon exists
+   * @vegaVersion 2.13.0
+   */
+  hasIcon(name: string): boolean;
+}
+export declare const VegaIconManager: IconManager;
+export {};

package/dist/types/helpers/icon/interface.d.ts

@@ -0,0 +1,10 @@
+export type IconPayload = {
+	/**
+	 * Custom icon SVG resource.
+	 */
+	icon: string;
+	/**
+	 * The `vega-icon` will automatically adjust its size when `autoSize` is set to `true`.
+	 */
+	autoSize?: boolean;
+};

package/dist/types/helpers/icon/internal-icon-manager.d.ts

@@ -0,0 +1,30 @@
+import { IconPayload } from './interface';
+/**
+ * Internal icon manager
+ */
+declare class InternalIconManager {
+  private static INTERNAL_ICON_NAMESPACE;
+  /**
+   * Get the internal icon key by name
+   *
+   * @param {string} name - The name of the icon
+   * @returns {string} returns the internal icon key
+   */
+  getIconKey(name: string): string;
+  /**
+   * Register internal icons
+   *
+   * @param {Record<string, IconPayload>} icons - The icons to register
+   */
+  register(icons: Record<string, IconPayload>): void;
+  /**
+   * Generate the icon key with the namespace
+   *
+   * @param {string} name - The name of the icon
+   * @param {string} namespace - The namespace of the icon
+   * @returns {string} returns the key with the namespace
+   */
+  private generateIconKeyWithNamespace;
+}
+export declare const VegaInternalIconManager: InternalIconManager;
+export {};

package/dist/types/helpers/icon/test/icon-manager-controller.test.d.ts

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

package/dist/types/helpers/icon/test/internal-icon-manager.test.d.ts

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

package/dist/types/helpers/immutable/immutable-map.d.ts

@@ -0,0 +1,78 @@
+import { Nullable } from '../../types/general';
+import { Immutable } from './immutable';
+/** The `ImmutableMap` class is a TypeScript implementation of an immutable map data structure that allows for mutation through a `withMutation` method. */
+export declare class ImmutableMap<K, V> implements Immutable<Map<K, V>> {
+  size: number;
+  private readonly map;
+  /**
+   * The constructor initializes a new ImmutableMap object with an optional initial value and an optional callback function for mutation events.
+   *
+   * @param {Map<unknown,unknown>} [initialValue] - The `initialValue` parameter is an optional parameter that allows you to
+   * provide an initial value for the `Map`. It is of type `Map<K, V>`, where `K` represents the key
+   * type and `V` represents the value type.
+   * @param {(newMap: ImmutableMap<unknown, unknown>) => void} [onMutate] - The `onMutate` parameter is a callback function that is called whenever the
+   * `ImmutableMap` is mutated (i.e., when a key-value pair is added, updated, or removed). It receives
+   * the new `ImmutableMap` as an argument. This callback function can be used to perform any
+   */
+  constructor(initialValue: Map<K, V>, onMutate?: (newMap: ImmutableMap<K, V>) => void);
+  /**
+   * The "has" function checks if a key exists in a map.
+   *
+   * @param {unknown} key - The parameter "key" is of type K, which means it can be any type. It is used to specify the key that you want to check for existence in the map.
+   * @returns {boolean} A boolean value indicating whether the key exists in the map.
+   */
+  has(key: K): boolean;
+  /**
+   * The function returns an iterator of the keys in a map.
+   *
+   * @returns {IterableIterator<unknown>} The `keys()` method is returning an `IterableIterator` object that contains the keys of the `map`.
+   */
+  keys(): IterableIterator<K>;
+  /**
+   * The `set` function adds a key-value pair to an immutable map.
+   *
+   * @param {unknown} key - The key parameter is the key of the entry that you want to add or update in the map. It is of type K, which represents the type of the keys in the map.
+   * @param {unknown} value - The value parameter represents the value that you want to associate with the specified key in the ImmutableMap.
+   * @returns {ImmutableMap<unknown, unknown>} The method is returning an ImmutableMap<K, V>.
+   */
+  set(key: K, value: V): ImmutableMap<K, V>;
+  /**
+   * The get function retrieves the value associated with a given key from a map.
+   *
+   * @param {unknown} key - The parameter "key" is of type "K", which means it can be any type.
+   * @returns {unknown} The value associated with the given key in the map.
+   */
+  get(key: K): Nullable<V>;
+  /**
+   * The values() method of Map instances returns a new map iterator object that contains the values for each element in this map in insertion order.
+   *
+   * @returns {IterableIterator<unknown>} An iterator of the values in the map.
+   */
+  values(): IterableIterator<V>;
+  /**
+   * The `delete` function removes an entry from an ImmutableMap by deleting the corresponding key-value pair from the underlying Map.
+   *
+   * @param {unknown} key - The key parameter is the key of the entry that you want to delete from the ImmutableMap.
+   * @returns {ImmutableMap<unknown, unknown>} The method is returning an ImmutableMap<K, V>.
+   */
+  delete(key: K): ImmutableMap<K, V>;
+  /**
+   * The `clear` function clears all key-value pairs from an ImmutableMap.
+   *
+   * @returns {ImmutableMap<unknown, unknown>} The method is returning an ImmutableMap<K, V>.
+   */
+  clear(): ImmutableMap<K, V>;
+  /**
+   * The function is called when the map is mutated
+   *
+   * @param {ImmutableMap<unknown,unknown>} _newMap - The new set that was created.
+   */
+  onMutate(_newMap: ImmutableMap<K, V>): void;
+  /**
+   * The `withMutation` function takes a callback function that mutates a map and returns a new immutable map with the changes applied.
+   *
+   * @param {(map: Map<unknown, unknown>) => void} fn - A function that takes a map as its parameter and does some mutation on it.
+   * @returns {ImmutableMap<unknown, unknown>} a new instance of `ImmutableMap<K, V>`.
+   */
+  private withMutation;
+}

package/dist/types/helpers/immutable/immutable-set.d.ts

@@ -0,0 +1,65 @@
+import { Immutable } from './immutable';
+/**
+ * Immutable Set cannot be changed once created
+ */
+export declare class ImmutableSet<T> implements Immutable<Set<T>> {
+  size: number;
+  private readonly set;
+  /**
+   * The constructor of ImmutableSet
+   *
+   * @typedef T generic type parameter
+   * @param {Set<T>} initialSet - The initial set to use. If not provided, the set will be empty.
+   * @param {() => void} onMutate - A callback function that will be called whenever the set is mutated.
+   */
+  constructor(initialSet?: Set<T>, onMutate?: (newSet: ImmutableSet<T>) => void);
+  /**
+   * The function is called when the set is mutated
+   *
+   * @param {Immutable<Set<T>>} _newSet - The new set that was created.
+   */
+  onMutate(_newSet: Immutable<Set<T>>): void;
+  /**
+   * Add new items to the set, and then call the onMutate with the new ImmutableSet
+   *
+   * @typedef T generic type parameter
+   * @param {T[]} value  - The items to add to the set.
+   * @returns {ImmutableSet<T>} A new ImmutableSet with the new items added.
+   */
+  add(...value: T[]): ImmutableSet<T>;
+  /**
+   * clear the set values
+   *
+   * @typedef T generic type parameter
+   */
+  clear(): void;
+  /**
+   * delete item from set
+   *
+   * @typedef T generic type parameter
+   * @param {T} value - The key to delete from the set.
+   * @returns {ImmutableSet<T>} A new ImmutableSet
+   */
+  delete(value: T): ImmutableSet<T>;
+  /**
+   * It takes a function that mutates a set, and returns a new immutable set that is the result of that mutation
+   *
+   * @param {(set: Set<T>) => void} fn - (set: Set<T>) => void
+   * @returns {ImmutableSet<T>} A new ImmutableSet
+   */
+  withMutation(fn: (set: Set<T>) => void): ImmutableSet<T>;
+  /**
+   * It returns true if the value is in the set, and false otherwise
+   *
+   * @typedef T generic type parameter
+   * @param {T} value - The value to check for.
+   * @returns {boolean} A boolean value.
+   */
+  has(value: T): boolean;
+  /**
+   * It returns an array of the values in the set
+   *
+   * @returns {T[]} An array of the values in the set.
+   */
+  toArray(): T[];
+}

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

@@ -0,0 +1,3 @@
+export interface Immutable<T> {
+	onMutate(newObj: Immutable<T>): void;
+}

package/dist/types/helpers/immutable/test/immutable-map.test.d.ts

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

package/dist/types/helpers/immutable/test/immutable-set.test.d.ts

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

package/dist/types/helpers/keyboard/keyboard-manager.d.ts

@@ -0,0 +1,60 @@
+import { KeyboardCodeType } from '../../types/ui.type';
+export declare type KeyboardEventListener = {
+  keyCode: KeyboardCodeType | KeyboardCodeType[];
+  activeElementInScope?: HTMLElement[] | (() => HTMLElement[]);
+  activeElementOutScope?: HTMLElement[] | (() => HTMLElement[]);
+  eventName?: 'keyup' | 'keydown';
+  callback: (event: KeyboardEvent) => void;
+};
+/**
+ * It listens to the keyup event on the window and calls the appropriate method on the registered elements
+ *
+ * @property {KeyboardEventListener[]} listeners used to record listeners
+ */
+declare class KeyboardManager {
+  private listeners;
+  /**
+   * Manager init
+   */
+  constructor();
+  /**
+   * Add the given listener to the list of listeners.
+   *
+   * @param {KeyboardEventListener[]} listeners - The listener to register.
+   * @returns {void}
+   */
+  register(listeners: KeyboardEventListener[]): void;
+  /**
+   * The function removes the listeners from the listeners array
+   *
+   * @param {KeyboardEventListener[]} listeners - KeyboardEventListener[]
+   * @returns {void}
+   */
+  deregister(listeners: KeyboardEventListener[]): void;
+  /**
+   * > Listen for keyup events on the window, and if the code matches the keyCode of a listener,
+   * invoke the listener's callback
+   */
+  private listenKeyPress;
+  /**
+   * We filter the listeners by the event name, then filter them by whether the key code matches the
+   * listener's key code, and then invoke the callback function for each listener that matches
+   *
+   * @param {'keyup' | 'keydown'} eventName - The name of the event that was triggered.
+   * @param {KeyboardEvent} event - KeyboardEvent - this is the event that is passed to the event
+   * listener.
+   */
+  private invokeListeners;
+  /**
+   * > If the keyCode is accepted, and the activeElement is in the scope, and the activeElement is not
+   * out of the scope, then invoke the listener
+   *
+   * @param {KeyboardEventListener} listener - KeyboardEventListener - the listener object that we're
+   * checking
+   * @param {string} keyCode - The key code of the key that was pressed.
+   * @returns {boolean} - should invoke
+   */
+  private shouldInvokeListener;
+}
+declare const _default: KeyboardManager;
+export default _default;

package/dist/types/helpers/keyboard/test/keyboard-manager.test.d.ts

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

package/dist/types/helpers/level-tracker/nested-level-tracker.d.ts

@@ -0,0 +1,36 @@
+import { Nullable } from '../../types/general';
+/**
+ * This class is used to track the nested level of a component
+ * by using the target element and tracking element selector
+ *
+ * @property {Map<HTMLElement,{string:number}>} map used to record the nesting level
+ */
+declare class ComponentNestedLevelTracker {
+  private map;
+  /**
+   * If the element matches the selector, then set the level of the element to the level of the parent element + 1
+   *
+   * @param {HTMLElement} el - HTMLElement
+   * @param {string} selector - The selector of the card that is being nested.
+   * @returns {Nullable<number>} The nested level of the element.
+   */
+  setNestedLevel(el: HTMLElement, selector: string): Nullable<number>;
+  /**
+   * Given an element and a selector, return the nested level of that selector
+   *
+   * @param {HTMLElement} el - HTMLElement
+   * @param {string} selector - The selector to look for.
+   * @returns {Nullable<number>} The nullable number of nested levels of the element.
+   */
+  getNestedLevel(el: HTMLElement, selector: string): Nullable<number>;
+  /**
+   * Set the level of a selector for a given element
+   *
+   * @param {HTMLElement} el - HTMLElement
+   * @param {string} selector - The selector for the element.
+   * @param {number} level - The level of the element.
+   */
+  private setLevelToMap;
+}
+declare const _default: ComponentNestedLevelTracker;
+export default _default;

package/dist/types/helpers/level-tracker/test/nested-level-tracker.test.d.ts

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

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

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

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

@@ -0,0 +1,55 @@
+import { VegaLoaderOptions } from './vega-loader';
+import { Nullable } from '../../types/general';
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
+/**
+ * Vega loader controller to control the loading indicator
+ */
+declare class VegaLoaderController {
+  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
+  /**
+   * 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?: VegaLoaderOptions): Nullable<string>;
+  /**
+   * Close the loader by id
+   *
+   * @param {string} id - The id of the loader.
+   * @vegaVersion 1.16.0
+   */
+  close(id: string): void;
+  /**
+   * 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.
+   */
+  private findLoader;
+  /**
+   * Create a loader for loading indicator
+   *
+   * @param {string} containerSelector The container which you want to append
+   * @returns {HTMLElement} a wrapper for loader
+   */
+  private createLoader;
+  /**
+   * Create a loading indicator
+   *
+   * @param {VegaLoaderIndicatorOptions} indicatorOptions the props of vega loading indicator
+   * @returns {HTMLElement} vega-loading-indicator component template
+   */
+  private createLoadingIndicator;
+  /**
+   * 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.
+   */
+  private appendLoader;
+}
+export declare const VegaLoader: VegaLoaderController;
+export {};

package/dist/types/helpers/loading-indicator/vega-loader.d.ts

@@ -0,0 +1,17 @@
+import { ResponsiveType } from '../../types/ui.type';
+import { VegaLoadingIndicatorSize } from '../../components/vega-loading-indicator/types';
+
+export type VegaLoaderIndicatorOptions = {
+	shape?: 'circle' | 'bar';
+	size?: ResponsiveType<VegaLoadingIndicatorSize>;
+	mode?: 'indeterminate' | 'determinate';
+	percent?: number;
+	label?: string;
+	hint?: string;
+	status?: 'default' | 'success' | 'error';
+};
+
+export type VegaLoaderOptions = {
+	containerSelector?: string;
+	indicatorOptions?: VegaLoaderIndicatorOptions;
+};

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

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