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

package/blazorGlobalSrc/rich-text-editor/actions/markdown-editor.js

@@ -0,0 +1,142 @@
+define(["require", "exports", "../base/constant", "@syncfusion/ej2-base", "../formatter/markdown-formatter", "../base/enum", "../base/classes", "./markdown-toolbar-status", "../renderer/markdown-renderer", "./../../markdown-parser/plugin/markdown-selection"], function (require, exports, events, ej2_base_1, markdown_formatter_1, enum_1, classes, markdown_toolbar_status_1, markdown_renderer_1, markdown_selection_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var MarkdownEditor = (function () {
+        function MarkdownEditor(parent, serviceLocator) {
+            this.parent = parent;
+            this.locator = serviceLocator;
+            this.renderFactory = this.locator.getService('rendererFactory');
+            this.addEventListener();
+            this.isDestroyed = false;
+        }
+        MarkdownEditor.prototype.destroy = function () {
+            if (this.isDestroyed) {
+                return;
+            }
+            this.removeEventListener();
+            this.isDestroyed = true;
+        };
+        MarkdownEditor.prototype.addEventListener = function () {
+            if (this.parent.isDestroyed) {
+                return;
+            }
+            this.saveSelection = new markdown_selection_1.MarkdownSelection();
+            this.parent.on(events.initialLoad, this.instantiateRenderer, this);
+            this.parent.on(events.initialEnd, this.render, this);
+            this.parent.on(events.modelChanged, this.onPropertyChanged, this);
+            this.parent.on(events.markdownToolbarClick, this.onToolbarClick, this);
+            this.parent.on(events.destroy, this.destroy, this);
+            this.parent.on(events.selectAll, this.selectAll, this);
+            this.parent.on(events.getSelectedHtml, this.getSelectedHtml, this);
+            this.parent.on(events.selectionSave, this.onSelectionSave, this);
+            this.parent.on(events.selectionRestore, this.onSelectionRestore, this);
+            this.parent.on(events.readOnlyMode, this.updateReadOnly, this);
+        };
+        MarkdownEditor.prototype.updateReadOnly = function () {
+            if (this.parent.readonly) {
+                this.parent.contentModule.getEditPanel().setAttribute('readonly', 'readonly');
+                ej2_base_1.addClass([this.parent.element], classes.CLS_RTE_READONLY);
+            }
+            else {
+                this.parent.contentModule.getEditPanel().removeAttribute('readonly');
+                ej2_base_1.removeClass([this.parent.element], classes.CLS_RTE_READONLY);
+            }
+        };
+        MarkdownEditor.prototype.onSelectionSave = function () {
+            var textArea = this.parent.contentModule.getEditPanel();
+            this.saveSelection.save(textArea.selectionStart, textArea.selectionEnd);
+        };
+        MarkdownEditor.prototype.onSelectionRestore = function (e) {
+            this.contentRenderer.getEditPanel().focus();
+            var textArea = this.parent.contentModule.getEditPanel();
+            this.saveSelection.restore(textArea);
+        };
+        MarkdownEditor.prototype.onToolbarClick = function (args) {
+            var item = args.item;
+            var textArea = this.parent.contentModule.getEditPanel();
+            if (item.command !== 'Formats') {
+                textArea.focus();
+            }
+            var startOffset = textArea.selectionStart;
+            var endOffset = textArea.selectionEnd;
+            var text = textArea.value.substring(startOffset, endOffset);
+            switch (item.subCommand) {
+                case 'Maximize':
+                    this.parent.notify(events.enableFullScreen, { args: args });
+                    break;
+                case 'Minimize':
+                    this.parent.notify(events.disableFullScreen, { args: args });
+                    break;
+                case 'CreateLink':
+                    this.parent.notify(events.insertLink, { member: 'link', args: args, text: text, module: 'Markdown' });
+                    break;
+                case 'Image':
+                    this.parent.notify(events.insertImage, { member: 'image', args: args, text: text, module: 'Markdown' });
+                    break;
+                case 'CreateTable': {
+                    var tableConstant = {
+                        'headingText': this.parent.localeObj.getConstant('TableHeadingText'),
+                        'colText': this.parent.localeObj.getConstant('TableColText')
+                    };
+                    this.parent.formatter.process(this.parent, args, args.originalEvent, tableConstant);
+                    break;
+                }
+                default:
+                    this.parent.formatter.process(this.parent, args, args.originalEvent, null);
+                    break;
+            }
+        };
+        MarkdownEditor.prototype.instantiateRenderer = function () {
+            this.renderFactory.addRenderer(enum_1.RenderType.Content, new markdown_renderer_1.MarkdownRender(this.parent));
+        };
+        MarkdownEditor.prototype.removeEventListener = function () {
+            this.parent.off(events.initialEnd, this.render);
+            this.parent.off(events.modelChanged, this.onPropertyChanged);
+            this.parent.off(events.destroy, this.destroy);
+            this.parent.off(events.markdownToolbarClick, this.onToolbarClick);
+            this.parent.off(events.initialLoad, this.instantiateRenderer);
+            this.parent.off(events.selectAll, this.selectAll);
+            this.parent.off(events.getSelectedHtml, this.getSelectedHtml);
+            this.parent.off(events.selectionSave, this.onSelectionSave);
+            this.parent.off(events.selectionRestore, this.onSelectionRestore);
+            this.parent.off(events.readOnlyMode, this.updateReadOnly);
+        };
+        MarkdownEditor.prototype.render = function () {
+            this.contentRenderer = this.renderFactory.getRenderer(enum_1.RenderType.Content);
+            var editElement = this.contentRenderer.getEditPanel();
+            var option = { undoRedoSteps: this.parent.undoRedoSteps, undoRedoTimer: this.parent.undoRedoTimer };
+            if (ej2_base_1.isNullOrUndefined(this.parent.formatter)) {
+                this.parent.formatter = new markdown_formatter_1.MarkdownFormatter({
+                    element: editElement,
+                    options: option
+                });
+            }
+            else {
+                this.parent.formatter.updateFormatter(editElement, this.contentRenderer.getDocument(), option);
+            }
+            if (this.parent.toolbarSettings.enable) {
+                this.toolbarUpdate = new markdown_toolbar_status_1.MarkdownToolbarStatus(this.parent);
+            }
+            this.parent.notify(events.bindOnEnd, {});
+        };
+        MarkdownEditor.prototype.onPropertyChanged = function (e) {
+            if (!ej2_base_1.isNullOrUndefined(e.newProp.formatter)) {
+                var editElement = this.contentRenderer.getEditPanel();
+                var option = { undoRedoSteps: this.parent.undoRedoSteps,
+                    undoRedoTimer: this.parent.undoRedoTimer };
+                this.parent.formatter.updateFormatter(editElement, this.contentRenderer.getDocument(), option);
+            }
+        };
+        MarkdownEditor.prototype.getModuleName = function () {
+            return 'markdownEditor';
+        };
+        MarkdownEditor.prototype.selectAll = function () {
+            this.parent.formatter.editorManager.markdownSelection.setSelection(this.parent.contentModule.getEditPanel(), 0, this.parent.contentModule.getEditPanel().value.length);
+        };
+        MarkdownEditor.prototype.getSelectedHtml = function (e) {
+            e.callBack(this.parent.formatter.editorManager.markdownSelection.getSelectedText(this.parent.contentModule.getEditPanel()));
+        };
+        return MarkdownEditor;
+    }());
+    exports.MarkdownEditor = MarkdownEditor;
+});

