@syncfusion/ej2-richtexteditor 29.2.4-738301 → 29.2.4-760237

package/blazorGlobalSrc/rich-text-editor/actions/base-toolbar.js

@@ -0,0 +1,216 @@
+define(["require", "exports", "../base/enum", "../base/classes", "../base/constant", "../base/util", "../models/items", "@syncfusion/ej2-base", "../renderer"], function (require, exports, enum_1, classes_1, events, util_1, items_1, ej2_base_1, renderer_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var BaseToolbar = (function () {
+        function BaseToolbar(parent, serviceLocator) {
+            this.tools = {};
+            this.parent = parent;
+            this.locator = serviceLocator;
+            this.isDestroyed = false;
+            this.renderFactory = this.locator.getService('rendererFactory');
+            this.addEventListener();
+            if (this.parent.toolbarSettings && Object.keys(this.parent.toolbarSettings.itemConfigs).length > 0) {
+                ej2_base_1.extend(this.tools, items_1.tools, util_1.toObjectLowerCase(this.parent.toolbarSettings.itemConfigs), true);
+            }
+            else {
+                this.tools = items_1.tools;
+            }
+            if (this.parent.toolbarSettings.enable || this.parent.quickToolbarSettings.enable) {
+                this.toolbarRenderer = new renderer_1.ToolbarRenderer(this.parent, this.locator);
+                this.renderFactory.addRenderer(enum_1.RenderType.Toolbar, this.toolbarRenderer);
+            }
+        }
+        BaseToolbar.prototype.addEventListener = function () {
+            this.parent.on(events.rtlMode, this.setRtl, this);
+            this.parent.on(events.bindCssClass, this.setCssClass, this);
+        };
+        BaseToolbar.prototype.removeEventListener = function () {
+            this.parent.off(events.rtlMode, this.setRtl);
+            this.parent.off(events.bindCssClass, this.setCssClass);
+        };
+        BaseToolbar.prototype.setCssClass = function (e) {
+            if (!ej2_base_1.isNullOrUndefined(this.toolbarObj)) {
+                if (ej2_base_1.isNullOrUndefined(e.oldCssClass)) {
+                    this.toolbarObj.setProperties({ cssClass: (this.toolbarObj.cssClass + ' ' + e.cssClass).trim() });
+                }
+                else {
+                    this.toolbarObj.setProperties({ cssClass: (this.toolbarObj.cssClass.replace(e.oldCssClass, '').trim() + ' ' + e.cssClass).trim() });
+                }
+            }
+        };
+        BaseToolbar.prototype.setRtl = function (args) {
+            if (!ej2_base_1.isNullOrUndefined(this.toolbarObj)) {
+                this.toolbarObj.setProperties({ enableRtl: args.enableRtl });
+            }
+        };
+        BaseToolbar.prototype.getClass = function (item) {
+            var classes;
+            switch (item) {
+                case 'fontsize':
+                    classes = 'e-rte-inline-size-template';
+                    break;
+                case 'fontcolor':
+                case 'backgroundcolor':
+                    classes = 'e-rte-inline-color-template';
+                    break;
+                default:
+                    classes = 'e-rte-inline-template';
+                    break;
+            }
+            return classes;
+        };
+        BaseToolbar.prototype.getTemplateObject = function (itemStr, container) {
+            var tagName;
+            switch (itemStr) {
+                case 'fontcolor':
+                case 'backgroundcolor':
+                case 'numberformatlist':
+                case 'bulletformatlist':
+                    tagName = 'span';
+                    break;
+                default:
+                    tagName = 'button';
+                    break;
+            }
+            return {
+                command: this.tools[itemStr.toLocaleLowerCase()].command,
+                subCommand: this.tools[itemStr.toLocaleLowerCase()].subCommand,
+                template: this.parent.createElement(tagName, {
+                    id: this.parent.getID() + '_' + container
+                        + '_' + this.tools[itemStr.toLocaleLowerCase()].id
+                }).outerHTML,
+                cssClass: this.parent.inlineMode.enable ? this.getClass(itemStr) : '',
+                tooltipText: util_1.getTooltipText(itemStr, this.locator)
+            };
+        };
+        BaseToolbar.prototype.getObject = function (item, container) {
+            var itemStr = item.toLowerCase();
+            if (items_1.templateItems.indexOf(itemStr) !== -1) {
+                return this.getTemplateObject(itemStr, container);
+            }
+            else {
+                switch (itemStr) {
+                    case '|':
+                        return { type: 'Separator' };
+                    case '-':
+                        return { type: 'Separator', cssClass: classes_1.CLS_HR_SEPARATOR };
+                    default:
+                        return {
+                            id: this.parent.getID() + '_' + container + '_' + this.tools[itemStr.toLocaleLowerCase()].id,
+                            prefixIcon: this.tools[itemStr.toLocaleLowerCase()].icon,
+                            tooltipText: util_1.getTooltipText(itemStr, this.locator),
+                            command: this.tools[itemStr.toLocaleLowerCase()].command,
+                            subCommand: this.tools[itemStr.toLocaleLowerCase()].subCommand
+                        };
+                }
+            }
+        };
+        BaseToolbar.prototype.getItems = function (tbItems, container) {
+            var _this = this;
+            if (this.parent.toolbarSettings.items.length < 1) {
+                return [];
+            }
+            var items = [];
+            var _loop_1 = function (item) {
+                switch (typeof item) {
+                    case 'string':
+                        items.push(this_1.getObject(item, container));
+                        break;
+                    default:
+                        if (!ej2_base_1.isNullOrUndefined(item.click)) {
+                            var proxy_1 = item;
+                            var callback_1 = proxy_1.click;
+                            proxy_1.click = function () {
+                                if (proxy_1.undo && _this.parent.formatter.getUndoRedoStack().length === 0) {
+                                    _this.parent.formatter.saveData();
+                                }
+                                callback_1.call(_this);
+                                if (_this.parent.formatter.getUndoRedoStack().length > 0) {
+                                    var currentContentElem = _this.parent.createElement('div');
+                                    var stackItem = _this.parent.formatter.
+                                        getUndoRedoStack()[_this.parent.formatter.getUndoRedoStack().length - 1];
+                                    var clonedItem = (stackItem.text).cloneNode(true);
+                                    currentContentElem.appendChild(clonedItem);
+                                    if (currentContentElem.innerHTML.trim() === _this.parent.inputElement.innerHTML.trim()) {
+                                        return;
+                                    }
+                                }
+                                if (proxy_1.undo) {
+                                    _this.parent.formatter.saveData();
+                                }
+                            };
+                        }
+                        items.push(item);
+                }
+            };
+            var this_1 = this;
+            for (var _i = 0, tbItems_1 = tbItems; _i < tbItems_1.length; _i++) {
+                var item = tbItems_1[_i];
+                _loop_1(item);
+            }
+            if (this.parent.showTooltip) {
+                var _loop_2 = function (num) {
+                    var tooltipText = items[num].tooltipText;
+                    var shortCutKey = void 0;
+                    var isMacDev = this_2.parent.userAgentData.getPlatform() === 'macOS';
+                    if (items_1.windowKeys["" + items[num].subCommand] && (!ej2_base_1.isNullOrUndefined(items[num].id) || !ej2_base_1.isNullOrUndefined(items[num].cssClass))) {
+                        var shortcuts = items_1.windowKeys["" + items[num].subCommand].split(',');
+                        shortCutKey = shortcuts.map(function (shortcut) {
+                            return isMacDev
+                                ? shortcut.replace('Ctrl+', '⌘').replace('Shift+', '⇧').replace('Alt+', '⌥')
+                                : shortcut;
+                        }).join(', ');
+                    }
+                    else {
+                        shortCutKey = tooltipText;
+                    }
+                    if (shortCutKey) {
+                        if (!(items[num].command === 'Images' && items[num].subCommand === 'InsertLink')) {
+                            items[num].tooltipText = (tooltipText !== shortCutKey) ? tooltipText + ' (' + shortCutKey + ')' : tooltipText;
+                        }
+                    }
+                };
+                var this_2 = this;
+                for (var num = 0; num < items.length; num++) {
+                    _loop_2(num);
+                }
+            }
+            return items;
+        };
+        BaseToolbar.prototype.getToolbarOptions = function (args) {
+            return {
+                target: args.target,
+                rteToolbarObj: this,
+                items: this.getItems(args.items, args.container),
+                overflowMode: args.mode,
+                enablePersistence: this.parent.enablePersistence,
+                enableRtl: this.parent.enableRtl,
+                cssClass: args.cssClass,
+                type: args.container
+            };
+        };
+        BaseToolbar.prototype.render = function (args) {
+            this.toolbarRenderer = this.renderFactory.getRenderer(enum_1.RenderType.Toolbar);
+            if (this.toolbarRenderer && this.toolbarRenderer.isDestroyed) {
+                this.toolbarRenderer = new renderer_1.ToolbarRenderer(this.parent, this.locator);
+            }
+            this.toolbarRenderer.renderToolbar(this.getToolbarOptions(args));
+        };
+        BaseToolbar.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.removeEventListener();
+            if (this.toolbarObj && !this.toolbarObj.isDestroyed) {
+                this.toolbarObj.destroy();
+                this.toolbarObj = null;
+            }
+            this.toolbarRenderer.destroy();
+            this.toolbarRenderer = null;
+            this.tools = {};
+            this.isDestroyed = true;
+        };
+        return BaseToolbar;
+    }());
+    exports.BaseToolbar = BaseToolbar;
+});

