@gravity-ui/markdown-editor 13.0.0

package/build/esm/styles/markdown.css

@@ -0,0 +1,67 @@
+:root {
+  --yfm-colorify-black: #000;
+  --yfm-colorify-gray: #808080;
+  --yfm-colorify-yellow: #ffd700;
+  --yfm-colorify-orange: #f80;
+  --yfm-colorify-red: #c00;
+  --yfm-colorify-green: #080;
+  --yfm-colorify-blue: #04b;
+  --yfm-colorify-violet: #f0f;
+}
+
+.yfm-colorify--black {
+  color: var(--yfm-colorify-black);
+}
+
+.yfm-colorify--gray {
+  color: var(--yfm-colorify-gray);
+}
+
+.yfm-colorify--yellow {
+  color: var(--yfm-colorify-yellow);
+}
+
+.yfm-colorify--orange {
+  color: var(--yfm-colorify-orange);
+}
+
+.yfm-colorify--red {
+  color: var(--yfm-colorify-red);
+}
+
+.yfm-colorify--green {
+  color: var(--yfm-colorify-green);
+}
+
+.yfm-colorify--blue {
+  color: var(--yfm-colorify-blue);
+}
+
+.yfm-colorify--violet {
+  color: var(--yfm-colorify-violet);
+}
+
+.g-root .yfm:not(.yfm_only-light) {
+  --yfm-file-icon-color: var(--g-color-text-primary);
+}
+
+.g-root {
+  --yfm-color-text-gray: var(--g-color-text-secondary);
+  --yfm-color-text-yellow: var(--g-color-private-yellow-600-solid);
+  --yfm-color-text-orange: var(--g-color-private-orange-500-solid);
+  --yfm-color-text-red: var(--g-color-text-danger);
+  --yfm-color-text-green: var(--g-color-text-positive);
+  --yfm-color-text-blue: var(--g-color-text-info);
+  --yfm-color-text-violet: var(--g-color-text-utility);
+}
+
+.g-root {
+  --yfm-colorify-black: var(--g-color-text-primary);
+  --yfm-colorify-gray: var(--yfm-color-text-gray);
+  --yfm-colorify-yellow: var(--yfm-color-text-yellow);
+  --yfm-colorify-orange: var(--yfm-color-text-orange);
+  --yfm-colorify-red: var(--yfm-color-text-red);
+  --yfm-colorify-green: var(--yfm-color-text-green);
+  --yfm-colorify-blue: var(--yfm-color-text-blue);
+  --yfm-colorify-violet: var(--yfm-color-text-violet);
+}

package/build/esm/styles/styles.css

@@ -0,0 +1,24 @@
+.g-root .yfm:not(.yfm_only-light) {
+  --yfm-file-icon-color: var(--g-color-text-primary);
+}
+
+.g-root {
+  --yfm-color-text-gray: var(--g-color-text-secondary);
+  --yfm-color-text-yellow: var(--g-color-private-yellow-600-solid);
+  --yfm-color-text-orange: var(--g-color-private-orange-500-solid);
+  --yfm-color-text-red: var(--g-color-text-danger);
+  --yfm-color-text-green: var(--g-color-text-positive);
+  --yfm-color-text-blue: var(--g-color-text-info);
+  --yfm-color-text-violet: var(--g-color-text-utility);
+}
+
+.g-root {
+  --yfm-colorify-black: var(--g-color-text-primary);
+  --yfm-colorify-gray: var(--yfm-color-text-gray);
+  --yfm-colorify-yellow: var(--yfm-color-text-yellow);
+  --yfm-colorify-orange: var(--yfm-color-text-orange);
+  --yfm-colorify-red: var(--yfm-color-text-red);
+  --yfm-colorify-green: var(--yfm-color-text-green);
+  --yfm-colorify-blue: var(--yfm-color-text-blue);
+  --yfm-colorify-violet: var(--yfm-color-text-violet);
+}

package/build/esm/styles/yc-colors.css

