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

package/blazorGlobalSrc/editor-manager/plugin/selection-exec.d.ts

@@ -0,0 +1,24 @@
+import { EditorManager } from './../base/editor-manager';
+/**
+ * Selection EXEC internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class SelectionBasedExec {
+    private parent;
+    /**
+     * Constructor for creating the Formats plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private keyDownHandler;
+    private applySelection;
+    private callBack;
+    destroy(): void;
+}

package/blazorGlobalSrc/editor-manager/plugin/selection-exec.js

@@ -0,0 +1,49 @@
+define(["require", "exports", "./../base/constant", "./selection-commands", "./../../common/constant"], function (require, exports, CONSTANT, selection_commands_1, EVENTS) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var SelectionBasedExec = (function () {
+        function SelectionBasedExec(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        SelectionBasedExec.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.SELECTION_TYPE, this.applySelection, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.keyDownHandler, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        SelectionBasedExec.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.SELECTION_TYPE, this.applySelection);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.keyDownHandler);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        SelectionBasedExec.prototype.keyDownHandler = function (e) {
+            var validFormats = ['bold', 'italic', 'underline', 'strikethrough', 'superscript',
+                'subscript', 'uppercase', 'lowercase', 'inlinecode'];
+            if ((e.event.ctrlKey || e.event.metaKey) && validFormats.indexOf(e.event.action) > -1) {
+                e.event.preventDefault();
+                selection_commands_1.SelectionCommands.applyFormat(this.parent.currentDocument, e.event.action, this.parent.editableElement, e.enterAction, this.parent.tableCellSelection);
+                this.callBack(e, e.event.action);
+            }
+        };
+        SelectionBasedExec.prototype.applySelection = function (e) {
+            selection_commands_1.SelectionCommands.applyFormat(this.parent.currentDocument, e.subCommand.toLocaleLowerCase(), this.parent.editableElement, e.enterAction, this.parent.tableCellSelection, e.value, e.selector);
+            this.callBack(e, e.subCommand);
+        };
+        SelectionBasedExec.prototype.callBack = function (event, action) {
+            if (event.callBack) {
+                event.callBack({
+                    requestType: action,
+                    event: event.event,
+                    editorMode: 'HTML',
+                    range: this.parent.nodeSelection.getRange(this.parent.currentDocument),
+                    elements: this.parent.nodeSelection.getSelectedNodes(this.parent.currentDocument)
+                });
+            }
+        };
+        SelectionBasedExec.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        return SelectionBasedExec;
+    }());
+    exports.SelectionBasedExec = SelectionBasedExec;
+});

package/blazorGlobalSrc/editor-manager/plugin/table-selection.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utilities to handle the table cell selection
+ */
+export declare class TableSelection {
+    private root;
+    private currentDocument;
+    private BLOCK_TAGS;
+    private BASIC_FORMATS;
+    constructor(root: HTMLElement | HTMLBodyElement, currentDocument: Document);
+    /**
+     * Get the block nodes from the selected cells.
+     *
+     * @returns {HTMLTableCellElement[]} - Returns the selected cells
+     */
+    getBlockNodes(): HTMLElement[];
+    private addBlockNodes;
+    /**
+     * Get the text nodes from the selected cells
+     *
+     * @returns {Node[]} - Returns the text nodes
+     */
+    getTextNodes(): Node[];
+    private addTextNodes;
+    private wrapParagraphNodes;
+    private wrapInlineNodes;
+}

package/blazorGlobalSrc/editor-manager/plugin/table-selection.js

