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

package/blazorGlobalSrc/rich-text-editor/formatter/formatter.d.ts

@@ -0,0 +1,87 @@
+import { ActionBeginEventArgs } from './../base/interface';
+import { IRichTextEditor, IEditorModel, IItemCollectionArgs } from './../base/interface';
+import { IHtmlFormatterCallBack, IMarkdownFormatterCallBack, IUndoCallBack } from './../../common/interface';
+import { MarkdownUndoRedoData } from '../../markdown-parser/base/interface';
+import { IHtmlUndoRedoData } from '../../editor-manager/base/interface';
+/**
+ * Formatter
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class Formatter {
+    editorManager: IEditorModel;
+    private timeInterval;
+    /**
+     * To execute the command
+     *
+     * @param  {IRichTextEditor} self - specifies the self element.
+     * @param  {ActionBeginEventArgs} args - specifies the event arguments.
+     * @param  {MouseEvent|KeyboardEvent} event - specifies the keyboard event.
+     * @param  {IItemCollectionArgs} value - specifies the collection arguments
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    process(self: IRichTextEditor, args: ActionBeginEventArgs, event: MouseEvent | KeyboardEvent, value: IItemCollectionArgs): void;
+    private getAncestorNode;
+    /**
+     * onKeyHandler method
+     *
+     * @param {IRichTextEditor} self - specifies the self element.
+     * @param {KeyboardEvent} e - specifies the keyboard event.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    onKeyHandler(self: IRichTextEditor, e: KeyboardEvent): void;
+    /**
+     * onSuccess method
+     *
+     * @param {IRichTextEditor} self - specifies the self element.
+     * @param {IMarkdownFormatterCallBack} events - specifies the event call back
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    onSuccess(self: IRichTextEditor, events: IMarkdownFormatterCallBack | IHtmlFormatterCallBack): void;
+    /**
+     * Save the data for undo and redo action.
+     *
+     * @param {KeyboardEvent} e - specifies the keyboard event.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    saveData(e?: KeyboardEvent | MouseEvent | IUndoCallBack): void;
+    /**
+     * getUndoStatus method
+     *
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getUndoStatus(): {
+        [key: string]: boolean;
+    };
+    /**
+     * getUndoRedoStack method
+     *
+     * @param {IHtmlUndoRedoData}  - specifies the redo data.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    getUndoRedoStack(): IHtmlUndoRedoData[] | MarkdownUndoRedoData[];
+    /**
+     * enableUndo method
+     *
+     * @param {IRichTextEditor} self - specifies the self element.
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    enableUndo(self: IRichTextEditor): void;
+    beforeSlashMenuApply(): void;
+    getCurrentStackIndex(): undefined | number;
+}

package/blazorGlobalSrc/rich-text-editor/formatter/formatter.js

@@ -0,0 +1,223 @@
+define(["require", "exports", "@syncfusion/ej2-base", "../base/constant", "../base/util", "./../../common/constant"], function (require, exports, ej2_base_1, CONSTANT, util_1, constant_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Formatter = (function () {
+        function Formatter() {
+        }
+        Formatter.prototype.process = function (self, args, event, value) {
+            var _this = this;
+            var selection = self.contentModule.getDocument().getSelection();
+            var range = (selection.rangeCount > 0) ? selection.getRangeAt(selection.rangeCount - 1) : null;
+            var saveSelection;
+            var newRange;
+            if (!ej2_base_1.isNullOrUndefined(value) && !ej2_base_1.isNullOrUndefined(value.selection)) {
+                newRange = value.selection.range;
+            }
+            var isKeyboardVideoInsert = (!ej2_base_1.isNullOrUndefined(value) && !ej2_base_1.isNullOrUndefined(value.cssClass) &&
+                value.cssClass !== 'e-video-inline');
+            if (self.editorMode === 'HTML') {
+                if (!ej2_base_1.isNullOrUndefined(args) && !isKeyboardVideoInsert) {
+                    if (ej2_base_1.isNullOrUndefined(args.name) || (!ej2_base_1.isNullOrUndefined(args.name) && args.name !== 'showDialog') && !ej2_base_1.isNullOrUndefined(args.item.command)) {
+                        if (newRange) {
+                            saveSelection = this.editorManager.nodeSelection.save(newRange, self.contentModule.getDocument());
+                        }
+                        else {
+                            saveSelection = this.editorManager.nodeSelection.save(range, self.contentModule.getDocument());
+                        }
+                    }
+                }
+            }
+            if (!ej2_base_1.isNullOrUndefined(args)
+                && args.item.command
+                && args.item.command !== 'Table'
+                && args.item.command !== 'Actions'
+                && args.item.command !== 'Links'
+                && args.item.command !== 'Images'
+                && args.item.command !== 'Files'
+                && args.item.command !== 'Audios'
+                && args.item.command !== 'Videos'
+                && args.item.command !== 'EmojiPicker'
+                && range
+                && !(self.contentModule.getEditPanel().contains(this.getAncestorNode(range.commonAncestorContainer))
+                    || self.contentModule.getEditPanel() === range.commonAncestorContainer
+                    || self.contentModule.getPanel() === range.commonAncestorContainer)) {
+                return;
+            }
+            if (!ej2_base_1.isNullOrUndefined(args) && self.maxLength !== -1 && !ej2_base_1.isNullOrUndefined(args.item.command)) {
+                var currentInsertContentLength = 0;
+                if (args.item.command === 'Links') {
+                    currentInsertContentLength = value.text.length === 0 ? value.url.length : value.text.length;
+                }
+                if (args.item.command === 'Images' || args.item.command === 'Videos' || args.item.command === 'Table' || args.item.command === 'Files') {
+                    currentInsertContentLength = 1;
+                }
+                var currentLength = self.getText().trim().replace(/(\r\n|\n|\r|\t)/gm, '').replace(/\u200B/g, '').length;
+                var selectionLength = self.getSelection().length;
+                var totalLength = (currentLength - selectionLength) + currentInsertContentLength;
+                if (!(self.maxLength === -1 || totalLength <= self.maxLength)) {
+                    return;
+                }
+            }
+            if (ej2_base_1.isNullOrUndefined(args)) {
+                var action_1 = event.action;
+                args = {};
+                var items = {
+                    originalEvent: event, cancel: false,
+                    requestType: action_1 || (event.key + 'Key'),
+                    itemCollection: value
+                };
+                ej2_base_1.extend(args, args, items, true);
+                if (action_1 !== 'tab' && action_1 !== 'enter' && action_1 !== 'space' && action_1 !== 'escape') {
+                    if (self.editorMode === 'Markdown' && action_1 === 'insert-table') {
+                        value = {
+                            'headingText': self.localeObj.getConstant('TableHeadingText'),
+                            'colText': self.localeObj.getConstant('TableColText')
+                        };
+                    }
+                    self.trigger(CONSTANT.actionBegin, args, function (actionBeginArgs) {
+                        if (actionBeginArgs.cancel) {
+                            if (action_1 === 'paste' || action_1 === 'cut' || action_1 === 'copy') {
+                                event.preventDefault();
+                            }
+                        }
+                    });
+                }
+                if (!args.cancel) {
+                    var isTableModule = ej2_base_1.isNullOrUndefined(self.tableModule) ? true : self.tableModule ?
+                        self.tableModule.ensureInsideTableList : false;
+                    if ((event.which === 9 && isTableModule) || event.which !== 9) {
+                        if (event.which === 13 && self.editorMode === 'HTML') {
+                            value = {
+                                'enterAction': self.enterKey
+                            };
+                        }
+                        this.editorManager.observer.notify((event.type === 'keydown' ? constant_1.KEY_DOWN : constant_1.KEY_UP), {
+                            event: event,
+                            callBack: this.onSuccess.bind(this, self),
+                            value: value,
+                            enterAction: self.enterKey,
+                            enableTabKey: self.enableTabKey
+                        });
+                    }
+                }
+            }
+            else if (!ej2_base_1.isNullOrUndefined(args) && args.item.command && args.item.subCommand && ((args.item.command !== args.item.subCommand
+                && args.item.command !== 'Font' && args.item.command !== 'Export')
+                || ((args.item.subCommand === 'FontName' || args.item.subCommand === 'FontSize') && args.name === 'dropDownSelect')
+                || ((args.item.subCommand === 'BackgroundColor' || args.item.subCommand === 'FontColor')
+                    && (args.name === 'colorPickerChanged' || args.name === 'tableColorPickerChanged')) || args.item.subCommand === 'FormatPainter' || args.item.subCommand === 'EmojiPicker')) {
+                ej2_base_1.extend(args, args, { requestType: args.item.subCommand, cancel: false, itemCollection: value, selectType: args.name }, true);
+                self.trigger(CONSTANT.actionBegin, args, function (actionBeginArgs) {
+                    if (!actionBeginArgs.cancel) {
+                        var formatPainterCopy = !ej2_base_1.isNullOrUndefined(actionBeginArgs.requestType) && actionBeginArgs.requestType === 'FormatPainter' && actionBeginArgs.name === 'format-copy';
+                        var formatPainterPaste = !ej2_base_1.isNullOrUndefined(actionBeginArgs.requestType) && actionBeginArgs.requestType === 'FormatPainter' && actionBeginArgs.name === 'format-paste';
+                        if ((_this.getUndoRedoStack().length === 0 && actionBeginArgs.item.command !== 'Links' && actionBeginArgs.item.command !== 'Images' && !formatPainterCopy)
+                            || formatPainterPaste) {
+                            _this.saveData();
+                        }
+                        self.isBlur = false;
+                        var quickToolbarAction = !ej2_base_1.isNullOrUndefined(event) && !ej2_base_1.isNullOrUndefined(event.target) && (!ej2_base_1.isNullOrUndefined(ej2_base_1.closest(event.target, '.e-rte-elements.e-dropdown-popup.e-rte-dropdown-popup.e-quick-dropdown.e-popup-open')) || !ej2_base_1.isNullOrUndefined(ej2_base_1.closest(event.target, '.e-rte-elements.e-rte-quick-popup.e-popup-open')));
+                        if (ej2_base_1.isNullOrUndefined(saveSelection) || (!quickToolbarAction && (ej2_base_1.isNullOrUndefined(ej2_base_1.closest(saveSelection.range.startContainer.parentElement, '.e-img-caption')) ? true : !(ej2_base_1.closest(saveSelection.range.startContainer.parentElement, '.e-img-caption').getAttribute('contenteditable') === 'false'))) && !(ej2_base_1.Browser.userAgent.indexOf('Firefox') !== -1)) {
+                            self.contentModule.getEditPanel().focus({ preventScroll: true });
+                        }
+                        if (self.editorMode === 'HTML' && !isKeyboardVideoInsert) {
+                            if (ej2_base_1.isNullOrUndefined(args.selectType) || (!ej2_base_1.isNullOrUndefined(args.selectType) && args.selectType !== 'showDialog')) {
+                                saveSelection.restore();
+                            }
+                        }
+                        var command = actionBeginArgs.item.subCommand.toLocaleLowerCase();
+                        if (command === 'image' || command === 'file' || command === 'replace') {
+                            value = actionBeginArgs.itemCollection;
+                        }
+                        if (command === 'paste' || command === 'cut' || command === 'copy') {
+                            self.clipboardAction(command, event);
+                        }
+                        else {
+                            _this.editorManager.observer.notify(CONSTANT.checkUndo, { subCommand: actionBeginArgs.item.subCommand });
+                            _this.editorManager.execCommand(actionBeginArgs.item.command, actionBeginArgs.item.subCommand, event, _this.onSuccess.bind(_this, self), actionBeginArgs.item.value, actionBeginArgs.item.subCommand === 'Pre' && actionBeginArgs.selectType === 'dropDownSelect' ?
+                                { name: actionBeginArgs.selectType } : value, ('#' + self.getID() + ' iframe'), self.enterKey);
+                        }
+                    }
+                });
+            }
+            if ((ej2_base_1.isNullOrUndefined(event) || event && event.action !== 'copy') &&
+                !(event && event.shiftKey && event.key === 'Tab')) {
+                this.enableUndo(self);
+            }
+        };
+        Formatter.prototype.getAncestorNode = function (node) {
+            node = node.nodeType === 3 ? node.parentNode : node;
+            return node;
+        };
+        Formatter.prototype.onKeyHandler = function (self, e) {
+            var _this = this;
+            this.editorManager.observer.notify(constant_1.KEY_UP, {
+                event: e, callBack: function () {
+                    self.notify(CONSTANT.contentChanged, {});
+                    _this.enableUndo(self);
+                },
+                enterAction: self.enterKey
+            });
+        };
+        Formatter.prototype.onSuccess = function (self, events) {
+            self.notify(CONSTANT.contentChanged, {});
+            if (events && (ej2_base_1.isNullOrUndefined(events.event) || events.event.action !== 'copy')) {
+                if (events.requestType === 'Paste') {
+                    self.notify(CONSTANT.execCommandCallBack, events);
+                    this.enableUndo(self);
+                }
+                else {
+                    this.enableUndo(self);
+                    self.notify(CONSTANT.execCommandCallBack, events);
+                }
+            }
+            self.trigger(CONSTANT.actionComplete, events, function (callbackArgs) {
+                self.setPlaceHolder();
+                if ((callbackArgs.requestType === 'Images' || callbackArgs.requestType === 'Replace' || callbackArgs.requestType === 'Links' || callbackArgs.requestType === 'Audios' || callbackArgs.requestType === 'Videos') && self.editorMode === 'HTML') {
+                    var args = callbackArgs;
+                    if (callbackArgs.requestType === 'Links' && callbackArgs.event &&
+                        callbackArgs.event.type === 'keydown' &&
+                        callbackArgs.event.keyCode === 32) {
+                        return;
+                    }
+                    self.notify(CONSTANT.insertCompleted, {
+                        args: args.event, type: callbackArgs.requestType, isNotify: true,
+                        elements: args.elements
+                    });
+                }
+                if (callbackArgs.requestType === 'VideosPlayPause') {
+                    self.notify('editAreaClick', { args: event });
+                }
+                self.autoResize();
+            });
+        };
+        Formatter.prototype.saveData = function (e) {
+            this.editorManager.undoRedoManager.saveData(e);
+        };
+        Formatter.prototype.getUndoStatus = function () {
+            return this.editorManager.undoRedoManager.getUndoStatus();
+        };
+        Formatter.prototype.getUndoRedoStack = function () {
+            return this.editorManager.undoRedoManager.undoRedoStack;
+        };
+        Formatter.prototype.enableUndo = function (self) {
+            var status = this.getUndoStatus();
+            if (self.inlineMode.enable && (!ej2_base_1.Browser.isDevice || util_1.isIDevice())) {
+                util_1.updateUndoRedoStatus(self.quickToolbarModule.inlineQTBar.quickTBarObj, status);
+            }
+            else {
+                if (self.toolbarModule && self.toolbarModule.baseToolbar) {
+                    util_1.updateUndoRedoStatus(self.toolbarModule.baseToolbar, status);
+                }
+            }
+        };
+        Formatter.prototype.beforeSlashMenuApply = function () {
+            this.editorManager.beforeSlashMenuApplyFormat();
+        };
+        Formatter.prototype.getCurrentStackIndex = function () {
+            return this.editorManager.undoRedoManager.getCurrentStackIndex();
+        };
+        return Formatter;
+    }());
+    exports.Formatter = Formatter;
+});

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

@@ -0,0 +1,34 @@
+import { Formatter } from './formatter';
+import { IEditorModel, IHtmlFormatterModel } from './../base/interface';
+import { FormatPainterSettingsModel } from '../models';
+/**
+ * HTML adapter
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class HTMLFormatter extends Formatter {
+    keyConfig: {
+        [key: string]: string;
+    };
+    currentDocument: Document;
+    element: Element;
+    editorManager: IEditorModel;
+    private toolbarUpdate;
+    constructor(options?: IHtmlFormatterModel);
+    private initialize;
+    /**
+     * Update the formatter of RichTextEditor
+     *
+     * @param {Element} editElement - specifies the edit element.
+     * @param {Document} doc - specifies the doucment
+     * @param {number} options - specifies the options
+     * @param {FormatPainterSettingsModel} formatPainterSettings - specifies the format painter settings
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    updateFormatter(editElement: Element, doc?: Document, options?: {
+        [key: string]: number;
+    }, formatPainterSettings?: FormatPainterSettingsModel): void;
+}

package/blazorGlobalSrc/rich-text-editor/formatter/html-formatter.js

@@ -0,0 +1,44 @@
+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", "./formatter", "./../../editor-manager/base/editor-manager", "@syncfusion/ej2-base", "./../../common/config"], function (require, exports, formatter_1, editor_manager_1, ej2_base_1, config_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var HTMLFormatter = (function (_super) {
+        __extends(HTMLFormatter, _super);
+        function HTMLFormatter(options) {
+            var _this = _super.call(this) || this;
+            _this.initialize();
+            ej2_base_1.extend(_this, _this, options, true);
+            if (_this.currentDocument && _this.element) {
+                _this.updateFormatter(_this.element, _this.currentDocument, options.options, options.formatPainterSettings);
+            }
+            return _this;
+        }
+        HTMLFormatter.prototype.initialize = function () {
+            this.keyConfig = config_1.htmlKeyConfig;
+        };
+        HTMLFormatter.prototype.updateFormatter = function (editElement, doc, options, formatPainterSettings) {
+            if (editElement && doc) {
+                this.editorManager = new editor_manager_1.EditorManager({
+                    document: doc,
+                    editableElement: editElement,
+                    options: options,
+                    formatPainterSettings: formatPainterSettings
+                });
+            }
+        };
+        return HTMLFormatter;
+    }(formatter_1.Formatter));
+    exports.HTMLFormatter = HTMLFormatter;
+});

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

@@ -0,0 +1,39 @@
+import { Formatter } from './formatter';
+import { IEditorModel, IMarkdownFormatterModel } from './../base/interface';
+/**
+ * Markdown adapter
+ *
+ * @hidden
+ * @deprecated
+ */
+export declare class MarkdownFormatter extends Formatter {
+    keyConfig: {
+        [key: string]: string;
+    };
+    formatTags: {
+        [key: string]: string;
+    };
+    listTags: {
+        [key: string]: string;
+    };
+    selectionTags: {
+        [key: string]: string;
+    };
+    editorManager: IEditorModel;
+    private element;
+    constructor(options?: IMarkdownFormatterModel);
+    private initialize;
+    /**
+     * Update the formatter of RichTextEditor
+     *
+     * @param  {Element} editElement - specifies the edit element.
+     * @param  {Document} doc - specifies the document.
+     * @param {number} options - specifies the options
+     * @returns {void}
+     * @hidden
+     * @deprecated
+     */
+    updateFormatter(editElement: Element, doc?: Document, options?: {
+        [key: string]: number;
+    }): void;
+}

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

