cvnert-editor 0.1.0

package/dist/hooks/use-composed-ref.d.ts

@@ -0,0 +1,3 @@
+type UserRef<T> = ((instance: T | null) => void) | React.RefObject<T | null> | null | undefined;
+export declare const useComposedRef: <T extends HTMLElement>(libRef: React.RefObject<T | null>, userRef: UserRef<T>) => (instance: T | null) => void;
+export default useComposedRef;

package/dist/hooks/use-cursor-visibility.d.ts

@@ -0,0 +1,20 @@
+import type { Editor } from "@tiptap/react";
+export interface CursorVisibilityOptions {
+    /**
+     * The Tiptap editor instance
+     */
+    editor?: Editor | null;
+    /**
+     * Reference to the toolbar element that may obscure the cursor
+     */
+    overlayHeight?: number;
+}
+/**
+ * Custom hook that ensures the cursor remains visible when typing in a Tiptap editor.
+ * Automatically scrolls the window when the cursor would be hidden by the toolbar.
+ *
+ * @param options.editor The Tiptap editor instance
+ * @param options.overlayHeight Toolbar height to account for
+ * @returns The bounding rect of the body
+ */
+export declare function useCursorVisibility({ editor, overlayHeight, }: CursorVisibilityOptions): import("@/hooks/use-element-rect").RectState;

package/dist/hooks/use-element-rect.d.ts

@@ -0,0 +1,35 @@
+export type RectState = Omit<DOMRect, "toJSON">;
+export interface ElementRectOptions {
+    /**
+     * The element to track. Can be an Element, ref, or selector string.
+     * Defaults to document.body if not provided.
+     */
+    element?: Element | React.RefObject<Element> | string | null;
+    /**
+     * Whether to enable rect tracking
+     */
+    enabled?: boolean;
+    /**
+     * Throttle delay in milliseconds for rect updates
+     */
+    throttleMs?: number;
+    /**
+     * Whether to use ResizeObserver for more accurate tracking
+     */
+    useResizeObserver?: boolean;
+}
+/**
+ * Custom hook that tracks an element's bounding rectangle and updates on resize, scroll, etc.
+ *
+ * @param options Configuration options for element rect tracking
+ * @returns The current bounding rectangle of the element
+ */
+export declare function useElementRect({ element, enabled, throttleMs, useResizeObserver, }?: ElementRectOptions): RectState;
+/**
+ * Convenience hook for tracking document.body rect
+ */
+export declare function useBodyRect(options?: Omit<ElementRectOptions, "element">): RectState;
+/**
+ * Convenience hook for tracking a ref element's rect
+ */
+export declare function useRefRect<T extends Element>(ref: React.RefObject<T>, options?: Omit<ElementRectOptions, "element">): RectState;

package/dist/hooks/use-floating-element.d.ts

@@ -0,0 +1,36 @@
+import type { AutoUpdateOptions, UseDismissProps, UseFloatingOptions } from "@floating-ui/react";
+interface FloatingElementReturn {
+    /**
+     * Whether the floating element is currently mounted in the DOM.
+     */
+    isMounted: boolean;
+    /**
+     * Ref function to attach to the floating element DOM node.
+     */
+    ref: (node: HTMLElement | null) => void;
+    /**
+     * Combined styles for positioning, transitions, and z-index.
+     */
+    style: React.CSSProperties;
+    /**
+     * Returns props that should be spread onto the floating element.
+     */
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    /**
+     * Returns props that should be spread onto the reference element.
+     */
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+}
+/**
+ * Custom hook for creating and managing floating elements relative to a reference position
+ *
+ * @param show - Boolean controlling visibility of the floating element
+ * @param referencePos - DOMRect, function returning DOMRect, or null representing the position to anchor the floating element to
+ * @param zIndex - Z-index value for the floating element
+ * @param options - Additional options to pass to the underlying useFloating hook
+ * @returns Object containing properties and methods to control the floating element
+ */
+export declare function useFloatingElement(show: boolean, reference: HTMLElement | DOMRect | (() => DOMRect | null) | null, zIndex: number, options?: Partial<UseFloatingOptions & {
+    dismissOptions?: UseDismissProps;
+}>, autoUpdateOptions?: AutoUpdateOptions): FloatingElementReturn;
+export {};

package/dist/hooks/use-floating-toolbar-visibility.d.ts

