@lobehub/editor 4.15.1 → 4.16.0

package/es/plugins/slash/react/type.d.ts

@@ -0,0 +1,114 @@
+import { IEditor } from "../../../types/kernel.js";
+import { ISlashMenuOption, ISlashOption, SlashOptions } from "../service/i-slash-service.js";
+import { FC, ReactElement } from "react";
+import { IFuseOptions } from "fuse.js";
+
+//#region src/plugins/slash/react/type.d.ts
+interface ReactSlashOptionProps {
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  /**
+   * Searchable options
+   */
+  items?: SlashOptions['items'];
+  /**
+   * Maximum search length
+   * Default is 75
+   */
+  maxLength?: number;
+  onSelect?: (editor: IEditor, option: ISlashMenuOption) => void;
+  /**
+   * Custom render component
+   */
+  renderComp?: FC<MenuRenderProps>;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  /**
+   * Trigger character
+   */
+  trigger?: SlashOptions['trigger'];
+}
+interface MenuRenderProps {
+  /**
+   * Current active option key
+   */
+  activeKey: string | null;
+  /**
+   * Loading state
+   */
+  loading?: boolean;
+  /**
+   * Actively trigger selection
+   * @param option Currently selected element
+   */
+  onSelect?: (option: ISlashMenuOption) => void;
+  open?: boolean;
+  /**
+   * Currently searched options
+   */
+  options: Array<ISlashOption>;
+  /**
+   * Actively set current active option key
+   * @param key
+   * @returns
+   */
+  setActiveKey: (key: string | null) => void;
+}
+/**
+ * SlashMenu component props - only responsible for rendering
+ */
+interface SlashMenuProps {
+  /** Current active option key */
+  activeKey: string | null;
+  /** Anchor element className */
+  anchorClassName?: string;
+  /** Custom render component if provided */
+  customRender?: FC<MenuRenderProps>;
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Loading state */
+  loading: boolean;
+  /** Callback to set active key */
+  onActiveKeyChange: (key: string | null) => void;
+  /** Callback when menu should close */
+  onClose: () => void;
+  /** Callback when an option is selected */
+  onSelect: (option: ISlashMenuOption) => void;
+  /** Whether the menu is open */
+  open: boolean;
+  /** Available options to display */
+  options: Array<ISlashOption>;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+  /** Menu position */
+  position: {
+    getRect?: () => DOMRect;
+    rect?: DOMRect;
+    x: number;
+    y: number;
+  };
+}
+interface ReactSlashPluginProps {
+  anchorClassName?: string;
+  children?: (ReactElement<ReactSlashOptionProps> | undefined) | (ReactElement<ReactSlashOptionProps> | undefined)[];
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+}
+//#endregion
+export { MenuRenderProps, ReactSlashOptionProps, ReactSlashPluginProps, SlashMenuProps };

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

@@ -0,0 +1,18 @@
+//#region src/plugins/slash/react/utils.ts
+function setCancelablePromise(executor) {
+	let isCancelled = false;
+	return {
+		cancel: () => {
+			isCancelled = true;
+		},
+		promise: new Promise((resolve, reject) => {
+			executor((value) => {
+				if (!isCancelled) resolve(value);
+			}, (reason) => {
+				if (!isCancelled) reject(reason);
+			});
+		})
+	};
+}
+//#endregion
+export { setCancelablePromise };

package/es/plugins/slash/service/i-slash-service.d.ts

@@ -0,0 +1,50 @@
+import { IEditor, IServiceID } from "../../../types/kernel.js";
+import { DropdownMenuItemType } from "@lobehub/ui";
+import Fuse, { IFuseOptions } from "fuse.js";
+
+//#region src/plugins/slash/service/i-slash-service.d.ts
+type ISlashDividerOption = {
+  type: 'divider';
+};
+interface ISlashMenuOption extends DropdownMenuItemType {
+  metadata?: Record<string, any>;
+  onSelect?: (editor: IEditor, matchingString: string) => void;
+}
+type ISlashOption = ISlashMenuOption | ISlashDividerOption;
+interface SlashOptions {
+  allowWhitespace?: boolean;
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  items: Array<ISlashOption> | ((search: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+  } | null) => Promise<Array<ISlashOption>>);
+  maxLength?: number;
+  minLength?: number;
+  punctuation?: string;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  trigger: string;
+}
+interface ISlashService {
+  registerSlash(options: SlashOptions): void;
+  updateOptions(options: SlashOptions[]): void;
+}
+declare const ISlashService: IServiceID<ISlashService>;
+//#endregion
+export { ISlashMenuOption, ISlashOption, ISlashService, SlashOptions };

