suneditor 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/core/class/component.js

@@ -3,39 +3,85 @@
  */
 
 import CoreInjector from '../../editorInjector/_core';
-import { domUtils, env, numbers, unicode } from '../../helper';
+import { dom, env, numbers, unicode, keyCodeMap, converter } from '../../helper';
 import { Figure, _DragHandle } from '../../modules';
 
 const { _w, ON_OVER_COMPONENT, isMobile } = env;
 const DIR_KEYCODE = /^(3[7-9]|40)$/;
 const DIR_UP_KEYCODE = /^3[7-8]$/;
 
-const Component = function (editor) {
+/**
+ * @typedef {Omit<Component & Partial<__se__EditorInjector>, 'component'>} ComponentThis
+ */
+
+/**
+ * @constructor
+ * @this {ComponentThis}
+ * @description Class for managing components such as images and tables that are not in line format
+ * @param {__se__EditorCore} editor - The root editor instance
+ */
+function Component(editor) {
 	CoreInjector.call(this, editor);
 
-	// members
+	/**
+	 * @description The current component information, used copy, cut, and keydown events
+	 * @type {__se__ComponentInfo}
+	 */
 	this.info = null;
+
+	/**
+	 * @description Component is selected
+	 * @type {boolean}
+	 */
 	this.isSelected = false;
+
+	/**
+	 * @description Currently selected component target
+	 * @type {Node|null}
+	 */
 	this.currentTarget = null;
+
+	/**
+	 * @description Currently selected component plugin instance
+	 * @type {*}
+	 */
 	this.currentPlugin = null;
+
+	/**
+	 * @description Currently selected component plugin name
+	 * @type {*}
+	 */
 	this.currentPluginName = '';
+
+	/**
+	 * @description Currently selected component information
+	 * @type {__se__ComponentInfo|null}
+	 */
 	this.currentInfo = null;
+
+	/** @type {Object<string, (...args: *) => *>} */
 	this.__globalEvents = {
 		copy: OnCopy_component.bind(this),
 		cut: OnCut_component.bind(this),
 		keydown: OnKeyDown_component.bind(this),
 		mousedown: CloseListener_mousedown.bind(this)
 	};
+	/** @type {__se__GlobalEventInfo|void} */
 	this._bindClose_copy = null;
+	/** @type {__se__GlobalEventInfo|void} */
 	this._bindClose_cut = null;
+	/** @type {__se__GlobalEventInfo|void} */
 	this._bindClose_keydown = null;
+	/** @type {__se__GlobalEventInfo|void} */
 	this._bindClose_mousedown = null;
+	/** @type {__se__GlobalEventInfo|void} */
 	this._bindClose_touchstart = null;
+	/** @type {boolean} */
 	this.__selectionSelected = false;
 
 	this.editor.applyFrameRoots((e) => {
 		// drag
-		const dragHandle = domUtils.createElement('DIV', { class: 'se-drag-handle', draggable: 'true' }, this.icons.selection);
+		const dragHandle = dom.utils.createElement('DIV', { class: 'se-drag-handle', draggable: 'true' }, this.icons.selection);
 		e.get('wrapper').appendChild(dragHandle);
 		this.eventManager.addEvent(dragHandle, 'mouseenter', OnDragEnter.bind(this));
 		this.eventManager.addEvent(dragHandle, 'mouseleave', OnDragLeave.bind(this));
@@ -43,19 +89,22 @@ const Component = function (editor) {
 		this.eventManager.addEvent(dragHandle, 'dragend', OnDragEnd.bind(this));
 		this.eventManager.addEvent(dragHandle, 'click', OnDragClick.bind(this));
 	});
-};
+}
 
 Component.prototype = {
 	/**
-	 * @description The method to insert a element and return. (used elements : table, hr, image, video)
-	 * If "element" is "HR", insert and return the new line.
-	 * @param {Element} element Element to be inserted
-	 * @param {boolean} notCheckCharCount If true, it will be inserted even if "frameOptions.get('charCounter_max')" is exceeded.
-	 * @param {boolean} notSelect If true, Do not automatically select the inserted component.
-	 * @returns {Element}
+	 * @this {ComponentThis}
+	 * @description Inserts an element and returns it. (Used for elements: table, hr, image, video)
+	 * - If "element" is "HR", inserts and returns the new line.
+	 * @param {Node} element Element to be inserted
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.skipCharCount=false] If true, it will be inserted even if "frameOptions.get('charCounter_max')" is exceeded.
+	 * @param {boolean} [options.skipSelection=false] If true, do not automatically select the inserted component.
+	 * @param {boolean} [options.skipHistory=false] If true, do not push to history.
+	 * @returns {HTMLElement} The inserted element or new line (for HR)
 	 */
-	insert(element, notCheckCharCount, notSelect) {
-		if (this.editor.frameContext.get('isReadOnly') || (!notCheckCharCount && !this.char.check(element))) {
+	insert(element, { skipCharCount, skipSelection, skipHistory } = {}) {
+		if (this.editor.frameContext.get('isReadOnly') || (!skipCharCount && !this.char.check(element))) {
 			return null;
 		}
 
@@ -66,45 +115,51 @@ Component.prototype = {
 		let oNode = null;
 		let formatEl = this.format.getLine(selectionNode, null);
 
-		if (domUtils.isListCell(formatEl)) {
-			this.html.insertNode(element, isInline ? null : selectionNode === formatEl ? null : r.container.nextSibling, true);
-			if (!isInline && !element.nextSibling) element.parentNode.appendChild(domUtils.createElement('BR'));
+		if (dom.check.isListCell(formatEl)) {
+			this.html.insertNode(element, { afterNode: isInline ? null : selectionNode === formatEl ? null : r.container.nextSibling, skipCharCount: true });
+			if (!isInline && !element.nextSibling) element.parentNode.appendChild(dom.utils.createElement('BR'));
 		} else {
-			if (this.selection.getRange().collapsed && (r.container.nodeType === 3 || domUtils.isBreak(r.container))) {
-				const depthFormat = domUtils.getParentElement(r.container, this.format.isBlock.bind(this.format));
-				oNode = this.nodeTransform.split(r.container, r.offset, !depthFormat ? 0 : domUtils.getNodeDepth(depthFormat) + 1);
-				if (oNode) formatEl = oNode.previousSibling;
+			if (!isInline && this.selection.getRange().collapsed && (r.container.nodeType === 3 || dom.check.isBreak(r.container))) {
+				const depthFormat = dom.query.getParentElement(r.container, this.format.isBlock.bind(this.format));
+				oNode = this.nodeTransform.split(r.container, r.offset, !depthFormat ? 0 : dom.query.getNodeDepth(depthFormat) + 1);
+				if (oNode) formatEl = /** @type {HTMLElement} */ (oNode.previousSibling);
 			}
-			this.html.insertNode(element, isInline ? null : this.format.isBlock(formatEl) ? null : formatEl, true);
-			if (!isInline && formatEl && domUtils.isZeroWith(formatEl)) domUtils.removeItem(formatEl);
+			this.html.insertNode(element, { afterNode: isInline ? null : this.format.isBlock(formatEl) ? null : formatEl, skipCharCount: true });
+			if (!isInline && formatEl && dom.check.isZeroWidth(formatEl)) dom.utils.removeItem(formatEl);
 		}
 
 		if (isInline) {
-			const empty = domUtils.createTextNode(unicode.zeroWidthSpace);
+			const empty = dom.utils.createTextNode(unicode.zeroWidthSpace);
 			element.parentNode.insertBefore(empty, element.nextSibling);
 		}
 
-		this.history.push(false);
+		if (!skipHistory) this.history.push(false);
 
-		if (!notSelect) {
+		if (!skipSelection) {
 			this.selection.setRange(element, 0, element, 0);
 			const fileComponentInfo = this.get(element);
 			if (fileComponentInfo) {
 				this.select(fileComponentInfo.target, fileComponentInfo.pluginName);
 			} else if (oNode) {
-				oNode = domUtils.getEdgeChildNodes(oNode, null).sc || oNode;
+				oNode = dom.query.getEdgeChildNodes(oNode, null).sc || oNode;
 				this.selection.setRange(oNode, 0, oNode, 0);
 			}
 		}
 
-		return oNode || element;
+		// document type
+		if (this.editor.frameContext.has('documentType-use-header')) {
+			this.editor.frameContext.get('documentType').reHeader();
+		}
+
+		return /** @type {HTMLElement} */ (oNode || element);
 	},
 
 	/**
+	 * @this {ComponentThis}
 	 * @description Gets the file component and that plugin name
-	 * return: {target, component, pluginName} | null
-	 * @param {Element} element Target element (figure tag, component div, file tag)
-	 * @returns {Object|null}
+	 * - return: {target, component, pluginName} | null
+	 * @param {Node} element Target element (figure tag, component div, file tag)
+	 * @returns {__se__ComponentInfo|null}
 	 */
 	get(element) {
 		if (!element) return null;
@@ -113,10 +168,11 @@ Component.prototype = {
 		let pluginName = '';
 		let options = {};
 		let isFile = false;
+		let launcher = null;
 
 		if (this.is(element)) {
-			if (domUtils.hasClass(element, 'se-component') && !domUtils.hasClass(element, 'se-inline-component')) element = element.firstElementChild || element;
-			if (/^FIGURE$/i.test(element.nodeName)) element = element.firstElementChild;
+			if (dom.utils.hasClass(element, 'se-component') && !dom.utils.hasClass(element, 'se-inline-component')) element = /** @type {HTMLElement} */ (element).firstElementChild || element;
+			if (/^FIGURE$/i.test(element.nodeName)) element = /** @type {HTMLElement} */ (element).firstElementChild;
 			if (!element) return null;
 
 			const comp = this.editor._componentManager.map((f) => f(element)).find((e) => e);
@@ -124,6 +180,7 @@ Component.prototype = {
 			target = comp.target;
 			pluginName = comp.pluginName;
 			options = comp.options;
+			launcher = comp.launcher;
 		}
 
 		if (!target && element.nodeName) {
@@ -135,6 +192,7 @@ Component.prototype = {
 			target = comp.target;
 			pluginName = comp.pluginName;
 			options = comp.options;
+			launcher = comp.launcher;
 		}
 
 		if (!target) {
@@ -142,31 +200,40 @@ Component.prototype = {
 		}
 
 		const figureInfo = Figure.GetContainer(target);
+		const container = figureInfo.container || figureInfo.cover || target;
 		return (this.info = {
 			target,
 			pluginName,
 			options,
-			container: figureInfo.container || figureInfo.cover || target,
+			container: container,
 			cover: figureInfo.cover,
+			inlineCover: figureInfo.inlineCover,
 			caption: figureInfo.caption,
-			isFile: isFile
+			isFile,
+			launcher,
+			isInputType: dom.utils.hasClass(container, 'se-input-component')
 		});
 	},
 
 	/**
-	 * @description The component(image, video) is selected and the resizing module is called.
-	 * @param {Element} element Element tag (img, iframe, video)
-	 * @param {string} pluginName Plugin name (image, video)
+	 * @this {ComponentThis}
+	 * @description The component(media, file component, table, etc) is selected and the resizing module is called.
+	 * @param {Node} element Target element
+	 * @param {string} pluginName The plugin name for the selected target.
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.isInput=false] Whether the target is an input component.(table)
 	 */
-	select(element, pluginName, isInput) {
+	select(element, pluginName, { isInput = false } = {}) {
 		const info = this.get(element);
-		if (!info || domUtils.isUneditable(domUtils.getParentElement(element, this.is.bind(this))) || domUtils.isUneditable(element)) return false;
+		if (!info || dom.check.isUneditable(dom.query.getParentElement(element, this.is.bind(this))) || dom.check.isUneditable(element)) return false;
 
-		const plugin = this.plugins[pluginName];
+		const plugin = info.launcher || this.plugins[pluginName];
 		if (!plugin) return;
 
 		if (!isInput && _DragHandle.get('__overInfo') !== ON_OVER_COMPONENT) {
-			this.editor._antiBlur = true;
+			if (this.editor.status._onMousedown) return;
+
+			this.editor._preventBlur = true;
 			this.__selectionSelected = true;
 			if (this.isInline(info.container)) {
 				this.selection.setRange(info.container, 0, info.container, 0);
@@ -182,7 +249,8 @@ Component.prototype = {
 		let isNonFigureComponent;
 		if (typeof plugin.select === 'function') isNonFigureComponent = plugin.select(element);
 
-		if (!isNonFigureComponent && !domUtils.hasClass(info.container, 'se-inline-component')) this._setComponentLineBreaker(info.container || info.cover || element);
+		const isBreakComponent = dom.utils.hasClass(info.target, 'se-component-line-break');
+		if (isBreakComponent || (!isNonFigureComponent && !dom.utils.hasClass(info.container, 'se-inline-component'))) this._setComponentLineBreaker(/** @type {HTMLElement} */ (info.container || info.cover || element));
 
 		this.currentTarget = element;
 		this.currentPlugin = plugin;
@@ -197,31 +265,32 @@ Component.prototype = {
 			if (__overInfo !== ON_OVER_COMPONENT) this.__addGlobalEvent();
 			if (!info.isFile) this.__addNotFileGlobalEvent();
 		}, 0);
-		domUtils.addClass(info.container, 'se-component-selected');
 
-		if (__overInfo !== ON_OVER_COMPONENT) {
-			domUtils.setDisabled(this.editor._controllerOnDisabledButtons, true);
+		converter.debounce(() => {
+			dom.utils.addClass(info.container, 'se-component-selected');
+		}, 0)();
 
+		if (!isBreakComponent && __overInfo !== ON_OVER_COMPONENT) {
 			// set zero width space
 			if (!this.isInline(info.container)) return;
 
 			const oNode = info.container;
 			let zeroWidth = null;
-			if (!oNode.previousSibling || domUtils.isBreak(oNode.previousSibling)) {
-				zeroWidth = domUtils.createTextNode(unicode.zeroWidthSpace);
+			if (!oNode.previousSibling || dom.check.isBreak(oNode.previousSibling)) {
+				zeroWidth = dom.utils.createTextNode(unicode.zeroWidthSpace);
 				oNode.parentNode.insertBefore(zeroWidth, oNode);
 			}
 
-			if (!oNode.nextSibling || domUtils.isBreak(oNode.nextSibling)) {
-				zeroWidth = domUtils.createTextNode(unicode.zeroWidthSpace);
+			if (!oNode.nextSibling || dom.check.isBreak(oNode.nextSibling)) {
+				zeroWidth = dom.utils.createTextNode(unicode.zeroWidthSpace);
 				oNode.parentNode.insertBefore(zeroWidth, oNode.nextSibling);
 			}
 
-			this.editor.status.componentSelected = true;
-		} else if (!domUtils.hasClass(info.container, 'se-input-component')) {
+			this.editor.status.onSelected = true;
+		} else if (isBreakComponent || !dom.utils.hasClass(info.container, 'se-input-component')) {
 			const dragHandle = this.editor.frameContext.get('wrapper').querySelector('.se-drag-handle');
-			domUtils.addClass(dragHandle, 'se-drag-handle-full');
-			this.editor._visibleControllers(false, false);
+			dom.utils.addClass(dragHandle, 'se-drag-handle-full');
+			this.ui._visibleControllers(false, false);
 
 			const sizeTarget = info.caption ? info.target : info.cover || info.container || info.target;
 			const w = sizeTarget.offsetWidth;
@@ -242,32 +311,40 @@ Component.prototype = {
 		}
 	},
 
+	/**
+	 * @this {ComponentThis}
+	 * @description Deselects the selected component.
+	 */
 	deselect() {
-		this.editor.status.componentSelected = false;
+		_w.setTimeout(() => {
+			this.editor.status.onSelected = false;
+		}, 0);
 		this.__deselect();
-		domUtils.setDisabled(this.editor._controllerOnDisabledButtons, false);
+		this.ui.setControllerOnDisabledButtons(false);
 	},
 
 	/**
+	 * @this {ComponentThis}
 	 * @description Determines if the specified node is a block component (e.g., img, iframe, video, audio, table) with the class "se-component"
-	 * or a direct FIGURE node. This function checks if the node itself is a component
-	 * or if it belongs to any components identified by the component manager.
+	 * - or a direct FIGURE node. This function checks if the node itself is a component
+	 * - or if it belongs to any components identified by the component manager.
 	 * @param {Node} element The DOM node to check.
 	 * @returns {boolean} True if the node is a block component or part of it, otherwise false.
 	 */
 	is(element) {
 		if (!element) return false;
 
-		if (/^FIGURE$/i.test(element.nodeName) || domUtils.hasClass(element, 'se-component')) return true;
+		if (/^FIGURE$/i.test(element.nodeName) || dom.utils.hasClass(element, 'se-component')) return true;
 		if (this.editor._componentManager.find((f) => f(element))) return true;
 
 		return false;
 	},
 
 	/**
+	 * @this {ComponentThis}
 	 * @description Checks if the given node is an inline component (class "se-inline-component").
-	 * If the node is a FIGURE, it checks the parent element instead.
-	 * It also verifies whether the node is part of an inline component recognized by the component manager.
+	 * - If the node is a FIGURE, it checks the parent element instead.
+	 * - It also verifies whether the node is part of an inline component recognized by the component manager.
 	 * @param {Node} element The DOM node to check.
 	 * @returns {boolean} True if the node is an inline component or part of it, otherwise false.
 	 */
@@ -275,18 +352,19 @@ Component.prototype = {
 		if (!element) return false;
 
 		if (/^FIGURE$/i.test(element.nodeName)) element = element.parentElement;
-		if (domUtils.hasClass(element, 'se-inline-component')) return true;
+		if (dom.utils.hasClass(element, 'se-inline-component')) return true;
 
 		const container = this.editor._componentManager.find((f) => f(element));
-		if (container && domUtils.hasClass(element, 'se-inline-component')) return true;
+		if (container && dom.utils.hasClass(element, 'se-inline-component')) return true;
 
 		return false;
 	},
 
 	/**
+	 * @this {ComponentThis}
 	 * @description Checks if the specified node qualifies as a basic component within the editor.
-	 * This function verifies whether the node is recognized as a component by the `is` function, while also ensuring that it is not an inline component as determined by the `isInline` function.
-	 * This is used to identify block-level elements or standalone components that are not part of the inline component classification.
+	 * - This function verifies whether the node is recognized as a component by the `is` function, while also ensuring that it is not an inline component as determined by the `isInline` function.
+	 * - This is used to identify block-level elements or standalone components that are not part of the inline component classification.
 	 * @param {Node} element The DOM node to check.
 	 * @returns {boolean} True if the node is a basic (non-inline) component, otherwise false.
 	 */
@@ -294,17 +372,60 @@ Component.prototype = {
 		return this.is(element) && !this.isInline(element);
 	},
 
+	/**
+	 * @this {ComponentThis}
+	 * @description Copies the specified component node to the clipboard.
+	 * - This function is different from the one called when the user presses the "Ctrl + C" key combination.
+	 * @param {Node} container The DOM node to check.
+	 */
+	copy(container) {
+		const cloneContainer = /** @type {HTMLElement} */ (dom.utils.clone(container, true));
+
+		// remove selected class
+		dom.utils.removeClass(cloneContainer, 'se-component-selected');
+		dom.utils.removeClass(cloneContainer.querySelectorAll('.se-figure-selected'), 'se-figure-selected');
+		dom.utils.removeClass(cloneContainer.querySelectorAll('.se-selected-table-cell'), 'se-selected-table-cell');
+		dom.utils.removeClass(cloneContainer.querySelector('.se-selected-cell-focus'), 'se-selected-cell-focus');
+
+		// copy to clipboard
+		this.html.copy(cloneContainer);
+
+		// copy effect
+		dom.utils.flashClass(container, 'se-copy');
+	},
+
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Checks if the given element is a file component by matching its tag name against the file manager's regular expressions.
+	 * - It also verifies whether the element has the required attributes based on the tag type.
+	 * @param {Node} element The element to check.
+	 * @returns {boolean} Returns true if the element is a file component, otherwise false.
+	 */
 	__isFiles(element) {
 		const nodeName = element.nodeName.toLowerCase();
-		return this.editor._fileManager.regExp.test(nodeName) && (!this.editor._fileManager.tagAttrs[nodeName] || this.editor._fileManager.tagAttrs[nodeName]?.every((v) => element.hasAttribute(v)));
+		return this.editor._fileManager.regExp.test(nodeName) && (!this.editor._fileManager.tagAttrs[nodeName] || this.editor._fileManager.tagAttrs[nodeName]?.every((v) => /** @type {HTMLElement} */ (element).hasAttribute(v)));
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Deselects the currently selected component, removing any selection effects and associated event listeners.
+	 * - This method resets the selection state and hides UI elements related to the component selection.
+	 */
 	__deselect() {
-		this.editor._antiBlur = false;
+		this.editor._preventBlur = false;
 		_DragHandle.set('__overInfo', null);
-		this._removeDragEvent(this);
-		domUtils.removeClass(this.currentInfo?.container, 'se-component-selected|');
-		domUtils.removeClass(this.currentInfo?.cover, 'se-figure-over-selected');
+		this._removeDragEvent();
+
+		if (this.currentInfo) {
+			const infoContainer = this.currentInfo.container;
+			const infoCover = this.currentInfo.cover;
+			converter.debounce(() => {
+				dom.utils.removeClass(infoContainer, 'se-component-selected');
+				dom.utils.removeClass(infoCover, 'se-figure-over-selected');
+			}, 0)();
+		}
 
 		const { frameContext } = this.editor;
 		frameContext.get('lineBreaker_t').style.display = frameContext.get('lineBreaker_b').style.display = 'none';
@@ -319,47 +440,58 @@ Component.prototype = {
 		this.currentPluginName = '';
 		this.currentInfo = null;
 		this.__removeGlobalEvent();
-		this.editor.__offControllers();
+		this.ui.__offControllers();
 	},
 
 	/**
-	 * @description Set line breaker of component
-	 * @param {Element} element Element tag
 	 * @private
+	 * @this {ComponentThis}
+	 * @description Set line breaker of component
+	 * @param {HTMLElement} element Element tag
 	 */
 	_setComponentLineBreaker(element) {
+		const _overInfo = _DragHandle.get('__overInfo') === ON_OVER_COMPONENT;
 		this.eventManager._lineBreakComp = null;
 		const info = this.get(element);
 		if (!info) return;
 
 		const fc = this.editor.frameContext;
 		const container = info.container;
-		const isNonSelected = domUtils.hasClass(container, 'se-flex-component');
+		const isNonSelected = dom.utils.hasClass(container, 'se-flex-component');
 		const lb_t = fc.get('lineBreaker_t');
 		const lb_b = fc.get('lineBreaker_b');
 		const t_style = lb_t.style;
 		const b_style = lb_b.style;
 		const offsetTarget = container.offsetWidth < element.offsetWidth ? container : element;
 		const target = this.editor._figureContainer?.style.display === 'block' ? this.editor._figureContainer : offsetTarget;
-		const isList = domUtils.isListCell(container.parentNode);
+		const isList = dom.check.isListCell(container.parentNode);
 
 		// top
 		let componentTop, w;
 		const isRtl = this.options.get('_rtl');
 		const dir = isRtl ? ['right', 'left'] : ['left', 'right'];
-		const top = offsetTarget.offsetTop;
-		const { scrollX, scrollY } = this.offset.getLocal(offsetTarget);
+		const { top, left, right, scrollX, scrollY } = this.offset.getLocal(offsetTarget);
+		const sideOffset = isRtl ? right : left;
 
 		if (isList ? !container.previousSibling : !this.format.isLine(container.previousElementSibling)) {
-			const tH = numbers.get(_w.getComputedStyle(lb_t).height, 1);
+			const cStyle = _w.getComputedStyle(lb_t);
+			const cH = numbers.get(cStyle.height, 1);
+			const cW = numbers.get(cStyle.width, 1);
+
 			this.eventManager._lineBreakComp = container;
 			componentTop = top;
 			w = target.offsetWidth / 2 / 2;
-			t_style.top = componentTop - scrollY - tH / 2 + 'px';
-			t_style[dir[0]] = (isNonSelected ? 4 : this.offset.get(target).left + w) + 'px';
+
+			t_style.top = componentTop - scrollY - cH / 2 + 'px';
+			t_style[dir[0]] = (isNonSelected ? sideOffset - cW / 2 : sideOffset + w) + 'px';
 			t_style[dir[1]] = '';
+
 			lb_t.setAttribute('data-offset', scrollY + ',' + scrollX);
+			if (_overInfo) dom.utils.removeClass(lb_t, 'se-on-selected');
+			else dom.utils.addClass(lb_t, 'se-on-selected');
+
 			t_style.display = 'block';
+			t_style.visibility = '';
 		} else {
 			t_style.display = 'none';
 		}
@@ -367,8 +499,8 @@ Component.prototype = {
 		// bottom
 		if (isList ? !container.nextSibling : !this.format.isLine(container.nextElementSibling)) {
 			const cStyle = _w.getComputedStyle(lb_b);
-			const bH = numbers.get(cStyle.height, 1);
-			const bW = numbers.get(cStyle.width, 1);
+			const cH = numbers.get(cStyle.height, 1);
+			const cW = numbers.get(cStyle.width, 1);
 
 			if (!componentTop) {
 				this.eventManager._lineBreakComp = container;
@@ -376,18 +508,26 @@ Component.prototype = {
 				w = target.offsetWidth / 2 / 2;
 			}
 
-			b_style.top = componentTop + target.offsetHeight - scrollY - bH / 2 + 'px';
-			b_style.right = '';
-			b_style.left = this.offset.get(target).left + (isRtl ? 0 : target.offsetWidth) - (isNonSelected ? 0 : w) - (isNonSelected ? bW / 2 : bW) + 'px';
+			b_style.top = componentTop + target.offsetHeight - scrollY - cH / 2 + 'px';
+			b_style[dir[0]] = sideOffset + target.offsetWidth - (isNonSelected ? 0 : w) - (isNonSelected ? cW / 2 : cW) + 'px';
+			b_style[dir[1]] = '';
+
+			lb_b.setAttribute('data-offset', scrollY + ',' + dir[0] + ',' + scrollX);
+			if (_overInfo) dom.utils.removeClass(lb_b, 'se-on-selected');
+			else dom.utils.addClass(lb_b, 'se-on-selected');
 
-			const bDir = 'left';
-			lb_b.setAttribute('data-offset', scrollY + ',' + bDir + ',' + scrollX);
 			b_style.display = 'block';
+			b_style.visibility = '';
 		} else {
 			b_style.display = 'none';
 		}
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Adds global event listeners for component interactions such as copy, cut, and keydown events.
+	 */
 	__addGlobalEvent() {
 		this.__removeGlobalEvent();
 		this._bindClose_copy = this.eventManager.addGlobalEvent('copy', this.__globalEvents.copy);
@@ -395,6 +535,11 @@ Component.prototype = {
 		this._bindClose_keydown = this.eventManager.addGlobalEvent('keydown', this.__globalEvents.keydown);
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Removes global event listeners that were previously added for component interactions.
+	 */
 	__removeGlobalEvent() {
 		this.__removeNotFileGlobalEvent();
 		if (this._bindClose_copy) this._bindClose_copy = this.eventManager.removeGlobalEvent(this._bindClose_copy);
@@ -402,23 +547,38 @@ Component.prototype = {
 		if (this._bindClose_keydown) this._bindClose_keydown = this.eventManager.removeGlobalEvent(this._bindClose_keydown);
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Adds global event listeners for non-file-related interactions such as mouse and touch events.
+	 */
 	__addNotFileGlobalEvent() {
 		this.__removeNotFileGlobalEvent();
 		if (!isMobile) this._bindClose_mousedown = this.eventManager.addGlobalEvent('mousedown', this.__globalEvents.mousedown, true);
 		else this._bindClose_touchstart = this.eventManager.addGlobalEvent('touchstart', this.__globalEvents.mousedown, true);
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Removes global event listeners related to non-file interactions.
+	 */
 	__removeNotFileGlobalEvent() {
 		if (this._bindClose_mousedown) this._bindClose_mousedown = this.eventManager.removeGlobalEvent(this._bindClose_mousedown);
 		if (this._bindClose_touchstart) this._bindClose_touchstart = this.eventManager.removeGlobalEvent(this._bindClose_touchstart);
 	},
 
+	/**
+	 * @private
+	 * @this {ComponentThis}
+	 * @description Removes drag-related events and resets drag-related states.
+	 */
 	_removeDragEvent() {
-		this.carrierWrapper.querySelector('.se-drag-cursor').style.left = '-10000px';
+		/** @type {HTMLElement} */ (this.carrierWrapper.querySelector('.se-drag-cursor')).style.left = '-10000px';
 		if (_DragHandle.get('__dragHandler')) _DragHandle.get('__dragHandler').style.display = 'none';
 
-		domUtils.removeClass([_DragHandle.get('__dragHandler'), _DragHandle.get('__dragContainer')], 'se-dragging');
-		domUtils.removeClass([_DragHandle.get('__dragCover'), _DragHandle.get('__dragContainer')], 'se-drag-over');
+		dom.utils.removeClass([_DragHandle.get('__dragHandler'), _DragHandle.get('__dragContainer')], 'se-dragging');
+		dom.utils.removeClass([_DragHandle.get('__dragCover'), _DragHandle.get('__dragContainer')], 'se-drag-over');
 
 		_DragHandle.set('__figureInst', null);
 		_DragHandle.set('__dragInst', null);
@@ -432,18 +592,28 @@ Component.prototype = {
 	constructor: Component
 };
 
+/**
+ * @this {ComponentThis}
+ */
 function OnDragEnter() {
-	this.editor._antiBlur = true;
-	this.editor._visibleControllers(false, domUtils.hasClass(_DragHandle.get('__dragHandler'), 'se-drag-handle-full'));
-	domUtils.addClass(_DragHandle.get('__dragCover') || _DragHandle.get('__dragContainer'), 'se-drag-over');
+	this.editor._preventBlur = true;
+	this.ui._visibleControllers(false, dom.utils.hasClass(_DragHandle.get('__dragHandler'), 'se-drag-handle-full'));
+	dom.utils.addClass(_DragHandle.get('__dragCover') || _DragHandle.get('__dragContainer'), 'se-drag-over');
 }
 
+/**
+ * @this {ComponentThis}
+ */
 function OnDragLeave() {
-	this.editor._antiBlur = false;
-	if (!domUtils.hasClass(_DragHandle.get('__dragHandler'), 'se-drag-handle-full')) this.editor._visibleControllers(true, true);
-	domUtils.removeClass([_DragHandle.get('__dragCover'), _DragHandle.get('__dragContainer')], 'se-drag-over');
+	this.editor._preventBlur = false;
+	if (!dom.utils.hasClass(_DragHandle.get('__dragHandler'), 'se-drag-handle-full')) this.ui._visibleControllers(true, true);
+	dom.utils.removeClass([_DragHandle.get('__dragCover'), _DragHandle.get('__dragContainer')], 'se-drag-over');
 }
 
+/**
+ * @this {ComponentThis}
+ * @param {DragEvent} e - Drag event
+ */
 function OnDragStart(e) {
 	const cover = _DragHandle.get('__dragCover') || _DragHandle.get('__dragContainer');
 
@@ -452,29 +622,44 @@ function OnDragStart(e) {
 		return;
 	}
 
-	this.editor._antiBlur = false;
-	domUtils.addClass(_DragHandle.get('__dragHandler'), 'se-dragging');
-	domUtils.addClass(_DragHandle.get('__dragContainer'), 'se-dragging');
+	this.editor._preventBlur = false;
+	dom.utils.addClass(_DragHandle.get('__dragHandler'), 'se-dragging');
+	dom.utils.addClass(_DragHandle.get('__dragContainer'), 'se-dragging');
 	e.dataTransfer.setDragImage(cover, this.options.get('_rtl') ? cover.offsetWidth : -5, -5);
 }
 
+/**
+ * @this {ComponentThis}
+ */
 function OnDragEnd() {
-	this.editor._antiBlur = false;
-	domUtils.removeClass([_DragHandle.get('__dragHandler'), _DragHandle.get('__dragContainer')], 'se-dragging');
+	this.editor._preventBlur = false;
+	dom.utils.removeClass([_DragHandle.get('__dragHandler'), _DragHandle.get('__dragContainer')], 'se-dragging');
 	this._removeDragEvent();
 }
 
-function OnDragClick({ target }) {
-	if (!domUtils.hasClass(target, 'se-drag-handle-full')) return;
+/**
+ * @this {ComponentThis}
+ * @param {MouseEvent} e - Mouse event
+ */
+function OnDragClick(e) {
+	const target = dom.query.getEventTarget(e);
+	if (!dom.utils.hasClass(target, 'se-drag-handle-full')) return;
+
 	const dragInst = _DragHandle.get('__dragInst');
-	this.select(dragInst.currentTarget, dragInst.currentPluginName, false);
+	this._removeDragEvent();
+	this.select(dragInst.currentTarget, dragInst.currentPluginName);
 }
 
-function CloseListener_mousedown({ target }) {
+/**
+ * @this {ComponentThis}
+ * @param {MouseEvent} e - Mouse event
+ */
+function CloseListener_mousedown(e) {
+	const target = dom.query.getEventTarget(e);
 	if (
 		this.currentTarget?.contains(target) ||
-		domUtils.getParentElement(target, '.se-controller') ||
-		domUtils.hasClass(target, 'se-drag-handle') ||
+		dom.query.getParentElement(target, '.se-controller') ||
+		dom.utils.hasClass(target, 'se-drag-handle') ||
 		(this.currentPluginName === this.editor.currentControllerName && this.editor.opendControllers.some(({ form }) => form.contains(target)))
 	) {
 		return;
@@ -482,39 +667,58 @@ function CloseListener_mousedown({ target }) {
 	this.deselect();
 }
 
+/**
+ * @this {ComponentThis}
+ * @param {ClipboardEvent} e - Event object
+ */
 function OnCopy_component(e) {
-	if (domUtils.isInputElement(e.target) && domUtils.getParentElement(e.target, '.se-modal')) return;
+	const target = dom.query.getEventTarget(e);
+	if (dom.check.isInputElement(target) && dom.query.getParentElement(target, '.se-modal')) return;
 
 	const info = this.info;
 	if (!info) return;
 
-	SetClipboardComponent(e, info.container, e.clipboardData);
-	domUtils.addClass(info.container, 'se-copy');
+	const cloneContainer = info.container.cloneNode(true);
+	dom.utils.removeClass(cloneContainer, 'se-component-selected');
+
+	if (typeof this.plugins[info.pluginName]?.onCopyComponent !== 'function' || this.plugins[info.pluginName].onCopyComponent({ event: e, cloneContainer, info }) === false) {
+		SetClipboardComponent(e, cloneContainer, e.clipboardData);
+	}
+
 	// copy effect
-	_w.setTimeout(() => {
-		domUtils.removeClass(info.container, 'se-copy');
-	}, 120);
+	dom.utils.flashClass(info.container, 'se-copy');
 }
 
+/**
+ * @this {ComponentThis}
+ * @param {ClipboardEvent} e - Event object
+ */
 function OnCut_component(e) {
 	const info = this.info;
 	if (!info) return;
 
-	SetClipboardComponent(e, info.container, e.clipboardData);
+	const cloneContainer = info.container.cloneNode(true);
+	dom.utils.removeClass(cloneContainer, 'se-component-selected');
+
+	SetClipboardComponent(e, cloneContainer, e.clipboardData);
 	this.deselect();
-	domUtils.removeItem(info.container);
+	dom.utils.removeItem(info.container);
 }
 
-function OnKeyDown_component(e) {
+/**
+ * @this {ComponentThis}
+ * @param {KeyboardEvent} e - Event object
+ */
+async function OnKeyDown_component(e) {
 	if (this.editor.selectMenuOn) return;
 
-	const keyCode = e.keyCode;
-	const ctrl = e.ctrlKey || e.metaKey || keyCode === 91 || keyCode === 92 || keyCode === 224;
+	const keyCode = e.code;
+	const ctrl = keyCodeMap.isCtrl(e);
 
 	// redo, undo
 	if (ctrl) {
-		if (keyCode !== 17) {
-			const info = this.editor.shortcutsKeyMap.get(keyCode + (e.shiftKey ? 1000 : 0));
+		if (keyCode !== 'ControlRight' && keyCode !== 'ControlLeft') {
+			const info = this.editor.shortcutsKeyMap.get(keyCode + (e.shiftKey ? '1000' : ''));
 			if (/^(redo|undo)$/.test(info?.c)) {
 				e.preventDefault();
 				e.stopPropagation();
@@ -525,11 +729,11 @@ function OnKeyDown_component(e) {
 	}
 
 	// backspace key, delete key
-	if (keyCode === 8 || keyCode === 46) {
+	if (keyCodeMap.isRemoveKey(keyCode)) {
 		e.preventDefault();
 		e.stopPropagation();
 		if (typeof this.currentPlugin?.destroy === 'function') {
-			this.currentPlugin.destroy(this.currentTarget);
+			await this.currentPlugin.destroy(this.currentTarget);
 			this.deselect();
 			this.editor.focus();
 			return;
@@ -537,16 +741,16 @@ function OnKeyDown_component(e) {
 	}
 
 	// enter key
-	if (keyCode === 13) {
+	if (keyCodeMap.isEnter(keyCode)) {
 		e.preventDefault();
 		const compContext = this.currentInfo || this.get(this.currentTarget);
 		const container = compContext.container || compContext.target;
 		const sibling = container.previousElementSibling || container.nextElementSibling;
 		let newEl = null;
-		if (domUtils.isListCell(container.parentNode)) {
-			newEl = domUtils.createElement('BR');
+		if (dom.check.isListCell(container.parentNode)) {
+			newEl = dom.utils.createElement('BR');
 		} else {
-			newEl = domUtils.createElement(this.format.isLine(sibling) && !this.format.isBlock(sibling) ? sibling.nodeName : this.options.get('defaultLine'), null, '<br>');
+			newEl = dom.utils.createElement(this.format.isLine(sibling) ? sibling.nodeName : this.options.get('defaultLine'), null, '<br>');
 		}
 
 		const pluginName = this.currentPluginName;
@@ -567,21 +771,22 @@ function OnKeyDown_component(e) {
 		let offset = 1;
 		if (isInline) {
 			switch (keyCode) {
-				case 37: // left
+				case 'ArrowLeft': // left
 					el = container.previousSibling;
 					offset = el?.nodeType === 3 ? el.textContent.length : 1;
 					break;
-				case 39: // right
+				case 'ArrowRight': // right
 					el = container.nextSibling;
+					offset = 0;
 					break;
-				case 38: {
+				case 'ArrowUp': {
 					// up
 					const line = this.format.getLine(container, null);
 					el = line?.previousElementSibling;
 					offset = 0;
 					break;
 				}
-				case 40: {
+				case 'ArrowDown': {
 					// down
 					const line = this.format.getLine(container, null);
 					el = line?.nextElementSibling;
@@ -607,16 +812,21 @@ function OnKeyDown_component(e) {
 			e.preventDefault();
 			this.select(elComp.target, elComp.pluginName);
 		} else {
-			e.stopPropagation();
-			e.preventDefault();
-			this.selection.setRange(el, offset, el, offset);
+			try {
+				this.editor._preventBlur = true;
+				e.stopPropagation();
+				e.preventDefault();
+				this.selection.setRange(el, offset, el, offset);
+			} finally {
+				this.editor._preventBlur = false;
+			}
 		}
 
 		return;
 	}
 
 	// ESC
-	if (keyCode === 27) {
+	if (keyCodeMap.isEsc(keyCode)) {
 		this.deselect();
 		return;
 	}
@@ -625,10 +835,8 @@ function OnKeyDown_component(e) {
 function SetClipboardComponent(e, container, clipboardData) {
 	e.preventDefault();
 	e.stopPropagation();
-	const pasteContainer = container.cloneNode(true);
-	domUtils.removeClass(pasteContainer, 'se-component-selected');
-	pasteContainer.querySelectorAll('.se-figure-selected').forEach((el) => domUtils.removeClass(el, 'se-figure-selected'));
-	clipboardData.setData('text/html', pasteContainer.outerHTML);
+	container.querySelectorAll('.se-figure-selected').forEach((el) => dom.utils.removeClass(el, 'se-figure-selected'));
+	clipboardData.setData('text/html', container.outerHTML);
 }
 
 export default Component;