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

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

@@ -0,0 +1,14 @@
+import { IRichTextEditor } from '../base/interface';
+import { IToolbarStatus } from '../../common/interface';
+/**
+ * HtmlToolbarStatus module for refresh the toolbar status
+ */
+export declare class HtmlToolbarStatus {
+    parent: IRichTextEditor;
+    toolbarStatus: IToolbarStatus;
+    private prevToolbarStatus;
+    constructor(parent: IRichTextEditor);
+    private addEventListener;
+    private removeEventListener;
+    private onRefreshHandler;
+}

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

@@ -0,0 +1,47 @@
+define(["require", "exports", "../base/constant", "../../editor-manager/plugin/toolbar-status", "../../common/util"], function (require, exports, events, toolbar_status_1, util_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var HtmlToolbarStatus = (function () {
+        function HtmlToolbarStatus(parent) {
+            this.parent = parent;
+            this.toolbarStatus = this.prevToolbarStatus = util_1.getDefaultHtmlTbStatus();
+            this.addEventListener();
+        }
+        HtmlToolbarStatus.prototype.addEventListener = function () {
+            this.parent.on(events.toolbarRefresh, this.onRefreshHandler, this);
+            this.parent.on(events.destroy, this.removeEventListener, this);
+        };
+        HtmlToolbarStatus.prototype.removeEventListener = function () {
+            this.toolbarStatus = null;
+            this.prevToolbarStatus = null;
+            this.parent.off(events.toolbarRefresh, this.onRefreshHandler);
+            this.parent.off(events.destroy, this.removeEventListener);
+        };
+        HtmlToolbarStatus.prototype.onRefreshHandler = function (args) {
+            if (this.parent.readonly) {
+                return;
+            }
+            var fontsize = [];
+            var fontName = [];
+            var formats = [];
+            this.parent.fontSize.items.forEach(function (item) {
+                fontsize.push(item.value);
+            });
+            this.parent.fontFamily.items.forEach(function (item) {
+                fontName.push(item.value);
+            });
+            this.parent.format.types.forEach(function (item) {
+                formats.push(item.value.toLocaleLowerCase());
+            });
+            this.toolbarStatus = toolbar_status_1.ToolbarStatus.get(this.parent.contentModule.getDocument(), this.parent.contentModule.getEditPanel(), formats, fontsize, fontName, args.documentNode);
+            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: JSON.parse(tbStatusString), markdown: null });
+                this.prevToolbarStatus = JSON.parse(tbStatusString);
+            }
+        };
+        return HtmlToolbarStatus;
+    }());
+    exports.HtmlToolbarStatus = HtmlToolbarStatus;
+});

package/blazorGlobalSrc/rich-text-editor/actions/import-export.d.ts

@@ -0,0 +1,21 @@
+import { IRichTextEditor } from '../base/interface';
+/**
+ * ImportExport module called when import and export content in RichTextEditor
+ */
+export declare class ImportExport {
+    private rteID;
+    private parent;
+    private uploaderObj;
+    constructor(parent?: IRichTextEditor);
+    private addEventListener;
+    private onImport;
+    private onExport;
+    private destroy;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    private getModuleName;
+}

package/blazorGlobalSrc/rich-text-editor/actions/import-export.js

