@lumir-company/editor 0.4.17 → 0.4.18

package/dist/index.mjs

@@ -4901,6 +4901,9 @@ function LumirTableHandlesController() {
   const frozenRef = useRef11(false);
   const menuOpenRef = useRef11(false);
   const draggingRef = useRef11(false);
+  useEffect10(() => {
+    editor.__lumirActiveTableId = focused?.block?.id ?? null;
+  }, [editor, focused]);
   const recompute = useCallback20(() => {
     if (frozenRef.current) {
       return;
@@ -5443,6 +5446,140 @@ function liftFontSize(blocks) {
   return mapPreservingRef(blocks, (b) => mapBlock(b, "lift"));
 }
 
+// src/utils/table-delete.ts
+import { CellSelection, TableMap as TableMap2, deleteRow } from "prosemirror-tables";
+function measureRowHeights(view, tablePos) {
+  try {
+    const at = view?.domAtPos?.(tablePos + 1);
+    let el = at?.node;
+    if (el && el.nodeType === 3) el = el.parentElement;
+    const tableEl = el?.closest?.("table") ?? null;
+    const body = tableEl?.tBodies?.[0];
+    if (!body) return null;
+    return Array.from(body.rows).map(
+      (tr) => Math.round(tr.getBoundingClientRect().height)
+    );
+  } catch {
+    return null;
+  }
+}
+function buildDeleteColumnTr(state, tablePos, col, rowPx) {
+  const table = state.doc.nodeAt(tablePos);
+  if (!table || table.type.name !== "table") return null;
+  const map = TableMap2.get(table);
+  const W = map.width;
+  const H = map.height;
+  if (col < 0 || col >= W || W <= 1) return null;
+  const cells = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let r = 0; r < H; r++) {
+    for (let c = 0; c < W; c++) {
+      const pos = map.map[r * W + c];
+      if (seen.has(pos)) continue;
+      seen.add(pos);
+      const node = table.nodeAt(pos);
+      if (!node) continue;
+      cells.push({
+        node,
+        top: r,
+        left: c,
+        rowspan: node.attrs.rowspan ?? 1,
+        colspan: node.attrs.colspan ?? 1
+      });
+    }
+  }
+  const spansCol = (c) => c.left <= col && col < c.left + c.colspan;
+  const isDropped = (c) => spansCol(c) && c.colspan === 1;
+  const survivingByRow = new Array(H).fill(0);
+  for (const c of cells) if (!isDropped(c)) survivingByRow[c.top]++;
+  const rowDies = survivingByRow.map((n) => n === 0);
+  const newRowIndex = [];
+  let ni = 0;
+  for (let r = 0; r < H; r++) newRowIndex[r] = rowDies[r] ? -1 : ni++;
+  const newH = ni;
+  if (newH === 0) return null;
+  const newRows = Array.from({ length: newH }, () => []);
+  for (const c of cells) {
+    if (isDropped(c)) continue;
+    const newColspan = c.colspan - (spansCol(c) ? 1 : 0);
+    let dyingWithin = 0;
+    for (let r = c.top; r < c.top + c.rowspan; r++) if (rowDies[r]) dyingWithin++;
+    const newRowspan = Math.max(1, c.rowspan - dyingWithin);
+    const attrs = { ...c.node.attrs, colspan: newColspan, rowspan: newRowspan };
+    if (spansCol(c) && Array.isArray(attrs.colwidth) && attrs.colwidth.length) {
+      const cw = attrs.colwidth.slice();
+      cw.splice(col - c.left, 1);
+      attrs.colwidth = cw.some((w) => w > 0) ? cw : null;
+    }
+    if (dyingWithin > 0 && rowPx) {
+      let sum = 0;
+      let ok = true;
+      for (let r = c.top; r < c.top + c.rowspan; r++) {
+        if (typeof rowPx[r] !== "number") {
+          ok = false;
+          break;
+        }
+        sum += rowPx[r];
+      }
+      if (ok && sum > 0) attrs.rowHeight = Math.round(sum);
+    }
+    const target = newRowIndex[c.top];
+    if (target >= 0) newRows[target].push(c.node.type.create(attrs, c.node.content));
+  }
+  const rowType = table.child(0)?.type;
+  if (!rowType) return null;
+  const rowNodes = newRows.map((rowCells) => rowType.create(null, rowCells));
+  const newTable = table.type.create(table.attrs, rowNodes);
+  const tr = state.tr;
+  tr.replaceWith(tablePos, tablePos + table.nodeSize, newTable);
+  return tr.docChanged ? tr : null;
+}
+function removeFocusedRowOrColumn(editor, index, direction) {
+  const tiptap = editor?._tiptapEditor;
+  if (!tiptap) return false;
+  const { state } = tiptap;
+  let tablePos = -1;
+  const activeId = editor?.__lumirActiveTableId;
+  if (activeId) {
+    const p = findTableNodePos(tiptap, activeId);
+    if (p >= 0 && state.doc.nodeAt(p)?.type.name === "table") tablePos = p;
+  }
+  if (tablePos < 0) {
+    const $from = state.selection.$from;
+    for (let d = $from.depth; d > 0; d--) {
+      if ($from.node(d).type.name === "table") {
+        tablePos = $from.before(d);
+        break;
+      }
+    }
+  }
+  if (tablePos < 0) {
+    const vp = editor?.tableHandles?.view?.tablePos;
+    if (typeof vp === "number" && state.doc.nodeAt(vp)?.type.name === "table") {
+      tablePos = vp;
+    }
+  }
+  if (tablePos < 0) return false;
+  try {
+    if (direction === "column") {
+      const rowPx = measureRowHeights(tiptap.view, tablePos);
+      const tr = buildDeleteColumnTr(state, tablePos, index, rowPx);
+      if (!tr) return false;
+      tiptap.view.dispatch(tr);
+      return true;
+    }
+    const tableInside = state.doc.resolve(tablePos + 1);
+    const rowStart = state.doc.resolve(tableInside.posAtIndex(index) + 1);
+    const cellPos = state.doc.resolve(rowStart.posAtIndex(0));
+    const selState = state.apply(
+      state.tr.setSelection(new CellSelection(cellPos))
+    );
+    return deleteRow(selState, (tr) => tiptap.view.dispatch(tr));
+  } catch {
+    return false;
+  }
+}
+
 // src/utils/excel-paste.ts
 var NAMED_COLORS = {
   black: "#000000",
@@ -6296,6 +6433,18 @@ function LumirEditor({
       editor.isEditable = editable;
     }
   }, [editor, editable]);
+  useEffect11(() => {
+    if (!editor) return;
+    const th = editor.tableHandles;
+    if (!th || th.__lumirColDelPatched || typeof th.removeRowOrColumn !== "function")
+      return;
+    const orig = th.removeRowOrColumn.bind(th);
+    th.removeRowOrColumn = (index, dir) => {
+      if (removeFocusedRowOrColumn(editor, index, dir)) return;
+      return orig(index, dir);
+    };
+    th.__lumirColDelPatched = true;
+  }, [editor]);
   useEffect11(() => {
     if (!editor || !floatingMenu) return;
     const ft = editor.formattingToolbar;