cvnert-editor 0.1.0

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

@@ -0,0 +1,11 @@
+import type { Editor } from "@tiptap/react";
+import "./table-cell-handle-menu.css";
+declare const TableActionMenu: ({ onClose }: {
+    onClose: () => void;
+}) => import("react").JSX.Element;
+interface TableCellHandleMenuProps extends React.ComponentPropsWithoutRef<"button"> {
+    editor?: Editor | null;
+    onOpenChange?: (isOpen: boolean) => void;
+}
+export declare const TableCellHandleMenu: import("react").ForwardRefExoticComponent<TableCellHandleMenuProps & import("react").RefAttributes<HTMLButtonElement>>;
+export { TableActionMenu };

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

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

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

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

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

@@ -0,0 +1,96 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface UseTableClearRowColumnContentConfig {
+    /**
+     * 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 clear.
+     * If omitted, will clear the currently selected cells.
+     */
+    index?: number;
+    /**
+     * Whether you're clearing a row or a column.
+     * If omitted, will clear the currently selected cells.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * Hide the button when clearing isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Whether to reset cell attributes (backgroundColor, nodeVerticalAlign, nodeTextAlign) when clearing.
+     * @default false
+     */
+    resetAttrs?: boolean;
+    /**
+     * Callback function called after a successful clear.
+     */
+    onCleared?: () => void;
+}
+export declare const tableClearRowColumnContentLabels: Record<Orientation, string>;
+/**
+ * Custom hook that provides **table row/column content clearing**
+ * functionality for the Tiptap editor.
+ *
+ * @example
+ * ```tsx
+ * // Clear currently selected cells (no parameters needed)
+ * function ClearSelectedButton() {
+ *   const { isVisible, handleClear } = useTableClearRowColumnContent()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleClear}>Clear Selection</button>
+ * }
+ *
+ * // Clear specific row with attribute reset
+ * function ClearRowButton({ rowIndex }: { rowIndex: number }) {
+ *   const { isVisible, handleClear, label, canClearRowColumnContent } = useTableClearRowColumnContent({
+ *     index: rowIndex,
+ *     orientation: "row",
+ *     resetAttrs: true,
+ *     hideWhenUnavailable: true,
+ *     onCleared: () => console.log("Row cleared and attributes reset!"),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleClear}
+ *       disabled={!canClearRowColumnContent}
+ *       aria-label={label}
+ *     >
+ *       {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Clear content based on current table selection (row/column/cells)
+ * function SmartClearButton() {
+ *   const { isVisible, handleClear, label } = useTableClearRowColumnContent({
+ *     resetAttrs: true,
+ *     hideWhenUnavailable: true
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleClear}>{label}</button>
+ * }
+ * ```
+ */
+export declare function useTableClearRowColumnContent(config?: UseTableClearRowColumnContentConfig): {
+    isVisible: boolean;
+    canClearRowColumnContent: boolean;
+    handleClear: () => 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-delete-row-column-button/index.d.ts

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

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

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

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

@@ -0,0 +1,80 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface UseTableDeleteRowColumnConfig {
+    /**
+     * 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 delete.
+     */
+    index?: number;
+    /**
+     * Whether you're deleting a row or a column.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * Hide the button when deletion isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful delete.
+     */
+    onDeleted?: () => void;
+}
+export declare const tableDeleteRowColumnLabels: Record<Orientation, string>;
+/**
+ * Custom hook that provides **table row/column deletion**
+ * functionality for the Tiptap editor.
+ *
+ * @example
+ * ```tsx
+ * // Simple usage with default editor context
+ * function DeleteRowButton() {
+ *   const { isVisible, handleDelete } = useTableDeleteRowColumn({
+ *     index: 0,
+ *     orientation: "row",
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleDelete}>Delete Row</button>
+ * }
+ *
+ * // Advanced usage with custom editor instance
+ * function DeleteColumnButton({ editor }: { editor: Editor }) {
+ *   const { isVisible, handleDelete, label, canDeleteRowColumn, Icon } = useTableDeleteRowColumn({
+ *     editor,
+ *     index: 1,
+ *     orientation: "column",
+ *     hideWhenUnavailable: true,
+ *     onDeleted: () => console.log("Column deleted!"),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleDelete}
+ *       aria-disabled={!canDeleteRowColumn}
+ *       aria-label={label}
+ *     >
+ *       <Icon /> Delete Column
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTableDeleteRowColumn(config: UseTableDeleteRowColumnConfig): {
+    isVisible: boolean;
+    canDeleteRowColumn: boolean;
+    handleDelete: () => 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-duplicate-row-column-button/index.d.ts

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

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

@@ -0,0 +1,6 @@
+import type { UseTableDuplicateRowColumnConfig } from "@/components/tiptap-node/table-node/ui/table-duplicate-row-column-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableDuplicateRowColumnButtonProps extends Omit<ButtonProps, "type">, UseTableDuplicateRowColumnConfig {
+    text?: string;
+}
+export declare const TableDuplicateRowColumnButton: import("react").ForwardRefExoticComponent<TableDuplicateRowColumnButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,42 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface UseTableDuplicateRowColumnConfig {
+    /**
+     * 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 duplicate.
+     */
+    index?: number;
+    /**
+     * Whether you're duplicating a row or a column.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * Hide the button when duplication isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful duplication.
+     */
+    onDuplicated?: () => void;
+}
+export declare const tableDuplicateRowColumnLabels: Record<Orientation, string>;
+/**
+ * Custom hook that provides **table row/column duplication**
+ * functionality for the Tiptap editor.
+ */
+export declare function useTableDuplicateRowColumn(config: UseTableDuplicateRowColumnConfig): {
+    isVisible: boolean;
+    canDuplicateRowColumn: boolean;
+    handleDuplicate: () => 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-extend-row-column-button/index.d.ts

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

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

@@ -0,0 +1,23 @@
+import { type Editor } from "@tiptap/react";
+import type { Node } from "@tiptap/pm/model";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+import "./table-extend-row-column-button.css";
+interface TableExtendRowColumnButtonProps {
+    editor?: Editor | null;
+    block: Node;
+    onMouseDown: () => void;
+    onMouseUp: () => void;
+    orientation: Orientation;
+    children?: React.ReactNode;
+}
+/**
+ * Simplified button component for extending/reducing table dimensions
+ */
+export declare const TableExtendRowColumnButton: React.FC<TableExtendRowColumnButtonProps>;
+export interface TableExtendRowColumnButtonsProps {
+    editor?: Editor | null;
+    onMouseDown?: () => void;
+    onMouseUp?: () => void;
+}
+export declare const TableExtendRowColumnButtons: React.FC<TableExtendRowColumnButtonsProps>;
+export {};

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

@@ -0,0 +1,14 @@
+interface TableExtendRowColumnButtonPositionResult {
+    isMounted: boolean;
+    ref: (node: HTMLElement | null) => void;
+    style: React.CSSProperties;
+}
+interface TableExtendRowColumnButtonsPositioningResult {
+    rowButton: TableExtendRowColumnButtonPositionResult;
+    columnButton: TableExtendRowColumnButtonPositionResult;
+}
+/**
+ * Hook for managing positioning of both row and column extend buttons
+ */
+export declare function useTableExtendRowColumnButtonsPositioning(showAddOrRemoveColumnsButton: boolean, showAddOrRemoveRowsButton: boolean, referencePosTable: DOMRect | null): TableExtendRowColumnButtonsPositioningResult;
+export {};

package/dist/components/tiptap-node/table-node/ui/table-fit-to-width-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./table-fit-to-width-button";
+export * from "./use-table-fit-to-width";

package/dist/components/tiptap-node/table-node/ui/table-fit-to-width-button/table-fit-to-width-button.d.ts

@@ -0,0 +1,21 @@
+import type { UseTableFitToWidthConfig } from "@/components/tiptap-node/table-node/ui/table-fit-to-width-button/use-table-fit-to-width";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableFitToWidthButtonProps extends Omit<ButtonProps, "type">, UseTableFitToWidthConfig {
+    text?: string;
+}
+/**
+ * Button component for fitting table to container width.
+ *
+ * This component provides a user interface for toggling table width between
+ * fixed column widths and container-fitting behavior. It integrates with the
+ * Tiptap table extension to modify table layout properties.
+ *
+ * @example
+ * ```tsx
+ * <TableFitToWidthButton
+ *   editor={editor}
+ *   onWidthAdjusted={() => console.log('Width changed')}
+ * />
+ * ```
+ */
+export declare const TableFitToWidthButton: import("react").ForwardRefExoticComponent<TableFitToWidthButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-node/table-node/ui/table-fit-to-width-button/use-table-fit-to-width.d.ts

@@ -0,0 +1,67 @@
+import type { Editor } from "@tiptap/react";
+export interface UseTableFitToWidthConfig {
+    /**
+     * The Tiptap editor instance. If omitted, the hook will use
+     * the editor from `useTiptapEditor`.
+     */
+    editor?: Editor | null;
+    /**
+     * Hide the button when the action isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Called after the table width is successfully adjusted.
+     */
+    onWidthAdjusted?: () => void;
+}
+/**
+ * React hook that provides a **Fit table to container width** action for Tiptap.
+ *
+ * What it does:
+ * - Sets the current table's `width` to `"100%"`
+ * - Clears cell-level `colwidth` so the table can expand fluidly
+ *
+ * Returned API:
+ * - `isVisible`: whether a button should be shown
+ * - `canFitToWidth`: whether the action can execute now
+ * - `handleFitToWidth()`: runs the action; returns `true` on success
+ * - `label`: UI label, e.g. "Fit to width"
+ * - `Icon`: a presentational icon component
+ *
+ * @example
+ * // Minimal button
+ * function FitToWidthButton() {
+ *   const { isVisible, canFitToWidth, handleFitToWidth, label, Icon } =
+ *     useTableFitToWidth({ hideWhenUnavailable: true })
+ *
+ *   if (!isVisible) return null
+ *   return (
+ *     <button onClick={handleFitToWidth} disabled={!canFitToWidth} aria-label={label}>
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * @example
+ * // Using a provided editor instance and a success callback
+ * function FitToWidthWithCallback({ editor }: { editor: Editor }) {
+ *   const { handleFitToWidth, canFitToWidth } = useTableFitToWidth({
+ *     editor,
+ *     hideWhenUnavailable: true,
+ *     onWidthAdjusted: () => console.log("Table set to auto width"),
+ *   })
+ *   return (
+ *     <button onClick={handleFitToWidth} disabled={!canFitToWidth}>
+ *       Fit to container
+ *     </button>
+ *   )
+ * }
+ */
+export declare function useTableFitToWidth(config?: UseTableFitToWidthConfig): {
+    isVisible: boolean;
+    canFitToWidth: boolean;
+    handleFitToWidth: () => 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-handle/table-handle.d.ts

@@ -0,0 +1,50 @@
+import type { Editor } from "@tiptap/react";
+import type { ComponentType } from "react";
+import type { Node } from "@tiptap/pm/model";
+import { useTableHandlePositioning } from "@/components/tiptap-node/table-node/ui/table-handle/use-table-handle-positioning";
+import { useTableHandleState } from "@/components/tiptap-node/table-node/hooks/use-table-handle-state";
+import { type Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface TableHandleButtonProps {
+    editor: Editor;
+    orientation: Orientation;
+    index?: number;
+    tablePos?: number;
+    tableNode?: Node;
+    onToggleOtherHandle?: (visible: boolean) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface TableHandleRenderProps {
+    editor: Editor;
+    state: ReturnType<typeof useTableHandleState>;
+    rowHandle: ReturnType<typeof useTableHandlePositioning>["rowHandle"];
+    colHandle: ReturnType<typeof useTableHandlePositioning>["colHandle"];
+    toggleRowVisibility: (visible: boolean) => void;
+    toggleColumnVisibility: (visible: boolean) => void;
+}
+export interface TableHandleProps {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Custom component to render for row handles.
+     * If not provided, uses the default TableHandleMenu.
+     */
+    rowButton?: ComponentType<TableHandleButtonProps>;
+    /**
+     * Custom component to render for column handles.
+     * If not provided, uses the default TableHandleMenu.
+     */
+    columnButton?: ComponentType<TableHandleButtonProps>;
+}
+/**
+ * Main table handle component that manages the positioning and rendering
+ * of table row/column handles, extend buttons, and context menus.
+ *
+ * This component can be extended with custom row and column buttons,
+ * or completely customized using the render prop pattern.
+ */
+export declare function TableHandle({ editor: providedEditor, rowButton: CustomRowButton, columnButton: CustomColumnButton, }: TableHandleProps): import("react").JSX.Element | null;
+export declare namespace TableHandle {
+    var displayName: string;
+}

package/dist/components/tiptap-node/table-node/ui/table-handle/use-table-handle-positioning.d.ts

@@ -0,0 +1,41 @@
+type Orientation = "row" | "col" | "cell";
+type DraggingState = {
+    draggedCellOrientation: Exclude<Orientation, "cell">;
+    mousePos: number;
+    initialOffset?: number;
+};
+/**
+ * Hook for positioning individual table handles using Floating UI
+ */
+export declare function useTableHandlePosition(orientation: Orientation, show: boolean, referencePosCell: DOMRect | null, referencePosTable: DOMRect | null, draggingState?: DraggingState): {
+    isMounted: boolean;
+    ref: (node: HTMLElement | null) => void;
+    style: React.CSSProperties;
+};
+/**
+ * Hook for managing positioning of all table handles (row, column, and cell)
+ *
+ * @param show - Whether handles should be shown
+ * @param referencePosCell - The bounding rect of the current cell
+ * @param referencePosTable - The bounding rect of the table
+ * @param draggingState - Current dragging state if any
+ * @returns Positioning data for all handle types
+ */
+export declare function useTableHandlePositioning(show: boolean, referencePosCell: DOMRect | null, referencePosTable: DOMRect | null, draggingState?: DraggingState): {
+    rowHandle: {
+        isMounted: boolean;
+        ref: (node: HTMLElement | null) => void;
+        style: React.CSSProperties;
+    };
+    colHandle: {
+        isMounted: boolean;
+        ref: (node: HTMLElement | null) => void;
+        style: React.CSSProperties;
+    };
+    cellHandle: {
+        isMounted: boolean;
+        ref: (node: HTMLElement | null) => void;
+        style: React.CSSProperties;
+    };
+};
+export {};

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

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

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

@@ -0,0 +1,25 @@
+import type { Editor } from "@tiptap/react";
+import type { Node } from "@tiptap/pm/model";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+import "./table-handle-menu.css";
+interface BaseProps {
+    editor?: Editor | null;
+    orientation: Orientation;
+    index?: number;
+    tableNode?: Node;
+    tablePos?: number;
+}
+interface TableHandleMenuProps extends BaseProps {
+    onToggleOtherHandle?: (visible: boolean) => void;
+    onOpenChange?: (open: boolean) => void;
+    dragStart?: (e: React.DragEvent) => void;
+}
+/**
+ * Menu content component
+ */
+declare const TableActionMenu: () => import("react").JSX.Element;
+/**
+ * Main table handle menu component
+ */
+export declare const TableHandleMenu: ({ editor: providedEditor, orientation, index, tableNode, tablePos, onToggleOtherHandle, onOpenChange, dragStart, }: TableHandleMenuProps) => import("react").JSX.Element;
+export { TableActionMenu };

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

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

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

@@ -0,0 +1,15 @@
+import type { UseTableHeaderRowColumnConfig } from "@/components/tiptap-node/table-node/ui/table-header-row-column-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableHeaderRowColumnButtonProps extends Omit<ButtonProps, "type">, UseTableHeaderRowColumnConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for toggling table header row/column in a Tiptap editor.
+ * Only works for the first row (index 0) or first column (index 0).
+ *
+ * For custom button implementations, use the `useTableHeaderRowColumn` hook instead.
+ */
+export declare const TableHeaderRowColumnButton: import("react").ForwardRefExoticComponent<TableHeaderRowColumnButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,51 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export interface UseTableHeaderRowColumnConfig {
+    /**
+     * 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. Header functionality only applies to index 0.
+     * If omitted, will use the current selection.
+     */
+    index?: number;
+    /**
+     * Whether you're toggling header for a row or a column.
+     * If omitted, will use the current selection.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     * Used when there's no cell selection so we can target a specific table.
+     */
+    tablePos?: number;
+    /**
+     * Hide the button when header toggle isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful header toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const tableHeaderRowColumnLabels: Record<Orientation, string>;
+export declare const tableHeaderRowColumnIcons: {
+    row: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    column: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Custom hook that provides **table header row/column toggle**
+ * functionality for the Tiptap editor. Supports `tablePos` when
+ * no cell is selected.
+ */
+export declare function useTableHeaderRowColumn(config: UseTableHeaderRowColumnConfig): {
+    isVisible: boolean;
+    canToggleHeader: boolean;
+    handleToggle: () => boolean;
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    isActive: boolean;
+};

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

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