@syncfusion/ej2-richtexteditor 24.2.9 → 25.1.35

package/dist/global/index.d.ts

@@ -1,6 +1,6 @@
 /*!
 *  filename: index.d.ts
-*  version : 24.2.9
+*  version : 25.1.35
 *  Copyright Syncfusion Inc. 2001 - 2023. All rights reserved.
 *  Use of this code is subject to the terms of our license.
 *  A copy of the current license can be obtained at any time by e-mailing

package/package.json

@@ -1,8 +1,8 @@
 {
   "_from": "@syncfusion/ej2-richtexteditor@*",
-  "_id": "@syncfusion/ej2-richtexteditor@24.2.8",
+  "_id": "@syncfusion/ej2-richtexteditor@23.1.54",
   "_inBundle": false,
-  "_integrity": "sha512-RiTlxXAeoPOeO3I9n1A4XHgDuna06LrHQgt08fEpnjhBE38mAzyH68yRzCtrUlVnoVqTPOvJJ83rLI2VDDlC1w==",
+  "_integrity": "sha512-PsphjMpa/0wW711Fuq+Qd4CDUY2UbDH56WhYjnk/8Tuv01Gj42/krKh44yI6yJYJRZq+Q47NErl/5FJUNT0Ozg==",
   "_location": "/@syncfusion/ej2-richtexteditor",
   "_phantomChildren": {},
   "_requested": {
@@ -25,10 +25,10 @@
     "/@syncfusion/ej2-react-richtexteditor",
     "/@syncfusion/ej2-vue-richtexteditor"
   ],
-  "_resolved": "https://nexus.syncfusioninternal.com/repository/ej2-hotfix-new/@syncfusion/ej2-richtexteditor/-/ej2-richtexteditor-24.2.8.tgz",
-  "_shasum": "f966e83e1230cc284396b8ec962f1df25c80d5a9",
+  "_resolved": "https://nexus.syncfusioninternal.com/repository/ej2-release/@syncfusion/ej2-richtexteditor/-/ej2-richtexteditor-23.1.54.tgz",
+  "_shasum": "40d45ccccd6bc1a49e83e34d5f9d850b12fefc33",
   "_spec": "@syncfusion/ej2-richtexteditor@*",
-  "_where": "/jenkins/workspace/elease-automation_release_24.1.1/packages/included",
+  "_where": "/jenkins/workspace/elease-automation_release_25.1.1/packages/included",
   "author": {
     "name": "Syncfusion Inc."
   },
@@ -37,13 +37,13 @@
   },
   "bundleDependencies": false,
   "dependencies": {
-    "@syncfusion/ej2-base": "~24.2.7",
-    "@syncfusion/ej2-buttons": "~24.2.7",
-    "@syncfusion/ej2-filemanager": "~24.2.7",
-    "@syncfusion/ej2-inputs": "~24.2.9",
-    "@syncfusion/ej2-navigations": "~24.2.8",
-    "@syncfusion/ej2-popups": "~24.2.9",
-    "@syncfusion/ej2-splitbuttons": "~24.2.7"
+    "@syncfusion/ej2-base": "~25.1.35",
+    "@syncfusion/ej2-buttons": "~25.1.35",
+    "@syncfusion/ej2-filemanager": "~25.1.35",
+    "@syncfusion/ej2-inputs": "~25.1.35",
+    "@syncfusion/ej2-navigations": "~25.1.35",
+    "@syncfusion/ej2-popups": "~25.1.35",
+    "@syncfusion/ej2-splitbuttons": "~25.1.35"
   },
   "deprecated": false,
   "description": "Essential JS 2 RichTextEditor component",
@@ -69,6 +69,6 @@
     "url": "git+https://github.com/syncfusion/ej2-javascript-ui-controls.git"
   },
   "typings": "index.d.ts",
-  "version": "24.2.9",
+  "version": "25.1.35",
   "sideEffects": false
 }

package/src/common/config.d.ts

@@ -1,3 +1,4 @@
+import { IImageResizeFactor } from "./interface";
 /**
  * Default Markdown formats config for adapter
  */
