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

package/blazorGlobalSrc/editor-manager/plugin/dom-tree.d.ts

@@ -0,0 +1,84 @@
+/**
+ *  DOMTreeMethods - A `TreeWalkder` API implementation to get the block and text nodes in the selection.
+ */
+export declare class DOMMethods {
+    private directRangeElems;
+    private BLOCK_TAGS;
+    /**
+     * Refers the `inputElement` of the editor.
+     *
+     * @hidden
+     **/
+    editableElement: HTMLDivElement | HTMLBodyElement;
+    private currentDocument;
+    constructor(editElement: HTMLDivElement | HTMLBodyElement);
+    /**
+     * Method to get the block nodes inside the given Block node `TreeWalker` API.
+     *
+     * @returns {HTMLElement[]} The block node element.
+     *
+     *
+     */
+    getBlockNode(): HTMLElement[];
+    private addToBlockCollection;
+    /**
+     * Method to get the text nodes inside the given Block node `TreeWalker` API.
+     *
+     * @param {HTMLElement} blockElem - specifies the parent block element.
+     * @returns {Text[]} The Text Nodes.
+     *
+     *
+     */
+    getTextNodes(blockElem: HTMLElement): Text[];
+    /**
+     * isBlockNode method
+     *
+     * @param {Element} element - specifies the node element.
+     * @returns {boolean} - sepcifies the boolean value
+     * @hidden
+     */
+    isBlockNode(element: Element): boolean;
+    /**
+     * Retrieves the last text node within the provided node and its descendants.
+     *
+     * This method uses a TreeWalker to traverse all text nodes in the given node's subtree,
+     * and returns the last text node found.
+     *
+     * @param {Node} node - The root node from which to begin searching for text nodes.
+     * @returns {Node | null} - The last text node within the node, or null if no text nodes are found.
+     */
+    getLastTextNode(node: Node): Node | null;
+    /**
+     * Retrieves the first text node within the provided node and its descendants.
+     *
+     * This method uses a TreeWalker to traverse all text nodes in the given node's subtree,
+     * and returns the first text node found.
+     *
+     * @param {Node} node - The root node from which to begin searching for text nodes.
+     * @returns {Node | null} - The first text node within the node, or null if no text nodes are found.
+     */
+    getFirstTextNode(node: Node): Node | null;
+    /**
+     * Retrieves the parent block node of the given inline node.
+     *
+     * This method uses a TreeWalker to traverse the DOM tree and find the nearest ancestor of the given node
+     * that is a block element.
+     *
+     * @param {Node} node - The node for which to find the parent block node.
+     * @returns {Node} - The parent block node of the given node.
+     * @hidden
+     */
+    getParentBlockNode(node: Node): HTMLElement;
+    /**
+     * Retrieves the top-most node in the DOM that is not a block-level element.
+     * If the given text node is part of a block element, it returns the text node itself.
+     * Otherwise, it traverses upwards through its parent nodes until it finds a node
+     * that is either a block-level node or a node that contains different text content than the provided `text`.
+     *
+     * @param {Text} text - The text node from which to start the search. This can be a child of an inline element.
+     * @returns {HTMLElement | Text} - The top-most parent element that is not a block node, or the text node itself if it's inside a block-level element.
+     * @hidden
+     *
+     */
+    getTopMostNode(text: Text): HTMLElement | Text;
+}

package/blazorGlobalSrc/editor-manager/plugin/dom-tree.js

