@underverse-ui/underverse 1.0.183 → 1.0.184

package/dist/index.js

@@ -27369,7 +27369,7 @@ function useLocale2() {
 }
 
 // src/components/UEditor/UEditor.tsx
-import React87, { useEffect as useEffect39, useImperativeHandle as useImperativeHandle4, useMemo as useMemo27, useRef as useRef38 } from "react";
+import React87, { useEffect as useEffect40, useImperativeHandle as useImperativeHandle4, useMemo as useMemo27, useRef as useRef39 } from "react";
 import { useEditor, EditorContent } from "@tiptap/react";
 
 // src/components/UEditor/extensions.ts
@@ -29905,11 +29905,17 @@ function isInTableCell(editor) {
 }
 function buildFormulaSuggestionItems({ query }) {
   const normalizedQuery = query.trim().toUpperCase();
+  if (!isFormulaFunctionSuggestionQuery(normalizedQuery)) {
+    return [];
+  }
   if (!normalizedQuery) {
     return FORMULA_FUNCTIONS;
   }
   return FORMULA_FUNCTIONS.filter((item) => item.name.startsWith(normalizedQuery));
 }
+function isFormulaFunctionSuggestionQuery(query) {
+  return /^[A-Z]*$/i.test(query.trim());
+}
 var FormulaSuggestionList = forwardRef16((props, ref) => {
   const t = useSmartTranslations("UEditor");
   const [selectedIndex, setSelectedIndex] = React76.useState(0);
@@ -29980,7 +29986,11 @@ var FormulaSuggestion = Extension4.create({
         editor: this.editor,
         char: "=",
         pluginKey: new PluginKey3("formulaSuggestion"),
-        allow: ({ editor }) => isInTableCell(editor),
+        allow: ({ editor, range }) => {
+          if (!isInTableCell(editor)) return false;
+          const suggestionText = editor.state.doc.textBetween(range.from, range.to, "", "");
+          return suggestionText.startsWith("=") && isFormulaFunctionSuggestionQuery(suggestionText.slice(1));
+        },
         command: ({ editor, range, props }) => {
           insertFormulaFunction(editor, range, props);
         },
@@ -33983,51 +33993,98 @@ function buildTableFormulaDependencyGraph(cells) {
   return { dependencies, dependents, formulas };
 }
 function getTableFormulaCircularReferences(graph) {
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
   const circular = /* @__PURE__ */ new Set();
-  const stack = [];
-  const visit = (label) => {
-    if (visiting.has(label)) {
-      const start = stack.indexOf(label);
-      for (const cycleLabel of start >= 0 ? stack.slice(start) : [label]) {
-        circular.add(cycleLabel);
+  const visited = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const startLabel of graph.formulas.keys()) {
+    if (visited.has(startLabel)) continue;
+    visited.add(startLabel);
+    const stack = [
+      {
+        label: startLabel,
+        references: Array.from(graph.dependencies.get(startLabel) ?? []).filter((ref) => graph.formulas.has(ref)),
+        nextIndex: 0
       }
-      return;
-    }
-    if (visited.has(label)) return;
-    visiting.add(label);
-    stack.push(label);
-    for (const ref of graph.dependencies.get(label) ?? []) {
-      if (graph.formulas.has(ref)) {
-        visit(ref);
+    ];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) break;
+      const reference = frame.references[frame.nextIndex];
+      if (reference) {
+        frame.nextIndex += 1;
+        if (!visited.has(reference)) {
+          visited.add(reference);
+          stack.push({
+            label: reference,
+            references: Array.from(graph.dependencies.get(reference) ?? []).filter((ref) => graph.formulas.has(ref)),
+            nextIndex: 0
+          });
+        }
+        continue;
       }
+      stack.pop();
+      finishOrder.push(frame.label);
+    }
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  for (let index = finishOrder.length - 1; index >= 0; index -= 1) {
+    const startLabel = finishOrder[index];
+    if (!startLabel || assigned.has(startLabel)) continue;
+    const component = [];
+    const stack = [startLabel];
+    assigned.add(startLabel);
+    while (stack.length > 0) {
+      const label = stack.pop();
+      if (!label) continue;
+      component.push(label);
+      for (const dependent of graph.dependents.get(label) ?? []) {
+        if (!graph.formulas.has(dependent) || assigned.has(dependent)) continue;
+        assigned.add(dependent);
+        stack.push(dependent);
+      }
+    }
+    if (component.length > 1) {
+      for (const label of component) circular.add(label);
+    } else {
+      const label = component[0];
+      if (label && graph.dependencies.get(label)?.has(label)) circular.add(label);
     }
-    stack.pop();
-    visiting.delete(label);
-    visited.add(label);
-  };
-  for (const label of graph.formulas.keys()) {
-    visit(label);
   }
   return circular;
 }
 function getTableFormulaRecalculationOrder(graph) {
   const circular = getTableFormulaCircularReferences(graph);
+  const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const order = [];
-  const visit = (label) => {
-    if (visited.has(label) || circular.has(label)) return;
-    visited.add(label);
-    for (const ref of graph.dependencies.get(label) ?? []) {
-      if (graph.formulas.has(ref)) {
-        visit(ref);
+  for (const startLabel of graph.formulas.keys()) {
+    if (visited.has(startLabel) || circular.has(startLabel)) continue;
+    const stack = [];
+    const push = (label) => {
+      visiting.add(label);
+      stack.push({
+        label,
+        references: Array.from(graph.dependencies.get(label) ?? []).filter((ref) => graph.formulas.has(ref) && !circular.has(ref)),
+        nextIndex: 0
+      });
+    };
+    push(startLabel);
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) break;
+      const reference = frame.references[frame.nextIndex];
+      if (reference) {
+        frame.nextIndex += 1;
+        if (!visited.has(reference) && !visiting.has(reference)) {
+          push(reference);
+        }
+        continue;
       }
+      stack.pop();
+      visiting.delete(frame.label);
+      visited.add(frame.label);
+      order.push(frame.label);
     }
-    order.push(label);
-  };
-  for (const label of graph.formulas.keys()) {
-    visit(label);
   }
   return { order, circular };
 }
@@ -34086,9 +34143,11 @@ function tokenizeFormula(formula) {
       index += 1;
       continue;
     }
-    const numberMatch = formula.slice(index).match(/^\d+(?:\.\d+)?/);
+    const numberMatch = formula.slice(index).match(/^(?:\d+(?:\.\d*)?|\.\d+)/);
     if (numberMatch?.[0]) {
-      tokens.push({ type: "number", value: Number.parseFloat(numberMatch[0]) });
+      const value = Number.parseFloat(numberMatch[0]);
+      if (!Number.isFinite(value)) return null;
+      tokens.push({ type: "number", value });
       index += numberMatch[0].length;
       continue;
     }
@@ -34106,6 +34165,28 @@ function tokenizeFormula(formula) {
   }
   return tokens;
 }
+function toFiniteFormulaResult(value) {
+  return Number.isFinite(value) ? { value, error: null } : { value: null, error: "invalid-formula" };
+}
+function parseTableCellNumericValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  let normalized = String(value ?? "").trim();
+  if (!normalized || normalized.startsWith("#")) return null;
+  const isPercent = normalized.endsWith("%");
+  if (isPercent) normalized = normalized.slice(0, -1).trim();
+  const currencyMatch = normalized.match(/^([+-]?)\$(.+)$/);
+  if (currencyMatch) {
+    normalized = `${currencyMatch[1] ?? ""}${currencyMatch[2] ?? ""}`.trim();
+  }
+  const groupedNumber = /^[+-]?\d{1,3}(?:,\d{3})+(?:\.\d*)?(?:[eE][+-]?\d+)?$/;
+  const plainNumber = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+  if (!groupedNumber.test(normalized) && !plainNumber.test(normalized)) return null;
+  const parsed = Number(normalized.replace(/,/g, ""));
+  if (!Number.isFinite(parsed)) return null;
+  return isPercent ? parsed / 100 : parsed;
+}
 var FormulaParser = class {
   constructor(tokens, getCellValue) {
     this.tokens = tokens;
@@ -34123,10 +34204,7 @@ var FormulaParser = class {
       this.index += 1;
       const right = this.parseTerm();
       if (right.error) return right;
-      left = {
-        value: operator.value === "+" ? left.value + right.value : left.value - right.value,
-        error: null
-      };
+      left = toFiniteFormulaResult(operator.value === "+" ? left.value + right.value : left.value - right.value);
     }
     return left;
   }
@@ -34141,10 +34219,7 @@ var FormulaParser = class {
       if (operator.value === "/" && right.value === 0) {
         return { value: null, error: "division-by-zero" };
       }
-      left = {
-        value: operator.value === "*" ? left.value * right.value : left.value / right.value,
-        error: null
-      };
+      left = toFiniteFormulaResult(operator.value === "*" ? left.value * right.value : left.value / right.value);
     }
     return left;
   }
@@ -34153,11 +34228,11 @@ var FormulaParser = class {
     if (!token) {
       return { value: null, error: "invalid-formula" };
     }
-    if (token.type === "operator" && token.value === "-") {
+    if (token.type === "operator" && (token.value === "-" || token.value === "+")) {
       this.index += 1;
       const value = this.parseFactor();
       if (value.error) return value;
-      return { value: -value.value, error: null };
+      return toFiniteFormulaResult(token.value === "-" ? -value.value : value.value);
     }
     if (token.type === "number") {
       this.index += 1;
@@ -34202,11 +34277,10 @@ var FormulaParser = class {
             if (cellValue2 != null) values.push(cellValue2);
             continue;
           }
-          const cellValue = this.readCellNumber(label);
-          if (cellValue.error) return cellValue;
-          values.push(cellValue.value);
+          const cellValue = this.readOptionalCellNumber(label);
+          if (cellValue != null) values.push(cellValue);
         }
-      } else if (name === "COUNT" && token.type === "cell") {
+      } else if (token.type === "cell") {
         this.index += 1;
         const cellValue = this.readOptionalCellNumber(token.value);
         if (cellValue != null) values.push(cellValue);
@@ -34223,28 +34297,24 @@ var FormulaParser = class {
       }
       return { value: null, error: "invalid-formula" };
     }
-    if (values.length === 0 && name !== "COUNT") {
-      return { value: null, error: "invalid-formula" };
+    if (name === "SUM") return toFiniteFormulaResult(values.reduce((sum, value) => sum + value, 0));
+    if (name === "AVG") {
+      return values.length > 0 ? toFiniteFormulaResult(values.reduce((sum, value) => sum + value, 0) / values.length) : { value: null, error: "division-by-zero" };
     }
-    if (name === "SUM") return { value: values.reduce((sum, value) => sum + value, 0), error: null };
-    if (name === "AVG") return { value: values.reduce((sum, value) => sum + value, 0) / values.length, error: null };
-    if (name === "MIN") return { value: Math.min(...values), error: null };
-    if (name === "MAX") return { value: Math.max(...values), error: null };
+    if (name === "MIN") return toFiniteFormulaResult(values.length > 0 ? Math.min(...values) : 0);
+    if (name === "MAX") return toFiniteFormulaResult(values.length > 0 ? Math.max(...values) : 0);
     if (name === "COUNT") return { value: values.length, error: null };
     return { value: null, error: "invalid-formula" };
   }
   readCellNumber(label) {
-    const value = this.getCellValue(label);
-    const parsed = typeof value === "number" ? value : Number.parseFloat(String(value ?? "").trim());
-    if (!Number.isFinite(parsed)) {
+    const parsed = parseTableCellNumericValue(this.getCellValue(label));
+    if (parsed == null) {
       return { value: null, error: "invalid-reference" };
     }
     return { value: parsed, error: null };
   }
   readOptionalCellNumber(label) {
-    const value = this.getCellValue(label);
-    const parsed = typeof value === "number" ? value : Number.parseFloat(String(value ?? "").trim());
-    return Number.isFinite(parsed) ? parsed : null;
+    return parseTableCellNumericValue(this.getCellValue(label));
   }
   peekOperator(operators) {
     const token = this.tokens[this.index];
@@ -35360,7 +35430,7 @@ var CustomBubbleMenu = ({
   const BUBBLE_MENU_ESTIMATED_HEIGHT = 44;
   const [isVisible, setIsVisible] = useState50(false);
   const [linkInputOpen, setLinkInputOpen] = useState50(false);
-  const [position, setPosition] = useState50({
+  const [position, setPosition2] = useState50({
     top: 0,
     left: 0,
     placement: "top"
@@ -35432,7 +35502,7 @@ var CustomBubbleMenu = ({
         Math.max(viewportPadding, (start.left + end.left) / 2)
       );
       const top = placement === "top" ? Math.max(viewportPadding, selectionTop - BUBBLE_MENU_OFFSET) : Math.min(window.innerHeight - viewportPadding, selectionBottom + BUBBLE_MENU_OFFSET);
-      setPosition({ top, left, placement });
+      setPosition2({ top, left, placement });
       if (keepOpenRef.current) {
         clearShowTimeout();
         setIsVisible(true);
@@ -41961,8 +42031,401 @@ function useUEditorTableInteractions(editor, editable = true) {
   };
 }
 
+// src/components/UEditor/use-formula-coordinate-overlay.ts
+import { useEffect as useEffect39, useRef as useRef37 } from "react";
+import { TableMap as TableMap6 } from "@tiptap/pm/tables";
+
+// src/components/UEditor/table-formula-range-picker.ts
+import { TextSelection as TextSelection4 } from "@tiptap/pm/state";
+import { TableMap as TableMap5 } from "@tiptap/pm/tables";
+function getCellText2(cellNode) {
+  return cellNode.textBetween(0, cellNode.content.size, "\n").trim();
+}
+function getFormulaEditingTableContext(view) {
+  const { $from } = view.state.selection;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const node = $from.node(depth);
+    if (node.type.name !== "tableCell" && node.type.name !== "tableHeader") continue;
+    if (!getCellText2(node).startsWith("=")) return null;
+    const cellPos = $from.before(depth);
+    const cellDom = view.nodeDOM(cellPos);
+    if (!(cellDom instanceof HTMLTableCellElement)) return null;
+    const tableDepth = depth - 2;
+    const tableNode = tableDepth > 0 ? $from.node(tableDepth) : null;
+    if (!tableNode || tableNode.type.name !== "table") return null;
+    const tableDom = cellDom.closest("table");
+    if (!(tableDom instanceof HTMLTableElement)) return null;
+    return {
+      cellContentEnd: $from.end(depth),
+      cellContentStart: $from.start(depth),
+      cellDom,
+      formula: getCellText2(node),
+      tableDom,
+      tableNode,
+      tablePos: $from.before(tableDepth)
+    };
+  }
+  return null;
+}
+function cancelFormulaEditing(view) {
+  const context = getFormulaEditingTableContext(view);
+  if (!context) return false;
+  let tr = view.state.tr.delete(context.cellContentStart, context.cellContentEnd);
+  const selectionPos = Math.min(context.cellContentStart, tr.doc.content.size);
+  tr = tr.setSelection(TextSelection4.near(tr.doc.resolve(selectionPos)));
+  view.dispatch(tr);
+  view.focus();
+  return true;
+}
+function getReferenceInsertionPrefix(view, cellContentStart, insertionPos) {
+  const textBeforeCursor = view.state.doc.textBetween(cellContentStart, insertionPos, "", "");
+  const isInsideFunctionArguments = /[A-Z]+\([^)]*$/i.test(textBeforeCursor);
+  const followsReference = /[A-Z]+[1-9]\d*(?::[A-Z]+[1-9]\d*)?\s*$/i.test(textBeforeCursor);
+  return isInsideFunctionArguments && followsReference ? "," : "";
+}
+function findTableForPos(view, pos) {
+  const $pos = view.state.doc.resolve(pos);
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type.name === "table") {
+      return {
+        node,
+        pos: $pos.before(depth),
+        start: $pos.start(depth)
+      };
+    }
+  }
+  return null;
+}
+function getCellRelativePosFromDomPos2(map, tableStart, domPos) {
+  const relativeDomPos = domPos - tableStart;
+  const seen = /* @__PURE__ */ new Set();
+  for (const relativeCellPos of map.map) {
+    if (seen.has(relativeCellPos)) continue;
+    seen.add(relativeCellPos);
+    if (relativeDomPos === relativeCellPos || relativeDomPos === relativeCellPos + 1) {
+      return relativeCellPos;
+    }
+  }
+  return null;
+}
+function getFormulaTableCellInfo(view, target, tablePos) {
+  const element = resolveEventElement(target);
+  const cell = element?.closest?.("th,td");
+  if (!(cell instanceof HTMLTableCellElement)) return null;
+  const domPos = view.posAtDOM(cell, 0);
+  const tableInfo = findTableForPos(view, domPos);
+  if (!tableInfo || tableInfo.pos !== tablePos) return null;
+  const map = TableMap5.get(tableInfo.node);
+  const relativeCellPos = getCellRelativePosFromDomPos2(map, tableInfo.start, domPos);
+  if (relativeCellPos == null) return null;
+  const rect = map.findCell(relativeCellPos);
+  return {
+    cell,
+    label: `${indexToColumnName(rect.left)}${rect.top + 1}`,
+    rect
+  };
+}
+function normalizeFormulaRangeLabel(fromLabel, toLabel) {
+  return fromLabel === toLabel ? fromLabel : `${fromLabel}:${toLabel}`;
+}
+function replacePickedLabel(view, pickState, nextLabel, currentCell) {
+  if (nextLabel === pickState.currentLabel && currentCell === pickState.currentCell) return pickState;
+  if (nextLabel === pickState.currentLabel) {
+    return {
+      ...pickState,
+      currentCell
+    };
+  }
+  let tr = view.state.tr.insertText(nextLabel, pickState.insertedFrom, pickState.insertedTo);
+  const nextTo = pickState.insertedFrom + nextLabel.length;
+  tr = tr.setSelection(TextSelection4.create(tr.doc, nextTo));
+  view.dispatch(tr);
+  return {
+    ...pickState,
+    insertedTo: nextTo,
+    currentLabel: nextLabel,
+    currentCell
+  };
+}
+function beginFormulaRangePick(view, event) {
+  if (event.button !== 0) return null;
+  const formulaCell = getFormulaEditingTableContext(view);
+  if (!formulaCell) return null;
+  const picked = getFormulaTableCellInfo(view, event.target, formulaCell.tablePos);
+  if (!picked || picked.cell === formulaCell.cellDom) return null;
+  const { from, to } = view.state.selection;
+  const prefix = from === to ? getReferenceInsertionPrefix(view, formulaCell.cellContentStart, from) : "";
+  const insertedText = `${prefix}${picked.label}`;
+  const insertedFrom = from + prefix.length;
+  let tr = view.state.tr.insertText(insertedText, from, to);
+  tr = tr.setSelection(TextSelection4.create(tr.doc, from + insertedText.length));
+  view.dispatch(tr);
+  view.focus();
+  event.preventDefault();
+  event.stopPropagation();
+  return {
+    anchorLabel: picked.label,
+    anchorCell: picked.cell,
+    tablePos: formulaCell.tablePos,
+    insertedFrom,
+    insertedTo: insertedFrom + picked.label.length,
+    currentLabel: picked.label,
+    currentCell: picked.cell
+  };
+}
+function updateFormulaRangePick(view, pickState, event) {
+  const picked = getFormulaTableCellInfo(view, event.target, pickState.tablePos);
+  if (!picked) return pickState;
+  event.preventDefault();
+  event.stopPropagation();
+  return replacePickedLabel(
+    view,
+    pickState,
+    normalizeFormulaRangeLabel(pickState.anchorLabel, picked.label),
+    picked.cell
+  );
+}
+function getFormulaRangePickHighlight(container, pickState) {
+  if (!container.contains(pickState.anchorCell) || !container.contains(pickState.currentCell)) return null;
+  const containerRect = container.getBoundingClientRect();
+  const anchorRect = pickState.anchorCell.getBoundingClientRect();
+  const currentRect = pickState.currentCell.getBoundingClientRect();
+  const left = Math.min(anchorRect.left, currentRect.left) - containerRect.left + container.scrollLeft;
+  const top = Math.min(anchorRect.top, currentRect.top) - containerRect.top + container.scrollTop;
+  const right = Math.max(anchorRect.right, currentRect.right) - containerRect.left + container.scrollLeft;
+  const bottom = Math.max(anchorRect.bottom, currentRect.bottom) - containerRect.top + container.scrollTop;
+  return {
+    left,
+    top,
+    width: Math.max(0, right - left),
+    height: Math.max(0, bottom - top)
+  };
+}
+
+// src/components/UEditor/use-formula-coordinate-overlay.ts
+function setPosition(element, left, top, width, height) {
+  element.style.left = `${left}px`;
+  element.style.top = `${top}px`;
+  if (width != null) element.style.width = `${Math.max(0, width)}px`;
+  if (height != null) element.style.height = `${Math.max(0, height)}px`;
+}
+function createCoordinateLabel(kind, label) {
+  const element = document.createElement("span");
+  element.dataset.ueditorFormulaCoordinate = kind;
+  element.textContent = label;
+  element.className = "pointer-events-none absolute z-30 flex items-center justify-center rounded-[3px] border border-primary/35 bg-primary/90 px-1 font-mono text-[10px] font-semibold leading-none text-primary-foreground shadow-sm";
+  return element;
+}
+function createReferenceHighlight(label) {
+  const element = document.createElement("span");
+  element.dataset.ueditorFormulaReference = label;
+  element.className = "pointer-events-none absolute z-[21] rounded-[2px] border-2 border-emerald-500 bg-emerald-500/15";
+  return element;
+}
+function useFormulaCoordinateOverlay(editor, containerRef, labels) {
+  const overlayRef = useRef37(null);
+  useEffect39(() => {
+    if (!editor) return void 0;
+    const overlay = overlayRef.current;
+    const container = containerRef.current;
+    if (!overlay || !container) return void 0;
+    let animationFrame = null;
+    let activeTable = null;
+    let activeTablePos = null;
+    let hoverLabel = null;
+    const clearOverlay = () => {
+      activeTable = null;
+      activeTablePos = null;
+      hoverLabel = null;
+      overlay.replaceChildren();
+      overlay.style.display = "none";
+    };
+    const syncOverlay = () => {
+      animationFrame = null;
+      if (editor.isDestroyed) return;
+      const context = getFormulaEditingTableContext(editor.view);
+      if (!context) {
+        clearOverlay();
+        return;
+      }
+      const containerRect = container.getBoundingClientRect();
+      const tableRect = context.tableDom.getBoundingClientRect();
+      const tableLeft = tableRect.left - containerRect.left + container.scrollLeft;
+      const tableTop = tableRect.top - containerRect.top + container.scrollTop;
+      const map = TableMap6.get(context.tableNode);
+      const columnSegments = Array(map.width);
+      const rowSegments = Array(map.height);
+      const cellInfos = [];
+      for (const cell of context.tableDom.querySelectorAll("th,td")) {
+        if (!(cell instanceof HTMLTableCellElement)) continue;
+        const info = getFormulaTableCellInfo(editor.view, cell, context.tablePos);
+        if (!info) continue;
+        cellInfos.push(info);
+        const cellRect = cell.getBoundingClientRect();
+        const columnSpan = Math.max(1, info.rect.right - info.rect.left);
+        const rowSpan = Math.max(1, info.rect.bottom - info.rect.top);
+        const columnWidth = cellRect.width / columnSpan;
+        const rowHeight = cellRect.height / rowSpan;
+        for (let column = info.rect.left; column < info.rect.right; column += 1) {
+          if (!columnSegments[column] || columnSpan < columnSegments[column].span) {
+            columnSegments[column] = {
+              start: cellRect.left - containerRect.left + container.scrollLeft + (column - info.rect.left) * columnWidth,
+              size: columnWidth,
+              span: columnSpan
+            };
+          }
+        }
+        for (let row = info.rect.top; row < info.rect.bottom; row += 1) {
+          if (!rowSegments[row] || rowSpan < rowSegments[row].span) {
+            rowSegments[row] = {
+              start: cellRect.top - containerRect.top + container.scrollTop + (row - info.rect.top) * rowHeight,
+              size: rowHeight,
+              span: rowSpan
+            };
+          }
+        }
+      }
+      const fallbackColumnWidth = map.width > 0 ? tableRect.width / map.width : 0;
+      const fallbackRowHeight = map.height > 0 ? tableRect.height / map.height : 0;
+      const children = [];
+      const actions = document.createElement("div");
+      actions.dataset.ueditorFormulaActions = "";
+      actions.className = "pointer-events-auto absolute z-50 flex items-center gap-1 rounded-md border border-border bg-background p-1 shadow-md";
+      const formulaCellRect = context.cellDom.getBoundingClientRect();
+      setPosition(
+        actions,
+        formulaCellRect.left - containerRect.left + container.scrollLeft,
+        formulaCellRect.bottom - containerRect.top + container.scrollTop + 4
+      );
+      const applyButton = document.createElement("button");
+      applyButton.type = "button";
+      applyButton.dataset.ueditorFormulaApply = "";
+      applyButton.disabled = isDraftTableFormula(context.formula);
+      applyButton.textContent = `${applyButton.disabled ? "" : "\u2713 "}${labels.apply} (Enter)`;
+      applyButton.className = "rounded bg-primary px-2.5 py-1 text-xs font-medium text-primary-foreground hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-45";
+      const cancelButton = document.createElement("button");
+      cancelButton.type = "button";
+      cancelButton.dataset.ueditorFormulaCancel = "";
+      cancelButton.textContent = `${labels.cancel} (Esc)`;
+      cancelButton.className = "rounded px-2.5 py-1 text-xs font-medium text-foreground hover:bg-muted";
+      const preserveSelection = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      };
+      applyButton.addEventListener("mousedown", preserveSelection);
+      cancelButton.addEventListener("mousedown", preserveSelection);
+      applyButton.addEventListener("click", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!applyButton.disabled) recalculateActiveTableFormulas(editor);
+      });
+      cancelButton.addEventListener("click", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        cancelFormulaEditing(editor.view);
+      });
+      actions.append(applyButton, cancelButton);
+      children.push(actions);
+      for (let column = 0; column < map.width; column += 1) {
+        const segment = columnSegments[column] ?? {
+          start: tableLeft + column * fallbackColumnWidth,
+          size: fallbackColumnWidth,
+          span: map.width
+        };
+        const label = createCoordinateLabel("column", indexToColumnName(column));
+        setPosition(label, segment.start, Math.max(0, tableTop - 22), segment.size, 20);
+        children.push(label);
+      }
+      for (let row = 0; row < map.height; row += 1) {
+        const segment = rowSegments[row] ?? {
+          start: tableTop + row * fallbackRowHeight,
+          size: fallbackRowHeight,
+          span: map.height
+        };
+        const label = createCoordinateLabel("row", String(row + 1));
+        setPosition(label, Math.max(0, tableLeft - 28), segment.start, 26, segment.size);
+        children.push(label);
+      }
+      const references = new Set(getTableFormulaReferences(context.formula));
+      for (const info of cellInfos) {
+        if (!info || !references.has(info.label)) continue;
+        const cellRect = info.cell.getBoundingClientRect();
+        const highlight = createReferenceHighlight(info.label);
+        setPosition(
+          highlight,
+          cellRect.left - containerRect.left + container.scrollLeft + 2,
+          cellRect.top - containerRect.top + container.scrollTop + 2,
+          cellRect.width - 4,
+          cellRect.height - 4
+        );
+        children.push(highlight);
+      }
+      hoverLabel = document.createElement("span");
+      hoverLabel.dataset.ueditorFormulaHoverLabel = "";
+      hoverLabel.className = "pointer-events-none absolute z-40 hidden rounded bg-foreground px-1.5 py-1 font-mono text-[10px] font-semibold leading-none text-background shadow-md";
+      children.push(hoverLabel);
+      overlay.replaceChildren(...children);
+      overlay.style.display = "block";
+      activeTable = context.tableDom;
+      activeTablePos = context.tablePos;
+    };
+    const scheduleSync = () => {
+      if (animationFrame != null) return;
+      animationFrame = window.requestAnimationFrame(syncOverlay);
+    };
+    const handleMouseMove2 = (event) => {
+      if (!activeTable || activeTablePos == null || !hoverLabel) return;
+      const target = event.target instanceof Element ? event.target.closest("th,td") : null;
+      if (!(target instanceof HTMLTableCellElement) || target.closest("table") !== activeTable) {
+        hoverLabel.style.display = "none";
+        return;
+      }
+      const info = getFormulaTableCellInfo(editor.view, target, activeTablePos);
+      if (!info) {
+        hoverLabel.style.display = "none";
+        return;
+      }
+      const containerRect = container.getBoundingClientRect();
+      const cellRect = target.getBoundingClientRect();
+      hoverLabel.textContent = info.label;
+      hoverLabel.style.display = "block";
+      setPosition(
+        hoverLabel,
+        cellRect.left - containerRect.left + container.scrollLeft + 4,
+        cellRect.top - containerRect.top + container.scrollTop + 4
+      );
+    };
+    const handleMouseLeave2 = () => {
+      if (hoverLabel) hoverLabel.style.display = "none";
+    };
+    editor.on("selectionUpdate", scheduleSync);
+    editor.on("update", scheduleSync);
+    editor.on("focus", scheduleSync);
+    editor.on("blur", scheduleSync);
+    editor.view.dom.addEventListener("mousemove", handleMouseMove2);
+    editor.view.dom.addEventListener("mouseleave", handleMouseLeave2);
+    container.addEventListener(UEDITOR_TABLE_LAYOUT_CHANGE_EVENT, scheduleSync);
+    window.addEventListener("resize", scheduleSync);
+    scheduleSync();
+    return () => {
+      editor.off("selectionUpdate", scheduleSync);
+      editor.off("update", scheduleSync);
+      editor.off("focus", scheduleSync);
+      editor.off("blur", scheduleSync);
+      editor.view.dom.removeEventListener("mousemove", handleMouseMove2);
+      editor.view.dom.removeEventListener("mouseleave", handleMouseLeave2);
+      container.removeEventListener(UEDITOR_TABLE_LAYOUT_CHANGE_EVENT, scheduleSync);
+      window.removeEventListener("resize", scheduleSync);
+      if (animationFrame != null) window.cancelAnimationFrame(animationFrame);
+      clearOverlay();
+    };
+  }, [containerRef, editor, labels.apply, labels.cancel]);
+  return overlayRef;
+}
+
 // src/components/UEditor/menu-bar.tsx
-import React86, { useMemo as useMemo26, useRef as useRef37, useState as useState51 } from "react";
+import React86, { useMemo as useMemo26, useRef as useRef38, useState as useState51 } from "react";
 import { useEditorState as useEditorState3 } from "@tiptap/react";
 import {
   AlignCenter as AlignCenter4,
@@ -42586,7 +43049,7 @@ var MenuBar = ({
     editor,
     selector: ({ transactionNumber }) => transactionNumber
   });
-  const fileInputRef = useRef37(null);
+  const fileInputRef = useRef38(null);
   const [showImageInput, setShowImageInput] = useState51(false);
   const [showLinkInput, setShowLinkInput] = useState51(false);
   const [isInsertMenuOpen, setIsInsertMenuOpen] = useState51(false);
@@ -42875,146 +43338,6 @@ var MenuBar = ({
   ] });
 };
 
-// src/components/UEditor/table-formula-range-picker.ts
-import { TextSelection as TextSelection4 } from "@tiptap/pm/state";
-import { TableMap as TableMap5 } from "@tiptap/pm/tables";
-function getCellText2(cellNode) {
-  return cellNode.textBetween(0, cellNode.content.size, "\n").trim();
-}
-function findSelectionFormulaCell(view) {
-  const { $from } = view.state.selection;
-  for (let depth = $from.depth; depth > 0; depth -= 1) {
-    const node = $from.node(depth);
-    if (node.type.name !== "tableCell" && node.type.name !== "tableHeader") continue;
-    if (!getCellText2(node).startsWith("=")) return null;
-    const cellPos = $from.before(depth);
-    const cellDom = view.nodeDOM(cellPos);
-    const tableDepth = depth - 2;
-    const tableNode = tableDepth > 0 ? $from.node(tableDepth) : null;
-    if (!tableNode || tableNode.type.name !== "table") return null;
-    return {
-      cellDom: cellDom instanceof HTMLTableCellElement ? cellDom : null,
-      tablePos: $from.before(tableDepth)
-    };
-  }
-  return null;
-}
-function findTableForPos(view, pos) {
-  const $pos = view.state.doc.resolve(pos);
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth);
-    if (node.type.name === "table") {
-      return {
-        node,
-        pos: $pos.before(depth),
-        start: $pos.start(depth)
-      };
-    }
-  }
-  return null;
-}
-function getCellRelativePosFromDomPos2(map, tableStart, domPos) {
-  const relativeDomPos = domPos - tableStart;
-  const seen = /* @__PURE__ */ new Set();
-  for (const relativeCellPos of map.map) {
-    if (seen.has(relativeCellPos)) continue;
-    seen.add(relativeCellPos);
-    if (relativeDomPos === relativeCellPos || relativeDomPos === relativeCellPos + 1) {
-      return relativeCellPos;
-    }
-  }
-  return null;
-}
-function getPickedCellLabel(view, target, tablePos) {
-  const element = resolveEventElement(target);
-  const cell = element?.closest?.("th,td");
-  if (!(cell instanceof HTMLTableCellElement)) return null;
-  const domPos = view.posAtDOM(cell, 0);
-  const tableInfo = findTableForPos(view, domPos);
-  if (!tableInfo || tableInfo.pos !== tablePos) return null;
-  const map = TableMap5.get(tableInfo.node);
-  const relativeCellPos = getCellRelativePosFromDomPos2(map, tableInfo.start, domPos);
-  if (relativeCellPos == null) return null;
-  const rect = map.findCell(relativeCellPos);
-  return {
-    cell,
-    label: `${indexToColumnName(rect.left)}${rect.top + 1}`
-  };
-}
-function normalizeFormulaRangeLabel(fromLabel, toLabel) {
-  return fromLabel === toLabel ? fromLabel : `${fromLabel}:${toLabel}`;
-}
-function replacePickedLabel(view, pickState, nextLabel, currentCell) {
-  if (nextLabel === pickState.currentLabel && currentCell === pickState.currentCell) return pickState;
-  if (nextLabel === pickState.currentLabel) {
-    return {
-      ...pickState,
-      currentCell
-    };
-  }
-  let tr = view.state.tr.insertText(nextLabel, pickState.insertedFrom, pickState.insertedTo);
-  const nextTo = pickState.insertedFrom + nextLabel.length;
-  tr = tr.setSelection(TextSelection4.create(tr.doc, nextTo));
-  view.dispatch(tr);
-  return {
-    ...pickState,
-    insertedTo: nextTo,
-    currentLabel: nextLabel,
-    currentCell
-  };
-}
-function beginFormulaRangePick(view, event) {
-  if (event.button !== 0) return null;
-  const formulaCell = findSelectionFormulaCell(view);
-  if (!formulaCell) return null;
-  const picked = getPickedCellLabel(view, event.target, formulaCell.tablePos);
-  if (!picked || picked.cell === formulaCell.cellDom) return null;
-  const { from, to } = view.state.selection;
-  let tr = view.state.tr.insertText(picked.label, from, to);
-  tr = tr.setSelection(TextSelection4.create(tr.doc, from + picked.label.length));
-  view.dispatch(tr);
-  view.focus();
-  event.preventDefault();
-  event.stopPropagation();
-  return {
-    anchorLabel: picked.label,
-    anchorCell: picked.cell,
-    tablePos: formulaCell.tablePos,
-    insertedFrom: from,
-    insertedTo: from + picked.label.length,
-    currentLabel: picked.label,
-    currentCell: picked.cell
-  };
-}
-function updateFormulaRangePick(view, pickState, event) {
-  const picked = getPickedCellLabel(view, event.target, pickState.tablePos);
-  if (!picked) return pickState;
-  event.preventDefault();
-  event.stopPropagation();
-  return replacePickedLabel(
-    view,
-    pickState,
-    normalizeFormulaRangeLabel(pickState.anchorLabel, picked.label),
-    picked.cell
-  );
-}
-function getFormulaRangePickHighlight(container, pickState) {
-  if (!container.contains(pickState.anchorCell) || !container.contains(pickState.currentCell)) return null;
-  const containerRect = container.getBoundingClientRect();
-  const anchorRect = pickState.anchorCell.getBoundingClientRect();
-  const currentRect = pickState.currentCell.getBoundingClientRect();
-  const left = Math.min(anchorRect.left, currentRect.left) - containerRect.left + container.scrollLeft;
-  const top = Math.min(anchorRect.top, currentRect.top) - containerRect.top + container.scrollTop;
-  const right = Math.max(anchorRect.right, currentRect.right) - containerRect.left + container.scrollLeft;
-  const bottom = Math.max(anchorRect.bottom, currentRect.bottom) - containerRect.top + container.scrollTop;
-  return {
-    left,
-    top,
-    width: Math.max(0, right - left),
-    height: Math.max(0, bottom - top)
-  };
-}
-
 // src/components/UEditor/UEditor.tsx
 import { jsx as jsx99, jsxs as jsxs82 } from "react/jsx-runtime";
 var UEditor = React87.forwardRef(({
@@ -43058,11 +43381,12 @@ var UEditor = React87.forwardRef(({
 }, ref) => {
   const t = useSmartTranslations("UEditor");
   const effectivePlaceholder = placeholder ?? t("placeholder");
-  const inFlightPrepareRef = useRef38(null);
-  const lastAppliedContentRef = useRef38(content ?? "");
-  const scheduledFormulaRecalculateRef = useRef38(false);
-  const formulaRangePickRef = useRef38(null);
-  const formulaRangeSurfaceRef = useRef38(null);
+  const inFlightPrepareRef = useRef39(null);
+  const lastAppliedContentRef = useRef39(content ?? "");
+  const scheduledFormulaRecalculateRef = useRef39(false);
+  const editorInstanceRef = useRef39(null);
+  const formulaRangePickRef = useRef39(null);
+  const formulaRangeSurfaceRef = useRef39(null);
   const [formulaRangeHighlight, setFormulaRangeHighlight] = React87.useState(null);
   const scheduleFormulaRecalculate = React87.useCallback((editor2, options) => {
     if (editor2.isDestroyed || scheduledFormulaRecalculateRef.current) return;
@@ -43149,6 +43473,22 @@ var UEditor = React87.forwardRef(({
         },
         keydown: (_view, event) => {
           if (!(event instanceof KeyboardEvent)) return false;
+          const formulaContext = getFormulaEditingTableContext(_view);
+          if (formulaContext && event.key === "Enter") {
+            event.preventDefault();
+            event.stopPropagation();
+            const activeEditor = editorInstanceRef.current;
+            if (activeEditor && !isDraftTableFormula(formulaContext.formula)) {
+              recalculateActiveTableFormulas(activeEditor);
+            }
+            return true;
+          }
+          if (formulaContext && event.key === "Escape") {
+            event.preventDefault();
+            event.stopPropagation();
+            cancelFormulaEditing(_view);
+            return true;
+          }
           if (event.key === "ArrowLeft" || event.key === "ArrowRight" || event.key === "ArrowUp" || event.key === "ArrowDown") {
             event.stopPropagation();
           }
@@ -43189,12 +43529,22 @@ var UEditor = React87.forwardRef(({
       scheduleFormulaRecalculate(editor2, { force: true });
     }
   });
+  useEffect40(() => {
+    editorInstanceRef.current = editor;
+    return () => {
+      if (editorInstanceRef.current === editor) editorInstanceRef.current = null;
+    };
+  }, [editor]);
   const {
     editorContentRef,
     tableColumnGuideRef,
     tableRowGuideRef,
     activeTableCellHighlightRef
   } = useUEditorTableInteractions(editor, editable);
+  const formulaCoordinateOverlayRef = useFormulaCoordinateOverlay(editor, editorContentRef, {
+    apply: t("tableMenu.apply"),
+    cancel: t("imageInput.cancelBtn")
+  });
   useImperativeHandle4(
     ref,
     () => ({
@@ -43220,7 +43570,7 @@ var UEditor = React87.forwardRef(({
     }),
     [content, editor, uploadImageForSave, uploadFileForSave, uploadImageConcurrency]
   );
-  useEffect39(() => {
+  useEffect40(() => {
     if (!editor) return;
     queueMicrotask(() => {
       if (!editor.isDestroyed) {
@@ -43228,7 +43578,7 @@ var UEditor = React87.forwardRef(({
       }
     });
   }, [editor]);
-  useEffect39(() => {
+  useEffect40(() => {
     if (!editor) return;
     const nextContent = content ?? "";
     if (lastAppliedContentRef.current === nextContent) return;
@@ -43348,6 +43698,14 @@ var UEditor = React87.forwardRef(({
                   className: "pointer-events-none hidden absolute z-20 rounded-[2px] border-2 border-primary bg-primary/10"
                 }
               ),
+              /* @__PURE__ */ jsx99(
+                "div",
+                {
+                  ref: formulaCoordinateOverlayRef,
+                  "data-ueditor-formula-coordinate-overlay": "",
+                  className: "pointer-events-none absolute inset-0 z-[21] hidden overflow-visible"
+                }
+              ),
               formulaRangeHighlight && /* @__PURE__ */ jsx99(
                 "span",
                 {