@monolith-forensics/monolith-ui 1.8.1 → 1.9.0

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

@@ -1,24 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from "react";
-import { Button } from "../../../Button";
-import Input from "../../../Input";
-import { Switch } from "../../../Switch";
-import { Field, InsertGrid, SwitchRow, TableToolsPanel, TableToolsSection, TableToolsSectionTitle, } from "./TableTools.styled";
-import { DEFAULT_TABLE_OPTIONS, MAX_TABLE_SIZE, MIN_TABLE_SIZE, } from "./TableTools.constants";
-import { runTableCommand } from "./TableTools.commands";
-import { clampTableSize, hasTableExtension } from "./TableTools.selectors";
-export const TableToolsContent = ({ editor, showInsert = false, onInsert, onAction, }) => {
-    const [insertOptions, setInsertOptions] = useState(DEFAULT_TABLE_OPTIONS);
-    const tableAvailable = hasTableExtension(editor) && (editor === null || editor === void 0 ? void 0 : editor.isEditable);
-    const updateInsertOption = (key, value) => {
-        setInsertOptions((current) => (Object.assign(Object.assign({}, current), { [key]: typeof value === "number" ? clampTableSize(value) : value })));
-    };
-    const insertTable = () => {
-        if (!tableAvailable)
-            return;
-        runTableCommand(editor, "insertTable", [insertOptions]);
-        onInsert === null || onInsert === void 0 ? void 0 : onInsert();
-        onAction === null || onAction === void 0 ? void 0 : onAction();
-    };
-    return (_jsx(TableToolsPanel, { children: showInsert && (_jsxs(TableToolsSection, { children: [_jsx(TableToolsSectionTitle, { description: "Create and insert a table at the current editor position.", children: "Insert Table" }), _jsxs(TableToolsSection, { style: { gap: "1rem" }, children: [_jsxs(InsertGrid, { children: [_jsxs(Field, { children: ["Rows", _jsx(Input, { type: "number", min: MIN_TABLE_SIZE, max: MAX_TABLE_SIZE, size: "xs", value: insertOptions.rows, onChange: (event) => updateInsertOption("rows", Number(event.target.value)) })] }), _jsxs(Field, { children: ["Columns", _jsx(Input, { type: "number", min: MIN_TABLE_SIZE, max: MAX_TABLE_SIZE, size: "xs", value: insertOptions.cols, onChange: (event) => updateInsertOption("cols", Number(event.target.value)) })] })] }), _jsx(SwitchRow, { children: _jsx(Switch, { size: "xs", label: "Include Header Row", description: "The first row will be formatted as a header.", value: insertOptions.withHeaderRow, onChange: (checked) => updateInsertOption("withHeaderRow", checked) }) }), _jsx(Button, { size: "xs", variant: "outlined", fullWidth: true, disabled: !tableAvailable, onClick: insertTable, children: "Insert Table" })] })] })) }));
-};

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

