@monolith-forensics/monolith-ui 1.9.1-dev.9 → 1.9.3-dev.1

package/dist/RichTextEditor/Components/TableTools/TableTools.actions.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ArrowDownToLineIcon, ArrowLeftToLineIcon, ArrowRightToLineIcon, ArrowUpToLineIcon, CopyIcon, EraserIcon, MoveDownIcon, MoveLeftIcon, MoveRightIcon, MoveUpIcon, PanelTopIcon, Trash2Icon, } from "lucide-react";
+import { clearTableContents, clearTargetContents, deleteColumnAt, deleteRowAt, deleteTable, duplicateColumn, duplicateRow, duplicateTable, insertColumnAt, insertRowAt, moveColumn, moveRow, toggleTopHeaderRow, } from "./TableTools.commands";
+import { getTopRowIsHeader, hasRiskyMergedCells } from "./TableTools.selectors";
+export const getColumnActionGroups = (editor, target) => {
+    const risky = hasRiskyMergedCells(target);
+    const lastColumn = target.tableContext.map.width - 1;
+    return [
+        {
+            label: "Move",
+            actions: [
+                {
+                    label: "Move column left",
+                    leftSection: _jsx(MoveLeftIcon, { size: 14 }),
+                    disabled: risky || target.colIndex === 0,
+                    onClick: () => moveColumn(editor, target, -1),
+                },
+                {
+                    label: "Move column right",
+                    leftSection: _jsx(MoveRightIcon, { size: 14 }),
+                    disabled: risky || target.colIndex === lastColumn,
+                    onClick: () => moveColumn(editor, target, 1),
+                },
+            ],
+        },
+        {
+            label: "Insert",
+            actions: [
+                {
+                    label: "Insert column left",
+                    leftSection: _jsx(ArrowLeftToLineIcon, { size: 14 }),
+                    onClick: () => insertColumnAt(editor, target, target.colIndex),
+                },
+                {
+                    label: "Insert column right",
+                    leftSection: _jsx(ArrowRightToLineIcon, { size: 14 }),
+                    onClick: () => insertColumnAt(editor, target, target.colIndex + 1),
+                },
+            ],
+        },
+        {
+            label: "Content",
+            actions: [
+                {
+                    label: "Clear column contents",
+                    leftSection: _jsx(EraserIcon, { size: 14 }),
+                    disabled: risky,
+                    onClick: () => clearTargetContents(editor, target),
+                },
+                {
+                    label: "Duplicate column",
+                    leftSection: _jsx(CopyIcon, { size: 14 }),
+                    disabled: risky,
+                    onClick: () => duplicateColumn(editor, target),
+                },
+            ],
+        },
+        {
+            label: "Delete",
+            actions: [
+                {
+                    label: "Delete column",
+                    leftSection: _jsx(Trash2Icon, { size: 14 }),
+                    danger: true,
+                    disabled: risky || target.tableContext.map.width <= 1,
+                    onClick: () => deleteColumnAt(editor, target),
+                },
+            ],
+        },
+    ];
+};
+export const getRowActionGroups = (editor, target) => {
+    const risky = hasRiskyMergedCells(target);
+    const topRowIsHeader = getTopRowIsHeader(target);
+    const lastRow = target.tableContext.map.height - 1;
+    return [
+        {
+            label: "Header",
+            actions: [
+                {
+                    label: topRowIsHeader ? "Unset header row" : "Set header row",
+                    leftSection: _jsx(PanelTopIcon, { size: 14 }),
+                    disabled: target.rowIndex !== 0,
+                    onClick: () => toggleTopHeaderRow(editor, target),
+                },
+            ],
+        },
+        {
+            label: "Move",
+            actions: [
+                {
+                    label: "Move row up",
+                    leftSection: _jsx(MoveUpIcon, { size: 14 }),
+                    disabled: risky ||
+                        target.rowIndex === 0 ||
+                        (topRowIsHeader && target.rowIndex === 1),
+                    onClick: () => moveRow(editor, target, -1),
+                },
+                {
+                    label: "Move row down",
+                    leftSection: _jsx(MoveDownIcon, { size: 14 }),
+                    disabled: risky ||
+                        target.rowIndex === lastRow ||
+                        (topRowIsHeader && target.rowIndex === 0),
+                    onClick: () => moveRow(editor, target, 1),
+                },
+            ],
+        },
+        {
+            label: "Insert",
+            actions: [
+                {
+                    label: "Insert row above",
+                    leftSection: _jsx(ArrowUpToLineIcon, { size: 14 }),
+                    disabled: topRowIsHeader && target.rowIndex === 0,
+                    onClick: () => insertRowAt(editor, target, target.rowIndex),
+                },
+                {
+                    label: "Insert row below",
+                    leftSection: _jsx(ArrowDownToLineIcon, { size: 14 }),
+                    onClick: () => insertRowAt(editor, target, target.rowIndex + 1),
+                },
+            ],
+        },
+        {
+            label: "Content",
+            actions: [
+                {
+                    label: "Clear row contents",
+                    leftSection: _jsx(EraserIcon, { size: 14 }),
+                    disabled: risky,
+                    onClick: () => clearTargetContents(editor, target),
+                },
+                {
+                    label: "Duplicate row",
+                    leftSection: _jsx(CopyIcon, { size: 14 }),
+                    disabled: risky,
+                    onClick: () => duplicateRow(editor, target),
+                },
+            ],
+        },
+        {
+            label: "Delete",
+            actions: [
+                {
+                    label: "Delete row",
+                    leftSection: _jsx(Trash2Icon, { size: 14 }),
+                    danger: true,
+                    disabled: risky || target.tableContext.map.height <= 1,
+                    onClick: () => deleteRowAt(editor, target),
+                },
+            ],
+        },
+    ];
+};
+export const getTableActionGroups = (editor, target) => [
+    {
+        label: "Content",
+        actions: [
+            {
+                label: "Clear table contents",
+                leftSection: _jsx(EraserIcon, { size: 14 }),
+                onClick: () => clearTableContents(editor, target),
+            },
+            {
+                label: "Duplicate table",
+                leftSection: _jsx(CopyIcon, { size: 14 }),
+                onClick: () => duplicateTable(editor, target),
+            },
+        ],
+    },
+    {
+        label: "Delete",
+        actions: [
+            {
+                label: "Delete table",
+                leftSection: _jsx(Trash2Icon, { size: 14 }),
+                danger: true,
+                onClick: () => deleteTable(editor, target),
+            },
+        ],
+    },
+];

