@ctzhian/tiptap 2.13.7-beta.0 → 3.0.0

package/dist/features/table/plugin/shared.d.ts

@@ -0,0 +1,37 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as TiptapNode } from '@tiptap/pm/model';
+import { PluginKey } from '@tiptap/pm/state';
+export type TableHandlesState = {
+    show: boolean;
+    showAddOrRemoveRowsButton: boolean;
+    showAddOrRemoveColumnsButton: boolean;
+    referencePosCell?: DOMRect;
+    referencePosTable: DOMRect;
+    referencePosLastRow?: DOMRect;
+    referencePosLastCol?: DOMRect;
+    block: TiptapNode;
+    blockPos: number;
+    colIndex: number | undefined;
+    rowIndex: number | undefined;
+    draggingState?: {
+        draggedCellOrientation: 'row' | 'col';
+        originalIndex: number;
+        mousePos: number;
+        initialOffset: number;
+        originalCellSize?: {
+            width: number;
+            height: number;
+        };
+    } | undefined;
+    widgetContainer: HTMLElement | undefined;
+    _cachedHandleRects?: DOMRect[];
+    _cachedHandleRectsTime?: number;
+};
+export interface TableHandleRuntime {
+    editor: Editor;
+    state: TableHandlesState | undefined;
+    emitUpdate: () => void;
+}
+export declare const tableHandlePluginKey: PluginKey<any>;
+export declare const setTableHandleRuntime: (runtime: TableHandleRuntime | null) => void;
+export declare const getTableHandleRuntime: () => TableHandleRuntime | null;

package/dist/features/table/plugin/shared.js

@@ -0,0 +1,9 @@
+import { PluginKey } from '@tiptap/pm/state';
+export var tableHandlePluginKey = new PluginKey('tableHandlePlugin');
+var tableHandleRuntime = null;
+export var setTableHandleRuntime = function setTableHandleRuntime(runtime) {
+  tableHandleRuntime = runtime;
+};
+export var getTableHandleRuntime = function getTableHandleRuntime() {
+  return tableHandleRuntime;
+};

package/dist/features/table/plugin/state-sync.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from '@tiptap/core';
+import type { TableHandlesState } from './shared';
+export declare const syncTableHandleState: ({ editor, tableElement, state, }: {
+    editor: Editor;
+    tableElement: HTMLElement;
+    state: TableHandlesState;
+}) => {
+    nextState: TableHandlesState;
+    blockChanged: boolean;
+    indicesChanged: boolean;
+    refPosChanged: boolean;
+} | null;

package/dist/features/table/plugin/state-sync.js