package/blazorGlobalSrc/rich-text-editor/actions/markdown-toolbar-status.d.ts

@@ -0,0 +1,23 @@
+import { MarkdownSelection } from '../../markdown-parser/plugin/markdown-selection';
+import { IRichTextEditor } from '../base/interface';
+import { IToolbarStatus } from '../../common/interface';
+/**
+ * MarkdownToolbarStatus module for refresh the toolbar status
+ */
+export declare class MarkdownToolbarStatus {
+    selection: MarkdownSelection;
+    parent: IRichTextEditor;
+    element: HTMLTextAreaElement;
+    toolbarStatus: IToolbarStatus;
+    private prevToolbarStatus;
+    constructor(parent: IRichTextEditor);
+    private addEventListener;
+    private removeEventListener;
+    private onRefreshHandler;
+    private isListsApplied;
+    private currentFormat;
+    private codeFormat;
+    private getSelectedText;
+    private isCode;
+    private multiCharRegx;
+}

package/blazorGlobalSrc/rich-text-editor/actions/markdown-toolbar-status.js

@@ -0,0 +1,124 @@
+define(["require", "exports", "../../markdown-parser/plugin/markdown-selection", "../base/constant", "../../common/util"], function (require, exports, markdown_selection_1, events, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var MarkdownToolbarStatus = (function () {
+        function MarkdownToolbarStatus(parent) {
+            this.toolbarStatus = this.prevToolbarStatus = util_1.getDefaultMDTbStatus();
+            this.selection = new markdown_selection_1.MarkdownSelection();
+            this.parent = parent;
+            this.element = this.parent.contentModule.getEditPanel();
+            this.addEventListener();
+        }
+        MarkdownToolbarStatus.prototype.addEventListener = function () {
+            this.parent.on(events.toolbarRefresh, this.onRefreshHandler, this);
+            this.parent.on(events.destroy, this.removeEventListener, this);
+        };
+        MarkdownToolbarStatus.prototype.removeEventListener = function () {
+            this.parent.off(events.toolbarRefresh, this.onRefreshHandler);
+            this.parent.off(events.destroy, this.removeEventListener);
+        };
+        MarkdownToolbarStatus.prototype.onRefreshHandler = function (args) {
+            var parentsLines = this.selection.getSelectedParentPoints(this.element);
+            this.toolbarStatus = {
+                orderedlist: args.documentNode ? false : this.isListsApplied(parentsLines, 'OL'),
+                unorderedlist: args.documentNode ? false : this.isListsApplied(parentsLines, 'UL'),
+                formats: this.currentFormat(parentsLines, args.documentNode),
+                bold: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('Bold'),
+                italic: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('Italic'),
+                inlinecode: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('InlineCode'),
+                strikethrough: args.documentNode ? false :
+                    this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('StrikeThrough'),
+                subscript: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('SubScript'),
+                superscript: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('SuperScript'),
+                uppercase: args.documentNode ? false : this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('UpperCase')
+            };
+            if (this.parent.formatter.editorManager.mdSelectionFormats.isAppliedCommand('InlineCode')) {
+                this.toolbarStatus.formats = 'pre';
+            }
+            var tbStatusString = JSON.stringify(this.toolbarStatus);
+            this.parent.notify(events.toolbarUpdated, this.toolbarStatus);
+            if (JSON.stringify(this.prevToolbarStatus) !== tbStatusString) {
+                this.parent.notify(events.updateTbItemsStatus, { html: null, markdown: JSON.parse(tbStatusString) });
+                this.prevToolbarStatus = JSON.parse(tbStatusString);
+            }
+        };
+        MarkdownToolbarStatus.prototype.isListsApplied = function (lines, type) {
+            var isApply = true;
+            if (type === 'OL') {
+                for (var i = 0; i < lines.length; i++) {
+                    var lineSplit = lines[i].text.trim().split(' ', 2)[0] + ' ';
+                    if (!/^[\d.]+[ ]+$/.test(lineSplit)) {
+                        isApply = false;
+                        break;
+                    }
+                }
+            }
+            else {
+                for (var i = 0; i < lines.length; i++) {
+                    if (!this.selection.isStartWith(lines[i].text, this.parent.formatter.listTags["" + type])) {
+                        isApply = false;
+                        break;
+                    }
+                }
+            }
+            return isApply;
+        };
+        MarkdownToolbarStatus.prototype.currentFormat = function (lines, documentNode) {
+            var format = 'p';
+            var keys = Object.keys(this.parent.formatter.formatTags);
+            var direction = this.element.selectionDirection;
+            var checkLine = direction === 'backward' ? lines[0].text : lines[lines.length - 1].text;
+            for (var i = 0; !documentNode && i < keys.length; i++) {
+                if (keys[i] !== 'pre' && this.selection.isStartWith(checkLine, this.parent.formatter.formatTags[keys[i]])) {
+                    format = keys[i];
+                    break;
+                }
+                else if (keys[i] === 'pre') {
+                    if (this.codeFormat()) {
+                        format = keys[i];
+                        break;
+                    }
+                }
+            }
+            return format;
+        };
+        MarkdownToolbarStatus.prototype.codeFormat = function () {
+            var isFormat = false;
+            var textArea = this.parent.inputElement;
+            var start = textArea.selectionStart;
+            var splitAt = function (index) { return function (x) { return [x.slice(0, index), x.slice(index)]; }; };
+            var splitText = splitAt(start)(textArea.value);
+            var cmdPre = this.parent.formatter.formatTags.pre;
+            var selectedText = this.getSelectedText(textArea);
+            if (selectedText !== '' && selectedText === selectedText.toLocaleUpperCase()) {
+                return true;
+            }
+            else if (selectedText === '') {
+                var beforeText = textArea.value.substr(splitText[0].length - 1, 1);
+                var afterText = splitText[1].substr(0, 1);
+                if ((beforeText !== '' && afterText !== '' && beforeText.match(/[a-z]/i)) &&
+                    beforeText === beforeText.toLocaleUpperCase() && afterText === afterText.toLocaleUpperCase()) {
+                    return true;
+                }
+            }
+            if ((this.isCode(splitText[0], cmdPre) && this.isCode(splitText[1], cmdPre)) &&
+                (splitText[0].match(this.multiCharRegx(cmdPre)).length % 2 === 1 &&
+                    splitText[1].match(this.multiCharRegx(cmdPre)).length % 2 === 1)) {
+                isFormat = true;
+            }
+            return isFormat;
+        };
+        MarkdownToolbarStatus.prototype.getSelectedText = function (textarea) {
+            return textarea.value.substring(textarea.selectionStart, textarea.selectionEnd);
+        };
+        MarkdownToolbarStatus.prototype.isCode = function (text, cmd) {
+            return text.search('\\' + cmd + '') !== -1;
+        };
+        MarkdownToolbarStatus.prototype.multiCharRegx = function (cmd) {
+            var regExp = RegExp;
+            return new regExp('(\\' + cmd + ')', 'g');
+        };
+        return MarkdownToolbarStatus;
+    }());
+    exports.MarkdownToolbarStatus = MarkdownToolbarStatus;
+});

