@ctzhian/tiptap 1.13.8 → 2.0.0

package/dist/util/table-utils.js

@@ -0,0 +1,605 @@
+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 _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 _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 _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 _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 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 { Selection } from '@tiptap/pm/state';
+import { cellAround, CellSelection, findTable, selectedRect, selectionCell, TableMap } from '@tiptap/pm/tables';
+import { Mapping } from '@tiptap/pm/transform';
+export var RESIZE_MIN_WIDTH = 35;
+export var EMPTY_CELL_WIDTH = 120;
+export var EMPTY_CELL_HEIGHT = 40;
+// ============================================================================
+// HELPER CONSTANTS & UTILITIES
+// ============================================================================
+
+var EMPTY_CELLS_RESULT = {
+  cells: [],
+  mergedCells: []
+};
+export function isHTMLElement(n) {
+  return n instanceof HTMLElement;
+}
+export function safeClosest(start, selector) {
+  var _ref, _start$closest;
+  return (_ref = start === null || start === void 0 || (_start$closest = start.closest) === null || _start$closest === void 0 ? void 0 : _start$closest.call(start, selector)) !== null && _ref !== void 0 ? _ref : null;
+}
+
+/**
+ * Walk up from an element until we find a TD/TH or the table wrapper.
+ * Returns the found element plus its tbody (if present).
+ */
+export function domCellAround(target) {
+  var current = target;
+  while (current && current.tagName !== 'TD' && current.tagName !== 'TH' && !current.classList.contains('tableWrapper')) {
+    if (current.classList.contains('ProseMirror')) return undefined;
+    current = isHTMLElement(current.parentNode) ? current.parentNode : null;
+  }
+  if (!current) return undefined;
+  if (current.tagName === 'TD' || current.tagName === 'TH') {
+    return {
+      type: 'cell',
+      domNode: current,
+      tbodyNode: safeClosest(current, 'tbody')
+    };
+  }
+  return {
+    type: 'wrapper',
+    domNode: current,
+    tbodyNode: current.querySelector('tbody')
+  };
+}
+
+/**
+ * Clamps a value between min and max bounds
+ */
+export function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+
+/**
+ * Validates if row/col indices are within table bounds
+ */
+function isWithinBounds(row, col, map) {
+  return row >= 0 && row < map.height && col >= 0 && col < map.width;
+}
+
+/**
+ * Resolves the index for a row or column based on current selection or provided value
+ */
+function resolveOrientationIndex(state, table, orientation, providedIndex) {
+  var _cellAround;
+  if (typeof providedIndex === 'number') {
+    return providedIndex;
+  }
+  if (state.selection instanceof CellSelection) {
+    var _rect = selectedRect(state);
+    return orientation === 'row' ? _rect.top : _rect.left;
+  }
+  var $cell = (_cellAround = cellAround(state.selection.$anchor)) !== null && _cellAround !== void 0 ? _cellAround : selectionCell(state);
+  if (!$cell) return null;
+  var rel = $cell.pos - table.start;
+  var rect = table.map.findCell(rel);
+  return orientation === 'row' ? rect.top : rect.left;
+}
+
+/**
+ * Creates a CellInfo object from position data
+ */
+function createCellInfo(row, column, cellPos, cellNode) {
+  return {
+    row: row,
+    column: column,
+    pos: cellPos,
+    node: cellNode,
+    start: cellPos + 1,
+    depth: cellNode ? cellNode.content.size : 0
+  };
+}
+
+/**
+ * Checks if a cell is merged (has colspan or rowspan > 1)
+ */
+export function isCellMerged(node) {
+  var _node$attrs$colspan, _node$attrs$rowspan;
+  if (!node) return false;
+  var colspan = (_node$attrs$colspan = node.attrs.colspan) !== null && _node$attrs$colspan !== void 0 ? _node$attrs$colspan : 1;
+  var rowspan = (_node$attrs$rowspan = node.attrs.rowspan) !== null && _node$attrs$rowspan !== void 0 ? _node$attrs$rowspan : 1;
+  return colspan > 1 || rowspan > 1;
+}
+
+/**
+ * Generic function to collect cells along a row or column
+ */
+function collectCells(editor, orientation, index, tablePos) {
+  if (!editor) return EMPTY_CELLS_RESULT;
+  var state = editor.state;
+  var table = getTable(editor, tablePos);
+  if (!table) return EMPTY_CELLS_RESULT;
+  var tableStart = table.start;
+  var tableNode = table.node;
+  var map = table.map;
+  var resolvedIndex = resolveOrientationIndex(state, table, orientation, index);
+  if (resolvedIndex === null) return EMPTY_CELLS_RESULT;
+
+  // Bounds check
+  var maxIndex = orientation === 'row' ? map.height : map.width;
+  if (resolvedIndex < 0 || resolvedIndex >= maxIndex) {
+    return EMPTY_CELLS_RESULT;
+  }
+  var cells = [];
+  var mergedCells = [];
+  var seenMerged = new Set();
+  var iterationCount = orientation === 'row' ? map.width : map.height;
+  for (var i = 0; i < iterationCount; i++) {
+    var row = orientation === 'row' ? resolvedIndex : i;
+    var col = orientation === 'row' ? i : resolvedIndex;
+    var cellIndex = row * map.width + col;
+    var mapCell = map.map[cellIndex];
+    if (mapCell === undefined) continue;
+    var cellPos = tableStart + mapCell;
+    var cellNode = tableNode.nodeAt(mapCell);
+    if (!cellNode) continue;
+    var cell = createCellInfo(row, col, cellPos, cellNode);
+    if (isCellMerged(cellNode)) {
+      if (!seenMerged.has(cellPos)) {
+        mergedCells.push(cell);
+        seenMerged.add(cellPos);
+      }
+    }
+    cells.push(cell);
+  }
+  return {
+    cells: cells,
+    mergedCells: mergedCells
+  };
+}
+
+/**
+ * Generic function to count empty cells from the end of a row or column
+ */
+function countEmptyCellsFromEnd(editor, tablePos, orientation) {
+  var table = getTable(editor, tablePos);
+  if (!table) return 0;
+  var doc = editor.state.doc;
+  var maxIndex = orientation === 'row' ? table.map.height : table.map.width;
+  var emptyCount = 0;
+  for (var idx = maxIndex - 1; idx >= 0; idx--) {
+    var seen = new Set();
+    var isLineEmpty = true;
+    var iterationCount = orientation === 'row' ? table.map.width : table.map.height;
+    for (var i = 0; i < iterationCount; i++) {
+      var row = orientation === 'row' ? idx : i;
+      var col = orientation === 'row' ? i : idx;
+      var rel = table.map.positionAt(row, col, table.node);
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      var abs = tablePos + 1 + rel;
+      var cell = doc.nodeAt(abs);
+      if (!cell) continue;
+      if (!isCellEmpty(cell)) {
+        isLineEmpty = false;
+        break;
+      }
+    }
+    if (isLineEmpty) emptyCount++;else break;
+  }
+  return emptyCount;
+}
+
+/**
+ * Get information about the table at the current selection or a specific position.
+ */
+export function getTable(editor, tablePos) {
+  if (!editor) return null;
+  var table = null;
+  if (typeof tablePos === 'number') {
+    var tableNode = editor.state.doc.nodeAt(tablePos);
+    if ((tableNode === null || tableNode === void 0 ? void 0 : tableNode.type.name) === 'table') {
+      table = {
+        node: tableNode,
+        pos: tablePos,
+        start: tablePos + 1,
+        depth: editor.state.doc.resolve(tablePos).depth
+      };
+    }
+  }
+  if (!table) {
+    var state = editor.state;
+    var $from = state.doc.resolve(state.selection.from);
+    table = findTable($from);
+  }
+  if (!table) return null;
+  var tableMap = TableMap.get(table.node);
+  if (!tableMap) return null;
+  return _objectSpread(_objectSpread({}, table), {}, {
+    map: tableMap
+  });
+}
+
+/**
+ * Checks if the current text selection is inside a table cell.
+ */
+export function isSelectionInCell(state) {
+  var selection = state.selection;
+  var $from = selection.$from;
+  for (var depth = $from.depth; depth > 0; depth--) {
+    var node = $from.node(depth);
+    if (node.type.name === 'tableCell' || node.type.name === 'tableHeader') {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Runs a function while preserving the editor's selection.
+ */
+export function runPreservingCursor(editor, fn) {
+  var view = editor.view;
+  var startSel = view.state.selection;
+  var bookmark = startSel.getBookmark();
+  var mapping = new Mapping();
+  var originalDispatch = view.dispatch;
+  view.dispatch = function (tr) {
+    mapping.appendMapping(tr.mapping);
+    originalDispatch(tr);
+  };
+  try {
+    fn();
+  } finally {
+    view.dispatch = originalDispatch;
+  }
+  try {
+    var sel = bookmark.map(mapping).resolve(view.state.doc);
+    view.dispatch(view.state.tr.setSelection(sel));
+    return true;
+  } catch (_unused) {
+    // Fallback: if the exact spot vanished (e.g., cell deleted),
+    // go to the nearest valid position.
+    var mappedPos = mapping.map(startSel.from, -1);
+    var clamped = clamp(mappedPos, 0, view.state.doc.content.size);
+    var near = Selection.near(view.state.doc.resolve(clamped), -1);
+    view.dispatch(view.state.tr.setSelection(near));
+    return false;
+  }
+}
+
+/**
+ * Determines whether a table cell is effectively empty.
+ */
+export function isCellEmpty(cellNode) {
+  if (cellNode.childCount === 0) return true;
+  var isEmpty = true;
+  cellNode.descendants(function (n) {
+    var _n$text;
+    if (n.isText && (_n$text = n.text) !== null && _n$text !== void 0 && _n$text.trim()) {
+      isEmpty = false;
+      return false;
+    }
+    if (n.isLeaf && !n.isText) {
+      isEmpty = false;
+      return false;
+    }
+    return true;
+  });
+  return isEmpty;
+}
+
+/**
+ * Counts how many consecutive empty rows exist at the bottom of a given table.
+ */
+export function countEmptyRowsFromEnd(editor, tablePos) {
+  return countEmptyCellsFromEnd(editor, tablePos, 'row');
+}
+
+/**
+ * Counts how many consecutive empty columns exist at the right edge of a given table.
+ */
+export function countEmptyColumnsFromEnd(editor, tablePos) {
+  return countEmptyCellsFromEnd(editor, tablePos, 'column');
+}
+
+/**
+ * Rounds a number with a symmetric "dead-zone" around integer boundaries.
+ */
+export function marginRound(num) {
+  var margin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.3;
+  var floor = Math.floor(num);
+  var ceil = Math.ceil(num);
+  var lowerBound = floor + margin;
+  var upperBound = ceil - margin;
+  if (num < lowerBound) return floor;
+  if (num > upperBound) return ceil;
+  return Math.round(num);
+}
+
+/**
+ * Applies the transaction based on the specified mode
+ */
+function applySelectionWithMode(state, transaction, options) {
+  var _options$mode;
+  var mode = (_options$mode = options.mode) !== null && _options$mode !== void 0 ? _options$mode : 'state';
+  switch (mode) {
+    case 'dispatch':
+      {
+        var dispatchOptions = options;
+        if (typeof dispatchOptions.dispatch === 'function') {
+          dispatchOptions.dispatch(transaction);
+        }
+        return;
+      }
+    case 'transaction':
+      return transaction;
+    default:
+      // "state"
+      return state.apply(transaction);
+  }
+}
+
+/**
+ * Selects table cells by their (row, col) coordinates.
+ */
+export function selectCellsByCoords(editor, tablePos, coords) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
+    mode: 'state'
+  };
+  if (!editor) return;
+  var table = getTable(editor, tablePos);
+  if (!table) return;
+  var state = editor.state;
+  var tableMap = table.map;
+  var cleanedCoords = coords.map(function (coord) {
+    return {
+      row: clamp(coord.row, 0, tableMap.height - 1),
+      col: clamp(coord.col, 0, tableMap.width - 1)
+    };
+  }).filter(function (coord) {
+    return isWithinBounds(coord.row, coord.col, tableMap);
+  });
+  if (cleanedCoords.length === 0) {
+    return;
+  }
+
+  // --- Find the smallest rectangle that contains all our coordinates ---
+  var allRows = cleanedCoords.map(function (coord) {
+    return coord.row;
+  });
+  var topRow = Math.min.apply(Math, _toConsumableArray(allRows));
+  var bottomRow = Math.max.apply(Math, _toConsumableArray(allRows));
+  var allCols = cleanedCoords.map(function (coord) {
+    return coord.col;
+  });
+  var leftCol = Math.min.apply(Math, _toConsumableArray(allCols));
+  var rightCol = Math.max.apply(Math, _toConsumableArray(allCols));
+
+  // --- Convert visual coordinates to document positions ---
+  var getCellPositionFromMap = function getCellPositionFromMap(row, col) {
+    var cellOffset = tableMap.map[row * tableMap.width + col];
+    if (cellOffset === undefined) return null;
+    return tablePos + 1 + cellOffset;
+  };
+
+  // Anchor = where the selection starts (top-left of bounding box)
+  var anchorPosition = getCellPositionFromMap(topRow, leftCol);
+  if (anchorPosition === null) return;
+
+  // Head = where the selection ends (usually bottom-right of bounding box)
+  var headPosition = getCellPositionFromMap(bottomRow, rightCol);
+  if (headPosition === null) return;
+
+  // --- Handle edge case with merged cells ---
+  if (headPosition === anchorPosition) {
+    var foundDifferentCell = false;
+    for (var row = bottomRow; row >= topRow && !foundDifferentCell; row--) {
+      for (var col = rightCol; col >= leftCol && !foundDifferentCell; col--) {
+        var candidatePosition = getCellPositionFromMap(row, col);
+        if (candidatePosition !== null && candidatePosition !== anchorPosition) {
+          headPosition = candidatePosition;
+          foundDifferentCell = true;
+        }
+      }
+    }
+  }
+  try {
+    var anchorRef = state.doc.resolve(anchorPosition);
+    var headRef = state.doc.resolve(headPosition);
+    var cellSelection = new CellSelection(anchorRef, headRef);
+    var transaction = state.tr.setSelection(cellSelection);
+    return applySelectionWithMode(state, transaction, options);
+  } catch (error) {
+    console.error('Failed to create cell selection:', error);
+    return;
+  }
+}
+
+/**
+ * Select the cell at (row, col) using `cellAround` to respect merged cells.
+ */
+export function selectCellAt(_ref2) {
+  var editor = _ref2.editor,
+    row = _ref2.row,
+    col = _ref2.col,
+    tablePos = _ref2.tablePos,
+    dispatch = _ref2.dispatch;
+  if (!editor) return false;
+  var state = editor.state,
+    view = editor.view;
+  var found = getTable(editor, tablePos);
+  if (!found) return false;
+
+  // Bounds check
+  if (!isWithinBounds(row, col, found.map)) {
+    return false;
+  }
+  var relCellPos = found.map.positionAt(row, col, found.node);
+  var absCellPos = found.start + relCellPos;
+  var $abs = state.doc.resolve(absCellPos);
+  var $cell = cellAround($abs);
+  var cellPos = $cell ? $cell.pos : absCellPos;
+  var sel = CellSelection.create(state.doc, cellPos);
+  var doDispatch = dispatch !== null && dispatch !== void 0 ? dispatch : view === null || view === void 0 ? void 0 : view.dispatch;
+  if (!doDispatch) return false;
+  doDispatch(state.tr.setSelection(sel));
+  return true;
+}
+
+/**
+ * Selects a boundary cell of the table based on orientation.
+ */
+export function selectLastCell(editor, tableNode, tablePos, orientation) {
+  var map = TableMap.get(tableNode);
+  var isRow = orientation === 'row';
+
+  // For rows, select bottom-left cell; for columns, select top-right cell
+  var row = isRow ? map.height - 1 : 0;
+  var col = isRow ? 0 : map.width - 1;
+
+  // Calculate the index in the table map
+  var index = row * map.width + col;
+
+  // Get the actual cell position from the map (handles merged cells)
+  var cellPos = map.map[index];
+  if (!cellPos && cellPos !== 0) {
+    console.warn('selectLastCell: cell position not found in map', {
+      index: index,
+      row: row,
+      col: col,
+      map: map
+    });
+    return false;
+  }
+
+  // Find the row and column of the actual cell
+  var cellIndex = map.map.indexOf(cellPos);
+  var actualRow = cellIndex >= 0 ? Math.floor(cellIndex / map.width) : 0;
+  var actualCol = cellIndex >= 0 ? cellIndex % map.width : 0;
+  return selectCellAt({
+    editor: editor,
+    row: actualRow,
+    col: actualCol,
+    tablePos: tablePos,
+    dispatch: editor.view.dispatch.bind(editor.view)
+  });
+}
+
+/**
+ * Get all (row, col) coordinates for a given row or column index.
+ */
+export function getIndexCoordinates(_ref3) {
+  var editor = _ref3.editor,
+    index = _ref3.index,
+    orientation = _ref3.orientation,
+    tablePos = _ref3.tablePos;
+  if (!editor) return null;
+  var table = getTable(editor, tablePos);
+  if (!table) return null;
+  var map = table.map;
+  var width = map.width,
+    height = map.height;
+  if (index < 0) return null;
+  if (orientation === 'row' && index >= height) return null;
+  if (orientation === 'column' && index >= width) return null;
+  return orientation === 'row' ? Array.from({
+    length: map.width
+  }, function (_, col) {
+    return {
+      row: index,
+      col: col
+    };
+  }) : Array.from({
+    length: map.height
+  }, function (_, row) {
+    return {
+      row: row,
+      col: index
+    };
+  });
+}
+
+/**
+ * Given a DOM cell element, find its (row, col) indices within the table.
+ */
+export function getCellIndicesFromDOM(cell, tableNode, editor) {
+  if (!tableNode) return null;
+  try {
+    var cellPos = editor.view.posAtDOM(cell, 0);
+    var $cellPos = editor.view.state.doc.resolve(cellPos);
+    for (var d = $cellPos.depth; d > 0; d--) {
+      var node = $cellPos.node(d);
+      if (node.type.name === 'tableCell' || node.type.name === 'tableHeader') {
+        var tableMap = TableMap.get(tableNode);
+        var cellNodePos = $cellPos.before(d);
+        var tableStart = $cellPos.start(d - 2);
+        var cellOffset = cellNodePos - tableStart;
+        var cellIndex = tableMap.map.indexOf(cellOffset);
+        return {
+          rowIndex: Math.floor(cellIndex / tableMap.width),
+          colIndex: cellIndex % tableMap.width
+        };
+      }
+    }
+  } catch (error) {
+    console.warn('Could not get cell position:', error);
+  }
+  return null;
+}
+
+/**
+ * Given a DOM element inside a table, find the corresponding table node and its position.
+ */
+export function getTableFromDOM(tableElement, editor) {
+  try {
+    var pos = editor.view.posAtDOM(tableElement, 0);
+    var $pos = editor.view.state.doc.resolve(pos);
+    for (var d = $pos.depth; d >= 0; d--) {
+      var node = $pos.node(d);
+      if (isTableNode(node)) {
+        return {
+          node: node,
+          pos: d === 0 ? 0 : $pos.before(d)
+        };
+      }
+    }
+  } catch (error) {
+    console.warn('Could not get table from DOM:', error);
+  }
+  return null;
+}
+
+/**
+ * Checks if a node is a table node
+ */
+export function isTableNode(node) {
+  return !!node && (node.type.name === 'table' || node.type.spec.tableRole === 'table');
+}
+
+/**
+ * Get all cells (and unique merged cells) from a specific row.
+ */
+export function getRowCells(editor, rowIndex, tablePos) {
+  return collectCells(editor, 'row', rowIndex, tablePos);
+}
+
+/**
+ * Collect cells (and unique merged cells) from the current table.
+ */
+export function getColumnCells(editor, columnIndex, tablePos) {
+  return collectCells(editor, 'column', columnIndex, tablePos);
+}
+
+/**
+ * Compare two DOMRects for equality (within a small tolerance)
+ */
+export function rectEq(rect1, rect2) {
+  if (!rect1 || !rect2) return rect1 === rect2;
+  var tolerance = 0.5;
+  return Math.abs(rect1.left - rect2.left) < tolerance && Math.abs(rect1.top - rect2.top) < tolerance && Math.abs(rect1.width - rect2.width) < tolerance && Math.abs(rect1.height - rect2.height) < tolerance;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctzhian/tiptap",
-  "version": "1.13.8",
+  "version": "2.0.0",
   "description": "基于 Tiptap 二次开发的编辑器组件",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -81,38 +81,39 @@
   },
   "dependencies": {
     "@floating-ui/dom": "^1.7.2",
-    "@tiptap/core": "^3.10.7",
-    "@tiptap/extension-bubble-menu": "^3.10.7",
-    "@tiptap/extension-code": "^3.10.7",
-    "@tiptap/extension-code-block-lowlight": "^3.10.7",
-    "@tiptap/extension-details": "^3.10.7",
-    "@tiptap/extension-drag-handle-react": "^3.10.7",
-    "@tiptap/extension-emoji": "^3.10.7",
-    "@tiptap/extension-file-handler": "^3.10.7",
-    "@tiptap/extension-highlight": "^3.10.7",
-    "@tiptap/extension-horizontal-rule": "^3.10.7",
-    "@tiptap/extension-image": "^3.10.7",
-    "@tiptap/extension-invisible-characters": "^3.10.7",
-    "@tiptap/extension-link": "^3.10.7",
-    "@tiptap/extension-list": "^3.10.7",
-    "@tiptap/extension-mathematics": "^3.10.7",
-    "@tiptap/extension-mention": "^3.10.7",
-    "@tiptap/extension-subscript": "^3.10.7",
-    "@tiptap/extension-superscript": "^3.10.7",
-    "@tiptap/extension-table": "^3.10.7",
-    "@tiptap/extension-table-of-contents": "^3.10.7",
-    "@tiptap/extension-text-align": "^3.10.7",
-    "@tiptap/extension-text-style": "^3.10.7",
-    "@tiptap/extension-unique-id": "^3.10.7",
-    "@tiptap/extension-youtube": "^3.10.7",
-    "@tiptap/extensions": "^3.10.7",
-    "@tiptap/html": "^3.10.7",
-    "@tiptap/markdown": "^3.10.7",
-    "@tiptap/pm": "^3.10.7",
-    "@tiptap/react": "^3.10.7",
-    "@tiptap/starter-kit": "^3.10.7",
-    "@tiptap/static-renderer": "^3.10.7",
-    "@tiptap/suggestion": "^3.10.7",
+    "@floating-ui/react": "^0.27.16",
+    "@tiptap/core": "^3.11.0",
+    "@tiptap/extension-bubble-menu": "^3.11.0",
+    "@tiptap/extension-code": "^3.11.0",
+    "@tiptap/extension-code-block-lowlight": "^3.11.0",
+    "@tiptap/extension-details": "^3.11.0",
+    "@tiptap/extension-drag-handle-react": "^3.11.0",
+    "@tiptap/extension-emoji": "^3.11.0",
+    "@tiptap/extension-file-handler": "^3.11.0",
+    "@tiptap/extension-highlight": "^3.11.0",
+    "@tiptap/extension-horizontal-rule": "^3.11.0",
+    "@tiptap/extension-image": "^3.11.0",
+    "@tiptap/extension-invisible-characters": "^3.11.0",
+    "@tiptap/extension-link": "^3.11.0",
+    "@tiptap/extension-list": "^3.11.0",
+    "@tiptap/extension-mathematics": "^3.11.0",
+    "@tiptap/extension-mention": "^3.11.0",
+    "@tiptap/extension-subscript": "^3.11.0",
+    "@tiptap/extension-superscript": "^3.11.0",
+    "@tiptap/extension-table": "^3.11.0",
+    "@tiptap/extension-table-of-contents": "^3.11.0",
+    "@tiptap/extension-text-align": "^3.11.0",
+    "@tiptap/extension-text-style": "^3.11.0",
+    "@tiptap/extension-unique-id": "^3.11.0",
+    "@tiptap/extension-youtube": "^3.11.0",
+    "@tiptap/extensions": "^3.11.0",
+    "@tiptap/html": "^3.11.0",
+    "@tiptap/markdown": "^3.11.0",
+    "@tiptap/pm": "^3.11.0",
+    "@tiptap/react": "^3.11.0",
+    "@tiptap/starter-kit": "^3.11.0",
+    "@tiptap/static-renderer": "^3.11.0",
+    "@tiptap/suggestion": "^3.11.0",
     "ace-builds": "^1.43.4",
     "core-js": "^3.46.0",
     "diff-match-patch": "^1.0.5",