@syncfusion/ej2-filemanager 29.2.4 → 30.1.37

package/dist/ts/file-manager/actions/virtualization.d.ts

@@ -0,0 +1,93 @@
+import { FileManager } from '../base';
+export declare class Virtualization {
+    constructor(instance: FileManager);
+    private filemanagerInstance;
+    private largeIconInstance;
+    private itemCount;
+    private rowItemCount;
+    private items;
+    private itemList;
+    private scrollPosition;
+    private totalHeight;
+    private listItemHeight;
+    private topElementHeight;
+    private bottomElementHeight;
+    private renderedCount;
+    private lastRowCount;
+    private topElement;
+    private bottomElement;
+    private listDiff;
+    /**
+     * Sets up UI virtualization for the large icon view.
+     *
+     * @returns {void}
+     */
+    setUIVirtualization(): void;
+    /**
+     * Sets the height of the top and bottom elements that are used for virtualization.
+     * These elements are used to give the appearance of an infinitely scrolling list.
+     *
+     * @returns {void}
+     */
+    setUlElementHeight(): void;
+    /**
+     * Calculates the number of items to display in the list based on the available width and height.
+     *
+     * @param {number} dataSourceLength The length of the data source.
+     * @returns {number} The number of items to display.
+     */
+    private getItemCount;
+    /**
+     * Wires or un wires the scroll event for the list element.
+     *
+     * @param {boolean} destroy - Set `true` to unwire the scroll event.
+     * @returns {void}
+     */
+    wireScrollEvent(destroy: boolean): void;
+    /**
+     * Handles the scroll event for the list element.
+     * This method updates the top and bottom elements and the displayed items based on the scroll position.
+     *
+     * @returns {void}
+     * @private
+     */
+    private onVirtualUiScroll;
+    /**
+     * Calculates the current scroll position of the list element.
+     *
+     * @param {number} startingHeight The starting height from which to calculate the scroll position.
+     * @returns {number} The current scroll position.
+     * @private
+     */
+    private getscrollerHeight;
+    /**
+     * This method updates the displayed items and the selection based on the scroll direction.
+     *
+     * @param {number} listDiff The number of rows to update.
+     * @param {boolean} isScrollingDown If set to true, the scroll direction is downward.
+     * @returns {void}
+     * @private
+     */
+    private onNormalScroll;
+    /**
+     * Updates the items in the large icons view.
+     *
+     * @param {boolean} isScrollingDown - If set to true, the scroll direction is downward.
+     * @returns {void}
+     * @private
+     */
+    private updateUI;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} - returns the module name.
+     * @private
+     */
+    private getModuleName;
+    /**
+     * Destroys the component.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+}

package/dist/ts/file-manager/actions/virtualization.ts

@@ -0,0 +1,324 @@
+import { EventHandler, isNullOrUndefined, detach, formatUnit } from '@syncfusion/ej2-base';
+import { FileManager } from '../base';
+import { ListBase } from '@syncfusion/ej2-lists';
+import { createElement, selectAll } from '@syncfusion/ej2-base';
+import * as CLS from '../base/classes';
+import { LargeIconsView } from '../layout';
+
+export class Virtualization {
+    constructor(instance: FileManager) {
+        this.filemanagerInstance = instance;
+        this.largeIconInstance = instance.largeiconsviewModule;
+    }
+
+    // The file manager component instance
+    private filemanagerInstance: FileManager;
+    // The LargeIconsView module
+    private largeIconInstance: LargeIconsView;
+    // The number of items that can be rendered in the viewport
+    private itemCount: number;
+    // The number of items that can be rendered per row
+    private rowItemCount: number;
+    // The rendered items
+    private items: Object[];
+    // The rendered items element
+    private itemList: HTMLElement[];
+    // The current scroll position of the view
+    private scrollPosition: number;
+    // The total height for rendering all items
+    private totalHeight: number;
+    // The height of each list item
+    private listItemHeight: number;
+    // The height of the top virtual element
+    private topElementHeight: number;
+    // The height of the bottom virtual element
+    private bottomElementHeight: number;
+    // The number of rendered items
+    private renderedCount: number;
+    // The last row's items
+    private lastRowCount: number;
+    // The top div element
+    private topElement: HTMLElement;
+    // The bottom div element
+    private bottomElement: HTMLElement;
+    // The number of rows scrolled
+    private listDiff: number;
+
+
+    /**
+     * Sets up UI virtualization for the large icon view.
+     *
+     * @returns {void}
+     */
+    public setUIVirtualization(): void {
+        // Get the current view data source
+        const currentViewItems: { [key: string]: object; }[] = this.largeIconInstance.items as { [key: string]: object; }[];
+        // Get the first item in the data source
+        const firstItem: { [key: string]: object }[] = currentViewItems.slice(0, 1);
+        // Create a list element from the first item in the data source
+        const listElements: HTMLElement = ListBase.createListFromJson(createElement, firstItem, this.largeIconInstance.listObj);
+        // Get the list items from the list element
+        this.itemList = Array.prototype.slice.call(selectAll('.' + CLS.LIST_ITEM, listElements));
+        // Append the list element to the large icon element
+        this.largeIconInstance.element.appendChild(listElements);
+        if (this.itemList.length !== 0 && this.largeIconInstance.element.querySelector('.' + CLS.EMPTY)) {
+            this.largeIconInstance.element.removeChild(this.largeIconInstance.element.querySelector('.' + CLS.EMPTY));
+        }
+        // Get the total number of items
+        this.itemCount = this.getItemCount(Object.keys(this.largeIconInstance.allItems).length);
+        // Remove the first child element from the large icon element
+        this.largeIconInstance.element.firstChild.remove();
+        // Set the items for the large icon view to the current view data source, limited to the number of items to display
+        this.largeIconInstance.items = currentViewItems.slice(0, this.itemCount);
+    }
+
+    /**
+     * Sets the height of the top and bottom elements that are used for virtualization.
+     * These elements are used to give the appearance of an infinitely scrolling list.
+     *
+     * @returns {void}
+     */
+    public setUlElementHeight(): void {
+        // Calculate the number of items in the last row
+        this.lastRowCount = (this.largeIconInstance.allItems.length - this.itemCount) % this.rowItemCount ?
+            (this.largeIconInstance.allItems.length - this.itemCount) % this.rowItemCount : this.rowItemCount;
+        // Create top and bottom elements
+        this.topElement = this.filemanagerInstance.createElement('div');
+        this.topElement.classList.add('e-virtual-top');
+        this.largeIconInstance.element.firstElementChild.insertBefore(
+            this.topElement, this.largeIconInstance.element.firstElementChild.firstChild);
+        this.bottomElement = this.filemanagerInstance.createElement('div');
+        this.bottomElement.classList.add('e-virtual-bottom');
+        this.largeIconInstance.element.firstElementChild.insertBefore(this.bottomElement, null);
+        // Get the margin value for list items
+        const marginValue: number = parseInt(window.getComputedStyle(this.largeIconInstance.itemList[0]).getPropertyValue('margin-top'), 10) +
+            parseInt(window.getComputedStyle(this.largeIconInstance.itemList[0]).getPropertyValue('margin-bottom'), 10);
+        // Calculate the height of a single list item
+        this.listItemHeight = this.largeIconInstance.itemList[0].getBoundingClientRect().height + marginValue;
+        // Calculate the total height of the list
+        this.totalHeight = (Object.keys(this.largeIconInstance.allItems).length / this.rowItemCount) * this.listItemHeight;
+        // Set the initial height of the top and bottom elements
+        this.topElement.style.height = 0 + 'px';
+        this.bottomElement.style.height = this.totalHeight + 'px';
+        // Initialize the top and bottom element heights
+        this.topElementHeight = 0;
+        this.bottomElementHeight = this.totalHeight;
+        // Initialize the list difference variable
+        this.listDiff = 0;
+        // Set the initial rendered count
+        this.renderedCount = this.itemCount;
+    }
+
+    /**
+     * Calculates the number of items to display in the list based on the available width and height.
+     *
+     * @param {number} dataSourceLength The length of the data source.
+     * @returns {number} The number of items to display.
+     */
+    private getItemCount(dataSourceLength: number): number {
+        // Get the margin values for list items
+        const widthMargin: number = parseInt(window.getComputedStyle(this.itemList[0]).getPropertyValue('margin-right'), 10) +
+            parseInt(window.getComputedStyle(this.itemList[0]).getPropertyValue('margin-left'), 10);
+        // Calculate the number of items that can fit in a single row
+        this.rowItemCount =
+        Math.floor(parseFloat(formatUnit(this.largeIconInstance.element.firstElementChild.clientWidth)) /
+        (this.itemList[0].offsetWidth + widthMargin));
+        // Calculate the number of items that can fit in the available height
+        let itemCount: number =
+        this.rowItemCount *
+        (Math.round(parseFloat(formatUnit(this.largeIconInstance.element.clientHeight)) / this.itemList[0].offsetHeight));
+        // If the calculated item count is greater than the data source length, set the item count to the data source length
+        if (itemCount > dataSourceLength  || itemCount === 0) {
+            itemCount = dataSourceLength;
+        }
+        return itemCount;
+    }
+
+    /**
+     * Wires or un wires the scroll event for the list element.
+     *
+     * @param {boolean} destroy - Set `true` to unwire the scroll event.
+     * @returns {void}
+     */
+    public wireScrollEvent(destroy: boolean): void {
+        if (!destroy) {
+            // Wire the scroll event
+            EventHandler.add(this.largeIconInstance.element.firstElementChild, 'scroll', this.onVirtualUiScroll, this);
+        } else {
+            // Unwire the scroll event
+            EventHandler.remove(this.largeIconInstance.element.firstElementChild, 'scroll', this.onVirtualUiScroll);
+        }
+    }
+
+    /**
+     * Handles the scroll event for the list element.
+     * This method updates the top and bottom elements and the displayed items based on the scroll position.
+     *
+     * @returns {void}
+     * @private
+     */
+    private onVirtualUiScroll(): void {
+        // Set the starting height to 0
+        const startingHeight: number =  0;
+        // Get the current scroll position
+        this.scrollPosition = isNullOrUndefined(this.scrollPosition) ? 0 : this.scrollPosition;
+        const scroll: number = this.getscrollerHeight(startingHeight);
+        // Calculate the height of the top element
+        this.topElementHeight = this.listItemHeight * Math.floor(scroll / this.listItemHeight);
+        // Calculate the height of the bottom element
+        this.bottomElementHeight = this.totalHeight - this.topElementHeight;
+        // If the scroll position is less than or equal to the total height, set the top and bottom element heights.
+        // Otherwise, set the top element height to the total height and the bottom element height to 0.
+        [this.topElementHeight, this.bottomElementHeight] = scroll <= this.totalHeight ?
+            [this.topElementHeight, this.bottomElementHeight] : [this.totalHeight, 0];
+        // If the top element height has changed, update the top and bottom element heights and re-render the items.
+        if (this.topElementHeight !== parseFloat(this.topElement.style.height)) {
+            this.topElement.style.height = this.topElementHeight + 'px';
+            this.bottomElement.style.height = this.bottomElementHeight + 'px';
+            // Check whether the scroll direction is upward or downward
+            if (scroll > this.scrollPosition) {
+                // Scrolling is upward
+                const listDiff: number = Math.round(((this.topElementHeight / this.listItemHeight) - this.listDiff));
+                this.onNormalScroll(listDiff, true);
+            } else {
+                // Scrolling is downward
+                const listDiff: number = Math.round((this.listDiff - (this.topElementHeight / this.listItemHeight)));
+                this.onNormalScroll(listDiff, false);
+            }
+        }
+        // Update the list difference and scroll position variables
+        this.listDiff = Math.round(this.topElementHeight / this.listItemHeight);
+        this.scrollPosition = scroll;
+        // Update the list of items and the items property of the largeIconInstance
+        this.largeIconInstance.itemList = Array.prototype.slice.call(selectAll('.' + CLS.LIST_ITEM, this.largeIconInstance.element));
+        this.itemCount = this.itemCount !== this.largeIconInstance.itemList.length ?
+            this.largeIconInstance.itemList.length : this.itemCount;
+        this.largeIconInstance.items = this.largeIconInstance.allItems.slice(this.renderedCount -
+            this.itemCount, this.renderedCount);
+    }
+
+    /**
+     * Calculates the current scroll position of the list element.
+     *
+     * @param {number} startingHeight The starting height from which to calculate the scroll position.
+     * @returns {number} The current scroll position.
+     * @private
+     */
+    private getscrollerHeight(startingHeight: number): number {
+        // If the scroll position is less than or equal to the starting height, return 0.
+        // Otherwise, return the scroll position minus the starting height.
+        return ((this.largeIconInstance.element.firstElementChild.scrollTop - startingHeight) <= 0) ? 0 :
+            (this.largeIconInstance.element.firstElementChild.scrollTop - startingHeight);
+    }
+
+    /**
+     * This method updates the displayed items and the selection based on the scroll direction.
+     *
+     * @param {number} listDiff The number of rows to update.
+     * @param {boolean} isScrollingDown If set to true, the scroll direction is downward.
+     * @returns {void}
+     * @private
+     */
+    private onNormalScroll(listDiff: number, isScrollingDown: boolean): void {
+        // Update the displayed items
+        for (let i: number = 0; i < listDiff; i++) {
+            this.updateUI(isScrollingDown);
+        }
+    }
+
+    /**
+     * Updates the items in the large icons view.
+     *
+     * @param {boolean} isScrollingDown - If set to true, the scroll direction is downward.
+     * @returns {void}
+     * @private
+     */
+    private updateUI(isScrollingDown: boolean): void {
+        if (isScrollingDown) {
+            // Get the next batch of items to be displayed
+            this.items = this.largeIconInstance.allItems.slice(this.renderedCount, this.renderedCount + this.rowItemCount);
+            // If there are items to be displayed, create list elements for them and append them to the list
+            if (this.items.length > 0) {
+                const listElements: HTMLElement = ListBase.createListFromJson(
+                    createElement, <{ [key: string]: Object; }[]>this.items, this.largeIconInstance.listObj
+                );
+                this.itemList = Array.prototype.slice.call(selectAll('.' + CLS.LIST_ITEM, listElements));
+                this.itemList.forEach((liEle: HTMLElement) => {
+                    this.largeIconInstance.element.firstElementChild.insertBefore(liEle, this.bottomElement);
+                });
+                // Update the rendered count variable
+                this.renderedCount = (this.largeIconInstance.allItems.length >= this.renderedCount + this.rowItemCount) ?
+                    this.renderedCount + this.rowItemCount : this.renderedCount + this.lastRowCount;
+                // Remove the first batch of items from the list
+                for (let i: number = 0; i < this.rowItemCount; i++) {
+                    detach(this.topElement.nextElementSibling);
+                }
+            }
+        } else {
+            // Scrolling up
+            let lastItemIndex: number;
+            let isAllRendered: boolean;
+            if (this.renderedCount === this.largeIconInstance.allItems.length) {
+                // Set lastItemIndex to the last item in the last row
+                lastItemIndex = this.renderedCount - (this.itemCount - this.rowItemCount + this.lastRowCount);
+                // Set renderedCount to the total number of items that have been rendered, except for the items in the last row
+                this.renderedCount = ((this.renderedCount - this.lastRowCount) < this.itemCount) ?
+                    this.itemCount : (this.renderedCount - this.lastRowCount);
+                // Set isAllRendered to true to indicate that all items have been rendered
+                isAllRendered = true;
+            } else {
+                // Set lastItemIndex to the last item in the current row
+                lastItemIndex = this.renderedCount - this.itemCount;
+                // Set renderedCount to the total number of items that have been rendered, except for the items in the current row
+                this.renderedCount = ((this.renderedCount - this.rowItemCount) < this.itemCount) ?
+                    this.itemCount : (this.renderedCount - this.rowItemCount);
+            }
+            // Set startItemIndex to the first item in the current or previous row
+            const startItemIndex: number = (lastItemIndex - this.rowItemCount > 0) ? lastItemIndex - this.rowItemCount : 0;
+            // Set the items array to the items in the current or previous row
+            this.items = this.largeIconInstance.allItems.slice(startItemIndex, lastItemIndex);
+            if (this.items.length > 0) {
+                // Create a list of elements from the items array
+                const listElements: HTMLElement = ListBase.createListFromJson(
+                    createElement, <{ [key: string]: Object; }[]>this.items, this.largeIconInstance.listObj
+                );
+                // Set the itemList array to the list items in the list elements
+                this.itemList = Array.prototype.slice.call(selectAll('.' + CLS.LIST_ITEM, listElements));
+                // Add the items to the beginning of the list
+                for (let len: number = this.itemList.length; len > 0; len--) {
+                    this.largeIconInstance.element.firstElementChild.insertBefore(
+                        this.itemList[len - 1], this.topElement.nextElementSibling
+                    );
+                }
+                // Remove the last row of items from the list
+                for (let i: number = 0; i < ((isAllRendered) ? this.lastRowCount : this.rowItemCount); i++) {
+                    detach(this.bottomElement.previousElementSibling);
+                }
+            }
+        }
+    }
+
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} - returns the module name.
+     * @private
+     */
+    private getModuleName(): string {
+        return 'virtualization';
+    }
+
+    /**
+     * Destroys the component.
+     *
+     * @returns {void}
+     */
+    public destroy(): void {
+        // If the file manager has already been destroyed, return immediately
+        if (this.filemanagerInstance.isDestroyed) { return; }
+        // If the large icon element has a child element, unwire the scroll event
+        if (!isNullOrUndefined(this.largeIconInstance.element.firstElementChild)) {
+            this.wireScrollEvent(true);
+        }
+    }
+}