@@ -0,0 +1,117 @@
+define(["require", "exports", "../base/constant", "@syncfusion/ej2-inputs"], function (require, exports, events, ej2_inputs_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ImportExport = (function () {
+        function ImportExport(parent) {
+            this.parent = parent;
+            this.addEventListener();
+        }
+        ImportExport.prototype.addEventListener = function () {
+            this.parent.on(events.onImport, this.onImport, this);
+            this.parent.on(events.onExport, this.onExport, this);
+            this.parent.on(events.destroy, this.destroy, this);
+        };
+        ImportExport.prototype.onImport = function () {
+            var _this = this;
+            var actionBegin = {
+                cancel: false,
+                requestType: 'Import'
+            };
+            this.parent.trigger(events.actionBegin, actionBegin, function (actionBeginArgs) {
+                if (!actionBeginArgs.cancel) {
+                    _this.uploaderObj = new ej2_inputs_1.Uploader({
+                        allowedExtensions: '.doc,.docx,.rtf,.dot,.dotx,.docm,.dotm',
+                        asyncSettings: {
+                            saveUrl: _this.parent.importWord.serviceUrl
+                        },
+                        success: function (args) {
+                            _this.parent.executeCommand('importWord', args.e.currentTarget.response, { undo: true });
+                            _this.parent.trigger(events.actionComplete, { requestType: 'Import' });
+                        }
+                    });
+                    _this.parent.setProperties({ enableXhtml: true }, true);
+                    var uploadParentEle = _this.parent.createElement('div', { className: 'e-import-uploadwrap e-droparea' + _this.parent.getCssClass(true) });
+                    var uploadEle = _this.parent.createElement('input', {
+                        id: _this.rteID + '_upload', attrs: { type: 'File', name: 'UploadFiles' }, className: _this.parent.getCssClass()
+                    });
+                    uploadParentEle.appendChild(uploadEle);
+                    _this.uploaderObj.appendTo(uploadEle);
+                    _this.uploaderObj.element.click();
+                    _this.uploaderObj.element.closest('.e-upload').style.display = 'none';
+                }
+            });
+        };
+        ImportExport.prototype.onExport = function (args) {
+            var _this = this;
+            var filename;
+            var serviceUrl;
+            this.parent.setProperties({ enableXhtml: true }, true);
+            var rteHtmlData = this.parent.getHtml();
+            var html;
+            if (args.member === 'ExportWord') {
+                filename = this.parent.exportWord.fileName;
+                serviceUrl = this.parent.exportWord.serviceUrl;
+                html = "<html><head><style>" + this.parent.exportWord.stylesheet + "</style></head><body>" + rteHtmlData + "</body></html>";
+            }
+            else if (args.member === 'ExportPdf') {
+                filename = this.parent.exportPdf.fileName;
+                serviceUrl = this.parent.exportPdf.serviceUrl;
+                html = "<html><head><style>" + this.parent.exportPdf.stylesheet + "</style></head><body>" + rteHtmlData + "</body></html>";
+            }
+            var actionBegin = {
+                requestType: args.member,
+                exportValue: html,
+                cancel: false
+            };
+            this.parent.trigger(events.actionBegin, actionBegin, function (actionBeginArgs) {
+                if (!actionBeginArgs.cancel) {
+                    fetch(serviceUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ html: actionBeginArgs.exportValue })
+                    })
+                        .then(function (response) {
+                        if (!response.ok) {
+                            throw new Error("HTTP error! Status: " + response.status);
+                        }
+                        return response.blob().then(function (blob) { return ({ blob: blob, filename: filename }); });
+                    })
+                        .then(function (_a) {
+                        var blob = _a.blob, filename = _a.filename;
+                        var url = window.URL.createObjectURL(blob);
+                        var a = document.createElement('a');
+                        a.href = url;
+                        a.download = filename;
+                        document.body.appendChild(a);
+                        a.click();
+                        document.body.removeChild(a);
+                        window.URL.revokeObjectURL(url);
+                        _this.parent.trigger(events.actionComplete, { requestType: args.member });
+                    })
+                        .catch(function (error) {
+                        console.error('Fetch error:', error);
+                    });
+                }
+            });
+        };
+        ImportExport.prototype.destroy = function () {
+            if (this.parent.isDestroyed) {
+                return;
+            }
+            this.parent.off(events.onImport, this.onImport);
+            this.parent.off(events.onExport, this.onExport);
+            this.parent.off(events.destroy, this.destroy);
+            if (this.uploaderObj && !this.uploaderObj.isDestroyed) {
+                this.uploaderObj.destroy();
+                this.uploaderObj = null;
+            }
+        };
+        ImportExport.prototype.getModuleName = function () {
+            return 'importExport';
+        };
+        return ImportExport;
+    }());
+    exports.ImportExport = ImportExport;
+});

package/blazorGlobalSrc/rich-text-editor/actions/keyboard-model.d.ts

@@ -0,0 +1,30 @@
+import { Property, NotifyPropertyChanges, INotifyPropertyChanged, Event } from '@syncfusion/ej2-base';
+import {KeyboardEventArgs} from "./keyboard";
+
+/**
+ * Interface for a class KeyboardEvents
+ */
+export interface KeyboardEventsModel {
+
+    /**
+     * Specifies key combination and it respective action name.
+     *
+     * @default null
+     */
+    keyConfigs?: { [key: string]: string };
+
+    /**
+     * Specifies on which event keyboardEvents class should listen for key press. For ex., `keyup`, `keydown` or `keypress`
+     *
+     * @default 'keyup'
+     */
+    eventName?: string;
+
+    /**
+     * Specifies the listener when keyboard actions is performed.
+     *
+     * @event 'keyAction'
+     */
+    keyAction?: EmitType<KeyboardEventArgs>;
+
+}

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