@@ -1,2 +0,0 @@
-import type { TableRailsProps } from "./TableTools.types";
-export declare const TableRails: ({ editor }: TableRailsProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,180 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { MoreHorizontalIcon, MoreVerticalIcon } from "lucide-react";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { Button } from "../../../Button";
-import { Popover } from "../../../Popover";
-import { TableCornerMenu } from "./TableCornerMenu";
-import { getColumnActionGroups, getRowActionGroups, } from "./TableTools.actions";
-import { RAIL_HIDE_DELAY } from "./TableTools.constants";
-import { getRailRect, getRailTargetFromCell } from "./TableTools.geometry";
-import { MenuDropdown, RailRoot } from "./TableTools.styled";
-import { getCellsInTableTarget, getCellsInTarget, hasTableExtension, } from "./TableTools.selectors";
-import { TableToolMenu } from "./TableToolMenu";
-export const TableRails = ({ editor }) => {
-    const [hoverTarget, setHoverTarget] = useState(null);
-    const [lockedTarget, setLockedTarget] = useState(null);
-    const [openRail, setOpenRail] = useState(null);
-    const hideTimerRef = useRef(null);
-    const lastPointerRef = useRef(null);
-    const activeTarget = openRail && lockedTarget ? lockedTarget : hoverTarget;
-    const clearHideTimer = useCallback(() => {
-        if (hideTimerRef.current) {
-            clearTimeout(hideTimerRef.current);
-            hideTimerRef.current = null;
-        }
-    }, []);
-    const clearTarget = useCallback(() => {
-        var _a;
-        clearHideTimer();
-        if (!openRail) {
-            const pointer = lastPointerRef.current;
-            const element = pointer
-                ? document.elementFromPoint(pointer.x, pointer.y)
-                : null;
-            if ((_a = element === null || element === void 0 ? void 0 : element.closest) === null || _a === void 0 ? void 0 : _a.call(element, "[data-monolith-table-rail]")) {
-                return;
-            }
-            setHoverTarget(null);
-        }
-    }, [clearHideTimer, openRail]);
-    const scheduleClearTarget = useCallback(() => {
-        clearHideTimer();
-        hideTimerRef.current = setTimeout(clearTarget, RAIL_HIDE_DELAY);
-    }, [clearHideTimer, clearTarget]);
-    const refreshTargetFromPoint = useCallback(() => {
-        var _a, _b;
-        if (!editor || !lastPointerRef.current) {
-            setHoverTarget(null);
-            return;
-        }
-        const element = document.elementFromPoint(lastPointerRef.current.x, lastPointerRef.current.y);
-        if ((_a = element === null || element === void 0 ? void 0 : element.closest) === null || _a === void 0 ? void 0 : _a.call(element, "[data-monolith-table-rail]")) {
-            return;
-        }
-        const cell = (_b = element === null || element === void 0 ? void 0 : element.closest) === null || _b === void 0 ? void 0 : _b.call(element, "td, th");
-        if (cell instanceof HTMLTableCellElement &&
-            editor.view.dom.contains(cell)) {
-            const target = getRailTargetFromCell(editor, cell);
-            setHoverTarget(target);
-            return;
-        }
-        setHoverTarget(null);
-    }, [editor]);
-    const closeMenu = useCallback(() => {
-        setOpenRail(null);
-        setLockedTarget(null);
-        requestAnimationFrame(refreshTargetFromPoint);
-    }, [refreshTargetFromPoint]);
-    useEffect(() => {
-        if (!editor || !hasTableExtension(editor))
-            return;
-        const handleMouseMove = (event) => {
-            var _a, _b;
-            const target = event.target;
-            const cell = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, "td, th");
-            lastPointerRef.current = { x: event.clientX, y: event.clientY };
-            if ((_b = target === null || target === void 0 ? void 0 : target.closest) === null || _b === void 0 ? void 0 : _b.call(target, "[data-monolith-table-rail]")) {
-                clearHideTimer();
-                return;
-            }
-            if (openRail) {
-                clearHideTimer();
-                return;
-            }
-            if (!(cell instanceof HTMLTableCellElement) ||
-                !editor.view.dom.contains(cell)) {
-                if (!openRail) {
-                    scheduleClearTarget();
-                }
-                return;
-            }
-            const railTarget = getRailTargetFromCell(editor, cell);
-            if (railTarget) {
-                clearHideTimer();
-                setHoverTarget(railTarget);
-            }
-        };
-        const handleMouseLeave = () => {
-            if (!openRail) {
-                scheduleClearTarget();
-            }
-        };
-        editor.view.dom.addEventListener("mousemove", handleMouseMove);
-        editor.view.dom.addEventListener("mouseleave", handleMouseLeave);
-        window.addEventListener("mousemove", handleMouseMove);
-        window.addEventListener("scroll", refreshTargetFromPoint, true);
-        window.addEventListener("resize", refreshTargetFromPoint);
-        return () => {
-            editor.view.dom.removeEventListener("mousemove", handleMouseMove);
-            editor.view.dom.removeEventListener("mouseleave", handleMouseLeave);
-            window.removeEventListener("mousemove", handleMouseMove);
-            window.removeEventListener("scroll", refreshTargetFromPoint, true);
-            window.removeEventListener("resize", refreshTargetFromPoint);
-            clearHideTimer();
-        };
-    }, [
-        clearHideTimer,
-        editor,
-        openRail,
-        refreshTargetFromPoint,
-        scheduleClearTarget,
-    ]);
-    useEffect(() => {
-        const highlighted = Array.from(document.querySelectorAll(".monolith-table-rail-target"));
-        highlighted.forEach((element) => element.classList.remove("monolith-table-rail-target"));
-        if (!activeTarget || !openRail)
-            return;
-        const cells = openRail === "table"
-            ? getCellsInTableTarget(activeTarget)
-            : getCellsInTarget(Object.assign(Object.assign({}, activeTarget), { kind: openRail }));
-        cells.forEach((cell) => {
-            const dom = editor === null || editor === void 0 ? void 0 : editor.view.nodeDOM(activeTarget.tableContext.start + cell.pos);
-            if (dom instanceof HTMLElement) {
-                dom.classList.add("monolith-table-rail-target");
-            }
-        });
-        return () => {
-            cells.forEach((cell) => {
-                const dom = editor === null || editor === void 0 ? void 0 : editor.view.nodeDOM(activeTarget.tableContext.start + cell.pos);
-                if (dom instanceof HTMLElement) {
-                    dom.classList.remove("monolith-table-rail-target");
-                }
-            });
-        };
-    }, [activeTarget, editor, openRail]);
-    const keepEditorSelection = (event) => {
-        event.preventDefault();
-    };
-    if (!activeTarget || !(editor === null || editor === void 0 ? void 0 : editor.isEditable))
-        return null;
-    const keepTargetVisible = () => {
-        clearHideTimer();
-    };
-    const scheduleTargetClearIfClosed = () => {
-        if (!openRail) {
-            scheduleClearTarget();
-        }
-    };
-    const renderRail = (kind) => {
-        const railTarget = Object.assign(Object.assign({}, activeTarget), { kind });
-        const groups = kind === "column"
-            ? getColumnActionGroups(editor, railTarget)
-            : getRowActionGroups(editor, railTarget);
-        return (_jsx(RailRoot, { "data-monolith-table-rail": true, "$kind": kind, "$rect": getRailRect(activeTarget, kind), onMouseEnter: keepTargetVisible, onMouseLeave: scheduleTargetClearIfClosed, children: _jsxs(Popover, { opened: openRail === kind, onChange: (opened) => {
-                    if (opened) {
-                        clearHideTimer();
-                        setLockedTarget(railTarget);
-                        setOpenRail(kind);
-                        return;
-                    }
-                    setOpenRail(null);
-                    setLockedTarget(null);
-                    refreshTargetFromPoint();
-                }, position: kind === "column" ? "bottom" : "right", width: 245, trapFocus: true, children: [_jsx(Popover.Target, { children: _jsx(Button, { type: "button", size: "xs", variant: "outlined", title: kind === "column" ? "Column options" : "Row options", "aria-label": kind === "column" ? "Column options" : "Row options", selected: openRail === kind, onMouseDown: keepEditorSelection, children: kind === "column" ? (_jsx(MoreHorizontalIcon, { size: 14 })) : (_jsx(MoreVerticalIcon, { size: 14 })) }) }), _jsx(MenuDropdown, { children: _jsx(TableToolMenu, { groups: groups, onAction: closeMenu }) })] }) }, kind));
-    };
-    return (_jsxs(_Fragment, { children: [_jsx(TableCornerMenu, { editor: editor, target: activeTarget, opened: openRail === "table", onOpen: () => {
-                    clearHideTimer();
-                    setLockedTarget(activeTarget);
-                    setOpenRail("table");
-                }, onClose: closeMenu, onAction: closeMenu, onMouseEnter: keepTargetVisible, onMouseLeave: scheduleTargetClearIfClosed, onMouseDown: keepEditorSelection }), renderRail("column"), renderRail("row")] }));
-};

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

