@syncfusion/ej2-richtexteditor 19.2.57 → 19.3.43

package/src/rich-text-editor/actions/enter-key.js

@@ -0,0 +1,290 @@
+import { isNullOrUndefined as isNOU, detach } from '@syncfusion/ej2-base';
+import * as events from '../base/constant';
+/**
+ * `EnterKey` module is used to handle enter key press actions.
+ */
+var EnterKeyAction = /** @class */ (function () {
+    function EnterKeyAction(parent) {
+        this.parent = parent;
+        this.addEventListener();
+    }
+    EnterKeyAction.prototype.addEventListener = function () {
+        this.parent.on(events.enterHandler, this.enterHandler, this);
+        this.parent.on(events.destroy, this.destroy, this);
+    };
+    EnterKeyAction.prototype.destroy = function () {
+        this.removeEventListener();
+    };
+    EnterKeyAction.prototype.removeEventListener = function () {
+        this.parent.off(events.enterHandler, this.enterHandler);
+        this.parent.off(events.destroy, this.destroy);
+    };
+    EnterKeyAction.prototype.getRangeNode = function () {
+        this.range = this.parent.getRange();
+        this.startNode = this.range.startContainer.nodeName === '#text' ? this.range.startContainer.parentElement :
+            this.range.startContainer;
+        this.endNode = this.range.endContainer.nodeName === '#text' ? this.range.endContainer.parentElement :
+            this.range.endContainer;
+    };
+    EnterKeyAction.prototype.enterHandler = function (e) {
+        var _this = this;
+        this.getRangeNode();
+        if (e.args.which === 13 && e.args.code === 'Enter') {
+            if (isNOU(this.startNode.closest('LI')) && isNOU(this.endNode.closest('LI')) && isNOU(this.startNode.closest('TABLE')) &&
+                isNOU(this.endNode.closest('TABLE')) && isNOU(this.startNode.closest('PRE')) && isNOU(this.endNode.closest('PRE'))) {
+                var shiftKey_1 = e.args.shiftKey;
+                var actionBeginArgs = {
+                    cancel: false,
+                    name: events.actionBegin,
+                    requestType: shiftKey_1 ? 'ShiftEnterAction' : 'EnterAction',
+                    originalEvent: e.args
+                };
+                this.parent.trigger(events.actionBegin, actionBeginArgs, function (actionBeginArgs) {
+                    if (!actionBeginArgs.cancel) {
+                        if (!(_this.range.startOffset === _this.range.endOffset && _this.range.startContainer === _this.range.endContainer)) {
+                            _this.range.deleteContents();
+                            if (_this.range.startContainer.nodeName === '#text' && _this.range.startContainer.textContent.length === 0 &&
+                                _this.range.startContainer.parentElement !== _this.parent.inputElement) {
+                                if (_this.parent.enterKey === 'BR') {
+                                    _this.range.startContainer.parentElement.innerHTML = '​';
+                                }
+                                else {
+                                    _this.range.startContainer.parentElement.innerHTML = '<br>';
+                                }
+                            }
+                            else if (_this.range.startContainer === _this.parent.inputElement && _this.range.startContainer.innerHTML === '') {
+                                _this.range.startContainer.innerHTML = '<br>';
+                                var focusElem = _this.range.startContainer.childNodes[_this.range.startOffset];
+                                _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), focusElem, 0);
+                            }
+                            else if (_this.parent.inputElement === _this.range.startContainer) {
+                                var focusElem = _this.range.startContainer.childNodes[_this.range.startOffset];
+                                if (focusElem.nodeName === '#text' && focusElem.textContent.length === 0) {
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), focusElem, focusElem.previousSibling.textContent.length);
+                                }
+                                else {
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), focusElem, focusElem.textContent.length >= 0 ? 0 : 1);
+                                    if (focusElem.previousSibling.textContent.length === 0) {
+                                        detach(focusElem.previousSibling);
+                                    }
+                                    else if (focusElem.textContent.length === 0) {
+                                        var currentFocusElem = focusElem.previousSibling.lastChild;
+                                        var finalFocusElem = void 0;
+                                        while (currentFocusElem.nodeName !== '#text') {
+                                            finalFocusElem = currentFocusElem;
+                                            currentFocusElem = currentFocusElem.lastChild;
+                                        }
+                                        _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), currentFocusElem, currentFocusElem.textContent.length);
+                                        detach(focusElem);
+                                    }
+                                    else if (_this.parent.enterKey !== 'BR' &&
+                                        focusElem.previousSibling.textContent.length !== 0 && focusElem.textContent.length !== 0) {
+                                        e.args.preventDefault();
+                                        return;
+                                    }
+                                }
+                                _this.getRangeNode();
+                            }
+                        }
+                        if (_this.range.startContainer === _this.range.endContainer && _this.range.startOffset === 0 &&
+                            _this.range.startOffset == _this.range.endOffset && _this.range.startContainer === _this.parent.inputElement) {
+                            _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), _this.range.startContainer.childNodes[_this.range.startOffset], _this.range.startOffset);
+                            _this.getRangeNode();
+                        }
+                        if (_this.parent.enterKey === 'P' || _this.parent.enterKey === 'DIV' ||
+                            (_this.parent.shiftEnterKey === 'P' && shiftKey_1) ||
+                            (_this.parent.shiftEnterKey === 'DIV' && shiftKey_1)) {
+                            var nearBlockNode = _this.parent.formatter.editorManager.domNode.blockParentNode(_this.startNode);
+                            var isImageNode = false;
+                            if (_this.range.startOffset === 0 && _this.range.endOffset === 0 && !(!isNOU(_this.range.startContainer.previousSibling) && _this.range.startContainer.previousSibling.nodeName === 'IMG')) {
+                                var isNearBlockLengthZero = void 0;
+                                var newElem = void 0;
+                                if (_this.range.startContainer.nodeName === 'IMG') {
+                                    newElem = _this.createInsertElement(shiftKey_1);
+                                    isImageNode = true;
+                                    isNearBlockLengthZero = false;
+                                }
+                                else {
+                                    if (nearBlockNode.textContent.length !== 0) {
+                                        newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, nearBlockNode, false).cloneNode(true);
+                                        isNearBlockLengthZero = false;
+                                    }
+                                    else {
+                                        newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, nearBlockNode, true).cloneNode(true);
+                                        isNearBlockLengthZero = true;
+                                    }
+                                }
+                                var insertElem = _this.createInsertElement(shiftKey_1);
+                                while (newElem.firstChild) {
+                                    insertElem.appendChild(newElem.firstChild);
+                                }
+                                nearBlockNode.parentElement.insertBefore(insertElem, nearBlockNode);
+                                if (!isNearBlockLengthZero) {
+                                    var currentFocusElem = insertElem;
+                                    var finalFocusElem = void 0;
+                                    while (!isNOU(currentFocusElem) && currentFocusElem.nodeName !== '#text') {
+                                        finalFocusElem = currentFocusElem;
+                                        currentFocusElem = currentFocusElem.lastChild;
+                                    }
+                                    finalFocusElem.innerHTML = '<br>';
+                                    if (!isImageNode) {
+                                        detach(nearBlockNode);
+                                    }
+                                }
+                            }
+                            else if (nearBlockNode.textContent.length === 0 && !(!isNOU(nearBlockNode.childNodes[0]) && nearBlockNode.childNodes[0].nodeName === 'IMG')) {
+                                if (!isNOU(nearBlockNode.children[0]) && nearBlockNode.children[0].tagName !== 'BR') {
+                                    var newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, nearBlockNode, false).cloneNode(true);
+                                    _this.parent.formatter.editorManager.domNode.insertAfter(newElem, nearBlockNode);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), newElem, newElem.textContent.length >= 0 ? 0 : 1);
+                                }
+                                else {
+                                    var insertElem = _this.createInsertElement(shiftKey_1);
+                                    insertElem.innerHTML = '<br>';
+                                    _this.parent.formatter.editorManager.domNode.insertAfter(insertElem, nearBlockNode);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), insertElem, 0);
+                                }
+                            }
+                            else {
+                                var newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, nearBlockNode, true);
+                                if (!isNOU(newElem.childNodes[0]) && newElem.childNodes[0].nodeName === '#text' &&
+                                    newElem.childNodes[0].textContent.length === 0) {
+                                    detach(newElem.childNodes[0]);
+                                }
+                                if (newElem.textContent.trim().length === 0) {
+                                    var brElm = _this.parent.createElement('br');
+                                    _this.startNode.appendChild(brElm);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), _this.startNode, 0);
+                                }
+                                if (((_this.parent.enterKey === 'P' || _this.parent.enterKey === 'DIV') && !shiftKey_1) || ((_this.parent.shiftEnterKey === 'DIV' ||
+                                    _this.parent.shiftEnterKey === 'P') && shiftKey_1)) {
+                                    var insertElm = _this.createInsertElement(shiftKey_1);
+                                    while (newElem.firstChild) {
+                                        insertElm.appendChild(newElem.firstChild);
+                                    }
+                                    _this.parent.formatter.editorManager.domNode.insertAfter(insertElm, newElem);
+                                    detach(newElem);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), insertElm, insertElm.textContent.length >= 0 ? 0 : 1);
+                                }
+                            }
+                            e.args.preventDefault();
+                        }
+                        if (_this.parent.enterKey === 'BR' && !shiftKey_1) {
+                            var currentParent = void 0;
+                            if (!_this.parent.formatter.editorManager.domNode.isBlockNode(_this.startNode)) {
+                                var currentNode = _this.startNode;
+                                var previousNode = currentNode;
+                                while (!_this.parent.formatter.editorManager.domNode.isBlockNode(currentNode)) {
+                                    previousNode = currentNode;
+                                    currentNode = currentNode.parentElement;
+                                }
+                                currentParent = currentNode === _this.parent.inputElement ?
+                                    previousNode : currentNode;
+                            }
+                            else {
+                                currentParent = _this.startNode;
+                            }
+                            var isEmptyBrInserted = false;
+                            if (currentParent !== _this.parent.inputElement &&
+                                _this.parent.formatter.editorManager.domNode.isBlockNode(currentParent) &&
+                                _this.range.startOffset === _this.range.endOffset &&
+                                _this.range.startOffset === currentParent.textContent.length) {
+                                var outerBRElem = _this.parent.createElement('br');
+                                _this.parent.formatter.editorManager.domNode.insertAfter(outerBRElem, currentParent);
+                                _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), outerBRElem, 0);
+                            }
+                            else if (!isNOU(currentParent) && currentParent !== _this.parent.inputElement && currentParent.nodeName !== 'BR') {
+                                if (currentParent.textContent.trim().length === 0 || (currentParent.textContent.trim().length === 1 &&
+                                    currentParent.textContent.charCodeAt(0) === 8203)) {
+                                    var newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, currentParent, true).cloneNode(true);
+                                    _this.parent.formatter.editorManager.domNode.insertAfter(newElem, currentParent);
+                                    var outerBRElem = _this.parent.createElement('br');
+                                    newElem.parentElement.insertBefore(outerBRElem, newElem);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), newElem, 0);
+                                }
+                                else {
+                                    var newElem = void 0;
+                                    var focusElem = void 0;
+                                    var outerBRElem = _this.parent.createElement('br');
+                                    if (_this.range.startOffset === 0 && _this.range.endOffset === 0 &&
+                                        !isNOU(currentParent.previousSibling) && currentParent.previousSibling.nodeName === 'BR') {
+                                        focusElem = _this.range.startContainer;
+                                        newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, currentParent, false).cloneNode(true);
+                                        _this.parent.formatter.editorManager.domNode.insertAfter(outerBRElem, currentParent);
+                                        _this.insertFocusContent();
+                                        var currentFocusElem = outerBRElem.nextSibling;
+                                        var finalFocusElem = void 0;
+                                        while (!isNOU(currentFocusElem) && currentFocusElem.nodeName !== '#text') {
+                                            finalFocusElem = currentFocusElem;
+                                            currentFocusElem = currentFocusElem.lastChild;
+                                        }
+                                        _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), currentFocusElem, 0);
+                                        isEmptyBrInserted = true;
+                                    }
+                                    else {
+                                        newElem = _this.parent.formatter.editorManager.nodeCutter.SplitNode(_this.range, currentParent, true);
+                                        newElem.parentElement.insertBefore(outerBRElem, newElem);
+                                        _this.insertFocusContent();
+                                    }
+                                }
+                            }
+                            else {
+                                var brElm = _this.parent.createElement('br');
+                                if (_this.startNode.nodeName === 'BR' && _this.endNode.nodeName === 'BR' && _this.range.startOffset === 0 && _this.range.startOffset === _this.range.endOffset) {
+                                    _this.parent.formatter.editorManager.domNode.insertAfter(brElm, _this.startNode);
+                                    isEmptyBrInserted = true;
+                                }
+                                else {
+                                    if (_this.startNode === _this.parent.inputElement && !isNOU(_this.range.startContainer.previousSibling) &&
+                                        _this.range.startContainer.previousSibling.nodeName === 'BR' && _this.range.startContainer.textContent.length === 0) {
+                                        isEmptyBrInserted = true;
+                                    }
+                                    _this.range.insertNode(brElm);
+                                }
+                                if (isEmptyBrInserted || (!isNOU(brElm.nextElementSibling) && brElm.nextElementSibling.tagName === 'BR') || (!isNOU(brElm.nextSibling) && brElm.nextSibling.textContent.length > 0)) {
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), !isNOU(brElm.nextSibling) ? brElm.nextSibling : brElm, 0);
+                                    isEmptyBrInserted = false;
+                                }
+                                else {
+                                    var brElm2 = _this.parent.createElement('br');
+                                    _this.range.insertNode(brElm2);
+                                    _this.parent.formatter.editorManager.nodeSelection.setCursorPoint(_this.parent.contentModule.getDocument(), brElm, 0);
+                                }
+                            }
+                            e.args.preventDefault();
+                        }
+                        if (_this.range.startContainer.nodeName === '#text') {
+                            _this.range.startContainer.parentElement.scrollIntoView(false);
+                        }
+                        else {
+                            _this.range.startContainer.scrollIntoView(false);
+                        }
+                        _this.parent.trigger(events.actionComplete, { requestType: shiftKey_1 ? 'ShiftEnterAction' : 'EnterAction', args: e.args });
+                    }
+                });
+            }
+        }
+    };
+    EnterKeyAction.prototype.insertFocusContent = function () {
+        if (this.range.startContainer.textContent.length === 0) {
+            if (this.range.startContainer.nodeName === '#text') {
+                this.range.startContainer.parentElement.innerHTML = '&#8203;';
+            }
+            else {
+                this.range.startContainer.innerHTML = '&#8203;';
+            }
+        }
+    };
+    EnterKeyAction.prototype.createInsertElement = function (shiftKey) {
+        var insertElem;
+        if ((this.parent.enterKey === 'DIV' && !shiftKey) || (this.parent.shiftEnterKey === 'DIV' && shiftKey)) {
+            insertElem = this.parent.createElement('div');
+        }
+        else if ((this.parent.enterKey === 'P' && !shiftKey) || (this.parent.shiftEnterKey === 'P' && shiftKey)) {
+            insertElem = this.parent.createElement('p');
+        }
+        return insertElem;
+    };
+    return EnterKeyAction;
+}());
+export { EnterKeyAction };