@@ -0,0 +1,75 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { TableMap } from '@tiptap/pm/tables';
+import { getTableFromDOM } from "../../../utils/table";
+import { didReferencePositionsChange, getLastEdgeReferences, getReferenceCellRect } from "./positioning";
+export var syncTableHandleState = function syncTableHandleState(_ref) {
+  var _state$draggingState;
+  var editor = _ref.editor,
+    tableElement = _ref.tableElement,
+    state = _ref.state;
+  var tableInfo = getTableFromDOM(tableElement, editor);
+  if (!tableInfo || tableInfo.node.type.name !== 'table') {
+    return null;
+  }
+  var tableBody = tableElement.querySelector('tbody');
+  if (!tableBody) {
+    throw new Error("Table block does not contain a 'tbody' HTML element. This should never happen.");
+  }
+  var _TableMap$get = TableMap.get(tableInfo.node),
+    rowCount = _TableMap$get.height,
+    colCount = _TableMap$get.width;
+  var newRowIndex = state.rowIndex;
+  var newColIndex = state.colIndex;
+  if (newRowIndex !== undefined && newRowIndex >= rowCount) {
+    newRowIndex = rowCount ? rowCount - 1 : undefined;
+  }
+  if (newColIndex !== undefined && newColIndex >= colCount) {
+    newColIndex = colCount ? colCount - 1 : undefined;
+  }
+  var newReferencePosCell = getReferenceCellRect({
+    tableBody: tableBody,
+    rowIndex: newRowIndex,
+    colIndex: newColIndex,
+    originalSize: (_state$draggingState = state.draggingState) === null || _state$draggingState === void 0 ? void 0 : _state$draggingState.originalCellSize
+  });
+  if (!newReferencePosCell && newRowIndex !== undefined && newColIndex !== undefined) {
+    newRowIndex = undefined;
+    newColIndex = undefined;
+  }
+  var newReferencePosTable = tableBody.getBoundingClientRect();
+  var _getLastEdgeReference = getLastEdgeReferences({
+      tableBody: tableBody,
+      tableNode: tableInfo.node,
+      includeLastRow: state.showAddOrRemoveRowsButton,
+      includeLastColumn: state.showAddOrRemoveColumnsButton
+    }),
+    newReferencePosLastRow = _getLastEdgeReference.referencePosLastRow,
+    newReferencePosLastCol = _getLastEdgeReference.referencePosLastCol;
+  var nextState = _objectSpread(_objectSpread({}, state), {}, {
+    block: tableInfo.node,
+    blockPos: tableInfo.pos,
+    rowIndex: newRowIndex,
+    colIndex: newColIndex,
+    referencePosCell: newReferencePosCell,
+    referencePosTable: newReferencePosTable,
+    referencePosLastRow: newReferencePosLastRow,
+    referencePosLastCol: newReferencePosLastCol
+  });
+  var blockChanged = state.block !== tableInfo.node || state.blockPos !== tableInfo.pos;
+  var indicesChanged = newRowIndex !== state.rowIndex || newColIndex !== state.colIndex;
+  var refPosChanged = didReferencePositionsChange({
+    previous: state,
+    next: nextState
+  });
+  return {
+    nextState: nextState,
+    blockChanged: blockChanged,
+    indicesChanged: indicesChanged,
+    refPosChanged: refPosChanged
+  };
+};

package/dist/features/toolbar/index.d.ts

@@ -0,0 +1,16 @@
+import { Editor } from '@tiptap/react';
+import React from 'react';
+import { ToolbarItemType } from '../../types';
+interface EditorToolbarProps {
+    editor: Editor;
+    menuInToolbarMore?: ToolbarItemType[];
+    /**
+     * Toolbar 模式
+     * - advanced：展示全部工具
+     * - simple：只展示常用工具，并尽量保持单行
+     */
+    mode?: 'simple' | 'advanced';
+    onModeChange?: (mode: 'simple' | 'advanced') => void;
+}
+declare const EditorToolbar: ({ editor, menuInToolbarMore, mode, onModeChange, }: EditorToolbarProps) => React.JSX.Element;
+export default EditorToolbar;

package/dist/features/toolbar/index.js