@@ -0,0 +1,164 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var DOMMethods = (function () {
+        function DOMMethods(editElement) {
+            this.directRangeElems = ['IMG', 'TABLE', 'AUDIO', 'VIDEO', 'HR'];
+            this.BLOCK_TAGS = ['address', 'article', 'aside', 'audio', 'blockquote',
+                'canvas', 'details', 'dd', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer',
+                'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'li', 'main', 'nav',
+                'noscript', 'output', 'p', 'pre', 'section', 'td', 'tfoot', 'th',
+                'video', 'body'];
+            this.editableElement = editElement;
+            this.currentDocument = editElement.ownerDocument;
+        }
+        DOMMethods.prototype.getBlockNode = function () {
+            var _this = this;
+            var blockCollection = [];
+            var selection = this.currentDocument.getSelection();
+            var range = selection.getRangeAt(0);
+            var directRange = range.startContainer === this.editableElement && range.startContainer === range.endContainer &&
+                range.startContainer.nodeName !== '#text';
+            if (directRange) {
+                if (range.startOffset === range.endOffset) {
+                    var isDirectRangeElems = this.editableElement.childNodes[range.startOffset] &&
+                        this.directRangeElems.indexOf(this.editableElement.childNodes[range.startOffset].nodeName) > -1;
+                    if (isDirectRangeElems) {
+                        blockCollection.push(this.editableElement.childNodes[range.startOffset]);
+                    }
+                }
+                else {
+                    var isElementRange = range.endOffset === range.startOffset + 1;
+                    if (isElementRange) {
+                        blockCollection.push(this.editableElement.childNodes[range.startOffset]);
+                    }
+                }
+                if (blockCollection.length > 0) {
+                    return blockCollection;
+                }
+            }
+            else {
+                var start = range.startContainer.nodeType === Node.TEXT_NODE ?
+                    range.startContainer.parentElement : range.startContainer;
+                var end = range.endContainer.nodeType === Node.TEXT_NODE ?
+                    range.endContainer.parentElement : range.endContainer;
+                var endBlockNode = this.isBlockNode(end) ? end : this.getParentBlockNode(end);
+                var blockNodeWalker = this.currentDocument.createTreeWalker(this.editableElement, NodeFilter.SHOW_ELEMENT, {
+                    acceptNode: function (node) {
+                        if (!range.intersectsNode(node)) {
+                            return NodeFilter.FILTER_REJECT;
+                        }
+                        return _this.isBlockNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+                    }
+                });
+                blockNodeWalker.currentNode = start;
+                while (blockNodeWalker.currentNode) {
+                    if (this.isBlockNode(blockNodeWalker.currentNode)) {
+                        this.addToBlockCollection(blockCollection, blockNodeWalker, range);
+                        blockNodeWalker.nextNode();
+                    }
+                    else {
+                        blockNodeWalker.previousNode();
+                    }
+                    if (blockNodeWalker.currentNode === end || blockNodeWalker.currentNode === endBlockNode) {
+                        this.addToBlockCollection(blockCollection, blockNodeWalker, range);
+                        break;
+                    }
+                }
+            }
+            return blockCollection;
+        };
+        DOMMethods.prototype.addToBlockCollection = function (blockCollection, blockNodeWalker, range) {
+            var currentNode = blockNodeWalker.currentNode;
+            if (blockNodeWalker.currentNode && blockCollection.indexOf(blockNodeWalker.currentNode) === -1) {
+                if (currentNode.nodeName === 'LI') {
+                    var isDirectChild = !currentNode.parentNode.closest('li');
+                    if (isDirectChild) {
+                        blockCollection.push(blockNodeWalker.currentNode);
+                    }
+                    else {
+                        var commonAncestor = range.commonAncestorContainer;
+                        var parentLI = currentNode.parentElement.closest('li');
+                        var isNestedLI = currentNode.nodeName === 'LI' && !!parentLI;
+                        var ancestorElement = commonAncestor.nodeType === 3 ? commonAncestor.parentElement : commonAncestor;
+                        var isListAncestor = !!ancestorElement.closest('ul,ol');
+                        if (isNestedLI && isListAncestor) {
+                            blockCollection.push(blockNodeWalker.currentNode);
+                        }
+                        else {
+                            return;
+                        }
+                    }
+                }
+                else {
+                    blockCollection.push(blockNodeWalker.currentNode);
+                }
+            }
+        };
+        DOMMethods.prototype.getTextNodes = function (blockElem) {
+            var nodeCollection = [];
+            var selection = this.currentDocument.getSelection();
+            var range = selection.getRangeAt(0);
+            var textNodeWalker = this.currentDocument.createTreeWalker(blockElem, NodeFilter.SHOW_TEXT, {
+                acceptNode: function (node) {
+                    if (!range.intersectsNode(node)) {
+                        return NodeFilter.FILTER_REJECT;
+                    }
+                    return NodeFilter.FILTER_ACCEPT;
+                }
+            });
+            var textNode = textNodeWalker.nextNode();
+            while (textNode) {
+                nodeCollection.push(textNode);
+                textNode = textNodeWalker.nextNode();
+            }
+            return nodeCollection;
+        };
+        DOMMethods.prototype.isBlockNode = function (element) {
+            return (!!element && (element.nodeType === Node.ELEMENT_NODE && this.BLOCK_TAGS.indexOf(element.tagName.toLowerCase()) >= 0));
+        };
+        DOMMethods.prototype.getLastTextNode = function (node) {
+            var treeWalker = this.currentDocument.createTreeWalker(node, NodeFilter.SHOW_TEXT, null);
+            var lastTextNode = null;
+            var currentNode = treeWalker.nextNode();
+            while (currentNode) {
+                lastTextNode = currentNode;
+                currentNode = treeWalker.nextNode();
+            }
+            return lastTextNode;
+        };
+        DOMMethods.prototype.getFirstTextNode = function (node) {
+            var treeWalker = this.currentDocument.createTreeWalker(node, NodeFilter.SHOW_TEXT, null);
+            var firstTextNode = treeWalker.nextNode();
+            return firstTextNode;
+        };
+        DOMMethods.prototype.getParentBlockNode = function (node) {
+            var _this = this;
+            var treeWalker = this.currentDocument.createTreeWalker(this.editableElement, NodeFilter.SHOW_ELEMENT, {
+                acceptNode: function (currentNode) {
+                    return _this.isBlockNode(currentNode) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+                }
+            });
+            treeWalker.currentNode = node;
+            var blockParent = treeWalker.parentNode();
+            return blockParent;
+        };
+        DOMMethods.prototype.getTopMostNode = function (text) {
+            if (this.isBlockNode(text.parentNode)) {
+                return text;
+            }
+            var parent = text.parentNode;
+            while (parent) {
+                if (!this.isBlockNode(parent.parentNode) && text.textContent === parent.textContent) {
+                    parent = parent.parentNode;
+                }
+                else {
+                    return parent;
+                }
+            }
+            return parent;
+        };
+        return DOMMethods;
+    }());
+    exports.DOMMethods = DOMMethods;
+});

