@lobehub/editor 4.15.2 → 4.16.0

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/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/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 };

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

@@ -1,57 +1,238 @@
-import { $createTableNodeWithDimensions, $createTableSelection, $findTableNode, $isTableNode, $isTableSelection } from "@lexical/table";
+import { createDefaultTableColWidths, syncTableWidthDOM } from "../utils/index.js";
+import { getAutoFitTableColumnWidths } from "../utils/autoFitColumnWidth.js";
+import { getDistributedTableColumnWidths } from "../utils/distributeColumnWidth.js";
+import { $computeTableMapSkipCellCheck, $createTableNodeWithDimensions, $createTableSelection, $findTableNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isSimpleTable, $isTableNode, $isTableRowNode, $isTableSelection } from "@lexical/table";
 import { $getNodeByKey, $getPreviousSelection, $getSelection, $isElementNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
 import { $insertNodeToNearestRoot, mergeRegister } from "@lexical/utils";
 //#region src/plugins/table/command/index.ts
 const INSERT_TABLE_COMMAND = createCommand();
 const SELECT_TABLE_COMMAND = createCommand();
+const INSERT_TABLE_COLUMN_COMMAND = createCommand();
+const INSERT_TABLE_ROW_COMMAND = createCommand();
+const SYNC_TABLE_COLUMN_WIDTH_COMMAND = createCommand();
+const AUTO_FIT_TABLE_COLUMN_WIDTH_COMMAND = createCommand();
+const DISTRIBUTE_TABLE_COLUMN_WIDTH_COMMAND = createCommand();
+const MOVE_TABLE_COLUMN_COMMAND = createCommand();
+const MOVE_TABLE_ROW_COMMAND = createCommand();
+const resetTableScrollLeft = (editor, tableKey) => {
+	const tableElement = editor.getElementByKey(tableKey);
+	const scrollWrapper = (tableElement instanceof HTMLTableElement ? tableElement : tableElement?.querySelector("table.editor_table, table"))?.closest(".lobe-editor-table-scroll-wrapper");
+	if (scrollWrapper) scrollWrapper.scrollLeft = 0;
+};
+const $selectFirstDescendant = (node) => {
+	const firstDescendant = node.getFirstDescendant();
+	if ($isTextNode(firstDescendant)) firstDescendant.select();
+	else node.selectStart();
+};
+const getMoveRange = (selectedIndexes, targetIndex, insertAfter = false) => {
+	if (selectedIndexes.length === 0) return null;
+	const sortedIndexes = [...selectedIndexes].sort((a, b) => a - b);
+	const from = sortedIndexes[0];
+	const to = sortedIndexes.at(-1) ?? from;
+	const count = to - from + 1;
+	const insertionIndex = insertAfter ? targetIndex + 1 : targetIndex;
+	if (insertionIndex >= from && insertionIndex <= to + 1) return null;
+	return {
+		count,
+		from,
+		target: insertionIndex > to ? insertionIndex - count : insertionIndex,
+		to
+	};
+};
+const $selectTableRows = (tableNode, from, to) => {
+	const [tableMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+	const firstRow = tableMap[from];
+	const lastRow = tableMap[to];
+	const firstCell = firstRow?.[0]?.cell;
+	const lastCell = lastRow?.[lastRow.length - 1]?.cell;
+	if (!firstCell || !lastCell) return false;
+	const tableSelection = $createTableSelection();
+	tableSelection.set(tableNode.getKey(), firstCell.getKey(), lastCell.getKey());
+	$setSelection(tableSelection);
+	return true;
+};
+const $selectTableColumns = (tableNode, from, to) => {
+	const [tableMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+	const firstCell = tableMap.find((row) => row[from])?.[from]?.cell;
+	const lastCell = [...tableMap].reverse().find((row) => row[to])?.[to]?.cell;
+	if (!firstCell || !lastCell) return false;
+	const tableSelection = $createTableSelection();
+	tableSelection.set(tableNode.getKey(), firstCell.getKey(), lastCell.getKey());
+	$setSelection(tableSelection);
+	return true;
+};
+const getRangeFromSelection = (selection, table, targetIndex, direction, crossAxisLength, anchorIndex) => {
+	if (anchorIndex !== void 0) return {
+		from: Math.min(anchorIndex, targetIndex),
+		to: Math.max(anchorIndex, targetIndex)
+	};
+	if (!$isTableSelection(selection) || selection.tableKey !== table) return {
+		from: 0,
+		to: targetIndex
+	};
+	const shape = selection.getShape();
+	if (!(direction === "row" ? shape.fromX === 0 && shape.toX === crossAxisLength - 1 : shape.fromY === 0 && shape.toY === crossAxisLength - 1)) return {
+		from: 0,
+		to: targetIndex
+	};
+	const from = direction === "row" ? shape.fromY : shape.fromX;
+	const to = direction === "row" ? shape.toY : shape.toX;
+	return {
+		from: Math.min(from, targetIndex),
+		to: Math.max(to, targetIndex)
+	};
+};
 function registerTableCommand(editor) {
 	return mergeRegister(editor.registerCommand(INSERT_TABLE_COMMAND, ({ rows, columns, includeHeaders }) => {
 		const selection = $getSelection() || $getPreviousSelection();
 		if (!selection || !$isRangeSelection(selection)) return false;
-		if ($findTableNode(selection.anchor.getNode())) return false;
-		const anchorNode = selection.anchor.getNode();
-		const tableNode = $createTableNodeWithDimensions(Number(rows), Number(columns), includeHeaders);
+		const anchorNode = $getNodeByKey(selection.anchor.key);
+		if (!anchorNode) return false;
+		if ($findTableNode(anchorNode)) return false;
+		const rowCount = Number(rows);
+		const columnCount = Number(columns);
+		const tableNode = $createTableNodeWithDimensions(rowCount, columnCount, includeHeaders);
+		tableNode.setColWidths(createDefaultTableColWidths(columnCount));
 		if ($isElementNode(anchorNode) && anchorNode.isEmpty()) anchorNode.replace(tableNode);
 		else $insertNodeToNearestRoot(tableNode);
 		const firstDescendant = tableNode.getFirstDescendant();
 		if ($isTextNode(firstDescendant)) firstDescendant.select();
 		return true;
-	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_TABLE_COMMAND, ({ table, columnIndex, rowIndex }) => {
-		editor.update(() => {
-			const prevSelection = $getSelection();
-			const tableNode = $getNodeByKey(table);
-			if (!tableNode || !$isTableNode(tableNode)) return;
-			const tableSelection = $isTableSelection(prevSelection) ? prevSelection : $createTableSelection();
-			if (rowIndex !== void 0) {
-				const firstRow = tableNode.getChildren()[rowIndex];
-				if (!firstRow) return;
-				const firstCell = firstRow.getFirstChild();
-				const lastCell = firstRow.getLastChild();
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			} else if (columnIndex !== void 0) {
-				const firstRow = tableNode.getFirstChild();
-				const lastRow = tableNode.getLastChild();
-				if (!firstRow || !lastRow) return;
-				const firstCell = firstRow.getChildren()[columnIndex];
-				const lastCell = lastRow.getChildren()[columnIndex];
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			} else {
-				const firstRow = tableNode.getFirstChild();
-				const lastRow = tableNode.getLastChild();
-				if (!firstRow || !lastRow) return;
-				const firstCell = firstRow.getFirstChild();
-				const lastCell = lastRow.getLastChild();
-				if (!firstCell || !lastCell) return;
-				tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
-				$setSelection(tableSelection);
-			}
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(INSERT_TABLE_COLUMN_COMMAND, ({ table, columnIndex, insertAfter = true }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const [tableMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+		const firstCell = tableMap.find((row) => row[columnIndex])?.[columnIndex]?.cell;
+		const lastCell = [...tableMap].reverse().find((row) => row[columnIndex])?.[columnIndex]?.cell;
+		if (!firstCell || !lastCell) return false;
+		const tableSelection = $createTableSelection();
+		tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+		$setSelection(tableSelection);
+		$insertTableColumnAtSelection(insertAfter);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(INSERT_TABLE_ROW_COMMAND, ({ table, rowIndex, insertAfter = true }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const [tableMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+		const row = tableMap[rowIndex];
+		const firstCell = row?.[0]?.cell;
+		const lastCell = row?.[row.length - 1]?.cell;
+		if (!firstCell || !lastCell) return false;
+		const tableSelection = $createTableSelection();
+		tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+		$setSelection(tableSelection);
+		const insertedRow = $insertTableRowAtSelection(insertAfter);
+		if (insertedRow) $selectFirstDescendant(insertedRow);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SYNC_TABLE_COLUMN_WIDTH_COMMAND, ({ table, columnIndex }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const columnCount = tableNode.getColumnCount();
+		const selectedWidth = (tableNode.getColWidths() || createDefaultTableColWidths(columnCount))[columnIndex];
+		if (selectedWidth === void 0) return false;
+		const nextColWidths = Array.from({ length: columnCount }, () => selectedWidth);
+		tableNode.setColWidths(nextColWidths);
+		requestAnimationFrame(() => {
+			syncTableWidthDOM(editor, table, nextColWidths);
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(AUTO_FIT_TABLE_COLUMN_WIDTH_COMMAND, ({ table, columnIndexes }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const nextColWidths = getAutoFitTableColumnWidths(editor, tableNode, columnIndexes);
+		if (!nextColWidths) return false;
+		tableNode.setColWidths(nextColWidths);
+		requestAnimationFrame(() => {
+			syncTableWidthDOM(editor, table, nextColWidths);
+		});
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(DISTRIBUTE_TABLE_COLUMN_WIDTH_COMMAND, ({ table }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const nextColWidths = getDistributedTableColumnWidths(editor, tableNode);
+		if (!nextColWidths) return false;
+		tableNode.setColWidths(nextColWidths);
+		requestAnimationFrame(() => {
+			syncTableWidthDOM(editor, table, nextColWidths);
+			resetTableScrollLeft(editor, table);
 		});
-		return false;
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(MOVE_TABLE_COLUMN_COMMAND, ({ table, selectedColumns, columnIndex, insertAfter = false }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode) || !$isSimpleTable(tableNode)) return false;
+		const moveRange = getMoveRange(selectedColumns, columnIndex, insertAfter);
+		if (!moveRange) return false;
+		const { count, from, target, to } = moveRange;
+		tableNode.getChildren().filter($isTableRowNode).forEach((row) => {
+			const cells = row.getChildren();
+			const movedCells = cells.slice(from, to + 1);
+			const nextCells = [...cells.slice(0, from), ...cells.slice(to + 1)];
+			nextCells.splice(target, 0, ...movedCells);
+			row.splice(0, cells.length, nextCells);
+		});
+		const colWidths = tableNode.getColWidths();
+		if (colWidths && colWidths.length === tableNode.getColumnCount()) {
+			const movedWidths = colWidths.slice(from, to + 1);
+			const nextWidths = [...colWidths.slice(0, from), ...colWidths.slice(to + 1)];
+			nextWidths.splice(target, 0, ...movedWidths);
+			tableNode.setColWidths(nextWidths);
+		}
+		$selectTableColumns(tableNode, target, target + count - 1);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(MOVE_TABLE_ROW_COMMAND, ({ table, selectedRows, rowIndex, insertAfter = false }) => {
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode) || !$isSimpleTable(tableNode)) return false;
+		const moveRange = getMoveRange(selectedRows, rowIndex, insertAfter);
+		if (!moveRange) return false;
+		const { count, from, target, to } = moveRange;
+		const rows = tableNode.getChildren();
+		const movedRows = rows.slice(from, to + 1);
+		const nextRows = [...rows.slice(0, from), ...rows.slice(to + 1)];
+		nextRows.splice(target, 0, ...movedRows);
+		tableNode.splice(0, rows.length, nextRows);
+		$selectTableRows(tableNode, target, target + count - 1);
+		return true;
+	}, COMMAND_PRIORITY_EDITOR), editor.registerCommand(SELECT_TABLE_COMMAND, ({ table, anchorIndex, columnIndex, extend, rowIndex }) => {
+		const prevSelection = $getSelection();
+		const tableNode = $getNodeByKey(table);
+		if (!tableNode || !$isTableNode(tableNode)) return false;
+		const tableSelection = $isTableSelection(prevSelection) ? prevSelection : $createTableSelection();
+		const [tableMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+		if (rowIndex !== void 0) {
+			const { from, to } = extend ? getRangeFromSelection(prevSelection, table, rowIndex, "row", tableNode.getColumnCount(), anchorIndex) : {
+				from: rowIndex,
+				to: rowIndex
+			};
+			const firstRow = tableMap[from];
+			const lastRow = tableMap[to];
+			const firstCell = firstRow?.[0]?.cell;
+			const lastCell = lastRow?.[lastRow.length - 1]?.cell;
+			if (!firstCell || !lastCell) return false;
+			tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+			$setSelection(tableSelection);
+			return true;
+		}
+		if (columnIndex !== void 0) {
+			const { from, to } = extend ? getRangeFromSelection(prevSelection, table, columnIndex, "column", tableMap.length, anchorIndex) : {
+				from: columnIndex,
+				to: columnIndex
+			};
+			const firstCell = tableMap.find((row) => row[from])?.[from]?.cell;
+			const lastCell = [...tableMap].reverse().find((row) => row[to])?.[to]?.cell;
+			if (!firstCell || !lastCell) return false;
+			tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+			$setSelection(tableSelection);
+			return true;
+		}
+		const firstRow = tableMap[0];
+		const lastRow = tableMap.at(-1);
+		const firstCell = firstRow?.[0]?.cell;
+		const lastCell = lastRow?.[lastRow.length - 1]?.cell;
+		if (!firstCell || !lastCell) return false;
+		tableSelection.set(table, firstCell.getKey(), lastCell.getKey());
+		$setSelection(tableSelection);
+		return true;
 	}, COMMAND_PRIORITY_EDITOR));
 }
 //#endregion
-export { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND, registerTableCommand };
+export { AUTO_FIT_TABLE_COLUMN_WIDTH_COMMAND, DISTRIBUTE_TABLE_COLUMN_WIDTH_COMMAND, INSERT_TABLE_COLUMN_COMMAND, INSERT_TABLE_COMMAND, INSERT_TABLE_ROW_COMMAND, MOVE_TABLE_COLUMN_COMMAND, MOVE_TABLE_ROW_COMMAND, SELECT_TABLE_COMMAND, SYNC_TABLE_COLUMN_WIDTH_COMMAND, registerTableCommand };

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

@@ -1,3 +1,4 @@
-import { INSERT_TABLE_COMMAND, SELECT_TABLE_COMMAND } from "./command/index.js";
+import { INSERT_TABLE_COLUMN_COMMAND, INSERT_TABLE_COMMAND, INSERT_TABLE_ROW_COMMAND, SELECT_TABLE_COMMAND } from "./command/index.js";
 import { TablePlugin, TablePluginOptions } from "./plugin/index.js";
-import { ReactTablePlugin } from "./react/index.js";
+import { ReactTablePlugin } from "./react/index.js";
+import { ITableControllerMenuActionItem, ITableControllerMenuItem, ITableControllerMenuRenderContext, ITableControllerMenuSeparatorItem, ITableControllerMenuService, TableControllerMenuAxis, TableControllerMenuService } from "./service/i-table-controller-menu-service.js";

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

@@ -0,0 +1,2 @@
+import { TableNode as TableNode$1 } from "@lexical/table";
+export { TableNode$1 as TableNode };