@import-ai/omnibox-editor 0.0.1

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

@@ -0,0 +1,86 @@
+import type { UseFloatingOptions } from "@floating-ui/react";
+import type { PluginKey } from "@tiptap/pm/state";
+import type { SuggestionOptions } from "@tiptap/suggestion";
+import type { Editor, Range } from "@tiptap/react";
+type DefaultContext = any;
+type IconProps = React.SVGProps<SVGSVGElement>;
+type IconComponent = ({ className, ...props }: IconProps) => React.ReactElement;
+export interface SuggestionItem<T = DefaultContext> {
+    /**
+     * The main text to display for the suggestion.
+     */
+    title: string;
+    /**
+     * Secondary text to provide additional context.
+     */
+    subtext?: string;
+    /**
+     * Icon or badge to display alongside the suggestion.
+     */
+    badge?: React.MemoExoticComponent<IconComponent> | React.FC<IconProps> | string;
+    /**
+     * Group identifier for organizing suggestions.
+     */
+    group?: string;
+    /**
+     * Additional keywords for filtering suggestions.
+     */
+    keywords?: string[];
+    /**
+     * Custom data to pass to the onSelect handler.
+     */
+    context?: T;
+    /**
+     * Callback executed when this suggestion is selected.
+     */
+    onSelect: (props: {
+        editor: Editor;
+        range: Range;
+        context?: T;
+    }) => void;
+}
+export type SuggestionMenuRenderProps<T = DefaultContext> = {
+    /**
+     * List of suggestion items to display.
+     */
+    items: SuggestionItem<T>[];
+    /**
+     * Index of the currently selected item.
+     */
+    selectedIndex?: number;
+    /**
+     * Callback to select an item.
+     */
+    onSelect: (item: SuggestionItem<T>) => void;
+};
+export interface SuggestionMenuProps<T = DefaultContext> extends Omit<SuggestionOptions<SuggestionItem<T>>, "pluginKey" | "editor"> {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * Additional options for the floating UI.
+     */
+    floatingOptions?: Partial<UseFloatingOptions>;
+    /**
+     * CSS selector attribute for targeting the menu.
+     * @default 'tiptap-suggestion-menu'
+     */
+    selector?: string;
+    /**
+     * Unique key for the suggestion plugin.
+     * @default SuggestionPluginKey
+     */
+    pluginKey?: string | PluginKey;
+    /**
+     * Maximum height of the suggestion menu.
+     * If provided, the menu will scroll if content exceeds this height.
+     * @default 384
+     */
+    maxHeight?: number;
+    /**
+     * Render function for the menu content.
+     */
+    children: (props: SuggestionMenuRenderProps<T>) => React.ReactNode;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { Node } from "@tiptap/pm/model";
+import type { SuggestionItem } from "@/components/tiptap-ui-utils/suggestion-menu/suggestion-menu-types";
+/**
+ * Calculates the start position of a suggestion command in the text.
+ *
+ * @param cursorPosition Current cursor position
+ * @param previousNode Node before the cursor
+ * @param triggerChar Character that triggers the suggestion
+ * @returns The position where the command starts
+ */
+export declare function calculateStartPosition(cursorPosition: number, previousNode: Node | null, triggerChar?: string): number;
+/**
+ * Filters and sorts suggestion items based on a search query.
+ *
+ * @param items List of suggestion items to filter
+ * @param query Search query string
+ * @returns Filtered and sorted list of suggestions
+ */
+export declare function filterSuggestionItems(items: SuggestionItem[], query: string): SuggestionItem<any>[];

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

@@ -0,0 +1,6 @@
+import type { SuggestionMenuProps } from "@/components/tiptap-ui-utils/suggestion-menu/suggestion-menu-types";
+/**
+ * A component that renders a suggestion menu for Tiptap editors.
+ * Displays a floating menu when a trigger character is typed.
+ */
+export declare const SuggestionMenu: ({ editor: providedEditor, floatingOptions, selector, children, maxHeight, pluginKey, ...internalSuggestionProps }: SuggestionMenuProps) => import("react").JSX.Element | null;

package/dist/contexts/user-context.d.ts

@@ -0,0 +1,16 @@
+import { type EditorUser } from "@/lib/editor-users";
+import type { OmniboxEditorCollaborationUser, OmniboxEditorMentionUser } from "@/types";
+export type User = EditorUser;
+export type UserContextValue = {
+    user: User;
+    mentionUsers: User[];
+    onlineUsers: User[];
+    setOnlineUsers: (users: User[]) => void;
+};
+export declare const UserContext: import("react").Context<UserContextValue>;
+export declare function UserProvider({ children, mentionUsers, user: providedUser, }: {
+    children: React.ReactNode;
+    mentionUsers?: OmniboxEditorMentionUser[];
+    user?: OmniboxEditorCollaborationUser;
+}): import("react").JSX.Element;
+export declare const useUser: () => UserContextValue;

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,7 @@
+import "./style.css";
+export { OmniboxEditor, } from "./components/tiptap-templates/omnibox/omnibox-editor";
+export { contentToMarkdown, contentToTiptapJson, htmlTableToTiptapNode, markdownWithHtmlTablesToTiptapJson, markdownToTiptapJson, tiptapJsonToMarkdown, } from "./lib/markdown";
+export { getEditorTranslations } from "./lib/i18n";
+export type { OmniboxEditorAiAction, OmniboxEditorCollaborationConfig, OmniboxEditorCollaborationProvider, OmniboxEditorCollaborationUser, OmniboxEditorMentionUser, EditorProviderProps, OmniboxEditorAiConfig, OmniboxEditorAiFeature, OmniboxEditorAiSubmitPayload, OmniboxEditorTheme, OmniboxEditorProps, OmniboxEditorUpdatePayload, UploadFunction, } from "./types";
+export type { MarkdownParseOptions, TiptapJsonContent, } from "./lib/markdown";
+export type { OmniboxEditorLocale, OmniboxEditorTranslations, } from "./lib/i18n";

package/dist/lib/clipboard.d.ts

@@ -0,0 +1,6 @@
+import type { JSONContent } from "@tiptap/core";
+import type { Slice } from "@tiptap/pm/model";
+export type TiptapClipboardJsonContent = JSONContent;
+export declare function tiptapJsonToClipboardText(json: TiptapClipboardJsonContent): string;
+export declare function clipboardSliceToTiptapJson(slice: Slice): TiptapClipboardJsonContent;
+export declare function clipboardSliceToText(slice: Slice): string;

package/dist/lib/editor-collaboration.d.ts

@@ -0,0 +1,6 @@
+import type { OmniboxEditorCollaborationConfig, OmniboxEditorCollaborationUser } from "@/types";
+export type CollaborationUser = OmniboxEditorCollaborationUser;
+export declare function isCollaborationEnabled(collaboration?: OmniboxEditorCollaborationConfig): boolean;
+export declare function shouldSyncExternalContent(collaboration?: OmniboxEditorCollaborationConfig): boolean;
+export declare function getStarterKitUndoRedo(collaboration?: OmniboxEditorCollaborationConfig): false | undefined;
+export declare function getCollaborationUser(collaboration: OmniboxEditorCollaborationConfig, fallbackUser?: OmniboxEditorCollaborationUser): CollaborationUser;

package/dist/lib/editor-content.d.ts

@@ -0,0 +1,5 @@
+import type { Content, JSONContent } from "@tiptap/core";
+import { type MarkdownParseOptions, type TiptapJsonContent } from "./markdown";
+export type ExternalEditorContent = Content | string;
+export declare function normalizeEditorContent(content: ExternalEditorContent, options?: MarkdownParseOptions): TiptapJsonContent;
+export declare function getExternalContentUpdate(previousContent: TiptapJsonContent | null, nextContent: ExternalEditorContent, options?: MarkdownParseOptions): JSONContent | null;

package/dist/lib/editor-users.d.ts

@@ -0,0 +1,27 @@
+import type { OmniboxEditorCollaborationUser, OmniboxEditorMentionUser } from "@/types";
+export type EditorUser = {
+    id: string;
+    name: string;
+    color: string;
+    avatar: string;
+    position?: string;
+};
+type StorageLike = Pick<Storage, "getItem" | "setItem">;
+export declare const FIRST_NAMES: string[];
+export declare const LAST_NAMES: string[];
+export declare const USER_COLORS: string[];
+export declare function getOrCreateEditorUser(storage?: StorageLike | null): EditorUser;
+export declare function toEditorUser(user?: OmniboxEditorCollaborationUser | OmniboxEditorMentionUser | null): EditorUser | null;
+export declare function toEditorUsers(users?: Array<OmniboxEditorCollaborationUser | OmniboxEditorMentionUser | null | undefined>): EditorUser[];
+type AwarenessUser = {
+    clientId?: number;
+    id?: unknown;
+    name?: unknown;
+    color?: unknown;
+    avatar?: unknown;
+    position?: unknown;
+};
+export declare function awarenessUserToEditorUser(user: AwarenessUser): EditorUser | null;
+export declare function dedupeEditorUsers(users: EditorUser[]): EditorUser[];
+export declare function getMentionUsers(query: string, users: EditorUser[], limit?: number): EditorUser[];
+export {};

package/dist/lib/html-table.d.ts

@@ -0,0 +1,5 @@
+import type { TiptapJsonContent } from "./markdown";
+export declare function htmlTableToTiptapNode(tableHtml: string): TiptapJsonContent | null;
+export declare function containsMergedTable(node: TiptapJsonContent): boolean;
+export declare function isMergedTable(node: TiptapJsonContent): boolean;
+export declare function tableToHtml(table: TiptapJsonContent, serializeBlockNode: (node: TiptapJsonContent) => string): string;