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

package/blazorGlobalSrc/rich-text-editor/actions/execute-command-callback.d.ts

@@ -0,0 +1,11 @@
+import { IRichTextEditor } from '../base/interface';
+/**
+ * `ExecCommandCallBack` module is used to run the editor manager command
+ */
+export declare class ExecCommandCallBack {
+    protected parent: IRichTextEditor;
+    constructor(parent?: IRichTextEditor);
+    private addEventListener;
+    private commandCallBack;
+    private removeEventListener;
+}

package/blazorGlobalSrc/rich-text-editor/actions/execute-command-callback.js

@@ -0,0 +1,28 @@
+define(["require", "exports", "../base/constant", "@syncfusion/ej2-base"], function (require, exports, events, ej2_base_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ExecCommandCallBack = (function () {
+        function ExecCommandCallBack(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        ExecCommandCallBack.prototype.addEventListener = function () {
+            this.parent.on(events.execCommandCallBack, this.commandCallBack, this);
+            this.parent.on(events.destroy, this.removeEventListener, this);
+        };
+        ExecCommandCallBack.prototype.commandCallBack = function (args) {
+            var formatPainterCopy = !ej2_base_1.isNullOrUndefined(args.requestType) && args.requestType === 'FormatPainter' && args.action === 'format-copy';
+            if (!ej2_base_1.isNullOrUndefined(args) && !ej2_base_1.isNullOrUndefined(args.requestType) && args.requestType !== 'Undo' && args.requestType !== 'Redo' && !formatPainterCopy) {
+                this.parent.formatter.saveData();
+            }
+            this.parent.notify(events.toolbarRefresh, { args: args });
+            this.parent.notify(events.count, {});
+        };
+        ExecCommandCallBack.prototype.removeEventListener = function () {
+            this.parent.off(events.execCommandCallBack, this.commandCallBack);
+            this.parent.off(events.destroy, this.removeEventListener);
+        };
+        return ExecCommandCallBack;
+    }());
+    exports.ExecCommandCallBack = ExecCommandCallBack;
+});

package/blazorGlobalSrc/rich-text-editor/actions/file-manager.d.ts

@@ -0,0 +1,45 @@
+import { Dialog } from '@syncfusion/ej2-popups';
+import { IRichTextEditor } from '../base/interface';
+/**
+ * `FileManager` module is used to display the directories and images inside the editor.
+ */
+export declare class FileManager {
+    private i10n;
+    dialogObj: Dialog;
+    private fileWrap;
+    private fileObj;
+    private contentModule;
+    protected parent: IRichTextEditor;
+    private inputUrl;
+    private selectObj;
+    private dlgButtons;
+    private dialogRenderObj;
+    private rendererFactory;
+    private isDestroyed;
+    private insertImageBoundFn;
+    private cancelDialogBoundFn;
+    private renderFileManagerBoundFn;
+    private dialogClosedBoundFn;
+    private onDocumentClickBoundFn;
+    private constructor();
+    private initialize;
+    private render;
+    private setCssClass;
+    private dialogClosed;
+    private renderFileManager;
+    private getInputUrlElement;
+    private insertImageUrl;
+    private cancelDialog;
+    private onDocumentClick;
+    private addEventListener;
+    private removeEventListener;
+    private destroyComponents;
+    private destroy;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} - returns the string value
+     * @hidden
+     */
+    private getModuleName;
+}

package/blazorGlobalSrc/rich-text-editor/actions/file-manager.js

