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

package/blazorGlobalSrc/markdown-parser/plugin/table.js

@@ -0,0 +1,216 @@
+define(["require", "exports", "./../base/constant", "@syncfusion/ej2-base", "./../../common/constant"], function (require, exports, CONSTANT, ej2_base_1, EVENTS) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var MDTable = (function () {
+        function MDTable(options) {
+            ej2_base_1.extend(this, this, options, true);
+            this.selection = this.parent.markdownSelection;
+            this.addEventListener();
+        }
+        MDTable.prototype.addEventListener = function () {
+            this.parent.observer.on(CONSTANT.MD_TABLE, this.createTable, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        MDTable.prototype.removeEventListener = function () {
+            this.parent.observer.off(CONSTANT.MD_TABLE, this.createTable);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.onKeyDown);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        MDTable.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        MDTable.prototype.onKeyDown = function (e) {
+            if (e.event.action === 'insert-table') {
+                e.item = e.value;
+                this.createTable(e);
+            }
+        };
+        MDTable.prototype.createTable = function (e) {
+            this.element = this.parent.element;
+            var start = this.element.selectionStart;
+            var end = this.element.selectionEnd;
+            var textAreaInitial = this.element.value;
+            this.locale = e;
+            this.selection.save(start, end);
+            this.restore(this.element.selectionStart, this.element.selectionEnd, null);
+            this.insertTable(start, end, textAreaInitial, e);
+        };
+        MDTable.prototype.getTable = function () {
+            var table = '';
+            table += this.textNonEmpty();
+            table += this.tableHeader(this.locale);
+            table += this.tableCell(this.locale);
+            return table;
+        };
+        MDTable.prototype.tableHeader = function (e) {
+            var text = '';
+            for (var i = 1; i <= 2; i++) {
+                text += '|';
+                for (var j = 1; j <= 2; j++) {
+                    if (i === 1) {
+                        text += e.item.headingText + ' ' + j + '|';
+                    }
+                    else {
+                        text += '---------|';
+                    }
+                }
+                text += this.insertLine();
+            }
+            return text;
+        };
+        MDTable.prototype.tableCell = function (e) {
+            var text = '';
+            for (var i = 1; i <= 2; i++) {
+                text += '|';
+                for (var j = 1; j <= 2; j++) {
+                    text += e.item.colText + ' ' + this.convertToLetters(i) + j + '|';
+                }
+                text += this.insertLine();
+            }
+            text += this.insertLine();
+            return text;
+        };
+        MDTable.prototype.insertLine = function () {
+            var dummyElement = document.createElement('div');
+            dummyElement.innerHTML = '\n';
+            return dummyElement.textContent;
+        };
+        MDTable.prototype.insertTable = function (start, end, textAreaInitial, e) {
+            var parentText = this.selection.getSelectedParentPoints(this.element);
+            var lastLineSplit = parentText[parentText.length - 1].text.split(' ', 2);
+            var syntaxArr = this.getFormatTag();
+            var syntaxCount = 0;
+            if (lastLineSplit.length < 2) {
+                this.element.value = this.updateValue(this.getTable());
+                this.makeSelection(textAreaInitial, start, end);
+            }
+            else {
+                if (this.ensureFormatApply(parentText[parentText.length - 1].text)) {
+                    this.checkValid(start, end, this.getTable(), textAreaInitial, e, lastLineSplit, parentText, syntaxArr);
+                }
+                else {
+                    this.element.value = this.updateValue(this.getTable());
+                    this.makeSelection(textAreaInitial, start, end);
+                }
+            }
+            this.restore(this.element.selectionStart, this.element.selectionEnd, e);
+        };
+        MDTable.prototype.makeSelection = function (textAreaInitial, start, end) {
+            end = start + (textAreaInitial.length > 0 ? 12 : 10);
+            start += textAreaInitial.length > 0 ? 3 : 1;
+            this.selection.setSelection(this.element, start, end);
+        };
+        MDTable.prototype.getFormatTag = function () {
+            var syntaxFormatKey = Object.keys(this.syntaxTag.Formats);
+            var syntaxListKey = Object.keys(this.syntaxTag.List);
+            var syntaxArr = [];
+            for (var i = 0; i < syntaxFormatKey.length; i++) {
+                syntaxArr.push(this.syntaxTag.Formats[syntaxFormatKey[i]]);
+            }
+            for (var j = 0; j < syntaxListKey.length; j++) {
+                syntaxArr.push(this.syntaxTag.List[syntaxListKey[j]]);
+            }
+            return syntaxArr;
+        };
+        MDTable.prototype.ensureFormatApply = function (line) {
+            var formatTags = this.getFormatTag();
+            var formatSplitZero = line.trim().split(' ', 2)[0] + ' ';
+            for (var i = 0; i < formatTags.length; i++) {
+                if (formatSplitZero === formatTags[i] || /^[\d.]+[ ]+$/.test(formatSplitZero)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        MDTable.prototype.ensureStartValid = function (firstLine, parentText) {
+            var firstLineSplit = parentText[0].text.split(' ', 2);
+            for (var i = firstLine + 1; i <= firstLine + firstLineSplit[0].length - 1; i++) {
+                if (this.element.selectionStart === i || this.element.selectionEnd === i) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        MDTable.prototype.ensureEndValid = function (lastLine, formatSplitLength) {
+            for (var i = lastLine + 1; i <= lastLine + formatSplitLength - 1; i++) {
+                if (this.element.selectionEnd === i) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        MDTable.prototype.updateValueWithFormat = function (formatSplit, text) {
+            var textApplyFormat = this.element.value.substring(this.element.selectionEnd, this.element.value.length);
+            text += textApplyFormat.replace(textApplyFormat, (formatSplit[0] + ' ' + textApplyFormat));
+            return this.element.value.substr(0, this.element.selectionStart) + text;
+        };
+        MDTable.prototype.updateValue = function (text) {
+            return this.element.value.substr(0, this.element.selectionStart) + text +
+                this.element.value.substr(this.element.selectionEnd, this.element.value.length);
+        };
+        MDTable.prototype.checkValid = function (start, end, text, textAreaInitial, e, formatSplit, parentText, syntaxArr) {
+            if (this.ensureStartValid(parentText[0].start, parentText) &&
+                this.ensureEndValid(parentText[parentText.length - 1].start, formatSplit[0].length)) {
+                if (start === parentText[0].start) {
+                    if (start !== end && end !== (parentText[parentText.length - 1].end - 1)) {
+                        this.element.value = this.updateValueWithFormat(formatSplit, text);
+                    }
+                    else {
+                        this.element.value = this.updateValue(text);
+                    }
+                }
+                else if (end === parentText[parentText.length - 1].end - 1) {
+                    this.element.value = this.updateValue(text);
+                }
+                else {
+                    this.element.value = this.updateValueWithFormat(formatSplit, text);
+                }
+                this.makeSelection(textAreaInitial, start, end);
+            }
+        };
+        MDTable.prototype.convertToLetters = function (rowNumber) {
+            var baseChar = ('A').charCodeAt(0);
+            var letters = '';
+            do {
+                rowNumber -= 1;
+                letters = String.fromCharCode(baseChar + (rowNumber % 26)) + letters;
+                rowNumber = (rowNumber / 26) >> 0;
+            } while (rowNumber > 0);
+            return letters;
+        };
+        MDTable.prototype.textNonEmpty = function () {
+            var emptyText = '';
+            if (this.isCursorBased() || this.isSelectionBased()) {
+                if (this.element.value.length > 0) {
+                    emptyText += this.insertLine();
+                    emptyText += this.insertLine();
+                }
+            }
+            return emptyText;
+        };
+        MDTable.prototype.isCursorBased = function () {
+            return this.element.selectionStart === this.element.selectionEnd;
+        };
+        MDTable.prototype.isSelectionBased = function () {
+            return this.element.selectionStart !== this.element.selectionEnd;
+        };
+        MDTable.prototype.restore = function (start, end, event) {
+            this.selection.save(start, end);
+            this.selection.restore(this.element);
+            if (event && event.callBack) {
+                if (ej2_base_1.isNullOrUndefined(event.subCommand) && 'action' in event.event && event.event.action === 'insert-table') {
+                    event.subCommand = 'CreateTable';
+                }
+                event.callBack({
+                    requestType: event.subCommand,
+                    selectedText: this.selection.getSelectedText(this.element),
+                    editorMode: 'Markdown',
+                    event: event.event
+                });
+            }
+        };
+        return MDTable;
+    }());
+    exports.MDTable = MDTable;
+});

package/blazorGlobalSrc/markdown-parser/plugin/undo.d.ts

@@ -0,0 +1,83 @@
+import { MarkdownParser } from './../base/markdown-parser';
+import { IMarkdownSubCommands, IMDKeyboardEvent, MarkdownUndoRedoData } from './../base/interface';
+import { IUndoCallBack } from '../../common/interface';
+/**
+ * `Undo` module is used to handle undo actions.
+ */
+export declare class UndoRedoCommands {
+    steps: number;
+    undoRedoStack: MarkdownUndoRedoData[];
+    private parent;
+    private selection;
+    private currentAction;
+    undoRedoSteps: number;
+    undoRedoTimer: number;
+    constructor(parent?: MarkdownParser, options?: {
+        [key: string]: number;
+    });
+    protected addEventListener(): void;
+    private onPropertyChanged;
+    protected removeEventListener(): void;
+    /**
+     * Destroys the ToolBar.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    /**
+     * onAction method
+     *
+     * @param {IMarkdownSubCommands} e - specifies the sub commands
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    onAction(e: IMarkdownSubCommands): void;
+    private keyDown;
+    private keyUp;
+    /**
+     * MD collection stored string format.
+     *
+     * @param {KeyboardEvent} e - specifies the key board event
+     * @function saveData
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    saveData(e?: KeyboardEvent | MouseEvent | IUndoCallBack): void;
+    /**
+     * Undo the editable text.
+     *
+     * @param {IMarkdownSubCommands} e - specifies the sub commands
+     * @function undo
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    undo(e?: IMarkdownSubCommands | IMDKeyboardEvent): void;
+    /**
+     * Redo the editable text.
+     *
+     * @param {IMarkdownSubCommands} e - specifies the sub commands
+     * @function redo
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    redo(e?: IMarkdownSubCommands | IMDKeyboardEvent): void;
+    private restore;
+    /**
+     * getUndoStatus method
+     *
+     * @returns {boolean} - returns the boolean value
+     * @hidden
+     * @deprecated
+     */
+    getUndoStatus(): {
+        [key: string]: boolean;
+    };
+    getCurrentStackIndex(): number;
+}

package/blazorGlobalSrc/markdown-parser/plugin/undo.js

@@ -0,0 +1,147 @@
+define(["require", "exports", "@syncfusion/ej2-base", "./../../common/constant"], function (require, exports, ej2_base_1, EVENTS) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var UndoRedoCommands = (function () {
+        function UndoRedoCommands(parent, options) {
+            this.undoRedoStack = [];
+            this.parent = parent;
+            this.undoRedoSteps = !ej2_base_1.isNullOrUndefined(options) ? options.undoRedoSteps : 30;
+            this.undoRedoTimer = !ej2_base_1.isNullOrUndefined(options) ? options.undoRedoTimer : 300;
+            this.selection = this.parent.markdownSelection;
+            this.addEventListener();
+        }
+        UndoRedoCommands.prototype.addEventListener = function () {
+            var debounceListener = ej2_base_1.debounce(this.keyUp, this.undoRedoTimer);
+            this.parent.observer.on(EVENTS.KEY_UP_HANDLER, debounceListener, this);
+            this.parent.observer.on(EVENTS.KEY_DOWN_HANDLER, this.keyDown, this);
+            this.parent.observer.on(EVENTS.ACTION, this.onAction, this);
+            this.parent.observer.on(EVENTS.MODEL_CHANGED_PLUGIN, this.onPropertyChanged, this);
+            this.parent.observer.on(EVENTS.INTERNAL_DESTROY, this.destroy, this);
+        };
+        UndoRedoCommands.prototype.onPropertyChanged = function (props) {
+            for (var _i = 0, _a = Object.keys(props.newProp); _i < _a.length; _i++) {
+                var prop = _a[_i];
+                switch (prop) {
+                    case 'undoRedoSteps':
+                        this.undoRedoSteps = props.newProp.undoRedoSteps;
+                        break;
+                    case 'undoRedoTimer':
+                        this.undoRedoTimer = props.newProp.undoRedoTimer;
+                        break;
+                }
+            }
+        };
+        UndoRedoCommands.prototype.removeEventListener = function () {
+            var debounceListener = ej2_base_1.debounce(this.keyUp, 300);
+            this.parent.observer.off(EVENTS.KEY_UP_HANDLER, debounceListener);
+            this.parent.observer.off(EVENTS.KEY_DOWN_HANDLER, this.keyDown);
+            this.parent.observer.off(EVENTS.ACTION, this.onAction);
+            this.parent.observer.off(EVENTS.MODEL_CHANGED_PLUGIN, this.onPropertyChanged);
+            this.parent.observer.off(EVENTS.INTERNAL_DESTROY, this.destroy);
+        };
+        UndoRedoCommands.prototype.destroy = function () {
+            this.removeEventListener();
+        };
+        UndoRedoCommands.prototype.onAction = function (e) {
+            if (e.subCommand === 'Undo') {
+                this.undo(e);
+            }
+            else {
+                this.redo(e);
+            }
+        };
+        UndoRedoCommands.prototype.keyDown = function (e) {
+            var event = e.event;
+            var proxy = this;
+            switch (event.action) {
+                case 'undo':
+                    event.preventDefault();
+                    proxy.undo(e);
+                    break;
+                case 'redo':
+                    event.preventDefault();
+                    proxy.redo(e);
+                    break;
+            }
+        };
+        UndoRedoCommands.prototype.keyUp = function (e) {
+            if (e.event.keyCode !== 17 && !e.event.ctrlKey) {
+                this.saveData(e);
+            }
+        };
+        UndoRedoCommands.prototype.saveData = function (e) {
+            var textArea = this.parent.element;
+            this.selection.save(textArea.selectionStart, textArea.selectionEnd);
+            var start = textArea.selectionStart;
+            var end = textArea.selectionEnd;
+            var textValue = this.parent.element.value.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+            var changEle = { text: textValue, start: start, end: end };
+            if (this.undoRedoStack.length >= this.steps) {
+                this.undoRedoStack = this.undoRedoStack.slice(0, this.steps + 1);
+            }
+            if (this.undoRedoStack.length > 1 && (this.undoRedoStack[this.undoRedoStack.length - 1].start === start) &&
+                (this.undoRedoStack[this.undoRedoStack.length - 1].end === end)) {
+                return;
+            }
+            this.undoRedoStack.push(changEle);
+            this.steps = this.undoRedoStack.length - 1;
+            if (this.steps > this.undoRedoSteps) {
+                this.undoRedoStack.shift();
+                this.steps--;
+            }
+            if (e && e.callBack) {
+                e.callBack();
+            }
+        };
+        UndoRedoCommands.prototype.undo = function (e) {
+            if (this.steps > 0) {
+                this.currentAction = 'Undo';
+                var start = this.undoRedoStack[this.steps - 1].start;
+                var end = this.undoRedoStack[this.steps - 1].end;
+                var removedContent = this.undoRedoStack[this.steps - 1].text;
+                this.parent.element.value = removedContent.replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+                this.parent.element.focus();
+                this.steps--;
+                this.restore(this.parent.element, start, end, e);
+            }
+        };
+        UndoRedoCommands.prototype.redo = function (e) {
+            if (this.undoRedoStack[this.steps + 1] != null) {
+                this.currentAction = 'Redo';
+                var start = this.undoRedoStack[this.steps + 1].start;
+                var end = this.undoRedoStack[this.steps + 1].end;
+                this.parent.element.value = this.undoRedoStack[this.steps + 1].text;
+                this.parent.element.focus();
+                this.steps++;
+                this.restore(this.parent.element, start, end, e);
+            }
+        };
+        UndoRedoCommands.prototype.restore = function (textArea, start, end, event) {
+            this.selection.save(start, end);
+            this.selection.restore(textArea);
+            if (event && event.callBack) {
+                event.callBack({
+                    requestType: this.currentAction,
+                    selectedText: this.selection.getSelectedText(textArea),
+                    editorMode: 'Markdown',
+                    event: event.event
+                });
+            }
+        };
+        UndoRedoCommands.prototype.getUndoStatus = function () {
+            var status = { undo: false, redo: false };
+            if (this.steps > 0) {
+                status.undo = true;
+            }
+            if (this.undoRedoStack[this.steps + 1] != null) {
+                status.redo = true;
+            }
+            return status;
+        };
+        UndoRedoCommands.prototype.getCurrentStackIndex = function () {
+            return this.steps;
+        };
+        return UndoRedoCommands;
+    }());
+    exports.UndoRedoCommands = UndoRedoCommands;
+});

package/blazorGlobalSrc/markdown-parser/plugin.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Export all markdown plugins
+ */
+export * from './plugin/clearformat';
+export * from './plugin/lists';
+export * from './plugin/formats';
+export * from './plugin/markdown-selection';
+export * from './plugin/undo';
+export * from './plugin/md-selection-formats';
+export * from './plugin/link';
+export * from './plugin/table';

package/blazorGlobalSrc/markdown-parser/plugin.js

@@ -0,0 +1,15 @@
+define(["require", "exports", "./plugin/clearformat", "./plugin/lists", "./plugin/formats", "./plugin/markdown-selection", "./plugin/undo", "./plugin/md-selection-formats", "./plugin/link", "./plugin/table"], function (require, exports, clearformat_1, lists_1, formats_1, markdown_selection_1, undo_1, md_selection_formats_1, link_1, table_1) {
+    "use strict";
+    function __export(m) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __export(clearformat_1);
+    __export(lists_1);
+    __export(formats_1);
+    __export(markdown_selection_1);
+    __export(undo_1);
+    __export(md_selection_formats_1);
+    __export(link_1);
+    __export(table_1);
+});

package/blazorGlobalSrc/rich-text-editor/actions/base-quick-toolbar.d.ts

@@ -0,0 +1,114 @@
+import { Popup } from '@syncfusion/ej2-popups';
+import { IRichTextEditor, IBaseQuickToolbar } from '../base/interface';
+import { IToolbarItems, IQuickToolbarOptions } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { BaseToolbar } from './base-toolbar';
+import { RichTextEditorModel } from '../base/rich-text-editor-model';
+/**
+ * `Quick toolbar` module is used to handle Quick toolbar actions.
+ */
+export declare class BaseQuickToolbar implements IBaseQuickToolbar {
+    isDestroyed: boolean;
+    popupObj: Popup;
+    element: HTMLElement;
+    isRendered: boolean;
+    quickTBarObj: BaseToolbar;
+    private stringItems;
+    private dropDownButtons;
+    private colorPickerObj;
+    private locator;
+    private parent;
+    private contentRenderer;
+    private popupRenderer;
+    toolbarElement: HTMLElement;
+    private renderFactory;
+    private tooltip;
+    constructor(parent?: IRichTextEditor, locator?: ServiceLocator);
+    private appendPopupContent;
+    /**
+     * render method
+     *
+     * @param {IQuickToolbarOptions} args - specifies the arguments
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    render(args: IQuickToolbarOptions): void;
+    private createToolbar;
+    private setPosition;
+    private checkCollision;
+    /**
+     * showPopup method
+     *
+     * @param {number} x - specifies the x value
+     * @param {number} y - specifies the y value
+     * @param {Element} target - specifies the element
+     * @param {string} type - specifies the type
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    showPopup(x: number, y: number, target: Element, type?: string): void;
+    private tooltipBeforeRender;
+    /**
+     * hidePopup method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    hidePopup(): void;
+    /**
+     * @param {string} item - specifies the string value
+     * @param {number} index - specifies the index value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    addQTBarItem(item: (string | IToolbarItems)[], index: number): void;
+    /**
+     * @param {number} index - specifies the index value
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    removeQTBarItem(index: number | HTMLElement[] | Element[]): void;
+    private removeEleFromDOM;
+    private updateStatus;
+    /**
+     * Destroys the Quick toolbar.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    /**
+     * addEventListener method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    addEventListener(): void;
+    /**
+     * Called internally if any of the property value changed.
+     *
+     * @param {RichTextEditorModel} e - specifies the model element
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    protected onPropertyChanged(e: {
+        [key: string]: RichTextEditorModel;
+    }): void;
+    /**
+     * removeEventListener method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    removeEventListener(): void;
+}