@lobehub/editor 4.15.2 → 4.16.1

package/es/plugins/block/react/drag/drag-utils.js

@@ -1,21 +1,48 @@
 //#region src/plugins/block/react/drag/drag-utils.ts
+const toRectSnapshot = (rect) => ({
+	bottom: rect.bottom,
+	height: rect.height,
+	left: rect.left,
+	top: rect.top,
+	width: rect.width
+});
+const isTableBlockElement = (element) => {
+	return element instanceof HTMLTableElement || Boolean(element.querySelector("table.editor_table, table"));
+};
+const getTableBlockRect = (element) => {
+	const table = element instanceof HTMLTableElement ? element : element.querySelector("table.editor_table, table");
+	if (!(table instanceof HTMLElement)) return null;
+	const tableRect = table.getBoundingClientRect();
+	const firstCell = table.querySelector("th, td");
+	if (firstCell instanceof HTMLElement) {
+		const cellRect = firstCell.getBoundingClientRect();
+		if (cellRect.width > 0 && cellRect.height > 0) return {
+			bottom: tableRect.height > 0 ? tableRect.bottom : cellRect.bottom,
+			height: tableRect.height > 0 ? tableRect.height : cellRect.height,
+			left: cellRect.left,
+			top: tableRect.height > 0 ? tableRect.top : cellRect.top,
+			width: tableRect.width > 0 ? tableRect.width : cellRect.width
+		};
+	}
+	if (tableRect.height <= 0) return null;
+	return toRectSnapshot(tableRect);
+};
+const getBlockMeasureRect = (block) => {
+	const rect = isTableBlockElement(block) ? getTableBlockRect(block) : toRectSnapshot(block.getBoundingClientRect());
+	if (!rect || rect.height <= 0) return null;
+	return rect;
+};
 const collectDragBlocks = (root) => {
 	if (!root) return [];
 	return Array.from(root.querySelectorAll("[data-block-id]")).reduce((acc, block) => {
 		const blockId = block.dataset.blockId;
 		if (!blockId) return acc;
-		const rect = block.getBoundingClientRect();
-		if (rect.height <= 0) return acc;
+		const rect = getBlockMeasureRect(block);
+		if (!rect) return acc;
 		acc.push({
 			block,
 			blockId,
-			rect: {
-				bottom: rect.bottom,
-				height: rect.height,
-				left: rect.left,
-				top: rect.top,
-				width: rect.width
-			}
+			rect
 		});
 		return acc;
 	}, []).sort((a, b) => a.rect.top - b.rect.top);
@@ -92,4 +119,4 @@ const resolveNearestInsertionSlot = (sourceBlockId, blocks, y) => {
 	return bestSlot;
 };
 //#endregion
-export { collectDragBlocks, getAutoScrollDelta, resolveNearestInsertionSlot, resolveScrollContainers };
+export { collectDragBlocks, getAutoScrollDelta, getBlockMeasureRect, getTableBlockRect, isTableBlockElement, resolveNearestInsertionSlot, resolveScrollContainers };

package/es/plugins/block/service/i-block-menu-service.d.ts

@@ -1,4 +1,6 @@
 import { IEditor, IServiceID } from "../../../types/kernel.js";
+import { LexicalNode } from "lexical";
+
 //#region src/plugins/block/service/i-block-menu-service.d.ts
 interface IBlockMenuRenderContext {
   blockElement: HTMLElement;
@@ -21,11 +23,20 @@ interface IBlockActionButton {
   title: string | ((context: IBlockMenuRenderContext) => string);
   when?: (context: IBlockMenuRenderContext) => boolean;
 }
+interface IBlockSelectHandler {
+  key: string;
+  onSelect: (node: LexicalNode) => boolean | void;
+  order?: number;
+}
 interface IBlockMenuService {
   getActionButtons(context: IBlockMenuRenderContext): IBlockActionButton[];
   getMenus(context: IBlockMenuRenderContext): IBlockMenuItem[];
+  isMenuSuppressed(): boolean;
   registerActionButton(item: IBlockActionButton): () => void;
   registerMenu(item: IBlockMenuItem): () => void;
+  registerSelectHandler(item: IBlockSelectHandler): () => void;
+  selectNode(node: LexicalNode): boolean;
+  setMenuSuppressed(key: string, suppressed: boolean): void;
   subscribe(listener: () => void): () => void;
 }
 declare const IBlockMenuService: IServiceID<IBlockMenuService>;
@@ -33,12 +44,18 @@ declare class BlockMenuService implements IBlockMenuService {
   private actionButtons;
   private items;
   private listeners;
+  private selectHandlers;
+  private suppressors;
   getActionButtons(context: IBlockMenuRenderContext): IBlockActionButton[];
   getMenus(context: IBlockMenuRenderContext): IBlockMenuItem[];
+  isMenuSuppressed(): boolean;
   registerActionButton(item: IBlockActionButton): () => void;
   registerMenu(item: IBlockMenuItem): () => void;
+  registerSelectHandler(item: IBlockSelectHandler): () => void;
+  selectNode(node: LexicalNode): boolean;
+  setMenuSuppressed(key: string, suppressed: boolean): void;
   subscribe(listener: () => void): () => void;
   private notify;
 }
 //#endregion
-export { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService };
+export { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService, IBlockSelectHandler };

package/es/plugins/block/service/i-block-menu-service.js

@@ -6,6 +6,8 @@ var BlockMenuService = class {
 		this.actionButtons = /* @__PURE__ */ new Map();
 		this.items = /* @__PURE__ */ new Map();
 		this.listeners = /* @__PURE__ */ new Set();
+		this.selectHandlers = /* @__PURE__ */ new Map();
+		this.suppressors = /* @__PURE__ */ new Set();
 	}
 	getActionButtons(context) {
 		return Array.from(this.actionButtons.values()).filter((item) => item.when ? item.when(context) : true).sort((a, b) => (a.order || 0) - (b.order || 0));
@@ -13,6 +15,9 @@ var BlockMenuService = class {
 	getMenus(context) {
 		return Array.from(this.items.values()).filter((item) => item.when ? item.when(context) : true).sort((a, b) => (a.order || 0) - (b.order || 0));
 	}
+	isMenuSuppressed() {
+		return this.suppressors.size > 0;
+	}
 	registerActionButton(item) {
 		this.actionButtons.set(item.key, item);
 		this.notify();
@@ -29,6 +34,25 @@ var BlockMenuService = class {
 			this.notify();
 		};
 	}
+	registerSelectHandler(item) {
+		this.selectHandlers.set(item.key, item);
+		this.notify();
+		return () => {
+			this.selectHandlers.delete(item.key);
+			this.notify();
+		};
+	}
+	selectNode(node) {
+		const handlers = Array.from(this.selectHandlers.values()).sort((a, b) => (a.order || 0) - (b.order || 0));
+		for (const handler of handlers) if (handler.onSelect(node)) return true;
+		return false;
+	}
+	setMenuSuppressed(key, suppressed) {
+		const size = this.suppressors.size;
+		if (suppressed) this.suppressors.add(key);
+		else this.suppressors.delete(key);
+		if (this.suppressors.size !== size) this.notify();
+	}
 	subscribe(listener) {
 		this.listeners.add(listener);
 		return () => {

package/es/plugins/block/service/index.d.ts

@@ -1 +1 @@
-import { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService } from "./i-block-menu-service.js";
+import { BlockMenuService, IBlockActionButton, IBlockActionButtonIcon, IBlockMenuItem, IBlockMenuRenderContext, IBlockMenuService, IBlockSelectHandler } from "./i-block-menu-service.js";

package/es/plugins/codeblock/plugin/index.js

@@ -2,10 +2,11 @@ import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js
 import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
 import { ILitexmlService } from "../../litexml/service/litexml-service.js";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
+import { IBlockMenuService } from "../../block/service/i-block-menu-service.js";
 import { getCodeLanguageByInput } from "../utils/language.js";
 import { registerCodeHighlighting, toCodeTheme } from "./CodeHighlighterShiki.js";
 import { CustomShikiTokenizer, registerCodeCommand } from "../command/index.js";
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, PASTE_COMMAND, TabNode } from "lexical";
+import { $createRangeSelection, $getSelection, $isRangeSelection, $setSelection, COMMAND_PRIORITY_EDITOR, PASTE_COMMAND, TabNode } from "lexical";
 import { $createCodeNode, $isCodeHighlightNode, $isCodeNode, CodeHighlightNode, CodeNode } from "@lexical/code-core";
 //#region src/plugins/codeblock/plugin/index.ts
 init_helper();
@@ -75,6 +76,29 @@ const CodeblockPlugin = class extends KernelPlugin {
 		}, COMMAND_PRIORITY_EDITOR));
 		this.registerMarkdown();
 		this.registerLiteXml();
+		this.registerBlockSelect();
+	}
+	registerBlockSelect() {
+		const blockMenuService = this.kernel.requireService(IBlockMenuService);
+		if (!blockMenuService) return;
+		this.register(blockMenuService.registerSelectHandler({
+			key: "__codeblock_block_select_handler",
+			onSelect: (node) => {
+				if (!$isCodeNode(node)) return false;
+				const textNodes = node.getAllTextNodes();
+				const firstTextNode = textNodes[0];
+				const lastTextNode = textNodes.at(-1);
+				if (!firstTextNode || !lastTextNode) {
+					node.select(0, node.getChildrenSize());
+					return true;
+				}
+				const selection = $createRangeSelection();
+				selection.setTextNodeRange(firstTextNode, 0, lastTextNode, lastTextNode.getTextContentSize());
+				$setSelection(selection);
+				return true;
+			},
+			order: 100
+		}));
 	}
 	registerLiteXml() {
 		const litexmlService = this.kernel.requireService(ILitexmlService);

package/es/plugins/common/plugin/register.js

@@ -1,7 +1,7 @@
 import { createDebugLogger, init_debug } from "../../../utils/debug.js";
 import { HotkeyEnum, init_hotkey } from "../../../types/hotkey.js";
 import { $closest } from "../../../editor-kernel/utils.js";
-import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, REDO_COMMAND, UNDO_COMMAND } from "lexical";
+import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, HISTORIC_TAG, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, REDO_COMMAND, UNDO_COMMAND } from "lexical";
 import { $isHeadingNode, QuoteNode } from "@lexical/rich-text";
 import { mergeRegister } from "@lexical/utils";
 import { $isCodeHighlightNode, $isCodeNode } from "@lexical/code-core";
@@ -297,7 +297,7 @@ function registerLastElement(editor) {
 						root.append(paragraph);
 					}
 					isProcessing = false;
-				});
+				}, { tag: HISTORIC_TAG });
 			});
 		}
 	});