package/blazorGlobalSrc/rich-text-editor/actions/color-picker.d.ts

@@ -0,0 +1,52 @@
+import { IRichTextEditor, IRenderer, IColorPickerRenderArgs } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { RendererFactory } from '../services/renderer-factory';
+import { DropDownButton } from '@syncfusion/ej2-splitbuttons';
+/**
+ * `Color Picker` module is used to handle ColorPicker actions.
+ */
+export declare class ColorPickerInput {
+    private defaultColorPicker;
+    private fontColorPicker;
+    private backgroundColorPicker;
+    /**
+     * @hidden
+     */
+    fontColorDropDown: DropDownButton;
+    /**
+     * @hidden
+     */
+    backgroundColorDropDown: DropDownButton;
+    protected parent: IRichTextEditor;
+    protected locator: ServiceLocator;
+    protected toolbarRenderer: IRenderer;
+    protected renderFactory: RendererFactory;
+    private tools;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    private initializeInstance;
+    /**
+     * renderColorPickerInput method
+     *
+     * @param {IColorPickerRenderArgs} args - specify the arguments.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    renderColorPickerInput(args: IColorPickerRenderArgs): void;
+    destroy(): void;
+    /**
+     * destroyColorPicker method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroyColorPicker(): void;
+    private setRtl;
+    private setCssClass;
+    private updateCss;
+    protected addEventListener(): void;
+    private showColorPicker;
+    private onPropertyChanged;
+    protected removeEventListener(): void;
+}

package/blazorGlobalSrc/rich-text-editor/actions/color-picker.js

@@ -0,0 +1,241 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../base/enum", "../base/constant", "../base/classes", "../base/util", "../models/items"], function (require, exports, ej2_base_1, enum_1, events, classes, util_1, items_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ColorPickerInput = (function () {
+        function ColorPickerInput(parent, serviceLocator) {
+            this.tools = {};
+            this.parent = parent;
+            this.locator = serviceLocator;
+            this.renderFactory = this.locator.getService('rendererFactory');
+            this.addEventListener();
+            if (this.parent.toolbarSettings && Object.keys(this.parent.toolbarSettings.itemConfigs).length > 0) {
+                ej2_base_1.extend(this.tools, items_1.tools, util_1.toObjectLowerCase(this.parent.toolbarSettings.itemConfigs), true);
+            }
+            else {
+                this.tools = items_1.tools;
+            }
+        }
+        ColorPickerInput.prototype.initializeInstance = function () {
+            this.toolbarRenderer = this.renderFactory.getRenderer(enum_1.RenderType.Toolbar);
+        };
+        ColorPickerInput.prototype.renderColorPickerInput = function (args) {
+            var _this = this;
+            this.initializeInstance();
+            var suffixID = args.containerType;
+            var tbElement = args.container;
+            var targetID;
+            var options;
+            items_1.templateItems.forEach(function (item) {
+                if (util_1.getIndex(item, args.items) !== -1) {
+                    switch (item) {
+                        case 'fontcolor': {
+                            targetID = _this.parent.getID() + '_' + suffixID + '_FontColor_Target';
+                            var fontNode = _this.parent.createElement('input');
+                            fontNode.id = targetID;
+                            fontNode.classList.add(classes.CLS_FONT_COLOR_TARGET);
+                            if (!ej2_base_1.isNullOrUndefined(_this.parent.cssClass)) {
+                                var allClassName = _this.parent.cssClass.split(' ');
+                                for (var i = 0; i < allClassName.length; i++) {
+                                    if (allClassName[i].trim() !== '') {
+                                        fontNode.classList.add(allClassName[i]);
+                                    }
+                                }
+                            }
+                            document.body.appendChild(fontNode);
+                            options = {
+                                cssClass: _this.tools[item.toLocaleLowerCase()].icon
+                                    + ' ' + classes.CLS_RTE_ELEMENTS + ' ' + classes.CLS_ICONS + _this.parent.getCssClass(true),
+                                value: _this.tools[item.toLocaleLowerCase()].value,
+                                command: _this.tools[item.toLocaleLowerCase()].command,
+                                subCommand: _this.tools[item.toLocaleLowerCase()].subCommand,
+                                element: ej2_base_1.select('#' + _this.parent.getID() + '_' + suffixID + '_FontColor', tbElement),
+                                target: (targetID)
+                            };
+                            _this.fontColorPicker = _this.toolbarRenderer.renderColorPicker(options, 'fontcolor');
+                            _this.fontColorDropDown = _this.toolbarRenderer.renderColorPickerDropDown(options, 'fontcolor', _this.fontColorPicker);
+                            break;
+                        }
+                        case 'backgroundcolor': {
+                            targetID = _this.parent.getID() + '_' + suffixID + '_BackgroundColor_Target';
+                            var backNode = _this.parent.createElement('input');
+                            backNode.id = targetID;
+                            backNode.classList.add(classes.CLS_BACKGROUND_COLOR_TARGET);
+                            if (!ej2_base_1.isNullOrUndefined(_this.parent.cssClass)) {
+                                var allClassName = _this.parent.cssClass.split(' ');
+                                for (var i = 0; i < allClassName.length; i++) {
+                                    if (allClassName[i].trim() !== '') {
+                                        backNode.classList.add(allClassName[i]);
+                                    }
+                                }
+                            }
+                            document.body.appendChild(backNode);
+                            options = {
+                                cssClass: _this.tools[item.toLocaleLowerCase()].icon
+                                    + ' ' + classes.CLS_RTE_ELEMENTS + ' ' + classes.CLS_ICONS + _this.parent.getCssClass(true),
+                                value: _this.tools[item.toLocaleLowerCase()].value,
+                                command: _this.tools[item.toLocaleLowerCase()].command,
+                                subCommand: _this.tools[item.toLocaleLowerCase()].subCommand,
+                                element: ej2_base_1.select('#' + _this.parent.getID() + '_' + suffixID + '_BackgroundColor', tbElement),
+                                target: (targetID)
+                            };
+                            _this.backgroundColorPicker = _this.toolbarRenderer.renderColorPicker(options, 'backgroundcolor', args.containerType);
+                            _this.backgroundColorDropDown = _this.toolbarRenderer.renderColorPickerDropDown(options, 'backgroundcolor', _this.backgroundColorPicker, _this.defaultColorPicker, args.containerType);
+                            break;
+                        }
+                    }
+                }
+            });
+            if (this.parent.inlineMode.enable) {
+                this.setCssClass({ cssClass: this.parent.getCssClass() });
+            }
+        };
+        ColorPickerInput.prototype.destroy = function () {
+            this.removeEventListener();
+            this.destroyColorPicker();
+            this.defaultColorPicker = null;
+            this.fontColorPicker = null;
+            this.fontColorDropDown = null;
+            this.backgroundColorDropDown = null;
+            this.backgroundColorPicker = null;
+            this.tools = {};
+        };
+        ColorPickerInput.prototype.destroyColorPicker = function () {
+            if (this.fontColorPicker && !this.fontColorPicker.isDestroyed) {
+                this.fontColorPicker.destroy();
+            }
+            if (this.backgroundColorPicker && !this.backgroundColorPicker.isDestroyed) {
+                this.backgroundColorPicker.destroy();
+            }
+            if (this.fontColorDropDown && !this.fontColorDropDown.isDestroyed) {
+                var innerEle = this.fontColorDropDown.element.querySelector('.e-rte-color-content');
+                if (innerEle) {
+                    ej2_base_1.detach(innerEle);
+                }
+                this.fontColorDropDown.destroy();
+            }
+            if (this.backgroundColorDropDown && !this.backgroundColorDropDown.isDestroyed) {
+                var innerEle = this.backgroundColorDropDown.element.querySelector('.e-rte-color-content');
+                if (innerEle) {
+                    this.defaultColorPicker = innerEle.children[0].style.borderBottomColor;
+                    ej2_base_1.detach(innerEle);
+                }
+                this.backgroundColorDropDown.destroy();
+            }
+        };
+        ColorPickerInput.prototype.setRtl = function (args) {
+            if (this.fontColorPicker) {
+                this.fontColorPicker.setProperties({ enableRtl: args.enableRtl });
+                this.fontColorDropDown.setProperties({ enableRtl: args.enableRtl });
+            }
+            if (this.backgroundColorPicker) {
+                this.backgroundColorPicker.setProperties({ enableRtl: args.enableRtl });
+                this.backgroundColorDropDown.setProperties({ enableRtl: args.enableRtl });
+            }
+        };
+        ColorPickerInput.prototype.setCssClass = function (e) {
+            this.updateCss(this.fontColorPicker, this.fontColorDropDown, e);
+            this.updateCss(this.backgroundColorPicker, this.backgroundColorDropDown, e);
+        };
+        ColorPickerInput.prototype.updateCss = function (colorPickerObj, dropDownObj, e) {
+            if (colorPickerObj && e.cssClass) {
+                if (ej2_base_1.isNullOrUndefined(e.oldCssClass)) {
+                    colorPickerObj.setProperties({ cssClass: (colorPickerObj.cssClass + ' ' + e.cssClass).trim() });
+                    dropDownObj.setProperties({ cssClass: (dropDownObj.cssClass + ' ' + e.cssClass).trim() });
+                }
+                else {
+                    colorPickerObj.setProperties({ cssClass: (colorPickerObj.cssClass.replace(e.oldCssClass, '').replace('  ', ' ').trim() + ' ' + e.cssClass).trim() });
+                    dropDownObj.setProperties({ cssClass: (dropDownObj.cssClass.replace(e.oldCssClass, '').replace('  ', ' ').trim() + ' ' + e.cssClass).trim() });
+                }
+            }
+        };
+        ColorPickerInput.prototype.addEventListener = function () {
+            this.parent.on(events.toolbarRenderComplete, this.renderColorPickerInput, this);
+            this.parent.on(events.rtlMode, this.setRtl, this);
+            this.parent.on(events.modelChanged, this.onPropertyChanged, this);
+            this.parent.on(events.bindCssClass, this.setCssClass, this);
+            this.parent.on(events.showColorPicker, this.showColorPicker, this);
+        };
+        ColorPickerInput.prototype.showColorPicker = function (e) {
+            if (!ej2_base_1.isNullOrUndefined(this.fontColorPicker) && (e.toolbarClick === 'fontcolor')) {
+                this.fontColorDropDown.toggle();
+            }
+            else if (!ej2_base_1.isNullOrUndefined(this.backgroundColorPicker) && (e.toolbarClick === 'backgroundcolor')) {
+                this.backgroundColorDropDown.toggle();
+            }
+        };
+        ColorPickerInput.prototype.onPropertyChanged = function (model) {
+            var newProp = model.newProp;
+            var element;
+            for (var _i = 0, _a = Object.keys(newProp); _i < _a.length; _i++) {
+                var prop = _a[_i];
+                switch (prop) {
+                    case 'fontColor':
+                        if (this.fontColorPicker) {
+                            for (var _b = 0, _c = Object.keys(newProp.fontColor); _b < _c.length; _b++) {
+                                var font = _c[_b];
+                                switch (font) {
+                                    case 'default': {
+                                        this.fontColorPicker.setProperties({ value: newProp.fontColor.default });
+                                        element = this.fontColorDropDown.element;
+                                        var fontBorder = element.querySelector('.' + this.tools['fontcolor'].icon);
+                                        fontBorder.style.borderBottomColor = newProp.fontColor.default;
+                                        break;
+                                    }
+                                    case 'mode':
+                                        this.fontColorPicker.setProperties({ mode: newProp.fontColor.mode });
+                                        break;
+                                    case 'columns':
+                                        this.fontColorPicker.setProperties({ columns: newProp.fontColor.columns });
+                                        break;
+                                    case 'colorCode':
+                                        this.fontColorPicker.setProperties({ presetColors: newProp.fontColor.colorCode });
+                                        break;
+                                    case 'modeSwitcher':
+                                        this.fontColorPicker.setProperties({ modeSwitcher: newProp.fontColor.modeSwitcher });
+                                        break;
+                                }
+                            }
+                        }
+                        break;
+                    case 'backgroundColor':
+                        if (this.backgroundColorPicker) {
+                            for (var _d = 0, _e = Object.keys(newProp.backgroundColor); _d < _e.length; _d++) {
+                                var background = _e[_d];
+                                switch (background) {
+                                    case 'default': {
+                                        this.backgroundColorPicker.setProperties({ value: newProp.backgroundColor.default });
+                                        element = this.backgroundColorDropDown.element;
+                                        var backgroundBorder = element.querySelector('.' + this.tools['backgroundcolor'].icon);
+                                        backgroundBorder.style.borderBottomColor = newProp.backgroundColor.default;
+                                        break;
+                                    }
+                                    case 'mode':
+                                        this.backgroundColorPicker.setProperties({ mode: newProp.backgroundColor.mode });
+                                        break;
+                                    case 'columns':
+                                        this.backgroundColorPicker.setProperties({ columns: newProp.backgroundColor.columns });
+                                        break;
+                                    case 'colorCode':
+                                        this.backgroundColorPicker.setProperties({ presetColors: newProp.backgroundColor.colorCode });
+                                        break;
+                                    case 'modeSwitcher':
+                                        this.backgroundColorPicker.setProperties({ modeSwitcher: newProp.backgroundColor.modeSwitcher });
+                                        break;
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+        };
+        ColorPickerInput.prototype.removeEventListener = function () {
+            this.parent.off(events.toolbarRenderComplete, this.renderColorPickerInput);
+            this.parent.off(events.rtlMode, this.setRtl);
+            this.parent.off(events.modelChanged, this.onPropertyChanged);
+            this.parent.off(events.bindCssClass, this.setCssClass);
+            this.parent.off(events.showColorPicker, this.showColorPicker);
+        };
+        return ColorPickerInput;
+    }());
+    exports.ColorPickerInput = ColorPickerInput;
+});

package/blazorGlobalSrc/rich-text-editor/actions/count.d.ts

@@ -0,0 +1,55 @@
+import { IRichTextEditor } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { RendererFactory } from '../services/renderer-factory';
+/**
+ * `Count` module is used to handle Count actions.
+ */
+export declare class Count {
+    protected parent: IRichTextEditor;
+    protected maxLength: number;
+    protected htmlLength: number;
+    protected locator: ServiceLocator;
+    protected renderFactory: RendererFactory;
+    private editPanel;
+    private contentModule;
+    private contentRenderer;
+    private args;
+    private element;
+    private isDestroyed;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    private initializeInstance;
+    /**
+     * renderCount method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    renderCount(): void;
+    private appendCount;
+    private charCountBackground;
+    /**
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    refresh(): void;
+    /**
+     * Destroys the Count.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    private toggle;
+    protected addEventListener(): void;
+    protected removeEventListener(): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} - returns the string value
+     */
+    private getModuleName;
+}