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

package/blazorGlobalSrc/rich-text-editor/actions/full-screen.js

@@ -0,0 +1,148 @@
+define(["require", "exports", "@syncfusion/ej2-base", "@syncfusion/ej2-popups", "../base/constant", "../base/classes", "@syncfusion/ej2-base"], function (require, exports, ej2_base_1, ej2_popups_1, events, classes, ej2_base_2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var FullScreen = (function () {
+        function FullScreen(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        FullScreen.prototype.showFullScreen = function (event) {
+            var _this = this;
+            if (this.parent.toolbarSettings.enable === true && this.parent.editorMode !== 'Markdown'
+                && !ej2_base_1.isNullOrUndefined(this.parent.quickToolbarModule)) {
+                this.parent.quickToolbarModule.hideQuickToolbars();
+            }
+            if (this.parent.showTooltip && !ej2_base_1.isNullOrUndefined(document.querySelector('.e-tooltip-wrap'))) {
+                this.parent.notify(events.destroyTooltip, { args: event });
+            }
+            this.scrollableParent = ej2_popups_1.getScrollableParent(this.parent.element);
+            if (!this.parent.element.classList.contains(classes.CLS_FULL_SCREEN)) {
+                var evenArgs = {
+                    cancel: false,
+                    requestType: 'Maximize',
+                    targetItem: 'Maximize',
+                    args: event
+                };
+                this.parent.trigger(events.actionBegin, evenArgs, function (beginEventArgs) {
+                    if (!beginEventArgs.cancel) {
+                        if (_this.parent.toolbarSettings.enableFloating &&
+                            !_this.parent.inlineMode.enable && _this.parent.toolbarSettings.enable) {
+                            _this.parent.getToolbarElement().style.width = '100%';
+                            _this.parent.getToolbarElement().style.top = '0px';
+                        }
+                        _this.parent.element.classList.add(classes.CLS_FULL_SCREEN);
+                        _this.toggleParentOverflow(true);
+                        if (_this.parent.toolbarModule) {
+                            if (!_this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
+                                _this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
+                            }
+                            if (ej2_base_1.Browser.isDevice) {
+                                _this.parent.toolbarModule.removeFixedTBarClass();
+                            }
+                            _this.parent.toolbarModule.updateItem({
+                                targetItem: 'Maximize',
+                                updateItem: 'Minimize',
+                                baseToolbar: _this.parent.getBaseToolbarObject()
+                            });
+                        }
+                        _this.parent.refreshUI();
+                        _this.parent.trigger(events.actionComplete, { requestType: 'Maximize', targetItem: 'Maximize', args: event });
+                    }
+                });
+            }
+        };
+        FullScreen.prototype.hideFullScreen = function (event) {
+            var _this = this;
+            if (this.parent.toolbarSettings.enable === true && this.parent.editorMode !== 'Markdown'
+                && !ej2_base_1.isNullOrUndefined(this.parent.quickToolbarModule)) {
+                this.parent.quickToolbarModule.hideQuickToolbars();
+            }
+            if (this.parent.showTooltip && !ej2_base_1.isNullOrUndefined(document.querySelector('.e-tooltip-wrap'))) {
+                this.parent.notify(events.destroyTooltip, { args: event });
+            }
+            if (this.parent.element.classList.contains(classes.CLS_FULL_SCREEN)) {
+                var evenArgs = {
+                    cancel: false,
+                    requestType: 'Minimize',
+                    targetItem: 'Minimize',
+                    args: event
+                };
+                this.parent.trigger(events.actionBegin, evenArgs, function (beginEventArgs) {
+                    if (!beginEventArgs.cancel) {
+                        _this.parent.element.classList.remove(classes.CLS_FULL_SCREEN);
+                        var elem = document.querySelectorAll('.e-rte-overflow');
+                        for (var i = 0; i < elem.length; i++) {
+                            ej2_base_2.removeClass([elem[i]], ['e-rte-overflow']);
+                        }
+                        if (_this.parent.toolbarModule) {
+                            if (!_this.parent.getBaseToolbarObject().toolbarObj.items[0].properties) {
+                                _this.parent.getBaseToolbarObject().toolbarObj.removeItems(0);
+                            }
+                            _this.parent.toolbarModule.updateItem({
+                                targetItem: 'Minimize',
+                                updateItem: 'Maximize',
+                                baseToolbar: _this.parent.getBaseToolbarObject()
+                            });
+                            if (ej2_base_1.Browser.isDevice && _this.parent.inlineMode.enable) {
+                                _this.parent.toolbarModule.addFixedTBarClass();
+                            }
+                        }
+                        _this.parent.refreshUI();
+                        _this.parent.trigger(events.actionComplete, { requestType: 'Minimize', targetItem: 'Minimize', args: event });
+                    }
+                });
+            }
+        };
+        FullScreen.prototype.toggleParentOverflow = function (isAdd) {
+            if (ej2_base_1.isNullOrUndefined(this.scrollableParent)) {
+                return;
+            }
+            for (var i = 0; i < this.scrollableParent.length; i++) {
+                if (this.scrollableParent[i].nodeName === '#document') {
+                    var elem = document.querySelector('body');
+                    ej2_base_2.addClass([elem], ['e-rte-overflow']);
+                }
+                else {
+                    var elem = this.scrollableParent[i];
+                    ej2_base_2.addClass([elem], ['e-rte-overflow']);
+                }
+            }
+        };
+        FullScreen.prototype.onKeyDown = function (event) {
+            var originalEvent = event.args;
+            switch (originalEvent.action) {
+                case 'full-screen':
+                    this.showFullScreen(event.args);
+                    originalEvent.preventDefault();
+                    break;
+                case 'escape':
+                    this.hideFullScreen(event.args);
+                    originalEvent.preventDefault();
+                    break;
+            }
+        };
+        FullScreen.prototype.addEventListener = function () {
+            this.parent.on(events.keyDown, this.onKeyDown, this);
+            this.parent.on(events.destroy, this.destroy, this);
+        };
+        FullScreen.prototype.removeEventListener = function () {
+            this.parent.off(events.keyDown, this.onKeyDown);
+            this.parent.off(events.destroy, this.destroy);
+        };
+        FullScreen.prototype.destroy = function () {
+            if (ej2_base_1.isNullOrUndefined(this.parent)) {
+                return;
+            }
+            if (this.parent.element.classList.contains(classes.CLS_FULL_SCREEN)) {
+                this.toggleParentOverflow(false);
+            }
+            var elem = document.querySelectorAll('.e-rte-overflow');
+            for (var i = 0; i < elem.length; i++) {
+                ej2_base_2.removeClass([elem[i]], ['e-rte-overflow']);
+            }
+            this.removeEventListener();
+        };
+        return FullScreen;
+    }());
+    exports.FullScreen = FullScreen;
+});

package/blazorGlobalSrc/rich-text-editor/actions/html-attributes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Used to set the HTML Attributes for RTE container
+ */
+import { IRichTextEditor } from '../base/interface';
+/**
+ * @param {string} htmlAttributes - specifies the string value
+ * @param {IRichTextEditor} rte - specifies the rte value
+ * @param {boolean} isFrame - specifies the boolean value
+ * @param {boolean} initial - specifies the boolean value
+ * @returns {void}
+ * @hidden
+ */
+export declare function setAttributes(htmlAttributes: {
+    [key: string]: string;
+}, rte: IRichTextEditor, isFrame: boolean, initial: boolean): void;

package/blazorGlobalSrc/rich-text-editor/actions/html-attributes.js

@@ -0,0 +1,50 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function setAttributes(htmlAttributes, rte, isFrame, initial) {
+        var target;
+        if (isFrame) {
+            var iFrame = rte.contentModule.getDocument();
+            target = iFrame.querySelector('body');
+        }
+        else {
+            target = rte.element;
+        }
+        if (Object.keys(htmlAttributes).length) {
+            for (var _i = 0, _a = Object.keys(htmlAttributes); _i < _a.length; _i++) {
+                var htmlAttr = _a[_i];
+                if (htmlAttr === 'class') {
+                    target.classList.add(htmlAttributes["" + htmlAttr]);
+                }
+                else if (htmlAttr === 'disabled' && htmlAttributes["" + htmlAttr] === 'disabled') {
+                    rte.enabled = false;
+                    rte.setEnable();
+                }
+                else if (htmlAttr === 'readonly' && htmlAttributes["" + htmlAttr] === 'readonly') {
+                    rte.readonly = true;
+                    rte.setReadOnly(initial);
+                }
+                else if (htmlAttr === 'style') {
+                    target.style.cssText = htmlAttributes["" + htmlAttr];
+                }
+                else if (htmlAttr === 'tabindex') {
+                    rte.inputElement.setAttribute('tabindex', htmlAttributes["" + htmlAttr]);
+                }
+                else if (htmlAttr === 'placeholder') {
+                    rte.placeholder = htmlAttributes["" + htmlAttr];
+                    rte.setPlaceHolder();
+                }
+                else {
+                    var validateAttr = ['name', 'required'];
+                    if (validateAttr.indexOf(htmlAttr) > -1) {
+                        rte.valueContainer.setAttribute(htmlAttr, htmlAttributes["" + htmlAttr]);
+                    }
+                    else {
+                        target.setAttribute(htmlAttr, htmlAttributes["" + htmlAttr]);
+                    }
+                }
+            }
+        }
+    }
+    exports.setAttributes = setAttributes;
+});

