@blocknote/core 0.12.0 → 0.12.3

package/src/extensions/{HyperlinkToolbar/HyperlinkToolbarPlugin.ts → LinkToolbar/LinkToolbarPlugin.ts}

@@ -8,38 +8,38 @@ import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
 import { EventEmitter } from "../../util/EventEmitter";
 
-export type HyperlinkToolbarState = UiElementPosition & {
-  // The hovered hyperlink's URL, and the text it's displayed with in the
+export type LinkToolbarState = UiElementPosition & {
+  // The hovered link's URL, and the text it's displayed with in the
   // editor.
   url: string;
   text: string;
 };
 
-class HyperlinkToolbarView {
-  public state?: HyperlinkToolbarState;
+class LinkToolbarView {
+  public state?: LinkToolbarState;
   public emitUpdate: () => void;
 
   menuUpdateTimer: ReturnType<typeof setTimeout> | undefined;
   startMenuUpdateTimer: () => void;
   stopMenuUpdateTimer: () => void;
 
-  mouseHoveredHyperlinkMark: Mark | undefined;
-  mouseHoveredHyperlinkMarkRange: Range | undefined;
+  mouseHoveredLinkMark: Mark | undefined;
+  mouseHoveredLinkMarkRange: Range | undefined;
 
-  keyboardHoveredHyperlinkMark: Mark | undefined;
-  keyboardHoveredHyperlinkMarkRange: Range | undefined;
+  keyboardHoveredLinkMark: Mark | undefined;
+  keyboardHoveredLinkMarkRange: Range | undefined;
 
-  hyperlinkMark: Mark | undefined;
-  hyperlinkMarkRange: Range | undefined;
+  linkMark: Mark | undefined;
+  linkMarkRange: Range | undefined;
 
   constructor(
     private readonly editor: BlockNoteEditor<any, any, any>,
     private readonly pmView: EditorView,
-    emitUpdate: (state: HyperlinkToolbarState) => void
+    emitUpdate: (state: LinkToolbarState) => void
   ) {
     this.emitUpdate = () => {
       if (!this.state) {
-        throw new Error("Attempting to update uninitialized hyperlink toolbar");
+        throw new Error("Attempting to update uninitialized link toolbar");
       }
 
       emitUpdate(this.state);
@@ -66,9 +66,9 @@ class HyperlinkToolbarView {
   }
 
   mouseOverHandler = (event: MouseEvent) => {
-    // Resets the hyperlink mark currently hovered by the mouse cursor.
-    this.mouseHoveredHyperlinkMark = undefined;
-    this.mouseHoveredHyperlinkMarkRange = undefined;
+    // Resets the link mark currently hovered by the mouse cursor.
+    this.mouseHoveredLinkMark = undefined;
+    this.mouseHoveredLinkMarkRange = undefined;
 
     this.stopMenuUpdateTimer();
 
@@ -76,27 +76,23 @@ class HyperlinkToolbarView {
       event.target instanceof HTMLAnchorElement &&
       event.target.nodeName === "A"
     ) {
-      // Finds link mark at the hovered element's position to update mouseHoveredHyperlinkMark and
-      // mouseHoveredHyperlinkMarkRange.
-      const hoveredHyperlinkElement = event.target;
-      const posInHoveredHyperlinkMark =
-        this.pmView.posAtDOM(hoveredHyperlinkElement, 0) + 1;
-      const resolvedPosInHoveredHyperlinkMark = this.pmView.state.doc.resolve(
-        posInHoveredHyperlinkMark
-      );
-      const marksAtPos = resolvedPosInHoveredHyperlinkMark.marks();
+      // Finds link mark at the hovered element's position to update mouseHoveredLinkMark and
+      // mouseHoveredLinkMarkRange.
+      const hoveredLinkElement = event.target;
+      const posInHoveredLinkMark =
+        this.pmView.posAtDOM(hoveredLinkElement, 0) + 1;
+      const resolvedPosInHoveredLinkMark =
+        this.pmView.state.doc.resolve(posInHoveredLinkMark);
+      const marksAtPos = resolvedPosInHoveredLinkMark.marks();
 
       for (const mark of marksAtPos) {
         if (
           mark.type.name === this.pmView.state.schema.mark("link").type.name
         ) {
-          this.mouseHoveredHyperlinkMark = mark;
-          this.mouseHoveredHyperlinkMarkRange =
-            getMarkRange(
-              resolvedPosInHoveredHyperlinkMark,
-              mark.type,
-              mark.attrs
-            ) || undefined;
+          this.mouseHoveredLinkMark = mark;
+          this.mouseHoveredLinkMarkRange =
+            getMarkRange(resolvedPosInHoveredLinkMark, mark.type, mark.attrs) ||
+            undefined;
 
           break;
         }
@@ -113,7 +109,7 @@ class HyperlinkToolbarView {
 
     if (
       // Toolbar is open.
-      this.hyperlinkMark &&
+      this.linkMark &&
       // An element is clicked.
       event &&
       event.target &&
@@ -131,27 +127,27 @@ class HyperlinkToolbarView {
   };
 
   scrollHandler = () => {
-    if (this.hyperlinkMark !== undefined) {
+    if (this.linkMark !== undefined) {
       if (this.state?.show) {
         this.state.referencePos = posToDOMRect(
           this.pmView,
-          this.hyperlinkMarkRange!.from,
-          this.hyperlinkMarkRange!.to
+          this.linkMarkRange!.from,
+          this.linkMarkRange!.to
         );
         this.emitUpdate();
       }
     }
   };
 
-  editHyperlink(url: string, text: string) {
+  editLink(url: string, text: string) {
     const tr = this.pmView.state.tr.insertText(
       text,
-      this.hyperlinkMarkRange!.from,
-      this.hyperlinkMarkRange!.to
+      this.linkMarkRange!.from,
+      this.linkMarkRange!.to
     );
     tr.addMark(
-      this.hyperlinkMarkRange!.from,
-      this.hyperlinkMarkRange!.from + text.length,
+      this.linkMarkRange!.from,
+      this.linkMarkRange!.from + text.length,
       this.pmView.state.schema.mark("link", { href: url })
     );
     this.pmView.dispatch(tr);
@@ -163,13 +159,13 @@ class HyperlinkToolbarView {
     }
   }
 
-  deleteHyperlink() {
+  deleteLink() {
     this.pmView.dispatch(
       this.pmView.state.tr
         .removeMark(
-          this.hyperlinkMarkRange!.from,
-          this.hyperlinkMarkRange!.to,
-          this.hyperlinkMark!.type
+          this.linkMarkRange!.from,
+          this.linkMarkRange!.to,
+          this.linkMark!.type
         )
         .setMeta("preventAutolink", true)
     );
@@ -186,19 +182,19 @@ class HyperlinkToolbarView {
       return;
     }
 
-    // Saves the currently hovered hyperlink mark before it's updated.
-    const prevHyperlinkMark = this.hyperlinkMark;
+    // Saves the currently hovered link mark before it's updated.
+    const prevLinkMark = this.linkMark;
 
-    // Resets the currently hovered hyperlink mark.
-    this.hyperlinkMark = undefined;
-    this.hyperlinkMarkRange = undefined;
+    // Resets the currently hovered link mark.
+    this.linkMark = undefined;
+    this.linkMarkRange = undefined;
 
-    // Resets the hyperlink mark currently hovered by the keyboard cursor.
-    this.keyboardHoveredHyperlinkMark = undefined;
-    this.keyboardHoveredHyperlinkMarkRange = undefined;
+    // Resets the link mark currently hovered by the keyboard cursor.
+    this.keyboardHoveredLinkMark = undefined;
+    this.keyboardHoveredLinkMarkRange = undefined;
 
-    // Finds link mark at the editor selection's position to update keyboardHoveredHyperlinkMark and
-    // keyboardHoveredHyperlinkMarkRange.
+    // Finds link mark at the editor selection's position to update keyboardHoveredLinkMark and
+    // keyboardHoveredLinkMarkRange.
     if (this.pmView.state.selection.empty) {
       const marksAtPos = this.pmView.state.selection.$from.marks();
 
@@ -206,8 +202,8 @@ class HyperlinkToolbarView {
         if (
           mark.type.name === this.pmView.state.schema.mark("link").type.name
         ) {
-          this.keyboardHoveredHyperlinkMark = mark;
-          this.keyboardHoveredHyperlinkMarkRange =
+          this.keyboardHoveredLinkMark = mark;
+          this.keyboardHoveredLinkMarkRange =
             getMarkRange(
               this.pmView.state.selection.$from,
               mark.type,
@@ -219,29 +215,29 @@ class HyperlinkToolbarView {
       }
     }
 
-    if (this.mouseHoveredHyperlinkMark) {
-      this.hyperlinkMark = this.mouseHoveredHyperlinkMark;
-      this.hyperlinkMarkRange = this.mouseHoveredHyperlinkMarkRange;
+    if (this.mouseHoveredLinkMark) {
+      this.linkMark = this.mouseHoveredLinkMark;
+      this.linkMarkRange = this.mouseHoveredLinkMarkRange;
     }
 
-    // Keyboard cursor position takes precedence over mouse hovered hyperlink.
-    if (this.keyboardHoveredHyperlinkMark) {
-      this.hyperlinkMark = this.keyboardHoveredHyperlinkMark;
-      this.hyperlinkMarkRange = this.keyboardHoveredHyperlinkMarkRange;
+    // Keyboard cursor position takes precedence over mouse hovered link.
+    if (this.keyboardHoveredLinkMark) {
+      this.linkMark = this.keyboardHoveredLinkMark;
+      this.linkMarkRange = this.keyboardHoveredLinkMarkRange;
     }
 
-    if (this.hyperlinkMark && this.editor.isEditable) {
+    if (this.linkMark && this.editor.isEditable) {
       this.state = {
         show: true,
         referencePos: posToDOMRect(
           this.pmView,
-          this.hyperlinkMarkRange!.from,
-          this.hyperlinkMarkRange!.to
+          this.linkMarkRange!.from,
+          this.linkMarkRange!.to
         ),
-        url: this.hyperlinkMark!.attrs.href,
+        url: this.linkMark!.attrs.href,
         text: this.pmView.state.doc.textBetween(
-          this.hyperlinkMarkRange!.from,
-          this.hyperlinkMarkRange!.to
+          this.linkMarkRange!.from,
+          this.linkMarkRange!.to
         ),
       };
       this.emitUpdate();
@@ -252,8 +248,8 @@ class HyperlinkToolbarView {
     // Hides menu.
     if (
       this.state?.show &&
-      prevHyperlinkMark &&
-      (!this.hyperlinkMark || !this.editor.isEditable)
+      prevLinkMark &&
+      (!this.linkMark || !this.editor.isEditable)
     ) {
       this.state.show = false;
       this.emitUpdate();
@@ -269,24 +265,22 @@ class HyperlinkToolbarView {
   }
 }
 
-export const hyperlinkToolbarPluginKey = new PluginKey(
-  "HyperlinkToolbarPlugin"
-);
+export const linkToolbarPluginKey = new PluginKey("LinkToolbarPlugin");
 
-export class HyperlinkToolbarProsemirrorPlugin<
+export class LinkToolbarProsemirrorPlugin<
   BSchema extends BlockSchema,
   I extends InlineContentSchema,
   S extends StyleSchema
 > extends EventEmitter<any> {
-  private view: HyperlinkToolbarView | undefined;
+  private view: LinkToolbarView | undefined;
   public readonly plugin: Plugin;
 
   constructor(editor: BlockNoteEditor<BSchema, I, S>) {
     super();
     this.plugin = new Plugin({
-      key: hyperlinkToolbarPluginKey,
+      key: linkToolbarPluginKey,
       view: (editorView) => {
-        this.view = new HyperlinkToolbarView(editor, editorView, (state) => {
+        this.view = new LinkToolbarView(editor, editorView, (state) => {
           this.emit("update", state);
         });
         return this.view;
@@ -294,39 +288,41 @@ export class HyperlinkToolbarProsemirrorPlugin<
     });
   }
 
-  public onUpdate(callback: (state: HyperlinkToolbarState) => void) {
+  public onUpdate(callback: (state: LinkToolbarState) => void) {
     return this.on("update", callback);
   }
 
   /**
-   * Edit the currently hovered hyperlink.
+   * Edit the currently hovered link.
    */
-  public editHyperlink = (url: string, text: string) => {
-    this.view!.editHyperlink(url, text);
+  public editLink = (url: string, text: string) => {
+    this.view!.editLink(url, text);
   };
 
   /**
-   * Delete the currently hovered hyperlink.
+   * Delete the currently hovered link.
    */
-  public deleteHyperlink = () => {
-    this.view!.deleteHyperlink();
+  public deleteLink = () => {
+    this.view!.deleteLink();
   };
 
   /**
-   * When hovering on/off hyperlinks using the mouse cursor, the hyperlink
-   * toolbar will open & close with a delay.
+   * When hovering on/off links using the mouse cursor, the link toolbar will
+   * open & close with a delay.
    *
-   * This function starts the delay timer, and should be used for when the mouse cursor enters the hyperlink toolbar.
+   * This function starts the delay timer, and should be used for when the mouse
+   * cursor enters the link toolbar.
    */
   public startHideTimer = () => {
     this.view!.startMenuUpdateTimer();
   };
 
   /**
-   * When hovering on/off hyperlinks using the mouse cursor, the hyperlink
-   * toolbar will open & close with a delay.
+   * When hovering on/off links using the mouse cursor, the link toolbar will
+   * open & close with a delay.
    *
-   * This function stops the delay timer, and should be used for when the mouse cursor exits the hyperlink toolbar.
+   * This function stops the delay timer, and should be used for when the mouse
+   * cursor exits the link toolbar.
    */
   public stopHideTimer = () => {
     this.view!.stopMenuUpdateTimer();

package/src/extensions/SuggestionMenu/getDefaultSlashMenuItems.ts

@@ -205,7 +205,7 @@ export function getDefaultSlashMenuItems<
 
         // Immediately open the image toolbar
         editor.prosemirrorView.dispatch(
-          editor._tiptapEditor.state.tr.setMeta(editor.imageToolbar!.plugin, {
+          editor._tiptapEditor.state.tr.setMeta(editor.imagePanel!.plugin, {
             block: insertedBlock,
           })
         );

package/src/index.ts

@@ -11,8 +11,8 @@ export * from "./editor/BlockNoteSchema";
 export * from "./editor/selectionTypes";
 export * from "./extensions-shared/UiElementPosition";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
-export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
-export * from "./extensions/ImageToolbar/ImageToolbarPlugin";
+export * from "./extensions/ImagePanel/ImageToolbarPlugin";
+export * from "./extensions/LinkToolbar/LinkToolbarPlugin";
 export * from "./extensions/SideMenu/SideMenuPlugin";
 export * from "./extensions/SuggestionMenu/DefaultSuggestionItem";
 export * from "./extensions/SuggestionMenu/SuggestionPlugin";

package/types/src/api/getCurrentBlockContentType.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from "@tiptap/core";
+export declare const getCurrentBlockContentType: (editor: Editor) => string | undefined;

package/types/src/editor/BlockNoteEditor.d.ts

@@ -3,18 +3,18 @@ import { Node } from "prosemirror-model";
 import * as Y from "yjs";
 import { Block, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/defaultBlocks";
 import { FormattingToolbarProsemirrorPlugin } from "../extensions/FormattingToolbar/FormattingToolbarPlugin";
-import { HyperlinkToolbarProsemirrorPlugin } from "../extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
-import { ImageToolbarProsemirrorPlugin } from "../extensions/ImageToolbar/ImageToolbarPlugin";
+import { LinkToolbarProsemirrorPlugin } from "../extensions/LinkToolbar/LinkToolbarPlugin";
 import { SideMenuProsemirrorPlugin } from "../extensions/SideMenu/SideMenuPlugin";
 import { SuggestionMenuProseMirrorPlugin } from "../extensions/SuggestionMenu/SuggestionPlugin";
+import { ImagePanelProsemirrorPlugin } from "../extensions/ImagePanel/ImageToolbarPlugin";
 import { TableHandlesProsemirrorPlugin } from "../extensions/TableHandles/TableHandlesPlugin";
 import { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, InlineContentSchema, InlineContentSpecs, PartialInlineContent, StyleSchema, StyleSpecs, Styles } from "../schema";
 import { NoInfer } from "../util/typescript";
 import { TextCursorPosition } from "./cursorPositionTypes";
 import { Selection } from "./selectionTypes";
-import "./Block.css";
 import { BlockNoteSchema } from "./BlockNoteSchema";
 import { BlockNoteTipTapEditor } from "./BlockNoteTipTapEditor";
+import "./Block.css";
 import "./editor.css";
 export type BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema extends InlineContentSchema, SSchema extends StyleSchema> = {
     enableBlockNoteExtensions: boolean;
@@ -79,10 +79,10 @@ export declare class BlockNoteEditor<BSchema extends BlockSchema = DefaultBlockS
     readonly inlineContentImplementations: InlineContentSpecs;
     readonly styleImplementations: StyleSpecs;
     readonly formattingToolbar: FormattingToolbarProsemirrorPlugin;
-    readonly hyperlinkToolbar: HyperlinkToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
+    readonly linkToolbar: LinkToolbarProsemirrorPlugin<BSchema, ISchema, SSchema>;
     readonly sideMenu: SideMenuProsemirrorPlugin<BSchema, ISchema, SSchema>;
     readonly suggestionMenus: SuggestionMenuProseMirrorPlugin<BSchema, ISchema, SSchema>;
-    readonly imageToolbar?: ImageToolbarProsemirrorPlugin<ISchema, SSchema>;
+    readonly imagePanel?: ImagePanelProsemirrorPlugin<ISchema, SSchema>;
     readonly tableHandles?: TableHandlesProsemirrorPlugin<ISchema, SSchema>;
     readonly uploadFile: ((file: File) => Promise<string>) | undefined;
     static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): BlockNoteEditor<BSchema, ISchema, SSchema>;

package/types/src/extensions/{ImageToolbar → ImagePanel}/ImageToolbarPlugin.d.ts

@@ -5,16 +5,16 @@ import type { BlockFromConfig, InlineContentSchema, StyleSchema } from "../../sc
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
 import { EventEmitter } from "../../util/EventEmitter";
 import { DefaultBlockSchema } from "../../blocks/defaultBlocks";
-export type ImageToolbarState<I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
+export type ImagePanelState<I extends InlineContentSchema, S extends StyleSchema> = UiElementPosition & {
     block: BlockFromConfig<DefaultBlockSchema["image"], I, S>;
 };
-export declare class ImageToolbarView<I extends InlineContentSchema, S extends StyleSchema> {
+export declare class ImagePanelView<I extends InlineContentSchema, S extends StyleSchema> {
     private readonly pluginKey;
     private readonly pmView;
-    state?: ImageToolbarState<I, S>;
+    state?: ImagePanelState<I, S>;
     emitUpdate: () => void;
     prevWasEditable: boolean | null;
-    constructor(pluginKey: PluginKey, pmView: EditorView, emitUpdate: (state: ImageToolbarState<I, S>) => void);
+    constructor(pluginKey: PluginKey, pmView: EditorView, emitUpdate: (state: ImagePanelState<I, S>) => void);
     mouseDownHandler: () => void;
     dragstartHandler: () => void;
     blurHandler: (event: FocusEvent) => void;
@@ -22,11 +22,11 @@ export declare class ImageToolbarView<I extends InlineContentSchema, S extends S
     update(view: EditorView, prevState: EditorState): void;
     destroy(): void;
 }
-export declare class ImageToolbarProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+export declare class ImagePanelProsemirrorPlugin<I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
     private view;
     readonly plugin: Plugin;
     constructor(_editor: BlockNoteEditor<{
         image: DefaultBlockSchema["image"];
     }, I, S>);
-    onUpdate(callback: (state: ImageToolbarState<I, S>) => void): () => void;
+    onUpdate(callback: (state: ImagePanelState<I, S>) => void): () => void;
 }

package/types/src/extensions/LinkToolbar/LinkToolbarPlugin.d.ts

@@ -0,0 +1,40 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
+import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
+import { EventEmitter } from "../../util/EventEmitter";
+export type LinkToolbarState = UiElementPosition & {
+    url: string;
+    text: string;
+};
+export declare const linkToolbarPluginKey: PluginKey<any>;
+export declare class LinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
+    private view;
+    readonly plugin: Plugin;
+    constructor(editor: BlockNoteEditor<BSchema, I, S>);
+    onUpdate(callback: (state: LinkToolbarState) => void): () => void;
+    /**
+     * Edit the currently hovered link.
+     */
+    editLink: (url: string, text: string) => void;
+    /**
+     * Delete the currently hovered link.
+     */
+    deleteLink: () => void;
+    /**
+     * When hovering on/off links using the mouse cursor, the link toolbar will
+     * open & close with a delay.
+     *
+     * This function starts the delay timer, and should be used for when the mouse
+     * cursor enters the link toolbar.
+     */
+    startHideTimer: () => void;
+    /**
+     * When hovering on/off links using the mouse cursor, the link toolbar will
+     * open & close with a delay.
+     *
+     * This function stops the delay timer, and should be used for when the mouse
+     * cursor exits the link toolbar.
+     */
+    stopHideTimer: () => void;
+}

package/types/src/index.d.ts

@@ -11,8 +11,8 @@ export * from "./editor/BlockNoteSchema";
 export * from "./editor/selectionTypes";
 export * from "./extensions-shared/UiElementPosition";
 export * from "./extensions/FormattingToolbar/FormattingToolbarPlugin";
-export * from "./extensions/HyperlinkToolbar/HyperlinkToolbarPlugin";
-export * from "./extensions/ImageToolbar/ImageToolbarPlugin";
+export * from "./extensions/ImagePanel/ImageToolbarPlugin";
+export * from "./extensions/LinkToolbar/LinkToolbarPlugin";
 export * from "./extensions/SideMenu/SideMenuPlugin";
 export * from "./extensions/SuggestionMenu/DefaultSuggestionItem";
 export * from "./extensions/SuggestionMenu/SuggestionPlugin";

package/types/src/extensions/HyperlinkToolbar/HyperlinkToolbarPlugin.d.ts

@@ -1,38 +0,0 @@
-import { Plugin, PluginKey } from "prosemirror-state";
-import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BlockSchema, InlineContentSchema, StyleSchema } from "../../schema";
-import { UiElementPosition } from "../../extensions-shared/UiElementPosition";
-import { EventEmitter } from "../../util/EventEmitter";
-export type HyperlinkToolbarState = UiElementPosition & {
-    url: string;
-    text: string;
-};
-export declare const hyperlinkToolbarPluginKey: PluginKey<any>;
-export declare class HyperlinkToolbarProsemirrorPlugin<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> extends EventEmitter<any> {
-    private view;
-    readonly plugin: Plugin;
-    constructor(editor: BlockNoteEditor<BSchema, I, S>);
-    onUpdate(callback: (state: HyperlinkToolbarState) => void): () => void;
-    /**
-     * Edit the currently hovered hyperlink.
-     */
-    editHyperlink: (url: string, text: string) => void;
-    /**
-     * Delete the currently hovered hyperlink.
-     */
-    deleteHyperlink: () => void;
-    /**
-     * When hovering on/off hyperlinks using the mouse cursor, the hyperlink
-     * toolbar will open & close with a delay.
-     *
-     * This function starts the delay timer, and should be used for when the mouse cursor enters the hyperlink toolbar.
-     */
-    startHideTimer: () => void;
-    /**
-     * When hovering on/off hyperlinks using the mouse cursor, the hyperlink
-     * toolbar will open & close with a delay.
-     *
-     * This function stops the delay timer, and should be used for when the mouse cursor exits the hyperlink toolbar.
-     */
-    stopHideTimer: () => void;
-}