@wecode-team/we0-cms 1.1.32 → 1.1.34

package/dist/components/tiptap-ui/link-popover/use-link-popover.d.ts

@@ -0,0 +1,117 @@
+import type { Editor } from "@tiptap/react";
+/**
+ * Configuration for the link popover functionality
+ */
+export interface UseLinkPopoverConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Whether to hide the link popover when not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called when the link is set.
+     */
+    onSetLink?: () => void;
+}
+/**
+ * Configuration for the link handler functionality
+ */
+export interface LinkHandlerProps {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor: Editor | null;
+    /**
+     * Callback function called when the link is set.
+     */
+    onSetLink?: () => void;
+}
+/**
+ * Checks if a link can be set in the current editor state
+ */
+export declare function canSetLink(editor: Editor | null): boolean;
+/**
+ * Checks if a link is currently active in the editor
+ */
+export declare function isLinkActive(editor: Editor | null): boolean;
+/**
+ * Determines if the link button should be shown
+ */
+export declare function shouldShowLinkButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook for handling link operations in a Tiptap editor
+ */
+export declare function useLinkHandler(props: LinkHandlerProps): {
+    url: string;
+    setUrl: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setLink: () => void;
+    removeLink: () => void;
+    openLink: (target?: string, features?: string) => void;
+};
+/**
+ * Custom hook for link popover state management
+ */
+export declare function useLinkState(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): {
+    isVisible: boolean;
+    canSet: boolean;
+    isActive: boolean;
+};
+/**
+ * Main hook that provides link popover functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyLinkButton() {
+ *   const { isVisible, canSet, isActive, Icon, label } = useLinkPopover()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button disabled={!canSet}>Link</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedLinkButton() {
+ *   const { isVisible, canSet, isActive, Icon, label } = useLinkPopover({
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onSetLink: () => console.log('Link set!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       disabled={!canSet}
+ *       aria-label={label}
+ *       aria-pressed={isActive}
+ *     >
+ *       <Icon />
+ *       {label}
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useLinkPopover(config?: UseLinkPopoverConfig): {
+    url: string;
+    setUrl: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    setLink: () => void;
+    removeLink: () => void;
+    openLink: (target?: string, features?: string) => void;
+    isVisible: boolean;
+    canSet: boolean;
+    isActive: boolean;
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

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

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

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

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

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

@@ -0,0 +1,97 @@
+import { type Editor } from "@tiptap/react";
+export type ListType = "bulletList" | "orderedList" | "taskList";
+/**
+ * Configuration for the list functionality
+ */
+export interface UseListConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The type of list to toggle.
+     */
+    type: ListType;
+    /**
+     * Whether the button should hide when list is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const listIcons: {
+    bulletList: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    orderedList: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    taskList: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+export declare const listLabels: Record<ListType, string>;
+export declare const LIST_SHORTCUT_KEYS: Record<ListType, string>;
+/**
+ * Checks if a list can be toggled in the current editor state
+ */
+export declare function canToggleList(editor: Editor | null, type: ListType, turnInto?: boolean): boolean;
+/**
+ * Checks if list is currently active
+ */
+export declare function isListActive(editor: Editor | null, type: ListType): boolean;
+/**
+ * Toggles list in the editor
+ */
+export declare function toggleList(editor: Editor | null, type: ListType): boolean;
+/**
+ * Determines if the list button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    type: ListType;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Custom hook that provides list functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleListButton() {
+ *   const { isVisible, handleToggle, isActive } = useList({ type: "bulletList" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleToggle}>Bullet List</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedListButton() {
+ *   const { isVisible, handleToggle, label, isActive } = useList({
+ *     type: "orderedList",
+ *     editor: myEditor,
+ *     hideWhenUnavailable: true,
+ *     onToggled: () => console.log('List toggled!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleToggle}
+ *       aria-label={label}
+ *       aria-pressed={isActive}
+ *     >
+ *       Toggle List
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useList(config: UseListConfig): {
+    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>;
+};

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

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

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

@@ -0,0 +1,28 @@
+import { type Editor } from "@tiptap/react";
+import { type ListType } from "@/components/tiptap-ui/list-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface ListDropdownMenuProps extends Omit<ButtonProps, "type"> {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor;
+    /**
+     * The list types to display in the dropdown.
+     */
+    types?: ListType[];
+    /**
+     * Whether the dropdown should be hidden when no list types are available
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback for when the dropdown opens or closes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Whether the dropdown should use a modal
+     */
+    modal?: boolean;
+}
+export declare function ListDropdownMenu({ editor: providedEditor, types, hideWhenUnavailable, onOpenChange, modal, ...props }: ListDropdownMenuProps): import("react").JSX.Element | null;
+export default ListDropdownMenu;

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

