@blocknote/core 0.47.0 → 0.47.2

package/src/i18n/locales/uz.ts

@@ -23,19 +23,37 @@ export const uz: Dictionary = {
     heading_4: {
       title: "4-darajali sarlavha",
       subtext: "Yana kichik bo‘limlar uchun ishlatiladi",
-      aliases: ["h4", "heading4", "subheading4", "sarlavha4", "kichik_sarlavha4"],
+      aliases: [
+        "h4",
+        "heading4",
+        "subheading4",
+        "sarlavha4",
+        "kichik_sarlavha4",
+      ],
       group: "Kichik sarlavhalar",
     },
     heading_5: {
       title: "5-darajali sarlavha",
       subtext: "Kichik bo‘lim sarlavhalari uchun",
-      aliases: ["h5", "heading5", "subheading5", "sarlavha5", "kichik_sarlavha5"],
+      aliases: [
+        "h5",
+        "heading5",
+        "subheading5",
+        "sarlavha5",
+        "kichik_sarlavha5",
+      ],
       group: "Kichik sarlavhalar",
     },
     heading_6: {
       title: "6-darajali sarlavha",
       subtext: "Eng past darajadagi sarlavha",
-      aliases: ["h6", "heading6", "subheading6", "sarlavha6", "kichik_sarlavha6"],
+      aliases: [
+        "h6",
+        "heading6",
+        "subheading6",
+        "sarlavha6",
+        "kichik_sarlavha6",
+      ],
       group: "Kichik sarlavhalar",
     },
     toggle_heading: {
@@ -418,4 +436,4 @@ export const uz: Dictionary = {
   generic: {
     ctrl_shortcut: "Ctrl",
   },
-};
+};

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./editor/BlockNoteExtension.js";
 export * from "./editor/defaultColors.js";
 export * from "./editor/selectionTypes.js";
 export * from "./exporter/index.js";
+export * from "./extensions/index.js";
 export * from "./extensions-shared/UiElementPosition.js";
 export * from "./i18n/dictionary.js";
 export * from "./schema/index.js";

package/src/schema/blocks/createSpec.ts

@@ -14,7 +14,9 @@ import {
 } from "./internal.js";
 import {
   BlockConfig,
+  BlockConfigOrCreator,
   BlockImplementation,
+  BlockImplementationOrCreator,
   BlockSpec,
   LooseBlockSpec,
 } from "./types.js";
@@ -76,10 +78,15 @@ export function getParseRules<
         config.content === "inline" || config.content === "none"
           ? (node, schema) => {
               if (implementation.parseContent) {
-                return implementation.parseContent({
+                const result = implementation.parseContent({
                   el: node as HTMLElement,
                   schema,
                 });
+                // parseContent may return undefined to fall through to
+                // the default inline content parsing below.
+                if (result !== undefined) {
+                  return result;
+                }
               }
 
               if (config.content === "inline") {
@@ -210,6 +217,8 @@ export function addNodeAndExtensionsToSpec<
 
           // See explanation for why `update` is not implemented for NodeViews
           // https://github.com/TypeCellOS/BlockNote/pull/1904#discussion_r2313461464
+          // TODO: in a future version, we might want to implement updates so that
+          // vanilla blocks don't always re-render entirely (https://github.com/TypeCellOS/BlockNote/issues/220)
           return nodeView;
         };
       },
@@ -295,18 +304,17 @@ export function createBlockSpec<
   const TOptions extends Partial<Record<string, any>> | undefined = undefined,
 >(
   blockConfigOrCreator: BlockConfig<TName, TProps, TContent>,
-  blockImplementationOrCreator:
-    | BlockImplementation<TName, TProps, TContent>
+  blockImplementationOrCreator: BlockImplementationOrCreator<
+    BlockConfig<TName, TProps, TContent>,
+    TOptions
+  >,
+  extensionsOrCreator?:
+    | (ExtensionFactoryInstance | Extension)[]
     | (TOptions extends undefined
-        ? () => BlockImplementation<TName, TProps, TContent>
+        ? () => (ExtensionFactoryInstance | Extension)[]
         : (
             options: Partial<TOptions>,
-          ) => BlockImplementation<TName, TProps, TContent>),
-  extensionsOrCreator?:
-    | ExtensionFactoryInstance[]
-    | (TOptions extends undefined
-        ? () => ExtensionFactoryInstance[]
-        : (options: Partial<TOptions>) => ExtensionFactoryInstance[]),
+          ) => (ExtensionFactoryInstance | Extension)[]),
 ): (options?: Partial<TOptions>) => BlockSpec<TName, TProps, TContent>;
 export function createBlockSpec<
   const TName extends string,
@@ -316,30 +324,17 @@ export function createBlockSpec<
   const TOptions extends Partial<Record<string, any>>,
 >(
   blockCreator: (options: Partial<TOptions>) => BlockConf,
-  blockImplementationOrCreator:
-    | BlockImplementation<
-        BlockConf["type"],
-        BlockConf["propSchema"],
-        BlockConf["content"]
-      >
+  blockImplementationOrCreator: BlockImplementationOrCreator<
+    BlockConf,
+    TOptions
+  >,
+  extensionsOrCreator?:
+    | (ExtensionFactoryInstance | Extension)[]
     | (TOptions extends undefined
-        ? () => BlockImplementation<
-            BlockConf["type"],
-            BlockConf["propSchema"],
-            BlockConf["content"]
-          >
+        ? () => (ExtensionFactoryInstance | Extension)[]
         : (
             options: Partial<TOptions>,
-          ) => BlockImplementation<
-            BlockConf["type"],
-            BlockConf["propSchema"],
-            BlockConf["content"]
-          >),
-  extensionsOrCreator?:
-    | ExtensionFactoryInstance[]
-    | (TOptions extends undefined
-        ? () => ExtensionFactoryInstance[]
-        : (options: Partial<TOptions>) => ExtensionFactoryInstance[]),
+          ) => (ExtensionFactoryInstance | Extension)[]),
 ): (
   options?: Partial<TOptions>,
 ) => BlockSpec<