package/es/plugins/litexml/command/diffCommand.d.ts

@@ -1,17 +1,2 @@
-import * as _$lexical from "lexical";
-import { LexicalEditor } from "lexical";
-
-//#region src/plugins/litexml/command/diffCommand.d.ts
-declare enum DiffAction {
-  Reject = 0,
-  Accept = 1
-}
-declare const LITEXML_DIFFNODE_COMMAND: _$lexical.LexicalCommand<{
-  action: DiffAction;
-  nodeKey: string;
-}>;
-declare const LITEXML_DIFFNODE_ALL_COMMAND: _$lexical.LexicalCommand<{
-  action: DiffAction;
-}>;
-//#endregion
-export { DiffAction, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND };
+import { DiffAction, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND } from "./symbols.js";
+import { LexicalEditor } from "lexical";

package/es/plugins/litexml/command/diffCommand.js

@@ -1,14 +1,8 @@
 import { DiffNode } from "../node/DiffNode.js";
-import { $getNodeByKey, $isElementNode, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND } from "./symbols.js";
+import { $getNodeByKey, $isElementNode, COMMAND_PRIORITY_EDITOR } from "lexical";
 import { mergeRegister } from "@lexical/utils";
 //#region src/plugins/litexml/command/diffCommand.ts