@@ -0,0 +1,20 @@
+.g-root {
+  --yfm-color-text-gray: var(--g-color-text-secondary);
+  --yfm-color-text-yellow: var(--g-color-private-yellow-600-solid);
+  --yfm-color-text-orange: var(--g-color-private-orange-500-solid);
+  --yfm-color-text-red: var(--g-color-text-danger);
+  --yfm-color-text-green: var(--g-color-text-positive);
+  --yfm-color-text-blue: var(--g-color-text-info);
+  --yfm-color-text-violet: var(--g-color-text-utility);
+}
+
+.g-root {
+  --yfm-colorify-black: var(--g-color-text-primary);
+  --yfm-colorify-gray: var(--yfm-color-text-gray);
+  --yfm-colorify-yellow: var(--yfm-color-text-yellow);
+  --yfm-colorify-orange: var(--yfm-color-text-orange);
+  --yfm-colorify-red: var(--yfm-color-text-red);
+  --yfm-colorify-green: var(--yfm-color-text-green);
+  --yfm-colorify-blue: var(--yfm-color-text-blue);
+  --yfm-colorify-violet: var(--yfm-color-text-violet);
+}

package/build/esm/styles/yc-file.css

@@ -0,0 +1,3 @@
+.g-root .yfm:not(.yfm_only-light) {
+  --yfm-file-icon-color: var(--g-color-text-primary);
+}

package/build/esm/table-utils/commands/addColumnAfter.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const addColumnAfter: Command;

package/build/esm/table-utils/commands/addColumnAfter.js