@@ -0,0 +1,48 @@
+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", "./formatter", "./../../markdown-parser/base/markdown-parser", "@syncfusion/ej2-base", "./../../common/config"], function (require, exports, formatter_1, markdown_parser_1, ej2_base_1, config_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var MarkdownFormatter = (function (_super) {
+        __extends(MarkdownFormatter, _super);
+        function MarkdownFormatter(options) {
+            var _this = _super.call(this) || this;
+            _this.initialize();
+            ej2_base_1.extend(_this, _this, options, true);
+            if (options && _this.element) {
+                _this.updateFormatter(_this.element, document, options.options);
+            }
+            return _this;
+        }
+        MarkdownFormatter.prototype.initialize = function () {
+            this.keyConfig = config_1.markdownKeyConfig;
+            this.formatTags = config_1.markdownFormatTags;
+            this.listTags = config_1.markdownListsTags;
+            this.selectionTags = config_1.markdownSelectionTags;
+        };
+        MarkdownFormatter.prototype.updateFormatter = function (editElement, doc, options) {
+            if (editElement) {
+                this.editorManager = new markdown_parser_1.MarkdownParser({
+                    element: editElement,
+                    formatTags: this.formatTags,
+                    listTags: this.listTags,
+                    selectionTags: this.selectionTags,
+                    options: options
+                });
+            }
+        };
+        return MarkdownFormatter;
+    }(formatter_1.Formatter));
+    exports.MarkdownFormatter = MarkdownFormatter;
+});