@@ -353,23 +348,18 @@ export function createBlockSpec<
   const TContent extends "inline" | "none",
   const TOptions extends Partial<Record<string, any>> | undefined = undefined,
 >(
-  blockConfigOrCreator:
-    | BlockConfig<TName, TProps, TContent>
-    | (TOptions extends undefined
-        ? () => BlockConfig<TName, TProps, TContent>
-        : (options: Partial<TOptions>) => BlockConfig<TName, TProps, TContent>),
-  blockImplementationOrCreator:
-    | BlockImplementation<TName, TProps, TContent>
+  blockConfigOrCreator: BlockConfigOrCreator<TName, TProps, TContent, TOptions>,
+  blockImplementationOrCreator: BlockImplementationOrCreator<
+    BlockConfig<TName, TProps, TContent>,
+    TOptions
+  >,
+  extensionsOrCreator?:
+    | (ExtensionFactoryInstance | Extension)[]
     | (TOptions extends undefined
-        ? () => BlockImplementation<TName, TProps, TContent>
+        ? () => (ExtensionFactoryInstance | Extension)[]
         : (
             options: Partial<TOptions>,
-          ) => BlockImplementation<TName, TProps, TContent>),
-  extensionsOrCreator?:
-    | ExtensionFactoryInstance[]
-    | (TOptions extends undefined
-        ? () => ExtensionFactoryInstance[]
-        : (options: Partial<TOptions>) => ExtensionFactoryInstance[]),
+          ) => (ExtensionFactoryInstance | Extension)[]),
 ): (options?: Partial<TOptions>) => BlockSpec<TName, TProps, TContent> {
   return (options = {} as TOptions) => {
     const blockConfig =

package/src/schema/blocks/types.ts

@@ -86,6 +86,34 @@ export interface BlockConfig<
   // e.g. tables, alerts (with title & content)
 }
 
+/**
+ * BlockConfigOrCreator is a union type of BlockConfig and a function that returns a BlockConfig.
+ * This is used to create block configs that can be passed to the createBlockSpec function.
+ */
+export type BlockConfigOrCreator<
+  TName extends string = string,
+  TProps extends PropSchema = PropSchema,
+  TContent extends "inline" | "none" = "inline" | "none",
+  TOptions extends Record<string, any> | undefined =
+    | Record<string, any>
+    | undefined,
+> =
+  | BlockConfig<TName, TProps, TContent>
+  | (TOptions extends undefined
+      ? () => BlockConfig<TName, TProps, TContent>
+      : (options: Partial<TOptions>) => BlockConfig<TName, TProps, TContent>);
+
+/**
+ * ExtractBlockConfigFromConfigOrCreator is a helper type that extracts the BlockConfig type from a BlockConfigOrCreator.
+ */
+export type ExtractBlockConfigFromConfigOrCreator<
+  ConfigOrCreator extends
+    | BlockConfig<string, PropSchema, "inline" | "none">
+    | ((...args: any[]) => BlockConfig<string, PropSchema, "inline" | "none">),
+> = ConfigOrCreator extends (...args: any[]) => infer Config
+  ? Config
+  : ConfigOrCreator;
+
 // restrict content to "inline" and "none" only
 export type CustomBlockConfig<
   T extends string = string,
@@ -104,6 +132,32 @@ export type BlockSpec<
   extensions?: (Extension | ExtensionFactoryInstance)[];
 };
 
