@kopexa/extension-table 17.0.45 → 17.1.0

package/dist/lib/table-utils.js

@@ -0,0 +1,488 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/table-utils.ts
+var table_utils_exports = {};
+__export(table_utils_exports, {
+  cellsOverlapRectangle: () => cellsOverlapRectangle,
+  domCellAround: () => domCellAround,
+  getCellIndicesFromDOM: () => getCellIndicesFromDOM,
+  getColumnCells: () => getColumnCells,
+  getIndexCoordinates: () => getIndexCoordinates,
+  getRowCells: () => getRowCells,
+  getRowOrColumnCells: () => getRowOrColumnCells,
+  getTable: () => getTable,
+  getTableFromDOM: () => getTableFromDOM,
+  getTableSelectionType: () => getTableSelectionType,
+  isCellEmpty: () => isCellEmpty,
+  isCellMerged: () => isCellMerged,
+  isTableNode: () => isTableNode,
+  rectEq: () => rectEq,
+  selectCellsByCoords: () => selectCellsByCoords,
+  setCellAttr: () => setCellAttr,
+  updateSelectionAfterAction: () => updateSelectionAfterAction
+});
+module.exports = __toCommonJS(table_utils_exports);
+var import_shared_utils = require("@kopexa/shared-utils");
+var import_tables = require("@tiptap/pm/tables");
+var EMPTY_CELLS_RESULT = { cells: [], mergedCells: [] };
+function domCellAround(target) {
+  let current = target;
+  while (current && current.tagName !== "TD" && current.tagName !== "TH" && !current.classList.contains("tableWrapper")) {
+    if (current.classList.contains("ProseMirror")) return void 0;
+    current = (0, import_shared_utils.isHTMLElement)(current.parentNode) ? current.parentNode : null;
+  }
+  if (!current) return void 0;
+  if (current.tagName === "TD" || current.tagName === "TH") {
+    return {
+      type: "cell",
+      domNode: current,
+      tbodyNode: (0, import_shared_utils.safeClosest)(current, "tbody")
+    };
+  }
+  return {
+    type: "wrapper",
+    domNode: current,
+    tbodyNode: current.querySelector("tbody")
+  };
+}
+function getCellIndicesFromDOM(cell, tableNode, editor) {
+  if (!tableNode) return null;
+  try {
+    const cellPos = editor.view.posAtDOM(cell, 0);
+    const $cellPos = editor.view.state.doc.resolve(cellPos);
+    for (let d = $cellPos.depth; d > 0; d--) {
+      const node = $cellPos.node(d);
+      if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+        const tableMap = import_tables.TableMap.get(tableNode);
+        const cellNodePos = $cellPos.before(d);
+        const tableStart = $cellPos.start(d - 2);
+        const cellOffset = cellNodePos - tableStart;
+        const 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;
+}
+function collectCells(editor, orientation, index, tablePos) {
+  if (!editor) return EMPTY_CELLS_RESULT;
+  const { state } = editor;
+  const table = getTable(editor, tablePos);
+  if (!table) return EMPTY_CELLS_RESULT;
+  const tableStart = table.start;
+  const tableNode = table.node;
+  const map = table.map;
+  const resolvedIndex = resolveOrientationIndex(
+    state,
+    table,
+    orientation,
+    index
+  );
+  if (resolvedIndex === null) return EMPTY_CELLS_RESULT;
+  const maxIndex = orientation === "row" ? map.height : map.width;
+  if (resolvedIndex < 0 || resolvedIndex >= maxIndex) {
+    return EMPTY_CELLS_RESULT;
+  }
+  const cells = [];
+  const mergedCells = [];
+  const seenMerged = /* @__PURE__ */ new Set();
+  const iterationCount = orientation === "row" ? map.width : map.height;
+  for (let i = 0; i < iterationCount; i++) {
+    const row = orientation === "row" ? resolvedIndex : i;
+    const col = orientation === "row" ? i : resolvedIndex;
+    const cellIndex = row * map.width + col;
+    const mapCell = map.map[cellIndex];
+    if (mapCell === void 0) continue;
+    const cellPos = tableStart + mapCell;
+    const cellNode = tableNode.nodeAt(mapCell);
+    if (!cellNode) continue;
+    const cell = createCellInfo(row, col, cellPos, cellNode);
+    if (isCellMerged(cellNode)) {
+      if (!seenMerged.has(cellPos)) {
+        mergedCells.push(cell);
+        seenMerged.add(cellPos);
+      }
+    }
+    cells.push(cell);
+  }
+  return { cells, mergedCells };
+}
+function isCellMerged(node) {
+  var _a, _b;
+  if (!node) return false;
+  const colspan = (_a = node.attrs.colspan) != null ? _a : 1;
+  const rowspan = (_b = node.attrs.rowspan) != null ? _b : 1;
+  return colspan > 1 || rowspan > 1;
+}
+function getColumnCells(editor, columnIndex, tablePos) {
+  return collectCells(editor, "column", columnIndex, tablePos);
+}
+function getTable(editor, tablePos) {
+  if (!editor) return null;
+  let table = null;
+  if (typeof tablePos === "number") {
+    const tableNode = editor.state.doc.nodeAt(tablePos);
+    if ((tableNode == null ? void 0 : tableNode.type.name) === "table") {
+      table = {
+        node: tableNode,
+        pos: tablePos,
+        start: tablePos + 1,
+        depth: editor.state.doc.resolve(tablePos).depth
+      };
+    }
+  }
+  if (!table) {
+    const { state } = editor;
+    const $from = state.doc.resolve(state.selection.from);
+    table = (0, import_tables.findTable)($from);
+  }
+  if (!table) return null;
+  const tableMap = import_tables.TableMap.get(table.node);
+  if (!tableMap) return null;
+  return { ...table, map: tableMap };
+}
+function createCellInfo(row, column, cellPos, cellNode) {
+  return {
+    row,
+    column,
+    pos: cellPos,
+    node: cellNode,
+    start: cellPos + 1,
+    depth: cellNode ? cellNode.content.size : 0
+  };
+}
+function resolveOrientationIndex(state, table, orientation, providedIndex) {
+  var _a;
+  if (typeof providedIndex === "number") {
+    return providedIndex;
+  }
+  if (state.selection instanceof import_tables.CellSelection) {
+    const rect2 = (0, import_tables.selectedRect)(state);
+    return orientation === "row" ? rect2.top : rect2.left;
+  }
+  const $cell = (_a = (0, import_tables.cellAround)(state.selection.$anchor)) != null ? _a : (0, import_tables.selectionCell)(state);
+  if (!$cell) return null;
+  const rel = $cell.pos - table.start;
+  const rect = table.map.findCell(rel);
+  return orientation === "row" ? rect.top : rect.left;
+}
+function getIndexCoordinates({
+  editor,
+  index,
+  orientation,
+  tablePos
+}) {
+  if (!editor) return null;
+  const table = getTable(editor, tablePos);
+  if (!table) return null;
+  const { map } = table;
+  const { width, height } = map;
+  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 }, (_, col) => ({ row: index, col })) : Array.from({ length: map.height }, (_, row) => ({ row, col: index }));
+}
+function getRowCells(editor, rowIndex, tablePos) {
+  return collectCells(editor, "row", rowIndex, tablePos);
+}
+function getTableFromDOM(tableElement, editor) {
+  try {
+    const pos = editor.view.posAtDOM(tableElement, 0);
+    const $pos = editor.view.state.doc.resolve(pos);
+    for (let d = $pos.depth; d >= 0; d--) {
+      const node = $pos.node(d);
+      if (isTableNode(node)) {
+        return { node, pos: d === 0 ? 0 : $pos.before(d) };
+      }
+    }
+  } catch (error) {
+    console.warn("Could not get table from DOM:", error);
+  }
+  return null;
+}
+function isTableNode(node) {
+  return !!node && (node.type.name === "table" || node.type.spec.tableRole === "table");
+}
+function selectCellsByCoords(editor, tablePos, coords, options = { mode: "state" }) {
+  if (!editor) return;
+  const table = getTable(editor, tablePos);
+  if (!table) return;
+  const { state } = editor;
+  const tableMap = table.map;
+  const cleanedCoords = coords.map((coord) => ({
+    row: (0, import_shared_utils.clamp)(coord.row, 0, tableMap.height - 1),
+    col: (0, import_shared_utils.clamp)(coord.col, 0, tableMap.width - 1)
+  })).filter((coord) => isWithinBounds(coord.row, coord.col, tableMap));
+  if (cleanedCoords.length === 0) {
+    return;
+  }
+  const allRows = cleanedCoords.map((coord) => coord.row);
+  const topRow = Math.min(...allRows);
+  const bottomRow = Math.max(...allRows);
+  const allCols = cleanedCoords.map((coord) => coord.col);
+  const leftCol = Math.min(...allCols);
+  const rightCol = Math.max(...allCols);
+  const getCellPositionFromMap = (row, col) => {
+    const cellOffset = tableMap.map[row * tableMap.width + col];
+    if (cellOffset === void 0) return null;
+    return tablePos + 1 + cellOffset;
+  };
+  const anchorPosition = getCellPositionFromMap(topRow, leftCol);
+  if (anchorPosition === null) return;
+  let headPosition = getCellPositionFromMap(bottomRow, rightCol);
+  if (headPosition === null) return;
+  if (headPosition === anchorPosition) {
+    let foundDifferentCell = false;
+    for (let row = bottomRow; row >= topRow && !foundDifferentCell; row--) {
+      for (let col = rightCol; col >= leftCol && !foundDifferentCell; col--) {
+        const candidatePosition = getCellPositionFromMap(row, col);
+        if (candidatePosition !== null && candidatePosition !== anchorPosition) {
+          headPosition = candidatePosition;
+          foundDifferentCell = true;
+        }
+      }
+    }
+  }
+  try {
+    const anchorRef = state.doc.resolve(anchorPosition);
+    const headRef = state.doc.resolve(headPosition);
+    const cellSelection = new import_tables.CellSelection(anchorRef, headRef);
+    const transaction = state.tr.setSelection(cellSelection);
+    return applySelectionWithMode(state, transaction, options);
+  } catch (error) {
+    console.error("Failed to create cell selection:", error);
+    return;
+  }
+}
+function isWithinBounds(row, col, map) {
+  return row >= 0 && row < map.height && col >= 0 && col < map.width;
+}
+function applySelectionWithMode(state, transaction, options) {
+  var _a;
+  const mode = (_a = options.mode) != null ? _a : "state";
+  switch (mode) {
+    case "dispatch": {
+      const dispatchOptions = options;
+      if (typeof dispatchOptions.dispatch === "function") {
+        dispatchOptions.dispatch(transaction);
+      }
+      return;
+    }
+    case "transaction":
+      return transaction;
+    default:
+      return state.apply(transaction);
+  }
+}
+function getTableSelectionType(editor, index, orientation, tablePos) {
+  if (typeof index === "number" && orientation) {
+    return { orientation, index };
+  }
+  if (!editor) return null;
+  const { state } = editor;
+  const table = getTable(editor, tablePos);
+  if (!table) return null;
+  if (state.selection instanceof import_tables.CellSelection) {
+    const rect = (0, import_tables.selectedRect)(state);
+    const map = import_tables.TableMap.get(table.node);
+    const width = rect.right - rect.left;
+    const height = rect.bottom - rect.top;
+    if (height === 1 && width === map.width) {
+      return { orientation: "row", index: rect.top };
+    }
+    if (width === 1 && height === map.height) {
+      return { orientation: "column", index: rect.left };
+    }
+    return null;
+  }
+  return null;
+}
+function getRowOrColumnCells(editor, index, orientation, tablePos) {
+  const emptyResult = {
+    cells: [],
+    mergedCells: [],
+    index: void 0,
+    orientation: void 0,
+    tablePos: void 0
+  };
+  if (!editor) {
+    return emptyResult;
+  }
+  if (typeof index !== "number" && !(editor.state.selection instanceof import_tables.CellSelection)) {
+    return emptyResult;
+  }
+  let finalIndex = index;
+  let finalOrientation = orientation;
+  if (typeof finalIndex !== "number" || !finalOrientation || !["row", "column"].includes(finalOrientation)) {
+    const selectionType = getTableSelectionType(editor);
+    if (!selectionType) return emptyResult;
+    finalIndex = selectionType.index;
+    finalOrientation = selectionType.orientation;
+  }
+  const result = collectCells(editor, finalOrientation, finalIndex, tablePos);
+  return { ...result, index: finalIndex, orientation: finalOrientation };
+}
+function updateSelectionAfterAction(editor, orientation, newIndex, tablePos) {
+  try {
+    const table = getTable(editor, tablePos);
+    if (!table) return;
+    const { state } = editor;
+    const { map } = table;
+    if (orientation === "row") {
+      if (newIndex >= 0 && newIndex < map.height) {
+        const startCol = 0;
+        const endCol = map.width - 1;
+        const startCellPos = table.start + map.positionAt(newIndex, startCol, table.node);
+        const endCellPos = table.start + map.positionAt(newIndex, endCol, table.node);
+        const $start = state.doc.resolve(startCellPos);
+        const $end = state.doc.resolve(endCellPos);
+        const newSelection = import_tables.CellSelection.create(
+          state.doc,
+          $start.pos,
+          $end.pos
+        );
+        const tr = state.tr.setSelection(newSelection);
+        editor.view.dispatch(tr);
+      }
+    } else if (orientation === "column") {
+      if (newIndex >= 0 && newIndex < map.width) {
+        const startRow = 0;
+        const endRow = map.height - 1;
+        const startCellPos = table.start + map.positionAt(startRow, newIndex, table.node);
+        const endCellPos = table.start + map.positionAt(endRow, newIndex, table.node);
+        const $start = state.doc.resolve(startCellPos);
+        const $end = state.doc.resolve(endCellPos);
+        const newSelection = import_tables.CellSelection.create(
+          state.doc,
+          $start.pos,
+          $end.pos
+        );
+        const tr = state.tr.setSelection(newSelection);
+        editor.view.dispatch(tr);
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to update selection after move:", error);
+  }
+}
+function isCellEmpty(cellNode) {
+  if (cellNode.childCount === 0) return true;
+  let isEmpty = true;
+  cellNode.descendants((n) => {
+    var _a;
+    if (n.isText && ((_a = n.text) == null ? void 0 : _a.trim())) {
+      isEmpty = false;
+      return false;
+    }
+    if (n.isLeaf && !n.isText) {
+      isEmpty = false;
+      return false;
+    }
+    return true;
+  });
+  return isEmpty;
+}
+function setCellAttr(nameOrAttrs, value) {
+  return (state, dispatch) => {
+    var _a;
+    if (!(0, import_tables.isInTable)(state)) return false;
+    const $cell = (0, import_tables.selectionCell)(state);
+    const attrs = typeof nameOrAttrs === "string" ? { [nameOrAttrs]: value } : nameOrAttrs;
+    if (dispatch) {
+      const tr = state.tr;
+      if (state.selection instanceof import_tables.CellSelection) {
+        state.selection.forEachCell((node, pos) => {
+          const needsUpdate = Object.entries(attrs).some(
+            ([name, val]) => node.attrs[name] !== val
+          );
+          if (needsUpdate) {
+            tr.setNodeMarkup(pos, null, {
+              ...node.attrs,
+              ...attrs
+            });
+          }
+        });
+      } else {
+        const needsUpdate = Object.entries(attrs).some(
+          ([name, val]) => {
+            var _a2;
+            return ((_a2 = $cell.nodeAfter) == null ? void 0 : _a2.attrs[name]) !== val;
+          }
+        );
+        if (needsUpdate) {
+          tr.setNodeMarkup($cell.pos, null, {
+            ...(_a = $cell.nodeAfter) == null ? void 0 : _a.attrs,
+            ...attrs
+          });
+        }
+      }
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+function cellsOverlapRectangle({ width, height, map }, rect) {
+  let indexTop = rect.top * width + rect.left, indexLeft = indexTop;
+  let indexBottom = (rect.bottom - 1) * width + rect.left, indexRight = indexTop + (rect.right - rect.left - 1);
+  for (let i = rect.top; i < rect.bottom; i++) {
+    if (rect.left > 0 && map[indexLeft] === map[indexLeft - 1] || rect.right < width && map[indexRight] === map[indexRight + 1])
+      return true;
+    indexLeft += width;
+    indexRight += width;
+  }
+  for (let i = rect.left; i < rect.right; i++) {
+    if (rect.top > 0 && map[indexTop] === map[indexTop - width] || rect.bottom < height && map[indexBottom] === map[indexBottom + width])
+      return true;
+    indexTop++;
+    indexBottom++;
+  }
+  return false;
+}
+function rectEq(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  return a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cellsOverlapRectangle,
+  domCellAround,
+  getCellIndicesFromDOM,
+  getColumnCells,
+  getIndexCoordinates,
+  getRowCells,
+  getRowOrColumnCells,
+  getTable,
+  getTableFromDOM,
+  getTableSelectionType,
+  isCellEmpty,
+  isCellMerged,
+  isTableNode,
+  rectEq,
+  selectCellsByCoords,
+  setCellAttr,
+  updateSelectionAfterAction
+});

package/dist/lib/table-utils.mjs

@@ -0,0 +1,40 @@
+"use client";
+import {
+  cellsOverlapRectangle,
+  domCellAround,
+  getCellIndicesFromDOM,
+  getColumnCells,
+  getIndexCoordinates,
+  getRowCells,
+  getRowOrColumnCells,
+  getTable,
+  getTableFromDOM,
+  getTableSelectionType,
+  isCellEmpty,
+  isCellMerged,
+  isTableNode,
+  rectEq,
+  selectCellsByCoords,
+  setCellAttr,
+  updateSelectionAfterAction
+} from "../chunk-5B5XIL2G.mjs";
+import "../chunk-WKV76XOR.mjs";
+export {
+  cellsOverlapRectangle,
+  domCellAround,
+  getCellIndicesFromDOM,
+  getColumnCells,
+  getIndexCoordinates,
+  getRowCells,
+  getRowOrColumnCells,
+  getTable,
+  getTableFromDOM,
+  getTableSelectionType,
+  isCellEmpty,
+  isCellMerged,
+  isTableNode,
+  rectEq,
+  selectCellsByCoords,
+  setCellAttr,
+  updateSelectionAfterAction
+};

package/dist/messages.d.mts

@@ -0,0 +1,174 @@
+declare const messages: {
+    row_actions: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    column_actions: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    cell_options: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    alignment: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_left: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_center: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_right: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    justify: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_top: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_middle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    align_bottom: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insert_row_above: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insert_row_below: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insert_column_left: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insert_column_right: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    delete_row: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    delete_column: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    move_row_up: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    move_row_down: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    move_column_left: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    move_column_right: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sort_row_asc: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sort_row_desc: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sort_column_asc: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sort_column_desc: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    duplicate_row: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    duplicate_column: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    header_row: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    header_column: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    merge_cells: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    split_cell: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clear_row_contents: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clear_column_contents: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clear_contents: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+
+export { messages };