package/dist/ts/file-manager/base/classes.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Specifies the File Manager internal ID's
+ */
+/** @hidden */
+export declare const TOOLBAR_ID: string;
+/** @hidden */
+export declare const LAYOUT_ID: string;
+/** @hidden */
+export declare const NAVIGATION_ID: string;
+/** @hidden */
+export declare const TREE_ID: string;
+/** @hidden */
+export declare const GRID_ID: string;
+/** @hidden */
+export declare const LARGEICON_ID: string;
+/** @hidden */
+export declare const DIALOG_ID: string;
+/** @hidden */
+export declare const ALT_DIALOG_ID: string;
+/** @hidden */
+export declare const IMG_DIALOG_ID: string;
+/** @hidden */
+export declare const EXTN_DIALOG_ID: string;
+/** @hidden */
+export declare const UPLOAD_DIALOG_ID: string;
+/** @hidden */
+export declare const RETRY_DIALOG_ID: string;
+/** @hidden */
+export declare const CONTEXT_MENU_ID: string;
+/** @hidden */
+export declare const SORTBY_ID: string;
+/** @hidden */
+export declare const VIEW_ID: string;
+/** @hidden */
+export declare const SPLITTER_ID: string;
+/** @hidden */
+export declare const CONTENT_ID: string;
+/** @hidden */
+export declare const BREADCRUMBBAR_ID: string;
+/** @hidden */
+export declare const UPLOAD_ID: string;
+/** @hidden */
+export declare const RETRY_ID: string;
+/** @hidden */
+export declare const SEARCH_ID: string;
+/**
+ * Specifies the File Manager internal class names
+ */
+/** @hidden */
+export declare const ROOT: string;
+/** @hidden */
+export declare const CONTROL: string;
+/** @hidden */
+export declare const CHECK_SELECT: string;
+/** @hidden */
+export declare const ROOT_POPUP: string;
+/** @hidden */
+export declare const MOBILE: string;
+/** @hidden */
+export declare const MOB_POPUP: string;
+/** @hidden */
+export declare const MULTI_SELECT: string;
+/** @hidden */
+export declare const FILTER: string;
+/** @hidden */
+export declare const LAYOUT: string;
+/** @hidden */
+export declare const NAVIGATION: string;
+/** @hidden */
+export declare const LAYOUT_CONTENT: string;
+/** @hidden */
+export declare const LARGE_ICONS: string;
+/** @hidden */
+export declare const TB_ITEM: string;
+/** @hidden */
+export declare const LIST_ITEM: string;
+/** @hidden */
+export declare const LIST_TEXT: string;
+/** @hidden */
+export declare const LIST_PARENT: string;
+/** @hidden */
+export declare const TB_OPTION_TICK: string;
+/** @hidden */
+export declare const TB_OPTION_DOT: string;
+/** @hidden */
+export declare const BLUR: string;
+/** @hidden */
+export declare const ACTIVE: string;
+/** @hidden */
+export declare const HOVER: string;
+/** @hidden */
+export declare const FOCUS: string;
+/** @hidden */
+export declare const FOCUSED: string;
+/** @hidden */
+export declare const CHECK: string;
+/** @hidden */
+export declare const FRAME: string;
+/** @hidden */
+export declare const CB_WRAP: string;
+/** @hidden */
+export declare const ROW: string;
+/** @hidden */
+export declare const ROWCELL: string;
+/** @hidden */
+export declare const EMPTY: string;
+/** @hidden */
+export declare const EMPTY_CONTENT: string;
+/** @hidden */
+export declare const EMPTY_INNER_CONTENT: string;
+/** @hidden */
+export declare const CLONE: string;
+/** @hidden */
+export declare const DROP_FOLDER: string;
+/** @hidden */
+export declare const DROP_FILE: string;
+/** @hidden */
+export declare const FOLDER: string;
+/** @hidden */
+export declare const ICON_IMAGE: string;
+/** @hidden */
+export declare const ICON_MUSIC: string;
+/** @hidden */
+export declare const ICON_VIDEO: string;
+/** @hidden */
+export declare const LARGE_ICON: string;
+/** @hidden */
+export declare const LARGE_EMPTY_FOLDER: string;
+/** @hidden */
+export declare const LARGE_EMPTY_FOLDER_TWO: string;
+/** @hidden */
+export declare const LARGE_ICON_FOLDER: string;
+/** @hidden */
+export declare const SELECTED_ITEMS: string;
+/** @hidden */
+export declare const TEXT_CONTENT: string;
+/** @hidden */
+export declare const GRID_HEADER: string;
+/** @hidden */
+export declare const TEMPLATE_CELL: string;
+/** @hidden */
+export declare const TREE_VIEW: string;
+/** @hidden */
+export declare const MENU_ITEM: string;
+/** @hidden */
+export declare const MENU_ICON: string;
+/** @hidden */
+export declare const SUBMENU_ICON: string;
+/** @hidden */
+export declare const GRID_VIEW: string;
+/** @hidden */
+export declare const GRID_CONTENT: string;
+/** @hidden */
+export declare const ICON_VIEW: string;
+/** @hidden */
+export declare const ICON_OPEN: string;
+/** @hidden */
+export declare const ICON_UPLOAD: string;
+/** @hidden */
+export declare const ICON_CUT: string;
+/** @hidden */
+export declare const ICON_COPY: string;
+/** @hidden */
+export declare const ICON_PASTE: string;
+/** @hidden */
+export declare const ICON_DELETE: string;
+/** @hidden */
+export declare const ICON_RENAME: string;
+/** @hidden */
+export declare const ICON_NEWFOLDER: string;
+/** @hidden */
+export declare const ICON_DETAILS: string;
+/** @hidden */
+export declare const ICON_SHORTBY: string;
+/** @hidden */
+export declare const ICON_REFRESH: string;
+/** @hidden */
+export declare const ICON_SELECTALL: string;
+/** @hidden */
+export declare const ICON_DOWNLOAD: string;
+/** @hidden */
+export declare const ICON_OPTIONS: string;
+/** @hidden */
+export declare const ICON_GRID: string;
+/** @hidden */
+export declare const ICON_LARGE: string;
+/** @hidden */
+export declare const ICON_BREADCRUMB: string;
+/** @hidden */
+export declare const ICON_CLEAR: string;
+/** @hidden */
+export declare const ICON_DROP_IN: string;
+/** @hidden */
+export declare const ICON_DROP_OUT: string;
+/** @hidden */
+export declare const ICON_NO_DROP: string;
+/** @hidden */
+export declare const ICONS: string;
+/** @hidden */
+export declare const DETAILS_LABEL: string;
+/** @hidden */
+export declare const ERROR_CONTENT: string;
+/** @hidden */
+export declare const STATUS: string;
+/** @hidden */
+export declare const BREADCRUMBS: string;
+/** @hidden */
+export declare const RTL: string;
+/** @hidden */
+export declare const DISPLAY_NONE: string;
+/** @hidden */
+export declare const COLLAPSED: string;
+/** @hidden */
+export declare const FULLROW: string;
+/** @hidden */
+export declare const ICON_COLLAPSIBLE: string;
+/** @hidden */
+export declare const SPLIT_BAR: string;
+/** @hidden */
+export declare const HEADER_CHECK: string;
+/** @hidden */
+export declare const OVERLAY: string;
+/** @hidden */
+export declare const VALUE: string;