+/**
+ * BlockSpecOrCreator is a union type of BlockSpec and a function that returns a BlockSpec.
+ * This is used to create block specs that can be passed to the createBlockSpec function.
+ */
+export type BlockSpecOrCreator<
+  T extends string = string,
+  PS extends PropSchema = PropSchema,
+  C extends "inline" | "none" | "table" = "inline" | "none" | "table",
+  TOptions extends Record<string, any> | undefined =
+    | Record<string, any>
+    | undefined,
+> =
+  | BlockSpec<T, PS, C>
+  | (TOptions extends undefined
+      ? () => BlockSpec<T, PS, C>
+      : (options: Partial<TOptions>) => BlockSpec<T, PS, C>);
+
+/**
+ * ExtractBlockSpecFromSpecOrCreator is a helper type that extracts the BlockSpec type from a BlockSpecOrCreator.
+ */
+export type ExtractBlockSpecFromSpecOrCreator<
+  SpecOrCreator extends
+    | BlockSpec<string, PropSchema, "inline" | "none">
+    | ((...args: any[]) => BlockSpec<string, PropSchema, "inline" | "none">),
+> = SpecOrCreator extends (...args: any[]) => infer Spec ? Spec : SpecOrCreator;
+
 /**
  * This allows de-coupling the types that we display to users versus the types we expose internally.
  *
@@ -146,6 +200,7 @@ export type LooseBlockSpec<
       | {
           dom: HTMLElement | DocumentFragment;
           contentDOM?: HTMLElement;
+          childrenDOM?: HTMLElement;
         }
       | undefined;
 
@@ -203,6 +258,7 @@ export type BlockSpecs = {
         | {
             dom: HTMLElement | DocumentFragment;
             contentDOM?: HTMLElement;
+            childrenDOM?: HTMLElement;
           }
         | undefined;
     };
@@ -476,6 +532,7 @@ export type BlockImplementation<
     | {
         dom: HTMLElement | DocumentFragment;
         contentDOM?: HTMLElement;
+        childrenDOM?: HTMLElement;
       }
     | undefined;
 
@@ -494,9 +551,52 @@ export type BlockImplementation<
    * Advanced parsing function that controls how content within the block is parsed.
    * This is not recommended to use, and is only useful for advanced use cases.
    */
-  parseContent?: (options: { el: HTMLElement; schema: Schema }) => Fragment;
+  parseContent?: (options: {
+    el: HTMLElement;
+    schema: Schema;
+  }) => Fragment | undefined;
 };
 