package/dist/RichTextEditor/Components/TableTools/TableTools.commands.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "@tiptap/react";
+import type { RailTarget, TableRailTarget } from "./TableTools.types";
+export declare const runTableCommand: (editor: Editor | null, command: string, args?: unknown[]) => void;
+export declare const insertRowAt: (editor: Editor | null, target: RailTarget, row: number) => boolean;
+export declare const insertColumnAt: (editor: Editor | null, target: RailTarget, column: number) => boolean;
+export declare const deleteRowAt: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const deleteColumnAt: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const clearTargetContents: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const duplicateRow: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const duplicateColumn: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const moveRow: (editor: Editor | null, target: RailTarget, direction: -1 | 1) => boolean;
+export declare const moveColumn: (editor: Editor | null, target: RailTarget, direction: -1 | 1) => boolean;
+export declare const toggleTopHeaderRow: (editor: Editor | null, target: RailTarget) => boolean;
+export declare const clearTableContents: (editor: Editor | null, target: TableRailTarget) => boolean;
+export declare const duplicateTable: (editor: Editor | null, target: TableRailTarget) => boolean;
+export declare const deleteTable: (editor: Editor | null, target: TableRailTarget) => boolean;

package/dist/RichTextEditor/Components/TableTools/TableTools.commands.js

