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

package/blazorGlobalSrc/rich-text-editor/renderer/content-renderer.d.ts

@@ -0,0 +1,65 @@
+import { IRenderer, IRichTextEditor } from '../base/interface';
+/**
+ * Content module is used to render Rich Text Editor content
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class ContentRender implements IRenderer {
+    protected contentPanel: Element;
+    protected parent: IRichTextEditor;
+    protected editableElement: HTMLElement;
+    /**
+     * Constructor for content renderer module
+     *
+     * @param {IRichTextEditor} parent - specifies the parent element.
+     */
+    constructor(parent?: IRichTextEditor);
+    /**
+     * The function is used to render Rich Text Editor content div
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    renderPanel(): void;
+    /**
+     * Get the content div element of RichTextEditor
+     *
+     * @returns {Element} - specifies the element.
+     * @hidden
+     * @deprecated
+     */
+    getPanel(): Element;
+    /**
+     * Get the editable element of RichTextEditor
+     *
+     * @returns {Element} - specifies the return element.
+     * @hidden
+     * @deprecated
+     */
+    getEditPanel(): Element;
+    /**
+     * Returns the text content as string.
+     *
+     * @returns {string} - specifies the string element.
+     */
+    getText(): string;
+    /**
+     * Set the content div element of RichTextEditor
+     *
+     * @param {Element} panel - specifies the panel element.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    setPanel(panel: Element): void;
+    /**
+     * Get the document of RichTextEditor
+     *
+     * @returns {Document} - specifies the document.
+     * @hidden
+     * @deprecated
+     */
+    getDocument(): Document;
+}

package/blazorGlobalSrc/rich-text-editor/renderer/content-renderer.js

@@ -0,0 +1,49 @@
+define(["require", "exports", "../base/util", "@syncfusion/ej2-base"], function (require, exports, util_1, ej2_base_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ContentRender = (function () {
+        function ContentRender(parent) {
+            this.parent = parent;
+        }
+        ContentRender.prototype.renderPanel = function () {
+            var rteObj = this.parent;
+            var div = this.parent.createElement('div', { className: 'e-rte-content', id: this.parent.getID() + 'rte-view' });
+            var rteContent = util_1.getEditValue(rteObj.value, rteObj);
+            this.editableElement = this.parent.createElement('div', {
+                className: 'e-content',
+                id: this.parent.getID() + '_rte-edit-view',
+                attrs: {
+                    'contenteditable': 'true'
+                }
+            });
+            if (!ej2_base_1.isNullOrUndefined(this.parent.fontFamily.default)) {
+                this.editableElement.style.fontFamily = this.parent.fontFamily.default;
+            }
+            if (!ej2_base_1.isNullOrUndefined(this.parent.fontSize.default)) {
+                this.editableElement.style.fontSize = this.parent.fontSize.default;
+            }
+            this.editableElement.innerHTML = rteContent;
+            div.appendChild(this.editableElement);
+            this.setPanel(div);
+            rteObj.rootContainer.appendChild(div);
+        };
+        ContentRender.prototype.getPanel = function () {
+            return this.contentPanel;
+        };
+        ContentRender.prototype.getEditPanel = function () {
+            return this.editableElement;
+        };
+        ContentRender.prototype.getText = function () {
+            var textString = this.getEditPanel().innerText;
+            return textString === '\n' ? '' : textString;
+        };
+        ContentRender.prototype.setPanel = function (panel) {
+            this.contentPanel = panel;
+        };
+        ContentRender.prototype.getDocument = function () {
+            return this.getEditPanel().ownerDocument;
+        };
+        return ContentRender;
+    }());
+    exports.ContentRender = ContentRender;
+});

package/blazorGlobalSrc/rich-text-editor/renderer/dialog-renderer.d.ts