+/**
+ * BlockImplementationOrCreator is a union type of BlockImplementation and a function that returns a BlockImplementation.
+ * This is used to create block implementations that can be passed to the createBlockSpec function.
+ */
+export type BlockImplementationOrCreator<
+  ConfigOrCreator extends BlockConfigOrCreator = BlockConfigOrCreator,
+  TOptions extends Record<string, any> | undefined =
+    | Record<string, any>
+    | undefined,
+  Config extends
+    ExtractBlockConfigFromConfigOrCreator<ConfigOrCreator> = ExtractBlockConfigFromConfigOrCreator<ConfigOrCreator>,
+> =
+  | BlockImplementation<Config["type"], Config["propSchema"], Config["content"]>
+  | (TOptions extends undefined
+      ? () => BlockImplementation<
+          Config["type"],
+          Config["propSchema"],
+          Config["content"]
+        >
+      : (
+          options: Partial<TOptions>,
+        ) => BlockImplementation<
+          Config["type"],
+          Config["propSchema"],
+          Config["content"]
+        >);
+
+/**
+ * ExtractBlockImplementationFromImplementationOrCreator is a helper type that extracts the BlockImplementation type from a BlockImplementationOrCreator.
+ */
+export type ExtractBlockImplementationFromImplementationOrCreator<
+  ImplementationOrCreator extends
+    | BlockImplementation<string, PropSchema, "inline" | "none">
+    | ((
+        ...args: any[]
+      ) => BlockImplementation<string, PropSchema, "inline" | "none">),
+> = ImplementationOrCreator extends (...args: any[]) => infer Implementation
+  ? Implementation
+  : ImplementationOrCreator;
+
 // restrict content to "inline" and "none" only
 export type CustomBlockImplementation<
   T extends string = string,

package/types/src/api/blockManipulation/commands/mergeBlocks/mergeBlocks.d.ts

@@ -11,6 +11,11 @@ export declare const getParentBlockInfo: (doc: Node, beforePos: number) => Block
  * or undefined if the given block is the first sibling.
  */
 export declare const getPrevBlockInfo: (doc: Node, beforePos: number) => BlockInfo | undefined;
+/**
+ * Returns the block info from the sibling block after (below) the given block,
+ * or undefined if the given block is the last sibling.
+ */
+export declare const getNextBlockInfo: (doc: Node, beforePos: number) => BlockInfo | undefined;
 /**
  * If a block has children like this:
  * A

package/types/src/blocks/getDetailsContent.d.ts

@@ -0,0 +1,19 @@
+import { Fragment, Schema } from "prosemirror-model";
+/**
+ * Parses a `<details>` element into a block's inline content + nested children.
+ *
+ * Given:
+ *   <details>
+ *     <summary>inline content here</summary>
+ *     <p>child block 1</p>
+ *     <p>child block 2</p>
+ *   </details>
+ *
+ * Returns a Fragment shaped like:
+ *   [inline content, blockGroup<blockContainer<child1>, blockContainer<child2>>]
+ *
+ * ProseMirror's "fitting" algorithm will place the inline content into the
+ * block node, and lift the blockGroup into the parent blockContainer as
+ * nested children. This is the same mechanism used by `getListItemContent`.
+ */
+export declare function getDetailsContent(details: HTMLElement, schema: Schema, nodeName: string): Fragment;

package/types/src/comments/threadstore/TipTapThreadStore.d.ts

@@ -1,7 +1,7 @@
-import type { TiptapCollabProvider } from "@hocuspocus/provider";
 import { CommentBody, ThreadData } from "../types.js";
 import { ThreadStore } from "./ThreadStore.js";
 import { ThreadStoreAuth } from "./ThreadStoreAuth.js";