@@ -1,5 +0,0 @@
-import type { TableToolActionGroup } from "./TableTools.types";
-export declare const TableToolMenu: ({ groups, onAction, }: {
-    groups: TableToolActionGroup[];
-    onAction: () => void;
-}) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { MenuButton, MenuGroup, MenuPanel } from "./TableTools.styled";
-export const TableToolMenu = ({ groups, onAction, }) => (_jsx(MenuPanel, { children: groups.map((group, index) => (_jsx(MenuGroup, { "$withDivider": index > 0, children: group.actions.map((action) => (_jsx(MenuButton, { "$danger": action.danger, size: "sm", variant: "subtle", leftSection: action.leftSection, disabled: action.disabled, justify: "start", onClick: () => {
-                action.onClick();
-                onAction();
-            }, children: action.label }, action.label))) }, group.label))) }));

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

@@ -1,5 +0,0 @@
-import type { Editor } from "@tiptap/react";
-import type { RailTarget, TableRailTarget, TableToolActionGroup } from "./TableTools.types";
-export declare const getColumnActionGroups: (editor: Editor | null, target: RailTarget) => TableToolActionGroup[];
-export declare const getRowActionGroups: (editor: Editor | null, target: RailTarget) => TableToolActionGroup[];
-export declare const getTableActionGroups: (editor: Editor | null, target: TableRailTarget) => TableToolActionGroup[];

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

@@ -1,183 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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;