@@ -0,0 +1,210 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../../common/util"], function (require, exports, ej2_base_1, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var TableSelection = (function () {
+        function TableSelection(root, currentDocument) {
+            this.BLOCK_TAGS = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'li', 'pre', 'td', 'th', 'div', 'hr', 'section', 'figure'];
+            this.BASIC_FORMATS = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'pre'];
+            this.root = root;
+            this.currentDocument = currentDocument;
+        }
+        TableSelection.prototype.getBlockNodes = function () {
+            var blockNodes = [];
+            if (ej2_base_1.isNullOrUndefined(this.root.querySelector('.e-cell-select'))) {
+                return blockNodes;
+            }
+            var currentTable = this.root.querySelector('.e-cell-select').closest('table');
+            var cellSelectNode = currentTable.querySelectorAll('.e-cell-select');
+            if (ej2_base_1.isNullOrUndefined(cellSelectNode) || cellSelectNode.length < 2) {
+                return blockNodes;
+            }
+            for (var i = 0; i < cellSelectNode.length; i++) {
+                this.addBlockNodes(cellSelectNode[i], blockNodes);
+            }
+            this.wrapParagraphNodes(blockNodes);
+            return blockNodes;
+        };
+        TableSelection.prototype.addBlockNodes = function (node, blockNodes) {
+            var nodes = node.childNodes;
+            if (nodes.length === 0) {
+                blockNodes.push(node);
+                return;
+            }
+            for (var j = 0; j < nodes.length; j++) {
+                var currentNode = nodes[j];
+                if (blockNodes.indexOf(currentNode.parentElement) >= 0) {
+                    continue;
+                }
+                if (currentNode.parentElement && (currentNode.parentElement.nodeName === 'TD' || currentNode.parentElement.nodeName === 'TH')
+                    && currentNode.parentElement.childNodes.length === 1) {
+                    if (currentNode.nodeName === 'BR') {
+                        blockNodes.push(currentNode.parentElement);
+                    }
+                    else if (currentNode.nodeType === Node.TEXT_NODE) {
+                        blockNodes.push(currentNode.parentElement);
+                    }
+                    else {
+                        blockNodes.push(currentNode.parentElement);
+                    }
+                }
+                else {
+                    blockNodes.push(currentNode.parentElement);
+                }
+            }
+        };
+        TableSelection.prototype.getTextNodes = function () {
+            var textNodes = [];
+            if (ej2_base_1.isNullOrUndefined(this.root.querySelector('.e-cell-select'))) {
+                return textNodes;
+            }
+            var currentTable = this.root.querySelector('.e-cell-select').closest('table');
+            var cellSelectNode = currentTable.querySelectorAll('.e-cell-select');
+            if (ej2_base_1.isNullOrUndefined(cellSelectNode) || cellSelectNode.length < 2) {
+                return textNodes;
+            }
+            for (var i = 0; i < cellSelectNode.length; i++) {
+                this.addTextNodes(cellSelectNode[i], textNodes);
+            }
+            return textNodes;
+        };
+        TableSelection.prototype.addTextNodes = function (parent, textNodes) {
+            var nodes = parent.childNodes;
+            if (nodes.length === 0 && (parent.nodeName === 'TD' || parent.nodeName === 'TH')) {
+                var text = this.currentDocument.createTextNode('\u200B');
+                parent.appendChild(text);
+                textNodes.push(text);
+                return;
+            }
+            else if (nodes.length === 1 && (parent.nodeName === 'TD' || parent.nodeName === 'TH') && nodes[0].nodeName === 'BR') {
+                var text = this.currentDocument.createTextNode('\u200B');
+                parent.insertBefore(text, nodes[0]);
+                textNodes.push(text);
+                return;
+            }
+            for (var j = 0; j < nodes.length; j++) {
+                var currentNode = nodes[j];
+                if (currentNode.nodeType === Node.TEXT_NODE) {
+                    textNodes.push(currentNode);
+                }
+                else if (currentNode.nodeType === Node.ELEMENT_NODE) {
+                    this.addTextNodes(currentNode, textNodes);
+                }
+            }
+        };
+        TableSelection.prototype.wrapParagraphNodes = function (blockNodes) {
+            var blockNodesArry = Array.from(blockNodes);
+            for (var i = 0; i < blockNodesArry.length; i++) {
+                var node = blockNodesArry[i];
+                if (node.nodeName === 'TD' || node.nodeName === 'TH') {
+                    if (node.childNodes.length === 1 && (node.childNodes[0].nodeName === 'BR' || node.childNodes[0].nodeType === Node.TEXT_NODE)) {
+                        var childNode = node.childNodes[0];
+                        var paragraph = ej2_base_1.createElement('p');
+                        childNode.parentElement.insertBefore(paragraph, childNode);
+                        paragraph.appendChild(childNode);
+                        var index = blockNodes.indexOf(node);
+                        blockNodes[index] = paragraph;
+                    }
+                    else {
+                        var newIndex = blockNodes.indexOf(node);
+                        this.wrapInlineNodes(node, blockNodes, newIndex);
+                    }
+                }
+            }
+            for (var i = 0; i < blockNodes.length; i++) {
+                var currentNode = blockNodes[i];
+                if (currentNode.nodeName === 'LI' && currentNode.childNodes.length === 1) {
+                    var firstChild = currentNode.childNodes[0];
+                    if (firstChild.nodeType === Node.ELEMENT_NODE && this.BASIC_FORMATS.indexOf(firstChild.nodeName.toLocaleLowerCase()) >= 0
+                        && firstChild.textContent === currentNode.textContent) {
+                        blockNodes[i] = firstChild;
+                    }
+                }
+            }
+        };
+        TableSelection.prototype.wrapInlineNodes = function (node, blockNodes, index) {
+            var child = node.childNodes[0];
+            var wrapperElement = ej2_base_1.createElement('p');
+            var tempBlockNodes = [];
+            if (ej2_base_1.isNullOrUndefined(child)) {
+                node.appendChild(wrapperElement);
+                tempBlockNodes.push(wrapperElement);
+                util_1.insertItemsAtIndex(blockNodes, tempBlockNodes, index);
+                return;
+            }
+            while (child) {
+                if (child.nodeName === 'BR') {
+                    child.parentNode.insertBefore(wrapperElement, child);
+                    wrapperElement.appendChild(child);
+                    if (wrapperElement.childNodes.length > 0 && tempBlockNodes.indexOf(wrapperElement) < 0) {
+                        tempBlockNodes.push(wrapperElement);
+                    }
+                    child = wrapperElement.nextSibling;
+                    wrapperElement = ej2_base_1.createElement('p');
+                }
+                else if (this.BLOCK_TAGS.indexOf(child.nodeName.toLocaleLowerCase()) >= 0) {
+                    tempBlockNodes.push(child);
+                    if (wrapperElement.childNodes.length > 0) {
+                        child = wrapperElement.nextSibling;
+                    }
+                    else {
+                        if (child && child.nodeName === 'LI' && child.querySelectorAll('li').length > 0) {
+                            var listNodes = child.querySelectorAll('li');
+                            for (var i = 0; i < listNodes.length; i++) {
+                                tempBlockNodes.push(listNodes[i]);
+                            }
+                        }
+                        if (child.nodeName === 'LI' && ej2_base_1.isNullOrUndefined(child.nextSibling)) {
+                            child = child.parentElement.nextSibling;
+                        }
+                        else {
+                            child = child.nextSibling;
+                        }
+                    }
+                }
+                else if (child.nodeType === Node.TEXT_NODE) {
+                    if (child.textContent.trim() === '' && child.textContent.indexOf('\u200B') < 0) {
+                        var nextSibling = child.nextSibling;
+                        ej2_base_1.detach(child);
+                        child = nextSibling;
+                        continue;
+                    }
+                    child.parentNode.insertBefore(wrapperElement, child);
+                    var textNode = child;
+                    wrapperElement.appendChild(textNode);
+                    if (wrapperElement.childNodes.length > 0 && tempBlockNodes.indexOf(wrapperElement) < 0) {
+                        tempBlockNodes.push(wrapperElement);
+                    }
+                    child = wrapperElement.nextSibling;
+                }
+                else if (child.nodeName === 'TABLE' || child.nodeName === 'UL' || child.nodeName === 'OL') {
+                    if (child.nodeName === 'TABLE') {
+                        var nestedBlockNodes = [];
+                        var cellSelectNode = child.querySelectorAll('td, th');
+                        for (var i = 0; i < cellSelectNode.length; i++) {
+                            this.addBlockNodes(cellSelectNode[i], nestedBlockNodes);
+                        }
+                        this.wrapParagraphNodes(nestedBlockNodes);
+                        for (var i = 0; i < nestedBlockNodes.length; i++) {
+                            tempBlockNodes.push(nestedBlockNodes[i]);
+                        }
+                        child = child.nextSibling;
+                    }
+                    else {
+                        child = child.firstElementChild;
+                    }
+                }
+                else if (this.BLOCK_TAGS.indexOf(child.nodeName.toLocaleLowerCase()) < 0) {
+                    child.parentNode.insertBefore(wrapperElement, child);
+                    wrapperElement.appendChild(child);
+                    if (wrapperElement.childNodes.length > 0 && tempBlockNodes.indexOf(wrapperElement) < 0) {
+                        tempBlockNodes.push(wrapperElement);
+                    }
+                    child = wrapperElement.nextSibling;
+                }
+            }
+            util_1.insertItemsAtIndex(blockNodes, tempBlockNodes, index);
+        };
+        return TableSelection;
+    }());
+    exports.TableSelection = TableSelection;
+});

