roosterjs-editor-adapter 0.26.0

package/lib-mjs/editor/EditorAdapter.js

@@ -0,0 +1,840 @@
+var _a;
+import { __assign, __extends, __read, __spreadArray } from "tslib";
+import { BridgePlugin } from '../corePlugins/BridgePlugin';
+import { buildRangeEx } from './utils/buildRangeEx';
+import { getObjectKeys } from 'roosterjs-content-model-dom';
+import { insertNode } from './utils/insertNode';
+import { newEventToOldEvent, oldEventToNewEvent, OldEventTypeToNewEventType, } from './utils/eventConverter';
+import { createModelFromHtml, exportContent, isBold, redo, retrieveModelFormatState, StandaloneEditor, transformColor, undo, } from 'roosterjs-content-model-core';
+import { convertDomSelectionToRangeEx, convertRangeExToDomSelection, } from './utils/selectionConverter';
+import { ContentTraverser, Position, PositionContentSearcher, cacheGetEventData, collapseNodes, contains, deleteSelectedContent, findClosestElementAncestor, getBlockElementAtNode, getRegionsFromRange, getSelectionPath, isNodeEmpty, isPositionAtBeginningOf, queryElements, toArray, wrap, } from 'roosterjs-editor-dom';
+var GetContentModeMap = (_a = {},
+    _a[0 /* CleanHTML */] = 'HTML',
+    _a[3 /* PlainText */] = 'PlainText',
+    _a[4 /* PlainTextFast */] = 'PlainTextFast',
+    _a[1 /* RawHTMLOnly */] = 'HTML',
+    _a[2 /* RawHTMLWithSelection */] = 'HTML',
+    _a);
+/**
+ * Editor for Content Model.
+ * (This class is still under development, and may still be changed in the future with some breaking changes)
+ */
+var EditorAdapter = /** @class */ (function (_super) {
+    __extends(EditorAdapter, _super);
+    /**
+     * Creates an instance of Editor
+     * @param contentDiv The DIV HTML element which will be the container element of editor
+     * @param options An optional options object to customize the editor
+     */
+    function EditorAdapter(contentDiv, options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        var _this = this;
+        var bridgePlugin = new BridgePlugin(function (core) {
+            _this.contentModelEditorCore = core;
+            return _this;
+        }, options.legacyPlugins, options.experimentalFeatures);
+        var plugins = __spreadArray([bridgePlugin], __read(((_a = options.plugins) !== null && _a !== void 0 ? _a : [])), false);
+        var initContent = (_b = options.initialContent) !== null && _b !== void 0 ? _b : contentDiv.innerHTML;
+        var initialModel = initContent && !options.initialModel
+            ? createModelFromHtml(initContent, options.defaultDomToModelOptions, options.trustedHTMLHandler, options.defaultSegmentFormat)
+            : options.initialModel;
+        var standaloneEditorOptions = __assign(__assign({}, options), { plugins: plugins, initialModel: initialModel });
+        _this = _super.call(this, contentDiv, standaloneEditorOptions) || this;
+        return _this;
+    }
+    /**
+     * Dispose this editor, dispose all plugins and custom data
+     */
+    EditorAdapter.prototype.dispose = function () {
+        var core = this.contentModelEditorCore;
+        if (core) {
+            getObjectKeys(core.customData).forEach(function (key) {
+                var data = core.customData[key];
+                if (data && data.disposer) {
+                    data.disposer(data.value);
+                }
+                delete core.customData[key];
+            });
+            this.contentModelEditorCore = undefined;
+        }
+        _super.prototype.dispose.call(this);
+    };
+    /**
+     * Get whether this editor is disposed
+     * @returns True if editor is disposed, otherwise false
+     */
+    EditorAdapter.prototype.isDisposed = function () {
+        return _super.prototype.isDisposed.call(this) || !this.contentModelEditorCore;
+    };
+    /**
+     * Insert node into editor
+     * @param node The node to insert
+     * @param option Insert options. Default value is:
+     *  position: ContentPosition.SelectionStart
+     *  updateCursor: true
+     *  replaceSelection: true
+     *  insertOnNewLine: false
+     * @returns true if node is inserted. Otherwise false
+     */
+    EditorAdapter.prototype.insertNode = function (node, option) {
+        var _a;
+        if (node) {
+            option = option || {
+                position: 3 /* SelectionStart */,
+                insertOnNewLine: false,
+                updateCursor: true,
+                replaceSelection: true,
+                insertToRegionRoot: false,
+            };
+            var contentDiv = this.getCore().contentDiv;
+            if (option.updateCursor) {
+                this.focus();
+            }
+            if (option.position == 4 /* Outside */) {
+                (_a = contentDiv.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(node, contentDiv.nextSibling);
+            }
+            else {
+                if (this.isDarkMode()) {
+                    transformColor(node, true /*includeSelf*/, 'lightToDark', this.getColorManager());
+                }
+                var selection = insertNode(contentDiv, this.getDOMSelection(), node, option);
+                if (selection) {
+                    this.setDOMSelection(selection);
+                }
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    /**
+     * Delete a node from editor content
+     * @param node The node to delete
+     * @returns true if node is deleted. Otherwise false
+     */
+    EditorAdapter.prototype.deleteNode = function (node) {
+        // Only remove the node when it falls within editor
+        if (node && this.contains(node) && node.parentNode) {
+            node.parentNode.removeChild(node);
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Replace a node in editor content with another node
+     * @param existingNode The existing node to be replaced
+     * @param toNode node to replace to
+     * @param transformColorForDarkMode (optional) Whether to transform new node to dark mode. Default is false
+     * @returns true if node is replaced. Otherwise false
+     */
+    EditorAdapter.prototype.replaceNode = function (existingNode, toNode, transformColorForDarkMode) {
+        var _a;
+        var core = this.getCore();
+        // Only replace the node when it falls within editor
+        if (this.contains(existingNode) && toNode) {
+            if (core.lifecycle.isDarkMode && transformColorForDarkMode) {
+                this.transformToDarkColor(toNode, 0 /* LightToDark */);
+            }
+            (_a = existingNode.parentNode) === null || _a === void 0 ? void 0 : _a.replaceChild(toNode, existingNode);
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Get BlockElement at given node
+     * @param node The node to create InlineElement
+     * @returns The BlockElement result
+     */
+    EditorAdapter.prototype.getBlockElementAtNode = function (node) {
+        return getBlockElementAtNode(this.getCore().contentDiv, node);
+    };
+    EditorAdapter.prototype.contains = function (arg) {
+        if (!arg) {
+            return false;
+        }
+        return contains(this.getCore().contentDiv, arg);
+    };
+    EditorAdapter.prototype.queryElements = function (selector, scopeOrCallback, callback) {
+        if (scopeOrCallback === void 0) { scopeOrCallback = 0 /* Body */; }
+        var core = this.getCore();
+        var result = [];
+        var scope = scopeOrCallback instanceof Function ? 0 /* Body */ : scopeOrCallback;
+        callback = scopeOrCallback instanceof Function ? scopeOrCallback : callback;
+        var selectionEx = scope == 0 /* Body */ ? null : this.getSelectionRangeEx();
+        if (selectionEx) {
+            selectionEx.ranges.forEach(function (range) {
+                result.push.apply(result, __spreadArray([], __read(queryElements(core.contentDiv, selector, callback, scope, range)), false));
+            });
+        }
+        else {
+            return queryElements(core.contentDiv, selector, callback, scope, undefined /* range */);
+        }
+        return result;
+    };
+    /**
+     * Collapse nodes within the given start and end nodes to their common ancestor node,
+     * split parent nodes if necessary
+     * @param start The start node
+     * @param end The end node
+     * @param canSplitParent True to allow split parent node there are nodes before start or after end under the same parent
+     * and the returned nodes will be all nodes from start through end after splitting
+     * False to disallow split parent
+     * @returns When canSplitParent is true, returns all node from start through end after splitting,
+     * otherwise just return start and end
+     */
+    EditorAdapter.prototype.collapseNodes = function (start, end, canSplitParent) {
+        return collapseNodes(this.getCore().contentDiv, start, end, canSplitParent);
+    };
+    //#endregion
+    //#region Content API
+    /**
+     * Check whether the editor contains any visible content
+     * @param trim Whether trim the content string before check. Default is false
+     * @returns True if there's no visible content, otherwise false
+     */
+    EditorAdapter.prototype.isEmpty = function (trim) {
+        return isNodeEmpty(this.getCore().contentDiv, trim);
+    };
+    /**
+     * Get current editor content as HTML string
+     * @param mode specify what kind of HTML content to retrieve
+     * @returns HTML string representing current editor content
+     */
+    EditorAdapter.prototype.getContent = function (mode) {
+        if (mode === void 0) { mode = 0 /* CleanHTML */; }
+        return exportContent(this, GetContentModeMap[mode]);
+    };
+    /**
+     * Set HTML content to this editor. All existing content will be replaced. A ContentChanged event will be triggered
+     * @param content HTML content to set in
+     * @param triggerContentChangedEvent True to trigger a ContentChanged event. Default value is true
+     */
+    EditorAdapter.prototype.setContent = function (content, triggerContentChangedEvent) {
+        if (triggerContentChangedEvent === void 0) { triggerContentChangedEvent = true; }
+        var core = this.getCore();
+        var contentDiv = core.contentDiv, api = core.api, trustedHTMLHandler = core.trustedHTMLHandler, lifecycle = core.lifecycle, darkColorHandler = core.darkColorHandler;
+        api.triggerEvent(core, {
+            eventType: 'beforeSetContent',
+            newContent: content,
+        }, true /*broadcast*/);
+        var newModel = createModelFromHtml(content, core.domToModelSettings.customized, trustedHTMLHandler, core.format.defaultFormat);
+        api.setContentModel(core, newModel);
+        if (triggerContentChangedEvent) {
+            api.triggerEvent(core, {
+                eventType: 'contentChanged',
+                source: "SetContent" /* SetContent */,
+            }, false /*broadcast*/);
+        }
+        else if (lifecycle.isDarkMode) {
+            transformColor(contentDiv, false /*includeSelf*/, 'lightToDark', darkColorHandler);
+        }
+    };
+    /**
+     * Insert HTML content into editor
+     * @param HTML content to insert
+     * @param option Insert options. Default value is:
+     *  position: ContentPosition.SelectionStart
+     *  updateCursor: true
+     *  replaceSelection: true
+     *  insertOnNewLine: false
+     */
+    EditorAdapter.prototype.insertContent = function (content, option) {
+        var _a;
+        if (content) {
+            var doc = this.getDocument();
+            var body = (_a = new DOMParser().parseFromString(this.getCore().trustedHTMLHandler(content), 'text/html')) === null || _a === void 0 ? void 0 : _a.body;
+            var allNodes = (body === null || body === void 0 ? void 0 : body.childNodes) ? toArray(body.childNodes) : [];
+            // If it is to insert on new line, and there are more than one node in the collection, wrap all nodes with
+            // a parent DIV before calling insertNode on each top level sub node. Otherwise, every sub node may get wrapped
+            // separately to show up on its own line
+            if (option && option.insertOnNewLine && allNodes.length > 1) {
+                allNodes = [wrap(allNodes)];
+            }
+            var fragment_1 = doc.createDocumentFragment();
+            allNodes.forEach(function (node) { return fragment_1.appendChild(node); });
+            this.insertNode(fragment_1, option);
+        }
+    };
+    /**
+     * Delete selected content
+     */
+    EditorAdapter.prototype.deleteSelectedContent = function () {
+        var range = this.getSelectionRange();
+        if (range && !range.collapsed) {
+            return deleteSelectedContent(this.getCore().contentDiv, range);
+        }
+        return null;
+    };
+    /**
+     * Paste into editor using a clipboardData object
+     * @param clipboardData Clipboard data retrieved from clipboard
+     * @param pasteAsText Force pasting as plain text. Default value is false
+     * @param applyCurrentStyle True if apply format of current selection to the pasted content,
+     * false to keep original format.  Default value is false. When pasteAsText is true, this parameter is ignored
+     * @param pasteAsImage: When set to true, if the clipboardData contains a imageDataUri will paste the image to the editor
+     */
+    EditorAdapter.prototype.paste = function (clipboardData, pasteAsText, applyCurrentFormat, pasteAsImage) {
+        if (pasteAsText === void 0) { pasteAsText = false; }
+        if (applyCurrentFormat === void 0) { applyCurrentFormat = false; }
+        if (pasteAsImage === void 0) { pasteAsImage = false; }
+        this.pasteFromClipboard(clipboardData, pasteAsText
+            ? 'asPlainText'
+            : applyCurrentFormat
+                ? 'mergeFormat'
+                : pasteAsImage
+                    ? 'asImage'
+                    : 'normal');
+    };
+    //#endregion
+    //#region Focus and Selection
+    /**
+     * Get current selection range from Editor.
+     * It does a live pull on the selection, if nothing retrieved, return whatever we have in cache.
+     * @param tryGetFromCache Set to true to retrieve the selection range from cache if editor doesn't own the focus now.
+     * Default value is true
+     * @returns current selection range, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getSelectionRange = function (tryGetFromCache) {
+        if (tryGetFromCache === void 0) { tryGetFromCache = true; }
+        var selection = this.getDOMSelection();
+        return (selection === null || selection === void 0 ? void 0 : selection.type) == 'range' ? selection.range : null;
+    };
+    /**
+     * Get current selection range from Editor.
+     * It does a live pull on the selection, if nothing retrieved, return whatever we have in cache.
+     * @param tryGetFromCache Set to true to retrieve the selection range from cache if editor doesn't own the focus now.
+     * Default value is true
+     * @returns current selection range, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getSelectionRangeEx = function () {
+        var selection = this.getDOMSelection();
+        return convertDomSelectionToRangeEx(selection);
+    };
+    /**
+     * Get current selection in a serializable format
+     * It does a live pull on the selection, if nothing retrieved, return whatever we have in cache.
+     * @returns current selection path, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getSelectionPath = function () {
+        var range = this.getSelectionRange();
+        return range && getSelectionPath(this.getCore().contentDiv, range);
+    };
+    EditorAdapter.prototype.select = function (arg1, arg2, arg3, arg4) {
+        var core = this.getCore();
+        var rangeEx = buildRangeEx(core.contentDiv, arg1, arg2, arg3, arg4);
+        var selection = convertRangeExToDomSelection(rangeEx);
+        this.setDOMSelection(selection);
+        return true;
+    };
+    /**
+     * Get current focused position. Return null if editor doesn't have focus at this time.
+     */
+    EditorAdapter.prototype.getFocusedPosition = function () {
+        var _a;
+        var sel = (_a = this.getDocument().defaultView) === null || _a === void 0 ? void 0 : _a.getSelection();
+        if ((sel === null || sel === void 0 ? void 0 : sel.focusNode) && this.contains(sel.focusNode)) {
+            return new Position(sel.focusNode, sel.focusOffset);
+        }
+        var range = this.getSelectionRange();
+        if (range) {
+            return Position.getStart(range);
+        }
+        return null;
+    };
+    /**
+     * Get an HTML element from current cursor position.
+     * When expectedTags is not specified, return value is the current node (if it is HTML element)
+     * or its parent node (if current node is a Text node).
+     * When expectedTags is specified, return value is the first ancestor of current node which has
+     * one of the expected tags.
+     * If no element found within editor by the given tag, return null.
+     * @param selector Optional, an HTML selector to find HTML element with.
+     * @param startFrom Start search from this node. If not specified, start from current focused position
+     * @param event Optional, if specified, editor will try to get cached result from the event object first.
+     * If it is not cached before, query from DOM and cache the result into the event object
+     */
+    EditorAdapter.prototype.getElementAtCursor = function (selector, startFrom, event) {
+        var _this = this;
+        var _a;
+        event = startFrom ? undefined : event; // Only use cache when startFrom is not specified, for different start position can have different result
+        return ((_a = cacheGetEventData(event !== null && event !== void 0 ? event : null, 'GET_ELEMENT_AT_CURSOR_' + selector, function () {
+            if (!startFrom) {
+                var position = _this.getFocusedPosition();
+                startFrom = position === null || position === void 0 ? void 0 : position.node;
+            }
+            return (startFrom &&
+                findClosestElementAncestor(startFrom, _this.getCore().contentDiv, selector));
+        })) !== null && _a !== void 0 ? _a : null);
+    };
+    /**
+     * Check if this position is at beginning of the editor.
+     * This will return true if all nodes between the beginning of target node and the position are empty.
+     * @param position The position to check
+     * @returns True if position is at beginning of the editor, otherwise false
+     */
+    EditorAdapter.prototype.isPositionAtBeginning = function (position) {
+        return isPositionAtBeginningOf(position, this.getCore().contentDiv);
+    };
+    /**
+     * Get impacted regions from selection
+     */
+    EditorAdapter.prototype.getSelectedRegions = function (type) {
+        if (type === void 0) { type = 0 /* Table */; }
+        var selection = this.getSelectionRangeEx();
+        var result = [];
+        var contentDiv = this.getCore().contentDiv;
+        selection.ranges.forEach(function (range) {
+            result.push.apply(result, __spreadArray([], __read((range ? getRegionsFromRange(contentDiv, range, type) : [])), false));
+        });
+        return result.filter(function (value, index, self) {
+            return self.indexOf(value) === index;
+        });
+    };
+    //#endregion
+    //#region EVENT API
+    EditorAdapter.prototype.addDomEventHandler = function (nameOrMap, handler) {
+        var _a;
+        var eventsMap = typeof nameOrMap == 'string' ? (_a = {}, _a[nameOrMap] = handler, _a) : nameOrMap;
+        var eventsMapResult = {};
+        getObjectKeys(eventsMap).forEach(function (key) {
+            var handlerObj = eventsMap[key];
+            var result = {
+                pluginEventType: null,
+                beforeDispatch: null,
+            };
+            if (typeof handlerObj === 'number') {
+                result.pluginEventType = OldEventTypeToNewEventType[handlerObj];
+            }
+            else if (typeof handlerObj === 'function') {
+                result.beforeDispatch = handlerObj;
+            }
+            else if (typeof handlerObj === 'object') {
+                var record = handlerObj;
+                result = {
+                    beforeDispatch: record.beforeDispatch,
+                    pluginEventType: typeof record.pluginEventType == 'number'
+                        ? OldEventTypeToNewEventType[record.pluginEventType]
+                        : undefined,
+                };
+            }
+            eventsMapResult[key] = result;
+        });
+        return this.attachDomEvent(eventsMapResult);
+    };
+    /**
+     * Trigger an event to be dispatched to all plugins
+     * @param eventType Type of the event
+     * @param data data of the event with given type, this is the rest part of PluginEvent with the given type
+     * @param broadcast indicates if the event needs to be dispatched to all plugins
+     * True means to all, false means to allow exclusive handling from one plugin unless no one wants that
+     * @returns the event object which is really passed into plugins. Some plugin may modify the event object so
+     * the result of this function provides a chance to read the modified result
+     */
+    EditorAdapter.prototype.triggerPluginEvent = function (eventType, data, broadcast) {
+        var _a;
+        if (broadcast === void 0) { broadcast = false; }
+        var oldEvent = __assign({ eventType: eventType }, data);
+        var newEvent = oldEventToNewEvent(oldEvent);
+        var core = this.getCore();
+        if (newEvent) {
+            core.api.triggerEvent(core, newEvent, broadcast);
+            return ((_a = newEventToOldEvent(newEvent, oldEvent)) !== null && _a !== void 0 ? _a : oldEvent);
+        }
+        else {
+            return oldEvent;
+        }
+    };
+    /**
+     * Trigger a ContentChangedEvent
+     * @param source Source of this event, by default is 'SetContent'
+     * @param data additional data for this event
+     */
+    EditorAdapter.prototype.triggerContentChangedEvent = function (source, data) {
+        if (source === void 0) { source = "SetContent" /* SetContent */; }
+        this.triggerPluginEvent(7 /* ContentChanged */, {
+            source: source,
+            data: data,
+        });
+    };
+    //#endregion
+    //#region Undo API
+    /**
+     * Undo last edit operation
+     */
+    EditorAdapter.prototype.undo = function () {
+        undo(this);
+    };
+    /**
+     * Redo next edit operation
+     */
+    EditorAdapter.prototype.redo = function () {
+        redo(this);
+    };
+    /**
+     * Add undo snapshot, and execute a format callback function, then add another undo snapshot, then trigger
+     * ContentChangedEvent with given change source.
+     * If this function is called nested, undo snapshot will only be added in the outside one
+     * @param callback The callback function to perform formatting, returns a data object which will be used as
+     * the data field in ContentChangedEvent if changeSource is not null.
+     * @param changeSource The change source to use when fire ContentChangedEvent. When the value is not null,
+     * a ContentChangedEvent will be fired with change source equal to this value
+     * @param canUndoByBackspace True if this action can be undone when user press Backspace key (aka Auto Complete).
+     */
+    EditorAdapter.prototype.addUndoSnapshot = function (callback, changeSource, canUndoByBackspace, additionalData) {
+        var _a, _b;
+        var core = this.getCore();
+        var undoState = core.undo;
+        var isNested = undoState.isNested;
+        var data;
+        if (!isNested) {
+            undoState.isNested = true;
+            // When there is getEntityState, it means this is triggered by an entity change.
+            // So if HTML content is not changed (hasNewContent is false), no need to add another snapshot before change
+            if (core.undo.snapshotsManager.hasNewContent ||
+                !(additionalData === null || additionalData === void 0 ? void 0 : additionalData.getEntityState) ||
+                !callback) {
+                core.api.addUndoSnapshot(core, !!canUndoByBackspace, (_a = additionalData === null || additionalData === void 0 ? void 0 : additionalData.getEntityState) === null || _a === void 0 ? void 0 : _a.call(additionalData));
+            }
+        }
+        try {
+            if (callback) {
+                var selection = core.api.getDOMSelection(core);
+                var range = (selection === null || selection === void 0 ? void 0 : selection.type) == 'range' ? selection.range : null;
+                data = callback(range && Position.getStart(range).normalize(), range && Position.getEnd(range).normalize());
+                if (!isNested) {
+                    var entityStates = (_b = additionalData === null || additionalData === void 0 ? void 0 : additionalData.getEntityState) === null || _b === void 0 ? void 0 : _b.call(additionalData);
+                    core.api.addUndoSnapshot(core, false /*isAutoCompleteSnapshot*/, entityStates);
+                }
+            }
+        }
+        finally {
+            if (!isNested) {
+                undoState.isNested = false;
+            }
+        }
+        if (callback && changeSource) {
+            var event_1 = {
+                eventType: 7 /* ContentChanged */,
+                source: changeSource,
+                data: data,
+                additionalData: additionalData,
+            };
+            this.triggerPluginEvent(7 /* ContentChanged */, event_1, true /*broadcast*/);
+        }
+        if (canUndoByBackspace) {
+            var selection = core.api.getDOMSelection(core);
+            if ((selection === null || selection === void 0 ? void 0 : selection.type) == 'range') {
+                core.undo.snapshotsManager.hasNewContent = false;
+                core.undo.posContainer = selection.range.startContainer;
+                core.undo.posOffset = selection.range.startOffset;
+            }
+        }
+    };
+    /**
+     * Whether there is an available undo/redo snapshot
+     */
+    EditorAdapter.prototype.getUndoState = function () {
+        var snapshotsManager = this.getCore().undo.snapshotsManager;
+        return {
+            canUndo: snapshotsManager.hasNewContent || snapshotsManager.canMove(-1 /*previousSnapshot*/),
+            canRedo: snapshotsManager.canMove(1 /*nextSnapshot*/),
+        };
+    };
+    //#endregion
+    //#region Misc
+    /**
+     * Get custom data related to this editor
+     * @param key Key of the custom data
+     * @param getter Getter function. If custom data for the given key doesn't exist,
+     * call this function to get one and store it if it is specified. Otherwise return undefined
+     * @param disposer An optional disposer function to dispose this custom data when
+     * dispose editor.
+     */
+    EditorAdapter.prototype.getCustomData = function (key, getter, disposer) {
+        var core = this.getContentModelEditorCore();
+        return (core.customData[key] = core.customData[key] || {
+            value: getter ? getter() : undefined,
+            disposer: disposer,
+        }).value;
+    };
+    /**
+     * Get default format of this editor
+     * @returns Default format object of this editor
+     */
+    EditorAdapter.prototype.getDefaultFormat = function () {
+        var format = this.getCore().format.defaultFormat;
+        return {
+            bold: isBold(format.fontWeight),
+            italic: format.italic,
+            underline: format.underline,
+            fontFamily: format.fontFamily,
+            fontSize: format.fontSize,
+            textColor: format.textColor,
+            backgroundColor: format.backgroundColor,
+        };
+    };
+    /**
+     * Get a content traverser for the whole editor
+     * @param startNode The node to start from. If not passed, it will start from the beginning of the body
+     */
+    EditorAdapter.prototype.getBodyTraverser = function (startNode) {
+        return ContentTraverser.createBodyTraverser(this.getCore().contentDiv, startNode);
+    };
+    /**
+     * Get a content traverser for current selection
+     * @returns A content traverser, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getSelectionTraverser = function (range) {
+        var _a;
+        range = (_a = range !== null && range !== void 0 ? range : this.getSelectionRange()) !== null && _a !== void 0 ? _a : undefined;
+        return range
+            ? ContentTraverser.createSelectionTraverser(this.getCore().contentDiv, range)
+            : null;
+    };
+    /**
+     * Get a content traverser for current block element start from specified position
+     * @param startFrom Start position of the traverser. Default value is ContentPosition.SelectionStart
+     * @returns A content traverser, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getBlockTraverser = function (startFrom) {
+        if (startFrom === void 0) { startFrom = 3 /* SelectionStart */; }
+        var range = this.getSelectionRange();
+        return range
+            ? ContentTraverser.createBlockTraverser(this.getCore().contentDiv, range, startFrom)
+            : null;
+    };
+    /**
+     * Get a text traverser of current selection
+     * @param event Optional, if specified, editor will try to get cached result from the event object first.
+     * If it is not cached before, query from DOM and cache the result into the event object
+     * @returns A content traverser, or null if editor never got focus before
+     */
+    EditorAdapter.prototype.getContentSearcherOfCursor = function (event) {
+        var _this = this;
+        return cacheGetEventData(event !== null && event !== void 0 ? event : null, 'ContentSearcher', function () {
+            var range = _this.getSelectionRange();
+            return (range &&
+                new PositionContentSearcher(_this.getCore().contentDiv, Position.getStart(range)));
+        });
+    };
+    /**
+     * Run a callback function asynchronously
+     * @param callback The callback function to run
+     * @returns a function to cancel this async run
+     */
+    EditorAdapter.prototype.runAsync = function (callback) {
+        var _this = this;
+        var win = this.getCore().contentDiv.ownerDocument.defaultView || window;
+        var handle = win.requestAnimationFrame(function () {
+            if (!_this.isDisposed() && callback) {
+                callback(_this);
+            }
+        });
+        return function () {
+            win.cancelAnimationFrame(handle);
+        };
+    };
+    /**
+     * Set DOM attribute of editor content DIV
+     * @param name Name of the attribute
+     * @param value Value of the attribute
+     */
+    EditorAdapter.prototype.setEditorDomAttribute = function (name, value) {
+        this.getDOMHelper().setDomAttribute(name, value);
+    };
+    /**
+     * Get DOM attribute of editor content DIV, null if there is no such attribute.
+     * @param name Name of the attribute
+     */
+    EditorAdapter.prototype.getEditorDomAttribute = function (name) {
+        return this.getDOMHelper().getDomAttribute(name);
+    };
+    /**
+     * @deprecated Use getVisibleViewport() instead.
+     *
+     * Get current relative distance from top-left corner of the given element to top-left corner of editor content DIV.
+     * @param element The element to calculate from. If the given element is not in editor, return value will be null
+     * @param addScroll When pass true, The return value will also add scrollLeft and scrollTop if any. So the value
+     * may be different than what user is seeing from the view. When pass false, scroll position will be ignored.
+     * @returns An [x, y] array which contains the left and top distances, or null if the given element is not in editor.
+     */
+    EditorAdapter.prototype.getRelativeDistanceToEditor = function (element, addScroll) {
+        if (this.contains(element)) {
+            var contentDiv = this.getCore().contentDiv;
+            var editorRect = contentDiv.getBoundingClientRect();
+            var elementRect = element.getBoundingClientRect();
+            if (editorRect && elementRect) {
+                var x = elementRect.left - (editorRect === null || editorRect === void 0 ? void 0 : editorRect.left);
+                var y = elementRect.top - (editorRect === null || editorRect === void 0 ? void 0 : editorRect.top);
+                if (addScroll) {
+                    x += contentDiv.scrollLeft;
+                    y += contentDiv.scrollTop;
+                }
+                return [x, y];
+            }
+        }
+        return null;
+    };
+    /**
+     * Add a Content Edit feature.
+     * @param feature The feature to add
+     */
+    EditorAdapter.prototype.addContentEditFeature = function (feature) {
+        var core = this.getContentModelEditorCore();
+        feature === null || feature === void 0 ? void 0 : feature.keys.forEach(function (key) {
+            var array = core.edit.features[key] || [];
+            array.push(feature);
+            core.edit.features[key] = array;
+        });
+    };
+    /**
+     * Remove a Content Edit feature.
+     * @param feature The feature to remove
+     */
+    EditorAdapter.prototype.removeContentEditFeature = function (feature) {
+        var core = this.getContentModelEditorCore();
+        feature === null || feature === void 0 ? void 0 : feature.keys.forEach(function (key) {
+            var _a;
+            var featureSet = core.edit.features[key];
+            var index = (_a = featureSet === null || featureSet === void 0 ? void 0 : featureSet.indexOf(feature)) !== null && _a !== void 0 ? _a : -1;
+            if (index >= 0) {
+                core.edit.features[key].splice(index, 1);
+                if (core.edit.features[key].length < 1) {
+                    delete core.edit.features[key];
+                }
+            }
+        });
+    };
+    /**
+     * @deprecated
+     * Get style based format state from current selection, including font name/size and colors
+     */
+    EditorAdapter.prototype.getStyleBasedFormatState = function () {
+        var format = this.retrieveFormatState();
+        return {
+            backgroundColor: format.backgroundColor,
+            direction: format.direction,
+            fontName: format.fontName,
+            fontSize: format.fontSize,
+            fontWeight: format.fontWeight,
+            lineHeight: format.lineHeight,
+            marginBottom: format.marginBottom,
+            marginTop: format.marginTop,
+            textAlign: format.textAlign,
+            textColor: format.textColor,
+        };
+    };
+    /**
+     * @deprecated
+     * Get the pendable format such as underline and bold
+     * @returns The pending format state
+     */
+    EditorAdapter.prototype.getPendableFormatState = function () {
+        var format = this.retrieveFormatState();
+        return {
+            isBold: format.isBold,
+            isItalic: format.isItalic,
+            isStrikeThrough: format.isStrikeThrough,
+            isSubscript: format.isSubscript,
+            isSuperscript: format.isSubscript,
+            isUnderline: format.isUnderline,
+        };
+    };
+    /**
+     * @deprecated
+     * Ensure user will type into a container element rather than into the editor content DIV directly
+     * @param position The position that user is about to type to
+     * @param keyboardEvent Optional keyboard event object
+     */
+    EditorAdapter.prototype.ensureTypeInContainer = function (position, keyboardEvent) {
+        // No OP
+    };
+    //#endregion
+    //#region Dark mode APIs
+    /**
+     * Transform the given node and all its child nodes to dark mode color if editor is in dark mode
+     * @param node The node to transform
+     * @param direction The transform direction. @default ColorTransformDirection.LightToDark
+     */
+    EditorAdapter.prototype.transformToDarkColor = function (node, direction) {
+        if (direction === void 0) { direction = 0 /* LightToDark */; }
+        var core = this.getCore();
+        if (core.lifecycle.isDarkMode) {
+            transformColor(node, true /*includeSelf*/, direction == 1 /* DarkToLight */ ? 'darkToLight' : 'lightToDark', core.darkColorHandler);
+        }
+    };
+    /**
+     * Check if the given experimental feature is enabled
+     * @param feature The feature to check
+     */
+    EditorAdapter.prototype.isFeatureEnabled = function (feature) {
+        return (this.getContentModelEditorCore().experimentalFeatures.indexOf(feature) >= 0);
+    };
+    /**
+     * Get current zoom scale, default value is 1
+     * When editor is put under a zoomed container, need to pass the zoom scale number using EditorOptions.zoomScale
+     * to let editor behave correctly especially for those mouse drag/drop behaviors
+     * @returns current zoom scale number
+     */
+    EditorAdapter.prototype.getZoomScale = function () {
+        return this.getDOMHelper().calculateZoomScale();
+    };
+    /**
+     * Set current zoom scale, default value is 1
+     * When editor is put under a zoomed container, need to pass the zoom scale number using EditorOptions.zoomScale
+     * to let editor behave correctly especially for those mouse drag/drop behaviors
+     * @param scale The new scale number to set. It should be positive number and no greater than 10, otherwise it will be ignored.
+     */
+    EditorAdapter.prototype.setZoomScale = function (scale) {
+        if (scale > 0 && scale <= 10) {
+            var oldValue = this.getZoomScale();
+            if (oldValue != scale) {
+                this.triggerEvent('zoomChanged', {
+                    newZoomScale: scale,
+                }, true /*broadcast*/);
+            }
+        }
+    };
+    /**
+     * @deprecated Use getZoomScale() instead
+     */
+    EditorAdapter.prototype.getSizeTransformer = function () {
+        return this.getContentModelEditorCore().sizeTransformer;
+    };
+    /**
+     * Get a darkColorHandler object for this editor.
+     */
+    EditorAdapter.prototype.getDarkColorHandler = function () {
+        var core = this.getContentModelEditorCore();
+        return core.darkColorHandler;
+    };
+    /**
+     * Check if editor is in IME input sequence
+     * @returns True if editor is in IME input sequence, otherwise false
+     */
+    EditorAdapter.prototype.isInIME = function () {
+        return this.getCore().domEvent.isInIME;
+    };
+    EditorAdapter.prototype.retrieveFormatState = function () {
+        var pendingFormat = this.getPendingFormat();
+        var result = {};
+        var model = this.getContentModelCopy('reduced');
+        retrieveModelFormatState(model, pendingFormat, result);
+        return result;
+    };
+    /**
+     * @returns the current EditorAdapterCore object
+     * @throws a standard Error if there's no core object
+     */
+    EditorAdapter.prototype.getContentModelEditorCore = function () {
+        if (!this.contentModelEditorCore) {
+            throw new Error('Editor is already disposed');
+        }
+        return this.contentModelEditorCore;
+    };
+    return EditorAdapter;
+}(StandaloneEditor));
+export { EditorAdapter };
+//# sourceMappingURL=EditorAdapter.js.map