cvnert-editor 0.1.0

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

@@ -0,0 +1,43 @@
+import type { UseTableMergeSplitCellConfig } from "@/components/tiptap-node/table-node/ui/table-merge-split-cell-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableMergeSplitCellButtonProps extends Omit<ButtonProps, "type">, UseTableMergeSplitCellConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for merging or splitting table cells in a Tiptap editor.
+ *
+ * **Merge Cells**: When multiple cells are selected (using CellSelection),
+ * this button will merge them into a single cell.
+ *
+ * **Split Cell**: When a merged cell is selected, this button will split
+ * it back into individual cells.
+ *
+ * For custom button implementations, use the `useTableMergeSplitCell` hook instead.
+ *
+ * @example
+ * ```tsx
+ * // Merge cells button
+ * <TableMergeSplitCellButton
+ *   action="merge"
+ *   hideWhenUnavailable={true}
+ * />
+ *
+ * // Split cell button
+ * <TableMergeSplitCellButton
+ *   action="split"
+ *   text="Split Cell"
+ *   onExecuted={(action) => console.log(`${action} completed!`)}
+ * />
+ *
+ * // Custom styling
+ * <TableMergeSplitCellButton
+ *   action="merge"
+ *   className="my-custom-merge-button"
+ *   style={{ backgroundColor: 'blue' }}
+ * />
+ * ```
+ */
+export declare const TableMergeSplitCellButton: import("react").ForwardRefExoticComponent<TableMergeSplitCellButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,119 @@
+import type { Editor } from "@tiptap/react";
+export type MergeSplitAction = "merge" | "split";
+export interface UseTableMergeSplitCellConfig {
+    /**
+     * The Tiptap editor instance. If omitted, the hook will use
+     * the context/editor from `useTiptapEditor`.
+     */
+    editor?: Editor | null;
+    /**
+     * The action to perform - merge or split cells.
+     */
+    action: MergeSplitAction;
+    /**
+     * Hide the button when the action isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful merge or split.
+     */
+    onExecuted?: (action: MergeSplitAction) => void;
+}
+export declare const tableMergeSplitCellLabels: Record<MergeSplitAction, string>;
+export declare const tableMergeSplitCellIcons: {
+    merge: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    split: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Custom hook that provides **table cell merge/split**
+ * functionality for the Tiptap editor.
+ *
+ * @example
+ * ```tsx
+ * // Simple merge button
+ * function MergeCellsButton() {
+ *   const { isVisible, handleExecute, canExecute, label, Icon } = useTableMergeSplitCell({
+ *     action: "merge",
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleExecute}
+ *       disabled={!canExecute}
+ *       aria-label={label}
+ *     >
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Split cell button with callback
+ * function SplitCellButton({ editor }: { editor: Editor }) {
+ *   const { isVisible, handleExecute, label, canExecute, Icon } = useTableMergeSplitCell({
+ *     editor,
+ *     action: "split",
+ *     hideWhenUnavailable: true,
+ *     onExecuted: (action) => console.log(`${action} completed!`),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleExecute}
+ *       disabled={!canExecute}
+ *       aria-label={label}
+ *     >
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Dynamic merge/split button based on context
+ * function MergeSplitButton() {
+ *   const mergeAction = useTableMergeSplitCell({
+ *     action: "merge",
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   const splitAction = useTableMergeSplitCell({
+ *     action: "split",
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   if (mergeAction.isVisible) {
+ *     return (
+ *       <button
+ *         onClick={mergeAction.handleExecute}
+ *         disabled={!mergeAction.canExecute}
+ *       >
+ *         {mergeAction.label}
+ *       </button>
+ *     )
+ *   }
+ *
+ *   if (splitAction.isVisible) {
+ *     return (
+ *       <button
+ *         onClick={splitAction.handleExecute}
+ *         disabled={!splitAction.canExecute}
+ *       >
+ *         {splitAction.label}
+ *       </button>
+ *     )
+ *   }
+ *
+ *   return null
+ * }
+ * ```
+ */
+export declare function useTableMergeSplitCell(config: UseTableMergeSplitCellConfig): {
+    isVisible: boolean;
+    canExecute: boolean;
+    handleExecute: () => 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>;
+};

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

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

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

@@ -0,0 +1,37 @@
+import type { UseTableMoveRowColumnConfig } from "@/components/tiptap-node/table-node/ui/table-move-row-column-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TableMoveRowColumnButtonProps extends Omit<ButtonProps, "type">, UseTableMoveRowColumnConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for moving a table row/column in a Tiptap editor.
+ *
+ * Supports moving:
+ * - Rows up or down
+ * - Columns left or right
+ *
+ * For custom button implementations, use the `useTableMoveRowColumn` hook instead.
+ *
+ * @example
+ * ```tsx
+ * // Move row up
+ * <TableMoveRowColumnButton
+ *   index={0}
+ *   orientation="row"
+ *   direction="up"
+ * />
+ *
+ * // Move column right
+ * <TableMoveRowColumnButton
+ *   index={2}
+ *   orientation="column"
+ *   direction="right"
+ *   hideWhenUnavailable={true}
+ *   onMoved={() => console.log("Column moved!")}
+ * />
+ * ```
+ */
+export declare const TableMoveRowColumnButton: import("react").ForwardRefExoticComponent<TableMoveRowColumnButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,94 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export type MoveDirection = "up" | "down" | "left" | "right";
+export interface UseTableMoveRowColumnConfig {
+    /**
+     * 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 move.
+     * If omitted, will use the current selection.
+     */
+    index?: number;
+    /**
+     * Whether you're moving a row or a column.
+     * If omitted, will use the current selection.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * The direction to move (up/down for rows, left/right for columns).
+     */
+    direction: MoveDirection;
+    /**
+     * Hide the button when moving isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful move.
+     */
+    onMoved?: () => void;
+}
+export declare const tableMoveRowColumnLabels: Record<Orientation, Record<MoveDirection, string>>;
+export declare const tableMoveRowColumnIcons: {
+    up: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    down: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    left: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    right: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Custom hook that provides **table row/column moving**
+ * functionality for the Tiptap editor.
+ *
+ * @example
+ * ```tsx
+ * // Move row up
+ * function MoveRowUpButton({ rowIndex }: { rowIndex: number }) {
+ *   const { isVisible, handleMove, canMoveRowColumn, label, Icon } = useTableMoveRowColumn({
+ *     index: rowIndex,
+ *     orientation: "row",
+ *     direction: "up",
+ *     hideWhenUnavailable: true,
+ *     onMoved: () => console.log("Row moved up!"),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleMove}
+ *       disabled={!canMoveRowColumn}
+ *       aria-label={label}
+ *     >
+ *       <Icon /> {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Move column based on current selection
+ * function MoveColumnButton({ direction }: { direction: "left" | "right" }) {
+ *   const { isVisible, handleMove, label } = useTableMoveRowColumn({
+ *     orientation: "column",
+ *     direction,
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleMove}>{label}</button>
+ * }
+ * ```
+ */
+export declare function useTableMoveRowColumn(config: UseTableMoveRowColumnConfig): {
+    isVisible: boolean;
+    canMoveRowColumn: boolean;
+    handleMove: () => 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> | 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>;
+};

package/dist/components/tiptap-node/table-node/ui/table-selection-overlay/index.d.ts

@@ -0,0 +1 @@
+export * from "./table-selection-overlay";

package/dist/components/tiptap-node/table-node/ui/table-selection-overlay/table-selection-overlay.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from "@tiptap/react";
+export interface TableSelectionOverlayProps {
+    editor?: Editor | null;
+    cellMenu?: React.ComponentType<{
+        onOpenChange?: (isOpen: boolean) => void;
+        editor?: Editor | null;
+        onResizeStart?: (handle: ResizeHandle) => (event: React.MouseEvent) => void;
+    }>;
+    showResizeHandles?: boolean;
+    onMenuOpenChange?: (isOpen: boolean) => void;
+}
+type ResizeHandle = "tl" | "tr" | "bl" | "br" | null;
+export declare const TableSelectionOverlay: React.FC<TableSelectionOverlayProps>;
+export {};

package/dist/components/tiptap-node/table-node/ui/table-selection-overlay/use-resize-overlay.d.ts

@@ -0,0 +1,2 @@
+import type { Editor } from "@tiptap/react";
+export declare function useResizeOverlay(editor: Editor | null, updateSelectionRect: () => void): void;

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

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

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

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

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

@@ -0,0 +1,111 @@
+import type { Editor } from "@tiptap/react";
+import type { Orientation } from "@/components/tiptap-node/table-node/lib/tiptap-table-utils";
+export type SortDirection = "asc" | "desc";
+export interface UseTableSortRowColumnConfig {
+    /**
+     * 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 sort.
+     * If omitted, will use the current selection.
+     */
+    index?: number;
+    /**
+     * Whether you're sorting a row or a column.
+     * If omitted, will use the current selection.
+     */
+    orientation?: Orientation;
+    /**
+     * The position of the table in the document.
+     */
+    tablePos?: number;
+    /**
+     * The sort direction (ascending or descending).
+     */
+    direction: SortDirection;
+    /**
+     * Hide the button when sorting isn't currently possible.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful sort.
+     */
+    onSorted?: () => void;
+}
+export declare const tableSortRowColumnLabels: Record<Orientation, Record<SortDirection, string>>;
+export declare const tableSortRowColumnIcons: {
+    asc: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    desc: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Custom hook that provides **table row/column sorting**
+ * functionality for the Tiptap editor.
+ *
+ * **Header Handling:** Header cells are automatically detected and excluded
+ * from sorting. During a sort operation, header cells remain in their original
+ * positions while only data cells are rearranged. Headers are identified by
+ * node type (`tableHeader`) or attributes (`header: true`).
+ *
+ * **Empty Cell Handling:** Empty cells are always sorted to the end,
+ * regardless of sort direction (A-Z or Z-A).
+ *
+ * @example
+ * ```tsx
+ * // Sort currently selected row/column (smart mode)
+ * function SortButton() {
+ *   const { isVisible, handleSort } = useTableSortRowColumn({ direction: "asc" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleSort}>Sort A-Z</button>
+ * }
+ *
+ * // Sort specific row, headers will be preserved
+ * function SortRowButton({ rowIndex }: { rowIndex: number }) {
+ *   const { isVisible, handleSort, label, canSortRowColumn } = useTableSortRowColumn({
+ *     index: rowIndex,
+ *     orientation: "row",
+ *     direction: "asc",
+ *     hideWhenUnavailable: true,
+ *     onSorted: () => console.log("Row sorted! Headers stayed in place."),
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleSort}
+ *       disabled={!canSortRowColumn}
+ *       aria-label={label}
+ *     >
+ *       {label}
+ *     </button>
+ *   )
+ * }
+ *
+ * // Sort with callback to handle the result
+ * function SmartSortButton() {
+ *   const { isVisible, handleSort, label } = useTableSortRowColumn({
+ *     direction: "desc",
+ *     hideWhenUnavailable: true,
+ *     onSorted: () => {
+ *       console.log("Sort completed! Headers were automatically preserved.")
+ *     }
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleSort}>{label}</button>
+ * }
+ * ```
+ */
+export declare function useTableSortRowColumn(config?: UseTableSortRowColumnConfig): {
+    isVisible: boolean;
+    canSortRowColumn: boolean;
+    handleSort: () => 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>;
+};

package/dist/components/tiptap-node/toc-node/context/toc-context.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from "react";
+import type { TableOfContentData, TableOfContentDataItem } from "@tiptap/extension-table-of-contents";
+type TocState = {
+    tocContent: TableOfContentData | null;
+    setTocContent: (value: TableOfContentData | null) => void;
+    navigateToHeading: (item: TableOfContentDataItem, options?: {
+        topOffset?: number;
+        behavior?: ScrollBehavior;
+    }) => void;
+    normalizeHeadingDepths: <T extends {
+        level?: number;
+        originalLevel?: number;
+    }>(headingList: T[]) => number[];
+};
+/**
+ * Normalizes heading depths for a table of contents (TOC) structure.
+ *
+ * This function ensures proper hierarchical nesting where a heading can only be
+ * a child of a previous heading with a smaller level number (higher priority).
+ * It prevents incorrect structures like h2 being listed under h3.
+ *
+ * Algorithm:
+ * 1. Rebases all levels so the minimum level becomes 1 (root level)
+ * 2. Maintains a stack of ancestors; pops entries until a smaller level is found
+ * 3. If found, nests it under that parent (parent depth + 1)
+ * 4. If not found, treats it as a root-level item (depth = 1)
+ *
+ * @param items - Array of heading items with `level` or `originalLevel` properties
+ * @returns Array of normalized depths corresponding to each heading item
+ */
+export declare function normalizeHeadingDepths<T extends {
+    level?: number;
+    originalLevel?: number;
+}>(items: T[]): number[];
+/**
+ * Find the nearest scrollable ancestor of an element.
+ * Falls back to `window` when no scrollable container is found.
+ */
+export declare const getScrollableAncestor: (element: HTMLElement) => HTMLElement | Window;
+export declare const TocProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+export declare const useToc: () => TocState;
+export {};

package/dist/components/tiptap-node/toc-node/extensions/toc-node-extension.d.ts

@@ -0,0 +1,45 @@
+import { Node } from "@tiptap/core";
+export interface TocNodeAttrs {
+    /**
+     * The maximum number of headings to show in the TOC node.
+     * @default 20
+     */
+    maxShowCount?: number | null;
+    /**
+     * Offset from the top of the viewport when scrolling to a heading.
+     * @default 0
+     */
+    topOffset?: number | null;
+    /**
+     * Whether to show the "Table of contents" title.
+     * @default true
+     */
+    showTitle?: boolean | null;
+}
+export interface TocNodeOptions extends TocNodeAttrs {
+    /**
+     * HTML attributes to add to the TOC node element
+     * @default {}
+     * @example { class: 'foo' }
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        tocNode: {
+            /**
+             * Insert a table of contents node.
+             *
+             * Example:
+             * editor.commands.insertTocNode({ maxShowCount: 10 })
+             */
+            insertTocNode: (attrs?: TocNodeAttrs) => ReturnType;
+        };
+    }
+}
+/**
+ * A Tiptap node extension that creates a table of contents node.
+ * @see registry/tiptap-node/toc-node/toc-node-component
+ */
+export declare const TocNode: Node<TocNodeOptions, any>;
+export default TocNode;

package/dist/components/tiptap-node/toc-node/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./extensions/toc-node-extension";
+export * from "./ui/toc-sidebar";
+export * from "./ui/toc-show-title-button";

package/dist/components/tiptap-node/toc-node/toc-node.d.ts

@@ -0,0 +1,4 @@
+import type { NodeViewProps } from "@tiptap/react";
+import "./toc-node.css";
+export declare function TocNodeComponent(props: NodeViewProps): import("react").JSX.Element;
+export default TocNodeComponent;

package/dist/components/tiptap-node/toc-node/ui/toc-show-title-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./toc-show-title";
+export * from "./toc-show-title-button";

package/dist/components/tiptap-node/toc-node/ui/toc-show-title-button/toc-show-title-button.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { UseTocShowTitleConfig } from "@/components/tiptap-node/toc-node/ui/toc-show-title-button/toc-show-title";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface TocShowTitleButtonProps extends Omit<ButtonProps, "type" | "onToggle">, UseTocShowTitleConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for toggling TOC title in a Tiptap editor.
+ * Only appears when a TOC node is selected in the editor.
+ *
+ * For custom button implementations, use the `useTocShowTitle` hook instead.
+ */
+export declare const TocShowTitleButton: React.ForwardRefExoticComponent<TocShowTitleButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-node/toc-node/ui/toc-show-title-button/toc-show-title.d.ts

@@ -0,0 +1,83 @@
+import { type Editor } from "@tiptap/react";
+/**
+ * Configuration for the TOC show title functionality
+ */
+export interface UseTocShowTitleConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether the button should hide when title toggle is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful title toggle.
+     */
+    onToggle?: () => void;
+}
+/**
+ * Checks if TOC title can be toggled in the current editor state
+ */
+export declare function canToggleTocTitle(editor: Editor | null): boolean;
+/**
+ * Checks if the currently selected TOC node has title enabled
+ */
+export declare function isTocTitleActive(editor: Editor | null): boolean;
+/**
+ * Toggles the TOC title in the editor
+ */
+export declare function toggleTocTitle(editor: Editor | null): boolean;
+/**
+ * Determines if the TOC show title button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides TOC show title functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyTocShowTitleButton() {
+ *   const { isVisible, handleToggle } = useTocShowTitle()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleToggle}>Toggle Title</button>
+ * }
+ *
+ * // Advanced usage
+ * function MyAdvancedTocShowTitleButton() {
+ *   const { isVisible, handleToggle, label, canToggle, isActive } = useTocShowTitle({
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onToggle: () => console.log('Title toggled!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleToggle}
+ *       disabled={!canToggle}
+ *       aria-label={label}
+ *       data-active={isActive}
+ *     >
+ *       Toggle Title
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTocShowTitle(config?: UseTocShowTitleConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    canToggle: boolean;
+    handleToggle: () => boolean;
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-node/toc-node/ui/toc-sidebar/index.d.ts

@@ -0,0 +1 @@
+export * from "./toc-sidebar";