@@ -0,0 +1,39 @@
+import { Dialog, DialogModel } from '@syncfusion/ej2-popups';
+import { IRichTextEditor } from '../base/interface';
+/**
+ * Dialog Renderer
+ */
+export declare class DialogRenderer {
+    dialogObj: Dialog;
+    private dialogEle;
+    private parent;
+    private outsideClickClosedBy;
+    constructor(parent?: IRichTextEditor);
+    protected addEventListener(): void;
+    protected removeEventListener(): void;
+    /**
+     * dialog render method
+     *
+     * @param {DialogModel} e - specifies the dialog model.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    render(e: DialogModel): Dialog;
+    private beforeOpen;
+    private handleEnterKeyDown;
+    private beforeOpenCallback;
+    private open;
+    private documentClickClosedBy;
+    private beforeClose;
+    private getDialogPosition;
+    /**
+     * dialog close method
+     *
+     * @param {Object} args - specifies the arguments.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    close(args: Object): void;
+}

package/blazorGlobalSrc/rich-text-editor/renderer/dialog-renderer.js

@@ -0,0 +1,111 @@
+define(["require", "exports", "@syncfusion/ej2-popups", "@syncfusion/ej2-base", "../base/constant"], function (require, exports, ej2_popups_1, ej2_base_1, events) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var DialogRenderer = (function () {
+        function DialogRenderer(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        DialogRenderer.prototype.addEventListener = function () {
+            if (this.parent.isDestroyed) {
+                return;
+            }
+            this.parent.on(events.destroy, this.removeEventListener, this);
+            this.parent.on(events.documentClickClosedBy, this.documentClickClosedBy, this);
+        };
+        DialogRenderer.prototype.removeEventListener = function () {
+            if (this.parent.isDestroyed) {
+                return;
+            }
+            this.parent.off(events.destroy, this.removeEventListener);
+            this.parent.off(events.documentClickClosedBy, this.documentClickClosedBy);
+        };
+        DialogRenderer.prototype.render = function (e) {
+            e.beforeOpen = this.beforeOpen.bind(this);
+            e.open = this.open.bind(this);
+            e.position = {
+                X: 'center',
+                Y: (e.target !== 'string' && e.target.nodeName === 'BODY' &&
+                    !ej2_base_1.isNullOrUndefined(e.position)) ? e.position.Y : this.getDialogPosition()
+            };
+            if (ej2_base_1.isNullOrUndefined(e.close)) {
+                e.close = this.close.bind(this);
+            }
+            e.beforeClose = this.beforeClose.bind(this);
+            if (this.parent.element.dataset.rteUnitTesting === 'true') {
+                e.animationSettings = { effect: 'None', duration: 0 };
+            }
+            var dlgObj = new ej2_popups_1.Dialog(e);
+            dlgObj.isStringTemplate = true;
+            return dlgObj;
+        };
+        DialogRenderer.prototype.beforeOpen = function (args) {
+            if (args.element.classList.contains('e-dialog')) {
+                var formEle = ej2_base_1.closest(args.target, 'form');
+                if (!ej2_base_1.isNullOrUndefined(formEle)) {
+                    this.dialogEle = args.element;
+                    this.dialogEle.addEventListener('keydown', this.handleEnterKeyDown);
+                }
+            }
+            this.parent.trigger(events.beforeDialogOpen, args, this.beforeOpenCallback.bind(this, args));
+        };
+        DialogRenderer.prototype.handleEnterKeyDown = function (args) {
+            if (args.key === 'Enter') {
+                args.preventDefault();
+            }
+        };
+        DialogRenderer.prototype.beforeOpenCallback = function (args) {
+            if (args.cancel) {
+                this.parent.notify(events.clearDialogObj, null);
+            }
+        };
+        DialogRenderer.prototype.open = function (args) {
+            var isFileMangerDialog = !ej2_base_1.isNullOrUndefined(args.container.querySelector('.e-rte-file-manager-dialog'));
+            if (isFileMangerDialog) {
+                args.preventFocus = true;
+            }
+            this.parent.trigger(events.dialogOpen, args);
+        };
+        DialogRenderer.prototype.documentClickClosedBy = function (args) {
+            this.outsideClickClosedBy = args.closedBy;
+        };
+        DialogRenderer.prototype.beforeClose = function (args) {
+            if (this.dialogEle) {
+                this.dialogEle.removeEventListener('keydown', this.handleEnterKeyDown);
+            }
+            args.closedBy = this.outsideClickClosedBy === 'outside click' ? this.outsideClickClosedBy : args.closedBy;
+            this.parent.trigger(events.beforeDialogClose, args, function (closeArgs) {
+                if (!closeArgs.cancel) {
+                    if (closeArgs.container.classList.contains('e-popup-close')) {
+                        closeArgs.cancel = true;
+                    }
+                }
+            });
+            this.outsideClickClosedBy = '';
+        };
+        DialogRenderer.prototype.getDialogPosition = function () {
+            var distanceFromVisibleTop = this.parent.element.getBoundingClientRect().top;
+            if (distanceFromVisibleTop < 0) {
+                var topHeight = 0;
+                var parentElement = this.parent.element;
+                while (parentElement.nodeName !== 'BODY') {
+                    var top_1 = parentElement.getBoundingClientRect().top;
+                    if (top_1 > 0) {
+                        topHeight = top_1;
+                    }
+                    parentElement = parentElement.parentElement;
+                }
+                distanceFromVisibleTop = Math.abs(distanceFromVisibleTop) + topHeight;
+                return distanceFromVisibleTop.toString();
+            }
+            else {
+                return 'top';
+            }
+        };
+        DialogRenderer.prototype.close = function (args) {
+            this.parent.trigger(events.dialogClose, args);
+        };
+        return DialogRenderer;
+    }());
+    exports.DialogRenderer = DialogRenderer;
+});

package/blazorGlobalSrc/rich-text-editor/renderer/iframe-content-renderer.d.ts

@@ -0,0 +1,33 @@
+import { ContentRender } from '../renderer/content-renderer';
+/**
+ * Content module is used to render Rich Text Editor content
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class IframeContentRender extends ContentRender {
+    /**
+     * The function is used to render Rich Text Editor iframe
+     *
+     * @hidden
+     * @deprecated
+     */
+    renderPanel(): void;
+    private setThemeColor;
+    /**
+     * Get the editable element of RichTextEditor
+     *
+     * @returns {Element} - specifies the element.
+     * @hidden
+     * @deprecated
+     */
+    getEditPanel(): Element;
+    /**
+     * Get the document of RichTextEditor
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getDocument(): Document;
+}

package/blazorGlobalSrc/rich-text-editor/renderer/iframe-content-renderer.js

@@ -0,0 +1,101 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+define(["require", "exports", "../renderer/content-renderer", "@syncfusion/ej2-base", "../base/util", "../../common/editor-styles"], function (require, exports, content_renderer_1, ej2_base_1, util_1, editor_styles_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var IFRAMEHEADER = "\n    <!DOCTYPE html> \n    <html>\n         <head>\n            <meta charset='utf-8' /> \n            <style>" +
+        editor_styles_1.IFRAME_EDITOR_STYLES.replace(/[\n\t]/g, '') + "\n            </style>\n        </head>\n";
+    var IframeContentRender = (function (_super) {
+        __extends(IframeContentRender, _super);
+        function IframeContentRender() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        IframeContentRender.prototype.renderPanel = function () {
+            var rteObj = this.parent;
+            var rteContent = util_1.getEditValue(rteObj.value, rteObj);
+            var iFrameBodyContent = '<body contenteditable="true">' +
+                rteContent + '</body></html>';
+            var iFrameContent = IFRAMEHEADER + iFrameBodyContent;
+            var iframe = this.parent.createElement('iframe', {
+                id: this.parent.getID() + '_rte-view',
+                className: 'e-rte-content',
+                attrs: { 'srcdoc': iFrameContent }
+            });
+            iframe.setAttribute('role', 'none');
+            this.setPanel(iframe);
+            if (!ej2_base_1.isNullOrUndefined(this.parent.iframeSettings.sandbox)) {
+                var sandboxValues = this.parent.iframeSettings.sandbox
+                    .map(function (element) { return element.toLocaleLowerCase().trim(); })
+                    .join(' ');
+                if (!sandboxValues.includes('allow-same-origin')) {
+                    sandboxValues += ' allow-same-origin';
+                }
+                iframe.setAttribute('sandbox', sandboxValues.trim());
+            }
+            rteObj.rootContainer.appendChild(iframe);
+            iframe.contentDocument.body.setAttribute('aria-owns', this.parent.getID());
+            iframe.contentDocument.open();
+            iFrameContent = this.setThemeColor(iFrameContent, { color: '#333' });
+            iframe.contentDocument.write(iFrameContent);
+            iframe.contentDocument.close();
+            var body = iframe.contentDocument.body;
+            body.className = 'e-content';
+            if (this.parent.height === 'auto') {
+                body.style.overflowY = 'hidden';
+            }
+            if (!ej2_base_1.isNullOrUndefined(this.parent.fontFamily.default)) {
+                body.style.fontFamily = this.parent.fontFamily.default;
+            }
+            if (!ej2_base_1.isNullOrUndefined(this.parent.fontSize.default)) {
+                body.style.fontSize = this.parent.fontSize.default;
+            }
+            body.id = this.parent.getID() + '_rte-edit-view';
+            if (rteObj.enableRtl) {
+                this.contentPanel.contentDocument.body.setAttribute('class', 'e-rtl');
+            }
+            if (!ej2_base_1.isNullOrUndefined(iframe.contentDocument.head) && this.parent.iframeSettings.metaTags.length > 0) {
+                var head_1 = iframe.contentDocument.head;
+                var metaData = this.parent.iframeSettings.metaTags;
+                metaData.forEach(function (tag) {
+                    var meta = document.createElement('meta');
+                    for (var key in tag) {
+                        if (!ej2_base_1.isNullOrUndefined(tag[key])) {
+                            meta.setAttribute((key === 'httpEquiv') ? 'http-equiv' : key, tag[key]);
+                        }
+                    }
+                    head_1.appendChild(meta);
+                });
+            }
+        };
+        IframeContentRender.prototype.setThemeColor = function (content, styles) {
+            var fontColor = getComputedStyle(this.parent.element, '.e-richtexteditor').getPropertyValue('color');
+            return content.replace(styles.color, fontColor);
+        };
+        IframeContentRender.prototype.getEditPanel = function () {
+            var editNode;
+            if (!ej2_base_1.isNullOrUndefined(this.contentPanel.contentDocument)) {
+                editNode = this.contentPanel.contentDocument.body;
+            }
+            else {
+                editNode = this.parent.inputElement;
+            }
+            return editNode;
+        };
+        IframeContentRender.prototype.getDocument = function () {
+            return this.getEditPanel().ownerDocument;
+        };
+        return IframeContentRender;
+    }(content_renderer_1.ContentRender));
+    exports.IframeContentRender = IframeContentRender;
+});

package/blazorGlobalSrc/rich-text-editor/renderer/image-module.d.ts

@@ -0,0 +1,199 @@
+import { Uploader } from '@syncfusion/ej2-inputs';
+import { Dialog } from '@syncfusion/ej2-popups';
+/**
+ * `Image` module is used to handle image actions.
+ */
+export declare class Image {
+    element: HTMLElement;
+    private rteID;
+    private parent;
+    dialogObj: Dialog;
+    private popupObj;
+    uploadObj: Uploader;
+    private i10n;
+    private inputUrl;
+    private captionEle;
+    private checkBoxObj;
+    private widthNum;
+    private heightNum;
+    private browseButton;
+    private uploadUrl;
+    private contentModule;
+    private rendererFactory;
+    private quickToolObj;
+    /**
+     * @hidden
+     */
+    imgResizeDiv: HTMLElement;
+    private imgDupPos;
+    private resizeBtnStat;
+    private imgEle;
+    private prevSelectedImgEle;
+    private isImgUploaded;
+    private isAllowedTypes;
+    private pageX;
+    private pageY;
+    private dialogRenderObj;
+    private deletedImg;
+    private changedWidthValue;
+    private changedHeightValue;
+    private inputWidthValue;
+    private inputHeightValue;
+    private removingImgName;
+    private currentResizeHandler;
+    private aspectRatio;
+    private drop;
+    private drag;
+    private enter;
+    private start;
+    private docClick;
+    private imageQTPopupTime;
+    private imageDragPopupTime;
+    private uploadCancelTime;
+    private uploadFailureTime;
+    private uploadSuccessTime;
+    private showImageQTbarTime;
+    private isDestroyed;
+    private constructor();
+    protected addEventListener(): void;
+    protected removeEventListener(): void;
+    private updateCss;
+    private setCssClass;
+    private onIframeMouseDown;
+    private afterRender;
+    private undoStack;
+    private resizeEnd;
+    private resizeStart;
+    private imageClick;
+    private onCutHandler;
+    private imageResize;
+    private getPointX;
+    private getPointY;
+    private imgResizePos;
+    private calcPos;
+    private setAspectRatio;
+    private setImageWidth;
+    private setImageHeight;
+    private removeImageHeight;
+    private getImageDimension;
+    private adjustDimensionsByAspectRatio;
+    private pixToPerc;
+    private imgDupMouseMove;
+    private resizing;
+    private adjustDimensions;
+    private getResizeFactor;
+    private findAspectRatio;
+    cancelResizeAction(): void;
+    private resizeImgDupPos;
+    private resizeBtnInit;
+    private onToolbarAction;
+    private openImgLink;
+    private editImgLink;
+    private removeImgLink;
+    private onKeyDown;
+    private handleSelectAll;
+    private openDialog;
+    private showDialog;
+    private closeDialog;
+    private onKeyUp;
+    private checkImageBack;
+    private checkImageDel;
+    private alignmentSelect;
+    private imageWithLinkQTBarItemUpdate;
+    private showImageQuickToolbar;
+    private hideImageQuickToolbar;
+    private editAreaClickHandler;
+    private insertImgLink;
+    private insertAltText;
+    private insertAlt;
+    private handleKeyDown;
+    private insertlink;
+    private isUrl;
+    private deleteImg;
+    private caption;
+    private imageSize;
+    private break;
+    private inline;
+    private alignImage;
+    private clearDialogObj;
+    private imagDialog;
+    private cancelDialog;
+    private onDocumentClick;
+    private removeResizeEle;
+    private onWindowResize;
+    private imageUrlPopup;
+    private insertImageUrl;
+    private imgsizeInput;
+    private inputValue;
+    private insertSize;
+    private insertImage;
+    private imgUpload;
+    private checkExtension;
+    private fileSelect;
+    private dragStart;
+    private dragEnter;
+    private dragOver;
+    /**
+     * Used to set range When drop an image
+     *
+     * @param {ImageDropEventArgs} args - specifies the image arguments.
+     * @returns {void}
+     */
+    private dragDrop;
+    /**
+     * Used to calculate range on internet explorer
+     *
+     * @param {number} x - specifies the x range.
+     * @param {number} y - specifies the y range.
+     * @returns {void}
+     */
+    private getDropRange;
+    private insertDragImage;
+    private hasOnlyImage;
+    private onSelect;
+    /**
+     * Rendering uploader and popup for drag and drop
+     *
+     * @param {DragEvent} dragEvent - specifies the event.
+     * @param {HTMLImageElement} imageElement - specifies the element.
+     * @returns {void}
+     */
+    private uploadMethod;
+    private refreshPopup;
+    /**
+     * Called when drop image upload was failed
+     *
+     * @param {HTMLElement} imgEle - specifies the image element.
+     * @param {IShowPopupArgs} args - specifies the arguments.
+     * @param {ImageFailedEventArgs} e - specfies the failure event.
+     * @returns {void}
+     */
+    private uploadFailure;
+    /**
+     * Called when drop image upload was successful
+     *
+     * @param {HTMLElement} imageElement - specifies the image element.
+     * @param {DragEvent} dragEvent - specifies the drag event.
+     * @param {IShowPopupArgs} args - specifies the arguments.
+     * @param {ImageSuccessEventArgs} e - specifies the success event.
+     * @returns {void}
+     */
+    private uploadSuccess;
+    private imagePaste;
+    private showPopupToolBar;
+    /**
+     * Destroys the ToolBar.
+     *
+     * @method destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {void}
+     */
+    private getModuleName;
+}