@ctzhian/tiptap 3.0.0 → 3.0.2

package/dist/extension/component/TableCellHandleMenu/index.js

@@ -0,0 +1,512 @@
+var _excluded = ["editor", "onOpenChange", "className", "onResizeStart"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { Menu } from "../../../component";
+import { AlignBottomIcon, AlignCenterIcon, AlignJustifyIcon, AlignLeftIcon, AlignRightIcon, AlignTopIcon, ArrowDownSLineIcon, BrushLineIcon, DeleteLineIcon, MergeCellsVerticalIcon, MoreLineIcon, SplitCellsVerticalIcon } from "../../../component/Icons";
+import { DeleteBack2LineIcon } from "../../../component/Icons/delete-back-2-line-icon";
+import { getThemeTextBgColor, getThemeTextColor } from "../../../contants/enums";
+import { Box, Divider, Typography } from '@mui/material';
+import { useTheme } from '@mui/material/styles';
+import { TextSelection } from '@tiptap/pm/state';
+import { CellSelection, cellAround, deleteCellSelection, mergeCells, splitCell } from '@tiptap/pm/tables';
+import { useEditorState } from '@tiptap/react';
+import React, { forwardRef, useCallback, useEffect, useState } from 'react';
+export var TableCellHandleMenu = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var editor = _ref.editor,
+    onOpenChange = _ref.onOpenChange,
+    className = _ref.className,
+    onResizeStart = _ref.onResizeStart,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isMenuOpen = _useState2[0],
+    setIsMenuOpen = _useState2[1];
+  var theme = useTheme();
+  var editorState = useEditorState({
+    editor: editor,
+    selector: function selector(context) {
+      if (!context.editor) return null;
+      return {
+        selection: context.editor.state.selection,
+        isEditable: context.editor.isEditable
+      };
+    }
+  });
+  var handleMenuToggle = useCallback(function (isOpen) {
+    setIsMenuOpen(isOpen);
+    if (!editor) return;
+    if (isOpen) {
+      editor.commands.freezeHandles();
+    } else {
+      editor.commands.unfreezeHandles();
+    }
+  }, [editor]);
+  useEffect(function () {
+    onOpenChange === null || onOpenChange === void 0 || onOpenChange(isMenuOpen);
+  }, [isMenuOpen, onOpenChange]);
+  var menuList = React.useMemo(function () {
+    if (!editor || !editor.isEditable) return [];
+    var canMerge = function () {
+      try {
+        return mergeCells(editor.state, undefined);
+      } catch (_unused) {
+        return false;
+      }
+    }();
+    var canSplit = function () {
+      try {
+        return splitCell(editor.state, undefined);
+      } catch (_unused2) {
+        return false;
+      }
+    }();
+    var menuItems = [];
+    if (canMerge || canSplit) {
+      if (canMerge) {
+        menuItems.push({
+          key: 'merge-cells',
+          label: '合并单元格',
+          icon: /*#__PURE__*/React.createElement(MergeCellsVerticalIcon, {
+            sx: {
+              fontSize: '1rem'
+            }
+          }),
+          onClick: function onClick() {
+            var state = editor.state,
+              view = editor.view;
+            mergeCells(state, view.dispatch.bind(view));
+          }
+        });
+      }
+      if (canSplit) {
+        menuItems.push({
+          key: 'split-cell',
+          label: '拆分单元格',
+          icon: /*#__PURE__*/React.createElement(SplitCellsVerticalIcon, {
+            sx: {
+              fontSize: '1rem'
+            }
+          }),
+          onClick: function onClick() {
+            var state = editor.state,
+              view = editor.view;
+            splitCell(state, view.dispatch.bind(view));
+          }
+        });
+      }
+      menuItems.push({
+        customLabel: /*#__PURE__*/React.createElement(Divider, {
+          sx: {
+            my: 0.5
+          }
+        }),
+        key: 'divider1'
+      });
+    }
+    menuItems.push({
+      key: 'color',
+      label: '颜色',
+      icon: /*#__PURE__*/React.createElement(BrushLineIcon, {
+        sx: {
+          fontSize: '1rem'
+        }
+      }),
+      children: [{
+        customLabel: /*#__PURE__*/React.createElement(Typography, {
+          sx: {
+            p: 1,
+            fontSize: '0.75rem',
+            color: 'text.secondary',
+            fontWeight: 'bold'
+          }
+        }, "\u6587\u5B57\u989C\u8272"),
+        key: 'text-color'
+      }].concat(_toConsumableArray(getThemeTextColor(theme).map(function (it) {
+        return {
+          label: it.label,
+          key: it.value,
+          icon: /*#__PURE__*/React.createElement(Box, {
+            sx: {
+              color: it.value,
+              width: '1rem',
+              height: '1rem',
+              borderRadius: '50%',
+              bgcolor: it.value,
+              border: '1px solid',
+              borderColor: it.value === theme.palette.common.white ? 'divider' : 'transparent'
+            }
+          }),
+          onClick: function onClick() {
+            if (!editor) return;
+            if (editor.state.storedMarks) {
+              var textStyleMarkType = editor.schema.marks.textStyle;
+              if (textStyleMarkType) {
+                editor.view.dispatch(editor.state.tr.removeStoredMark(textStyleMarkType));
+              }
+            }
+            setTimeout(function () {
+              var _editor$state = editor.state,
+                selection = _editor$state.selection,
+                doc = _editor$state.doc;
+              var textStyleMark = editor.schema.marks.textStyle;
+              if (!textStyleMark) return;
+              if (selection instanceof CellSelection) {
+                var tr = editor.state.tr;
+                var hasContent = false;
+                selection.forEachCell(function (cellNode, cellPos) {
+                  if (cellNode.content.size > 0) {
+                    hasContent = true;
+                    var from = cellPos + 1;
+                    var to = cellPos + cellNode.nodeSize - 1;
+                    if (from < to) {
+                      var $from = doc.resolve(from);
+                      var $to = doc.resolve(to);
+                      var cellTextSelection = TextSelection.between($from, $to, 1);
+                      if (cellTextSelection) {
+                        var mark = textStyleMark.create({
+                          color: it.value
+                        });
+                        tr.addMark(from, to, mark);
+                      }
+                    }
+                  }
+                });
+                if (hasContent) {
+                  editor.view.dispatch(tr);
+                  editor.commands.focus();
+                }
+              } else {
+                var $anchor = selection.$anchor;
+                var cell = cellAround($anchor);
+                if (cell) {
+                  var cellNode = doc.nodeAt(cell.pos);
+                  if (cellNode && cellNode.content.size > 0) {
+                    var from = cell.pos + 1;
+                    var to = cell.pos + cellNode.nodeSize - 1;
+                    if (from < to) {
+                      var $from = doc.resolve(from);
+                      var $to = doc.resolve(to);
+                      var newSelection = TextSelection.between($from, $to, 1);
+                      if (newSelection) {
+                        editor.view.dispatch(editor.state.tr.setSelection(newSelection));
+                      }
+                    }
+                  }
+                }
+                editor.chain().focus().toggleMark('textStyle', {
+                  color: it.value
+                }).run();
+              }
+            }, 0);
+          }
+        };
+      })), [{
+        customLabel: /*#__PURE__*/React.createElement(Typography, {
+          sx: {
+            p: 1,
+            fontSize: '0.75rem',
+            color: 'text.secondary',
+            fontWeight: 'bold'
+          }
+        }, "\u80CC\u666F\u989C\u8272"),
+        key: 'background-color'
+      }], _toConsumableArray(getThemeTextBgColor(theme).map(function (it) {
+        return {
+          label: it.label,
+          key: it.value,
+          icon: /*#__PURE__*/React.createElement(Box, {
+            sx: {
+              width: '1rem',
+              height: '1rem',
+              borderRadius: '50%',
+              bgcolor: it.value,
+              border: '1px solid',
+              borderColor: 'divider'
+            }
+          }),
+          onClick: function onClick() {
+            var bgColor = it.value === 'transparent' || it.value === 'var(--mui-palette-background-paper)' ? 'transparent' : it.value;
+            setTimeout(function () {
+              editor.chain().focus().setCellAttribute('bgcolor', bgColor).run();
+            }, 0);
+          }
+        };
+      })))
+    }, {
+      key: 'align',
+      label: '对齐方式',
+      icon: /*#__PURE__*/React.createElement(AlignLeftIcon, {
+        sx: {
+          fontSize: '1rem'
+        }
+      }),
+      children: [{
+        customLabel: /*#__PURE__*/React.createElement(Typography, {
+          sx: {
+            p: 1,
+            fontSize: '0.75rem',
+            color: 'text.secondary',
+            fontWeight: 'bold'
+          }
+        }, "\u6C34\u5E73\u5BF9\u9F50\u65B9\u5F0F"),
+        key: 'align-horizontal'
+      }, {
+        label: '左侧对齐',
+        key: 'align-horizontal-left',
+        icon: /*#__PURE__*/React.createElement(AlignLeftIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('textAlign', 'left').run();
+          }, 0);
+        }
+      }, {
+        label: '居中对齐',
+        key: 'align-horizontal-center',
+        icon: /*#__PURE__*/React.createElement(AlignCenterIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('textAlign', 'center').run();
+          }, 0);
+        }
+      }, {
+        label: '右侧对齐',
+        key: 'align-horizontal-right',
+        icon: /*#__PURE__*/React.createElement(AlignRightIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('textAlign', 'right').run();
+          }, 0);
+        }
+      }, {
+        label: '两端对齐',
+        key: 'align-horizontal-justify',
+        icon: /*#__PURE__*/React.createElement(AlignJustifyIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('textAlign', 'justify').run();
+          }, 0);
+        }
+      }, {
+        customLabel: /*#__PURE__*/React.createElement(Typography, {
+          sx: {
+            p: 1,
+            fontSize: '0.75rem',
+            color: 'text.secondary',
+            fontWeight: 'bold'
+          }
+        }, "\u5782\u76F4\u5BF9\u9F50\u65B9\u5F0F"),
+        key: 'align-vertical'
+      }, {
+        label: '顶部对齐',
+        key: 'align-vertical-top',
+        icon: /*#__PURE__*/React.createElement(AlignTopIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('verticalAlign', 'top').run();
+          }, 0);
+        }
+      }, {
+        label: '居中对齐',
+        key: 'align-vertical-center',
+        icon: /*#__PURE__*/React.createElement(AlignCenterIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('verticalAlign', 'middle').run();
+          }, 0);
+        }
+      }, {
+        label: '底部对齐',
+        key: 'align-vertical-bottom',
+        icon: /*#__PURE__*/React.createElement(AlignBottomIcon, {
+          sx: {
+            fontSize: '1rem'
+          }
+        }),
+        onClick: function onClick() {
+          if (!editor) return;
+          setTimeout(function () {
+            editor.chain().focus().setCellAttribute('verticalAlign', 'bottom').run();
+          }, 0);
+        }
+      }]
+    });
+    menuItems.push({
+      key: 'clear-content',
+      label: '清空单元格内容',
+      icon: /*#__PURE__*/React.createElement(DeleteBack2LineIcon, {
+        sx: {
+          fontSize: '1rem'
+        }
+      }),
+      onClick: function onClick() {
+        if (!editor) return;
+        var state = editor.state,
+          view = editor.view;
+        if (state.selection instanceof CellSelection) {
+          deleteCellSelection(state, view.dispatch.bind(view));
+        } else {
+          var $anchor = state.selection.$anchor;
+          var cell = cellAround($anchor);
+          if (cell) {
+            var cellNode = state.doc.nodeAt(cell.pos);
+            if (cellNode) {
+              var from = cell.pos + 1;
+              var to = cell.pos + cellNode.nodeSize - 1;
+              if (from < to) {
+                view.dispatch(state.tr.delete(from, to));
+              }
+            }
+          }
+        }
+      },
+      attrs: function () {
+        if (!editor) return {
+          disabled: true
+        };
+        var selection = editor.state.selection;
+        if (selection instanceof CellSelection) {
+          var hasContent = false;
+          selection.forEachCell(function (cell) {
+            if (cell.content.size > 0) {
+              hasContent = true;
+            }
+          });
+          return hasContent ? {} : {
+            disabled: true
+          };
+        } else {
+          var $anchor = selection.$anchor;
+          var cell = cellAround($anchor);
+          if (cell) {
+            var cellNode = editor.state.doc.nodeAt(cell.pos);
+            return cellNode && cellNode.content.size > 0 ? {} : {
+              disabled: true
+            };
+          }
+          return {
+            disabled: true
+          };
+        }
+      }()
+    }, {
+      key: 'delete-table',
+      label: '删除表格',
+      icon: /*#__PURE__*/React.createElement(DeleteLineIcon, {
+        sx: {
+          fontSize: '1rem'
+        }
+      }),
+      onClick: function onClick() {
+        if (!editor) return;
+        editor.chain().focus().deleteTable().run();
+      }
+    });
+    return menuItems;
+  }, [editor, theme, editorState]);
+  var handleButton = /*#__PURE__*/React.createElement(Box, _extends({
+    component: "button",
+    ref: ref,
+    className: className,
+    "aria-label": "Table cells option",
+    "aria-haspopup": "menu",
+    "aria-expanded": isMenuOpen,
+    onMouseDown: function onMouseDown(e) {
+      e.stopPropagation();
+      if (onResizeStart) {
+        onResizeStart('br')(e);
+      }
+    },
+    sx: {
+      position: 'absolute',
+      top: '50%',
+      right: '-8px',
+      transform: 'translateY(-50%)',
+      border: 'none',
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      borderRadius: 'var(--mui-shape-borderRadius)',
+      cursor: 'pointer',
+      padding: '4px',
+      width: '14px',
+      height: '14px',
+      zIndex: 4,
+      backgroundColor: 'var(--mui-palette-primary-main)',
+      '& .MuiSvgIcon-root': {
+        color: 'var(--mui-palette-common-white)'
+      }
+    }
+  }, props), /*#__PURE__*/React.createElement(MoreLineIcon, {
+    sx: {
+      width: '0.75rem',
+      height: '0.75rem'
+    }
+  }));
+  return /*#__PURE__*/React.createElement(Menu, {
+    width: 216,
+    context: handleButton,
+    list: menuList,
+    anchorOrigin: {
+      vertical: 'bottom',
+      horizontal: 'left'
+    },
+    transformOrigin: {
+      vertical: 'top',
+      horizontal: 'left'
+    },
+    onOpen: function onOpen() {
+      return handleMenuToggle(true);
+    },
+    onClose: function onClose() {
+      return handleMenuToggle(false);
+    },
+    arrowIcon: /*#__PURE__*/React.createElement(ArrowDownSLineIcon, {
+      sx: {
+        fontSize: '1rem',
+        transform: 'rotate(-90deg)'
+      }
+    })
+  });
+});
+TableCellHandleMenu.displayName = 'TableCellHandleMenu';