package/blazorGlobalSrc/editor-manager/plugin/emoji-picker-action.d.ts

@@ -0,0 +1,10 @@
+import { EditorManager } from './../base/editor-manager';
+export declare class EmojiPickerAction {
+    private parent;
+    constructor(parent?: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private emojiInsert;
+    private beforeApplyFormat;
+    destroy(): void;
+}

package/blazorGlobalSrc/editor-manager/plugin/emoji-picker-action.js

@@ -0,0 +1,86 @@
+define(["require", "exports", "./../../selection/index", "./../../common/constant", "./inserthtml", "@syncfusion/ej2-base"], function (require, exports, index_1, EVENTS, inserthtml_1, ej2_base_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EmojiPickerAction = (function () {
+        function EmojiPickerAction(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        EmojiPickerAction.prototype.addEventListener = function () {
+            this.parent.observer.on(EVENTS.EMOJI_PICKER_ACTIONS, this.emojiInsert, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        EmojiPickerAction.prototype.removeEventListener = function () {
+            this.parent.observer.off(EVENTS.EMOJI_PICKER_ACTIONS, this.emojiInsert);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        EmojiPickerAction.prototype.emojiInsert = function (args) {
+            var node = document.createTextNode(args.value);
+            var selection = this.parent.currentDocument.getSelection();
+            var range = selection.getRangeAt(0);
+            var cursorPos = range.startOffset;
+            for (var i = cursorPos - 1; i >= cursorPos - 15; i--) {
+                var prevChar_1 = selection.focusNode.textContent.substring(i - 1, i);
+                var isPrevSpace_1 = /:$/.test(prevChar_1);
+                if (isPrevSpace_1) {
+                    this.beforeApplyFormat(true);
+                    break;
+                }
+            }
+            var colon = /:$/.test(selection.focusNode.textContent.charAt(cursorPos - 1));
+            var prevChar = selection.focusNode.textContent.charAt(cursorPos - 2);
+            var isPrevSpace = /\s/.test(prevChar);
+            if (colon && (isPrevSpace || selection.focusOffset === 1)) {
+                this.beforeApplyFormat(true);
+            }
+            var focusNode = selection.focusNode;
+            var anchorParent = ej2_base_1.closest(focusNode.nodeName === '#text' ? focusNode.parentNode : focusNode, 'a');
+            if (anchorParent) {
+                if (cursorPos === 0) {
+                    anchorParent.parentNode.insertBefore(node, anchorParent);
+                }
+                else if (cursorPos === focusNode.textContent.length) {
+                    anchorParent.parentNode.insertBefore(node, anchorParent.nextSibling);
+                    var nodeSelection = new index_1.NodeSelection(anchorParent);
+                    nodeSelection.setCursorPoint(this.parent.currentDocument, anchorParent.nextSibling, anchorParent.nextSibling.textContent.length);
+                }
+            }
+            else {
+                inserthtml_1.InsertHtml.Insert(this.parent.currentDocument, node, this.parent.editableElement);
+            }
+            if (args.callBack) {
+                args.callBack({
+                    requestType: args.subCommand,
+                    editorMode: 'HTML',
+                    event: args.event,
+                    range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                    elements: this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)
+                });
+            }
+        };
+        EmojiPickerAction.prototype.beforeApplyFormat = function (isBlockFormat) {
+            var range1 = this.parent.nodeSelection.getRange(this.parent.currentDocument);
+            var node = this.parent.nodeSelection.getNodeCollection(range1)[0];
+            var blockNewLine = !(node.parentElement.innerHTML.replace(/&nbsp;|<br>/g, '').trim() === ':' || node.textContent.trim().indexOf('/') === 0);
+            var startNode = node;
+            if (blockNewLine && isBlockFormat) {
+                while (startNode !== this.parent.editableElement) {
+                    startNode = startNode.parentElement;
+                }
+            }
+            var startPoint = range1.startOffset;
+            while (this.parent.nodeSelection.getRange(this.parent.editableElement.ownerDocument).toString().indexOf(':') === -1) {
+                this.parent.nodeSelection.setSelectionText(this.parent.editableElement.ownerDocument, node, node, startPoint, range1.endOffset);
+                startPoint--;
+            }
+            var range2 = this.parent.nodeSelection.getRange(this.parent.currentDocument);
+            var node2 = this.parent.nodeCutter.GetSpliceNode(range2, node);
+            node2.parentNode.removeChild(node2);
+        };
+        EmojiPickerAction.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return EmojiPickerAction;
+    }());
+    exports.EmojiPickerAction = EmojiPickerAction;
+});

package/blazorGlobalSrc/editor-manager/plugin/format-painter-actions.d.ts

@@ -0,0 +1,47 @@
+import { IFormatPainterEditor, IFormatPainterSettings } from '../base';
+import { EditorManager } from '../base';
+export declare class FormatPainterActions implements IFormatPainterEditor {
+    private INVALID_TAGS;
+    private parent;
+    private copyCollection;
+    private deniedFormatsCollection;
+    private newElem;
+    private newElemLastChild;
+    private settings;
+    constructor(parent?: EditorManager, options?: IFormatPainterSettings);
+    private addEventListener;
+    private onPropertyChanged;
+    private removeEventListener;
+    /**
+     * Destroys the format painter.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    private actionHandler;
+    private callBack;
+    private generateElement;
+    private pasteAction;
+    private removeDeniedFormats;
+    private copyAction;
+    private getRangeParentElem;
+    private getNearestBlockParentElement;
+    private isBlockElement;
+    private escapeAction;
+    private paintPlainTextFormat;
+    private validateELementTag;
+    private findCurrentContext;
+    private insertFormatNode;
+    private isListCopied;
+    private insertBlockNode;
+    private insertNewList;
+    private insertSameList;
+    private isSameListType;
+    private cleanEmptyLists;
+    private setDeniedFormats;
+    private detachEmptyBlockNodes;
+    private makeDeniedFormatsCollection;
+}