@@ -0,0 +1,179 @@
+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 { Box, Stack } from '@mui/material';
+import { useEditorState } from '@tiptap/react';
+import React from 'react';
+import { hasMarksInSelection } from "../../utils";
+import { AiToolbarItem, HistoryToolbarSection, InsertToolbarSection, LayoutToolbarSection, MarksToolbarSection, ModeToggleToolbarItem, StructureToolbarSection, TypographyToolbarSection } from "./toolbar-sections";
+var EditorToolbar = function EditorToolbar(_ref) {
+  var editor = _ref.editor,
+    menuInToolbarMore = _ref.menuInToolbarMore,
+    mode = _ref.mode,
+    onModeChange = _ref.onModeChange;
+  var _React$useState = React.useState(function () {
+      return mode !== null && mode !== void 0 ? mode : 'advanced';
+    }),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    toolbarMode = _React$useState2[0],
+    setToolbarMode = _React$useState2[1];
+  React.useEffect(function () {
+    if (typeof mode !== 'undefined') {
+      setToolbarMode(mode);
+    }
+  }, [mode]);
+  var isSimpleMode = toolbarMode === 'simple';
+  var handleToggleMode = React.useCallback(function () {
+    var nextMode = isSimpleMode ? 'advanced' : 'simple';
+    setToolbarMode(nextMode);
+    onModeChange === null || onModeChange === void 0 || onModeChange(nextMode);
+  }, [isSimpleMode, onModeChange]);
+  var _useEditorState = useEditorState({
+      editor: editor,
+      selector: function selector(ctx) {
+        var _ctx$editor$can$chain, _ctx$editor$can$chain2, _ctx$editor$storage;
+        return {
+          isUndo: (_ctx$editor$can$chain = ctx.editor.can().chain().undo().run()) !== null && _ctx$editor$can$chain !== void 0 ? _ctx$editor$can$chain : false,
+          isRedo: (_ctx$editor$can$chain2 = ctx.editor.can().chain().redo().run()) !== null && _ctx$editor$can$chain2 !== void 0 ? _ctx$editor$can$chain2 : false,
+          isFormat: hasMarksInSelection(ctx.editor.state),
+          isBold: ctx.editor.isActive('bold'),
+          isItalic: ctx.editor.isActive('italic'),
+          isStrike: ctx.editor.isActive('strike'),
+          isUnderline: ctx.editor.isActive('underline'),
+          isSuperscript: ctx.editor.isActive('superscript'),
+          isSubscript: ctx.editor.isActive('subscript'),
+          isLink: ctx.editor.isActive('link'),
+          isHighlight: ctx.editor.isActive('highlight'),
+          isAiWriting: !!((_ctx$editor$storage = ctx.editor.storage) !== null && _ctx$editor$storage !== void 0 && (_ctx$editor$storage = _ctx$editor$storage.aiWriting) !== null && _ctx$editor$storage !== void 0 && _ctx$editor$storage.enabled),
+          isCodeBlock: ctx.editor.isActive('codeBlock'),
+          isTooltip: ctx.editor.isActive('tooltip')
+        };
+      }
+    }),
+    isUndo = _useEditorState.isUndo,
+    isRedo = _useEditorState.isRedo,
+    isFormat = _useEditorState.isFormat,
+    isBold = _useEditorState.isBold,
+    isItalic = _useEditorState.isItalic,
+    isStrike = _useEditorState.isStrike,
+    isUnderline = _useEditorState.isUnderline,
+    isSuperscript = _useEditorState.isSuperscript,
+    isSubscript = _useEditorState.isSubscript,
+    isLink = _useEditorState.isLink,
+    isAiWriting = _useEditorState.isAiWriting,
+    isHighlight = _useEditorState.isHighlight,
+    isCodeBlock = _useEditorState.isCodeBlock,
+    isTooltip = _useEditorState.isTooltip;
+  return /*#__PURE__*/React.createElement(Box, {
+    className: "editor-toolbar"
+  }, /*#__PURE__*/React.createElement(Stack, {
+    direction: "row",
+    alignItems: "center",
+    justifyContent: isSimpleMode ? 'flex-start' : 'center',
+    flexWrap: isSimpleMode ? 'nowrap' : 'wrap',
+    sx: {
+      minHeight: '44px',
+      overflowX: isSimpleMode ? 'auto' : 'visible',
+      columnGap: '1px',
+      '.MuiSelect-root': {
+        minWidth: '36px',
+        bgcolor: 'background.paper',
+        '.MuiSelect-select': {
+          p: '0 !important'
+        },
+        input: {
+          display: 'none'
+        },
+        '&:hover': {
+          bgcolor: 'background.paper2'
+        },
+        '&.tool-active': {
+          bgcolor: 'background.paper2',
+          color: 'primary.main',
+          button: {
+            color: 'primary.main'
+          }
+        },
+        '.MuiOutlinedInput-notchedOutline': {
+          borderWidth: '0px !important'
+        }
+      }
+    }
+  }, !isSimpleMode && /*#__PURE__*/React.createElement(AiToolbarItem, {
+    editor: editor,
+    isAiWriting: isAiWriting
+  }), /*#__PURE__*/React.createElement(InsertToolbarSection, {
+    editor: editor,
+    isSimpleMode: isSimpleMode
+  }), /*#__PURE__*/React.createElement(HistoryToolbarSection, {
+    editor: editor,
+    flags: {
+      isUndo: isUndo,
+      isRedo: isRedo,
+      isFormat: isFormat,
+      isBold: isBold,
+      isItalic: isItalic,
+      isStrike: isStrike,
+      isUnderline: isUnderline,
+      isSuperscript: isSuperscript,
+      isSubscript: isSubscript,
+      isLink: isLink,
+      isAiWriting: isAiWriting,
+      isHighlight: isHighlight,
+      isCodeBlock: isCodeBlock,
+      isTooltip: isTooltip
+    }
+  }), /*#__PURE__*/React.createElement(TypographyToolbarSection, {
+    editor: editor,
+    isSimpleMode: isSimpleMode
+  }), /*#__PURE__*/React.createElement(MarksToolbarSection, {
+    editor: editor,
+    isSimpleMode: isSimpleMode,
+    flags: {
+      isUndo: isUndo,
+      isRedo: isRedo,
+      isFormat: isFormat,
+      isBold: isBold,
+      isItalic: isItalic,
+      isStrike: isStrike,
+      isUnderline: isUnderline,
+      isSuperscript: isSuperscript,
+      isSubscript: isSubscript,
+      isLink: isLink,
+      isAiWriting: isAiWriting,
+      isHighlight: isHighlight,
+      isCodeBlock: isCodeBlock,
+      isTooltip: isTooltip
+    }
+  }), /*#__PURE__*/React.createElement(StructureToolbarSection, {
+    editor: editor,
+    isSimpleMode: isSimpleMode,
+    flags: {
+      isUndo: isUndo,
+      isRedo: isRedo,
+      isFormat: isFormat,
+      isBold: isBold,
+      isItalic: isItalic,
+      isStrike: isStrike,
+      isUnderline: isUnderline,
+      isSuperscript: isSuperscript,
+      isSubscript: isSubscript,
+      isLink: isLink,
+      isAiWriting: isAiWriting,
+      isHighlight: isHighlight,
+      isCodeBlock: isCodeBlock,
+      isTooltip: isTooltip
+    }
+  }), /*#__PURE__*/React.createElement(LayoutToolbarSection, {
+    editor: editor,
+    isSimpleMode: isSimpleMode,
+    menuInToolbarMore: menuInToolbarMore
+  }), mode === 'simple' && /*#__PURE__*/React.createElement(ModeToggleToolbarItem, {
+    isSimpleMode: isSimpleMode,
+    onToggle: handleToggleMode
+  })));
+};
+export default EditorToolbar;