@@ -0,0 +1,217 @@
+import { Fragment } from "@tiptap/pm/model";
+import { TextSelection } from "@tiptap/pm/state";
+import { addColumn, addRow, removeColumn, removeRow } from "@tiptap/pm/tables";
+import { getCellsInTableTarget, getCellsInTarget, getTopRowIsHeader, } from "./TableTools.selectors";
+export const runTableCommand = (editor, command, args = []) => {
+    const chain = editor === null || editor === void 0 ? void 0 : editor.chain().focus();
+    if (!(chain === null || chain === void 0 ? void 0 : chain[command]))
+        return;
+    chain[command](...args).run();
+};
+const getTableRect = (tableContext) => ({
+    left: 0,
+    top: 0,
+    right: tableContext.map.width,
+    bottom: tableContext.map.height,
+    tableStart: tableContext.start,
+    map: tableContext.map,
+    table: tableContext.node,
+});
+const getRowStartOffset = (table, rowIndex) => {
+    let offset = 0;
+    for (let index = 0; index < rowIndex; index += 1) {
+        offset += table.child(index).nodeSize;
+    }
+    return offset;
+};
+const getCellChildIndex = (table, rowIndex, cellPos) => {
+    const row = table.child(rowIndex);
+    let offset = getRowStartOffset(table, rowIndex) + 1;
+    for (let index = 0; index < row.childCount; index += 1) {
+        if (offset === cellPos)
+            return index;
+        offset += row.child(index).nodeSize;
+    }
+    return -1;
+};
+export const insertRowAt = (editor, target, row) => {
+    if (!editor)
+        return false;
+    editor.view.dispatch(addRow(editor.state.tr, getTableRect(target.tableContext), row));
+    return true;
+};
+export const insertColumnAt = (editor, target, column) => {
+    if (!editor)
+        return false;
+    editor.view.dispatch(addColumn(editor.state.tr, getTableRect(target.tableContext), column));
+    return true;
+};
+export const deleteRowAt = (editor, target) => {
+    if (!editor || target.tableContext.map.height <= 1)
+        return false;
+    const tr = editor.state.tr;
+    removeRow(tr, getTableRect(target.tableContext), target.rowIndex);
+    editor.view.dispatch(tr);
+    return true;
+};
+export const deleteColumnAt = (editor, target) => {
+    if (!editor || target.tableContext.map.width <= 1)
+        return false;
+    const tr = editor.state.tr;
+    removeColumn(tr, getTableRect(target.tableContext), target.colIndex);
+    editor.view.dispatch(tr);
+    return true;
+};
+export const clearTargetContents = (editor, target) => {
+    if (!editor)
+        return false;
+    const paragraph = editor.state.schema.nodes.paragraph.createAndFill();
+    if (!paragraph)
+        return false;
+    const tr = editor.state.tr;
+    const cells = getCellsInTarget(target).sort((a, b) => b.pos - a.pos);
+    cells.forEach((cell) => {
+        const from = target.tableContext.start + cell.pos + 1;
+        const to = target.tableContext.start + cell.pos + cell.node.nodeSize - 1;
+        tr.replaceWith(from, to, paragraph);
+    });
+    editor.view.dispatch(tr);
+    return true;
+};
+export const duplicateRow = (editor, target) => {
+    if (!editor)
+        return false;
+    const row = target.tableContext.node.child(target.rowIndex);
+    const insertPosition = target.tableContext.start +
+        getRowStartOffset(target.tableContext.node, target.rowIndex + 1);
+    editor.view.dispatch(editor.state.tr.insert(insertPosition, row.copy(row.content)));
+    return true;
+};
+export const duplicateColumn = (editor, target) => {
+    if (!editor)
+        return false;
+    const tr = editor.state.tr;
+    const inserts = [];
+    for (let row = 0; row < target.tableContext.map.height; row += 1) {
+        const cellPos = target.tableContext.map.positionAt(row, target.colIndex, target.tableContext.node);
+        const cell = target.tableContext.node.nodeAt(cellPos);
+        if (cell) {
+            inserts.push({
+                pos: target.tableContext.start + cellPos + cell.nodeSize,
+                node: cell.copy(cell.content),
+            });
+        }
+    }
+    inserts
+        .sort((a, b) => b.pos - a.pos)
+        .forEach((insert) => tr.insert(insert.pos, insert.node));
+    editor.view.dispatch(tr);
+    return true;
+};
+export const moveRow = (editor, target, direction) => {
+    if (!editor)
+        return false;
+    const to = target.rowIndex + direction;
+    if (to < 0 || to >= target.tableContext.map.height)
+        return false;
+    const rows = [];
+    target.tableContext.node.forEach((row) => {
+        rows.push(row);
+    });
+    const [row] = rows.splice(target.rowIndex, 1);
+    rows.splice(to, 0, row);
+    const nextTable = target.tableContext.node.copy(Fragment.from(rows));
+    editor.view.dispatch(editor.state.tr.replaceWith(target.tableContext.pos, target.tableContext.pos + target.tableContext.node.nodeSize, nextTable));
+    return true;
+};
+export const moveColumn = (editor, target, direction) => {
+    if (!editor)
+        return false;
+    const to = target.colIndex + direction;
+    if (to < 0 || to >= target.tableContext.map.width)
+        return false;
+    const rows = [];
+    for (let row = 0; row < target.tableContext.map.height; row += 1) {
+        const rowNode = target.tableContext.node.child(row);
+        const cells = [];
+        const cellPos = target.tableContext.map.positionAt(row, target.colIndex, target.tableContext.node);
+        const cellIndex = getCellChildIndex(target.tableContext.node, row, cellPos);
+        rowNode.forEach((cell) => {
+            cells.push(cell);
+        });
+        if (cellIndex < 0) {
+            rows.push(rowNode);
+            continue;
+        }
+        const [cell] = cells.splice(cellIndex, 1);
+        const insertIndex = direction > 0 ? cellIndex + 1 : cellIndex - 1;
+        cells.splice(insertIndex, 0, cell);
+        rows.push(rowNode.copy(Fragment.from(cells)));
+    }
+    const nextTable = target.tableContext.node.copy(Fragment.from(rows));
+    editor.view.dispatch(editor.state.tr.replaceWith(target.tableContext.pos, target.tableContext.pos + target.tableContext.node.nodeSize, nextTable));
+    return true;
+};
+export const toggleTopHeaderRow = (editor, target) => {
+    if (!editor || target.rowIndex !== 0)
+        return false;
+    const headerType = editor.state.schema.nodes.tableHeader;
+    const cellType = editor.state.schema.nodes.tableCell;
+    if (!headerType || !cellType)
+        return false;
+    const makeHeader = !getTopRowIsHeader(target);
+    const tr = editor.state.tr;
+    const cells = getCellsInTarget(target);
+    cells.forEach((cell) => {
+        tr.setNodeMarkup(target.tableContext.start + cell.pos, makeHeader ? headerType : cellType, cell.node.attrs);
+    });
+    editor.view.dispatch(tr);
+    return true;
+};
+export const clearTableContents = (editor, target) => {
+    if (!editor)
+        return false;
+    const paragraph = editor.state.schema.nodes.paragraph.createAndFill();
+    if (!paragraph)
+        return false;
+    const tr = editor.state.tr;
+    const cells = getCellsInTableTarget(target).sort((a, b) => b.pos - a.pos);
+    cells.forEach((cell) => {
+        const from = target.tableContext.start + cell.pos + 1;
+        const to = target.tableContext.start + cell.pos + cell.node.nodeSize - 1;
+        tr.replaceWith(from, to, paragraph);
+    });
+    editor.view.dispatch(tr);
+    return true;
+};
+export const duplicateTable = (editor, target) => {
+    if (!editor)
+        return false;
+    const { tableContext } = target;
+    const paragraph = editor.state.schema.nodes.paragraph.createAndFill();
+    if (!paragraph)
+        return false;
+    const insertPosition = tableContext.pos + tableContext.node.nodeSize;
+    const duplicatedTable = tableContext.node.copy(tableContext.node.content);
+    const tr = editor.state.tr.insert(insertPosition, [
+        paragraph,
+        duplicatedTable,
+    ]);
+    const firstCellPosition = tableContext.map.positionAt(0, 0, duplicatedTable);
+    if (firstCellPosition !== null) {
+        const duplicatePosition = insertPosition + paragraph.nodeSize;
+        const firstCellContentPosition = duplicatePosition + 1 + firstCellPosition + 1;
+        tr.setSelection(TextSelection.near(tr.doc.resolve(firstCellContentPosition)));
+    }
+    editor.view.dispatch(tr.scrollIntoView());
+    return true;
+};
+export const deleteTable = (editor, target) => {
+    if (!editor)
+        return false;
+    const { tableContext } = target;
+    editor.view.dispatch(editor.state.tr
+        .delete(tableContext.pos, tableContext.pos + tableContext.node.nodeSize)
+        .scrollIntoView());
+    return true;
+};