@@ -0,0 +1,110 @@
+import { INotifyPropertyChanged } from '@syncfusion/ej2-base';
+import { Base, EmitType } from '@syncfusion/ej2-base';
+import { KeyboardEventsModel } from '@syncfusion/ej2-base';
+/**
+ * KeyboardEvents
+ */
+export interface KeyboardEventArgs extends KeyboardEvent {
+    /**
+     * action of the KeyboardEvent
+     */
+    action: string;
+}
+/**
+ * KeyboardEvents class enables you to bind key action desired key combinations for ex., Ctrl+A, Delete, Alt+Space etc.
+ * ```html
+ * <div id='testEle'>  </div>;
+ * <script>
+ *   let node: HTMLElement = document.querySelector('#testEle');
+ *   let kbInstance = new KeyboardEvents({
+ *       element: node,
+ *       keyConfigs:{ selectAll : 'ctrl+a' },
+ *       keyAction: function (e:KeyboardEvent, action:string) {
+ *           // handler function code
+ *       }
+ *   });
+ * </script>
+ * ```
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class KeyboardEvents extends Base<HTMLElement> implements INotifyPropertyChanged {
+    /**
+     * Specifies key combination and it respective action name.
+     *
+     * @default null
+     */
+    keyConfigs: {
+        [key: string]: string;
+    };
+    /**
+     * Specifies on which event keyboardEvents class should listen for key press. For ex., `keyup`, `keydown` or `keypress`
+     *
+     * @default 'keyup'
+     */
+    eventName: string;
+    /**
+     * Specifies the listener when keyboard actions is performed.
+     *
+     * @event 'keyAction'
+     */
+    keyAction: EmitType<KeyboardEventArgs>;
+    /**
+     * Initializes the KeyboardEvents
+     *
+     * @param {HTMLElement} element - specifies the elements.
+     * @param {KeyboardEventsModel} options - specify the options
+     */
+    constructor(element: HTMLElement, options?: KeyboardEventsModel);
+    /**
+     * Unwire bound events and destroy the instance.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Function can be used to specify certain action if a property is changed
+     *
+     * @param {KeyboardEventsModel} newProp - specifies the keyboard event.
+     * @param {KeyboardEventsModel} oldProp - specifies the old property.
+     * @returns {void}
+     * @private
+     */
+    onPropertyChanged(newProp: KeyboardEventsModel, oldProp?: KeyboardEventsModel): void;
+    protected bind(): void;
+    /**
+     * To get the module name, returns 'keyboard'.
+     *
+     * @returns {void}
+     */
+    getModuleName(): string;
+    /**
+     * Wiring event handlers to events
+     *
+     * @returns {void}
+     */
+    private wireEvents;
+    /**
+     * Unwiring event handlers to events
+     *
+     * @returns {void}
+     */
+    private unwireEvents;
+    /**
+     * To handle a key press event returns null
+     *
+     * @param {KeyboardEventArgs} e - specifies the event arguments.
+     * @returns {void}
+     */
+    private keyPressHandler;
+    private static configCache;
+    /**
+     * To get the key configuration data
+     *
+     * @param {string} config - configuration data
+     * @returns {KeyData} - specifies the key data
+     */
+    private static getKeyConfigData;
+    private static getKeyCode;
+}

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