@@ -0,0 +1,27 @@
+import { findChildIndex } from '../helpers';
+import { findChildTableCells, findChildTableRows, findParentTable, findParentTableCell, findParentTableRow, } from '../utils';
+export const addColumnAfter = (state, dispatch) => {
+    const parentCell = findParentTableCell(state.selection);
+    const parentRow = findParentTableRow(state.selection);
+    const parentTable = findParentTable(state.selection);
+    if (!parentCell || !parentRow || !parentTable) {
+        return false;
+    }
+    const parentCellIndex = findChildIndex(parentRow.node, parentCell.node);
+    if (parentCellIndex < 0) {
+        return false;
+    }
+    if (dispatch) {
+        const allRows = findChildTableRows(parentTable.node);
+        let tr = state.tr;
+        for (const row of allRows) {
+            const rowCells = findChildTableCells(row.node);
+            const cell = rowCells[parentCellIndex];
+            tr = tr.insert(tr.mapping.map(parentTable.pos + row.pos + cell.pos + cell.node.nodeSize + 2), 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            cell.node.type.createAndFill(cell.node.attrs));
+        }
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};

package/build/esm/table-utils/commands/addRowAfter.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const addRowAfter: Command;

package/build/esm/table-utils/commands/addRowAfter.js

@@ -0,0 +1,19 @@
+import { Fragment } from 'prosemirror-model';
+import { findParentTableBody, findParentTableRow } from '../utils';
+export const addRowAfter = (state, dispatch) => {
+    const parentRow = findParentTableRow(state.selection);
+    const parentBody = findParentTableBody(state.selection);
+    if (!parentRow || !parentBody) {
+        return false;
+    }
+    if (dispatch) {
+        const newCellNodes = [];
+        parentRow.node.forEach((node) => {
+            newCellNodes.push(node.type.createAndFill(node.attrs));
+        });
+        dispatch(state.tr
+            .insert(parentRow.pos + parentRow.node.nodeSize, parentRow.node.copy(Fragment.from(newCellNodes)))
+            .scrollIntoView());
+    }
+    return true;
+};

package/build/esm/table-utils/commands/appendColumn.d.ts

@@ -0,0 +1,6 @@
+import type { CommandWithAttrs } from '../../core';
+export declare const appendColumn: CommandWithAttrs<{
+    tablePos: number;
+    columnNumber?: number;
+    direction?: 'before' | 'after';
+}>;

package/build/esm/table-utils/commands/appendColumn.js

@@ -0,0 +1,48 @@
+import { findChildren, findParentNodeClosestToPos } from 'prosemirror-utils';
+import { isTableNode, isTableRowNode } from '..';
+import { findChildIndex } from '../helpers';
+import { findChildTableCells, isTableBodyNode, isTableCellNode } from '../utils';
+export const appendColumn = (state, dispatch, _, attrs) => {
+    var _a;
+    if (!attrs)
+        return false;
+    const { tablePos, columnNumber, direction } = attrs;
+    const parentTable = (_a = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
+    if (!parentTable)
+        return false;
+    let parentCell;
+    let parentRow;
+    const tableBody = findChildren(parentTable, isTableBodyNode, false).pop();
+    if (!tableBody)
+        return false;
+    if (columnNumber !== undefined) {
+        parentCell = findChildTableCells(parentTable)[columnNumber];
+        parentRow = findParentNodeClosestToPos(state.doc.resolve(tablePos + parentCell.pos + 1), isTableRowNode);
+    }
+    else {
+        parentRow = findChildren(tableBody.node, isTableRowNode, false).pop();
+        if (!parentRow)
+            return false;
+        parentCell = findChildren(parentRow.node, isTableCellNode, false).pop();
+    }
+    if (!parentCell || !parentRow || !parentTable) {
+        return false;
+    }
+    const parentCellIndex = columnNumber || findChildIndex(parentRow.node, parentCell.node);
+    if (parentCellIndex < 0) {
+        return false;
+    }
+    if (dispatch) {
+        const allRows = findChildren(tableBody.node, isTableRowNode, false);
+        let tr = state.tr;
+        for (const row of allRows) {
+            const rowCells = findChildren(row.node, isTableCellNode, false);
+            const cell = rowCells[parentCellIndex];
+            let position = tablePos + row.pos + cell.pos + 3;
+            position += direction === 'before' ? 0 : cell.node.nodeSize;
+            tr = tr.insert(tr.mapping.map(position), cell.node.type.createAndFill(cell.node.attrs));
+        }
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};

package/build/esm/table-utils/commands/appendRow.d.ts

@@ -0,0 +1,6 @@
+import type { CommandWithAttrs } from '../../core';
+export declare const appendRow: CommandWithAttrs<{
+    tablePos: number;
+    rowNumber?: number;
+    direction?: 'before' | 'after';
+}>;

package/build/esm/table-utils/commands/appendRow.js

@@ -0,0 +1,35 @@
+import { Fragment } from 'prosemirror-model';
+import { findChildren, findParentNodeClosestToPos } from 'prosemirror-utils';
+import { findChildTableRows, isTableBodyNode, isTableNode, isTableRowNode } from '..';
+export const appendRow = (state, dispatch, _, attrs) => {
+    var _a;
+    if (!attrs)
+        return false;
+    const { tablePos, rowNumber, direction } = attrs;
+    const tableNode = (_a = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
+    if (!tableNode)
+        return false;
+    const parentBody = findChildren(tableNode, isTableBodyNode, false).pop();
+    if (!parentBody)
+        return false;
+    let parentRow;
+    if (rowNumber !== undefined) {
+        parentRow = findChildTableRows(tableNode)[rowNumber];
+    }
+    else {
+        parentRow = findChildren(parentBody.node, isTableRowNode, false).pop();
+    }
+    if (!parentRow) {
+        return false;
+    }
+    if (dispatch) {
+        const newCellNodes = [];
+        parentRow.node.forEach((node) => {
+            newCellNodes.push(node.type.createAndFill(node.attrs));
+        });
+        let position = tablePos + parentRow.pos;
+        position += direction === 'before' ? 1 : parentRow.node.nodeSize + 1;
+        dispatch(state.tr.insert(position, parentRow.node.copy(Fragment.from(newCellNodes))));
+    }
+    return true;
+};

package/build/esm/table-utils/commands/goToNextCell.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'prosemirror-state';
+export declare function goToNextCell(dir: 'prev' | 'next'): Command;

package/build/esm/table-utils/commands/goToNextCell.js

@@ -0,0 +1,48 @@
+import { TextSelection } from 'prosemirror-state';
+import { findChildTableCells, findParentTable, findParentTableCell } from '../utils';
+export function goToNextCell(dir) {
+    return (state, dispatch) => {
+        const parentTable = findParentTable(state.selection);
+        const parentCell = findParentTableCell(state.selection);
+        if (!parentTable || !parentCell) {
+            return false;
+        }
+        const allCells = findChildTableCells(parentTable.node);
+        const index = allCells.findIndex((node) => node.node === parentCell.node);
+        const isFirstCell = index === 0;
+        const isLastCell = index === allCells.length - 1;
+        const selectText = (from, to) => {
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr
+                .setSelection(TextSelection.between(state.doc.resolve(from), state.doc.resolve(to)))
+                .scrollIntoView());
+        };
+        const selectCell = (index) => {
+            const cell = allCells[index];
+            const from = parentTable.start + cell.pos;
+            const to = from + cell.node.nodeSize;
+            selectText(from, to);
+        };
+        const selectPrevCell = () => selectCell(index - 1);
+        const selectCurrentCell = () => selectCell(index);
+        const selectNextCell = () => selectCell(index + 1);
+        if (dir === 'prev') {
+            if (isFirstCell) {
+                selectCurrentCell();
+            }
+            else {
+                selectPrevCell();
+            }
+            return true;
+        }
+        if (dir === 'next') {
+            if (isLastCell) {
+                selectCurrentCell();
+            }
+            else {
+                selectNextCell();
+            }
+            return true;
+        }
+        return false;
+    };
+}

package/build/esm/table-utils/commands/index.d.ts

@@ -0,0 +1,10 @@
+export { goToNextCell } from './goToNextCell';
+export { addRowAfter } from './addRowAfter';
+export { addColumnAfter } from './addColumnAfter';
+export { appendRow } from './appendRow';
+export { appendColumn } from './appendColumn';
+export { removeColumn } from './removeColumn';
+export { removeCurrentColumn } from './removeCurrentColumn';
+export { removeRow } from './removeRow';
+export { removeCurrentRow } from './removeCurrentRow';
+export { transpose } from './transpose';

package/build/esm/table-utils/commands/index.js

@@ -0,0 +1,10 @@
+export { goToNextCell } from './goToNextCell';
+export { addRowAfter } from './addRowAfter';
+export { addColumnAfter } from './addColumnAfter';
+export { appendRow } from './appendRow';
+export { appendColumn } from './appendColumn';
+export { removeColumn } from './removeColumn';
+export { removeCurrentColumn } from './removeCurrentColumn';
+export { removeRow } from './removeRow';
+export { removeCurrentRow } from './removeCurrentRow';
+export { transpose } from './transpose';

package/build/esm/table-utils/commands/removeColumn.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const removeColumn: Command;

package/build/esm/table-utils/commands/removeColumn.js

@@ -0,0 +1,38 @@
+import { isTableNode } from '..';
+import { isTableBodyNode, isTableCellNode, isTableRowNode } from '../utils';
+export const removeColumn = (state, dispatch, _, attrs = {}) => {
+    const { tablePos, columnNumber } = attrs;
+    if (typeof tablePos !== 'number' || typeof columnNumber !== 'number')
+        return false;
+    if (Number.isNaN(tablePos) || Number.isNaN(columnNumber))
+        return false;
+    if (tablePos < 0 || columnNumber < 0)
+        return false;
+    const tableNode = state.doc.nodeAt(tablePos);
+    if (!tableNode || tableNode.nodeSize <= 2 || !isTableNode(tableNode))
+        return false;
+    const tableBodyNode = tableNode.firstChild;
+    if (!tableBodyNode || tableBodyNode.nodeSize <= 2 || !isTableBodyNode(tableBodyNode))
+        return false;
+    // there is one column left
+    if (tableBodyNode.firstChild && tableBodyNode.firstChild.childCount < 2)
+        return false;
+    if (dispatch) {
+        const { tr } = state;
+        tableBodyNode.forEach((rowNode, rowOffset) => {
+            if (!isTableRowNode(rowNode))
+                return;
+            rowNode.forEach((cellNode, cellOffset, cellIndex) => {
+                if (!isTableCellNode(cellNode))
+                    return;
+                if (cellIndex === columnNumber) {
+                    const from = tablePos + 1 + rowOffset + 1 + cellOffset;
+                    const to = from + cellNode.nodeSize;
+                    tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+                }
+            });
+        });
+        dispatch(tr);
+    }
+    return true;
+};

package/build/esm/table-utils/commands/removeCurrentColumn.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const removeCurrentColumn: Command;

package/build/esm/table-utils/commands/removeCurrentColumn.js

@@ -0,0 +1,34 @@
+import { findChildIndex } from '../helpers';
+import { findChildTableCells, findChildTableRows, findParentTable, findParentTableCell, findParentTableRow, } from '../utils';
+export const removeCurrentColumn = (state, dispatch) => {
+    const parentCell = findParentTableCell(state.selection);
+    const parentRow = findParentTableRow(state.selection);
+    const parentTable = findParentTable(state.selection);
+    if (!parentCell || !parentRow || !parentTable) {
+        return false;
+    }
+    if (parentRow.node.childCount < 2) {
+        // there is one column left
+        return false;
+    }
+    const parentCellIndex = findChildIndex(parentRow.node, parentCell.node);
+    if (parentCellIndex < 0) {
+        return false;
+    }
+    if (parentCellIndex === 0) {
+        return false; // TODO: remove first column
+    }
+    if (dispatch) {
+        let tr = state.tr;
+        const allRows = findChildTableRows(parentTable.node);
+        for (const row of allRows) {
+            const rowCells = findChildTableCells(row.node);
+            const cell = rowCells[parentCellIndex];
+            const from = parentTable.start + row.pos + cell.pos;
+            const to = from + cell.node.nodeSize;
+            tr = tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+        }
+        dispatch(tr);
+    }
+    return true;
+};

package/build/esm/table-utils/commands/removeCurrentRow.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const removeCurrentRow: Command;

package/build/esm/table-utils/commands/removeCurrentRow.js

@@ -0,0 +1,15 @@
+import { removeParentNodeOfType } from 'prosemirror-utils';
+import { findChildTableRows, findParentTableBody, findParentTableRow } from '../utils';
+export const removeCurrentRow = (state, dispatch) => {
+    const parentRow = findParentTableRow(state.selection);
+    const parentBody = findParentTableBody(state.selection);
+    if (!parentRow || !parentBody) {
+        return false;
+    }
+    if (findChildTableRows(parentBody.node).length < 2) {
+        // there is one row left
+        return false;
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(removeParentNodeOfType(parentRow.node.type)(state.tr));
+    return true;
+};

package/build/esm/table-utils/commands/removeRow.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const removeRow: Command;

package/build/esm/table-utils/commands/removeRow.js

@@ -0,0 +1,26 @@
+import { Fragment } from 'prosemirror-model';
+import { findChildren, findParentNodeClosestToPos } from 'prosemirror-utils';
+import { findChildTableBody, isTableNode, isTableRowNode } from '..';
+import { trackTransactionMetrics } from '../../core';
+import { findChildTableRows } from '../utils';
+export const removeRow = (state, dispatch, _, attrs = {}) => {
+    var _a;
+    const { tablePos, rowNumber } = attrs;
+    if (tablePos === undefined || rowNumber === undefined)
+        return false;
+    const tableNode = (_a = findParentNodeClosestToPos(state.doc.resolve(tablePos + 1), isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
+    if (!tableNode)
+        return false;
+    const parentRows = findChildren(tableNode, isTableRowNode);
+    const parentBody = findChildTableBody(tableNode)[0];
+    const parentRow = parentRows[rowNumber];
+    if (!parentRows.length || !parentBody) {
+        return false;
+    }
+    if (findChildTableRows(parentBody.node).length < 2) {
+        // there is one row left
+        return false;
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(trackTransactionMetrics(state.tr.replaceWith(tablePos + parentRow.pos, tablePos + parentRow.pos + parentRow.node.nodeSize + 1, Fragment.empty), 'removeRow', { rows: parentRows.length, cols: parentRow.node.childCount }));
+    return true;
+};

package/build/esm/table-utils/commands/transpose.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const transpose: Command;

package/build/esm/table-utils/commands/transpose.js

@@ -0,0 +1,28 @@
+import { Fragment } from 'prosemirror-model';
+import { findParentTable, findParentTableBody, findParentTableCell, findParentTableRow, } from '../utils';
+export const transpose = (state, dispatch) => {
+    var _a, _b;
+    const parentCell = findParentTableCell(state.selection);
+    const parentRow = findParentTableRow(state.selection);
+    const parentBody = findParentTableBody(state.selection);
+    const parentTable = findParentTable(state.selection);
+    if (!parentCell || !parentRow || !parentBody || !parentTable)
+        return false;
+    if (dispatch) {
+        const rowsCount = parentBody.node.childCount;
+        const cellsCount = (_b = (_a = parentBody.node.maybeChild(0)) === null || _a === void 0 ? void 0 : _a.childCount) !== null && _b !== void 0 ? _b : 0;
+        const newRowsList = [];
+        for (let i = 0; i < cellsCount; i++) {
+            const newCellsList = [];
+            for (let j = 0; j < rowsCount; j++) {
+                const cellNode = parentBody.node.child(j).child(i);
+                newCellsList.push(cellNode.copy(cellNode.content));
+            }
+            newRowsList.push(parentRow.node.copy(Fragment.from(newCellsList)));
+        }
+        const newBody = parentBody.node.copy(Fragment.from(newRowsList));
+        const newTable = parentTable.node.copy(Fragment.from(newBody));
+        dispatch(state.tr.replaceWith(parentTable.pos, parentTable.pos + parentTable.node.nodeSize, newTable));
+    }
+    return true;
+};

package/build/esm/table-utils/const.d.ts

@@ -0,0 +1,6 @@
+export declare enum TableRole {
+    Table = "table",
+    Body = "tableBody",
+    Row = "tableRow",
+    Cell = "tableCell"
+}

package/build/esm/table-utils/const.js

@@ -0,0 +1,7 @@
+export var TableRole;
+(function (TableRole) {
+    TableRole["Table"] = "table";
+    TableRole["Body"] = "tableBody";
+    TableRole["Row"] = "tableRow";
+    TableRole["Cell"] = "tableCell";
+})(TableRole || (TableRole = {}));

package/build/esm/table-utils/helpers.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from 'prosemirror-model';
+export declare const findChildIndex: (parentNode: Node, targetNode: Node) => number;

package/build/esm/table-utils/helpers.js

@@ -0,0 +1,9 @@
+export const findChildIndex = (parentNode, targetNode) => {
+    let targetIndex = -1;
+    parentNode.forEach((node, _, index) => {
+        if (node === targetNode) {
+            targetIndex = index;
+        }
+    });
+    return targetIndex;
+};

package/build/esm/table-utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './commands';
+export * from './const';
+export * from './utils';
+import type { TableRole } from './const';
+declare module 'prosemirror-model' {
+    interface NodeSpec {
+        tableRole?: TableRole;
+    }
+}

package/build/esm/table-utils/index.js

@@ -0,0 +1,3 @@
+export * from './commands';
+export * from './const';
+export * from './utils';

package/build/esm/table-utils/utils.d.ts

@@ -0,0 +1,32 @@
+import { Node as PmNode, ResolvedPos } from 'prosemirror-model';
+import { Predicate } from 'prosemirror-utils';
+import type { EditorView } from 'prosemirror-view';
+export declare const isTableNode: Predicate;
+export declare const isTableBodyNode: Predicate;
+export declare const isTableRowNode: Predicate;
+export declare const isTableCellNode: Predicate;
+export declare const findParentTable: ({ $from, $to }: import("prosemirror-state").Selection, validateSameParent?: boolean | undefined) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableBody: ({ $from, $to }: import("prosemirror-state").Selection, validateSameParent?: boolean | undefined) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableRow: ({ $from, $to }: import("prosemirror-state").Selection, validateSameParent?: boolean | undefined) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableCell: ({ $from, $to }: import("prosemirror-state").Selection, validateSameParent?: boolean | undefined) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableFromPos: ($pos: ResolvedPos) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableBodyFromPos: ($pos: ResolvedPos) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableRowFromPos: ($pos: ResolvedPos) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentTableCellFromPos: ($pos: ResolvedPos) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findChildTableRows: (node: PmNode) => {
+    node: PmNode;
+    pos: number;
+}[];
+export declare const findChildTableCells: (node: PmNode) => {
+    node: PmNode;
+    pos: number;
+}[];
+export declare const findChildTableBody: (node: PmNode) => {
+    node: PmNode;
+    pos: number;
+}[];
+export declare const getTableDimensions: (node: PmNode | Node) => {
+    rows: number;
+    cols: number;
+};
+export declare function atEndOfCell(view: EditorView, dir: number): number | null;

package/build/esm/table-utils/utils.js

@@ -0,0 +1,48 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { findChildren, findParentNode, findParentNodeClosestToPos, } from 'prosemirror-utils';
+import { isTextSelection } from '../utils/selection';
+import { TableRole } from './const';
+export const isTableNode = (node) => node.type.spec.tableRole === TableRole.Table;
+export const isTableBodyNode = (node) => node.type.spec.tableRole === TableRole.Body;
+export const isTableRowNode = (node) => node.type.spec.tableRole === TableRole.Row;
+export const isTableCellNode = (node) => node.type.spec.tableRole === TableRole.Cell;
+export const findParentTable = findParentNode(isTableNode);
+export const findParentTableBody = findParentNode(isTableBodyNode);
+export const findParentTableRow = findParentNode(isTableRowNode);
+export const findParentTableCell = findParentNode(isTableCellNode);
+export const findParentTableFromPos = ($pos) => findParentNodeClosestToPos($pos, isTableNode);
+export const findParentTableBodyFromPos = ($pos) => findParentNodeClosestToPos($pos, isTableBodyNode);
+export const findParentTableRowFromPos = ($pos) => findParentNodeClosestToPos($pos, isTableRowNode);
+export const findParentTableCellFromPos = ($pos) => findParentNodeClosestToPos($pos, isTableCellNode);
+export const findChildTableRows = (node) => findChildren(node, isTableRowNode);
+export const findChildTableCells = (node) => findChildren(node, isTableCellNode);
+export const findChildTableBody = (node) => findChildren(node, isTableBodyNode);
+export const getTableDimensions = (node) => {
+    var _a, _b, _c, _d, _e, _f;
+    let rows, cols;
+    if (node instanceof PmNode) {
+        rows = (_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.childCount;
+        cols = (_c = (_b = node.firstChild) === null || _b === void 0 ? void 0 : _b.firstChild) === null || _c === void 0 ? void 0 : _c.childCount;
+    }
+    else {
+        rows = (_d = node.firstChild) === null || _d === void 0 ? void 0 : _d.childNodes.length;
+        cols = (_f = (_e = node.firstChild) === null || _e === void 0 ? void 0 : _e.firstChild) === null || _f === void 0 ? void 0 : _f.childNodes.length;
+    }
+    return { rows: rows || 1, cols: cols || 1 };
+};
+export function atEndOfCell(view, dir) {
+    if (!isTextSelection(view.state.selection))
+        return null;
+    const { $head } = view.state.selection;
+    for (let d = $head.depth - 1; d >= 0; d--) {
+        const parent = $head.node(d), index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
+        if (index !== (dir < 0 ? 0 : parent.childCount))
+            return null;
+        if (parent.type.spec.tableRole === TableRole.Cell) {
+            const cellPos = $head.before(d);
+            const dirStr = dir > 0 ? 'down' : 'up';
+            return view.endOfTextblock(dirStr) ? cellPos : null;
+        }
+    }
+    return null;
+}