-let DiffAction = /* @__PURE__ */ function(DiffAction) {
-	DiffAction[DiffAction["Reject"] = 0] = "Reject";
-	DiffAction[DiffAction["Accept"] = 1] = "Accept";
-	return DiffAction;
-}({});
-const LITEXML_DIFFNODE_COMMAND = createCommand("LITEXML_DIFFNODE_COMMAND");
-const LITEXML_DIFFNODE_ALL_COMMAND = createCommand("LITEXML_DIFFNODE_ALL_COMMAND");
 function doAction(node, action) {
 	if (node.diffType === "modify") {
 		const children = node.getChildren();
@@ -94,4 +88,4 @@ function registerLiteXMLDiffCommand(editor) {
 	}, COMMAND_PRIORITY_EDITOR));
 }
 //#endregion
-export { DiffAction, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, registerLiteXMLDiffCommand };
+export { registerLiteXMLDiffCommand };

package/es/plugins/litexml/command/index.d.ts

@@ -1,38 +1,2 @@
-import * as _$lexical from "lexical";
-import { LexicalEditor } from "lexical";
-
-//#region src/plugins/litexml/command/index.d.ts
-declare const LITEXML_MODIFY_COMMAND: _$lexical.LexicalCommand<({
-  action: "insert";
-  beforeId: string;
-  litexml: string;
-} | {
-  action: "insert";
-  afterId: string;
-  litexml: string;
-} | {
-  action: "remove";
-  id: string;
-} | {
-  action: "modify";
-  litexml: string | string[];
-})[]>;
-declare const LITEXML_APPLY_COMMAND: _$lexical.LexicalCommand<{
-  delay?: boolean;
-  litexml: string | string[];
-}>;
-declare const LITEXML_REMOVE_COMMAND: _$lexical.LexicalCommand<{
-  delay?: boolean;
-  id: string;
-}>;
-declare const LITEXML_INSERT_COMMAND: _$lexical.LexicalCommand<{
-  beforeId: string;
-  delay?: boolean;
-  litexml: string;
-} | {
-  afterId: string;
-  delay?: boolean;
-  litexml: string;
-}>;
-//#endregion
-export { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND };
+import { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./symbols.js";
+import { LexicalEditor } from "lexical";

package/es/plugins/litexml/command/index.js

@@ -2,7 +2,8 @@ import { createDebugLogger, init_debug } from "../../../utils/debug.js";
 import { $closest } from "../../../editor-kernel/utils.js";
 import { $createDiffNode, DiffNode } from "../node/DiffNode.js";
 import { $cloneNode, $parseSerializedNodeImpl, charToId } from "../utils/index.js";
-import { $createParagraphNode, $getNodeByKey, $getRoot, $insertNodes, $isElementNode, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
+import { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./symbols.js";
+import { $createParagraphNode, $getNodeByKey, $getRoot, $insertNodes, $isElementNode, COMMAND_PRIORITY_EDITOR } from "lexical";
 import { mergeRegister } from "@lexical/utils";
 import { $isListItemNode } from "@lexical/list";
 //#region src/plugins/litexml/command/index.ts
@@ -101,10 +102,6 @@ function wrapBlockModify(oldBlock, editor, changeFn) {
 	diffNode.append($cloneNode(newBlock, editor));
 	newBlock.replace(diffNode, false);
 }
-const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_COMMAND");
-const LITEXML_APPLY_COMMAND = createCommand("LITEXML_APPLY_COMMAND");
-const LITEXML_REMOVE_COMMAND = createCommand("LITEXML_REMOVE_COMMAND");
-const LITEXML_INSERT_COMMAND = createCommand("LITEXML_INSERT_COMMAND");
 function registerLiteXMLCommand(editor, dataSource) {
 	return mergeRegister(editor.registerCommand(LITEXML_MODIFY_COMMAND, (payload) => {
 		const resultPayload = payload.reduce((acc, cur) => {
@@ -330,4 +327,4 @@ function handleInsert(editor, payload, dataSource) {
 	});
 }
 //#endregion
-export { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND, registerLiteXMLCommand };
+export { registerLiteXMLCommand };

package/es/plugins/litexml/command/symbols.d.ts

@@ -0,0 +1,67 @@
+import * as _$lexical from "lexical";
+
+//#region src/plugins/litexml/command/symbols.d.ts
+/**
+ * LiteXML command identities.
+ *
+ * These symbols are intentionally isolated in a side-effect-free module so they
+ * keep a SINGLE runtime identity across every entry of this package.
+ *
+ * Lexical's `dispatchCommand` matches command listeners by object reference, not
+ * by the string label. The package ships two independently-bundled entries — the
+ * browser build (`index` / `react` / `renderer`) and the node build (`headless`)
+ * — and if each entry inlined its own `createCommand(...)` call, dispatching a
+ * command obtained from one entry onto an editor registered by the other would
+ * silently no-op (different object identities, same label).
+ *
+ * By keeping every command in this one module — exposed verbatim through
+ * `@lobehub/editor/litexml-commands` and emitted as a shared chunk by both
+ * builds — a single object backs the command in any runtime, and the module is
+ * pure enough to be imported on the server without pulling in the DOM-dependent
+ * editor bundle.
+ */
+declare enum DiffAction {
+  Reject = 0,
+  Accept = 1
+}
+declare const LITEXML_MODIFY_COMMAND: _$lexical.LexicalCommand<({
+  action: "insert";
+  beforeId: string;
+  litexml: string;
+} | {
+  action: "insert";
+  afterId: string;
+  litexml: string;
+} | {
+  action: "remove";
+  id: string;
+} | {
+  action: "modify";
+  litexml: string | string[];
+})[]>;
+declare const LITEXML_APPLY_COMMAND: _$lexical.LexicalCommand<{
+  delay?: boolean;
+  litexml: string | string[];
+}>;
+declare const LITEXML_REMOVE_COMMAND: _$lexical.LexicalCommand<{
+  delay?: boolean;
+  id: string;
+}>;
+declare const LITEXML_INSERT_COMMAND: _$lexical.LexicalCommand<{
+  beforeId: string;
+  delay?: boolean;
+  litexml: string;
+} | {
+  afterId: string;
+  delay?: boolean;
+  litexml: string;
+}>;
+declare const LITEXML_DIFFNODE_COMMAND: _$lexical.LexicalCommand<{
+  action: DiffAction;
+  nodeKey: string;
+}>;
+declare const LITEXML_DIFFNODE_ALL_COMMAND: _$lexical.LexicalCommand<{
+  action: DiffAction;
+}>;
+//#endregion
+export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND };

package/es/plugins/litexml/command/symbols.js

@@ -0,0 +1,34 @@
+import { createCommand } from "lexical";
+//#region src/plugins/litexml/command/symbols.ts
+/**
+* LiteXML command identities.
+*
+* These symbols are intentionally isolated in a side-effect-free module so they
+* keep a SINGLE runtime identity across every entry of this package.
+*
+* Lexical's `dispatchCommand` matches command listeners by object reference, not
+* by the string label. The package ships two independently-bundled entries — the
+* browser build (`index` / `react` / `renderer`) and the node build (`headless`)
+* — and if each entry inlined its own `createCommand(...)` call, dispatching a
+* command obtained from one entry onto an editor registered by the other would
+* silently no-op (different object identities, same label).
+*
+* By keeping every command in this one module — exposed verbatim through
+* `@lobehub/editor/litexml-commands` and emitted as a shared chunk by both
+* builds — a single object backs the command in any runtime, and the module is
+* pure enough to be imported on the server without pulling in the DOM-dependent
+* editor bundle.
+*/
+let DiffAction = /* @__PURE__ */ function(DiffAction) {
+	DiffAction[DiffAction["Reject"] = 0] = "Reject";
+	DiffAction[DiffAction["Accept"] = 1] = "Accept";
+	return DiffAction;
+}({});
+const LITEXML_MODIFY_COMMAND = createCommand("LITEXML_MODIFY_COMMAND");
+const LITEXML_APPLY_COMMAND = createCommand("LITEXML_APPLY_COMMAND");
+const LITEXML_REMOVE_COMMAND = createCommand("LITEXML_REMOVE_COMMAND");
+const LITEXML_INSERT_COMMAND = createCommand("LITEXML_INSERT_COMMAND");
+const LITEXML_DIFFNODE_COMMAND = createCommand("LITEXML_DIFFNODE_COMMAND");
+const LITEXML_DIFFNODE_ALL_COMMAND = createCommand("LITEXML_DIFFNODE_ALL_COMMAND");
+//#endregion
+export { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND };

package/es/plugins/litexml/index.d.ts

@@ -1,7 +1,6 @@
 import { ILitexmlService, LitexmlService, XMLReaderFunc, XMLReaderRecord, XMLWriterFunc, XMLWriterRecord } from "./service/litexml-service.js";
 import { LitexmlDataSource } from "./data-source/litexml-data-source.js";
-import { LITEXML_APPLY_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./command/index.js";
-import { DiffAction, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND } from "./command/diffCommand.js";
+import { DiffAction, LITEXML_APPLY_COMMAND, LITEXML_DIFFNODE_ALL_COMMAND, LITEXML_DIFFNODE_COMMAND, LITEXML_INSERT_COMMAND, LITEXML_MODIFY_COMMAND, LITEXML_REMOVE_COMMAND } from "./command/symbols.js";
 import { LitexmlPlugin, LitexmlPluginOptions } from "./plugin/index.js";
 import { ReactLiteXmlPlugin } from "./react/index.js";
 import { useHasDiffNode } from "./react/hooks/useHasDiffNode.js";

package/es/plugins/litexml/plugin/index.js

@@ -5,7 +5,7 @@ import { registerLiteXMLDiffCommand } from "../command/diffCommand.js";
 import { ILitexmlService, LitexmlService } from "../service/litexml-service.js";
 import LitexmlDataSource from "../data-source/litexml-data-source.js";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut.js";
-import { $nodesOfType } from "lexical";
+import { $nodesOfType, HISTORIC_TAG } from "lexical";
 //#region src/plugins/litexml/plugin/index.ts
 init_plugin();
 /**
@@ -42,8 +42,14 @@ const LitexmlPlugin = class extends KernelPlugin {
 		this.register(editor.registerNodeTransform(DiffNode, (node) => {
 			if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");
 		}));
-		this.register(editor.registerUpdateListener(({ editorState, prevEditorState }) => {
+		this.register(editor.registerUpdateListener(({ editorState, prevEditorState, tags }) => {
 			if (editorState === prevEditorState) return;
+			if (tags.has(HISTORIC_TAG)) return;
+			let shouldNormalize = false;
+			editorState.read(() => {
+				shouldNormalize = $nodesOfType(DiffNode).some((node) => node.diffType === "modify" && node.getChildrenSize() === 1);
+			});
+			if (!shouldNormalize) return;
 			editor.update(() => {
 				const diffNodes = $nodesOfType(DiffNode);
 				for (const node of diffNodes) if (node.diffType === "modify" && node.getChildrenSize() === 1) node.setDiffType("remove");

package/es/plugins/litexml/react/DiffNodeToolbar/index.js

@@ -1,5 +1,5 @@
 import LexicalPortalContainer from "../../../../editor-kernel/react/PortalContainer.js";
-import { LITEXML_DIFFNODE_COMMAND } from "../../command/diffCommand.js";
+import { LITEXML_DIFFNODE_COMMAND } from "../../command/symbols.js";
 import { useTranslation } from "../../../../editor-kernel/react/useTranslation.js";
 import { styles } from "./style.js";
 import { ActionIcon, Block } from "@lobehub/ui";

package/es/plugins/slash/plugin/index.js

@@ -26,7 +26,7 @@ const SlashPlugin = class extends KernelPlugin {
 		});
 	}
 	triggerClose() {
-		this.config?.triggerClose?.();
+		if (this.currentSlashTrigger !== null || this.manualOpen || !this.suppressOpen) this.config?.triggerClose?.();
 		this.currentSlashTrigger = null;
 		this.currentSlashTriggerIndex = -1;
 		this.manualOpen = false;

package/es/plugins/slash/react/ReactSlashPlugin.js

@@ -26,10 +26,10 @@ const ReactSlashPlugin = ({ children, anchorClassName, getPopupContainer, placem
 	const cancelRef = useRef({ cancel: noop });
 	const triggerMapRef = useRef(/* @__PURE__ */ new Map());
 	const close = useCallback(() => {
-		setIsOpen(false);
-		setOptions([]);
-		setResolution(null);
-		setActiveKey(null);
+		setIsOpen((open) => open ? false : open);
+		setOptions((currentOptions) => currentOptions.length > 0 ? [] : currentOptions);
+		setResolution((currentResolution) => currentResolution ? null : currentResolution);
+		setActiveKey((currentActiveKey) => currentActiveKey ? null : currentActiveKey);
 	}, []);
 	useEffect(() => close, [close]);
 	const handleActiveKeyChange = useCallback((key) => {

package/es/plugins/table/command/index.d.ts

@@ -9,9 +9,21 @@ declare const INSERT_TABLE_COMMAND: _$lexical.LexicalCommand<{
   rows: string;
 }>;
 declare const SELECT_TABLE_COMMAND: _$lexical.LexicalCommand<{
+  anchorIndex?: number;
   columnIndex?: number;
+  extend?: boolean;
   rowIndex?: number;
   table: string;
 }>;
+declare const INSERT_TABLE_COLUMN_COMMAND: _$lexical.LexicalCommand<{
+  columnIndex: number;
+  insertAfter?: boolean;
+  table: string;
+}>;
+declare const INSERT_TABLE_ROW_COMMAND: _$lexical.LexicalCommand<{
+  insertAfter?: boolean;
+  rowIndex: number;
+  table: string;
+}>;
 //#endregion
-export { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND };
+export { INSERT_TABLE_COLUMN_COMMAND, INSERT_TABLE_COMMAND, INSERT_TABLE_ROW_COMMAND, SELECT_TABLE_COMMAND };