@@ -46,3 +47,9 @@ export declare const listConversionFilters: {
  * @hidden
  */
 export declare const selfClosingTags: string[];
+/**
+ * Resize factor for image.
+ * @hidden
+ *
+ */
+export declare const imageResizeFactor: IImageResizeFactor;

package/src/common/config.js

@@ -128,3 +128,14 @@ export var selfClosingTags = [
     'BR',
     'IMG'
 ];
+/**
+ * Resize factor for image.
+ * @hidden
+ *
+ */
+export var imageResizeFactor = {
+    topLeft: [-1, -1],
+    topRight: [1, -1],
+    botRight: [1, 1],
+    botLeft: [-1, 1]
+};

package/src/common/interface.d.ts

@@ -77,3 +77,15 @@ export interface IToolbarStatus {
     numberFormatList?: string | boolean;
     bulletFormatList?: string | boolean;
 }
+/**
+
+ * @private
+ *
+ *
+ * */
+export interface IImageResizeFactor {
+    topLeft: [number, number];
+    topRight: [number, number];
+    botLeft: [number, number];
+    botRight: [number, number];
+}

package/src/common/types.d.ts

@@ -18,3 +18,9 @@ export declare type EnterKey = 'P' | 'DIV' | 'BR';
  * Defines tag to be used when shift + enter key is pressed.
  */
 export declare type ShiftEnterKey = 'P' | 'DIV' | 'BR';
+/**
+ * Defines the types of action to be used in the Rich Text Editor.
+ * @hidden
+ * @private
+ */
+export declare type ContentHeightSource = 'SourceCode' | 'Init' | 'Preview' | 'Maximize' | 'Minimize' | 'WindowResize' | 'Toolbar' | 'Resize' | 'Refresh';

package/src/editor-manager/plugin/dom-node.d.ts

@@ -317,10 +317,14 @@ export declare class DOMNode {
     /**
      * blockNodes method
      *
+     * @param {boolean} action - Optional Boolean that specifies the action is whether performed.
      * @returns {Node[]} - returns the node array values
      * @hidden
 
      */
-    blockNodes(): Node[];
+    blockNodes(action?: boolean): Node[];
     private ignoreTableTag;
+    private getPreBlockNodeCollection;
+    private getClosestInlineParent;
+    private wrapWithBlockNode;
 }

package/src/editor-manager/plugin/dom-node.js

@@ -670,11 +670,12 @@ var DOMNode = /** @class */ (function () {
     /**
      * blockNodes method
      *
+     * @param {boolean} action - Optional Boolean that specifies the action is whether performed.
      * @returns {Node[]} - returns the node array values
      * @hidden
 
      */
-    DOMNode.prototype.blockNodes = function () {
+    DOMNode.prototype.blockNodes = function (action) {
         var collectionNodes = [];
         var selection = this.getSelection();
         if (this.isEditorArea() && selection.rangeCount) {
@@ -688,23 +689,46 @@ var DOMNode = /** @class */ (function () {
                     collectionNodes.push(startNode);
                 }
                 parentNode = this.blockParentNode(startNode);
+                var endParentNode = this.blockParentNode(endNode);
                 if (parentNode && collectionNodes.indexOf(parentNode) < 0) {
-                    if (CONSTANT.IGNORE_BLOCK_TAGS.indexOf(parentNode.tagName.toLocaleLowerCase()) >= 0 && (startNode.tagName === 'BR' ||
-                        startNode.nodeType === Node.TEXT_NODE ||
-                        startNode.classList.contains(markerClassName.startSelection) ||
-                        startNode.classList.contains(markerClassName.endSelection))) {
-                        var tempNode = startNode.previousSibling &&
-                            startNode.previousSibling.nodeType === Node.TEXT_NODE ?
-                            startNode.previousSibling : startNode;
-                        if (!startNode.nextSibling && !startNode.previousSibling && startNode.tagName === 'BR') {
-                            collectionNodes.push(tempNode);
+                    if (!isNOU(action) && action) {
+                        if (range.commonAncestorContainer.nodeName === 'TD' || parentNode.nodeName === 'TD' || endParentNode.nodeName === 'TD') {
+                            var processedNodes = this.getPreBlockNodeCollection(range);
+                            if (processedNodes.length > 1) {
+                                this.wrapWithBlockNode(processedNodes, collectionNodes);
+                            }
+                            else if (processedNodes.length > 0) {
+                                if (startNode !== endNode && startNode.nodeName !== 'BR') {
+                                    collectionNodes.push(this.createTempNode(startNode));
+                                }
+                                else if (startNode === endNode && startNode.nodeName === 'SPAN' && (startNode.classList.contains(markerClassName.startSelection)
+                                    || startNode.classList.contains(markerClassName.endSelection))) {
+                                    collectionNodes.push(this.createTempNode(startNode));
+                                }
+                            }
                         }
                         else {
-                            collectionNodes.push(this.createTempNode(tempNode));
+                            collectionNodes.push(parentNode);
                         }
                     }
                     else {
-                        collectionNodes.push(parentNode);
+                        if (CONSTANT.IGNORE_BLOCK_TAGS.indexOf(parentNode.tagName.toLocaleLowerCase()) >= 0 && (startNode.tagName === 'BR' ||
+                            startNode.nodeType === Node.TEXT_NODE ||
+                            startNode.classList.contains(markerClassName.startSelection) ||
+                            startNode.classList.contains(markerClassName.endSelection))) {
+                            var tempNode = startNode.previousSibling &&
+                                startNode.previousSibling.nodeType === Node.TEXT_NODE ?
+                                startNode.previousSibling : startNode;
+                            if (!startNode.nextSibling && !startNode.previousSibling && startNode.tagName === 'BR') {
+                                collectionNodes.push(tempNode);
+                            }
+                            else {
+                                collectionNodes.push(this.createTempNode(tempNode));
+                            }
+                        }
+                        else {
+                            collectionNodes.push(parentNode);
+                        }
                     }
                 }
                 var nodes = [];
@@ -773,6 +797,131 @@ var DOMNode = /** @class */ (function () {
     DOMNode.prototype.ignoreTableTag = function (element) {
         return !(CONSTANT.TABLE_BLOCK_TAGS.indexOf(element.tagName.toLocaleLowerCase()) >= 0);
     };
+    DOMNode.prototype.getPreBlockNodeCollection = function (range) {
+        var startNode = this.getSelectedNode(range.startContainer, range.startOffset);
+        var endNode = this.getSelectedNode(range.endContainer, range.endOffset);
+        var nodes = [];
+        var rootNode = startNode.closest('td, th');
+        if (isNOU(rootNode)) {
+            return nodes;
+        }
+        var rootChildNode = Array.from(rootNode.childNodes);
+        var isContinue = true;
+        var processedStart = this.getClosestInlineParent(startNode, rootNode, true);
+        var processedEnd = this.getClosestInlineParent(endNode, rootNode, false);
+        for (var i = 0; i < rootChildNode.length; i++) {
+            var child = rootChildNode[i];
+            if (processedStart === processedEnd && child === processedStart) {
+                nodes.push(child);
+                isContinue = true;
+            }
+            else if (child === processedStart) {
+                isContinue = false;
+            }
+            else if (child === processedEnd) {
+                nodes.push(child); // Early Exit so Push the end node.
+                isContinue = true;
+            }
+            if (isContinue) {
+                continue;
+            }
+            else {
+                nodes.push(child);
+            }
+        }
+        return nodes;
+    };
+    DOMNode.prototype.getClosestInlineParent = function (node, rootNode, isStart) {
+        // 1. If the node is a text node, return the node
+        // 2. If the node is a block node return block node
+        // 3. If the node is a inline node,
+        //      Traverse back untill the TD or TH node
+        //      Check if the the previous sibling , next sibling is a block node.
+        //      If yes return the inline node that is closest to the block node.
+        if (node.nodeType === Node.TEXT_NODE) {
+            return node;
+        }
+        if (this.isBlockNode(node)) {
+            return node;
+        }
+        var currentNode = node;
+        var rootFlag = false;
+        while (currentNode) {
+            var previousNode = currentNode;
+            if (rootFlag) {
+                if (this.isBlockNode(currentNode)) {
+                    return previousNode;
+                }
+                if (isStart && currentNode.previousSibling) {
+                    if (this.isBlockNode(currentNode.previousSibling) || currentNode.previousSibling.nodeName === 'BR') {
+                        return previousNode;
+                    }
+                    else {
+                        currentNode = currentNode.previousSibling;
+                    }
+                }
+                else if (!isStart && currentNode.nextSibling) {
+                    if (this.isBlockNode(currentNode.nextSibling) || currentNode.nextSibling.nodeName === 'BR') {
+                        return previousNode;
+                    }
+                    else {
+                        currentNode = currentNode.nextSibling;
+                    }
+                }
+                else {
+                    return currentNode;
+                }
+            }
+            else {
+                currentNode = currentNode.parentElement;
+                if (currentNode === rootNode) {
+                    currentNode = previousNode;
+                    rootFlag = true;
+                }
+            }
+        }
+        return null;
+    };
+    DOMNode.prototype.wrapWithBlockNode = function (nodes, collectionNodes) {
+        var wrapperElement = createElement('p');
+        for (var i = 0; i < nodes.length; i++) {
+            var child = nodes[i];
+            if (child.nodeName === 'BR') {
+                child.parentNode.insertBefore(wrapperElement, child);
+                wrapperElement.appendChild(child);
+                if (wrapperElement.childNodes.length > 0) {
+                    collectionNodes.push(wrapperElement);
+                }
+                wrapperElement = createElement('p');
+            }
+            else {
+                if (!this.isBlockNode(child)) {
+                    if (child.nodeName === '#text' && child.textContent.trim() === '') {
+                        continue;
+                    }
+                    if (wrapperElement.childElementCount === 0) {
+                        child.parentNode.insertBefore(wrapperElement, child);
+                        wrapperElement.appendChild(child);
+                    }
+                    else {
+                        wrapperElement.appendChild(child);
+                    }
+                }
+                else {
+                    collectionNodes.push(child);
+                }
+                // Use case when the BR is next sibling but the BR is not the part of selection.
+                if ((i === nodes.length - 1) && wrapperElement.nextElementSibling &&
+                    wrapperElement.querySelectorAll('br').length === 0 &&
+                    wrapperElement.nextElementSibling.nodeName === 'BR') {
+                    wrapperElement.appendChild(wrapperElement.nextElementSibling);
+                }
+            }
+        }
+        if (wrapperElement.childNodes.length > 0 && collectionNodes.indexOf(wrapperElement) < 0) {
+            collectionNodes.push(wrapperElement);
+        }
+    };
     return DOMNode;
 }());
 export { DOMNode };

package/src/editor-manager/plugin/formats.js

@@ -242,7 +242,7 @@ var Formats = /** @class */ (function () {
         }
         var save = this.parent.nodeSelection.save(range, this.parent.currentDocument);
         this.parent.domNode.setMarker(save);
-        var formatsNodes = this.parent.domNode.blockNodes();
+        var formatsNodes = this.parent.domNode.blockNodes(true);
         if (e.enterAction === 'BR') {
             this.setSelectionBRConfig();
             var allSelectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument);

package/src/editor-manager/plugin/image.js

@@ -79,7 +79,6 @@ var ImageCommand = /** @class */ (function () {
         }
     };
     ImageCommand.prototype.createImage = function (e) {
-        var _this = this;
         var isReplaced = false;
         e.item.url = isNOU(e.item.url) || e.item.url === 'undefined' ? e.item.src : e.item.url;
         if (!isNOU(e.item.selectParent) && e.item.selectParent[0].tagName === 'IMG') {
@@ -109,21 +108,18 @@ var ImageCommand = /** @class */ (function () {
             var selectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)[0];
             var imgElm_1 = (e.value === 'Replace' || isReplaced) ? e.item.selectParent[0] :
                 (Browser.isIE ? selectedNode.previousSibling : selectedNode.previousElementSibling);
-            imgElm_1.addEventListener('load', function () {
-                if (e.value !== 'Replace' || !isReplaced) {
-                    e.callBack({
-                        requestType: 'Images',
-                        editorMode: 'HTML',
-                        event: e.event,
-                        range: _this.parent.nodeSelection.getRange(_this.parent.currentDocument),
-                        elements: [imgElm_1]
-                    });
-                }
-            });
-        }
-        if (e.value === 'Replace') {
-            e.item.subCommand = 'Replace';
-            this.callBack(e);
+            var imageInstance_1 = this;
+            var onImageLoadEvent_1 = function () {
+                e.callBack({
+                    requestType: (e.value === 'Replace') ? (e.item.subCommand = 'Replace', "Replace") : 'Images',
+                    editorMode: 'HTML',
+                    event: e.event,
+                    range: imageInstance_1.parent.nodeSelection.getRange(imageInstance_1.parent.currentDocument),
+                    elements: [imgElm_1]
+                });
+                imgElm_1.removeEventListener('load', onImageLoadEvent_1);
+            };
+            imgElm_1.addEventListener('load', onImageLoadEvent_1);
         }
     };
     ImageCommand.prototype.setStyle = function (imgElement, e, imgReplace) {

package/src/editor-manager/plugin/inserthtml.d.ts

@@ -26,4 +26,5 @@ export declare class InsertHtml {
     private static findDetachEmptyElem;
     private static removeEmptyElements;
     private static closestEle;
+    private static insertTableInList;
 }

package/src/editor-manager/plugin/inserthtml.js

@@ -59,6 +59,10 @@ var InsertHtml = /** @class */ (function () {
         var isCollapsed = range.collapsed;
         var nodes = this.getNodeCollection(range, nodeSelection, node);
         var closestParentNode = (node.nodeName.toLowerCase() === 'table') ? this.closestEle(nodes[0].parentNode, editNode) : nodes[0];
+        if (closestParentNode && closestParentNode.nodeName === 'LI' && node.nodeName.toLowerCase() === 'table') {
+            this.insertTableInList(range, node, closestParentNode, nodes[0], nodeCutter);
+            return;
+        }
         if (isExternal || (!isNOU(node) && !isNOU(node.classList) &&
             node.classList.contains('pasteContent'))) {
             this.pasteInsertHTML(nodes, node, range, nodeSelection, nodeCutter, docElement, isCollapsed, closestParentNode, editNode, enterAction);
@@ -554,6 +558,9 @@ var InsertHtml = /** @class */ (function () {
     };
     InsertHtml.closestEle = function (element, editNode) {
         var el = element;
+        if (closest(el, 'li')) {
+            return closest(el, 'li');
+        }
         while (el && el.nodeType === 1) {
             if (el.parentNode === editNode ||
                 (!isNOU(el.parentNode.tagName) &&
@@ -564,6 +571,30 @@ var InsertHtml = /** @class */ (function () {
         }
         return null;
     };
+    InsertHtml.insertTableInList = function (range, insertNode, parentNode, currentNode, nodeCutter) {
+        if (range.collapsed) {
+            var isStart = range.startOffset === 0;
+            var isEnd = range.startContainer.textContent.trimEnd().length === range.startOffset;
+            if (isStart || isEnd) {
+                if (isStart) {
+                    InsertMethods.AppendBefore(insertNode, currentNode, false);
+                }
+                else {
+                    InsertMethods.AppendBefore(insertNode, currentNode, true);
+                }
+            }
+            else {
+                var preNode = nodeCutter.SplitNode(range, parentNode, true);
+                var sibNode = preNode.previousSibling;
+                sibNode.appendChild(insertNode);
+            }
+        }
+        else {
+            range.deleteContents();
+            parentNode.appendChild(insertNode);
+        }
+        insertNode.classList.add('ignore-table');
+    };
     /**
      * Insert method
      *

package/src/editor-manager/plugin/link.js

@@ -194,7 +194,7 @@ var LinkCommand = /** @class */ (function () {
         for (var i = 0, j_2 = 0, k = 0; i <= finalinlineNodes.length; i++) {
             if (i === 0) {
                 finalinlineNodes[i].parentNode.insertBefore(anchorNodes[j_2], finalinlineNodes[i].nextSibling);
-                if (this.parent.domNode.blockNodes().length === 1) {
+                if (this.parent.domNode.blockNodes().length === 1 && anchorNodes.length === 1) {
                     this.parent.nodeSelection.setSelectionNode(this.parent.currentDocument, anchorNodes[j_2]);
                 }
                 removeNodes[k] = finalinlineNodes[i];

package/src/editor-manager/plugin/lists.js

@@ -114,7 +114,8 @@ var Lists = /** @class */ (function () {
                 startNode.textContent = '';
             }
             var startNodeParent = startNode.parentElement;
-            if (isNOU(startNodeParent.parentElement.closest('UL')) && isNOU(startNodeParent.parentElement.closest('OL'))) {
+            var parentOfCurrentOLUL = startNodeParent.parentElement;
+            if (isNOU(parentOfCurrentOLUL.closest('UL')) && isNOU(parentOfCurrentOLUL.closest('OL'))) {
                 if (!isNOU(startNode.nextElementSibling)) {
                     var nearBlockNode = this.parent.domNode.blockParentNode(startNode);
                     this.parent.nodeCutter.GetSpliceNode(range, nearBlockNode);
@@ -141,6 +142,15 @@ var Lists = /** @class */ (function () {
                     detach(startNode);
                 }
             }
+            // To handle the nested enter key press in the list for the first LI element
+            if (!isNOU(parentOfCurrentOLUL) && (!isNOU(parentOfCurrentOLUL.closest('UL')) || !isNOU(parentOfCurrentOLUL.closest('OL'))) &&
+                parentOfCurrentOLUL.nodeName === 'LI' && parentOfCurrentOLUL.style.listStyleType === 'none' &&
+                parentOfCurrentOLUL.textContent === '' && startNode.textContent === '' && startNode === startNodeParent.firstElementChild &&
+                isNOU(startNode.nextSibling)) {
+                detach(startNodeParent);
+                parentOfCurrentOLUL.style.removeProperty('list-style-type');
+                e.event.preventDefault();
+            }
         }
     };
     Lists.prototype.backspaceList = function (e) {
@@ -514,7 +524,7 @@ var Lists = /** @class */ (function () {
         this.currentAction = e.subCommand;
         this.currentAction = e.subCommand = this.currentAction === 'NumberFormatList' ? 'OL' : this.currentAction === 'BulletFormatList' ? 'UL' : this.currentAction;
         this.domNode.setMarker(this.saveSelection);
-        var listsNodes = this.domNode.blockNodes();
+        var listsNodes = this.domNode.blockNodes(true);
         if (e.enterAction === 'BR') {
             this.setSelectionBRConfig();
             var allSelectedNode = this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument);
@@ -629,6 +639,18 @@ var Lists = /** @class */ (function () {
                     listEle.innerHTML = '<li><br/></li>';
                     elements[i].appendChild(listEle);
                 }
+                else if ('LI' !== elements[i].tagName && isNOU(item) &&
+                    elements[i].nodeName === 'BLOCKQUOTE') {
+                    isReverse = false;
+                    var elemAtt = this.domNode.attributes(elements[i]);
+                    var openTag = '<' + type + '>';
+                    var closeTag = '</' + type + '>';
+                    var newTag = 'li' + elemAtt;
+                    var replaceHTML = elements[i].innerHTML;
+                    var innerHTML = this.domNode.createTagString(newTag, null, replaceHTML);
+                    var collectionString = openTag + innerHTML + closeTag;
+                    elements[i].innerHTML = collectionString;
+                }
                 else if ('LI' !== elements[i].tagName && isNOU(item)) {
                     isReverse = false;
                     var elemAtt = elements[i].tagName === 'IMG' ? '' : this.domNode.attributes(elements[i]);