package/src/rich-text-editor/actions/full-screen.js

@@ -20,35 +20,45 @@ var FullScreen = /** @class */ (function () {
 
      */
     FullScreen.prototype.showFullScreen = function (event) {
+        var _this = this;
         if (this.parent.toolbarSettings.enable === true && this.parent.editorMode !== 'Markdown'
             && !isNOU(this.parent.quickToolbarModule)) {
             this.parent.quickToolbarModule.hideQuickToolbars();
         }
         this.scrollableParent = getScrollableParent(this.parent.element);
         if (!this.parent.element.classList.contains(classes.CLS_FULL_SCREEN)) {
-            this.parent.trigger(events.actionBegin, { requestType: 'Maximize', targetItem: 'Maximize', args: event });
-            if (this.parent.toolbarSettings.enableFloating &&
-                !this.parent.inlineMode.enable && this.parent.toolbarSettings.enable) {
-                this.parent.getToolbarElement().style.width = '100%';
-                this.parent.getToolbarElement().style.top = '0px';
-            }
-            this.parent.element.classList.add(classes.CLS_FULL_SCREEN);
-            this.toggleParentOverflow(true);
-            this.parent.setContentHeight();
-            if (this.parent.toolbarModule) {
-                if (!this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
-                    this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
-                }
-                if (Browser.isDevice) {
-                    this.parent.toolbarModule.removeFixedTBarClass();
+            var evenArgs = {
+                cancel: false,
+                requestType: 'Maximize',
+                targetItem: 'Maximize',
+                args: event
+            };
+            this.parent.trigger(events.actionBegin, evenArgs, function (beginEventArgs) {
+                if (!beginEventArgs.cancel) {
+                    if (_this.parent.toolbarSettings.enableFloating &&
+                        !_this.parent.inlineMode.enable && _this.parent.toolbarSettings.enable) {
+                        _this.parent.getToolbarElement().style.width = '100%';
+                        _this.parent.getToolbarElement().style.top = '0px';
+                    }
+                    _this.parent.element.classList.add(classes.CLS_FULL_SCREEN);
+                    _this.toggleParentOverflow(true);
+                    _this.parent.setContentHeight();
+                    if (_this.parent.toolbarModule) {
+                        if (!_this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
+                            _this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
+                        }
+                        if (Browser.isDevice) {
+                            _this.parent.toolbarModule.removeFixedTBarClass();
+                        }
+                        _this.parent.toolbarModule.updateItem({
+                            targetItem: 'Maximize',
+                            updateItem: 'Minimize',
+                            baseToolbar: _this.parent.getBaseToolbarObject()
+                        });
+                    }
+                    _this.parent.trigger(events.actionComplete, { requestType: 'Maximize', targetItem: 'Maximize', args: event });
                 }
-                this.parent.toolbarModule.updateItem({
-                    targetItem: 'Maximize',
-                    updateItem: 'Minimize',
-                    baseToolbar: this.parent.getBaseToolbarObject()
-                });
-            }
-            this.parent.trigger(events.actionComplete, { requestType: 'Maximize', targetItem: 'Maximize', args: event });
+            });
         }
     };
     /**
@@ -60,32 +70,42 @@ var FullScreen = /** @class */ (function () {
 
      */
     FullScreen.prototype.hideFullScreen = function (event) {
+        var _this = this;
         if (this.parent.toolbarSettings.enable === true && this.parent.editorMode !== 'Markdown'
             && !isNOU(this.parent.quickToolbarModule)) {
             this.parent.quickToolbarModule.hideQuickToolbars();
         }
         if (this.parent.element.classList.contains(classes.CLS_FULL_SCREEN)) {
-            this.parent.element.classList.remove(classes.CLS_FULL_SCREEN);
-            var elem = document.querySelectorAll('.e-rte-overflow');
-            for (var i = 0; i < elem.length; i++) {
-                removeClass([elem[i]], ['e-rte-overflow']);
-            }
-            this.parent.trigger(events.actionBegin, { requestType: 'Minimize', targetItem: 'Minimize', args: event });
-            this.parent.setContentHeight();
-            if (this.parent.toolbarModule) {
-                if (!this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
-                    this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
-                }
-                this.parent.toolbarModule.updateItem({
-                    targetItem: 'Minimize',
-                    updateItem: 'Maximize',
-                    baseToolbar: this.parent.getBaseToolbarObject()
-                });
-                if (Browser.isDevice && this.parent.inlineMode.enable) {
-                    this.parent.toolbarModule.addFixedTBarClass();
+            var evenArgs = {
+                cancel: false,
+                requestType: 'Minimize',
+                targetItem: 'Minimize',
+                args: event
+            };
+            this.parent.trigger(events.actionBegin, evenArgs, function (beginEventArgs) {
+                if (!beginEventArgs.cancel) {
+                    _this.parent.element.classList.remove(classes.CLS_FULL_SCREEN);
+                    var elem = document.querySelectorAll('.e-rte-overflow');
+                    for (var i = 0; i < elem.length; i++) {
+                        removeClass([elem[i]], ['e-rte-overflow']);
+                    }
+                    _this.parent.setContentHeight();
+                    if (_this.parent.toolbarModule) {
+                        if (!_this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
+                            _this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
+                        }
+                        _this.parent.toolbarModule.updateItem({
+                            targetItem: 'Minimize',
+                            updateItem: 'Maximize',
+                            baseToolbar: _this.parent.getBaseToolbarObject()
+                        });
+                        if (Browser.isDevice && _this.parent.inlineMode.enable) {
+                            _this.parent.toolbarModule.addFixedTBarClass();
+                        }
+                    }
+                    _this.parent.trigger(events.actionComplete, { requestType: 'Minimize', targetItem: 'Minimize', args: event });
                 }
-            }
-            this.parent.trigger(events.actionComplete, { requestType: 'Minimize', targetItem: 'Minimize', args: event });
+            });
         }
     };
     // eslint-disable-next-line

package/src/rich-text-editor/actions/html-editor.js

@@ -1,5 +1,6 @@
 import * as events from '../base/constant';
 import { isNullOrUndefined, closest, attributes, removeClass, addClass, Browser, detach } from '@syncfusion/ej2-base';
+import { isNullOrUndefined as isNOU } from '@syncfusion/ej2-base';
 import { HTMLFormatter } from '../formatter/html-formatter';
 import { RenderType } from '../base/enum';
 import * as classes from '../base/classes';
@@ -9,7 +10,7 @@ import { ContentRender } from '../renderer/content-renderer';
 import { ColorPickerInput } from './color-picker';
 import { NodeSelection } from '../../selection/selection';
 import { InsertHtml } from '../../editor-manager/plugin/inserthtml';
-import { getTextNodesUnder, sanitizeHelper } from '../base/util';
+import { getTextNodesUnder, sanitizeHelper, getDefaultValue } from '../base/util';
 import { isIDevice } from '../../common/util';
 import { XhtmlValidation } from './xhtml-validation';
 import { ON_BEGIN } from './../../common/constant';
@@ -92,33 +93,40 @@ var HtmlEditor = /** @class */ (function () {
     HtmlEditor.prototype.onKeyDown = function (e) {
         var _this = this;
         var currentRange;
+        var args = e.args;
         if (Browser.info.name === 'chrome') {
             currentRange = this.parent.getRange();
             this.backSpaceCleanup(e, currentRange);
             this.deleteCleanup(e, currentRange);
         }
-        if (e.args.keyCode === 9 && this.parent.enableTabKey) {
-            var range = this.nodeSelectionObj.getRange(this.contentRenderer.getDocument());
-            var parentNode = this.nodeSelectionObj.getParentNodeCollection(range);
-            if (!((parentNode[0].nodeName === 'LI' || closest(parentNode[0], 'li') ||
-                closest(parentNode[0], 'table')) && range.startOffset === 0)) {
-                e.args.preventDefault();
-                if (!e.args.shiftKey) {
-                    InsertHtml.Insert(this.contentRenderer.getDocument(), '    ');
-                    this.rangeCollection.push(this.nodeSelectionObj.getRange(this.contentRenderer.getDocument()));
-                }
-                else if (this.rangeCollection.length > 0 &&
-                    this.rangeCollection[this.rangeCollection.length - 1].startContainer.textContent.length === 4) {
-                    var textCont = this.rangeCollection[this.rangeCollection.length - 1].startContainer;
-                    this.nodeSelectionObj.setSelectionText(this.contentRenderer.getDocument(), textCont, textCont, 0, textCont.textContent.length);
-                    InsertHtml.Insert(this.contentRenderer.getDocument(), document.createTextNode(''));
-                    this.rangeCollection.pop();
+        if (args.keyCode === 9 && this.parent.enableTabKey) {
+            if (!isNOU(args.target) && isNullOrUndefined(closest(args.target, '.e-rte-toolbar'))) {
+                var range = this.nodeSelectionObj.getRange(this.contentRenderer.getDocument());
+                var parentNode = this.nodeSelectionObj.getParentNodeCollection(range);
+                if (!((parentNode[0].nodeName === 'LI' || closest(parentNode[0], 'li') ||
+                    closest(parentNode[0], 'table')) && range.startOffset === 0)) {
+                    args.preventDefault();
+                    if (!args.shiftKey) {
+                        InsertHtml.Insert(this.contentRenderer.getDocument(), '    ');
+                        this.rangeCollection.push(this.nodeSelectionObj.getRange(this.contentRenderer.getDocument()));
+                    }
+                    else if (this.rangeCollection.length > 0 &&
+                        this.rangeCollection[this.rangeCollection.length - 1].startContainer.textContent.length === 4) {
+                        var textCont = this.rangeCollection[this.rangeCollection.length - 1].startContainer;
+                        this.nodeSelectionObj.setSelectionText(this.contentRenderer.getDocument(), textCont, textCont, 0, textCont.textContent.length);
+                        InsertHtml.Insert(this.contentRenderer.getDocument(), document.createTextNode(''));
+                        this.rangeCollection.pop();
+                    }
                 }
             }
         }
         if (e.args.action === 'space' ||
-            e.args.action === 'enter') {
+            e.args.action === 'enter' ||
+            e.args.keyCode === 13) {
             this.spaceLink(e.args);
+            if (this.parent.editorMode === 'HTML' && !((this.parent.shiftEnterKey === 'BR' && e.args.shiftKey))) {
+                this.parent.notify(events.enterHandler, { args: e.args });
+            }
         }
         if (e.args.action === 'space') {
             var currentRange_1 = this.parent.getRange();
@@ -160,10 +168,11 @@ var HtmlEditor = /** @class */ (function () {
             this.oldRangeElement = null;
             this.deleteRangeElement = null;
             this.deleteOldRangeElement = null;
-            e.args.preventDefault();
+            args.preventDefault();
         }
     };
     HtmlEditor.prototype.isOrderedList = function (editorValue) {
+        editorValue = editorValue.replace(/\u200B/g, '');
         var olListStartRegex = [/^[1]+[.]+$/, /^[i]+[.]+$/, /^[a]+[.]+$/];
         if (!isNullOrUndefined(editorValue)) {
             for (var i = 0; i < olListStartRegex.length; i++) {
@@ -175,6 +184,7 @@ var HtmlEditor = /** @class */ (function () {
         return false;
     };
     HtmlEditor.prototype.isUnOrderedList = function (editorValue) {
+        editorValue = editorValue.replace(/\u200B/g, '');
         var ulListStartRegex = [/^[*]$/, /^[-]$/];
         if (!isNullOrUndefined(editorValue)) {
             for (var i = 0; i < ulListStartRegex.length; i++) {
@@ -360,7 +370,7 @@ var HtmlEditor = /** @class */ (function () {
             var contentInnerElem = '';
             for (var i = 0; i < enterSplitText.length; i++) {
                 if (enterSplitText[i].trim() === '') {
-                    contentInnerElem += '<p><br></p>';
+                    contentInnerElem += getDefaultValue(this.parent);
                 }
                 else {
                     var contentWithSpace = '';

package/src/rich-text-editor/actions/paste-clean-up.js

@@ -1,7 +1,7 @@
 import * as events from '../base/constant';
 import { Popup } from '@syncfusion/ej2-popups';
 import { RadioButton } from '@syncfusion/ej2-buttons';
-import { isNullOrUndefined as isNOU, isNullOrUndefined, detach, isBlazor, extend, addClass } from '@syncfusion/ej2-base';
+import { isNullOrUndefined as isNOU, isNullOrUndefined, detach, extend, addClass } from '@syncfusion/ej2-base';
 import { getUniqueID, Browser } from '@syncfusion/ej2-base';
 import { CLS_RTE_PASTE_KEEP_FORMAT, CLS_RTE_PASTE_REMOVE_FORMAT, CLS_RTE_PASTE_PLAIN_FORMAT } from '../base/classes';
 import { CLS_RTE_PASTE_OK, CLS_RTE_PASTE_CANCEL, CLS_RTE_DIALOG_MIN_HEIGHT } from '../base/classes';
@@ -11,7 +11,7 @@ import * as EVENTS from './../../common/constant';
 import { RenderType } from '../base/enum';
 import { Uploader } from '@syncfusion/ej2-inputs';
 import * as classes from '../base/classes';
-import { sanitizeHelper, convertToBlob } from '../base/util';
+import { sanitizeHelper, convertToBlob, getDefaultValue } from '../base/util';
 /**
  * PasteCleanup module called when pasting content in RichTextEditor
  */
@@ -143,7 +143,7 @@ var PasteCleanup = /** @class */ (function () {
         var contentInnerElem = '';
         for (var i = 0; i < enterSplitText.length; i++) {
             if (enterSplitText[i].trim() === '') {
-                contentInnerElem += '<p><br></p>';
+                contentInnerElem += getDefaultValue(this.parent);
             }
             else {
                 var contentWithSpace = this.makeSpace(enterSplitText[i]);
@@ -477,7 +477,7 @@ var PasteCleanup = /** @class */ (function () {
                             dialog.hide();
                             _this.parent.height = isHeight ? preRTEHeight : _this.parent.height;
                             isHeight = false;
-                            var argument = isBlazor() ? null : dialog;
+                            var argument = dialog;
                             _this.dialogRenderObj.close(argument);
                             dialog.destroy();
                             _this.selectFormatting(value, args, keepChecked, cleanChecked);
@@ -495,7 +495,7 @@ var PasteCleanup = /** @class */ (function () {
                             dialog.hide();
                             _this.parent.height = isHeight ? preRTEHeight : _this.parent.height;
                             isHeight = false;
-                            var args_1 = isBlazor() ? null : dialog;
+                            var args_1 = dialog;
                             _this.dialogRenderObj.close(args_1);
                             dialog.destroy();
                         }

package/src/rich-text-editor/actions/resize.js

@@ -1,4 +1,4 @@
-import { EventHandler, Browser, isNullOrUndefined, isBlazor, detach } from '@syncfusion/ej2-base';
+import { EventHandler, Browser, isNullOrUndefined, detach } from '@syncfusion/ej2-base';
 import * as events from '../base/constant';
 import * as classes from '../base/classes';
 /**
@@ -34,7 +34,7 @@ var Resize = /** @class */ (function () {
         }
         this.wireResizeEvents();
         this.parent.notify(events.resizeInitialized, {});
-        var args = isBlazor() ? { requestType: 'editor' } : { event: e, requestType: 'editor' };
+        var args = { event: e, requestType: 'editor' };
         this.parent.trigger(events.resizeStart, args, function (resizeStartArgs) {
             if (resizeStartArgs.cancel) {
                 _this.unwireResizeEvents();
@@ -43,7 +43,7 @@ var Resize = /** @class */ (function () {
     };
     Resize.prototype.performResize = function (e) {
         var _this = this;
-        var args = isBlazor() ? { requestType: 'editor' } : { event: e, requestType: 'editor' };
+        var args = { event: e, requestType: 'editor' };
         this.parent.trigger(events.onResize, args, function (resizingArgs) {
             if (resizingArgs.cancel) {
                 _this.unwireResizeEvents();
@@ -67,7 +67,7 @@ var Resize = /** @class */ (function () {
     Resize.prototype.stopResize = function (e) {
         this.parent.refreshUI();
         this.unwireResizeEvents();
-        var args = isBlazor() ? { requestType: 'editor' } : { event: e, requestType: 'editor' };
+        var args = { event: e, requestType: 'editor' };
         this.parent.trigger(events.resizeStop, args);
     };
     Resize.prototype.getEventType = function (e) {

package/src/rich-text-editor/base/constant.d.ts

@@ -444,6 +444,11 @@ export declare const pasteClean: string;
 /**
  * @hidden
 
+ */
+export declare const enterHandler: string;
+/**
+ * @hidden
+
  */
 export declare const beforeDialogOpen: string;
 /**

package/src/rich-text-editor/base/constant.js

@@ -444,6 +444,11 @@ export var pasteClean = 'pasteClean';
 /**
  * @hidden
 
+ */
+export var enterHandler = 'enterHandler';
+/**
+ * @hidden
+
  */
 export var beforeDialogOpen = 'beforeDialogOpen';
 /**