package/dist/RichTextEditor/Components/TableTools/TableTools.constants.d.ts

@@ -0,0 +1,8 @@
+import type { TableInsertOptions } from "./TableTools.types";
+export declare const DEFAULT_TABLE_OPTIONS: TableInsertOptions;
+export declare const MIN_TABLE_SIZE = 1;
+export declare const MAX_TABLE_SIZE = 20;
+export declare const RAIL_THICKNESS = 8;
+export declare const RAIL_HIDE_DELAY = 250;
+export declare const VIEWPORT_PADDING = 8;
+export declare const CORNER_BUTTON_SIZE = 18;

package/dist/RichTextEditor/Components/TableTools/TableTools.constants.js

@@ -0,0 +1,11 @@
+export const DEFAULT_TABLE_OPTIONS = {
+    rows: 3,
+    cols: 3,
+    withHeaderRow: true,
+};
+export const MIN_TABLE_SIZE = 1;
+export const MAX_TABLE_SIZE = 20;
+export const RAIL_THICKNESS = 8;
+export const RAIL_HIDE_DELAY = 250;
+export const VIEWPORT_PADDING = 8;
+export const CORNER_BUTTON_SIZE = 18;

package/dist/RichTextEditor/Components/TableTools/TableTools.d.ts

@@ -0,0 +1,3 @@
+export { TableRails } from "./TableRails";
+export { TableToolsContent } from "./TableInsertControls";
+export { TableToolsPopover } from "./TableToolsPopover";