@@ -0,0 +1,29 @@
+import { type Editor } from "@tiptap/react";
+export declare const HIDE_FLOATING_META = "hideFloatingToolbar";
+/**
+ * Centralizes all logic about when the floating toolbar should be hidden/shown.
+ *
+ * - Listens for transactions that carry HIDE_FLOATING_META
+ * - Clears the hide flag on common “user intent” events
+ * - Handles the “re-click on the same selected node” case
+ * - Exposes `shouldShow` so UI can just render based on it
+ * - Exposes helpers to set selections with the meta flag
+ */
+export declare function useFloatingToolbarVisibility(params: {
+    editor: Editor | null;
+    isSelectionValid: (editor: Editor, selection: Editor["state"]["selection"]) => boolean;
+    extraHideWhen?: boolean;
+}): {
+    shouldShow: boolean;
+};
+/**
+ * Programmatically select a node and hide floating for that selection
+ * @param editor
+ * @param pos
+ */
+export declare const selectNodeAndHideFloating: (editor: Editor, pos: number) => void;
+/**
+ * Mark “hide floating” on the next relevant transaction (no selection change needed)
+ * @param editor
+ */
+export declare const markHideFloatingOnNext: (editor: Editor) => void;

package/dist/hooks/use-is-breakpoint.d.ts

@@ -0,0 +1,9 @@
+type BreakpointMode = "min" | "max";
+/**
+ * Hook to detect whether the current viewport matches a given breakpoint rule.
+ * Example:
+ *   useIsBreakpoint("max", 768)   // true when width < 768
+ *   useIsBreakpoint("min", 1024)  // true when width >= 1024
+ */
+export declare function useIsBreakpoint(mode?: BreakpointMode, breakpoint?: number): boolean;
+export {};

package/dist/hooks/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,7 @@
+import { useEffect } from "react";
+/**
+ * Custom hook that uses either `useLayoutEffect` or `useEffect` based on the environment (client-side or server-side).
+ * @param {Function} effect - The effect function to be executed.
+ * @param {Array<any>} [dependencies] - An array of dependencies for the effect (optional).
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/hooks/use-menu-navigation.d.ts

@@ -0,0 +1,52 @@
+import type { Editor } from "@tiptap/react";
+type Orientation = "horizontal" | "vertical" | "both";
+interface MenuNavigationOptions<T> {
+    /**
+     * The Tiptap editor instance, if using with a Tiptap editor.
+     */
+    editor?: Editor | null;
+    /**
+     * Reference to the container element for handling keyboard events.
+     */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /**
+     * Search query that affects the selected item.
+     */
+    query?: string;
+    /**
+     * Array of items to navigate through.
+     */
+    items: T[];
+    /**
+     * Callback fired when an item is selected.
+     */
+    onSelect?: (item: T) => void;
+    /**
+     * Callback fired when the menu should close.
+     */
+    onClose?: () => void;
+    /**
+     * The navigation orientation of the menu.
+     * @default "vertical"
+     */
+    orientation?: Orientation;
+    /**
+     * Whether to automatically select the first item when the menu opens.
+     * @default true
+     */
+    autoSelectFirstItem?: boolean;
+}
+/**
+ * Hook that implements keyboard navigation for dropdown menus and command palettes.
+ *
+ * Handles arrow keys, tab, home/end, enter for selection, and escape to close.
+ * Works with both Tiptap editors and regular DOM elements.
+ *
+ * @param options - Configuration options for the menu navigation
+ * @returns Object containing the selected index and a setter function
+ */
+export declare function useMenuNavigation<T>({ editor, containerRef, query, items, onSelect, onClose, orientation, autoSelectFirstItem, }: MenuNavigationOptions<T>): {
+    selectedIndex: number | undefined;
+    setSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+};
+export {};

package/dist/hooks/use-on-click-outside.d.ts