package/blazorGlobalSrc/rich-text-editor/actions/paste-clean-up.d.ts

@@ -0,0 +1,86 @@
+import { IRichTextEditor } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+/**
+ * PasteCleanup module called when pasting content in RichTextEditor
+ */
+export declare class PasteCleanup {
+    private parent;
+    private renderFactory;
+    private locator;
+    private contentRenderer;
+    private i10n;
+    private saveSelection;
+    private nodeSelectionObj;
+    private dialogRenderObj;
+    private popupObj;
+    private uploadObj;
+    private dialogObj;
+    private keepRadioButton;
+    private cleanRadioButton;
+    private plainTextRadioButton;
+    private isNotFromHtml;
+    private containsHtml;
+    private cropImageData;
+    private fireFoxUploadTime;
+    private refreshPopupTime;
+    private popupCloseTime;
+    private failureTime;
+    private iframeUploadTime;
+    private plainTextContent;
+    private isDestroyed;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    private addEventListener;
+    private destroy;
+    private removeEventListener;
+    private pasteClean;
+    private splitBreakLine;
+    private makeSpace;
+    private imgUploading;
+    private getBlob;
+    private toolbarEnableDisable;
+    private uploadMethod;
+    private uploadFailure;
+    private popupClose;
+    private refreshPopup;
+    private base64ToFile;
+    /**
+     * Method for image formatting when pasting
+     *
+     * @param {Object} pasteArgs - specifies the paste arguments.
+     * @param {Element []} imgElement - specifies the array elements.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    private imageFormatting;
+    private radioRender;
+    private selectFormatting;
+    private pasteDialog;
+    private updateCss;
+    private setCssClass;
+    private destroyDialog;
+    private docClick;
+    private cleanAppleClass;
+    private formatting;
+    private convertBlobToBase64;
+    private cropImageHandler;
+    private addTableClass;
+    private setImageProperties;
+    private addTempClass;
+    private removeTempClass;
+    private sanitizeHelper;
+    private plainFormatting;
+    private tagGrouping;
+    private attributesfilter;
+    private deniedTags;
+    private deniedAttributes;
+    private allowedStyle;
+    private processPictureElement;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    private getModuleName;
+}