package/dist/{features/table → extension/component}/TableExtendButton/index.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from '@tiptap/pm/model';
 import type { Editor } from '@tiptap/react';
 import React from 'react';
-import type { Orientation } from '../../../utils/table';
+import type { Orientation } from '../../../util/table-utils';
 import './TableExtendButton.css';
 interface TableExtendRowColumnButtonProps {
     editor?: Editor | null;

package/dist/{features/table → extension/component}/TableExtendButton/index.js

@@ -8,8 +8,8 @@ import { FloatingPortal } from '@floating-ui/react';
 import { Box } from '@mui/material';
 import { TableMap } from '@tiptap/pm/tables';
 import React, { useCallback, useEffect, useRef, useState } from 'react';
-import { AddLineIcon } from "../../../components/Icons/add-line-icon";
-import { EMPTY_CELL_HEIGHT, EMPTY_CELL_WIDTH, countEmptyColumnsFromEnd, countEmptyRowsFromEnd, marginRound, runPreservingCursor, selectLastCell } from "../../../utils/table";
+import { AddLineIcon } from "../../../component/Icons/add-line-icon";
+import { EMPTY_CELL_HEIGHT, EMPTY_CELL_WIDTH, countEmptyColumnsFromEnd, countEmptyRowsFromEnd, marginRound, runPreservingCursor, selectLastCell } from "../../../util/table-utils";
 import { useTableHandleState } from "../TableHandle/use-table-handle-state";
 import "./TableExtendButton.css";
 import { useTableExtendRowColumnButtonsPositioning } from "./use-table-extend-row-column";

package/dist/{features/table → extension/component}/TableHandle/TableHandleAddButton.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from '@tiptap/pm/model';
 import type { Editor } from '@tiptap/react';
 import React from 'react';
-import type { Orientation } from '../../../utils/table';
+import type { Orientation } from '../../../util/table-utils';
 interface TableHandleAddButtonProps {
     editor?: Editor | null;
     orientation: Orientation;

package/dist/{features/table → extension/component}/TableHandle/TableHandleAddButton.js

@@ -1,7 +1,7 @@
-import { SkipDownIcon, SkipLeftIcon, SkipRightIcon, SkipUpIcon } from "../../../components/Icons";
+import { SkipDownIcon, SkipLeftIcon, SkipRightIcon, SkipUpIcon } from "../../../component/Icons";
 import { Box } from '@mui/material';
 import React, { useCallback } from 'react';
-import { selectCellsByCoords } from "../../../utils/table";
+import { selectCellsByCoords } from "../../../util/table-utils";
 export var TableHandleAddButton = function TableHandleAddButton(_ref) {
   var editor = _ref.editor,
     orientation = _ref.orientation,

package/dist/{features/table → extension/component}/TableHandle/TableHandleMenu.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from '@tiptap/pm/model';
 import type { Editor } from '@tiptap/react';
 import React from 'react';
-import type { Orientation } from '../../../utils/table';
+import type { Orientation } from '../../../util/table-utils';
 import './TableHandleMenu.css';
 interface TableHandleMenuProps {
     editor?: Editor | null;