@@ -0,0 +1,163 @@
+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 __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+define(["require", "exports", "@syncfusion/ej2-base", "@syncfusion/ej2-base"], function (require, exports, ej2_base_1, ej2_base_2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var keyCode = {
+        'backspace': 8,
+        'tab': 9,
+        'enter': 13,
+        'shift': 16,
+        'control': 17,
+        'alt': 18,
+        'pause': 19,
+        'capslock': 20,
+        'space': 32,
+        'escape': 27,
+        'pageup': 33,
+        'pagedown': 34,
+        'end': 35,
+        'home': 36,
+        'leftarrow': 37,
+        'uparrow': 38,
+        'rightarrow': 39,
+        'downarrow': 40,
+        'insert': 45,
+        'delete': 46,
+        'f1': 112,
+        'f2': 113,
+        'f3': 114,
+        'f4': 115,
+        'f5': 116,
+        'f6': 117,
+        'f7': 118,
+        'f8': 119,
+        'f9': 120,
+        'f10': 121,
+        'f11': 122,
+        'f12': 123,
+        'semicolon': 186,
+        'plus': 187,
+        'comma': 188,
+        'minus': 189,
+        'dot': 190,
+        'forwardslash': 191,
+        'graveaccent': 192,
+        'openbracket': 219,
+        'backslash': 220,
+        'closebracket': 221,
+        'singlequote': 222,
+        ']': 221,
+        '[': 219,
+        '=': 187,
+        '<': 188,
+        '>': 190,
+        '`': 192
+    };
+    var KeyboardEvents = (function (_super) {
+        __extends(KeyboardEvents, _super);
+        function KeyboardEvents(element, options) {
+            var _this = _super.call(this, options, element) || this;
+            _this.keyPressHandler = function (e) {
+                var isAltKey = e.altKey;
+                var isCtrlKey = e.ctrlKey;
+                var isShiftKey = e.shiftKey;
+                var isMetaKey = e.metaKey;
+                var curkeyCode = e.which;
+                var keys = Object.keys(_this.keyConfigs);
+                for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+                    var key = keys_1[_i];
+                    var configCollection = _this.keyConfigs["" + key].split(',');
+                    for (var _a = 0, configCollection_1 = configCollection; _a < configCollection_1.length; _a++) {
+                        var rconfig = configCollection_1[_a];
+                        var rKeyObj = KeyboardEvents_1.getKeyConfigData(rconfig.trim());
+                        if (isAltKey === rKeyObj.altKey && (isCtrlKey === rKeyObj.ctrlKey || isMetaKey) &&
+                            isShiftKey === rKeyObj.shiftKey && curkeyCode === rKeyObj.keyCode) {
+                            e.action = key;
+                        }
+                    }
+                }
+                if (_this.keyAction) {
+                    _this.keyAction(e);
+                }
+            };
+            _this.bind();
+            return _this;
+        }
+        KeyboardEvents_1 = KeyboardEvents;
+        KeyboardEvents.prototype.destroy = function () {
+            this.unwireEvents();
+            _super.prototype.destroy.call(this);
+        };
+        KeyboardEvents.prototype.onPropertyChanged = function (newProp, oldProp) {
+        };
+        KeyboardEvents.prototype.bind = function () {
+            this.wireEvents();
+        };
+        KeyboardEvents.prototype.getModuleName = function () {
+            return 'keyboard';
+        };
+        KeyboardEvents.prototype.wireEvents = function () {
+            this.element.addEventListener(this.eventName, this.keyPressHandler);
+        };
+        KeyboardEvents.prototype.unwireEvents = function () {
+            this.element.removeEventListener(this.eventName, this.keyPressHandler);
+        };
+        KeyboardEvents.getKeyConfigData = function (config) {
+            if (config in this.configCache) {
+                return this.configCache["" + config];
+            }
+            var keys = config.toLowerCase().split('+');
+            var keyData = {
+                altKey: (keys.indexOf('alt') !== -1 ? true : false),
+                ctrlKey: (keys.indexOf('ctrl') !== -1 ? true : false),
+                shiftKey: (keys.indexOf('shift') !== -1 ? true : false),
+                keyCode: null
+            };
+            if (keys[keys.length - 1].length > 1 && !!Number(keys[keys.length - 1])) {
+                keyData.keyCode = Number(keys[keys.length - 1]);
+            }
+            else {
+                keyData.keyCode = KeyboardEvents_1.getKeyCode(keys[keys.length - 1]);
+            }
+            KeyboardEvents_1.configCache["" + config] = keyData;
+            return keyData;
+        };
+        KeyboardEvents.getKeyCode = function (keyVal) {
+            return keyCode["" + keyVal] || keyVal.toUpperCase().charCodeAt(0);
+        };
+        var KeyboardEvents_1;
+        KeyboardEvents.configCache = {};
+        __decorate([
+            ej2_base_1.Property({})
+        ], KeyboardEvents.prototype, "keyConfigs", void 0);
+        __decorate([
+            ej2_base_1.Property('keyup')
+        ], KeyboardEvents.prototype, "eventName", void 0);
+        __decorate([
+            ej2_base_1.Event()
+        ], KeyboardEvents.prototype, "keyAction", void 0);
+        KeyboardEvents = KeyboardEvents_1 = __decorate([
+            ej2_base_1.NotifyPropertyChanges
+        ], KeyboardEvents);
+        return KeyboardEvents;
+    }(ej2_base_2.Base));
+    exports.KeyboardEvents = KeyboardEvents;
+});

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

@@ -0,0 +1,66 @@
+import { IRichTextEditor } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { RichTextEditorModel } from '../base/rich-text-editor-model';
+/**
+ * `MarkdownEditor` module is used to markdown editor
+ */
+export declare class MarkdownEditor {
+    private parent;
+    private locator;
+    private contentRenderer;
+    private renderFactory;
+    private toolbarUpdate;
+    private saveSelection;
+    private mdSelection;
+    private isDestroyed;
+    constructor(parent?: IRichTextEditor, serviceLocator?: ServiceLocator);
+    /**
+     * Destroys the Markdown.
+     *
+     * @function destroy
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    destroy(): void;
+    private addEventListener;
+    private updateReadOnly;
+    private onSelectionSave;
+    private onSelectionRestore;
+    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 {void}
+     */
+    private getModuleName;
+    /**
+     * For selecting all content in RTE
+     *
+     * @returns {void}
+     * @private
+     */
+    private selectAll;
+    /**
+     * For get a selected text in RTE
+     *
+     * @param {NotifyArgs} e - specifies the arguments.
+     * @returns {void}
+     * @private
+     */
+    private getSelectedHtml;
+}