@import-ai/omnibox-editor 0.0.1

package/dist/lib/i18n.d.ts

@@ -0,0 +1,170 @@
+export type OmniboxEditorLocale = "en" | "zh-CN" | (string & {});
+type OmniboxEditorTranslationMap = {
+    addCaption: string;
+    add: string;
+    ai: string;
+    aiIsWriting: string;
+    aiReviewPrompt: string;
+    aiTone: string;
+    apply: string;
+    askAi: string;
+    askAiPrompt: string;
+    askAiSubtext: string;
+    blockquote: string;
+    blockquoteBlock: string;
+    bulletList: string;
+    bold: string;
+    clearAllContents: string;
+    clickForOptions: string;
+    code: string;
+    codeBlock: string;
+    codeBlockWithSyntaxHighlighting: string;
+    color: string;
+    continueWriting: string;
+    continueWritingPrompt: string;
+    continueWritingSubtext: string;
+    copyAnchorLink: string;
+    copyToClipboard: string;
+    close: string;
+    delete: string;
+    discard: string;
+    duplicateNode: string;
+    applyFormula: string;
+    closeFormulaEditor: string;
+    editFormula: string;
+    emoji: string;
+    emojiSubtext: string;
+    failedToRenderChart: string;
+    failedToRenderDiagram: string;
+    heading: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    heading4: string;
+    heading5: string;
+    heading6: string;
+    highlightColor: string;
+    holdForDrag: string;
+    hideSource: string;
+    image: string;
+    imageSubtext: string;
+    addImage: string;
+    replaceImage: string;
+    increaseIndent: string;
+    insert: string;
+    italic: string;
+    linkEditor: string;
+    link: string;
+    listItem: string;
+    listWithOrderedItems: string;
+    listWithTasks: string;
+    listWithUnorderedItems: string;
+    loading: string;
+    mention: string;
+    mentionSubtext: string;
+    node: string;
+    orderedList: string;
+    placeholder: string;
+    pasteLink: string;
+    openLinkInNewWindow: string;
+    recentColors: string;
+    recentTextColor: string;
+    recentHighlightColor: string;
+    regularTextParagraph: string;
+    resetFormatting: string;
+    separator: string;
+    separatorSubtext: string;
+    showSource: string;
+    style: string;
+    subsectionAndGroupHeading: string;
+    table: string;
+    rowActions: string;
+    columnActions: string;
+    tableCellsOption: string;
+    insertRowAbove: string;
+    insertRowBelow: string;
+    deleteRow: string;
+    clearRowContents: string;
+    insertColumnLeft: string;
+    insertColumnRight: string;
+    duplicateRow: string;
+    duplicateColumn: string;
+    moveRowUp: string;
+    moveRowDown: string;
+    moveColumnLeft: string;
+    moveColumnRight: string;
+    sortRowAsc: string;
+    sortRowDesc: string;
+    sortColumnAsc: string;
+    sortColumnDesc: string;
+    deleteColumn: string;
+    clearColumnContents: string;
+    headerRow: string;
+    headerColumn: string;
+    mergeCells: string;
+    splitCell: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    alignTop: string;
+    alignMiddle: string;
+    alignBottom: string;
+    alignment: string;
+    backgroundColor: string;
+    defaultTextColor: string;
+    grayTextColor: string;
+    brownTextColor: string;
+    orangeTextColor: string;
+    yellowTextColor: string;
+    greenTextColor: string;
+    blueTextColor: string;
+    purpleTextColor: string;
+    pinkTextColor: string;
+    redTextColor: string;
+    defaultBackgroundColor: string;
+    grayBackgroundColor: string;
+    brownBackgroundColor: string;
+    orangeBackgroundColor: string;
+    yellowBackgroundColor: string;
+    greenBackgroundColor: string;
+    blueBackgroundColor: string;
+    purpleBackgroundColor: string;
+    pinkBackgroundColor: string;
+    redBackgroundColor: string;
+    clearContents: string;
+    fitToWidth: string;
+    deleteTable: string;
+    tableOfContents: string;
+    tableOfContentsSubtext: string;
+    tableSubtext: string;
+    taskList: string;
+    text: string;
+    textColor: string;
+    textColorOptions: string;
+    textHighlighter: string;
+    highlightColors: string;
+    removeHighlight: string;
+    moreOptions: string;
+    removeLink: string;
+    strike: string;
+    underline: string;
+    alignJustify: string;
+    applyLink: string;
+    superscript: string;
+    subscript: string;
+    decreaseIndent: string;
+    submitAiPrompt: string;
+    stopAiGeneration: string;
+    topLevelHeading: string;
+    turnInto: string;
+    turnIntoCurrent: string;
+    tryAgain: string;
+    upload: string;
+    uploadFailed: string;
+};
+export type OmniboxEditorTranslations = Partial<OmniboxEditorTranslationMap>;
+export declare function getEditorTranslations(locale?: OmniboxEditorLocale, translations?: OmniboxEditorTranslations): OmniboxEditorTranslationMap;
+export type OmniboxEditorI18n = OmniboxEditorTranslationMap;
+export declare const EditorI18nContext: import("react").Context<OmniboxEditorTranslationMap>;
+export declare function useEditorI18n(): OmniboxEditorTranslationMap;
+export {};

package/dist/lib/markdown.d.ts

@@ -0,0 +1,12 @@
+import type { JSONContent } from "@tiptap/core";
+export type TiptapJsonContent = JSONContent;
+export interface MarkdownParseOptions {
+    debug?: boolean;
+    linkBase?: string;
+}
+export declare function markdownToTiptapJson(markdown: string, options?: MarkdownParseOptions): TiptapJsonContent;
+export declare function markdownWithHtmlTablesToTiptapJson(markdown: string, options?: MarkdownParseOptions): TiptapJsonContent;
+export declare function contentToTiptapJson(content: string | TiptapJsonContent, options?: MarkdownParseOptions): TiptapJsonContent;
+export declare function tiptapJsonToMarkdown(json: TiptapJsonContent, options?: MarkdownParseOptions): string;
+export declare function contentToMarkdown(content: string | TiptapJsonContent, options?: MarkdownParseOptions): string;
+export { htmlTableToTiptapNode } from "./html-table";

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

@@ -0,0 +1,19 @@
+export type MathNodeEditTarget = {
+    type: "blockMath" | "inlineMath";
+    pos: number;
+    latex: string;
+};
+type MathEditorCommands = {
+    commands: {
+        updateBlockMath: (options: {
+            latex: string;
+            pos: number;
+        }) => boolean;
+        updateInlineMath: (options: {
+            latex: string;
+            pos: number;
+        }) => boolean;
+    };
+};
+export declare function updateMathNodeLatex(editor: MathEditorCommands, target: MathNodeEditTarget, latex: string): boolean;
+export {};

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,47 @@
+import { type Selection } from "@tiptap/pm/state";
+import type { JSONContent, Editor } from "@tiptap/react";
+import { type OmniboxEditorI18n } from "@/lib/i18n";
+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, i18n?: OmniboxEditorI18n) => 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 {};