cvnert-editor 0.1.0

package/dist/components/tiptap-ui/duplicate-button/use-duplicate.d.ts

@@ -0,0 +1,78 @@
+import { type Editor } from "@tiptap/react";
+export declare const DUPLICATE_SHORTCUT_KEY = "mod+d";
+/**
+ * Configuration for the duplicate functionality
+ */
+export interface UseDuplicateConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether the button should hide when duplication is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful duplication.
+     */
+    onDuplicated?: () => void;
+}
+/**
+ * Checks if a node can be duplicated in the current editor state
+ */
+export declare function canDuplicateNode(editor: Editor | null): boolean;
+/**
+ * Duplicates a node in the editor
+ */
+export declare function duplicateNode(editor: Editor | null): boolean;
+/**
+ * Determines if the duplicate button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides duplicate functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage - no params needed
+ * function MySimpleDuplicateButton() {
+ *   const { isVisible, handleDuplicate } = useDuplicate()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleDuplicate}>Duplicate</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedDuplicateButton() {
+ *   const { isVisible, handleDuplicate, label } = useDuplicate({
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onDuplicated: () => console.log('Node duplicated!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleDuplicate}
+ *       aria-label={label}
+ *     >
+ *       Duplicate Node
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useDuplicate(config?: UseDuplicateConfig): {
+    isVisible: boolean;
+    handleDuplicate: () => boolean;
+    canDuplicate: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/emoji-dropdown-menu/emoji-dropdown-menu.d.ts

@@ -0,0 +1,3 @@
+import type { SuggestionMenuProps } from "@/components/tiptap-ui-utils/suggestion-menu";
+export type EmojiDropdownMenuProps = Omit<SuggestionMenuProps, "items" | "children">;
+export declare const EmojiDropdownMenu: (props: EmojiDropdownMenuProps) => import("react").JSX.Element;

package/dist/components/tiptap-ui/emoji-dropdown-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./emoji-dropdown-menu";

package/dist/components/tiptap-ui/emoji-menu/emoji-menu-utils.d.ts

@@ -0,0 +1,6 @@
+import type { EmojiItem } from "@tiptap/extension-emoji";
+export declare const searchEmojiData: <T extends EmojiItem>(query: string, emojiData: T) => boolean;
+export declare const getFilteredEmojis: <T extends EmojiItem>(props: {
+    query: string;
+    emojis: T[];
+}) => T[];

package/dist/components/tiptap-ui/emoji-menu/emoji-menu.d.ts

@@ -0,0 +1,18 @@
+import type { EmojiItem } from "@tiptap/extension-emoji";
+import "@/components/tiptap-ui/emoji-menu/emoji-menu.css";
+export interface EmojiMenuItemProps<T extends EmojiItem> {
+    emoji: T;
+    index: number;
+    isSelected: boolean;
+    onSelect: (emoji: T) => void;
+    selector: string;
+}
+export declare const EmojiMenuItem: <T extends EmojiItem>(props: EmojiMenuItemProps<T>) => import("react").JSX.Element | null;
+export interface EmojiMenuProps<T extends EmojiItem> {
+    emojis: T[];
+    onSelect: (emoji: T) => void;
+    onClose?: () => void;
+    showSearch?: boolean;
+    selector?: string;
+}
+export declare const EmojiMenu: <T extends EmojiItem>(props: EmojiMenuProps<T>) => import("react").JSX.Element;

package/dist/components/tiptap-ui/emoji-menu/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./emoji-menu";
+export * from "./emoji-menu-utils";

package/dist/components/tiptap-ui/emoji-trigger-button/emoji-trigger-button.d.ts

@@ -0,0 +1,22 @@
+import type { UseEmojiTriggerConfig } from "@/components/tiptap-ui/emoji-trigger-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface EmojiTriggerButtonProps extends Omit<ButtonProps, "type">, UseEmojiTriggerConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function EmojiTriggerShortcutBadge({ shortcutKeys, }: {
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for adding emoji trigger in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useEmojiTrigger` hook instead.
+ */
+export declare const EmojiTriggerButton: import("react").ForwardRefExoticComponent<EmojiTriggerButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/emoji-trigger-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./emoji-trigger-button";
+export * from "./use-emoji-trigger";

package/dist/components/tiptap-ui/emoji-trigger-button/use-emoji-trigger.d.ts

