cvnert-editor 0.1.0

package/dist/components/tiptap-node/table-node/lib/tiptap-table-utils.d.ts

@@ -0,0 +1,395 @@
+import type { Editor } from "@tiptap/react";
+import type { Node } from "@tiptap/pm/model";
+import type { Command } from "@tiptap/pm/state";
+import { type EditorState, type Transaction } from "@tiptap/pm/state";
+import type { FindNodeResult, Rect } from "@tiptap/pm/tables";
+import { TableMap } from "@tiptap/pm/tables";
+export declare const RESIZE_MIN_WIDTH = 35;
+export declare const EMPTY_CELL_WIDTH = 120;
+export declare const EMPTY_CELL_HEIGHT = 40;
+export type Orientation = "row" | "column";
+export interface CellInfo extends FindNodeResult {
+    row: number;
+    column: number;
+}
+export type CellCoordinates = {
+    row: number;
+    col: number;
+};
+export type SelectionReturnMode = "state" | "transaction" | "dispatch";
+export type BaseSelectionOptions = {
+    mode?: SelectionReturnMode;
+};
+export type DispatchSelectionOptions = {
+    mode: "dispatch";
+    dispatch: (tr: Transaction) => void;
+};
+export type TransactionSelectionOptions = {
+    mode: "transaction";
+};
+export type StateSelectionOptions = {
+    mode?: "state";
+};
+export type TableInfo = {
+    map: TableMap;
+} & FindNodeResult;
+export declare function isHTMLElement(n: unknown): n is HTMLElement;
+export type DomCellAroundResult = {
+    type: "cell";
+    domNode: HTMLElement;
+    tbodyNode: HTMLTableSectionElement | null;
+} | {
+    type: "wrapper";
+    domNode: HTMLElement;
+    tbodyNode: HTMLTableSectionElement | null;
+};
+export declare function safeClosest<T extends Element>(start: Element | null, selector: string): T | null;
+/**
+ * Walk up from an element until we find a TD/TH or the table wrapper.
+ * Returns the found element plus its tbody (if present).
+ */
+export declare function domCellAround(target: Element): DomCellAroundResult | undefined;
+/**
+ * Clamps a value between min and max bounds
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Checks if a cell is merged (has colspan or rowspan > 1)
+ */
+export declare function isCellMerged(node: Node | null): boolean;
+/**
+ * Get information about the table at the current selection or a specific position.
+ *
+ * If `tablePos` is provided, it looks for a table at that exact position.
+ * Otherwise, it finds the nearest table containing the current selection.
+ *
+ * Returns an object with:
+ * - `node`: the table node
+ * - `pos`: the position of the table in the document
+ * - `start`: the position just after the table node (where its content starts)
+ * - `map`: the `TableMap` for layout info (rows, columns, spans)
+ *
+ * If no table is found, returns null.
+ */
+export declare function getTable(editor: Editor | null, tablePos?: number): {
+    map: TableMap;
+    node: Node;
+    pos: number;
+    start: number;
+    depth: number;
+} | null;
+/**
+ * Checks if the current text selection is inside a table cell.
+ * @param state - The editor state to check
+ * @returns true if the selection is inside a table cell; false otherwise
+ */
+export declare function isSelectionInCell(state: EditorState): boolean;
+/**
+ * Cells overlap a rectangle if any of the cells in the rectangle are merged
+ * with cells outside the rectangle.
+ */
+export declare function cellsOverlapRectangle({ width, height, map }: TableMap, rect: Rect): boolean;
+/**
+ * Runs a function while preserving the editor's selection.
+ * @param editor The Tiptap editor instance
+ * @param fn The function to run
+ * @returns True if the selection was successfully restored, false otherwise
+ */
+export declare function runPreservingCursor(editor: Editor, fn: () => void): boolean;
+/**
+ * Determines whether a table cell is effectively empty.
+ *
+ * A cell is considered empty when:
+ *  - it has no children, or
+ *  - it contains only whitespace text, or
+ *  - it contains no text and no non-text leaf nodes (images, embeds, etc.)
+ *
+ * Early-outs as soon as any meaningful content is found.
+ *
+ * @param cellNode - The table cell node to check
+ * @returns true if the cell is empty; false otherwise
+ */
+export declare function isCellEmpty(cellNode: Node): boolean;
+/**
+ * Determine if the current selection is a full row or column selection.
+ *
+ * If the selection is a `CellSelection` that spans an entire row or column,
+ * returns an object indicating the type and index:
+ * - `{ type: "row", index: number }` for full row selections
+ * - `{ type: "column", index: number }` for full column selections
+ *
+ * If the selection is not a full row/column, or if no table is found, returns null.
+ */
+export declare function getTableSelectionType(editor: Editor | null, index?: number, orientation?: Orientation, tablePos?: number): {
+    orientation: Orientation;
+    index: number;
+} | null;
+/**
+ * Get all cells (and unique merged cells) in the selected row or column.
+ *
+ * - If `index` is provided, uses that row/column index.
+ * - If omitted, uses the first selected row/column based on current selection.
+ *
+ * Returns an object with:
+ * - `cells`: all cells in the row/column
+ * - `mergedCells`: only the unique cells that have rowspan/colspan > 1
+ *
+ * If no valid selection or index is found, returns empty arrays.
+ */
+export declare function getRowOrColumnCells(editor: Editor | null, index?: number, orientation?: Orientation, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+    index?: number;
+    orientation?: Orientation;
+    tablePos?: number;
+};
+/**
+ * Collect cells (and unique merged cells) from a specific row.
+ * - If `rowIndex` is provided, scans that row.
+ * - If omitted, uses the first (topmost) selected row based on the current selection.
+ */
+export declare function getRowCells(editor: Editor | null, rowIndex?: number, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+};
+/**
+ * Collect cells (and unique merged cells) from the current table.
+ * - If `columnIndex` is provided, scans that column.
+ * - If omitted, uses the first (leftmost) selected column based on the current selection.
+ */
+export declare function getColumnCells(editor: Editor | null, columnIndex?: number, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+};
+/**
+ * After moving a row or column, update the selection to the moved item.
+ *
+ * This ensures that after a move operation, the selection remains on the
+ * moved row or column, providing better user feedback.
+ *
+ * @param editor - The editor instance
+ * @param orientation - "row" or "column" indicating what was moved
+ * @param newIndex - The new index of the moved row/column
+ * @param tablePos - Optional position of the table in the document
+ */
+export declare function updateSelectionAfterAction(editor: Editor, orientation: Orientation, newIndex: number, tablePos?: number): void;
+/**
+ * Returns a command that sets the given attributes to the given values,
+ * and is only available when the currently selected cell doesn't
+ * already have those attributes set to those values.
+ *
+ * @public
+ */
+export declare function setCellAttr(attrs: Record<string, unknown>): Command;
+export declare function setCellAttr(name: string, value: unknown): Command;
+/**
+ * Counts how many consecutive empty rows exist at the bottom of a given table.
+ *
+ * This function:
+ *  - Locates the exact table in the document via reference matching
+ *  - Iterates from the last visual row upward
+ *  - Deduplicates cells per row using `TableMap` (merged cells can repeat positions)
+ *  - Treats a row as empty only if all its unique cells are empty by `isCellEmpty`
+ *
+ * @param editor - The editor whose document contains the table
+ * @param target - The table node instance to analyze (must be the same reference as in the doc)
+ * @returns The number of trailing empty rows (0 if table not found)
+ */
+export declare function countEmptyRowsFromEnd(editor: Editor, tablePos: number): number;
+/**
+ * Counts how many consecutive empty columns exist at the right edge of a given table.
+ *
+ * Similar to `countEmptyRowsFromEnd`, but scans by columns:
+ *  - Iterates from the last visual column leftward
+ *  - Deduplicates per-column cells using `TableMap`
+ *  - A column is empty only if all unique cells in that column are empty
+ *
+ * @param editor - The editor whose document contains the table
+ * @param target - The table node instance to analyze (must be the same reference as in the doc)
+ * @returns The number of trailing empty columns (0 if table not found)
+ */
+export declare function countEmptyColumnsFromEnd(editor: Editor, tablePos: number): number;
+/**
+ * Rounds a number with a symmetric "dead-zone" around integer boundaries,
+ * which makes drag/resize UX feel less jittery near thresholds.
+ *
+ * For example, with `margin = 0.3`:
+ *  - values < n + 0.3 snap down to `n`
+ *  - values > n + 0.7 snap up to `n + 1`
+ *  - values in [n + 0.3, n + 0.7] fall back to `Math.round`
+ *
+ * @param num - The floating value to round
+ * @param margin - Half-width of the dead-zone around integer boundaries (default 0.3)
+ * @returns The rounded value using the dead-zone heuristic
+ */
+export declare function marginRound(num: number, margin?: number): number;
+/**
+ * Compares two DOMRect objects for equality.
+ *
+ * Treats `undefined` as a valid state, where two `undefined` rects are equal,
+ * and `undefined` is not equal to any defined rect.
+ *
+ * @param a - The first DOMRect or undefined
+ * @param b - The second DOMRect or undefined
+ * @returns true if both rects are equal or both are undefined; false otherwise
+ */
+export declare function rectEq(a?: DOMRect | null, b?: DOMRect | null): boolean;
+/**
+ * Create or apply a `CellSelection` inside a table.
+ *
+ * Depending on the `mode` option, this helper behaves differently:
+ *
+ * - `"state"` (default) → Returns a new `EditorState` with the selection applied.
+ * - `"transaction"` → Returns a `Transaction` with the selection set, without applying it.
+ * - `"dispatch"` → Immediately calls `dispatch(tr)` with the new selection.
+ *
+ * This allows you to reuse the same helper in commands, tests, or utilities
+ * without duplicating logic.
+ *
+ * Example:
+ * ```ts
+ * // Get new state
+ * const nextState = createTableCellSelection(state, tablePosition, { row: 1, col: 1 }, { row: 2, col: 3 })
+ *
+ * // Get transaction only
+ * const tr = createTableCellSelection(state, tablePosition, { row: 0, col: 0 }, { row: 0, col: 2 }, { mode: "transaction" })
+ *
+ * // Dispatch directly
+ * createTableCellSelection(state, tablePosition, { row: 1, col: 1 }, { row: 3, col: 2 }, { mode: "dispatch", dispatch })
+ * ```
+ */
+export declare function createTableCellSelection(state: EditorState, tablePosition: number, startCell: CellCoordinates, endCell?: CellCoordinates, options?: StateSelectionOptions): EditorState;
+export declare function createTableCellSelection(state: EditorState, tablePosition: number, startCell: CellCoordinates, endCell: CellCoordinates | undefined, options: TransactionSelectionOptions): Transaction;
+export declare function createTableCellSelection(state: EditorState, tablePosition: number, startCell: CellCoordinates, endCell: CellCoordinates | undefined, options: DispatchSelectionOptions): void;
+/**
+ * Get the position of a cell inside a table by relative row/col indices.
+ * Returns the position *before* the cell, which is what `CellSelection` expects.
+ */
+export declare function getCellPosition(state: EditorState, tablePosition: number, cellCoordinates: CellCoordinates): import("@tiptap/pm/model").ResolvedPos | null;
+/**
+ * Selects table cells by their (row, col) coordinates.
+ *
+ * This function can be used in three modes:
+ * - `"state"` (default) → Returns a new `EditorState` with the selection applied, or null if failed.
+ * - `"transaction"` → Returns a `Transaction` with the selection set, or null if failed.
+ * - `"dispatch"` → Immediately dispatches the selection and returns boolean success status.
+ *
+ * @param editor - The editor instance
+ * @param tablePos - Position of the table in the document
+ * @param coords - Array of {row, col} coordinates to select
+ * @param options - Mode and dispatch options
+ */
+export declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options?: StateSelectionOptions): EditorState;
+export declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options: TransactionSelectionOptions): Transaction;
+export declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options: DispatchSelectionOptions): void;
+/**
+ * Select the cell at (row, col) using `cellAround` to respect merged cells.
+ *
+ * @param editor    Tiptap editor
+ * @param row       Row index (0-based)
+ * @param col       Column index (0-based)
+ * @param tablePos  Optional absolute position of the table node
+ * @param dispatch  Optional dispatch; defaults to editor.view.dispatch
+ */
+export declare function selectCellAt({ editor, row, col, tablePos, dispatch, }: {
+    editor: Editor | null;
+    row: number;
+    col: number;
+    tablePos?: number;
+    dispatch?: (tr: Transaction) => void;
+}): boolean;
+/**
+ * Selects a boundary cell of the table based on orientation.
+ *
+ * For row orientation, selects the bottom-left cell of the table.
+ * For column orientation, selects the top-right cell of the table.
+ *
+ * This function accounts for merged cells to ensure the correct cell is selected.
+ *
+ * @param editor      The Tiptap editor instance
+ * @param tableNode   The table node
+ * @param tablePos    The position of the table node in the document
+ * @param orientation "row" to select bottom-left, "column" to select top-right
+ * @returns true if the selection was successful; false otherwise
+ */
+export declare function selectLastCell(editor: Editor, tableNode: Node, tablePos: number, orientation: Orientation): boolean;
+/**
+ * Get all (row, col) coordinates for a given row or column index.
+ *
+ * - If `orientation` is "row", returns all columns in that row.
+ * - If `orientation` is "column", returns all rows in that column.
+ *
+ * Returns null if:
+ * - the editor or table is not found
+ * - the index is out of bounds
+ *
+ * @param editor      The Tiptap editor instance
+ * @param index       The row or column index (0-based)
+ * @param orientation "row" to get row coordinates, "column" for column coordinates
+ * @param tablePos    Optional position of the table node in the document
+ * @returns Array of {row, col} objects or null if invalid
+ */
+export declare function getIndexCoordinates({ editor, index, orientation, tablePos, }: {
+    editor: Editor | null;
+    index: number;
+    orientation?: Orientation;
+    tablePos?: number;
+}): {
+    row: number;
+    col: number;
+}[] | null;
+/**
+ * Given a DOM cell element, find its (row, col) indices within the table.
+ *
+ * This function:
+ * - Locates the nearest ancestor table element
+ * - Uses the editor's document model to resolve the cell's position
+ * - Traverses up the node hierarchy to find the corresponding table cell node
+ * - Uses `TableMap` to translate the cell's position into (row, col) indices
+ *
+ * Returns null if:
+ * - the table or cell cannot be found in the editor's document
+ * - any error occurs during position resolution
+ *
+ * @param cell      The HTMLTableCellElement (td or th)
+ * @param tableNode The table node in the ProseMirror document
+ * @param editor    The Tiptap editor instance
+ * @returns An object with { rowIndex, colIndex } or null if not found
+ */
+export declare function getCellIndicesFromDOM(cell: HTMLTableCellElement, tableNode: Node | null, editor: Editor): {
+    rowIndex: number;
+    colIndex: number;
+} | null;
+/**
+ * Given a DOM element inside a table, find the corresponding table node and its position.
+ *
+ * This function:
+ * - Locates the nearest ancestor table element
+ * - Uses the editor's document model to resolve the table's position
+ * - Traverses up the node hierarchy to find the corresponding table node
+ *
+ * Returns null if:
+ * - the table cannot be found in the editor's document
+ * - any error occurs during position resolution
+ *
+ * @param tableElement The HTMLTableElement or an element inside it
+ * @param editor       The Tiptap editor instance
+ * @returns An object with { node: tableNode, pos: tablePos } or null if not found
+ */
+export declare function getTableFromDOM(tableElement: HTMLElement, editor: Editor): {
+    node: Node;
+    pos: number;
+} | null;
+/**
+ * Checks if a node is a table node
+ */
+export declare function isTableNode(node: Node | null | undefined): node is Node;

