Files
outline/shared/editor/queries/table.ts
T

631 lines
17 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import type { EditorState } from "prosemirror-state";
import type { TableRect } from "prosemirror-tables";
import { CellSelection, isInTable, selectedRect } from "prosemirror-tables";
import { ColumnSelection } from "../selection/ColumnSelection";
import { RowSelection } from "../selection/RowSelection";
import type { EditorView } from "prosemirror-view";
import type { NodeAttrMark, NodeAttrMarkName } from "../types";
import type { Node } from "prosemirror-model";
import type { Selection } from "prosemirror-state";
/**
* Checks if the current selection is a column selection.
* @param state The editor state.
* @returns True if the selection is a column selection, false otherwise.
*/
export function isColSelection(state: EditorState): boolean {
if (state.selection instanceof ColumnSelection) {
return state.selection.isColSelection();
}
return false;
}
/**
* Checks if the current selection is a row selection.
* @param state The editor state.
* @returns True if the selection is a row selection, false otherwise.
*/
export function isRowSelection(state: EditorState): boolean {
if (state.selection instanceof RowSelection) {
return state.selection.isRowSelection();
}
return false;
}
export function getColumnIndex(state: EditorState): number | undefined {
if (state.selection instanceof ColumnSelection) {
if (state.selection.isColSelection()) {
const rect = selectedRect(state);
return rect.left;
}
}
return undefined;
}
export function getRowIndex(state: EditorState): number | undefined {
if (state.selection instanceof RowSelection) {
if (state.selection.isRowSelection()) {
const rect = selectedRect(state);
return rect.top;
}
}
return undefined;
}
/**
* Get the actual row index in the table map for a given visual row index
* when merged cells are present.
*
* @param visualRowIndex The visual row index (0-based)
* @param state The editor state
* @returns The actual row index in the table map, or -1 if not found
*/
export function getRowIndexInMap(
visualRowIndex: number,
state: EditorState
): number {
if (!isInTable(state)) {
return -1;
}
const rect = selectedRect(state);
const cells = getCellsInColumn(0)(state);
if (visualRowIndex >= 0 && visualRowIndex < cells.length) {
const cellPos = cells[visualRowIndex] - rect.tableStart;
// Find the row index in the table map for this cell position
for (let row = 0; row < rect.map.height; row++) {
const rowStart = row * rect.map.width;
for (let col = 0; col < rect.map.width; col++) {
if (rect.map.map[rowStart + col] === cellPos) {
return row;
}
}
}
}
return -1;
}
/**
* Get the actual row positions in the table map, accounting for merged cells.
*
* Iterates through each visual row and returns the position of the first unique cell in that row.
* This ensures correct row identification even when cells span multiple rows (rowspan > 1).
*
* @param state The editor state
* @returns Array of cell positions representing the first unique cell in each row
*/
export function getRowsInTable(state: EditorState): number[] {
if (!isInTable(state)) {
return [];
}
const rect = selectedRect(state);
const rows: number[] = [];
const seenCells = new Set<number>();
for (let row = 0; row < rect.map.height; row++) {
// Find the leftmost cell in this row
for (let col = 0; col < rect.map.width; col++) {
const cellPos =
rect.tableStart + rect.map.map[row * rect.map.width + col];
if (!seenCells.has(cellPos)) {
rows.push(cellPos);
seenCells.add(cellPos);
break; // Only add the first unique cell per row
}
}
}
return rows;
}
/**
* Get the actual column positions in the table map, accounting for merged cells.
*
* @param state The editor state
* @returns Array of cell positions representing the first unique cell in each column
*/
export function getColumnsInTable(state: EditorState): number[] {
if (!isInTable(state)) {
return [];
}
const rect = selectedRect(state);
const columns: number[] = [];
const seenCells = new Set<number>();
for (let col = 0; col < rect.map.width; col++) {
// Find the topmost cell in this column
for (let row = 0; row < rect.map.height; row++) {
const cellPos =
rect.tableStart + rect.map.map[row * rect.map.width + col];
if (!seenCells.has(cellPos)) {
columns.push(cellPos);
seenCells.add(cellPos);
break; // Only add the first unique cell per column
}
}
}
return columns;
}
export function getCellsInColumn(index: number) {
return (state: EditorState): number[] => {
if (!isInTable(state)) {
return [];
}
const rect = selectedRect(state);
const cells = [];
let previous;
for (let i = index; i < rect.map.map.length; i += rect.map.width) {
const cell = rect.tableStart + rect.map.map[i];
// Ensure we don't add the same cell multiple times, this can happen
// if the column is selected and the table row has merged cells.
if (previous === cell) {
continue;
}
previous = cell;
cells.push(cell);
}
return cells;
};
}
export function getCellsInRow(index: number) {
return (state: EditorState): number[] => {
if (!isInTable(state)) {
return [];
}
const rect = selectedRect(state);
const cells = [];
let previous;
for (let i = 0; i < rect.map.width; i += 1) {
const cell = rect.tableStart + rect.map.map[index * rect.map.width + i];
cells.push(cell);
// Ensure we don't add the same cell multiple times, this can happen
// if the row is selected and the table column has merged cells.
if (previous === cell) {
continue;
}
previous = cell;
}
return cells;
};
}
/**
* Check if a specific column is selected in the editor.
*
* @param state The editor state
* @param index The index of the column to check
* @returns Boolean indicating if the column is selected
*/
export function isColumnSelected(index: number) {
return (state: EditorState): boolean => {
if (isColSelection(state)) {
const rect = selectedRect(state);
return rect.left <= index && rect.right > index;
}
return false;
};
}
/**
* Check if the header is enabled for the given type and table rect
*
* @param state The editor state
* @param type The type of header to check
* @param rect The table rect
* @returns Boolean indicating if the header is enabled
*/
export function isHeaderEnabled(
state: EditorState,
type: "row" | "column",
rect: TableRect
): boolean {
// Get cell positions for first row or first column
const cellPositions = rect.map.cellsInRect({
left: 0,
top: 0,
right: type === "row" ? rect.map.width : 1,
bottom: type === "column" ? rect.map.height : 1,
});
for (let i = 0; i < cellPositions.length; i++) {
const cell = rect.table.nodeAt(cellPositions[i]);
if (cell && cell.type !== state.schema.nodes.th) {
return false;
}
}
return true;
}
/**
* Check if a specific row is selected in the editor.
*
* @param state The editor state
* @param index The index of the row to check
* @returns Boolean indicating if the row is selected
*/
export function isRowSelected(index: number) {
return (state: EditorState): boolean =>
state.selection instanceof RowSelection && state.selection.isRowSelection()
? state.selection.$index === index
: false;
}
/**
* Check if an entire table is selected in the editor.
*
* @param state The editor state
* @returns Boolean indicating if the table is selected
*/
export function isTableSelected(state: EditorState): boolean {
if (state.selection instanceof CellSelection) {
const rect = selectedRect(state);
return (
rect.top === 0 &&
rect.left === 0 &&
rect.bottom === rect.map.height &&
rect.right === rect.map.width &&
!state.selection.empty
);
}
return false;
}
/**
* Check if multiple cells are selected in the editor.
*
* @param state The editor state
* @returns Boolean indicating if multiple cells are selected
*/
export function isMultipleCellSelection(state: EditorState): boolean {
const { selection } = state;
return (
selection instanceof CellSelection &&
(selection.isColSelection() ||
selection.isRowSelection() ||
selection.$anchorCell.pos !== selection.$headCell.pos)
);
}
/**
* Check if the selection spans multiple merged cells.
*
* @param state The editor state
* @returns Boolean indicating if a merged cell is selected
*/
export function isMergedCellSelection(state: EditorState): boolean {
const { selection } = state;
if (
selection instanceof CellSelection ||
selection instanceof RowSelection ||
selection instanceof ColumnSelection
) {
// Check if any cell in the selection has a colspan or rowspan > 1
let hasMergedCells = false;
selection.forEachCell((cell) => {
if (cell.attrs.colspan > 1 || cell.attrs.rowspan > 1) {
hasMergedCells = true;
return false;
}
return true;
});
return hasMergedCells;
}
return false;
}
/**
* Check if the table contains any cells with rowspan > 1.
* Cells with rowspan span multiple rows and would break table sorting.
*
* @param state The editor state.
* @returns true if the table has any cells with rowspan > 1, false otherwise.
*/
export function tableHasRowspan(state: EditorState): boolean {
if (!isInTable(state)) {
return false;
}
const rect = selectedRect(state);
const seen = new Set<number>();
for (let i = 0; i < rect.map.map.length; i++) {
const pos = rect.map.map[i];
// Skip already checked cells
if (seen.has(pos)) {
continue;
}
seen.add(pos);
const cell = rect.table.nodeAt(pos);
if (cell && cell.attrs.rowspan > 1) {
return true;
}
}
return false;
}
export function getAllSelectedColumns(state: EditorState): number[] {
const rect = selectedRect(state);
const selectedColumns: number[] = [];
for (let col = rect.left; col < rect.right; col++) {
selectedColumns.push(col);
}
return selectedColumns;
}
/**
* Get the indices of all currently selected rows.
*
* @param state The editor state
* @returns Array of selected row indices
*/
export function getAllSelectedRows(state: EditorState): number[] {
const rect = selectedRect(state);
const selectedRows: number[] = [];
for (let row = rect.top; row < rect.bottom; row++) {
selectedRows.push(row);
}
return selectedRows;
}
/**
* Get the positions of every unique cell across all selected columns, falling
* back to a single column when it is not part of the selection.
*
* Operating on the full selection ensures column operations affect all selected
* columns – including columns spanned by a merged (colspan) header cell, which a
* single-column lookup would miss.
*
* @param state The editor state
* @param fallbackIndex The column index to use when nothing is selected
* @returns Array of unique cell positions
*/
export function getCellsInSelectedColumns(
state: EditorState,
fallbackIndex: number
): number[] {
const selectedColumns = getAllSelectedColumns(state);
const columns = selectedColumns.includes(fallbackIndex)
? selectedColumns
: [fallbackIndex];
const seen = new Set<number>();
const cells: number[] = [];
columns.forEach((index) => {
getCellsInColumn(index)(state).forEach((pos) => {
if (!seen.has(pos)) {
seen.add(pos);
cells.push(pos);
}
});
});
return cells;
}
/**
* Get the positions of every unique cell across all selected rows, falling back
* to a single row when it is not part of the selection.
*
* Operating on the full selection ensures row operations affect all selected
* rows – including rows spanned by a merged (rowspan) cell, which a single-row
* lookup would miss.
*
* @param state The editor state
* @param fallbackIndex The row index to use when nothing is selected
* @returns Array of unique cell positions
*/
export function getCellsInSelectedRows(
state: EditorState,
fallbackIndex: number
): number[] {
const selectedRows = getAllSelectedRows(state);
const rows = selectedRows.includes(fallbackIndex)
? selectedRows
: [fallbackIndex];
const seen = new Set<number>();
const cells: number[] = [];
rows.forEach((index) => {
getCellsInRow(index)(state).forEach((pos) => {
if (!seen.has(pos)) {
seen.add(pos);
cells.push(pos);
}
});
});
return cells;
}
/**
* Get the total width of selected columns by measuring DOM elements.
* Uses getBoundingClientRect to get precise rendered widths including decimals.
*
* @param view The editor view
* @param rect The table rect
* @param selectedColumns Array of column indices to measure
* @returns The total width in px, or 0 if measurement fails
*/
export function getWidthFromDom({
view,
rect,
selectedColumns,
}: {
view?: EditorView;
rect: TableRect;
selectedColumns: number[];
}): number {
if (!view) {
return 0;
}
const tableDOM = view.domAtPos(rect.tableStart).node as HTMLElement;
const firstRow = tableDOM.closest("table")?.querySelector("tr");
if (!firstRow) {
return 0;
}
const cells = firstRow.querySelectorAll("td, th");
return selectedColumns.reduce((total, colIndex) => {
const cell = cells[colIndex] as HTMLElement | undefined;
return total + (cell?.getBoundingClientRect().width ?? 0);
}, 0);
}
/**
* Get the total width of selected columns from node attributes.
* Sums the colwidth values stored in the document state.
*
* @param state The editor state
* @param selectedColumns Array of column indices to measure
* @returns The total width in px from colwidth attributes
*/
export function getWidthFromNodes({
state,
selectedColumns,
}: {
state: EditorState;
selectedColumns: number[];
}): number {
const firstRowCells = getCellsInRow(0)(state);
if (!firstRowCells) {
return 0;
}
return selectedColumns.reduce((total, colIndex) => {
const cell =
firstRowCells[colIndex] !== undefined
? state.doc.nodeAt(firstRowCells[colIndex])
: null;
const colwidth = cell?.attrs.colwidth;
return total + (colwidth?.[0] ?? 0);
}, 0);
}
const getCellAttrMark = (cell: Node, type: NodeAttrMarkName) => {
const mark = (cell.attrs.marks ?? []).find(
(mark: NodeAttrMark) => mark.type === type
);
return mark;
};
export const hasNodeAttrMarkCellSelection = (
selection: CellSelection,
type: NodeAttrMarkName
) => {
let hasMark = false;
selection.forEachCell((cell) => {
if (!hasMark) {
hasMark = !!getCellAttrMark(cell, type);
}
});
return hasMark;
};
/**
* Returns the set of background colors applied to selected cells.
*
* @param selection - The current selection.
* @returns A set of color strings from background marks on selected cells.
*/
export function getColorSetForSelectedCells(selection: Selection): Set<string> {
const colors = new Set<string>();
if (!(selection instanceof CellSelection)) {
// If not a CellSelection, return empty set
return colors;
}
selection.forEachCell((cell) => {
const backgroundMark = (cell.attrs.marks ?? []).find(
(mark: NodeAttrMark) => mark.type === "background"
);
if (backgroundMark && backgroundMark.attrs.color) {
colors.add(backgroundMark.attrs.color);
}
});
return colors;
}
/**
* Get all unique background colors used in table cells across the entire document.
*
* @param state The editor state.
* @returns An array of unique hex color strings used for table cell backgrounds in the document.
*/
export function getDocumentTableBackgroundColors(state: EditorState): string[] {
const colors = new Set<string>();
state.doc.descendants((node) => {
if (node.type.name === "td" || node.type.name === "th") {
const backgroundMark = (node.attrs.marks ?? []).find(
(mark: NodeAttrMark) => mark.type === "background"
);
if (backgroundMark && backgroundMark.attrs.color) {
colors.add(backgroundMark.attrs.color);
}
}
});
return Array.from(colors);
}
/**
* Returns true if any cell in the selection has a mark of the given type
* with matching attributes.
*
* @param selection The CellSelection to check.
* @param type The mark type to look for.
* @param attrs The attributes to match against.
* @returns True if any cell has the mark with matching attributes.
*/
export const hasNodeAttrMarkWithAttrsCellSelection = (
selection: CellSelection,
type: NodeAttrMarkName,
attrs: Record<string, unknown>
) => {
let attrsMatch = true;
selection.forEachCell((cell) => {
const cellMark = getCellAttrMark(cell, type);
attrsMatch &&=
!!cellMark &&
Object.entries(attrs).every(
([key, value]) => (cellMark.attrs ?? {})[key] === value
);
});
return attrsMatch;
};