package/es/plugins/slash/service/i-slash-service.js

@@ -0,0 +1,55 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { genServiceId } from "../../../editor-kernel/utils.js";
+import { getBasicTypeaheadTriggerMatch } from "../utils/utils.js";
+import Fuse from "fuse.js";
+//#region src/plugins/slash/service/i-slash-service.ts
+init_debug();
+const ISlashService = genServiceId("SlashService");
+var SlashService = class {
+	constructor(kernel) {
+		this.kernel = kernel;
+		this.triggerMap = /* @__PURE__ */ new Map();
+		this.triggerFnMap = /* @__PURE__ */ new Map();
+		this.triggerFuseMap = /* @__PURE__ */ new Map();
+		this.logger = createDebugLogger("service", "slash");
+	}
+	registerSlash(options, update = false) {
+		if (this.triggerMap.has(options.trigger) && !update) if (this.kernel.isHotReloadMode()) this.logger.warn(`🔄 Overriding slash trigger "${options.trigger}"`);
+		else throw new Error(`Slash trigger "${options.trigger}" is already registered.`);
+		this.triggerMap.set(options.trigger, options);
+		this.triggerFnMap.set(options.trigger, getBasicTypeaheadTriggerMatch(options.trigger, {
+			allowWhitespace: options.allowWhitespace,
+			maxLength: options.maxLength,
+			minLength: options.minLength,
+			punctuation: options.punctuation
+		}));
+		this.logger.debug(`⚡ Slash trigger: ${options.trigger}`);
+		if (Array.isArray(options.items)) {
+			const searchableItems = options.items.filter((item) => !("type" in item) || item.type !== "divider");
+			const fuseConfig = options.fuseOptions || { keys: options.searchKeys || ["key"] };
+			this.triggerFuseMap.set(options.trigger, new Fuse(searchableItems, fuseConfig));
+		}
+	}
+	removeAllOptions() {
+		this.triggerMap.clear();
+		this.triggerFnMap.clear();
+		this.triggerFuseMap.clear();
+	}
+	updateOptions(options) {
+		this.removeAllOptions();
+		options.forEach((option) => {
+			this.registerSlash(option);
+		});
+	}
+	getSlashOptions(trigger) {
+		return this.triggerMap.get(trigger);
+	}
+	getSlashTriggerFn(trigger) {
+		return this.triggerFnMap.get(trigger);
+	}
+	getSlashFuse(trigger) {
+		return this.triggerFuseMap.get(trigger);
+	}
+};
+//#endregion
+export { ISlashService, SlashService };

package/es/plugins/slash/utils/utils.d.ts

@@ -0,0 +1 @@
+import { LexicalEditor, RangeSelection, TextNode } from "lexical";

package/es/plugins/slash/utils/utils.js