package/dist/features/toolbar/toolbar-config.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { Editor } from '@tiptap/react';
+export interface EditorToolbarFlags {
+    isUndo: boolean;
+    isRedo: boolean;
+    isFormat: boolean;
+    isBold: boolean;
+    isItalic: boolean;
+    isStrike: boolean;
+    isUnderline: boolean;
+    isSuperscript: boolean;
+    isSubscript: boolean;
+    isLink: boolean;
+    isAiWriting: boolean;
+    isHighlight: boolean;
+    isCodeBlock: boolean;
+    isTooltip: boolean;
+}
+export interface ToolbarActionConfig {
+    id: string;
+    tip: string;
+    icon: React.ReactNode;
+    shortcutKey?: string[];
+    className?: string;
+    disabled?: boolean;
+    onClick: () => void;
+}
+export declare const renderToolbarActions: (actions: ToolbarActionConfig[]) => React.JSX.Element;
+export declare const buildHistoryActions: (editor: Editor, flags: Pick<EditorToolbarFlags, 'isUndo' | 'isRedo' | 'isFormat'>) => ToolbarActionConfig[];
+export declare const buildBaseMarkActions: (editor: Editor, flags: Pick<EditorToolbarFlags, 'isBold' | 'isItalic'>) => ToolbarActionConfig[];
+export declare const buildAdvancedMarkActions: (editor: Editor, flags: Pick<EditorToolbarFlags, 'isStrike' | 'isUnderline' | 'isHighlight' | 'isTooltip' | 'isSuperscript' | 'isSubscript'>) => ToolbarActionConfig[];
+export declare const buildStructureAction: (editor: Editor, isSimpleMode: boolean, flags: Pick<EditorToolbarFlags, 'isCodeBlock' | 'isLink'>) => ToolbarActionConfig;

package/dist/features/toolbar/toolbar-config.js