@@ -0,0 +1,94 @@
+import { type Editor } from "@tiptap/react";
+import type { Node } from "@tiptap/pm/model";
+export declare const EMOJI_TRIGGER_SHORTCUT_KEY = "mod+shift+e";
+/**
+ * Configuration for the emoji trigger functionality
+ */
+export interface UseEmojiTriggerConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Optional node to insert trigger after.
+     */
+    node?: Node | null;
+    /**
+     * Optional position of the node to insert trigger after.
+     */
+    nodePos?: number | null;
+    /**
+     * The trigger text to insert.
+     * @default ":"
+     */
+    trigger?: string;
+    /**
+     * Whether the button should hide when trigger insertion is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful trigger insertion.
+     */
+    onTriggerApplied?: (trigger: string) => void;
+}
+/**
+ * Checks if emoji trigger can be added in the current editor state
+ */
+export declare function canAddEmojiTrigger(editor: Editor | null): boolean;
+/**
+ * Adds an emoji trigger at the current selection or specified node position
+ */
+export declare function addEmojiTrigger(editor: Editor | null, trigger?: string, node?: Node | null, nodePos?: number | null): boolean;
+/**
+ * Determines if the emoji trigger button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides emoji trigger functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage - no params needed
+ * function MySimpleEmojiTriggerButton() {
+ *   const { isVisible, handleAddTrigger } = useEmojiTrigger()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleAddTrigger}>Add Emoji</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedEmojiTriggerButton() {
+ *   const { isVisible, handleAddTrigger, label } = useEmojiTrigger({
+ *     editor: myEditor,
+ *     trigger: "::",
+ *     hideWhenUnavailable: true,
+ *     onTriggerApplied: (trigger) => console.log('Trigger added:', trigger)
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleAddTrigger}
+ *       aria-label={label}
+ *     >
+ *       Add Emoji Trigger
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useEmojiTrigger(config?: UseEmojiTriggerConfig): {
+    isVisible: boolean;
+    handleAddTrigger: () => boolean;
+    canAddTrigger: boolean;
+    label: string;
+    shortcutKeys: string;
+    trigger: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/heading-button/heading-button.d.ts

@@ -0,0 +1,23 @@
+import type { Level, UseHeadingConfig } from "@/components/tiptap-ui/heading-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface HeadingButtonProps extends Omit<ButtonProps, "type">, UseHeadingConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function HeadingShortcutBadge({ level, shortcutKeys, }: {
+    level: Level;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for toggling heading in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useHeading` hook instead.
+ */
+export declare const HeadingButton: import("react").ForwardRefExoticComponent<HeadingButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/heading-button/index.d.ts

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

package/dist/components/tiptap-ui/heading-button/use-heading.d.ts

@@ -0,0 +1,108 @@
+import { type Editor } from "@tiptap/react";
+export type Level = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Configuration for the heading functionality
+ */
+export interface UseHeadingConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The heading level.
+     */
+    level: Level;
+    /**
+     * Whether the button should hide when heading is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful heading toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const headingIcons: {
+    1: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    2: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    3: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    4: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    5: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    6: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+export declare const HEADING_SHORTCUT_KEYS: Record<Level, string>;
+/**
+ * Checks if heading can be toggled in the current editor state
+ */
+export declare function canToggle(editor: Editor | null, level?: Level, turnInto?: boolean): boolean;
+/**
+ * Checks if heading is currently active
+ */
+export declare function isHeadingActive(editor: Editor | null, level?: Level | Level[]): boolean;
+/**
+ * Toggles heading in the editor
+ */
+export declare function toggleHeading(editor: Editor | null, level: Level | Level[]): boolean;
+/**
+ * Determines if the heading button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    level?: Level | Level[];
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides heading functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleHeadingButton() {
+ *   const { isVisible, isActive, handleToggle, Icon } = useHeading({ level: 1 })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <button
+ *       onClick={handleToggle}
+ *       aria-pressed={isActive}
+ *     >
+ *       <Icon />
+ *       Heading 1
+ *     </button>
+ *   )
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedHeadingButton() {
+ *   const { isVisible, isActive, handleToggle, label, Icon } = useHeading({
+ *     level: 2,
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onToggled: (isActive) => console.log('Heading toggled:', isActive)
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleToggle}
+ *       aria-label={label}
+ *       aria-pressed={isActive}
+ *     >
+ *       <Icon />
+ *       Toggle Heading 2
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useHeading(config: UseHeadingConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleToggle: () => boolean;
+    canToggle: boolean;
+    label: string;
+    shortcutKeys: 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> | 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-ui/image-align-button/image-align-button.d.ts

@@ -0,0 +1,23 @@
+import type { ImageAlign, UseImageAlignConfig } from "@/components/tiptap-ui/image-align-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface ImageAlignButtonProps extends Omit<ButtonProps, "type">, UseImageAlignConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function ImageAlignShortcutBadge({ align, shortcutKeys, }: {
+    align: ImageAlign;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for setting image alignment in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useImageAlign` hook instead.
+ */
+export declare const ImageAlignButton: import("react").ForwardRefExoticComponent<ImageAlignButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/image-align-button/index.d.ts

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

package/dist/components/tiptap-ui/image-align-button/use-image-align.d.ts