@@ -0,0 +1,90 @@
+import type { Editor } from "@tiptap/react";
+import { type ListType } from "@/components/tiptap-ui/list-button";
+/**
+ * Configuration for the list dropdown menu functionality
+ */
+export interface UseListDropdownMenuConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The list types to display in the dropdown.
+     * @default ["bulletList", "orderedList", "taskList"]
+     */
+    types?: ListType[];
+    /**
+     * Whether the dropdown should be hidden when no list types are available
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+}
+export interface ListOption {
+    label: string;
+    type: ListType;
+    icon: React.ElementType;
+}
+export declare const listOptions: ListOption[];
+export declare function canToggleAnyList(editor: Editor | null, listTypes: ListType[]): boolean;
+export declare function isAnyListActive(editor: Editor | null, listTypes: ListType[]): boolean;
+export declare function getFilteredListOptions(availableTypes: ListType[]): typeof listOptions;
+export declare function shouldShowListDropdown(params: {
+    editor: Editor | null;
+    listTypes: ListType[];
+    hideWhenUnavailable: boolean;
+    listInSchema: boolean;
+    canToggleAny: boolean;
+}): boolean;
+/**
+ * Gets the currently active list type from the available types
+ */
+export declare function getActiveListType(editor: Editor | null, availableTypes: ListType[]): ListType | undefined;
+/**
+ * Custom hook that provides list dropdown menu functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MyListDropdown() {
+ *   const {
+ *     isVisible,
+ *     activeType,
+ *     isAnyActive,
+ *     canToggleAny,
+ *     filteredLists,
+ *   } = useListDropdownMenu()
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <DropdownMenu>
+ *       // dropdown content
+ *     </DropdownMenu>
+ *   )
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedListDropdown() {
+ *   const {
+ *     isVisible,
+ *     activeType,
+ *   } = useListDropdownMenu({
+ *     editor: myEditor,
+ *     types: ["bulletList", "orderedList"],
+ *     hideWhenUnavailable: true,
+ *   })
+ *
+ *   // component implementation
+ * }
+ * ```
+ */
+export declare function useListDropdownMenu(config?: UseListDropdownMenuConfig): {
+    isVisible: boolean;
+    activeType: ListType | undefined;
+    isActive: boolean;
+    canToggle: boolean;
+    types: ListType[];
+    filteredLists: ListOption[];
+    label: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

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

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

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

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

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

@@ -0,0 +1,104 @@
+import type { Editor } from "@tiptap/react";
+export type Mark = "bold" | "italic" | "strike" | "code" | "underline" | "superscript" | "subscript";
+/**
+ * Configuration for the mark functionality
+ */
+export interface UseMarkConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The type of mark to toggle
+     */
+    type: Mark;
+    /**
+     * Whether the button should hide when mark is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful mark toggle.
+     */
+    onToggled?: () => void;
+}
+export declare const markIcons: {
+    bold: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    italic: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    underline: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    strike: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    code: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    superscript: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    subscript: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+export declare const MARK_SHORTCUT_KEYS: Record<Mark, string>;
+/**
+ * Checks if a mark can be toggled in the current editor state
+ */
+export declare function canToggleMark(editor: Editor | null, type: Mark): boolean;
+/**
+ * Checks if a mark is currently active
+ */
+export declare function isMarkActive(editor: Editor | null, type: Mark): boolean;
+/**
+ * Toggles a mark in the editor
+ */
+export declare function toggleMark(editor: Editor | null, type: Mark): boolean;
+/**
+ * Determines if the mark button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    type: Mark;
+    hideWhenUnavailable: boolean;
+}): boolean;
+/**
+ * Gets the formatted mark name
+ */
+export declare function getFormattedMarkName(type: Mark): string;
+/**
+ * Custom hook that provides mark functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleBoldButton() {
+ *   const { isVisible, handleMark } = useMark({ type: "bold" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleMark}>Bold</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedItalicButton() {
+ *   const { isVisible, handleMark, label, isActive } = useMark({
+ *     editor: myEditor,
+ *     type: "italic",
+ *     hideWhenUnavailable: true,
+ *     onToggled: () => console.log('Mark toggled!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleMark}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Italic
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useMark(config: UseMarkConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleMark: () => 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> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

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

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

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

@@ -0,0 +1,30 @@
+import type { TextAlign, UseTextAlignConfig } from "@/components/tiptap-ui/text-align-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+type IconProps = React.SVGProps<SVGSVGElement>;
+type IconComponent = ({ className, ...props }: IconProps) => React.ReactElement;
+export interface TextAlignButtonProps extends Omit<ButtonProps, "type">, UseTextAlignConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+    /**
+     * Optional custom icon component to render instead of the default.
+     */
+    icon?: React.MemoExoticComponent<IconComponent> | React.FC<IconProps>;
+}
+export declare function TextAlignShortcutBadge({ align, shortcutKeys, }: {
+    align: TextAlign;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for setting text alignment in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useTextAlign` hook instead.
+ */
+export declare const TextAlignButton: import("react").ForwardRefExoticComponent<TextAlignButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

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

@@ -0,0 +1,102 @@
+import type { ChainedCommands } from "@tiptap/react";
+import { type Editor } from "@tiptap/react";
+export type TextAlign = "left" | "center" | "right" | "justify";
+/**
+ * Configuration for the text align functionality
+ */
+export interface UseTextAlignConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The text alignment to apply.
+     */
+    align: TextAlign;
+    /**
+     * 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 TEXT_ALIGN_SHORTCUT_KEYS: Record<TextAlign, string>;
+export declare const textAlignIcons: {
+    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>;
+    justify: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+export declare const textAlignLabels: Record<TextAlign, string>;
+/**
+ * Checks if text alignment can be performed in the current editor state
+ */
+export declare function canSetTextAlign(editor: Editor | null, align: TextAlign): boolean;
+export declare function hasSetTextAlign(commands: ChainedCommands): commands is ChainedCommands & {
+    setTextAlign: (align: TextAlign) => ChainedCommands;
+};
+/**
+ * Checks if the text alignment is currently active
+ */
+export declare function isTextAlignActive(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Sets text alignment in the editor
+ */
+export declare function setTextAlign(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Determines if the text align button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    align: TextAlign;
+}): boolean;
+/**
+ * Custom hook that provides text align functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleAlignButton() {
+ *   const { isVisible, handleTextAlign } = useTextAlign({ align: "center" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleTextAlign}>Align Center</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedAlignButton() {
+ *   const { isVisible, handleTextAlign, label, isActive } = useTextAlign({
+ *     editor: myEditor,
+ *     align: "right",
+ *     hideWhenUnavailable: true,
+ *     onAligned: () => console.log('Text aligned!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleTextAlign}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Align Right
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTextAlign(config: UseTextAlignConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleTextAlign: () => 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> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

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

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

package/dist/components/tiptap-ui/undo-redo-button/undo-redo-button.d.ts

@@ -0,0 +1,23 @@
+import type { UndoRedoAction, UseUndoRedoConfig } from "@/components/tiptap-ui/undo-redo-button";
+import type { ButtonProps } from "@/components/tiptap-ui-primitive/button";
+export interface UndoRedoButtonProps extends Omit<ButtonProps, "type">, UseUndoRedoConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function HistoryShortcutBadge({ action, shortcutKeys, }: {
+    action: UndoRedoAction;
+    shortcutKeys?: string;
+}): import("react").JSX.Element;
+/**
+ * Button component for triggering undo/redo actions in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useHistory` hook instead.
+ */
+export declare const UndoRedoButton: import("react").ForwardRefExoticComponent<UndoRedoButtonProps & import("react").RefAttributes<HTMLButtonElement>>;