@@ -0,0 +1,249 @@
+define(["require", "exports", "@syncfusion/ej2-base", "@syncfusion/ej2-filemanager", "@syncfusion/ej2-filemanager", "../base/enum", "../base/constant", "../base/classes", "../base/util"], function (require, exports, ej2_base_1, ej2_filemanager_1, ej2_filemanager_2, enum_1, events, classes, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var FileManager = (function () {
+        function FileManager(parent, locator) {
+            ej2_filemanager_1.FileManager.Inject(ej2_filemanager_1.ContextMenu, ej2_filemanager_1.DetailsView, ej2_filemanager_2.NavigationPane, ej2_filemanager_2.Toolbar);
+            this.parent = parent;
+            this.i10n = locator.getService('rteLocale');
+            this.dialogRenderObj = locator.getService('dialogRenderObject');
+            this.rendererFactory = locator.getService('rendererFactory');
+            this.addEventListener();
+            this.isDestroyed = false;
+            this.insertImageBoundFn = this.insertImageUrl.bind(this);
+            this.cancelDialogBoundFn = this.cancelDialog.bind(this);
+            this.renderFileManagerBoundFn = this.renderFileManager.bind(this);
+            this.dialogClosedBoundFn = this.dialogClosed.bind(this);
+            this.onDocumentClickBoundFn = this.onDocumentClick.bind(this);
+        }
+        FileManager.prototype.initialize = function () {
+            this.contentModule = this.rendererFactory.getRenderer(enum_1.RenderType.Content);
+        };
+        FileManager.prototype.render = function (e) {
+            var dlgInsert;
+            if (e.selectNode && e.selectNode[0].nodeName === 'IMG') {
+                dlgInsert = this.parent.localeObj.getConstant('dialogUpdate');
+            }
+            else {
+                dlgInsert = this.i10n.getConstant('dialogInsert');
+            }
+            var dlgHeader = this.parent.localeObj.getConstant('fileDialogHeader');
+            var dlgCancel = this.i10n.getConstant('dialogCancel');
+            this.dlgButtons = [{
+                    click: this.insertImageBoundFn,
+                    buttonModel: { content: dlgInsert, cssClass: 'e-flat e-insertImage', isPrimary: true, disabled: true }
+                },
+                {
+                    click: this.cancelDialogBoundFn,
+                    buttonModel: { cssClass: 'e-flat e-cancel', content: dlgCancel }
+                }];
+            this.selectObj = { selection: e.selection, args: e.args, selectParent: e.selectParent };
+            var dlgTarget = this.parent.createElement('div', {
+                className: 'e-rte-file-manager-dialog', id: this.parent.getID() + '_file-manager-dialog',
+                attrs: { 'aria-owns': this.parent.getID() }
+            });
+            document.body.appendChild(dlgTarget);
+            this.fileWrap = this.parent.createElement('div', {
+                id: this.parent.getID() + '_rte-file-manager', className: 'e-img-file-wrap'
+            });
+            dlgTarget.appendChild(this.fileWrap);
+            dlgTarget.appendChild(this.getInputUrlElement());
+            var dialogModel = {
+                visible: false,
+                isModal: true, header: dlgHeader,
+                target: document.body, locale: this.parent.locale,
+                enableRtl: this.parent.enableRtl, cssClass: classes.CLS_RTE_ELEMENTS,
+                animationSettings: { effect: 'None' },
+                showCloseIcon: true, closeOnEscape: true, width: '720px', height: 'auto',
+                position: { X: 'center', Y: 'center' },
+                buttons: this.dlgButtons,
+                created: this.renderFileManagerBoundFn,
+                close: this.dialogClosedBoundFn
+            };
+            this.dialogObj = this.dialogRenderObj.render(dialogModel);
+            this.dialogObj.createElement = this.parent.createElement;
+            this.dialogObj.appendTo(dlgTarget);
+            this.dialogObj.show(ej2_base_1.Browser.isDevice ? true : false);
+            this.setCssClass({ cssClass: this.parent.getCssClass() });
+        };
+        FileManager.prototype.setCssClass = function (e) {
+            if (this.dialogObj && e.cssClass) {
+                if (ej2_base_1.isNullOrUndefined(e.oldCssClass)) {
+                    this.dialogObj.setProperties({ cssClass: (this.dialogObj.cssClass + ' ' + e.cssClass).trim() });
+                }
+                else {
+                    this.dialogObj.setProperties({ cssClass: (this.dialogObj.cssClass.replace(e.oldCssClass, '').trim() + ' ' + e.cssClass).trim() });
+                }
+            }
+        };
+        FileManager.prototype.dialogClosed = function (e) {
+            this.parent.isBlur = false;
+            if (e && e.event.returnValue) {
+                this.selectObj.selection.restore();
+            }
+            this.destroyComponents();
+            this.parent.element.ownerDocument.removeEventListener('mousedown', this.onDocumentClickBoundFn);
+            this.dialogRenderObj.close(e);
+        };
+        FileManager.prototype.renderFileManager = function () {
+            var _this = this;
+            this.fileObj = new ej2_filemanager_1.FileManager({
+                allowMultiSelection: false,
+                locale: this.parent.locale,
+                enableRtl: this.parent.enableRtl,
+                path: this.parent.fileManagerSettings.path,
+                view: this.parent.fileManagerSettings.view,
+                enablePersistence: this.parent.enablePersistence,
+                cssClass: this.parent.fileManagerSettings.cssClass,
+                sortOrder: this.parent.fileManagerSettings.sortOrder,
+                ajaxSettings: this.parent.fileManagerSettings.ajaxSettings,
+                showThumbnail: this.parent.fileManagerSettings.showThumbnail,
+                rootAliasName: this.parent.fileManagerSettings.rootAliasName,
+                uploadSettings: this.parent.fileManagerSettings.uploadSettings,
+                searchSettings: this.parent.fileManagerSettings.searchSettings,
+                toolbarSettings: this.parent.fileManagerSettings.toolbarSettings,
+                showHiddenItems: this.parent.fileManagerSettings.showHiddenItems,
+                allowDragAndDrop: this.parent.fileManagerSettings.allowDragAndDrop,
+                showFileExtension: this.parent.fileManagerSettings.showFileExtension,
+                detailsViewSettings: this.parent.fileManagerSettings.detailsViewSettings,
+                contextMenuSettings: this.parent.fileManagerSettings.contextMenuSettings,
+                navigationPaneSettings: this.parent.fileManagerSettings.navigationPaneSettings,
+                beforeSend: this.parent.fileManagerSettings.beforeSend,
+                fileSelect: function (e) {
+                    var selectedFile = e.fileDetails;
+                    if (selectedFile.isFile && _this.parent.insertImageSettings.allowedTypes.indexOf(selectedFile.type) > -1) {
+                        _this.inputUrl.value = _this.parent.fileManagerSettings.ajaxSettings.getImageUrl + '?path=' +
+                            (selectedFile.filterPath && selectedFile.filterPath.replace(/\\/g, '/')) + selectedFile.name;
+                        _this.dlgButtons[0].buttonModel.disabled = false;
+                    }
+                    else {
+                        _this.inputUrl.value = '';
+                        _this.dlgButtons[0].buttonModel.disabled = true;
+                    }
+                    _this.dialogObj.setProperties({ buttons: _this.dlgButtons });
+                },
+                created: function () {
+                    _this.inputUrl.removeAttribute('disabled');
+                },
+                success: function () {
+                    _this.fileObj.refreshLayout();
+                }
+            });
+            if (ej2_base_1.Browser.isDevice) {
+                this.fileObj.height = '85%';
+            }
+            this.fileObj.appendTo(this.fileWrap);
+            this.parent.element.ownerDocument.addEventListener('mousedown', this.onDocumentClickBoundFn);
+        };
+        FileManager.prototype.getInputUrlElement = function () {
+            var imgUrl = this.parent.createElement('div', { className: 'imgUrl' });
+            var urlLabel = this.parent.createElement('div', { className: 'e-rte-label' });
+            urlLabel.innerHTML = '<label for="rteSample_img_url">' + this.i10n.getConstant('linkWebUrl') + '</label>';
+            imgUrl.appendChild(urlLabel);
+            var placeUrl = this.i10n.getConstant('imageUrl');
+            this.inputUrl = this.parent.createElement('input', {
+                className: 'e-input e-img-url',
+                attrs: { placeholder: placeUrl, spellcheck: 'false', disabled: 'true' }
+            });
+            imgUrl.appendChild(this.inputUrl);
+            return imgUrl;
+        };
+        FileManager.prototype.insertImageUrl = function (e) {
+            var url = this.inputUrl.value;
+            if (this.parent.formatter.getUndoRedoStack().length === 0) {
+                this.parent.formatter.saveData();
+            }
+            if (url !== '') {
+                if (this.parent.editorMode === 'HTML' &&
+                    ej2_base_1.isNullOrUndefined(ej2_base_1.closest(this.selectObj.selection.range.startContainer.parentNode, '#' + this.contentModule.getPanel().id))) {
+                    this.contentModule.getEditPanel().focus();
+                    var range = this.parent.formatter.editorManager.nodeSelection.getRange(this.contentModule.getDocument());
+                    this.selectObj.selection = this.parent.formatter.editorManager.nodeSelection.save(range, this.contentModule.getDocument());
+                    this.selectObj.selectParent = this.parent.formatter.editorManager.nodeSelection.getParentNodeCollection(range);
+                }
+                var regex = /[\w-]+.(jpg|png|jpeg|gif)/g;
+                var matchUrl = (!ej2_base_1.isNullOrUndefined(url.match(regex)) && this.parent.editorMode === 'HTML') ? url.match(regex)[0] : '';
+                var value = {
+                    cssClass: (this.parent.insertImageSettings.display === 'inline' ? classes.CLS_IMGINLINE : classes.CLS_IMGBREAK),
+                    url: url, selection: this.selectObj.selection, altText: matchUrl, selectParent: this.selectObj.selectParent,
+                    width: {
+                        width: this.parent.insertImageSettings.width, minWidth: this.parent.insertImageSettings.minWidth,
+                        maxWidth: this.parent.getInsertImgMaxWidth()
+                    },
+                    height: {
+                        height: this.parent.insertImageSettings.height, minHeight: this.parent.insertImageSettings.minHeight,
+                        maxHeight: this.parent.insertImageSettings.maxHeight
+                    }
+                };
+                this.parent.formatter.process(this.parent, this.selectObj.args, this.selectObj.args.originalEvent, value);
+                this.dialogObj.hide({ returnValue: false });
+            }
+        };
+        FileManager.prototype.cancelDialog = function () {
+            this.parent.isBlur = false;
+            this.dialogObj.hide({ returnValue: true });
+        };
+        FileManager.prototype.onDocumentClick = function (e) {
+            var target = e.target;
+            var prevEle = target.nodeName !== '#document' && !ej2_base_1.isNullOrUndefined(target.previousElementSibling) && target.previousElementSibling;
+            if (!ej2_base_1.isNullOrUndefined(this.dialogObj) &&
+                (!ej2_base_1.closest(target, '#' + this.parent.getID() + '_file-manager-dialog') &&
+                    !ej2_base_1.closest(target, '#' + this.parent.getID() + '_rte-file-manager_tb_sortby-popup') &&
+                    !ej2_base_1.closest(target, '#' + this.parent.getID() + '_rte-file-manager_tb_view-popup') &&
+                    !ej2_base_1.closest(target, '#' + this.parent.getID() + '_rte-file-manager_contextmenu') &&
+                    (!(!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(target, '.e-contextmenu-wrapper')) &&
+                        ej2_base_1.closest(target, '.e-contextmenu-wrapper').querySelector('#' + this.parent.getID() + '_rte-file-manager_contextmenu'))) &&
+                    (!ej2_base_1.isNullOrUndefined(prevEle) && !prevEle.classList.contains('e-rte-file-manager-dialog')) &&
+                    (!ej2_base_1.isNullOrUndefined(prevEle) && prevEle.id !== this.parent.getID() + '_rte-file-manager_contextmenu'))) {
+                this.dialogObj.hide({ returnValue: true });
+                this.parent.isBlur = true;
+                util_1.dispatchEvent(this.parent.element, 'focusout');
+            }
+            else {
+                this.parent.isRTE = true;
+            }
+        };
+        FileManager.prototype.addEventListener = function () {
+            this.parent.on(events.initialEnd, this.initialize, this);
+            this.parent.on(events.renderFileManager, this.render, this);
+            this.parent.on(events.bindCssClass, this.setCssClass, this);
+            this.parent.on(events.destroy, this.destroy, this);
+        };
+        FileManager.prototype.removeEventListener = function () {
+            this.parent.element.ownerDocument.removeEventListener('mousedown', this.onDocumentClickBoundFn);
+            this.parent.off(events.initialEnd, this.initialize);
+            this.parent.off(events.renderFileManager, this.render);
+            this.parent.off(events.bindCssClass, this.setCssClass);
+            this.parent.off(events.destroy, this.destroy);
+        };
+        FileManager.prototype.destroyComponents = function () {
+            if (this.fileObj) {
+                this.fileObj.destroy();
+                this.fileObj = null;
+            }
+            if (this.dialogObj) {
+                this.dialogObj.destroy();
+                ej2_base_1.detach(this.dialogObj.element);
+            }
+        };
+        FileManager.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.destroyComponents();
+            this.removeEventListener();
+            this.dlgButtons = null;
+            this.isDestroyed = true;
+            this.insertImageBoundFn = null;
+            this.cancelDialogBoundFn = null;
+            this.renderFileManagerBoundFn = null;
+            this.dialogClosedBoundFn = null;
+            this.onDocumentClickBoundFn = null;
+        };
+        FileManager.prototype.getModuleName = function () {
+            return 'fileManager';
+        };
+        return FileManager;
+    }());
+    exports.FileManager = FileManager;
+});