package/blazorGlobalSrc/rich-text-editor/actions/html-editor.d.ts

@@ -0,0 +1,120 @@
+import { IRichTextEditor } from '../base/interface';
+import { RichTextEditorModel } from '../base/rich-text-editor-model';
+import { ServiceLocator } from '../services/service-locator';
+import { XhtmlValidation } from './xhtml-validation';
+/**
+ * `HtmlEditor` module is used to HTML editor
+ */
+export declare class HtmlEditor {
+    private isDestroyed;
+    private parent;
+    private locator;
+    private contentRenderer;
+    private renderFactory;
+    private toolbarUpdate;
+    private nodeSelectionObj;
+    private rangeCollection;
+    private rangeElement;
+    private oldRangeElement;
+    private deleteRangeElement;
+    private deleteOldRangeElement;
+    private isImageDelete;
+    private isMention;
+    private saveSelection;
+    xhtmlValidation: XhtmlValidation;
+    private clickTimeout;
+    private isCopyAll;
+    private isSlashMenuOpen;
+    private isPreviousNodeBrAfterBackSpace;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    /**
+     * Destroys the Markdown.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    /**
+     * @param {string} value - specifies the string value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    sanitizeHelper(value: string): string;
+    private addEventListener;
+    private onSlashMenuOpen;
+    private updateReadOnly;
+    private onSelectionSave;
+    private onSelectionRestore;
+    private isTableClassAdded;
+    private onHandleFontsizeChange;
+    private convertFontSize;
+    private onKeyUp;
+    private removeZeroWidthSpaces;
+    private onKeyDown;
+    private isOrderedList;
+    private isUnOrderedList;
+    private hasMultipleTextNode;
+    private isCursorAtBlockStart;
+    private backSpaceCleanup;
+    private getLastNode;
+    private removeLastBr;
+    private deleteCleanup;
+    private getCaretIndex;
+    private getRangeElement;
+    private getRootBlockNode;
+    private getRangeLiNode;
+    private onPaste;
+    private spaceLink;
+    private onToolbarClick;
+    private instantiateRenderer;
+    private removeEventListener;
+    private render;
+    /**
+     * Called internally if any of the property value changed.
+     *
+     * @param {RichTextEditorModel} e - specifies the editor model
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    protected onPropertyChanged(e: {
+        [key: string]: RichTextEditorModel;
+    }): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} - returns the string value
+     * @hidden
+     */
+    private getModuleName;
+    /**
+     * For selecting all content in RTE
+     *
+     * @returns {void}
+     * @private
+     * @hidden
+     */
+    private selectAll;
+    /**
+     * For selecting all content in RTE
+     *
+     * @param {NotifyArgs} e - specifies the notified arguments
+     * @returns {void}
+     * @private
+     * @hidden
+     */
+    private selectRange;
+    /**
+     * For get a selected text in RTE
+     *
+     * @param {NotifyArgs} e - specifies the notified arguments
+     * @returns {void}
+     * @hidden
+     */
+    private getSelectedHtml;
+    private tableSelectionKeyAction;
+    private marginTabAdd;
+}