package/dist/RichTextEditor/Components/TableTools/TableTools.geometry.d.ts

@@ -0,0 +1,23 @@
+import { TableMap } from "@tiptap/pm/tables";
+import type { Editor } from "@tiptap/react";
+import type { RailKind, RailRect, RailTarget, TableRailTarget } from "./TableTools.types";
+export declare const getRailTargetFromCell: (editor: Editor, cell: HTMLTableCellElement) => {
+    kind: RailKind;
+    rowIndex: number;
+    colIndex: number;
+    tableElement: HTMLTableElement;
+    tableRect: RailRect;
+    tableContext: {
+        node: import("prosemirror-model").Node;
+        pos: number;
+        start: number;
+        map: TableMap;
+    };
+    rowRect: RailRect;
+    columnRect: RailRect;
+} | null;
+export declare const getRailRect: (target: RailTarget, kind: RailKind) => RailRect;
+export declare const getCornerRect: (target: TableRailTarget) => {
+    top: number;
+    left: number;
+};

package/dist/RichTextEditor/Components/TableTools/TableTools.geometry.js

@@ -0,0 +1,75 @@
+import { findCellPos, findTable, TableMap } from "@tiptap/pm/tables";
+import { CORNER_BUTTON_SIZE, RAIL_THICKNESS, VIEWPORT_PADDING, } from "./TableTools.constants";
+const toRect = (rect) => ({
+    top: rect.top,
+    left: rect.left,
+    width: rect.width,
+    height: rect.height,
+});
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+export const getRailTargetFromCell = (editor, cell) => {
+    const tableElement = cell.closest("table");
+    const rowElement = cell.closest("tr");
+    if (!tableElement || !rowElement || !editor.view.dom.contains(tableElement)) {
+        return null;
+    }
+    const cellPosition = editor.view.posAtDOM(cell, 0);
+    const $cell = findCellPos(editor.state.doc, cellPosition);
+    if (!$cell)
+        return null;
+    const table = findTable($cell);
+    if (!table)
+        return null;
+    const map = TableMap.get(table.node);
+    const cellRect = map.findCell($cell.pos - table.start);
+    const tableRect = toRect(tableElement.getBoundingClientRect());
+    const rowRect = toRect(rowElement.getBoundingClientRect());
+    const columnRect = toRect(cell.getBoundingClientRect());
+    if (tableRect.width <= 0 ||
+        tableRect.height <= 0 ||
+        rowRect.width <= 0 ||
+        rowRect.height <= 0 ||
+        columnRect.width <= 0 ||
+        columnRect.height <= 0) {
+        return null;
+    }
+    return {
+        kind: "column",
+        rowIndex: cellRect.top,
+        colIndex: cellRect.left,
+        tableElement,
+        tableRect,
+        tableContext: {
+            node: table.node,
+            pos: table.pos,
+            start: table.start,
+            map,
+        },
+        rowRect,
+        columnRect,
+    };
+};
+export const getRailRect = (target, kind) => {
+    if (kind === "column") {
+        const width = target.columnRect.width;
+        const left = clamp(target.columnRect.left, VIEWPORT_PADDING, Math.max(VIEWPORT_PADDING, window.innerWidth - width - VIEWPORT_PADDING));
+        return {
+            top: Math.max(VIEWPORT_PADDING, target.tableRect.top - RAIL_THICKNESS),
+            left,
+            width,
+            height: RAIL_THICKNESS,
+        };
+    }
+    const height = target.rowRect.height;
+    const top = clamp(target.rowRect.top, VIEWPORT_PADDING, Math.max(VIEWPORT_PADDING, window.innerHeight - height - VIEWPORT_PADDING));
+    return {
+        top,
+        left: Math.max(VIEWPORT_PADDING, target.rowRect.left - RAIL_THICKNESS),
+        width: RAIL_THICKNESS,
+        height,
+    };
+};
+export const getCornerRect = (target) => ({
+    top: Math.max(VIEWPORT_PADDING, target.tableRect.top - CORNER_BUTTON_SIZE),
+    left: Math.max(VIEWPORT_PADDING, target.tableRect.left - CORNER_BUTTON_SIZE),
+});

