@domternal/extension-block-menu 0.7.0

package/dist/index.d.ts

@@ -0,0 +1,607 @@
+import { Extension, Editor, FloatingMenuItemsOverride, FloatingMenuItem } from '@domternal/core';
+import { EditorState, PluginKey, Plugin } from '@domternal/pm/state';
+import { EditorView } from '@domternal/pm/view';
+import { Node, ResolvedPos, Attrs } from '@domternal/pm/model';
+
+/**
+ * Block-insert menu shown when the cursor sits at the start of an empty
+ * paragraph. Items collected via `addFloatingMenuItems()`. This file owns
+ * visibility, positioning, dismiss, and keyboard entry; framework wrappers
+ * render the UI.
+ */
+
+declare const floatingMenuPluginKey: PluginKey<any>;
+/**
+ * Keyboard shortcuts that move focus from the editor into the menu.
+ * Defaults combine the WAI-ARIA recommendation (`Alt-F10`) with a
+ * modern slash-command-friendly shortcut (`Mod-/`). Set to an empty
+ * array to disable keyboard entry entirely.
+ */
+interface FloatingMenuKeymap {
+    /** Shortcuts that focus the first menu item when the menu is visible. */
+    enterMenu?: string[];
+}
+interface FloatingMenuOptions {
+    /**
+     * The HTML element that contains the menu. Required when used directly;
+     * framework wrappers create this element and pass it in.
+     */
+    element: HTMLElement | null;
+    /**
+     * Visibility predicate. Defaults to `defaultShouldShow` (empty paragraph
+     * at cursor start).
+     */
+    shouldShow: (props: {
+        editor: Editor;
+        view: EditorView;
+        state: EditorState;
+    }) => boolean;
+    /**
+     * Pixel offset from the anchor. @default 0
+     */
+    offset: number;
+    /**
+     * Items override. Array replaces defaults entirely; function receives
+     * the collected defaults and returns a new list (filter/reorder/extend).
+     * Consumed by the controller; the plugin itself only reads it when the
+     * wrapper does not construct its own controller.
+     */
+    items?: FloatingMenuItemsOverride;
+    /** Keyboard shortcuts for entering the menu via keyboard. */
+    keymap?: FloatingMenuKeymap;
+    /**
+     * When `true`, the menu only appears when EXPLICITLY triggered via
+     * `showFloatingMenu(view)` (typically from BlockHandle's `+` button).
+     * Pressing `Enter` to create a new empty paragraph no longer auto-shows
+     * the menu. Mirrors Notion's behaviour: empty rows display a placeholder
+     * hint, the slash command (`/`) is the keyboard trigger, and the menu
+     * opens via the gutter `+` button only.
+     *
+     * @default false (auto-shows on every empty paragraph - backward compat)
+     */
+    requireExplicitTrigger?: boolean;
+}
+interface CreateFloatingMenuPluginOptions {
+    pluginKey: PluginKey;
+    editor: Editor;
+    element: HTMLElement;
+    shouldShow?: FloatingMenuOptions['shouldShow'];
+    offset?: number;
+    keymap?: FloatingMenuKeymap | undefined;
+    requireExplicitTrigger?: boolean;
+}
+/**
+ * Creates a standalone FloatingMenu ProseMirror plugin. Framework wrappers
+ * call this directly so they can own element creation and rendering.
+ */
+declare function createFloatingMenuPlugin(options: CreateFloatingMenuPluginOptions): Plugin;
+declare const FloatingMenu: Extension<FloatingMenuOptions, unknown>;
+
+/**
+ * Gutter-bias resolution for nested drag-target selection.
+ *
+ * When the cursor sits near a configured edge of a candidate's rect, the
+ * candidate is treated as "in the gutter" and its rank weight is reduced
+ * proportionally to its tree depth. Shallower (outer) ancestors therefore
+ * win against deeply-nested descendants in the gutter zone.
+ *
+ * The "deepest-match" mode skips this bias entirely and always returns the
+ * innermost allowed block under the cursor.
+ */
+/** Cardinal edge of a candidate's bounding rect. */
+type GutterEdge = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Named presets for the bias config:
+ *  - `'left'`  → ['left', 'top']  (left gutter, default)
+ *  - `'right'` → ['right', 'top'] (right gutter, RTL-friendly)
+ *  - `'both'`  → ['left', 'right', 'top']
+ *  - `'none'`  → no gutter bias (deepest match wins)
+ */
+type GutterBiasPreset = 'left' | 'right' | 'both' | 'none';
+interface GutterBiasConfig {
+    /** Edges that constitute the "gutter" zone. */
+    edges: GutterEdge[];
+    /** Pixel distance from the edge at which the bias activates. */
+    threshold: number;
+    /** Bias factor applied per depth level when in the gutter. */
+    strength: number;
+}
+
+/**
+ * Predicate-based block matching for nested drag-target resolution.
+ *
+ * A matcher answers one question for a candidate node: "should this be
+ * eligible to become the drag target?" Predicates return a verdict (allow
+ * or reject), and the resolver filters the candidate list before ranking.
+ *
+ * This replaces the score-deduction approach with explicit verdicts so
+ * the contract is binary: a candidate is either eligible or it isn't,
+ * with rank decided separately by depth + optional gutter bias.
+ */
+
+/** Eligibility verdict returned by a matcher's `test()`. */
+type MatchVerdict = 'allow' | 'reject';
+/**
+ * Information passed to a matcher about the node being considered.
+ * Bundles the node itself, its position metadata, its parent context,
+ * and the live editor view (in case a matcher needs DOM lookups).
+ */
+interface BlockCandidate {
+    /** The PM node being considered as a drag target. */
+    block: Node;
+    /** Document position immediately before `block`. */
+    documentPos: number;
+    /** Depth in the PM tree; 0 is the doc root and is never a candidate. */
+    treeDepth: number;
+    /** Parent node, or `null` when there is no parent. */
+    container: Node | null;
+    /** Index of `block` inside `container.content`. */
+    positionInContainer: number;
+    /** Convenience: `positionInContainer === 0`. */
+    isFirstChild: boolean;
+    /** Convenience: `positionInContainer === container.childCount - 1`. */
+    isLastChild: boolean;
+    /** The ProseMirror resolved position the resolver started from. */
+    resolvedPos: ResolvedPos;
+    /** Live editor view; matchers may call `editorView.nodeDOM(pos)`. */
+    editorView: EditorView;
+}
+/**
+ * A single matcher with a stable name (for debugging / opt-out) and a
+ * pure-function predicate.
+ */
+interface BlockMatcher {
+    name: string;
+    test(candidate: BlockCandidate): MatchVerdict;
+}
+
+/**
+ * BlockHandle Extension
+ *
+ * Renders a Notion-style gutter handle on the left side of each top-level
+ * block when the user hovers over the editor. The handle exposes two
+ * buttons:
+ *
+ * 1. `⋮⋮` drag handle (click → opens BlockContextMenu, drag → reorder)
+ * 2. `+` insert button (inserts an empty paragraph below the block; the
+ *    FloatingMenu extension picks up the empty-line state and auto-shows
+ *    its insert menu)
+ *
+ * Visibility + drag + context-menu trigger are fully owned by this plugin;
+ * the context menu UI itself lives in `BlockContextMenu.ts` and listens for
+ * the `dm:block-context-menu-open` custom event that this plugin dispatches.
+ *
+ * Styles ship via `@domternal/theme` (`_block-handle.scss`). The plugin
+ * adds a `dm-editor--has-block-handle` class to the `.dm-editor` container
+ * so the theme stylesheet can widen `.ProseMirror` padding-left to create
+ * gutter space inside the `overflow:hidden` editor wrapper.
+ */
+
+/** Default list of nodes treated as drag-targetable when `nested: true`. */
+declare const DEFAULT_NESTED_NODES: string[];
+declare const blockHandlePluginKey: PluginKey<BlockHandlePluginState>;
+interface BlockHandleOptions {
+    /**
+     * Milliseconds to wait before hiding the handle after the mouse leaves
+     * the editor. Gives users time to move into the handle without it
+     * disappearing.
+     * @default 200
+     */
+    hideDelay?: number;
+    /**
+     * Disable drag-to-reorder while still showing the plus/drag buttons
+     * (drag becomes a no-op, click opens context menu only).
+     * @default false
+     */
+    disableDrag?: boolean;
+    /**
+     * Auto-scroll the nearest scrollable ancestor when the user drags near
+     * the top/bottom edge of the viewport. Disable if the host app manages
+     * its own drag scroll behaviour.
+     * @default true
+     */
+    autoScroll?: boolean;
+    /**
+     * Distance in CSS pixels from the top/bottom edge that triggers
+     * auto-scroll. Larger values start scrolling sooner.
+     * @default 48
+     */
+    autoScrollThreshold?: number;
+    /**
+     * Peak scroll speed in CSS pixels per animation frame. Speed ramps
+     * linearly from 0 at the threshold to this value at the edge.
+     * @default 18
+     */
+    autoScrollMaxSpeed?: number;
+    /**
+     * Whether the handle should resolve to nested block containers (list
+     * items, task items, and optionally others) instead of always the
+     * top-level block.
+     *
+     * - `false` - only top-level blocks are hoverable / draggable (default).
+     * - `true` - list items and task items resolve individually (Notion behaviour).
+     * - object - fine-grained config; see `NestedConfig`.
+     *
+     * @default false
+     */
+    nested?: boolean | NestedConfig;
+    /**
+     * Pixel threshold from the LEFT edge of a list item beyond which a
+     * drop commits to nested-child mode (the dragged block becomes the
+     * last child of that item) instead of sibling mode (a new list item
+     * created next to it). Mirrors Notion's "drop indented = nested,
+     * drop on the marker = sibling" UX.
+     *
+     * Set to `0` to disable nested-drop entirely (every drop is sibling).
+     *
+     * The X-detection only fires when nested mode is on AND the resolved
+     * target is a `listItem` / `taskItem`. Other containers stay sibling-
+     * only until explicit support lands.
+     *
+     * @default 28
+     */
+    nestThreshold?: number;
+    /**
+     * Show a custom drop indicator line during drag-from-handle that
+     * mirrors EXACTLY where the drop will land. Replaces the need for
+     * `prosemirror-dropcursor` for our drag flow - `dropcursor` uses
+     * PM's default `posAtCoords` which can disagree with our resolver
+     * (especially in side-gutter / inter-block-gap drops).
+     *
+     * Set to `false` if you want the standard `prosemirror-dropcursor`
+     * behaviour or are providing your own indicator.
+     * @default true
+     */
+    dropIndicator?: boolean;
+}
+/**
+ * Configuration for nested resolution. Backwards-compatible with the
+ * earlier `{ allowedNodes }` literal - every field is optional.
+ */
+interface NestedConfig {
+    /**
+     * Node type names treated as drag targets when nested mode is on.
+     * @default ['listItem', 'taskItem']
+     */
+    allowedNodes?: string[];
+    /**
+     * Restrict resolution to nodes that have at least one ancestor of one
+     * of these type names. Use to scope nested mode to specific structures
+     * (e.g. only inside `table`). Empty / omitted → no restriction.
+     */
+    allowedContainers?: string[];
+    /**
+     * "Promote to parent at the gutter" behaviour. When the cursor is
+     * within `threshold` px of a configured edge, the candidate's score
+     * is reduced by `strength * depth` - deeper nodes are penalised
+     * more, so a shallower ancestor (e.g. the wrapping list) wins near
+     * the boundary.
+     *
+     * - `false` / `undefined` / `'none'` → deepest match wins.
+     * - `true` / `'left'` → defaults: edges `['left','top']`, threshold 12, strength 500.
+     * - `'right'` / `'both'` → preset variants.
+     * - object → custom config (any field optional, merged over defaults).
+     *
+     * @default false
+     */
+    promoteOnEdge?: boolean | GutterBiasPreset | Partial<GutterBiasConfig>;
+    /**
+     * Append custom block matchers. Default matchers still apply unless
+     * `defaultMatchers: false` is also set.
+     */
+    matchers?: BlockMatcher[];
+    /**
+     * Set to `false` to disable the four built-in matchers
+     * (firstChildOfListItem, listContainerSkip, tableInternals,
+     * inlineNodes). Almost always wanted; opt-out only for testing or
+     * specialised host editors.
+     * @default true
+     */
+    defaultMatchers?: boolean;
+}
+interface BlockHandlePluginState {
+    /** Absolute position of the top-level block currently under the cursor, or null. */
+    hoveredPos: number | null;
+    /**
+     * Source position of the block currently being dragged (set on
+     * dragstart, cleared on dragend). Used by `handleDrop` to determine
+     * whether the drop originated from our handle.
+     */
+    draggedFrom: number | null;
+}
+/**
+ * Internal, fully-resolved view of `NestedConfig`. Plain string arrays
+ * + an optional edge config so the resolver doesn't have to interpret
+ * presets at hover time.
+ */
+interface NestedResolution {
+    /** Allowed drag targets. Empty array → top-level-only mode. */
+    allowedNodes: string[];
+    /** Optional ancestor whitelist; empty array → no restriction. */
+    allowedContainers: string[];
+    /** Gutter bias config; `null` → deepest match wins. */
+    gutterBias: GutterBiasConfig | null;
+    /** Effective matcher list (defaults + user, or just user when defaults off). */
+    matchers: BlockMatcher[];
+}
+interface CreateBlockHandlePluginOptions {
+    pluginKey: PluginKey<BlockHandlePluginState>;
+    editor: Editor;
+    hideDelay: number;
+    disableDrag: boolean;
+    autoScroll: boolean;
+    autoScrollThreshold: number;
+    autoScrollMaxSpeed: number;
+    nested: NestedResolution;
+    dropIndicator: boolean;
+    /**
+     * Pixel threshold for nested-drop X-detection (see `BlockHandleOptions.nestThreshold`).
+     * `0` disables nested-drop.
+     */
+    nestThreshold: number;
+}
+/**
+ * Creates a standalone BlockHandle ProseMirror plugin. Exported so
+ * framework wrappers can build on top without going through the Extension
+ * factory.
+ */
+declare function createBlockHandlePlugin(options: CreateBlockHandlePluginOptions): Plugin<BlockHandlePluginState>;
+declare const BlockHandle: Extension<BlockHandleOptions, unknown>;
+
+/**
+ * Built-in eligibility matchers. Together they constrain the drag
+ * resolver to "user-visible block units" (paragraphs, headings, list
+ * items, task items, images, etc.) and exclude structural plumbing
+ * (table cells, inline text, list containers whose items are draggable
+ * individually).
+ *
+ * Hosts can disable the bundled set with `defaultMatchers: false` and
+ * supply their own matcher list via `matchers`.
+ */
+
+declare const DEFAULT_BLOCK_MATCHERS: readonly BlockMatcher[];
+
+/**
+ * `Mod-Shift-ArrowUp` / `Mod-Shift-ArrowDown` move the top-level block
+ * containing the selection. Accessibility companion to BlockHandle drag.
+ * Shares `moveBlock` so position math and self-move rejection match.
+ */
+
+declare const KeyboardReorder: Extension<unknown, unknown>;
+
+/**
+ * Editor commands the menu can route to for wrapper-style "Turn into".
+ * Each maps to a command from the corresponding node extension.
+ */
+type WrapperCommand = 'toggleBulletList' | 'toggleOrderedList' | 'toggleTaskList' | 'toggleBlockquote';
+
+/**
+ * BlockContextMenu Extension
+ *
+ * Popup menu that opens when the user clicks the BlockHandle `⋮⋮` drag
+ * handle without dragging. Offers block-level operations for the target:
+ *
+ * - **Delete**    - remove the block
+ * - **Duplicate** - insert an identical copy below
+ * - **Turn into** - change the block type (paragraph, heading, quote, etc.)
+ *
+ * Triggered by the `dm:block-context-menu-open` custom event dispatched
+ * from BlockHandle; payload carries `{ blockPos, anchorElement }`.
+ *
+ * Implementation mirrors FloatingMenu / SlashCommand styling conventions
+ * so theming is consistent: `role="menu"` container, `role="menuitem"`
+ * buttons, `data-show` for visibility, positioned via `positionFloatingOnce`.
+ */
+
+/**
+ * `props.decorations` reads `activeBlockPos` and applies the
+ * `dm-block-context-active` class via a PM Decoration. Decoration
+ * survives view rerenders that other transactions trigger (e.g.
+ * UniqueID stamping `id` via setNodeMarkup); inline classList
+ * mutation does not.
+ */
+interface BlockContextMenuPluginState {
+    activeBlockPos: number | null;
+}
+declare const blockContextMenuPluginKey: PluginKey<BlockContextMenuPluginState>;
+/**
+ * A target type the user can convert the current block into via the
+ * "Turn into" submenu.
+ */
+interface TurnIntoTarget {
+    /** Display label, e.g. "Heading 1". */
+    label: string;
+    /** Icon key resolved against `defaultIcons`. */
+    icon: string;
+    /** Schema node name, e.g. "heading", "paragraph", "blockquote". */
+    nodeType: string;
+    /** Optional node attributes (e.g. `{ level: 1 }` for Heading 1). */
+    attrs?: Attrs;
+    /**
+     * Editor command to invoke for non-textblock (wrapper) targets like
+     * lists and blockquote. When set, runTurnInto routes through
+     * `turnIntoWrapper` which sets selection then dispatches the
+     * command, instead of calling `setBlockType`. Leave undefined for
+     * textblock targets (paragraph, heading, codeBlock).
+     */
+    command?: WrapperCommand;
+}
+interface BlockContextMenuOptions {
+    /**
+     * Show the "Turn into" section of the menu. Disable to limit operations
+     * to Delete + Duplicate.
+     * @default true
+     */
+    turnIntoEnabled?: boolean;
+    /**
+     * Block types offered by "Turn into". Override to curate the list or
+     * add project-specific block types.
+     * @default DEFAULT_TURN_INTO
+     */
+    turnIntoTargets?: TurnIntoTarget[];
+    /**
+     * Show "Copy link" when the target block has an id attribute AND the
+     * `UniqueID` extension is loaded in the editor. Without UniqueID this
+     * option has no effect - the item never appears regardless of value.
+     * @default true
+     */
+    copyLinkEnabled?: boolean;
+    /**
+     * Build the URL written to the clipboard when the user clicks "Copy link".
+     * Receives the block's id and the editor; returns a full URL. Default
+     * appends `#<id>` to the current pathname+search, which works for static
+     * pages. Frameworks with client-side routing should provide a callback
+     * matching their URL scheme.
+     */
+    onCopyLink?: (blockId: string, editor: Editor) => string;
+    /**
+     * Show the Colors section (text color + background) when the `BlockColor`
+     * extension is loaded and the target block is in its `types` list.
+     * Without BlockColor this option has no effect.
+     * @default true
+     */
+    blockColorEnabled?: boolean;
+}
+interface CreateBlockContextMenuPluginOptions {
+    pluginKey: PluginKey<BlockContextMenuPluginState>;
+    editor: Editor;
+    turnIntoEnabled: boolean;
+    turnIntoTargets: TurnIntoTarget[];
+    copyLinkEnabled: boolean;
+    onCopyLink: (blockId: string, editor: Editor) => string;
+    blockColorEnabled: boolean;
+}
+/**
+ * Creates the BlockContextMenu ProseMirror plugin. Builds an absolutely
+ * positioned popup DOM, listens for `dm:block-context-menu-open` on the
+ * `.dm-editor` container, and executes block operations via the shared
+ * helpers in `helpers/blockOperations.ts`.
+ */
+declare function createBlockContextMenuPlugin(options: CreateBlockContextMenuPluginOptions): Plugin;
+declare const BlockContextMenu: Extension<BlockContextMenuOptions, unknown>;
+
+/**
+ * `/` trigger that opens a filtered popup of insertable blocks. Items are
+ * shared with FloatingMenu and BlockHandle via `addFloatingMenuItems()`.
+ * On select, the `/query` range is deleted and the item's command runs at
+ * the now-empty cursor (so "Heading 1" transforms the block, "Image" opens
+ * its popover, etc.).
+ */
+
+declare const slashCommandPluginKey: PluginKey<SlashCommandPluginState>;
+interface SlashCommandProps {
+    /** The editor instance (passed so custom renderers can read state). */
+    editor: Editor;
+    /** Current query string (text after the `/`). */
+    query: string;
+    /** Document range of the `/` + query (for replacement). */
+    range: {
+        from: number;
+        to: number;
+    };
+    /** Filtered and ranked items matching the query. */
+    items: FloatingMenuItem[];
+    /** Execute the selected item and close the popup. */
+    command: (item: FloatingMenuItem) => void;
+    /** Returns the client rect of the cursor for positioning the popup. */
+    clientRect: () => DOMRect | null;
+    /** The editor's ProseMirror DOM node (for portal parents etc.). */
+    element: HTMLElement;
+}
+interface SlashCommandRenderer {
+    onStart: (props: SlashCommandProps) => void;
+    onUpdate: (props: SlashCommandProps) => void;
+    onExit: () => void;
+    /** Return `true` to consume the key event and prevent default handling. */
+    onKeyDown: (event: KeyboardEvent) => boolean;
+}
+interface SlashCommandOptions {
+    /**
+     * The trigger character. @default '/'
+     */
+    char?: string;
+    /**
+     * Items override. When omitted, items from `editor.floatingMenuItems`
+     * (collected via `addFloatingMenuItems()`) are used. An array replaces
+     * defaults; a function transforms them.
+     */
+    items?: FloatingMenuItemsOverride;
+    /**
+     * Factory returning render callbacks for the popup. Default uses
+     * `createSlashSuggestionRenderer()`.
+     */
+    render?: () => SlashCommandRenderer;
+    /**
+     * Node types where slash should NOT activate (e.g. `codeBlock`).
+     * @default ['codeBlock']
+     */
+    invalidNodes?: string[];
+}
+interface CreateSlashCommandPluginOptions {
+    pluginKey: PluginKey<SlashCommandPluginState>;
+    editor: Editor;
+    char: string;
+    items?: FloatingMenuItemsOverride;
+    render: () => SlashCommandRenderer;
+    invalidNodes: string[];
+}
+interface SlashCommandPluginState {
+    active: boolean;
+    query: string;
+    range: {
+        from: number;
+        to: number;
+    } | null;
+}
+/**
+ * Filters and ranks FloatingMenuItems against a query. Priority:
+ *   1. Exact label prefix (case-insensitive)
+ *   2. Label substring match
+ *   3. Keyword match (preserving original keyword index for stable ranking)
+ * Returns items in rank order, stable within the same rank.
+ */
+declare function filterSlashItems(items: FloatingMenuItem[], query: string): FloatingMenuItem[];
+declare function createSlashCommandPlugin(options: CreateSlashCommandPluginOptions): Plugin<SlashCommandPluginState>;
+declare const SlashCommand: Extension<SlashCommandOptions, unknown>;
+/**
+ * Programmatically dismisses the slash suggestion.
+ */
+declare function dismissSlashCommand(view: EditorView): void;
+
+declare function createSlashSuggestionRenderer(): SlashCommandRenderer;
+
+/**
+ * Pasting block-level content at an INLINE position normally goes through PM's
+ * content fitter, which strips the block wrapper and pastes only inline text.
+ * SmartPaste catches the relevant cases and routes each to the right strategy:
+ *
+ *  1. List slice into a list ancestor: items adapted (`convertListItemForParent`)
+ *     and merged as siblings, preserving the surrounding list.
+ *  2. Trailing hardBreak (Shift+Enter scenario): trim the hardBreak and insert
+ *     the slice as a sibling after the parent.
+ *  3. Truly empty parent paragraph (`parentSize === 0`): replace the parent.
+ *  4-6. Caret at start / end / middle: insert as sibling or split-and-insert.
+ *  7. Range selection: delete first, then run through 2-6.
+ *
+ * Skipped (PM default applies) when:
+ *  - Cursor isn't inside a textblock.
+ *  - Slice's top-level blocks are ALL plain paragraphs.
+ *  - Slice is a SINGLE top-level block of the SAME TYPE as the destination
+ *    (heading-into-heading, etc.) - PM's inline merge is the intended behavior.
+ *
+ * Note: do NOT bail on `openStart > 0` - PM's clipboard parser routinely sets
+ * `openStart=1` even for closed-looking input like `<h1>x</h1>`. Top-level
+ * children of the slice are what matter.
+ */
+
+interface SmartPasteOptions {
+    /**
+     * Disable the plugin without removing the extension. Useful for tests
+     * or to fall back to PM's default paste handling temporarily.
+     * @default true
+     */
+    enabled?: boolean;
+}
+declare const SmartPaste: Extension<SmartPasteOptions, unknown>;
+
+export { type BlockCandidate, BlockContextMenu, type BlockContextMenuOptions, BlockHandle, type BlockHandleOptions, type BlockHandlePluginState, type BlockMatcher, type CreateBlockContextMenuPluginOptions, type CreateBlockHandlePluginOptions, type CreateFloatingMenuPluginOptions, type CreateSlashCommandPluginOptions, DEFAULT_BLOCK_MATCHERS, DEFAULT_NESTED_NODES, FloatingMenu, type FloatingMenuKeymap, type FloatingMenuOptions, KeyboardReorder, type MatchVerdict, type NestedConfig, SlashCommand, type SlashCommandOptions, type SlashCommandPluginState, type SlashCommandProps, type SlashCommandRenderer, SmartPaste, type SmartPasteOptions, type TurnIntoTarget, type WrapperCommand, blockContextMenuPluginKey, blockHandlePluginKey, createBlockContextMenuPlugin, createBlockHandlePlugin, createFloatingMenuPlugin, createSlashCommandPlugin, createSlashSuggestionRenderer, dismissSlashCommand, filterSlashItems, floatingMenuPluginKey, slashCommandPluginKey };