package/dist/components/tiptap-node/table-node/ui/table-add-row-column-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./table-add-row-column-button";
+export * from "./use-table-add-row-column";

package/dist/components/tiptap-node/table-node/ui/table-add-row-column-button/table-add-row-column-button.d.ts

@@ -0,0 +1,14 @@
+import type { UseTableAddRowColumnConfig } from "@/components/tiptap-node/table-node/ui/table-add-row-column-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableAddRowColumnButtonProps extends Omit<ButtonProps, "type">, UseTableAddRowColumnConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for adding a table row/column in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useTableAddRowColumn` hook instead.
+ */
+export declare const TableAddRowColumnButton: import("react").ForwardRefExoticComponent<TableAddRowColumnButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-node/table-node/ui/table-add-row-column-button/use-table-add-row-column.d.ts

@@ -0,0 +1,53 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export type RowSide = "above" | "below";
+export type ColSide = "left" | "right";
+export interface UseTableAddRowColumnConfig {
+    /**
+     * The Tiptap editor instance. If omitted, the hook will use
+     * the context/editor from `useTiptapEditor`.
+     */
+    editor?: Editor | null;
+    /**
+     * The index of the row or column to add relative to.
+     * If omitted, will use the current selection.
+     */
+    index?: number;
+    /**
+     * Whether you're adding a row or a column.
+     * If omitted, will use the current selection.
+     */
+    orientation?: Orientation;
+    /**
+     * The side to add on - above/below for rows, left/right for columns.
+     */
+    side: RowSide | ColSide;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * Hide the button when addition isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful addition.
+     */
+    onAdded?: () => void;
+}
+export declare const tableAddRowColumnLabels: {
+    readonly row: Record<RowSide, string>;
+    readonly column: Record<ColSide, string>;
+};
+/**
+ * Custom hook that provides **table row/column addition**
+ * functionality for the Tiptap editor.
+ */
+export declare function useTableAddRowColumn(config: UseTableAddRowColumnConfig): {
+    isVisible: boolean;
+    canAddRowColumn: boolean;
+    handleAdd: () => boolean;
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-node/table-node/ui/table-align-cell-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./table-align-cell-button";
+export * from "./use-table-align-cell";

package/dist/components/tiptap-node/table-node/ui/table-align-cell-button/table-align-cell-button.d.ts

@@ -0,0 +1,41 @@
+import type { UseTableAlignCellConfig } from "@/components/tiptap-node/table-node/ui/table-align-cell-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableAlignCellButtonProps extends Omit<ButtonProps, "type">, UseTableAlignCellConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for aligning table cells in a Tiptap editor.
+ * Supports both text alignment (left, center, right, justify) and
+ * vertical alignment (top, middle, bottom).
+ *
+ * Can align either the currently selected cell(s) or all cells in a specific row/column.
+ *
+ * @example
+ * ```tsx
+ * // Align the currently selected cell(s)
+ * <TableAlignCellButton
+ *   alignmentType="text"
+ *   alignment="center"
+ * />
+ *
+ * // Align all cells in row 0
+ * <TableAlignCellButton
+ *   alignmentType="text"
+ *   alignment="center"
+ *   index={0}
+ *   orientation="row"
+ * />
+ *
+ * // Align all cells in column 2
+ * <TableAlignCellButton
+ *   alignmentType="vertical"
+ *   alignment="middle"
+ *   index={2}
+ *   orientation="column"
+ * />
+ * ```
+ */
+export declare const TableAlignCellButton: import("react").ForwardRefExoticComponent<TableAlignCellButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-node/table-node/ui/table-align-cell-button/use-table-align-cell.d.ts

@@ -0,0 +1,145 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export type TextAlignment = "left" | "center" | "right" | "justify";
+export type VerticalAlignment = "top" | "middle" | "bottom";
+export type AlignmentType = "text" | "vertical";
+export interface UseTableAlignCellConfig {
+    /**
+     * The Tiptap editor instance. If omitted, the hook will use
+     * the context/editor from `useTiptapEditor`.
+     */
+    editor?: Editor | null;
+    /**
+     * The type of alignment to apply.
+     */
+    alignmentType: AlignmentType;
+    /**
+     * The alignment value to set.
+     */
+    alignment: TextAlignment | VerticalAlignment;
+    /**
+     * Optional index of the row or column to align.
+     * If provided along with orientation, aligns all cells in that row/column.
+     * If not provided, aligns the currently selected cell(s).
+     */
+    index?: number;
+    /**
+     * Optional orientation when using index.
+     * Determines whether to align a row or column.
+     */
+    orientation?: Orientation;
+    /**
+     * Hide the button when alignment isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after successful alignment change.
+     */
+    onAligned?: (alignment: TextAlignment | VerticalAlignment) => void;
+}
+export declare const tableAlignCellLabels: {
+    text: Record<TextAlignment, string>;
+    vertical: Record<VerticalAlignment, string>;
+};
+export declare const tableAlignCellIcons: {
+    text: Record<TextAlignment, React.ComponentType<{
+        className?: string;
+    }>>;
+    vertical: Record<VerticalAlignment, React.ComponentType<{
+        className?: string;
+    }>>;
+};
+/**
+ * Custom hook that provides **table cell alignment**
+ * functionality for the Tiptap editor.
+ *
+ * @example
+ * ```tsx
+ * // Simple text alignment button
+ * function AlignLeftButton() {
+ *   const { isVisible, handleAlign, canAlignCell, isActive, label, Icon } = useTableAlignCell({
+ *     alignmentType: "text",
+ *     alignment: "left",
+ *     hideWhenUnavailable: true,
+ *     onAligned: (alignment) => console.log(`Aligned to: ${alignment}`),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleAlign}
+ *       disabled={!canAlignCell}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Align entire row vertically
+ * function AlignRowTopButton({ rowIndex }: { rowIndex: number }) {
+ *   const { isVisible, handleAlign, label, Icon } = useTableAlignCell({
+ *     alignmentType: "vertical",
+ *     alignment: "top",
+ *     index: rowIndex,
+ *     orientation: "row",
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button onClick={handleAlign} aria-label={label}>
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Alignment toolbar for selected cell
+ * function CellAlignmentToolbar() {
+ *   const alignments: TextAlignment[] = ["left", "center", "right", "justify"]
+ *
+ *   return (
+ *     <div role="toolbar" aria-label="Text alignment">
+ *       {alignments.map((alignment) => {
+ *         const { isVisible, handleAlign, canAlignCell, isActive, Icon } = useTableAlignCell({
+ *           alignmentType: "text",
+ *           alignment,
+ *           hideWhenUnavailable: true,
+ *         })
+ *
+ *         if (!isVisible) return null
+ *
+ *         return (
+ *           <button
+ *             key={alignment}
+ *             onClick={handleAlign}
+ *             disabled={!canAlignCell}
+ *             aria-pressed={isActive}
+ *             title={`Align ${alignment}`}
+ *           >
+ *             <Icon />
+ *           </button>
+ *         )
+ *       })}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTableAlignCell(config: UseTableAlignCellConfig): {
+    isVisible: boolean;
+    canAlignCell: () => boolean;
+    handleAlign: () => boolean;
+    label: string;
+    Icon: import("react").ComponentClass<{
+        className?: string;
+    }, any> | import("react").FunctionComponent<{
+        className?: string;
+    }>;
+    isActive: boolean;
+    currentAlignment: () => TextAlignment | VerticalAlignment | null;
+};

package/dist/components/tiptap-node/table-node/ui/table-alignment-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./table-alignment-menu";

package/dist/components/tiptap-node/table-node/ui/table-alignment-menu/table-alignment-menu.d.ts

@@ -0,0 +1,16 @@
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface ActionItemProps {
+    icon: React.ComponentType<{
+        className?: string;
+        style?: React.CSSProperties;
+    }>;
+    label: string;
+    onClick: () => void;
+    disabled?: boolean;
+    isActive?: boolean;
+    shortcutBadge?: React.ReactNode;
+}
+export declare const TableAlignMenu: ({ index, orientation, }: {
+    index?: number;
+    orientation?: Orientation;
+}) => import("react").JSX.Element | null;

package/dist/components/tiptap-node/table-node/ui/table-cell-handle-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./table-cell-handle-menu";