suneditor 3.0.0-beta.3 → 3.0.0-beta.30

package/src/core/event/executor.js

@@ -0,0 +1,21 @@
+import common from './effects/common.registry';
+import keydown from './effects/keydown.registry';
+
+const HALT = 'action.stop';
+
+/**
+ * @description Execute actions sequentially
+ * @param {__se__EventActions} actions - Array of actions to execute
+ * @param {*} effContext - Effect context containing ports, ctx, and event
+ */
+export async function actionExecutor(actions, effContext) {
+	const effects = { ...common, ...keydown };
+	for (const a of actions) {
+		if (a.t === HALT) return false;
+		const eff = effects[a.t];
+		if (eff) {
+			const r = await eff(effContext, a.p);
+			if (r === false) return false;
+		}
+	}
+}

package/src/core/{base/eventHandlers → event/handlers}/handler_toolbar.js

@@ -15,7 +15,7 @@ export function ButtonsHandler(e) {
 	const eventTarget = dom.query.getEventTarget(e);
 	let target = eventTarget;
 
-	if (this.editor.isSubBalloon && !this.context.get('toolbar.sub.main')?.contains(target)) {
+	if (this.editor.isSubBalloon && !this.context.get('toolbar_sub_main')?.contains(target)) {
 		this._hideToolbar_sub();
 	}
 
@@ -23,7 +23,7 @@ export function ButtonsHandler(e) {
 
 	if (isInput) {
 		this.editor._preventBlur = false;
-	} else if (!this.editor.frameContext.get('wysiwyg').contains(this.selection.getNode())) {
+	} else if (!this.frameContext.get('wysiwyg').contains(this.selection.getNode())) {
 		this.editor.focus();
 	}
 
@@ -82,7 +82,7 @@ export function ButtonsHandler(e) {
 
 			this.__removeInput();
 			return;
-		} else if (!this.editor.frameContext.get('isCodeView')) {
+		} else if (!this.frameContext.get('isCodeView')) {
 			if (isMobile) {
 				this.editor._preventBlur = true;
 			} else {
@@ -113,7 +113,7 @@ export function OnClick_menuTray(e) {
 	let k = '';
 	while (t && !/se-menu-tray/.test(t.className) && !k) {
 		t = t.parentElement;
-		k = t.getAttribute('data-key');
+		k = t?.getAttribute('data-key');
 	}
 	if (!k) return;
 

package/src/core/{base/eventHandlers → event/handlers}/handler_ww_dragDrop.js

@@ -27,7 +27,7 @@ export function OnDragOver_wysiwyg(fc, dragCursor, _iframeTopArea, _innerToolbar
 	const _offset = { y: 0, x: 0 };
 	if (_iframeTopArea) {
 		const iframeOffset = this.offset.getGlobal(_iframeTopArea);
-		const toolbarH = _innerToolbar ? this.context.get('toolbar.main').offsetHeight : 0;
+		const toolbarH = _innerToolbar ? this.context.get('toolbar_main').offsetHeight : 0;
 		_offset.y = iframeOffset.top + toolbarH - this._w.scrollY;
 		_offset.x = iframeOffset.left - this._w.scrollX;
 	}
@@ -98,7 +98,7 @@ export function OnDrop_wysiwyg(fc, dragCursor, e) {
 			this.html.insertNode(dragContainer, { afterNode: null, skipCharCount: true });
 
 			// document type page
-			if (fc.has('documentType-use-page')) {
+			if (fc.has('documentType_use_page')) {
 				fc.get('documentTypePageMirror').innerHTML = fc.get('wysiwyg').innerHTML;
 				fc.get('documentType').rePage(true);
 			}

package/src/core/event/handlers/handler_ww_input.js

@@ -0,0 +1,77 @@
+import { dom, keyCodeMap } from '../../../helper';
+
+/**
+ * @typedef {Omit<import('../eventManager').default & Partial<__se__EditorInjector>, 'eventManager'>} EventManagerThis_handler_ww_input
+ */
+
+/**
+ * @private
+ * @this {EventManagerThis_handler_ww_input}
+ * @param {__se__FrameContext} fc - Frame context object
+ * @param {InputEvent} e - Event object
+ */
+export async function OnBeforeInput_wysiwyg(fc, e) {
+	if (fc.get('isReadOnly') || fc.get('isDisabled')) {
+		e.preventDefault();
+		e.stopPropagation();
+		return false;
+	}
+
+	const data = (e.data === null ? '' : e.data === undefined ? ' ' : e.data) || '';
+	if (!keyCodeMap.isComposing(e)) {
+		if (!this.char.test(data, false)) {
+			e.preventDefault();
+			e.stopPropagation();
+			return false;
+		}
+		this._handledInBefore = true;
+	} else {
+		this._handledInBefore = false;
+	}
+
+	// user event
+	if ((await this.triggerEvent('onBeforeInput', { frameContext: fc, event: e, data })) === false) return;
+	// plugin event
+	if (this._callPluginEvent('onBeforeInput', { frameContext: fc, event: e, data }) === false) return;
+}
+
+/**
+ * @private
+ * @this {EventManagerThis_handler_ww_input}
+ * @param {__se__FrameContext} fc - Frame context object
+ * @param {InputEvent} e - Event object
+ */
+export async function OnInput_wysiwyg(fc, e) {
+	if (fc.get('isReadOnly') || fc.get('isDisabled')) {
+		e.preventDefault();
+		e.stopPropagation();
+		return false;
+	}
+
+	const range = this.selection.getRange();
+	const selectionNode = this.selection.getNode();
+	const formatEl = this.format.getLine(selectionNode, null);
+	if (!this.format.isNormalLine(formatEl) && !this.format.isBrLine(formatEl) && range.collapsed && !this.component.is(selectionNode) && !dom.check.isList(selectionNode)) {
+		const rangeEl = this.format.getBlock(selectionNode, null);
+		this._setDefaultLine(this.format.isBlock(rangeEl) ? 'DIV' : this.options.get('defaultLine'));
+	}
+
+	this.selection._init();
+
+	const data = (e.data === null ? '' : e.data === undefined ? ' ' : e.data) || '';
+	if (!this._handledInBefore) {
+		if (!this.char.test(data, true)) {
+			e.preventDefault();
+			e.stopPropagation();
+			return false;
+		}
+	}
+	this._handledInBefore = false;
+
+	// user event
+	if ((await this.triggerEvent('onInput', { frameContext: fc, event: e, data })) === false) return;
+	// plugin event
+	if (this._callPluginEvent('onInput', { frameContext: fc, event: e, data }) === false) return;
+
+	this.history.push(true);
+}

package/src/core/event/handlers/handler_ww_key.js

@@ -0,0 +1,228 @@
+import { dom, env, unicode, keyCodeMap } from '../../../helper';
+import { actionExecutor } from '../executor';
+import { makePorts } from '../ports';
+import { reduceKeydown } from '../reducers/keydown.reducer';
+
+const { _w } = env;
+const FRONT_ZEROWIDTH = new RegExp(unicode.zeroWidthSpace + '+', '');
+
+const keyState = {
+	ctrl: false,
+	alt: false
+};
+const _styleNodes = Object.preventExtensions({ value: [] });
+
+/**
+ * @typedef {Omit<import('../eventManager').default & Partial<__se__EditorInjector>, 'eventManager'>} EventManagerThis_handler_ww_key_input
+ */
+
+/**
+ * @private
+ * @this {EventManagerThis_handler_ww_key_input}
+ * @param {__se__FrameContext} fc - Frame context object
+ * @param {KeyboardEvent} e - Event object
+ */
+export async function OnKeyDown_wysiwyg(fc, e) {
+	if ((this.isComposing = keyCodeMap.isComposing(e))) return true;
+	if (this.editor.selectMenuOn || !e.isTrusted) return;
+
+	let selectionNode = this.selection.getNode();
+	if (dom.check.isInputElement(selectionNode)) return;
+	if (this.menu.currentDropdownName) return;
+
+	const keyCode = e.code;
+	const shift = keyCodeMap.isShift(e);
+	const ctrl = (keyState.ctrl = keyCodeMap.isCtrl(e));
+	const alt = (keyState.alt = keyCodeMap.isAlt(e));
+
+	if (!ctrl && fc.get('isReadOnly') && !keyCodeMap.isDirectionKey(keyCode)) {
+		e.preventDefault();
+		return false;
+	}
+
+	this.menu.dropdownOff();
+
+	if (this.editor.isBalloon) {
+		this._hideToolbar();
+	} else if (this.editor.isSubBalloon) {
+		this._hideToolbar_sub();
+	}
+
+	// user event
+	if ((await this.triggerEvent('onKeyDown', { frameContext: fc, event: e })) === false) return;
+
+	/** default key action */
+	if (keyCodeMap.isEnter(keyCode) && this.format.isLine(this.selection.getRange()?.startContainer)) {
+		this.selection._resetRangeToTextNode();
+		selectionNode = this.selection.getNode();
+	}
+
+	const range = this.selection.getRange();
+	const formatEl = /** @type {HTMLElement} */ (this.format.getLine(selectionNode, null) || selectionNode);
+
+	/** Shortcuts */
+	if (ctrl && !keyCodeMap.isNonTextKey(keyCode) && this.shortcuts.command(e, ctrl, shift, keyCode, '', false, null, null)) {
+		this._onShortcutKey = true;
+		e.preventDefault();
+		e.stopPropagation();
+		return false;
+	} else if (!ctrl && !keyCodeMap.isNonTextKey(keyCode) && this.format.isLine(formatEl) && range.collapsed && dom.check.isEdgePoint(range.startContainer, 0, 'front')) {
+		const keyword = /** @type {Text} */ (range.startContainer).substringData?.(0, range.startOffset);
+		if (keyword && this.shortcuts.command(e, false, shift, keyCode, keyword, true, formatEl, range)) {
+			this._onShortcutKey = true;
+			e.preventDefault();
+			e.stopPropagation();
+			return false;
+		}
+	} else if (this._onShortcutKey) {
+		this._onShortcutKey = false;
+	}
+
+	// plugin event
+	if (this._callPluginEvent('onKeyDown', { frameContext: fc, event: e, range, line: formatEl }) === false) return;
+
+	// reducer / actions
+	/** @type {__se__EventKeydownCtx} */
+	const ctx = { e, fc, status: this.status, options: this.options, frameOptions: this.frameOptions, range, selectionNode, formatEl, keyCode, ctrl, alt, shift };
+	const ports = makePorts(this, { _styleNodes });
+
+	// action execute
+	const actions = await reduceKeydown(ports, ctx);
+	await actionExecutor(actions, { ports, ctx });
+}
+
+/**
+ * @private
+ * @this {EventManagerThis_handler_ww_key_input}
+ * @param {__se__FrameContext} fc - Frame context object
+ * @param {KeyboardEvent} e - Event object
+ */
+export async function OnKeyUp_wysiwyg(fc, e) {
+	if (this._onShortcutKey || this.menu.currentDropdownName) return;
+
+	const keyCode = e.code;
+	const ctrl = keyCodeMap.isCtrl(e);
+	const alt = keyCodeMap.isAlt(e);
+
+	if (ctrl) keyState.ctrl = false;
+	if (alt) keyState.alt = false;
+
+	if (fc.get('isReadOnly')) return;
+
+	const range = this.selection.getRange();
+	let selectionNode = this.selection.getNode();
+
+	if ((this.editor.isBalloon || this.editor.isSubBalloon) && (((this.editor.isBalloonAlways || this.editor.isSubBalloonAlways) && !keyCodeMap.isEsc(keyCode)) || !range.collapsed)) {
+		if (this.editor.isBalloonAlways || this.editor.isSubBalloonAlways) {
+			if (!keyCodeMap.isEsc(keyCode)) this._showToolbarBalloonDelay();
+		} else {
+			if (this.editor.isSubBalloon) this.subToolbar._showBalloon();
+			else this.toolbar._showBalloon();
+			return;
+		}
+	}
+
+	/** when format tag deleted */
+	if (keyCodeMap.isBackspace(keyCode) && dom.check.isWysiwygFrame(selectionNode) && selectionNode.textContent === '' && selectionNode.children.length === 0) {
+		e.preventDefault();
+		e.stopPropagation();
+
+		selectionNode.innerHTML = '';
+
+		const oFormatTag = dom.utils.createElement(this.format.isLine(this.status.currentNodes[0]) && !dom.check.isListCell(this.status.currentNodes[0]) ? this.status.currentNodes[0] : this.options.get('defaultLine'), null, '<br>');
+		selectionNode.appendChild(oFormatTag);
+		this.selection.setRange(oFormatTag, 0, oFormatTag, 0);
+		this.applyTagEffect();
+
+		this.history.push(false);
+
+		// document type
+		if (fc.has('documentType_use_header')) {
+			if (keyCodeMap.isDocumentTypeObserverKey(keyCode)) {
+				fc.get('documentType').reHeader();
+			}
+		}
+
+		return;
+	}
+
+	const formatEl = this.format.getLine(selectionNode, null);
+	const rangeEl = this.format.getBlock(selectionNode, null);
+	const attrs = this._formatAttrsTemp;
+
+	if (formatEl && attrs) {
+		for (let i = 0, len = attrs.length; i < len; i++) {
+			if (keyCodeMap.isEnter(keyCode) && /^id$/i.test(attrs[i].name)) {
+				formatEl.removeAttribute('id');
+				continue;
+			}
+			formatEl.setAttribute(attrs[i].name, attrs[i].value);
+		}
+		this._formatAttrsTemp = null;
+	}
+
+	if (
+		!this.format.isNormalLine(formatEl) &&
+		!this.format.isBrLine(formatEl) &&
+		range.collapsed &&
+		!this.component.is(selectionNode) &&
+		!dom.check.isList(selectionNode) &&
+		this._setDefaultLine(this.format.isBlock(rangeEl) ? 'DIV' : this.options.get('defaultLine')) !== null
+	) {
+		selectionNode = this.selection.getNode();
+	}
+
+	const textKey = !keyState.ctrl && !keyState.alt && !keyCodeMap.isNonTextKey(keyCode);
+	if (textKey && selectionNode.nodeType === 3 && unicode.zeroWidthRegExp.test(selectionNode.textContent) && !(e.isComposing !== undefined ? e.isComposing : this.isComposing)) {
+		let so = range.startOffset,
+			eo = range.endOffset;
+		const frontZeroWidthCnt = (selectionNode.textContent.substring(0, eo).match(FRONT_ZEROWIDTH) || '').length;
+		so = range.startOffset - frontZeroWidthCnt;
+		eo = range.endOffset - frontZeroWidthCnt;
+		selectionNode.textContent = selectionNode.textContent.replace(unicode.zeroWidthRegExp, '');
+		this.selection.setRange(selectionNode, so < 0 ? 0 : so, selectionNode, eo < 0 ? 0 : eo);
+	}
+
+	if (keyCodeMap.isRemoveKey(keyCode) && dom.check.isZeroWidth(formatEl?.textContent) && !formatEl.previousElementSibling && !dom.check.isListCell(formatEl)) {
+		const rsMode = this.options.get('retainStyleMode');
+		if (rsMode !== 'none' && _styleNodes.value?.length > 0) {
+			if (rsMode === 'repeat') {
+				if (this.__retainTimer) {
+					this.__retainTimer = _w.clearTimeout(this.__retainTimer);
+					this._clearRetainStyleNodes(formatEl);
+				} else {
+					this.__retainTimer = _w.setTimeout(() => {
+						this.__retainTimer = null;
+					}, 0);
+					this._retainStyleNodes(formatEl, _styleNodes.value);
+				}
+			} else {
+				this.__retainTimer = null;
+				this._retainStyleNodes(formatEl, _styleNodes.value);
+			}
+		} else {
+			this._clearRetainStyleNodes(formatEl);
+		}
+	}
+
+	// document type
+	if (fc.has('documentType_use_header')) {
+		if (keyCodeMap.isDocumentTypeObserverKey(keyCode)) {
+			fc.get('documentType').reHeader();
+			const el = dom.query.getParentElement(this.selection.selectionNode, this.format.isLine.bind(this.format));
+			fc.get('documentType').on(el);
+		} else {
+			const el = dom.query.getParentElement(selectionNode, (current) => current.nodeType === 1);
+			fc.get('documentType').onChangeText(el);
+		}
+	}
+
+	// user event
+	if ((await this.triggerEvent('onKeyUp', { frameContext: fc, event: e })) === false) return;
+	// plugin event
+	if (this._callPluginEvent('onKeyUp', { frameContext: fc, event: e, range, line: formatEl }) === false) return;
+
+	if (keyCodeMap.isHistoryRelevantKey(keyCode)) {
+		this.history.push(true);
+	}
+}

package/src/core/{base/eventHandlers → event/handlers}/handler_ww_mouse.js

@@ -48,7 +48,7 @@ export async function OnMouseDown_wysiwyg(fc, e) {
 		this._hideToolbar_sub();
 	}
 
-	if (/FIGURE/i.test(eventTarget.nodeName)) e.preventDefault();
+	if (/FIGURE/i.test(eventTarget?.nodeName)) e.preventDefault();
 }
 
 /**
@@ -136,10 +136,10 @@ export async function OnClick_wysiwyg(fc, e) {
 			const _styleNode = [...this.editor._onCopyFormatInfo];
 			const n = _styleNode.pop();
 
-			this.format.removeInlineElement();
+			this.inline.remove();
 
 			if (n) {
-				const insertedNode = this.format.applyInlineElement(n, { stylesToModify: null, nodesToRemove: [n.nodeName], strictRemove: false });
+				const insertedNode = this.inline.apply(n, { stylesToModify: null, nodesToRemove: [n.nodeName], strictRemove: false });
 				const { parent, inner } = this.nodeTransform.createNestedNode(_styleNode);
 				insertedNode.parentNode.insertBefore(parent, insertedNode);
 				inner.appendChild(insertedNode);

package/src/core/event/ports.js

@@ -0,0 +1,211 @@
+import { isMobile } from '../../helper/env';
+
+/**
+ * @typedef {import('./eventManager').EventManagerThis} EventManagerInstanceType
+ */
+
+/**
+ * @typedef {import('../class/selection').default} Selection
+ * @typedef {import('../class/format').default} Format
+ * @typedef {import('../class/listFormat').default} ListFormat
+ * @typedef {import('../class/component').default} Component
+ * @typedef {import('../class/html').default} Html
+ * @typedef {import('../class/nodeTransform').default} NodeTransform
+ * @typedef {import('../class/char').default} Char
+ * @typedef {import('../class/menu').default} Menu
+ */
+
+/**
+ * @typedef {Object} SelectionPorts
+ * @property {(...args: Parameters<Selection['getRange']>) => ReturnType<Selection['getRange']>} getRange
+ * @property {(...args: Parameters<Selection['getNode']>) => ReturnType<Selection['getNode']>} getNode
+ * @property {(...args: Parameters<Selection['setRange']>) => ReturnType<Selection['setRange']>} setRange
+ * @property {(...args: Parameters<Selection['get']>) => ReturnType<Selection['get']>} get
+ */
+
+/**
+ * @typedef {Object} FormatPorts
+ * @property {(...args: Parameters<Format['isLine']>) => ReturnType<Format['isLine']>} isLine
+ * @property {(...args: Parameters<Format['getLine']>) => ReturnType<Format['getLine']>} getLine
+ * @property {(...args: Parameters<Format['getLines']>) => ReturnType<Format['getLines']>} getLines
+ * @property {(...args: Parameters<Format['getBrLine']>) => ReturnType<Format['getBrLine']>} getBrLine
+ * @property {(...args: Parameters<Format['getBlock']>) => ReturnType<Format['getBlock']>} getBlock
+ * @property {(...args: Parameters<Format['isNormalLine']>) => ReturnType<Format['isNormalLine']>} isNormalLine
+ * @property {(...args: Parameters<Format['isBrLine']>) => ReturnType<Format['isBrLine']>} isBrLine
+ * @property {(...args: Parameters<Format['isClosureBrLine']>) => ReturnType<Format['isClosureBrLine']>} isClosureBrLine
+ * @property {(...args: Parameters<Format['isClosureBlock']>) => ReturnType<Format['isClosureBlock']>} isClosureBlock
+ * @property {(...args: Parameters<Format['isEdgeLine']>) => ReturnType<Format['isEdgeLine']>} isEdgeLine
+ * @property {(...args: Parameters<Format['removeBlock']>) => ReturnType<Format['removeBlock']>} removeBlock
+ * @property {(...args: Parameters<Format['addLine']>) => ReturnType<Format['addLine']>} addLine
+ */
+
+/**
+ * @typedef {Object} ListFormatPorts
+ * @property {(...args: Parameters<ListFormat['applyNested']>) => ReturnType<ListFormat['applyNested']>} applyNested
+ */
+
+/**
+ * @typedef {Object} ComponentPorts
+ * @property {(...args: Parameters<Component['deselect']>) => ReturnType<Component['deselect']>} deselect
+ * @property {(...args: Parameters<Component['is']>) => ReturnType<Component['is']>} is
+ * @property {(...args: Parameters<Component['get']>) => ReturnType<Component['get']>} get
+ * @property {(...args: Parameters<Component['select']>) => ReturnType<Component['select']>} select
+ */
+
+/**
+ * @typedef {Object} HtmlPorts
+ * @property {(...args: Parameters<Html['remove']>) => ReturnType<Html['remove']>} remove
+ * @property {(...args: Parameters<Html['insert']>) => ReturnType<Html['insert']>} insert
+ * @property {(...args: Parameters<Html['insertNode']>) => ReturnType<Html['insertNode']>} insertNode
+ */
+
+/**
+ * @typedef {Object} NodeTransformPorts
+ * @property {(...args: Parameters<NodeTransform['removeAllParents']>) => ReturnType<NodeTransform['removeAllParents']>} removeAllParents
+ * @property {(...args: Parameters<NodeTransform['split']>) => ReturnType<NodeTransform['split']>} split
+ */
+
+/**
+ * @typedef {Object} CharPorts
+ * @property {(...args: Parameters<Char['check']>) => ReturnType<Char['check']>} check
+ */
+
+/**
+ * @typedef {Object} MenuPorts
+ * @property {(...args: Parameters<Menu['dropdownOff']>) => ReturnType<Menu['dropdownOff']>} dropdownOff
+ */
+
+/**
+ * @description Create ports for event reducers
+ * @param {EventManagerInstanceType} inst - EventManager instance
+ * @param {Object} param1 - Additional parameters
+ * @param {*} param1._styleNodes - Style nodes reference object
+ */
+export function makePorts(inst, { _styleNodes }) {
+	const { selection, format, listFormat, component, html, nodeTransform, history, char, menu } = inst;
+
+	return {
+		// editor
+		editor: {
+			_nativeFocus: () => inst.editor._nativeFocus(),
+			blur: () => inst.editor.blur()
+		},
+
+		// === class ===
+		selection: {
+			getRange: () => selection.getRange(),
+			getNode: () => selection.getNode(),
+			setRange: (se, so, ec, eo) => selection.setRange(se, so, ec, eo),
+			get: () => selection.get()
+		},
+
+		format: {
+			isLine: (n) => format.isLine(n),
+			getLine: (n, p) => format.getLine(n, p),
+			getLines: (v) => format.getLines(v),
+			getBrLine: (n, p) => format.getBrLine(n, p),
+			getBlock: (n, p) => format.getBlock(n, p),
+			isNormalLine: (n) => format.isNormalLine(n),
+			isBrLine: (n) => format.isBrLine(n),
+			isClosureBrLine: (n) => format.isClosureBrLine(n),
+			isClosureBlock: (n) => format.isClosureBlock(n),
+			isEdgeLine: (node, offset, dir) => format.isEdgeLine(node, offset, dir),
+			removeBlock: (n, p) => format.removeBlock(n, p),
+			addLine: (el, nextOrTag) => format.addLine(el, nextOrTag)
+		},
+
+		listFormat: {
+			applyNested: (cells, shift) => listFormat.applyNested(cells, shift)
+		},
+
+		component: {
+			deselect: () => component.deselect(),
+			is: (n) => component.is(n),
+			get: (n) => component.get(n),
+			select: (t, p) => component.select(t, p)
+		},
+
+		html: {
+			remove: () => html.remove(),
+			insert: (h, p) => html.insert(h, p),
+			insertNode: (n, p) => html.insertNode(n, p)
+		},
+
+		history: {
+			push: (hard) => history.push(!!hard)
+		},
+
+		nodeTransform: {
+			removeAllParents: (s, n, p) => nodeTransform.removeAllParents(s, n, p),
+			split: (n, o, d) => nodeTransform.split(n, o, d)
+		},
+
+		char: {
+			check: (content) => char.check(content)
+		},
+
+		menu: {
+			dropdownOff: () => menu.dropdownOff()
+		},
+
+		// === inst(eventManager) commands ===
+		setDefaultLine: (tag) => inst._setDefaultLine(tag),
+		hideToolbar: () => inst._hideToolbar(),
+		hideToolbar_sub: () => inst._hideToolbar_sub(),
+		styleNodeCache: () => (_styleNodes.value = inst.__cacheStyleNodes),
+		formatAttrsTempCache: (attrs) => (inst._formatAttrsTemp = attrs),
+		setOnShortcutKey: (v) => (inst._onShortcutKey = v),
+
+		// === enter event specific ===
+		/**
+		 * @description Scrolls the editor view to the caret position after pressing Enter. (Ignored on mobile devices)
+		 * @param {Range} range Range object
+		 */
+		enterScrollTo(range) {
+			inst.editor._iframeAutoHeight(inst.frameContext);
+
+			// scroll to
+			if (isMobile && inst.scrollparents.length > 0) return;
+			inst.selection.scrollTo(range, { behavior: 'auto', block: 'nearest', inline: 'nearest' });
+		},
+		/**
+		 * @description Prevents the default behavior of the Enter key and refocuses the editor.
+		 * @param {Event} e The keyboard event
+		 */
+		enterPrevent(e) {
+			e.preventDefault();
+			if (!isMobile) return;
+
+			inst.__focusTemp.focus({ preventScroll: true });
+			inst.frameContext.get('wysiwyg').focus({ preventScroll: true });
+		}
+	};
+}
+
+/**
+ * @typedef {Object} EventReducerPorts
+ *
+ * @property {Object} editor
+ * @property {() => void} editor._nativeFocus
+ * @property {() => void} editor.blur
+ * @property {SelectionPorts} selection
+ * @property {FormatPorts} format
+ * @property {ListFormatPorts} listFormat
+ * @property {ComponentPorts} component
+ * @property {HtmlPorts} html
+ * @property {Object} history
+ * @property {(hard: boolean) => void} history.push
+ * @property {NodeTransformPorts} nodeTransform
+ * @property {CharPorts} char
+ * @property {MenuPorts} menu
+ *
+ * @property {(tag: string) => void} setDefaultLine
+ * @property {() => void} hideToolbar
+ * @property {() => void} hideToolbar_sub
+ * @property {() => void} styleNodeCache
+ * @property {(attrs: Object<string, *>) => void} formatAttrsTempCache
+ * @property {(v: boolean) => void} setOnShortcutKey
+ *
+ * @property {(e: Event) => void} enterPrevent
+ * @property {(range: Range) => void} enterScrollTo
+ */