package/blazorGlobalSrc/rich-text-editor/formatter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formatter
+ */
+export * from './formatter/html-formatter';
+export * from './formatter/formatter';
+export * from './formatter/markdown-formatter';

package/blazorGlobalSrc/rich-text-editor/formatter.js

@@ -0,0 +1,10 @@
+define(["require", "exports", "./formatter/html-formatter", "./formatter/formatter", "./formatter/markdown-formatter"], function (require, exports, html_formatter_1, formatter_1, markdown_formatter_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(html_formatter_1);
+    __export(formatter_1);
+    __export(markdown_formatter_1);
+});

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

@@ -0,0 +1,4 @@
+/**
+ * HtmlEditor
+ */
+export * from './actions/html-editor';

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

@@ -0,0 +1,8 @@
+define(["require", "exports", "./actions/html-editor"], function (require, exports, html_editor_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(html_editor_1);
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Image
+ */
+export * from './renderer/image-module';

package/blazorGlobalSrc/rich-text-editor/image.js

@@ -0,0 +1,8 @@
+define(["require", "exports", "./renderer/image-module"], function (require, exports, image_module_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(image_module_1);
+});

package/blazorGlobalSrc/rich-text-editor/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rich Text Editor component exported items
+ */
+export * from './actions';
+export * from './formatter';
+export * from './renderer';
+export * from './base';
+export * from './services';
+export * from './models';

package/blazorGlobalSrc/rich-text-editor/index.js

@@ -0,0 +1,12 @@
+define(["require", "exports", "./actions", "./formatter", "./renderer", "./base", "./services"], function (require, exports, actions_1, formatter_1, renderer_1, base_1, services_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(actions_1);
+    __export(formatter_1);
+    __export(renderer_1);
+    __export(base_1);
+    __export(services_1);
+});

package/blazorGlobalSrc/rich-text-editor/link.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Link
+ */
+export * from './renderer/link-module';

package/blazorGlobalSrc/rich-text-editor/link.js

@@ -0,0 +1,8 @@
+define(["require", "exports", "./renderer/link-module"], function (require, exports, link_module_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(link_module_1);
+});

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

@@ -0,0 +1,4 @@
+/**
+ * MarkdownEditor
+ */
+export * from './actions/markdown-editor';

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

@@ -0,0 +1,8 @@
+define(["require", "exports", "./actions/markdown-editor"], function (require, exports, markdown_editor_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(markdown_editor_1);
+});

package/blazorGlobalSrc/rich-text-editor/models/default-locale.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Export default locale
+ */
+export declare let defaultLocale: {
+    [key: string]: string;
+};
+export declare let toolsLocale: {
+    [key: string]: string;
+};
+export declare let fontNameLocale: {
+    [ket: string]: string;
+}[];
+export declare let formatsLocale: {
+    [ket: string]: string;
+}[];
+export declare let numberFormatListLocale: {
+    [ket: string]: string;
+}[];
+export declare let bulletFormatListLocale: {
+    [ket: string]: string;
+}[];
+export declare const slashMenuCommandsKey: Map<import("../../..").SlashMenuItems, {
+    text: string;
+    description: string;
+}>;