@lobehub/editor 1.0.0

package/es/plugins/table/react/TableActionMenu/index.js

@@ -0,0 +1,481 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { $computeTableMapSkipCellCheck, $deleteTableColumnAtSelection, $deleteTableRowAtSelection, $getTableCellNodeFromLexicalNode, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $insertTableColumnAtSelection, $insertTableRowAtSelection, $isTableCellNode, $isTableSelection, $mergeCells, $unmergeCell, TableCellHeaderStates, TableCellNode, getTableElement, getTableObserverFromTableElement } from '@lexical/table';
+import { mergeRegister } from '@lexical/utils';
+import { ActionIcon, Dropdown } from '@lobehub/ui';
+import { $getSelection, $isRangeSelection, $setSelection, COMMAND_PRIORITY_CRITICAL, SELECTION_CHANGE_COMMAND, getDOMSelection } from 'lexical';
+import { ChevronDown, Grid2X2XIcon, PanelBottomCloseIcon, PanelLeftCloseIcon, PanelRightCloseIcon, PanelTopCloseIcon, TableColumnsSplitIcon, TableRowsSplitIcon } from 'lucide-react';
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { useTranslation } from "../../../../editor-kernel/react/useTranslation";
+import { useStyles } from "./style";
+import { $canUnmerge, $selectLastDescendant, computeSelectionCount, currentCellBackgroundColor } from "./utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+var TableActionMenu = /*#__PURE__*/memo(function (_ref) {
+  var editor = _ref.editor,
+    _tableCellNode = _ref.tableCellNode,
+    cellMerge = _ref.cellMerge,
+    children = _ref.children;
+  var _useState = useState(_tableCellNode),
+    _useState2 = _slicedToArray(_useState, 2),
+    tableCellNode = _useState2[0],
+    updateTableCellNode = _useState2[1];
+  var _useState3 = useState({
+      columns: 1,
+      rows: 1
+    }),
+    _useState4 = _slicedToArray(_useState3, 2),
+    selectionCounts = _useState4[0],
+    updateSelectionCounts = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    canMergeCells = _useState6[0],
+    setCanMergeCells = _useState6[1];
+  var _useState7 = useState(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    canUnmergeCell = _useState8[0],
+    setCanUnmergeCell = _useState8[1];
+  var _useState9 = useState(function () {
+      return currentCellBackgroundColor(editor) || '';
+    }),
+    _useState10 = _slicedToArray(_useState9, 2),
+    setBackgroundColor = _useState10[1];
+  var t = useTranslation();
+  useEffect(function () {
+    return editor.registerMutationListener(TableCellNode, function (nodeMutations) {
+      var nodeUpdated = nodeMutations.get(tableCellNode.getKey()) === 'updated';
+      if (nodeUpdated) {
+        editor.getEditorState().read(function () {
+          updateTableCellNode(tableCellNode.getLatest());
+        });
+        setBackgroundColor(currentCellBackgroundColor(editor) || '');
+      }
+    }, {
+      skipInitialization: true
+    });
+  }, [editor, tableCellNode]);
+  useEffect(function () {
+    editor.getEditorState().read(function () {
+      var selection = $getSelection();
+      // Merge cells
+      if ($isTableSelection(selection)) {
+        var currentSelectionCounts = computeSelectionCount(selection);
+        updateSelectionCounts(computeSelectionCount(selection));
+        setCanMergeCells(currentSelectionCounts.columns > 1 || currentSelectionCounts.rows > 1);
+      }
+      // Unmerge cell
+      setCanUnmergeCell($canUnmerge());
+    });
+  }, [editor]);
+  var clearTableSelection = useCallback(function () {
+    editor.update(function () {
+      if (tableCellNode.isAttached()) {
+        var tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+        var tableElement = getTableElement(tableNode, editor.getElementByKey(tableNode.getKey()));
+        if (tableElement === null) {
+          throw new Error('TableActionMenu: Expected to find tableElement in DOM');
+        }
+        var tableObserver = getTableObserverFromTableElement(tableElement);
+        if (tableObserver !== null) {
+          tableObserver.$clearHighlight();
+        }
+        tableNode.markDirty();
+        updateTableCellNode(tableCellNode.getLatest());
+      }
+      $setSelection(null);
+    });
+  }, [editor, tableCellNode]);
+  var mergeTableCellsAtSelection = function mergeTableCellsAtSelection() {
+    editor.update(function () {
+      var selection = $getSelection();
+      if (!$isTableSelection(selection)) {
+        return;
+      }
+      var nodes = selection.getNodes();
+      var tableCells = nodes.filter($isTableCellNode);
+      var targetCell = $mergeCells(tableCells);
+      if (targetCell) {
+        $selectLastDescendant(targetCell);
+      }
+    });
+  };
+  var unmergeTableCellsAtSelection = function unmergeTableCellsAtSelection() {
+    editor.update(function () {
+      $unmergeCell();
+    });
+  };
+  var insertTableRowAtSelection = useCallback(function (shouldInsertAfter) {
+    editor.update(function () {
+      for (var i = 0; i < selectionCounts.rows; i++) {
+        $insertTableRowAtSelection(shouldInsertAfter);
+      }
+    });
+  }, [editor, selectionCounts.rows]);
+  var insertTableColumnAtSelection = useCallback(function (shouldInsertAfter) {
+    editor.update(function () {
+      for (var i = 0; i < selectionCounts.columns; i++) {
+        $insertTableColumnAtSelection(shouldInsertAfter);
+      }
+    });
+  }, [editor, selectionCounts.columns]);
+  var deleteTableRowAtSelection = useCallback(function () {
+    editor.update(function () {
+      $deleteTableRowAtSelection();
+    });
+  }, [editor]);
+  var deleteTableAtSelection = useCallback(function () {
+    editor.update(function () {
+      var tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      tableNode.remove();
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  var deleteTableColumnAtSelection = useCallback(function () {
+    editor.update(function () {
+      $deleteTableColumnAtSelection();
+    });
+  }, [editor]);
+  var toggleTableRowIsHeader = useCallback(function () {
+    editor.update(function () {
+      var tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      var tableRowIndex = $getTableRowIndexFromTableCellNode(tableCellNode);
+      var _$computeTableMapSkip = $computeTableMapSkipCellCheck(tableNode, null, null),
+        _$computeTableMapSkip2 = _slicedToArray(_$computeTableMapSkip, 1),
+        gridMap = _$computeTableMapSkip2[0];
+      var rowCells = new Set();
+      var newStyle = tableCellNode.getHeaderStyles() ^ TableCellHeaderStates.ROW;
+      for (var col = 0; col < gridMap[tableRowIndex].length; col++) {
+        var mapCell = gridMap[tableRowIndex][col];
+        if (!(mapCell !== null && mapCell !== void 0 && mapCell.cell)) {
+          continue;
+        }
+        if (!rowCells.has(mapCell.cell)) {
+          rowCells.add(mapCell.cell);
+          mapCell.cell.setHeaderStyles(newStyle, TableCellHeaderStates.ROW);
+        }
+      }
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  var toggleTableColumnIsHeader = useCallback(function () {
+    editor.update(function () {
+      var tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      var tableColumnIndex = $getTableColumnIndexFromTableCellNode(tableCellNode);
+      var _$computeTableMapSkip3 = $computeTableMapSkipCellCheck(tableNode, null, null),
+        _$computeTableMapSkip4 = _slicedToArray(_$computeTableMapSkip3, 1),
+        gridMap = _$computeTableMapSkip4[0];
+      var columnCells = new Set();
+      var newStyle = tableCellNode.getHeaderStyles() ^ TableCellHeaderStates.COLUMN;
+      var _iterator = _createForOfIteratorHelper(gridMap),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var element = _step.value;
+          var mapCell = element[tableColumnIndex];
+          if (!(mapCell !== null && mapCell !== void 0 && mapCell.cell)) {
+            continue;
+          }
+          if (!columnCells.has(mapCell.cell)) {
+            columnCells.add(mapCell.cell);
+            mapCell.cell.setHeaderStyles(newStyle, TableCellHeaderStates.COLUMN);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+
+  // Create menu items array with useMemo for performance
+  var menuItems = useMemo(function () {
+    return [
+    // // Merge/Unmerge cells (conditional)
+    // ...(cellMerge && canMergeCells
+    //   ? [
+    //       {
+    //         key: 'table-merge-cells',
+    //         label: 'Merge cells',
+    //         onClick: () => mergeTableCellsAtSelection(),
+    //       },
+    //     ]
+    //   : []),
+    // ...(cellMerge && canUnmergeCell
+    //   ? [
+    //       {
+    //         key: 'table-unmerge-cells',
+    //         label: 'Unmerge cells',
+    //         onClick: () => unmergeTableCellsAtSelection(),
+    //       },
+    //     ]
+    //   : []),
+    // // Divider after merge operations (if any merge operations exist)
+    // ...(cellMerge && (canMergeCells || canUnmergeCell) ? [{ type: 'divider' as const }] : []),
+    //
+    // // Row operations
+    {
+      icon: PanelTopCloseIcon,
+      key: 'table-insert-row-above',
+      label: t("table.insertRowAbove", {
+        count: selectionCounts.rows
+      }),
+      onClick: function onClick() {
+        return insertTableRowAtSelection(false);
+      }
+    }, {
+      icon: PanelBottomCloseIcon,
+      key: 'table-insert-row-below',
+      label: t("table.insertRowBelow", {
+        count: selectionCounts.rows
+      }),
+      onClick: function onClick() {
+        return insertTableRowAtSelection(true);
+      }
+    }, {
+      type: 'divider'
+    },
+    // Column operations
+    {
+      icon: PanelLeftCloseIcon,
+      key: 'table-insert-column-before',
+      // label: `Insert ${selectionCounts.columns === 1 ? 'column' : `${selectionCounts.columns} columns`} left`,
+      label: t("table.insertColumnLeft", {
+        count: selectionCounts.columns
+      }),
+      onClick: function onClick() {
+        return insertTableColumnAtSelection(false);
+      }
+    }, {
+      icon: PanelRightCloseIcon,
+      key: 'table-insert-column-after',
+      // label: `Insert ${selectionCounts.columns === 1 ? 'column' : `${selectionCounts.columns} columns`} right`,
+      label: t("table.insertColumnRight", {
+        count: selectionCounts.columns
+      }),
+      onClick: function onClick() {
+        return insertTableColumnAtSelection(true);
+      }
+    }, {
+      type: 'divider'
+    },
+    // Delete operations
+    {
+      icon: TableColumnsSplitIcon,
+      key: 'table-delete-columns',
+      // label: 'Delete column',
+      label: t("table.deleteColumn"),
+      onClick: function onClick() {
+        return deleteTableColumnAtSelection();
+      }
+    }, {
+      icon: TableRowsSplitIcon,
+      key: 'table-delete-rows',
+      // label: 'Delete row',
+      label: t("table.deleteRow"),
+      onClick: function onClick() {
+        return deleteTableRowAtSelection();
+      }
+    }, {
+      type: 'divider'
+    }, {
+      icon: Grid2X2XIcon,
+      key: 'table-delete',
+      // label: 'Delete table',
+      label: t("table.delete"),
+      onClick: function onClick() {
+        return deleteTableAtSelection();
+      }
+    }];
+  }, [cellMerge, canMergeCells, canUnmergeCell, selectionCounts.rows, selectionCounts.columns, tableCellNode.__headerState, mergeTableCellsAtSelection, unmergeTableCellsAtSelection, insertTableRowAtSelection, insertTableColumnAtSelection, deleteTableColumnAtSelection, deleteTableRowAtSelection, deleteTableAtSelection, toggleTableRowIsHeader, toggleTableColumnIsHeader]);
+  return /*#__PURE__*/_jsx(Dropdown, {
+    menu: {
+      items: menuItems
+    },
+    children: children
+  });
+});
+function TableCellActionMenuContainer(_ref2) {
+  var anchorElem = _ref2.anchorElem,
+    cellMerge = _ref2.cellMerge,
+    editor = _ref2.editor;
+  var menuButtonRef = useRef(null);
+  var _useState11 = useState(null),
+    _useState12 = _slicedToArray(_useState11, 2),
+    tableCellNode = _useState12[0],
+    setTableMenuCellNode = _useState12[1];
+
+  // const [colorPickerModal, showColorPickerModal] = useModal();
+
+  var checkTableCellOverflow = useCallback(function (tableCellParentNodeDOM) {
+    var scrollableContainer = tableCellParentNodeDOM.closest('.PlaygroundEditorTheme__tableScrollableWrapper');
+    if (scrollableContainer) {
+      var containerRect = scrollableContainer.getBoundingClientRect();
+      var cellRect = tableCellParentNodeDOM.getBoundingClientRect();
+
+      // Calculate where the action button would be positioned (5px from right edge of cell)
+      // Also account for the button width and table cell padding (8px)
+      var actionButtonRight = cellRect.right - 5;
+      var actionButtonLeft = actionButtonRight - 28; // 20px width + 8px padding
+
+      // Only hide if the action button would overflow the container
+      if (actionButtonRight > containerRect.right || actionButtonLeft < containerRect.left) {
+        return true;
+      }
+    }
+    return false;
+  }, []);
+  var $moveMenu = useCallback(function () {
+    var menu = menuButtonRef.current;
+    var selection = $getSelection();
+    var nativeSelection = getDOMSelection(editor._window);
+    var activeElement = typeof document !== 'undefined' ? document.activeElement : null;
+    function disable() {
+      if (menu) {
+        menu.classList.remove('table-cell-action-button-container--active');
+        menu.classList.add('table-cell-action-button-container--inactive');
+      }
+      setTableMenuCellNode(null);
+    }
+    if (!selection || !menu) {
+      return disable();
+    }
+    var rootElement = editor.getRootElement();
+    var tableObserver = null;
+    var tableCellParentNodeDOM = null;
+    if ($isRangeSelection(selection) && rootElement !== null && nativeSelection !== null && rootElement.contains(nativeSelection.anchorNode)) {
+      var tableCellNodeFromSelection = $getTableCellNodeFromLexicalNode(selection.anchor.getNode());
+      if (!tableCellNodeFromSelection) {
+        return disable();
+      }
+      tableCellParentNodeDOM = editor.getElementByKey(tableCellNodeFromSelection.getKey());
+      if (!tableCellParentNodeDOM || !tableCellNodeFromSelection.isAttached()) {
+        return disable();
+      }
+      if (checkTableCellOverflow(tableCellParentNodeDOM)) {
+        return disable();
+      }
+      var tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNodeFromSelection);
+      var tableElement = getTableElement(tableNode, editor.getElementByKey(tableNode.getKey()));
+      if (tableElement === null) {
+        throw new Error('TableActionMenu: Expected to find tableElement in DOM');
+      }
+      tableObserver = getTableObserverFromTableElement(tableElement);
+      setTableMenuCellNode(tableCellNodeFromSelection);
+    } else if ($isTableSelection(selection)) {
+      var anchorNode = $getTableCellNodeFromLexicalNode(selection.anchor.getNode());
+      if (!$isTableCellNode(anchorNode)) {
+        throw new Error('TableSelection anchorNode must be a TableCellNode');
+      }
+      var _tableNode = $getTableNodeFromLexicalNodeOrThrow(anchorNode);
+      var _tableElement = getTableElement(_tableNode, editor.getElementByKey(_tableNode.getKey()));
+      if (_tableElement === null) {
+        throw new Error('TableActionMenu: Expected to find tableElement in DOM');
+      }
+      tableObserver = getTableObserverFromTableElement(_tableElement);
+      tableCellParentNodeDOM = editor.getElementByKey(anchorNode.getKey());
+      if (tableCellParentNodeDOM === null) {
+        return disable();
+      }
+      if (checkTableCellOverflow(tableCellParentNodeDOM)) {
+        return disable();
+      }
+    } else if (!activeElement) {
+      return disable();
+    }
+    if (tableObserver === null || tableCellParentNodeDOM === null) {
+      return disable();
+    }
+    var enabled = !tableObserver || !tableObserver.isSelecting;
+    menu.classList.toggle('table-cell-action-button-container--active', enabled);
+    menu.classList.toggle('table-cell-action-button-container--inactive', !enabled);
+    if (enabled) {
+      var tableCellRect = tableCellParentNodeDOM.getBoundingClientRect();
+      var anchorRect = anchorElem.getBoundingClientRect();
+      var top = tableCellRect.top - anchorRect.top;
+      var left = tableCellRect.right - anchorRect.left;
+      menu.style.transform = "translate(".concat(left, "px, ").concat(top, "px)");
+    }
+  }, [editor, anchorElem, checkTableCellOverflow]);
+  useEffect(function () {
+    // We call the $moveMenu callback every time the selection changes,
+    // once up front, and once after each pointerUp
+    var timeoutId = undefined;
+    var callback = function callback() {
+      timeoutId = undefined;
+      editor.getEditorState().read($moveMenu);
+    };
+    var delayedCallback = function delayedCallback() {
+      if (timeoutId === undefined) {
+        timeoutId = setTimeout(callback, 0);
+      }
+      return false;
+    };
+    return mergeRegister(editor.registerUpdateListener(delayedCallback), editor.registerCommand(SELECTION_CHANGE_COMMAND, delayedCallback, COMMAND_PRIORITY_CRITICAL), editor.registerRootListener(function (rootElement, prevRootElement) {
+      if (prevRootElement) {
+        prevRootElement.removeEventListener('pointerup', delayedCallback);
+      }
+      if (rootElement) {
+        rootElement.addEventListener('pointerup', delayedCallback);
+        delayedCallback();
+      }
+    }), function () {
+      return clearTimeout(timeoutId);
+    });
+  });
+  var prevTableCellDOM = useRef(tableCellNode);
+  useEffect(function () {
+    prevTableCellDOM.current = tableCellNode;
+  }, [prevTableCellDOM, tableCellNode]);
+  var _useStyles = useStyles(),
+    styles = _useStyles.styles;
+  return /*#__PURE__*/_jsx("div", {
+    className: styles,
+    ref: menuButtonRef,
+    children: tableCellNode && /*#__PURE__*/_jsx(TableActionMenu, {
+      cellMerge: cellMerge,
+      editor: editor,
+      tableCellNode: tableCellNode,
+      children: /*#__PURE__*/_jsx(ActionIcon, {
+        glass: true,
+        icon: ChevronDown,
+        size: 'small',
+        style: {
+          position: 'absolute',
+          right: 4,
+          top: 4
+        },
+        variant: 'filled'
+      })
+    })
+  });
+}
+export default /*#__PURE__*/memo(function (_ref3) {
+  var anchorElem = _ref3.anchorElem,
+    _ref3$cellMerge = _ref3.cellMerge,
+    cellMerge = _ref3$cellMerge === void 0 ? false : _ref3$cellMerge,
+    editor = _ref3.editor;
+  // Don't render portal on server side
+  if (typeof document === 'undefined') {
+    return null;
+  }
+  var targetElement = anchorElem || document.body;
+  return /*#__PURE__*/createPortal( /*#__PURE__*/_jsx(TableCellActionMenuContainer, {
+    anchorElem: targetElement,
+    cellMerge: cellMerge,
+    editor: editor
+  }), targetElement);
+});

package/es/plugins/table/react/TableActionMenu/style.d.ts

@@ -0,0 +1 @@
+export declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<import("antd-style").SerializedStyles>;

package/es/plugins/table/react/TableActionMenu/style.js

@@ -0,0 +1,7 @@
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css;
+  return css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    will-change: transform;\n\n    position: absolute;\n    z-index: 3;\n    inset-block-start: 0;\n    inset-inline-start: 0;\n  "])));
+});

package/es/plugins/table/react/TableActionMenu/utils.d.ts

@@ -0,0 +1,9 @@
+import { TableSelection } from '@lexical/table';
+import { type ElementNode, type LexicalEditor } from 'lexical';
+export declare function computeSelectionCount(selection: TableSelection): {
+    columns: number;
+    rows: number;
+};
+export declare function $canUnmerge(): boolean;
+export declare function $selectLastDescendant(node: ElementNode): void;
+export declare function currentCellBackgroundColor(editor: LexicalEditor): null | string;

package/es/plugins/table/react/TableActionMenu/utils.js

@@ -0,0 +1,49 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { $getNodeTriplet, $isTableCellNode, $isTableSelection } from '@lexical/table';
+import { $getSelection, $isElementNode, $isRangeSelection, $isTextNode } from 'lexical';
+export function computeSelectionCount(selection) {
+  var selectionShape = selection.getShape();
+  return {
+    columns: selectionShape.toX - selectionShape.fromX + 1,
+    rows: selectionShape.toY - selectionShape.fromY + 1
+  };
+}
+export function $canUnmerge() {
+  var selection = $getSelection();
+  if ($isRangeSelection(selection) && !selection.isCollapsed() || $isTableSelection(selection) && !selection.anchor.is(selection.focus) || !$isRangeSelection(selection) && !$isTableSelection(selection)) {
+    return false;
+  }
+  var _$getNodeTriplet = $getNodeTriplet(selection.anchor),
+    _$getNodeTriplet2 = _slicedToArray(_$getNodeTriplet, 1),
+    cell = _$getNodeTriplet2[0];
+  return cell.__colSpan > 1 || cell.__rowSpan > 1;
+}
+export function $selectLastDescendant(node) {
+  var lastDescendant = node.getLastDescendant();
+  if ($isTextNode(lastDescendant)) {
+    lastDescendant.select();
+  } else if ($isElementNode(lastDescendant)) {
+    lastDescendant.selectEnd();
+  } else if (lastDescendant !== null) {
+    lastDescendant.selectNext();
+  }
+}
+export function currentCellBackgroundColor(editor) {
+  return editor.getEditorState().read(function () {
+    var selection = $getSelection();
+    if ($isRangeSelection(selection) || $isTableSelection(selection)) {
+      var _$getNodeTriplet3 = $getNodeTriplet(selection.anchor),
+        _$getNodeTriplet4 = _slicedToArray(_$getNodeTriplet3, 1),
+        cell = _$getNodeTriplet4[0];
+      if ($isTableCellNode(cell)) {
+        return cell.getBackgroundColor();
+      }
+    }
+    return null;
+  });
+}

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { LexicalEditor } from 'lexical';
+declare const _default: import("react").MemoExoticComponent<({ anchorElem, editor }: {
+    anchorElem?: HTMLElement | undefined;
+    editor: LexicalEditor;
+}) => import("react").ReactPortal | null>;
+export default _default;