@@ -0,0 +1,97 @@
+import { $getSelection, $isRangeSelection, getDOMSelection } from "lexical";
+//#region src/plugins/slash/utils/utils.ts
+/**
+* Get the text content of the editor up to the anchor point of the selection.
+* Get the text content before the anchor point of the selection
+* @param selection Selection object from Lexical editor
+* @returns
+*/
+function getTextUpToAnchor(selection) {
+	const anchor = selection.anchor;
+	if (anchor.type !== "text") return null;
+	const anchorNode = anchor.getNode();
+	if (!anchorNode.isSimpleText()) return null;
+	const anchorOffset = anchor.offset;
+	return anchorNode.getTextContent().slice(0, anchorOffset);
+}
+/**
+*
+* @param editor Lexical editor instance
+* Get the text content before the selection anchor point in the editor
+* @returns
+*/
+function getQueryTextForSearch(editor) {
+	let text = null;
+	editor.getEditorState().read(() => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return;
+		text = getTextUpToAnchor(selection);
+	});
+	return text;
+}
+function tryToPositionRange(leadOffset, range, editorWindow) {
+	const domSelection = getDOMSelection(editorWindow);
+	if (domSelection === null || !domSelection.isCollapsed) return false;
+	const anchorNode = domSelection.anchorNode;
+	const startOffset = leadOffset;
+	const endOffset = domSelection.anchorOffset;
+	if (anchorNode === null || endOffset === null) return false;
+	try {
+		range.setStart(anchorNode, startOffset);
+		range.setEnd(anchorNode, endOffset);
+	} catch {
+		return false;
+	}
+	return true;
+}
+const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
+function getBasicTypeaheadTriggerMatch(trigger, { minLength = 0, maxLength = 75, punctuation = PUNCTUATION, allowWhitespace = false }) {
+	return (text) => {
+		const validCharsSuffix = allowWhitespace ? "" : "\\s";
+		const validChars = "[^" + trigger + punctuation + validCharsSuffix + "]";
+		const regexPattern = allowWhitespace ? "(^|\\s|\\()([" + trigger + "]((?:" + validChars + "){0," + maxLength + "}))$" : "(^|\\s|\\()([" + trigger + "]((?:" + validChars + ")*?))(?=\\s|$)";
+		const match = new RegExp(regexPattern).exec(text);
+		if (match !== null) {
+			const maybeLeadingWhitespace = match[1];
+			const matchingString = match[3];
+			if (matchingString.length >= minLength && matchingString.length <= maxLength) return {
+				leadOffset: match.index + maybeLeadingWhitespace.length,
+				matchingString,
+				replaceableString: match[2]
+			};
+		}
+		return null;
+	};
+}
+/**
+* Walk backwards along user input and forward through entity title to try
+* and replace more of the user's text with entity.
+*/
+function getFullMatchOffset(documentText, entryText, offset) {
+	let triggerOffset = offset;
+	for (let i = triggerOffset; i <= entryText.length; i++) if (documentText.slice(-i) === entryText.slice(0, Math.max(0, i))) triggerOffset = i;
+	return triggerOffset;
+}
+/**
+* Split Lexical TextNode and return a new TextNode only containing matched text.
+* Common use cases include: removing the node, replacing with a new node.
+*/
+function $splitNodeContainingQuery(match) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection) || !selection.isCollapsed()) return null;
+	const anchor = selection.anchor;
+	if (anchor.type !== "text") return null;
+	const anchorNode = anchor.getNode();
+	if (!anchorNode.isSimpleText()) return null;
+	const selectionOffset = anchor.offset;
+	const textContent = anchorNode.getTextContent().slice(0, selectionOffset);
+	const characterOffset = match.replaceableString.length;
+	const startOffset = selectionOffset - getFullMatchOffset(textContent, match.matchingString, characterOffset);
+	if (startOffset < 0) return null;
+	let newNode;
+	if (startOffset === 0) [newNode] = anchorNode.splitText(selectionOffset);
+	else [, newNode] = anchorNode.splitText(startOffset, selectionOffset);
+	return newNode;
+}
+//#endregion
+export { $splitNodeContainingQuery, getBasicTypeaheadTriggerMatch, getQueryTextForSearch, tryToPositionRange };

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

@@ -0,0 +1,29 @@
+import { InsertTableCommandPayloadHeaders } from "@lexical/table";
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/table/command/index.d.ts
+declare const INSERT_TABLE_COMMAND: _$lexical.LexicalCommand<{
+  columns: string;
+  includeHeaders?: InsertTableCommandPayloadHeaders;
+  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_COLUMN_COMMAND, INSERT_TABLE_COMMAND, INSERT_TABLE_ROW_COMMAND, SELECT_TABLE_COMMAND };

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

@@ -0,0 +1,238 @@
+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;
+		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(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 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 { 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

@@ -0,0 +1,4 @@
+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 { 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 };