+import type { TiptapCollabProvider } from "./tiptap/types.js";
 /**
  * The `TiptapThreadStore` integrates with Tiptap's collaboration provider for comment management.
  * You can pass a `TiptapCollabProvider` to the constructor which takes care of storing the comments.

package/types/src/comments/threadstore/tiptap/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Tiptap comment types have moved to a private tiptap package and we don't want to create a dependency on it.
+ * We've extracted the types from https://github.com/ueberdosis/hocuspocus/blob/v2.15.3/packages/provider/src/types.ts
+ * and added them here.
+ */
+export type TCollabThread<Data = any, CommentData = any> = {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    resolvedAt?: string;
+    comments: TCollabComment<CommentData>[];
+    deletedComments: TCollabComment<CommentData>[];
+    data: Data;
+};
+export type TCollabComment<Data = any> = {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+    data: Data;
+    content: any;
+};
+export type ThreadType = "archived" | "unarchived";
+export type GetThreadsOptions = {
+    /**
+     * The types of threads to get
+     * @default ['unarchived']
+     */
+    types?: Array<ThreadType>;
+};
+export type DeleteCommentOptions = {
+    /**
+     * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
+     */
+    deleteThread?: boolean;
+    /**
+     * If `true`, will remove the content of the deleted comment
+     */
+    deleteContent?: boolean;
+};
+export type DeleteThreadOptions = {
+    /**
+     * If `true`, will remove the comments on the thread,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    deleteComments?: boolean;
+    /**
+     * If `true`, will forcefully remove the thread and all comments,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    force?: boolean;
+};
+export type TiptapCollabProvider = {
+    getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null;
+    getThreads<Data, CommentData>(options?: GetThreadsOptions): TCollabThread<Data, CommentData>[];
+    createThread(data: Omit<TCollabThread, "id" | "createdAt" | "updatedAt" | "deletedAt" | "comments" | "deletedComments">): TCollabThread;
+    addComment(threadId: TCollabThread["id"], data: Omit<TCollabComment, "id" | "updatedAt" | "createdAt">): TCollabThread;
+    updateComment(threadId: TCollabThread["id"], commentId: TCollabComment["id"], data: Partial<Pick<TCollabComment, "data" | "content">>): TCollabThread;
+    deleteComment(threadId: TCollabThread["id"], commentId: TCollabComment["id"], options?: DeleteCommentOptions): TCollabThread;
+    getThreadComments(threadId: TCollabThread["id"], includeDeleted?: boolean): TCollabComment[] | null;
+    getThreadComment(threadId: TCollabThread["id"], commentId: TCollabComment["id"], includeDeleted?: boolean): TCollabComment | null;
+    deleteThread(id: TCollabThread["id"], options?: DeleteThreadOptions): TCollabThread;
+    updateThread(id: TCollabThread["id"], data: Partial<Pick<TCollabThread, "data"> & {
+        resolvedAt: TCollabThread["resolvedAt"] | null;
+    }>): TCollabThread;
+    watchThreads(callback: () => void): void;
+    unwatchThreads(callback: () => void): void;
+};

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

@@ -1,9 +1,10 @@
 import { EditorOptions, FocusPosition, Editor as TiptapEditor } from "@tiptap/core";
-import { type Command, type Plugin, type Transaction } from "@tiptap/pm/state";
+import { type Command, type Transaction } from "@tiptap/pm/state";
 import { Node, Schema } from "prosemirror-model";
 import type { BlocksChanged } from "../api/getBlocksChangedByTransaction.js";
 import { Block, BlockNoteSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, PartialBlock } from "../blocks/index.js";
 import type { CollaborationOptions } from "../extensions/Collaboration/Collaboration.js";
+import { DropCursorOptions } from "../extensions/index.js";
 import type { Dictionary } from "../i18n/dictionary.js";
 import type { BlockIdentifier, BlockNoteDOMAttributes, BlockSchema, BlockSpecs, CustomBlockNoteSchema, InlineContentSchema, InlineContentSpecs, PartialInlineContent, Styles, StyleSchema, StyleSpecs } from "../schema/index.js";
 import "../style.css";
@@ -62,15 +63,11 @@ export interface BlockNoteEditorOptions<BSchema extends BlockSchema, ISchema ext
      */
     domAttributes?: Partial<BlockNoteDOMAttributes>;
     /**
-     * A replacement indicator to use when dragging and dropping blocks. Uses the [ProseMirror drop cursor](https://github.com/ProseMirror/prosemirror-dropcursor), or a modified version when [Column Blocks](https://www.blocknotejs.org/docs/document-structure#column-blocks) are enabled.
-     * @remarks `() => Plugin`
+     * Options for configuring the drop cursor behavior when dragging and dropping blocks.
+     * Allows customization of cursor appearance and drop position computation through hooks.
+     * @remarks `DropCursorOptions`
      */
-    dropCursor?: (opts: {
-        editor: BlockNoteEditor<NoInfer<BSchema>, NoInfer<ISchema>, NoInfer<SSchema>>;
-        color?: string | false;
-        width?: number;
-        class?: string;
-    }) => Plugin;
+    dropCursor?: DropCursorOptions;
     /**
      * The content that should be in the editor when it's created, represented as an array of {@link PartialBlock} objects.
      *

package/types/src/extensions/DropCursor/DropCursor.d.ts

@@ -1,5 +1,42 @@
-import { BlockNoteEditorOptions } from "../../editor/BlockNoteEditor.js";
-export declare const DropCursorExtension: (options: Pick<BlockNoteEditorOptions<any, any, any>, "dropCursor">) => import("../../index.js").ExtensionFactoryInstance<{
-    readonly key: "dropCursor";
-    readonly prosemirrorPlugins: readonly [import("prosemirror-state").Plugin<any>];
-}>;
+import type { EditorView } from "prosemirror-view";
+import { type DropCursorPosition } from "./utils.js";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+export declare const DRAG_EXCLUSION_CLASSNAME = "bn-drag-exclude";
+/**
+ * Context passed to the computeDropPosition hook.
+ */
+export interface ComputeDropPositionContext {
+    editor: BlockNoteEditor<any, any, any>;
+    event: DragEvent;
+    view: EditorView;
+    defaultPosition: DropCursorPosition | null;
+}
+/**
+ * Hooks for customizing drop cursor behavior.
+ */
+export interface DropCursorHooks {
+    /**
+     * Compute cursor position and orientation.
+     * Return null to prevent dropping (no cursor shown).
+     */
+    computeDropPosition?: (context: ComputeDropPositionContext) => DropCursorPosition | null;
+}
+/**
+ * Options for the DropCursor extension.
+ */
+export interface DropCursorOptions {
+    width?: number;
+    color?: string | false;
+    exclude?: string;
+    hooks?: DropCursorHooks;
+}
+/**
+ * Drop cursor visualization based on prosemirror-dropcursor:
+ * https://github.com/ProseMirror/prosemirror-dropcursor/blob/master/src/dropcursor.ts
+ *
+ * Refactored to use BlockNote extension pattern with mount callback and AbortSignal
+ * for lifecycle management instead of ProseMirror PluginView.
+ */
+export declare const DropCursorExtension: (options: {
+    dropCursor?: DropCursorOptions;
+}) => import("../../index.js").ExtensionFactoryInstance<import("../../index.js").Extension<any, string>>;

package/types/src/extensions/DropCursor/utils.d.ts

@@ -0,0 +1,48 @@
+import type { EditorView } from "prosemirror-view";
+/**
+ * The orientation of the drop cursor.
+ */
+export type DropCursorOrientation = "inline" | "block-horizontal" | "block-vertical-left" | "block-vertical-right";
+/**
+ * The position and orientation of the drop cursor.
+ */
+export type DropCursorPosition = {
+    pos: number;
+    orientation: DropCursorOrientation;
+};
+/**
+ * Bounding rectangle in viewport coordinates (e.g. from getBoundingClientRect).
+ */
+export type Rect = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * Returns true if the element or any ancestor has the given CSS class.
+ * Used to skip drop cursor for elements marked with the exclusion class (e.g. drag handles).
+ */
+export declare function hasExclusionClassname(element: Element | null, exclude: string): boolean;
+/**
+ * Computes the viewport rect for a block-level drop cursor (horizontal line between blocks
+ * or vertical line on left/right edge). Returns null for inline positions or when no DOM node exists.
+ */
+export declare function getBlockDropRect(view: EditorView, cursorPos: DropCursorPosition, width: number, scaleX: number, scaleY: number): Rect | null;
+/**
+ * Computes the viewport rect for an inline drop cursor (vertical line within text).
+ */
+export declare function getInlineDropRect(view: EditorView, cursorPos: DropCursorPosition, width: number, scaleX: number): Rect;
+/**
+ * Applies orientation-specific CSS classes to the drop cursor element so it can be
+ * styled correctly (e.g. horizontal vs vertical line, inline vs block).
+ */
+export declare function applyOrientationClasses(el: HTMLElement, orientation: DropCursorOrientation): void;
+/**
+ * Returns the offset of the parent element for converting viewport coordinates to
+ * parent-relative coordinates. Handles document.body and static positioning.
+ */
+export declare function getParentOffsets(parent: HTMLElement | null): {
+    parentLeft: number;
+    parentTop: number;
+};

package/types/src/extensions/SuggestionMenu/SuggestionMenu.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "prosemirror-state";
+import { Plugin, Transaction } from "prosemirror-state";
 import { UiElementPosition } from "../../extensions-shared/UiElementPosition.js";
 export type SuggestionMenuState = UiElementPosition & {
     query: string;
@@ -12,6 +12,15 @@ type SuggestionPluginState = {
     decorationId: string;
     ignoreQueryLength?: boolean;
 } | undefined;
+export type SuggestionMenuOptions = {
+    triggerCharacter: string;
+    /**
+     * Optional callback to determine whether the suggestion menu should be
+     * opened in the current editor state. Return `false` to prevent the
+     * menu from opening (e.g. when the cursor is inside table content).
+     */
+    shouldOpen?: (tr: Transaction) => boolean;
+};
 /**
  * A ProseMirror plugin for suggestions, designed to make '/'-commands possible as well as mentions.
  *
@@ -40,8 +49,8 @@ export declare const SuggestionMenu: (options?: any) => import("../../index.js")
     } & {
         triggerCharacter: string;
     }) | undefined>;
-    readonly addTriggerCharacter: (triggerCharacter: string) => void;
-    readonly removeTriggerCharacter: (triggerCharacter: string) => void;
+    readonly addSuggestionMenu: (options: SuggestionMenuOptions) => void;
+    readonly removeSuggestionMenu: (triggerCharacter: string) => void;
     readonly closeMenu: () => void;
     readonly clearQuery: () => void;
     readonly shown: () => boolean;

package/types/src/extensions/SuggestionMenu/SuggestionMenu.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/src/index.d.ts

@@ -14,6 +14,7 @@ export * from "./editor/BlockNoteExtension.js";
 export * from "./editor/defaultColors.js";
 export * from "./editor/selectionTypes.js";
 export * from "./exporter/index.js";
+export * from "./extensions/index.js";
 export * from "./extensions-shared/UiElementPosition.js";
 export * from "./i18n/dictionary.js";
 export * from "./schema/index.js";

package/types/src/schema/blocks/createSpec.d.ts

@@ -3,7 +3,7 @@ import { TagParseRule } from "@tiptap/pm/model";
 import { NodeView } from "@tiptap/pm/view";
 import { Extension, ExtensionFactoryInstance } from "../../editor/BlockNoteExtension.js";
 import { PropSchema } from "../propTypes.js";
-import { BlockConfig, BlockImplementation, BlockSpec, LooseBlockSpec } from "./types.js";
+import { BlockConfig, BlockImplementation, BlockImplementationOrCreator, BlockSpec, LooseBlockSpec } from "./types.js";
 export declare function applyNonSelectableBlockFix(nodeView: NodeView, editor: Editor): void;
 export declare function getParseRules<TName extends string, TProps extends PropSchema, TContent extends "inline" | "none" | "table">(config: BlockConfig<TName, TProps, TContent>, implementation: BlockImplementation<TName, TProps, TContent>): TagParseRule[];
 export declare function addNodeAndExtensionsToSpec<TName extends string, TProps extends PropSchema, TContent extends "inline" | "none" | "table">(blockConfig: BlockConfig<TName, TProps, TContent>, blockImplementation: BlockImplementation<TName, TProps, TContent>, extensions?: (ExtensionFactoryInstance | Extension)[], priority?: number): LooseBlockSpec<TName, TProps, TContent>;
@@ -15,5 +15,5 @@ export declare function createBlockConfig<TCallback extends (options: Partial<Re
  * Helper function to create a block definition.
  * Can accept either functions that return the required objects, or the objects directly.
  */
-export declare function createBlockSpec<const TName extends string, const TProps extends PropSchema, const TContent extends "inline" | "none", const TOptions extends Partial<Record<string, any>> | undefined = undefined>(blockConfigOrCreator: BlockConfig<TName, TProps, TContent>, blockImplementationOrCreator: BlockImplementation<TName, TProps, TContent> | (TOptions extends undefined ? () => BlockImplementation<TName, TProps, TContent> : (options: Partial<TOptions>) => BlockImplementation<TName, TProps, TContent>), extensionsOrCreator?: ExtensionFactoryInstance[] | (TOptions extends undefined ? () => ExtensionFactoryInstance[] : (options: Partial<TOptions>) => ExtensionFactoryInstance[])): (options?: Partial<TOptions>) => BlockSpec<TName, TProps, TContent>;
-export declare function createBlockSpec<const TName extends string, const TProps extends PropSchema, const TContent extends "inline" | "none", const BlockConf extends BlockConfig<TName, TProps, TContent>, const TOptions extends Partial<Record<string, any>>>(blockCreator: (options: Partial<TOptions>) => BlockConf, blockImplementationOrCreator: BlockImplementation<BlockConf["type"], BlockConf["propSchema"], BlockConf["content"]> | (TOptions extends undefined ? () => BlockImplementation<BlockConf["type"], BlockConf["propSchema"], BlockConf["content"]> : (options: Partial<TOptions>) => BlockImplementation<BlockConf["type"], BlockConf["propSchema"], BlockConf["content"]>), extensionsOrCreator?: ExtensionFactoryInstance[] | (TOptions extends undefined ? () => ExtensionFactoryInstance[] : (options: Partial<TOptions>) => ExtensionFactoryInstance[])): (options?: Partial<TOptions>) => BlockSpec<BlockConf["type"], BlockConf["propSchema"], BlockConf["content"]>;
+export declare function createBlockSpec<const TName extends string, const TProps extends PropSchema, const TContent extends "inline" | "none", const TOptions extends Partial<Record<string, any>> | undefined = undefined>(blockConfigOrCreator: BlockConfig<TName, TProps, TContent>, blockImplementationOrCreator: BlockImplementationOrCreator<BlockConfig<TName, TProps, TContent>, TOptions>, extensionsOrCreator?: (ExtensionFactoryInstance | Extension)[] | (TOptions extends undefined ? () => (ExtensionFactoryInstance | Extension)[] : (options: Partial<TOptions>) => (ExtensionFactoryInstance | Extension)[])): (options?: Partial<TOptions>) => BlockSpec<TName, TProps, TContent>;
+export declare function createBlockSpec<const TName extends string, const TProps extends PropSchema, const TContent extends "inline" | "none", const BlockConf extends BlockConfig<TName, TProps, TContent>, const TOptions extends Partial<Record<string, any>>>(blockCreator: (options: Partial<TOptions>) => BlockConf, blockImplementationOrCreator: BlockImplementationOrCreator<BlockConf, TOptions>, extensionsOrCreator?: (ExtensionFactoryInstance | Extension)[] | (TOptions extends undefined ? () => (ExtensionFactoryInstance | Extension)[] : (options: Partial<TOptions>) => (ExtensionFactoryInstance | Extension)[])): (options?: Partial<TOptions>) => BlockSpec<BlockConf["type"], BlockConf["propSchema"], BlockConf["content"]>;