@@ -0,0 +1,209 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from 'react';
+import { ArrowGoBackLineIcon, ArrowGoForwardLineIcon, BoldIcon, CodeBoxLineIcon, EraserLineIcon, ItalicIcon, LinkIcon, MarkPenLineIcon, StrikethroughIcon, SubscriptIcon, SuperscriptIcon, TooltipLineIcon, UnderlineIcon } from "../../components/Icons";
+import { ToolbarItem } from "../../components/Toolbar";
+import { getLinkAttributesWithSelectedText } from "../../utils";
+export var renderToolbarActions = function renderToolbarActions(actions) {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, actions.map(function (action) {
+    return /*#__PURE__*/React.createElement(ToolbarItem, {
+      key: action.id,
+      tip: action.tip,
+      shortcutKey: action.shortcutKey,
+      icon: action.icon,
+      onClick: action.onClick,
+      className: action.className,
+      disabled: action.disabled
+    });
+  }));
+};
+export var buildHistoryActions = function buildHistoryActions(editor, flags) {
+  return [{
+    id: 'undo',
+    tip: '撤销',
+    shortcutKey: ['ctrl', 'Z'],
+    icon: /*#__PURE__*/React.createElement(ArrowGoBackLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().undo().run();
+    },
+    disabled: !flags.isUndo
+  }, {
+    id: 'redo',
+    tip: '重做',
+    shortcutKey: ['ctrl', 'Y'],
+    icon: /*#__PURE__*/React.createElement(ArrowGoForwardLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().redo().run();
+    },
+    disabled: !flags.isRedo
+  }, {
+    id: 'clear-format',
+    tip: '清除格式',
+    icon: /*#__PURE__*/React.createElement(EraserLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().unsetAllMarks().run();
+    },
+    disabled: !flags.isFormat
+  }];
+};
+export var buildBaseMarkActions = function buildBaseMarkActions(editor, flags) {
+  return [{
+    id: 'bold',
+    tip: '加粗',
+    shortcutKey: ['ctrl', 'B'],
+    icon: /*#__PURE__*/React.createElement(BoldIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleBold().run();
+    },
+    className: flags.isBold ? 'tool-active' : ''
+  }, {
+    id: 'italic',
+    tip: '斜体',
+    shortcutKey: ['ctrl', 'I'],
+    icon: /*#__PURE__*/React.createElement(ItalicIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleItalic().run();
+    },
+    className: flags.isItalic ? 'tool-active' : ''
+  }];
+};
+export var buildAdvancedMarkActions = function buildAdvancedMarkActions(editor, flags) {
+  return [{
+    id: 'strike',
+    tip: '删除线',
+    shortcutKey: ['ctrl', 'shift', 'S'],
+    icon: /*#__PURE__*/React.createElement(StrikethroughIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleStrike().run();
+    },
+    className: flags.isStrike ? 'tool-active' : ''
+  }, {
+    id: 'underline',
+    tip: '下划线',
+    shortcutKey: ['ctrl', 'U'],
+    icon: /*#__PURE__*/React.createElement(UnderlineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleUnderline().run();
+    },
+    className: flags.isUnderline ? 'tool-active' : ''
+  }, {
+    id: 'highlight',
+    tip: '高亮',
+    shortcutKey: ['ctrl', 'shift', 'H'],
+    icon: /*#__PURE__*/React.createElement(MarkPenLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleHighlight().run();
+    },
+    className: flags.isHighlight ? 'tool-active' : ''
+  }, {
+    id: 'tooltip',
+    tip: '文本提示',
+    icon: /*#__PURE__*/React.createElement(TooltipLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      if (flags.isTooltip) {
+        editor.chain().focus().unsetTooltip().run();
+      } else {
+        editor.chain().focus().toggleTooltip().run();
+      }
+    },
+    className: flags.isTooltip ? 'tool-active' : ''
+  }, {
+    id: 'superscript',
+    tip: '上标',
+    shortcutKey: ['ctrl', '.'],
+    icon: /*#__PURE__*/React.createElement(SuperscriptIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleSuperscript().run();
+    },
+    className: flags.isSuperscript ? 'tool-active' : ''
+  }, {
+    id: 'subscript',
+    tip: '下标',
+    shortcutKey: ['ctrl', ','],
+    icon: /*#__PURE__*/React.createElement(SubscriptIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleSubscript().run();
+    },
+    className: flags.isSubscript ? 'tool-active' : ''
+  }];
+};
+export var buildStructureAction = function buildStructureAction(editor, isSimpleMode, flags) {
+  return isSimpleMode ? {
+    id: 'code-block',
+    tip: '代码块',
+    shortcutKey: ['ctrl', 'alt', 'C'],
+    icon: /*#__PURE__*/React.createElement(CodeBoxLineIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      return editor.chain().focus().toggleCodeBlock().run();
+    },
+    className: flags.isCodeBlock ? 'tool-active' : ''
+  } : {
+    id: 'link',
+    tip: '链接',
+    shortcutKey: ['ctrl', '1'],
+    icon: /*#__PURE__*/React.createElement(LinkIcon, {
+      sx: {
+        fontSize: '1rem'
+      }
+    }),
+    onClick: function onClick() {
+      var linkAttributes = getLinkAttributesWithSelectedText(editor);
+      editor.chain().focus().setInlineLink(_objectSpread({
+        href: ''
+      }, linkAttributes)).run();
+    },
+    className: flags.isLink ? 'tool-active' : ''
+  };
+};