package/blazorGlobalSrc/rich-text-editor/actions/format-painter.d.ts

@@ -0,0 +1,25 @@
+import { IFormatPainter, IRichTextEditor } from '../base/interface';
+export declare class FormatPainter implements IFormatPainter {
+    private parent;
+    private isSticky;
+    private isActive;
+    previousAction: string;
+    private isDestroyed;
+    constructor(parent?: IRichTextEditor);
+    private addEventListener;
+    private toolbarClick;
+    private toolbarDoubleClick;
+    private onKeyDown;
+    private actionHandler;
+    private updateCursor;
+    private updateToolbarBtn;
+    private editAreaClick;
+    destroy(): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    private getModuleName;
+}

package/blazorGlobalSrc/rich-text-editor/actions/format-painter.js

@@ -0,0 +1,156 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../base/constant"], function (require, exports, ej2_base_1, events) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var FormatPainter = (function () {
+        function FormatPainter(parent) {
+            this.isSticky = false;
+            this.isActive = false;
+            this.parent = parent;
+            this.addEventListener();
+            this.isDestroyed = false;
+        }
+        FormatPainter.prototype.addEventListener = function () {
+            this.parent.on(events.formatPainterClick, this.toolbarClick, this);
+            this.parent.on(events.formatPainterDoubleClick, this.toolbarDoubleClick, this);
+            this.parent.on(events.editAreaClick, this.editAreaClick, this);
+            this.parent.on(events.keyDown, this.onKeyDown, this);
+            this.parent.on(events.destroy, this.destroy, this);
+        };
+        FormatPainter.prototype.toolbarClick = function (clickargs) {
+            this.parent.focusIn();
+            if (!this.isSticky) {
+                this.isActive = true;
+                this.actionHandler(clickargs, 'click');
+            }
+            else {
+                clickargs.args.action = 'escape';
+                this.actionHandler(clickargs, 'keyBoard');
+            }
+            if (this.parent.quickToolbarModule && !ej2_base_1.isNullOrUndefined(this.parent.quickToolbarSettings.text) &&
+                this.parent.element.ownerDocument.contains(this.parent.quickToolbarModule.textQTBar.element)) {
+                this.parent.quickToolbarModule.textQTBar.hidePopup();
+            }
+        };
+        FormatPainter.prototype.toolbarDoubleClick = function (args) {
+            this.isActive = true;
+            this.isSticky = true;
+            this.parent.focusIn();
+            this.actionHandler(args, 'dbClick');
+        };
+        FormatPainter.prototype.onKeyDown = function (event) {
+            var originalEvent = event.args;
+            if (!ej2_base_1.isNullOrUndefined(originalEvent) && !ej2_base_1.isNullOrUndefined(originalEvent.action) && (originalEvent.action === 'format-copy' || originalEvent.action === 'format-paste')
+                || (originalEvent.action === 'escape' && (this.previousAction === 'format-copy' || this.previousAction === 'format-paste'))) {
+                if ((originalEvent.action === 'format-copy' || originalEvent.action === 'format-paste')) {
+                    originalEvent.stopPropagation();
+                }
+                if (this.parent.userAgentData.getBrowser() === 'Firefox' || this.parent.userAgentData.getBrowser() === 'Safari') {
+                    originalEvent.preventDefault();
+                }
+                this.actionHandler(event, 'keyBoard');
+            }
+        };
+        FormatPainter.prototype.actionHandler = function (event, type) {
+            var action;
+            var isKeyboard = false;
+            var originalEvent;
+            var args;
+            var item;
+            switch (type) {
+                case 'dbClick':
+                    args = event.args;
+                    item = args.item;
+                    originalEvent = event.args.originalEvent;
+                    action = 'format-copy';
+                    break;
+                case 'keyBoard':
+                    args = null;
+                    originalEvent = event.args;
+                    isKeyboard = true;
+                    action = event.args.action;
+                    if (action === 'escape') {
+                        this.isSticky = false;
+                        this.isActive = false;
+                    }
+                    break;
+                case 'click':
+                    args = event.args;
+                    item = args.item;
+                    originalEvent = event.args.originalEvent;
+                    action = 'format-copy';
+                    break;
+                case 'docClick':
+                    originalEvent = event;
+                    action = 'format-paste';
+                    break;
+            }
+            if (ej2_base_1.isNullOrUndefined(item)) {
+                item = {
+                    command: 'FormatPainter',
+                    subCommand: 'FormatPainter'
+                };
+            }
+            var actionBeginArgs = {
+                requestType: 'FormatPainter', originalEvent: originalEvent, name: action, item: item
+            };
+            var value = {
+                formatPainterAction: action
+            };
+            this.parent.formatter.process(this.parent, actionBeginArgs, originalEvent, value);
+            if (!actionBeginArgs.cancel) {
+                this.updateCursor(isKeyboard);
+                var enable = type === 'docClick' || action === 'escape' ? false : true;
+                this.updateToolbarBtn(enable);
+            }
+            this.previousAction = action;
+        };
+        FormatPainter.prototype.updateCursor = function (isKeyboard) {
+            if (!this.parent.inputElement.classList.contains('e-rte-cursor-brush') && !isKeyboard) {
+                ej2_base_1.addClass([this.parent.inputElement], 'e-rte-cursor-brush');
+            }
+            else if (!this.isSticky) {
+                ej2_base_1.removeClass([this.parent.inputElement], 'e-rte-cursor-brush');
+            }
+        };
+        FormatPainter.prototype.updateToolbarBtn = function (enable) {
+            if (!ej2_base_1.isNullOrUndefined(this.parent.element.querySelector('.e-rte-format-painter'))) {
+                var toolbarBtn = this.parent.element.querySelector('.e-rte-format-painter').parentElement.parentElement;
+                if (enable) {
+                    ej2_base_1.addClass([toolbarBtn], 'e-active');
+                }
+                else if (!this.isSticky) {
+                    ej2_base_1.removeClass([toolbarBtn], 'e-active');
+                }
+            }
+        };
+        FormatPainter.prototype.editAreaClick = function (args) {
+            if (this.isActive) {
+                if (!this.isSticky) {
+                    this.isActive = false;
+                }
+                this.actionHandler(args, 'docClick');
+                this.updateToolbarBtn(false);
+            }
+        };
+        FormatPainter.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.parent.off(events.formatPainterClick, this.toolbarClick);
+            this.parent.off(events.editAreaClick, this.editAreaClick);
+            this.parent.off(events.formatPainterDoubleClick, this.toolbarDoubleClick);
+            this.parent.off(events.keyDown, this.onKeyDown);
+            this.parent.off(events.destroy, this.destroy);
+            this.parent = null;
+            this.isSticky = null;
+            this.isActive = null;
+            this.previousAction = null;
+            this.isDestroyed = true;
+        };
+        FormatPainter.prototype.getModuleName = function () {
+            return 'formatPainter';
+        };
+        return FormatPainter;
+    }());
+    exports.FormatPainter = FormatPainter;
+});

package/blazorGlobalSrc/rich-text-editor/actions/full-screen.d.ts

@@ -0,0 +1,40 @@
+import { KeyboardEventArgs } from '@syncfusion/ej2-base';
+import { IRichTextEditor } from '../base/interface';
+/**
+ * `FullScreen` module is used to maximize and minimize screen
+ */
+export declare class FullScreen {
+    protected parent: IRichTextEditor;
+    private scrollableParent;
+    constructor(parent?: IRichTextEditor);
+    /**
+     * showFullScreen method
+     *
+     * @param {MouseEvent} event - specifies the mouse event
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    showFullScreen(event?: MouseEvent | KeyboardEventArgs): void;
+    /**
+     * hideFullScreen method
+     *
+     * @param {MouseEvent} event - specifies the mouse event
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    hideFullScreen(event?: MouseEvent | KeyboardEventArgs): void;
+    private toggleParentOverflow;
+    private onKeyDown;
+    protected addEventListener(): void;
+    protected removeEventListener(): void;
+    /**
+     * destroy method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+}