package/dist/RichTextEditor/Components/TableTools/TableTools.js

@@ -0,0 +1,3 @@
+export { TableRails } from "./TableRails";
+export { TableToolsContent } from "./TableInsertControls";
+export { TableToolsPopover } from "./TableToolsPopover";

package/dist/RichTextEditor/Components/TableTools/TableTools.selectors.d.ts

@@ -0,0 +1,16 @@
+import { Node as ProseMirrorNode } from "@tiptap/pm/model";
+import type { Editor } from "@tiptap/react";
+import type { RailTarget } from "./TableTools.types";
+export declare const clampTableSize: (value: number) => number;
+export declare const hasTableExtension: (editor: Editor | null) => boolean;
+export declare const isTableActive: (editor: Editor | null) => boolean;
+export declare const getCellsInTarget: (target: RailTarget) => {
+    pos: number;
+    node: ProseMirrorNode;
+}[];
+export declare const getCellsInTableTarget: (target: RailTarget) => {
+    pos: number;
+    node: ProseMirrorNode;
+}[];
+export declare const hasRiskyMergedCells: (target: RailTarget) => boolean;
+export declare const getTopRowIsHeader: (target: RailTarget) => boolean;

package/dist/RichTextEditor/Components/TableTools/TableTools.selectors.js