package/dist/features/toolbar/toolbar-divider.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ToolbarDivider: () => React.JSX.Element;
+export default ToolbarDivider;

package/dist/features/toolbar/toolbar-divider.js

@@ -0,0 +1,14 @@
+import { Divider } from '@mui/material';
+import React from 'react';
+var ToolbarDivider = function ToolbarDivider() {
+  return /*#__PURE__*/React.createElement(Divider, {
+    orientation: "vertical",
+    flexItem: true,
+    sx: {
+      mx: 0.25,
+      height: 20,
+      alignSelf: 'center'
+    }
+  });
+};
+export default ToolbarDivider;

package/dist/features/toolbar/toolbar-sections.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Editor } from '@tiptap/react';
+import { ToolbarItemType } from '../../types';
+import { EditorToolbarFlags } from './toolbar-config';
+interface EditorToolbarSectionProps {
+    editor: Editor;
+    isSimpleMode: boolean;
+    flags: EditorToolbarFlags;
+    menuInToolbarMore?: ToolbarItemType[];
+}
+interface ModeToggleToolbarItemProps {
+    isSimpleMode: boolean;
+    onToggle: () => void;
+}
+export declare const AiToolbarItem: ({ editor, isAiWriting }: Pick<EditorToolbarSectionProps, 'editor'> & Pick<EditorToolbarFlags, 'isAiWriting'>) => React.JSX.Element | null;
+export declare const InsertToolbarSection: ({ editor, isSimpleMode }: Pick<EditorToolbarSectionProps, 'editor' | 'isSimpleMode'>) => React.JSX.Element | null;
+export declare const HistoryToolbarSection: ({ editor, flags }: Pick<EditorToolbarSectionProps, 'editor' | 'flags'>) => React.JSX.Element;
+export declare const TypographyToolbarSection: ({ editor, isSimpleMode }: Pick<EditorToolbarSectionProps, 'editor' | 'isSimpleMode'>) => React.JSX.Element;
+export declare const MarksToolbarSection: ({ editor, isSimpleMode, flags }: Pick<EditorToolbarSectionProps, 'editor' | 'isSimpleMode' | 'flags'>) => React.JSX.Element;
+export declare const StructureToolbarSection: ({ editor, isSimpleMode, flags }: Pick<EditorToolbarSectionProps, 'editor' | 'isSimpleMode' | 'flags'>) => React.JSX.Element;
+export declare const LayoutToolbarSection: ({ editor, isSimpleMode, menuInToolbarMore, }: Pick<EditorToolbarSectionProps, 'editor' | 'isSimpleMode' | 'menuInToolbarMore'>) => React.JSX.Element | null;
+export declare const ModeToggleToolbarItem: ({ isSimpleMode, onToggle }: ModeToggleToolbarItemProps) => React.JSX.Element;
+export {};