@@ -0,0 +1,18 @@
+import type { RefObject } from "react";
+declare function useEventListener<K extends keyof MediaQueryListEventMap>(eventName: K, handler: (event: MediaQueryListEventMap[K]) => void, element: RefObject<MediaQueryList>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof HTMLElementEventMap & keyof SVGElementEventMap, T extends Element = K extends keyof HTMLElementEventMap ? HTMLDivElement : SVGElement>(eventName: K, handler: ((event: HTMLElementEventMap[K]) => void) | ((event: SVGElementEventMap[K]) => void), element: RefObject<T>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
+export { useEventListener };
+/** Supported event types. */
+type EventType = "mousedown" | "mouseup" | "touchstart" | "touchend" | "focusin" | "focusout";
+/**
+ * Custom hook that handles clicks outside a specified element.
+ * @template T - The type of the element's reference.
+ * @param {RefObject<T> | RefObject<T>[]} ref - The React ref object(s) representing the element(s) to watch for outside clicks.
+ * @param {(event: MouseEvent | TouchEvent | FocusEvent) => void} handler - The callback function to be executed when a click outside the element occurs.
+ * @param {EventType} [eventType] - The mouse event type to listen for (optional, default is 'mousedown').
+ * @param {?AddEventListenerOptions} [eventListenerOptions] - The options object to be passed to the `addEventListener` method (optional).
+ * @returns {void}
+ */
+export declare function useOnClickOutside<T extends HTMLElement | null = HTMLElement>(ref: RefObject<T> | RefObject<T>[], handler: (event: MouseEvent | TouchEvent | FocusEvent) => void, eventType?: EventType, eventListenerOptions?: AddEventListenerOptions): void;

package/dist/hooks/use-throttled-callback.d.ts

@@ -0,0 +1,18 @@
+interface ThrottleSettings {
+    leading?: boolean | undefined;
+    trailing?: boolean | undefined;
+}
+/**
+ * A hook that returns a throttled callback function.
+ *
+ * @param fn The function to throttle
+ * @param wait The time in ms to wait before calling the function
+ * @param dependencies The dependencies to watch for changes
+ * @param options The throttle options
+ */
+export declare function useThrottledCallback<T extends (...args: any[]) => any>(fn: T, wait?: number, dependencies?: React.DependencyList, options?: ThrottleSettings): {
+    (this: ThisParameterType<T>, ...args: Parameters<T>): ReturnType<T>;
+    cancel: () => void;
+    flush: () => void;
+};
+export default useThrottledCallback;

package/dist/hooks/use-tiptap-editor.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "@tiptap/react";
+export declare function useTiptapEditor(providedEditor?: Editor | null): {
+    editor: Editor | null;
+    editorState?: Editor["state"];
+    canCommand?: Editor["can"];
+};

package/dist/hooks/use-ui-editor-state.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from "@tiptap/react";
+import { type UiState } from "@/components/tiptap-extension/ui-state-extension";
+export declare function useUiEditorState(editor: Editor | null): UiState;
+export default useUiEditorState;

package/dist/hooks/use-unmount.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook that executes a callback when the component unmounts.
+ *
+ * @param callback Function to be called on component unmount
+ */
+export declare const useUnmount: (callback: (...args: Array<any>) => any) => void;
+export default useUnmount;

package/dist/hooks/use-window-size.d.ts

@@ -0,0 +1,35 @@
+export interface WindowSizeState {
+    /**
+     * The width of the window's visual viewport in pixels.
+     */
+    width: number;
+    /**
+     * The height of the window's visual viewport in pixels.
+     */
+    height: number;
+    /**
+     * The distance from the top of the visual viewport to the top of the layout viewport.
+     * Particularly useful for handling mobile keyboard appearance.
+     */
+    offsetTop: number;
+    /**
+     * The distance from the left of the visual viewport to the left of the layout viewport.
+     */
+    offsetLeft: number;
+    /**
+     * The scale factor of the visual viewport.
+     * This is useful for scaling elements based on the current zoom level.
+     */
+    scale: number;
+}
+/**
+ * Hook that tracks the window's visual viewport dimensions, position, and provides
+ * a CSS transform for positioning elements.
+ *
+ * Uses the Visual Viewport API to get accurate measurements, especially important
+ * for mobile devices where virtual keyboards can change the visible area.
+ * Only updates state when values actually change to optimize performance.
+ *
+ * @returns An object containing viewport properties and a CSS transform string
+ */
+export declare function useWindowSize(): WindowSizeState;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import "./style.css";
+export { OmniboxEditor, } from "./components/tiptap-templates/omnibox/omnibox-editor";
+export type { EditorProviderProps, OmniboxEditorProps, OmniboxEditorUpdatePayload, UploadFunction, } from "./types";

package/dist/lib/tiptap-advanced-utils.d.ts

@@ -0,0 +1,120 @@
+import type { Attrs, Node } from "@tiptap/pm/model";
+import { type Editor } from "@tiptap/react";
+/**
+ * Splits an array into chunks of specified size
+ */
+export declare function chunkArray<T>(array: Array<T>, size: number): Array<Array<T>>;
+/**
+ * Helper function to check if there's content above the current position
+ */
+export declare function hasContentAbove(editor: Editor | null): {
+    hasContent: boolean;
+    content: string;
+};
+/**
+ * Gets the active attributes of a specific mark in the current editor selection.
+ *
+ * @param editor - The Tiptap editor instance.
+ * @param markName - The name of the mark to look for (e.g., "highlight", "link").
+ * @returns The attributes of the active mark, or `null` if the mark is not active.
+ */
+export declare function getActiveMarkAttrs(editor: Editor | null, markName: string): Attrs | null;
+/**
+ * Finds the position of a node in the editor selection
+ * @param params Object containing editor, node (optional), and nodePos (optional)
+ * @returns The position of the node in the selection or null if not found
+ */
+export declare function findSelectionPosition(params: {
+    editor: Editor;
+    node?: Node | null;
+    nodePos?: number | null;
+}): number | null;
+/**
+ * Gets the currently selected DOM element in the editor
+ * @param editor The Tiptap editor instance
+ * @returns The selected DOM element or null if no selection is present
+ */
+export declare function getSelectedDOMElement(editor: Editor): HTMLElement | null;
+/**
+ * Gets the closest node from the current selection in the editor based on criteria
+ * @param editor The Tiptap editor instance
+ * @param options Configuration options for finding the node
+ * @returns An object containing the closest matching node, its position, and depth, or null if not found
+ */
+export declare function getClosestNode(editor: Editor | null, options?: {
+    nodeName?: string;
+    isBlock?: boolean;
+    predicate?: (node: Node) => boolean;
+}): {
+    node: Node;
+    pos: number;
+    depth: number;
+} | null;
+/**
+ * Gets the closest node from a specific position in the document
+ * @param editor The Tiptap editor instance
+ * @param pos The position to search from
+ * @param options Configuration options for finding the node
+ * @returns An object containing the closest matching node, its position, and depth, or null if not found
+ */
+export declare function getClosestNodeByPos(editor: Editor | null, pos: number, options?: {
+    nodeName?: string;
+    isBlock?: boolean;
+    predicate?: (node: Node) => boolean;
+}): {
+    node: Node;
+    pos: number;
+    depth: number;
+} | null;
+/**
+ * Convenience function to find closest block node (maintains backward compatibility)
+ */
+export declare function getClosestBlockNode(editor: Editor | null): {
+    node: Node;
+    pos: number;
+    depth: number;
+} | null;
+/**
+ * Convenience function to find closest node by name
+ */
+export declare function getClosestNodeByName(editor: Editor | null, nodeName: string): {
+    node: Node;
+    pos: number;
+    depth: number;
+} | null;
+/**
+ * Find multiple matching nodes up the tree
+ */
+export declare function getAllMatchingNodes(editor: Editor | null, options?: {
+    nodeName?: string;
+    isBlock?: boolean;
+    predicate?: (node: Node) => boolean;
+}): {
+    node: Node;
+    pos: number;
+    depth: number;
+}[];
+/**
+ * Gets the anchor node and its position in the editor.
+ * @param editor The Tiptap editor instance
+ * @param allowEmptySelection If true, still returns the node at the cursor position even if selection is empty
+ * @returns An object containing the anchor node and its position, or null if not found
+ */
+export declare function getAnchorNodeAndPos(editor: Editor | null, allowEmptySelection?: boolean): {
+    node: Node;
+    pos: number;
+} | null;
+/**
+ * Checks if the current selection in the editor contains any text.
+ *
+ * @param editor - The Tiptap editor instance.
+ * @returns `true` if the selection contains text, `false` otherwise.
+ */
+export declare function selectionHasText(editor: Editor | null): boolean;
+/**
+ * Retrieves a specific extension by name from the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionName - The name of the extension to retrieve
+ * @returns The extension instance if found, otherwise null
+ */
+export declare function getEditorExtension(editor: Editor | null, extensionName: string): import("@tiptap/core").AnyExtension | null;

package/dist/lib/tiptap-collab-utils.d.ts

@@ -0,0 +1,46 @@
+import { type Selection } from "@tiptap/pm/state";
+import type { JSONContent, Editor } from "@tiptap/react";
+export type OverflowPosition = "none" | "top" | "bottom" | "both";
+/**
+ * Returns a display name for the current node in the editor
+ * @param editor The Tiptap editor instance
+ * @returns The display name of the current node
+ */
+export declare const getNodeDisplayName: (editor: Editor | null) => string;
+/**
+ * Removes empty paragraph nodes from content
+ */
+export declare const removeEmptyParagraphs: (content: JSONContent) => {
+    content: JSONContent[] | undefined;
+    type?: string;
+    attrs?: Record<string, any> | undefined;
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+        [key: string]: any;
+    }[];
+    text?: string;
+};
+/**
+ * Determines how a target element overflows relative to a container element
+ */
+export declare function getElementOverflowPosition(targetElement: Element, containerElement: HTMLElement): OverflowPosition;
+/**
+ * Checks if the current selection is valid for a given editor
+ */
+export declare const isSelectionValid: (editor: Editor | null, selection?: Selection, excludedNodeTypes?: string[]) => boolean;
+/**
+ * Checks if the current text selection is valid for editing
+ * - Not empty
+ * - Not a code block
+ * - Not a node selection
+ */
+export declare const isTextSelectionValid: (editor: Editor | null) => boolean;
+/**
+ * Gets the bounding rect of the current selection in the editor.
+ */
+export declare const getSelectionBoundingRect: (editor: Editor) => DOMRect | null;
+/**
+ * Generates a deterministic avatar URL from a user name
+ */
+export declare const getAvatar: (name: string) => string;

package/dist/lib/tiptap-utils.d.ts

@@ -0,0 +1,174 @@
+import type { Node as PMNode } from "@tiptap/pm/model";
+import type { Transaction } from "@tiptap/pm/state";
+import { type ClassValue } from "clsx";
+import { Selection } from "@tiptap/pm/state";
+import { type Editor, type NodeWithPos } from "@tiptap/react";
+export declare const MAX_FILE_SIZE: number;
+export declare const MAC_SYMBOLS: Record<string, string>;
+export declare const SR_ONLY: {
+    readonly position: "absolute";
+    readonly width: "1px";
+    readonly height: "1px";
+    readonly padding: 0;
+    readonly margin: "-1px";
+    readonly overflow: "hidden";
+    readonly clip: "rect(0, 0, 0, 0)";
+    readonly whiteSpace: "nowrap";
+    readonly borderWidth: 0;
+};
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMac - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export declare const formatShortcutKey: (key: string, isMac: boolean, capitalize?: boolean) => string;
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "-")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export declare const parseShortcutKeys: (props: {
+    shortcutKeys: string | undefined;
+    delimiter?: string;
+    capitalize?: boolean;
+}) => string[];
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export declare const isMarkInSchema: (markName: string, editor: Editor | null) => boolean;
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export declare const isNodeInSchema: (nodeName: string, editor: Editor | null) => boolean;
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export declare function focusNextNode(editor: Editor): boolean;
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export declare function isValidPosition(pos: number | null | undefined): pos is number;
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export declare function isExtensionAvailable(editor: Editor | null, extensionNames: string | string[]): boolean;
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export declare function findNodeAtPosition(editor: Editor, position: number): PMNode | null;
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export declare function findNodePosition(props: {
+    editor: Editor | null;
+    node?: PMNode | null;
+    nodePos?: number | null;
+}): {
+    pos: number;
+    node: PMNode;
+} | null;
+/**
+ * Determines whether the current selection contains a node whose type matches
+ * any of the provided node type names.
+ * @param editor Tiptap editor instance
+ * @param nodeTypeNames List of node type names to match against
+ * @param checkAncestorNodes Whether to check ancestor node types up the depth chain
+ */
+export declare function isNodeTypeSelected(editor: Editor | null, nodeTypeNames?: string[], checkAncestorNodes?: boolean): boolean;
+/**
+ * Check whether the current selection is fully within nodes
+ * whose type names are in the provided `types` list.
+ *
+ * - NodeSelection → checks the selected node.
+ * - Text/AllSelection → ensures all textblocks within [from, to) are allowed.
+ */
+export declare function selectionWithinConvertibleTypes(editor: Editor, types?: string[]): boolean;
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+export declare const handleImageUpload: (file: File, onProgress?: (event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+export declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+export declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+/**
+ * Update a single attribute on multiple nodes.
+ *
+ * @param tr - The transaction to mutate
+ * @param targets - Array of { node, pos }
+ * @param attrName - Attribute key to update
+ * @param next - New value OR updater function receiving previous value
+ *               Pass `undefined` to remove the attribute.
+ * @returns true if at least one node was updated, false otherwise
+ */
+export declare function updateNodesAttr<A extends string = string, V = unknown>(tr: Transaction, targets: readonly NodeWithPos[], attrName: A, next: V | ((prev: V | undefined) => V | undefined)): boolean;
+/**
+ * Selects the entire content of the current block node if the selection is empty.
+ * If the selection is not empty, it does nothing.
+ * @param editor The Tiptap editor instance
+ */
+export declare function selectCurrentBlockContent(editor: Editor): void;
+/**
+ * Retrieves all nodes of specified types from the current selection.
+ * @param selection The current editor selection
+ * @param allowedNodeTypes An array of node type names to look for (e.g., ["image", "table"])
+ * @returns An array of objects containing the node and its position
+ */
+export declare function getSelectedNodesOfType(selection: Selection, allowedNodeTypes: string[]): NodeWithPos[];
+/**
+ * Clamps a value between min and max bounds
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function getSelectedBlockNodes(editor: Editor): PMNode[];
+export {};