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

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

@@ -0,0 +1,89 @@
+/**
+ * Is formatted or not.
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class IsFormatted {
+    static inlineTags: string[];
+    /**
+     * getFormattedNode method
+     *
+     * @param {Node} node - specifies the node.
+     * @param {string} format - specifies the string value.
+     * @param {Node} endNode - specifies the end node
+     * @returns {Node} - returns the node
+     * @hidden
+     * @deprecated
+     */
+    getFormattedNode(node: Node, format: string, endNode: Node): Node;
+    private getFormatParent;
+    private isFormattedNode;
+    /**
+     * isBold method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isBold(node: Node): boolean;
+    /**
+     * isItalic method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isItalic(node: Node): boolean;
+    /**
+     * isUnderline method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isUnderline(node: Node): boolean;
+    /**
+     * isStrikethrough method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isStrikethrough(node: Node): boolean;
+    /**
+     * isSuperscript method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isSuperscript(node: Node): boolean;
+    /**
+     * isSubscript method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isSubscript(node: Node): boolean;
+    private isFontColor;
+    private isBackgroundColor;
+    private isFontSize;
+    private isFontName;
+    /**
+     * isCode method
+     *
+     * @param {Node} node - specifies the node value
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    static isCode(node: Node): boolean;
+}

package/blazorGlobalSrc/editor-manager/plugin/isformatted.js

@@ -0,0 +1,199 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var IsFormatted = (function () {
+        function IsFormatted() {
+        }
+        IsFormatted.prototype.getFormattedNode = function (node, format, endNode) {
+            var parentNode = this.getFormatParent(node, format, endNode);
+            if (parentNode !== null && parentNode !== endNode) {
+                return parentNode;
+            }
+            return null;
+        };
+        IsFormatted.prototype.getFormatParent = function (node, format, endNode) {
+            do {
+                node = node.parentNode;
+            } while (node && (node !== endNode) && !this.isFormattedNode(node, format));
+            return node;
+        };
+        IsFormatted.prototype.isFormattedNode = function (node, format) {
+            switch (format) {
+                case 'bold':
+                    return IsFormatted.isBold(node);
+                case 'italic':
+                    return IsFormatted.isItalic(node);
+                case 'underline':
+                    return IsFormatted.isUnderline(node);
+                case 'strikethrough':
+                    return IsFormatted.isStrikethrough(node);
+                case 'superscript':
+                    return IsFormatted.isSuperscript(node);
+                case 'subscript':
+                    return IsFormatted.isSubscript(node);
+                case 'fontcolor':
+                    return this.isFontColor(node);
+                case 'fontname':
+                    return this.isFontName(node);
+                case 'fontsize':
+                    return this.isFontSize(node);
+                case 'backgroundcolor':
+                    return this.isBackgroundColor(node);
+                case 'inlinecode':
+                    return IsFormatted.isCode(node);
+                default:
+                    return false;
+            }
+        };
+        IsFormatted.isBold = function (node) {
+            var validTags = ['strong', 'b'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else if (this.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                node.style && node.style.fontWeight === 'bold') {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isItalic = function (node) {
+            var validTags = ['em', 'i'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else if (this.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                node.style && node.style.fontStyle === 'italic') {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isUnderline = function (node) {
+            var validTags = ['u'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else if (this.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                node.style && (node.style.textDecoration === 'underline' ||
+                node.style.textDecorationLine === 'underline')) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isStrikethrough = function (node) {
+            var validTags = ['del', 'strike', 's'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else if (this.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                node.style && (node.style.textDecoration === 'line-through' ||
+                node.style.textDecorationLine === 'line-through')) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isSuperscript = function (node) {
+            var validTags = ['sup'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isSubscript = function (node) {
+            var validTags = ['sub'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.prototype.isFontColor = function (node) {
+            var color = node.style && node.style.color;
+            if (IsFormatted.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                color !== null && color !== '' && color !== undefined) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.prototype.isBackgroundColor = function (node) {
+            var backColor = node.style && node.style.backgroundColor;
+            if (IsFormatted.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                backColor !== null && backColor !== '' && backColor !== undefined) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.prototype.isFontSize = function (node) {
+            var size = node.style && node.style.fontSize;
+            if (IsFormatted.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                size !== null && size !== '' && size !== undefined) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.prototype.isFontName = function (node) {
+            var name = node.style && node.style.fontFamily;
+            if (IsFormatted.inlineTags.indexOf(node.nodeName.toLowerCase()) !== -1 &&
+                name !== null && name !== '' && name !== undefined) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.isCode = function (node) {
+            var validTags = ['code'];
+            if (validTags.indexOf(node.nodeName.toLowerCase()) !== -1) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        IsFormatted.inlineTags = [
+            'a',
+            'abbr',
+            'acronym',
+            'b',
+            'bdo',
+            'big',
+            'cite',
+            'code',
+            'dfn',
+            'em',
+            'font',
+            'i',
+            'kbd',
+            'label',
+            'q',
+            'samp',
+            'small',
+            'span',
+            'strong',
+            'sub',
+            'sup',
+            'tt',
+            'u',
+            'var',
+            'del'
+        ];
+        return IsFormatted;
+    }());
+    exports.IsFormatted = IsFormatted;
+});

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

@@ -0,0 +1,41 @@
+import { EditorManager } from './../base/editor-manager';
+/**
+ * Link internal component
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class LinkCommand {
+    private parent;
+    private drop;
+    private enter;
+    private start;
+    private dragSelectionRange;
+    /**
+     * Constructor for creating the Formats plugin
+     *
+     * @param {EditorManager} parent - specifies the editor manager
+     * @hidden
+     * @deprecated
+     */
+    constructor(parent: EditorManager);
+    private addEventListener;
+    private removeEventListener;
+    private linkCommand;
+    private dragStart;
+    private dragEnter;
+    private dragDrop;
+    private normalizeEmptyLinks;
+    private createLink;
+    private createAchorNode;
+    private removeText;
+    private openLink;
+    private removeLink;
+    private callBack;
+    destroy(): void;
+    private handleLinkFormat;
+    private applyLinkToBlockNode;
+    private unwrapLink;
+    private replaceElementsWithAnchor;
+    private getSplitNode;
+}