@@ -0,0 +1,53 @@
+import { rowIsHeader } from "@tiptap/pm/tables";
+import { MAX_TABLE_SIZE, MIN_TABLE_SIZE } from "./TableTools.constants";
+export const clampTableSize = (value) => {
+    if (Number.isNaN(value))
+        return MIN_TABLE_SIZE;
+    return Math.min(MAX_TABLE_SIZE, Math.max(MIN_TABLE_SIZE, value));
+};
+export const hasTableExtension = (editor) => Boolean(editor === null || editor === void 0 ? void 0 : editor.extensionManager.extensions.find((extension) => extension.name === "table"));
+export const isTableActive = (editor) => Boolean((editor === null || editor === void 0 ? void 0 : editor.isActive("table")) ||
+    (editor === null || editor === void 0 ? void 0 : editor.isActive("tableRow")) ||
+    (editor === null || editor === void 0 ? void 0 : editor.isActive("tableCell")) ||
+    (editor === null || editor === void 0 ? void 0 : editor.isActive("tableHeader")));
+export const getCellsInTarget = (target) => {
+    const { tableContext } = target;
+    return tableContext.map
+        .cellsInRect(target.kind === "row"
+        ? {
+            left: 0,
+            right: tableContext.map.width,
+            top: target.rowIndex,
+            bottom: target.rowIndex + 1,
+        }
+        : {
+            left: target.colIndex,
+            right: target.colIndex + 1,
+            top: 0,
+            bottom: tableContext.map.height,
+        })
+        .map((pos) => ({
+        pos,
+        node: tableContext.node.nodeAt(pos),
+    }))
+        .filter((cell) => Boolean(cell.node));
+};
+export const getCellsInTableTarget = (target) => {
+    const { tableContext } = target;
+    return tableContext.map
+        .cellsInRect({
+        left: 0,
+        right: tableContext.map.width,
+        top: 0,
+        bottom: tableContext.map.height,
+    })
+        .map((pos) => ({
+        pos,
+        node: tableContext.node.nodeAt(pos),
+    }))
+        .filter((cell) => Boolean(cell.node));
+};
+export const hasRiskyMergedCells = (target) => {
+    return getCellsInTarget(target).some((cell) => cell.node.attrs.rowspan > 1 || cell.node.attrs.colspan > 1);
+};
+export const getTopRowIsHeader = (target) => rowIsHeader(target.tableContext.map, target.tableContext.node, 0);

package/dist/RichTextEditor/Components/TableTools/TableTools.styled.d.ts

@@ -0,0 +1,40 @@
+import type { RailKind, RailRect } from "./TableTools.types";
+export declare const TableToolsPanel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TableToolsSection: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TableToolsSectionTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("../../../FieldLabel").FieldLabelProps, never>, never>> & string;
+export declare const InsertGrid: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const Field: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>> & string;
+export declare const SwitchRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const RailRoot: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $rect: RailRect;
+    $kind: RailKind;
+}>> & string;
+export declare const MenuPanel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const MenuDropdown: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("../../../Popover").PopoverDropdownProps, never>> & string & Omit<import("react").FC<import("../../../Popover").PopoverDropdownProps>, keyof import("react").Component<any, {}, any>>;
+export declare const MenuGroup: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $withDivider: boolean;
+}>> & string;
+export declare const MenuButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    ref?: import("react").RefObject<HTMLButtonElement>;
+    children?: import("react").ReactNode | string;
+    className?: string;
+    loading?: boolean;
+    leftSection?: import("react").ReactNode;
+    rightSection?: import("react").ReactNode;
+    href?: string | null;
+    download?: string | null;
+    fullWidth?: boolean;
+    size?: import("../../../core").Size;
+    variant?: import("../../../core").Variant;
+    color?: import("../../../Button").ButtonColor;
+    disabled?: boolean;
+    selected?: boolean;
+    justify?: "start" | "center" | "end";
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}, {
+    $danger?: boolean;
+}>> & string & Omit<import("react").FC<import("../../../Button").ButtonProps>, keyof import("react").Component<any, {}, any>>;
+export declare const CornerRoot: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $top: number;
+    $left: number;
+}>> & string;