@@ -0,0 +1,110 @@
+import { type Editor } from "@tiptap/react";
+export type ImageAlign = "left" | "center" | "right";
+/**
+ * Configuration for the image align functionality
+ */
+export interface UseImageAlignConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The image alignment to apply.
+     */
+    align: ImageAlign;
+    /**
+     * The name of the image extension to target.
+     * @default "image"
+     */
+    extensionName?: string;
+    /**
+     * The attribute name used for alignment.
+     * @default "data-align"
+     */
+    attributeName?: string;
+    /**
+     * Whether the button should hide when alignment is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful alignment change.
+     */
+    onAligned?: () => void;
+}
+export declare const IMAGE_ALIGN_SHORTCUT_KEYS: Record<ImageAlign, string>;
+export declare const imageAlignIcons: {
+    left: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    center: 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>;
+};
+export declare const imageAlignLabels: Record<ImageAlign, string>;
+/**
+ * Checks if image alignment can be performed in the current editor state
+ */
+export declare function canSetImageAlign(editor: Editor | null, align: ImageAlign, extensionName?: string, attributeName?: string): boolean;
+/**
+ * Checks if the image alignment is currently active
+ */
+export declare function isImageAlignActive(editor: Editor | null, align: ImageAlign, extensionName?: string, attributeName?: string): boolean;
+/**
+ * Sets image alignment in the editor
+ */
+export declare function setImageAlign(editor: Editor | null, align: ImageAlign, extensionName?: string, attributeName?: string): boolean;
+/**
+ * Determines if the image align button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    align: ImageAlign;
+    extensionName?: string;
+    attributeName?: string;
+}): boolean;
+/**
+ * Custom hook that provides image align functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage with default "image" extension
+ * function MySimpleImageAlignButton() {
+ *   const { isVisible, handleImageAlign } = useImageAlign({ align: "center" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleImageAlign}>Align Center</button>
+ * }
+ *
+ * // Advanced usage with custom extension name
+ * function MyAdvancedImageAlignButton() {
+ *   const { isVisible, handleImageAlign, label, isActive } = useImageAlign({
+ *     editor: myEditor,
+ *     align: "right",
+ *     extensionName: "myCustomImage", // Use your custom extension name
+ *     hideWhenUnavailable: true,
+ *     onAligned: () => console.log('Image aligned!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleImageAlign}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Align Right
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useImageAlign(config: UseImageAlignConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleImageAlign: () => boolean;
+    canAlign: boolean;
+    label: string;
+    shortcutKeys: 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>;
+};

package/dist/components/tiptap-ui/image-caption-button/image-caption-button.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { UseImageCaptionConfig } from "@/components/tiptap-ui/image-caption-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface ImageCaptionButtonProps extends Omit<ButtonProps, "type">, UseImageCaptionConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+}
+/**
+ * Button component for toggling image captions in a Tiptap editor.
+ * Only appears when an image is selected in the editor.
+ *
+ * For custom button implementations, use the `useImageCaption` hook instead.
+ */
+export declare const ImageCaptionButton: React.ForwardRefExoticComponent<ImageCaptionButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/image-caption-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./image-caption-button";
+export * from "./use-image-caption";

package/dist/components/tiptap-ui/image-caption-button/use-image-caption.d.ts

@@ -0,0 +1,82 @@
+import { type Editor } from "@tiptap/react";
+/**
+ * Configuration for the image caption functionality
+ */
+export interface UseImageCaptionConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether the button should hide when caption toggle is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful caption set.
+     */
+    onSet?: () => void;
+}
+/**
+ * Checks if image caption can be toggled in the current editor state
+ */
+export declare function canToggleImageCaption(editor: Editor | null): boolean;
+/**
+ * Checks if the currently selected image has caption enabled
+ */
+export declare function isImageCaptionActive(editor: Editor | null): boolean;
+/**
+ * Toggles the image caption in the editor
+ */
+export declare function setImageCaption(editor: Editor | null): boolean;
+/**
+ * Determines if the image caption button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides image caption functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyImageCaptionButton() {
+ *   const { isVisible, handleSetCaption } = useImageCaption()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleSetCaption}>Add Caption</button>
+ * }
+ *
+ * // Advanced usage
+ * function MyAdvancedImageCaptionButton() {
+ *   const { isVisible, handleSetCaption, label, canToggle } = useImageCaption({
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onSet: () => console.log('Caption set!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleSetCaption}
+ *       disabled={!canToggle}
+ *       aria-label={label}
+ *     >
+ *       Add Caption
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useImageCaption(config?: UseImageCaptionConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    canToggle: boolean;
+    handleSetCaption: () => boolean;
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui/image-download-button/image-download-button.d.ts

@@ -0,0 +1,23 @@
+import type { UseImageDownloadConfig } from "@/components/tiptap-ui/image-download-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface ImageDownloadButtonProps extends Omit<ButtonProps, "type">, UseImageDownloadConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function ImageDownloadShortcutBadge({ shortcutKeys, }: {
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for downloading images from a Tiptap editor.
+ * Only appears when an image is selected in the editor.
+ *
+ * For custom button implementations, use the `useImageDownload` hook instead.
+ */
+export declare const ImageDownloadButton: import("react").ForwardRefExoticComponent<ImageDownloadButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/image-download-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./image-download-button";
+export * from "./use-image-download";