package/blazorGlobalSrc/editor-manager/plugin/table.d.ts

@@ -0,0 +1,56 @@
+import { EditorManager } from './../base/editor-manager';
+/**
+ * Link internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class TableCommand {
+    private parent;
+    private activeCell;
+    private curTable;
+    /**
+     * Constructor for creating the Formats plugin
+     *
+     * @param {EditorManager} parent - specifies the parent element
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private createTable;
+    private calculateStyleValue;
+    private insertAfter;
+    private getSelectedCellMinMaxIndex;
+    private insertRow;
+    private insertColumn;
+    private setBGColor;
+    private deleteColumn;
+    private deleteRow;
+    private getMergedRow;
+    private removeTable;
+    private tableHeader;
+    private tableVerticalAlign;
+    private cellMerge;
+    private updateColSpanStyle;
+    private updateRowSpanStyle;
+    private updateCellAttribute;
+    private mergeCellContent;
+    private getSelectedMinMaxIndexes;
+    private HorizontalSplit;
+    private VerticalSplit;
+    private getSplitColWidth;
+    private getColSizes;
+    private getCellIndex;
+    private convertPixelToPercentage;
+    private getCorrespondingColumns;
+    private FindIndex;
+    private getCorrespondingIndex;
+    private highlightCells;
+    private restoreRange;
+    private tableStyle;
+    private tableMove;
+    destroy(): void;
+    private cellStyleCleanup;
+}