suneditor 3.2.6 → 3.3.1

package/types/core/logic/panel/blockHandle.d.ts

@@ -12,9 +12,8 @@ declare class BlockHandle {
 	 * @param {HTMLElement} blockHandle - Handle group (.se-block-handle)
 	 * @param {HTMLElement} blockHandlePlus - Plus button
 	 * @param {HTMLElement} blockHandleDrag - Drag button
-	 * @param {Array<string | { title: string, icon?: string, action: function(SunEditor.Deps, { block: HTMLElement }): void }>|null} menuConfig
-	 *   Menu entries. Strings resolve via `ResolveButton` (plugin names, built-in commands). Objects
-	 *   define a custom row whose `action` is invoked with the Deps bag and the current block element.
+	 * @param {Object|Array<*>|null} blockHandleOptions - The `blockHandle` option object (`{ menu, onPlusClick, maxHeight, minWidth }`).
+	 * - An array is accepted as a shorthand for `{ menu: [...] }`.
 	 */
 	constructor(
 		$: SunEditor.Deps,
@@ -22,19 +21,7 @@ declare class BlockHandle {
 		blockHandle: HTMLElement,
 		blockHandlePlus: HTMLElement,
 		blockHandleDrag: HTMLElement,
-		menuConfig: Array<
-			| string
-			| {
-					title: string;
-					icon?: string;
-					action: (
-						arg0: SunEditor.Deps,
-						arg1: {
-							block: HTMLElement;
-						},
-					) => void;
-			  }
-		> | null,
+		blockHandleOptions: any | Array<any> | null,
 	);
 	/**
 	 * @description Position the block handle for the given mouse target. Uses rAF throttle.

package/types/core/logic/panel/menu.d.ts

@@ -118,6 +118,14 @@ declare class Menu {
 	 * @description Closes the currently open dropdown menu.
 	 */
 	dropdownOff(): void;
+	/**
+	 * @description Subscribe to be notified after a dropdown is turned off — i.e. a dropdown-free
+	 * plugin committed and closed itself via {@link dropdownOff}. Mirrors {@link Store#subscribe}:
+	 * returns an unsubscribe function.
+	 * @param {() => void} callback
+	 * @returns {() => void} Unsubscribe function
+	 */
+	subscribeDropdownOff(callback: () => void): () => void;
 	/**
 	 * @description Shows a previously hidden dropdown menu that is still in `on` state.
 	 * - Only works when a dropdown is active (`currentButton` exists)

package/types/core/logic/shell/ui.d.ts

@@ -15,11 +15,6 @@ declare class UIManager {
 	toastPopup: HTMLElement;
 	toastContainer: Element;
 	toastMessage: HTMLSpanElement;
-	/**
-	 * @description Whether `SelectMenu` is open
-	 * @type {boolean}
-	 */
-	selectMenuOn: boolean;
 	/**
 	 * @description Currently open `Controller` info array
 	 * @type {Array<SunEditor.Module.Controller.Info>}
@@ -36,6 +31,20 @@ declare class UIManager {
 	 * @type {?HTMLElement}
 	 */
 	_figureContainer: HTMLElement | null;
+	/**
+	 * @description Whether any `SelectMenu` is currently open.
+	 * - Read-only: a menu announces itself through {@link setSelectMenuOpen}. Derived from the set of
+	 * open instances so an unrelated menu closing cannot clear the flag for a menu that is still open.
+	 * @returns {boolean}
+	 */
+	get selectMenuOn(): boolean;
+	/**
+	 * @internal
+	 * @description `SelectMenu` open-state notification. Called by `SelectMenu.open()` / `.close()`.
+	 * @param {*} instance The `SelectMenu` instance changing state
+	 * @param {boolean} open `true` on open, `false` on close
+	 */
+	setSelectMenuOpen(instance: any, open: boolean): void;
 	/**
 	 * @description Set editor frame styles.
 	 * - Define the style of the edit area
@@ -231,6 +240,23 @@ declare class UIManager {
 	 * @param {SunEditor.FrameContext} [fc] - Frame context (defaults to current frameContext)
 	 */
 	_updatePlaceholder(fc?: SunEditor.FrameContext): void;
+	/**
+	 * @description Resolves the per-line placeholder text for an empty line from the `placeholder_line` option.
+	 * - String option: one hint for every empty line — except list cells and table cells (backward compatible).
+	 * - Object option: keyed by tag name or a category sentinel matching the editor's format classification
+	 *   ({@link Format#isNormalLine}, `isBrLine`, `isClosureBrLine`, `isBlock`, `isClosureBlock`, list cells).
+	 * @param {?Node} line - The (empty) line element.
+	 * @param {string|Object<string, string>} opt - The `placeholder_line` option value.
+	 * @returns {string} The resolved placeholder text (`''` = none).
+	 */
+	resolveLinePlaceholder(
+		line: Node | null,
+		opt:
+			| string
+			| {
+					[x: string]: string;
+			  },
+	): string;
 	/**
 	 * @internal
 	 * @description Synchronizes frame UI state after content changes.

package/types/core/schema/frameContext.d.ts

@@ -33,7 +33,7 @@ import type {} from '../../typedef';
  * @property {HTMLTextAreaElement} markdown - Markdown view editing element (a <textarea>).
  * @property {HTMLTextAreaElement} markdownNumbers - Element displaying line numbers in markdown view mode.
  * @property {HTMLElement} placeholder - Placeholder element shown when the editor is empty.
- * @property {string} placeholder_line - Per-line placeholder text, rendered via a `::before` on the focused empty line.
+ * @property {string|Object<string, string>} placeholder_line - Per-line placeholder text, rendered via a `::before` on the focused empty line.
  * @property {HTMLElement} statusbar - Editor status bar element (for resizing, info, etc.).
  * @property {HTMLElement} navigation - Navigation element (e.g., for outline or bookmarks).
  * @property {HTMLElement} charWrapper - Wrapper for the character counter element.
@@ -216,7 +216,11 @@ export type FrameContextStore = {
 	/**
 	 * - Per-line placeholder text, rendered via a `::before` on the focused empty line.
 	 */
-	placeholder_line: string;
+	placeholder_line:
+		| string
+		| {
+				[x: string]: string;
+		  };
 	/**
 	 * - Editor status bar element (for resizing, info, etc.).
 	 */

package/types/core/schema/options.d.ts

@@ -56,8 +56,22 @@ export namespace DEFAULTS {
  * === Content & Editing ===
  * @property {string} [value=""] - Initial value for the editor.
  * @property {string} [placeholder=""] - Placeholder text shown when the whole editor is empty.
- * @property {string} [placeholder_line=""] - per-line placeholder shown on the focused
+ * @property {string|Object<string, string>} [placeholder_line=""] - per-line placeholder shown on the focused
  * line when that line is empty. Takes priority over `placeholder` while a line is focused.
+ * - **string**: one hint for every empty line (list cells and table cells excluded).
+ * - **object**: per-type hints keyed by tag name (`p`, `pre`, `blockquote`, ...) or a category sentinel
+ * matching the editor's format classification: `@line`, `@normalLine`, `@list`, `@brLine`, `@closureBrLine`,
+ * `@block`, `@closureBlock`. Resolved most-specific → least, like `tagStyles`:
+ * `<tag>` → `@list` → `@closureBrLine` → `@brLine` → block container (`<blockTag>` → `@closureBlock` → `@block`)
+ * → `@normalLine` → `@line`. A missing key = no placeholder for that type; an explicit `''` suppresses it.
+ * ```js
+ * // one hint everywhere
+ * placeholder_line: 'Type something…'
+ * // per-type
+ * placeholder_line: {
+ *   '@normalLine': 'Type…', '@list': 'List item', '@block': 'Quote…', '@closureBlock': 'Cell', pre: '// code'
+ * }
+ * ```
  * @property {Object<string, string>} [editableFrameAttributes={spellcheck: "false"}] - Attributes for the editable frame[.sun-editor-editable].
  * ```js
  * { editableFrameAttributes: { spellcheck: 'true', autocomplete: 'on' } }
@@ -256,9 +270,25 @@ export namespace DEFAULTS {
  *   menu: [
  *     'p', 'heading', 'blockStyle',
  *     { title: 'Duplicate', icon: 'copy', action: ($, { block }) => block.after(block.cloneNode(true)) },
+ *     // `'table'` as a string opens the size picker; a custom item inserts a default table directly
+ *     { title: 'Table', icon: 'table', action: ($) => $.plugins.table.insert(3, 3) },
  *   ],
  * }
  * ```
+ * @property {string} [blockHandle.maxHeight=""] - Max height of the menu list. Any CSS length; the list scrolls past it.
+ * - Unset by default: the menu grows with its items and is only clamped when it would overflow the viewport.
+ * @property {string} [blockHandle.minWidth="200px"] - Min width of the menu.
+ * @property {function(SunEditor.Deps, { block: HTMLElement, openMenu: function(): void }): void} [blockHandle.onPlusClick] - Runs after the plus button inserted a new line.
+ * - Adding the line is fixed behavior; this hook decides what happens next. Nothing does by default.
+ * - `block` is the new line, already focused. `openMenu()` opens the block handle's own `menu`.
+ * ```js
+ * blockHandle: {
+ *   // open the block handle menu
+ *   onPlusClick: ($, { openMenu }) => openMenu(),
+ *   // ...or the slash command menu
+ *   onPlusClick: ($, { block }) => $.plugins.slashCommand.open(block),
+ * }
+ * ```
  * @property {string} [type=""] - Editor type. Use `"document"` for a document-style layout, with optional sub-types after `:`.
  * ```js
  * // type
@@ -403,6 +433,13 @@ export namespace DEFAULTS {
  * - Formats that include `line`, such as "Quote", still operate on a `line` basis.
  * - suneditor processes work in `line` units.
  * - When set to `br`, performance may decrease when editing a lot of data.
+ * @property {boolean} [lineBreakClearStyle=false] - When `true`, pressing Enter at the **end** of a line
+ * starts a fresh line that does not carry the caret's inline style nodes (e.g. bold/italic/color spans, links);
+ * the line-level element and its attributes are preserved.
+ * Only affects the end-of-line case — mid-line splits, start-of-line breaks, and Shift+Enter are unchanged.
+ * ```js
+ * { lineBreakClearStyle: true }
+ * ```
  * @property {string} [lineAttrReset=""] - Line properties that should be reset when changing lines. Delimiter: `"|"`.
  * ```js
  * { lineAttrReset: 'id|name' }
@@ -453,12 +490,16 @@ export namespace DEFAULTS {
  * { toolbar_innerWidth: 'auto' }
  * ```
  * @property {?HTMLElement} [toolbar_container] - Container element for the toolbar.
- * @property {number|{top: number, offset: number}} [toolbar_sticky=0] - Enables sticky toolbar.
+ * @property {number|{top: number, offset?: number, position?: "sticky"|"fixed"}} [toolbar_sticky=0] - Enables sticky toolbar.
  * - `number`: Sets the sticky top position (px). Use `-1` to disable sticky.
  * - `{top, offset}`: `top` is the sticky position when the page header is visible.
  * - `offset` is the sticky position when a virtual keyboard shifts the viewport (e.g., on tablets, touch devices).
  * - When the virtual keyboard is active, `offset` replaces `top` so the toolbar doesn't leave a gap
  * - for a page header that has scrolled out of view. Default `offset` is `0`.
+ * - `position` (default `"sticky"`): the positioning engine.
+ * - `"sticky"` uses native CSS `position: sticky` (with a JS `position: fixed` fallback where unsupported).
+ * `"fixed"` forces the JS `position: fixed` engine
+ * - even when CSS sticky is supported — for environments where CSS sticky silently misbehaves and can't be
  * ```js
  * // Basic usage — sticky at top with 0px offset
  * toolbar_sticky: 0
@@ -468,6 +509,9 @@ export namespace DEFAULTS {
  *
  * // 92px header on desktop, but 0px when virtual keyboard pushes the viewport
  * toolbar_sticky: { top: 92, offset: 0 }
+ *
+ * // Force the JS position:fixed engine (CSS sticky unreliable in this environment)
+ * toolbar_sticky: { top: 0, position: 'fixed' }
  * ```
  * @property {boolean} [toolbar_hide=false] - Hides toolbar initially.
  * @property {Object} [subToolbar={}] - Sub-toolbar configuration. A secondary toolbar that appears on text selection.
@@ -669,8 +713,26 @@ export type EditorFrameOptions = {
 	/**
 	 * - per-line placeholder shown on the focused
 	 * line when that line is empty. Takes priority over `placeholder` while a line is focused.
+	 * - **string**: one hint for every empty line (list cells and table cells excluded).
+	 * - **object**: per-type hints keyed by tag name (`p`, `pre`, `blockquote`, ...) or a category sentinel
+	 * matching the editor's format classification: `@line`, `@normalLine`, `@list`, `@brLine`, `@closureBrLine`,
+	 * `@block`, `@closureBlock`. Resolved most-specific → least, like `tagStyles`:
+	 * `<tag>` → `@list` → `@closureBrLine` → `@brLine` → block container (`<blockTag>` → `@closureBlock` → `@block`)
+	 * → `@normalLine` → `@line`. A missing key = no placeholder for that type; an explicit `''` suppresses it.
+	 * ```js
+	 * // one hint everywhere
+	 * placeholder_line: 'Type something…'
+	 * // per-type
+	 * placeholder_line: {
+	 * '@normalLine': 'Type…', '@list': 'List item', '@block': 'Quote…', '@closureBlock': 'Cell', pre: '// code'
+	 * }
+	 * ```
 	 */
-	placeholder_line?: string;
+	placeholder_line?:
+		| string
+		| {
+				[x: string]: string;
+		  };
 	/**
 	 * - Attributes for the editable frame[.sun-editor-editable].
 	 * ```js
@@ -1010,6 +1072,15 @@ export type EditorBaseOptions = {
 					) => void;
 			  }
 		>;
+		maxHeight?: string;
+		minWidth?: string;
+		onPlusClick?: (
+			arg0: SunEditor.Deps,
+			arg1: {
+				block: HTMLElement;
+				openMenu: () => void;
+			},
+		) => void;
 	};
 	/**
 	 * - Editor type. Use `"document"` for a document-style layout, with optional sub-types after `:`.
@@ -1232,6 +1303,16 @@ export type EditorBaseOptions = {
 	 * - When set to `br`, performance may decrease when editing a lot of data.
 	 */
 	defaultLineBreakFormat?: 'line' | 'br';
+	/**
+	 * - When `true`, pressing Enter at the **end** of a line
+	 * starts a fresh line that does not carry the caret's inline style nodes (e.g. bold/italic/color spans, links);
+	 * the line-level element and its attributes are preserved.
+	 * Only affects the end-of-line case — mid-line splits, start-of-line breaks, and Shift+Enter are unchanged.
+	 * ```js
+	 * { lineBreakClearStyle: true }
+	 * ```
+	 */
+	lineBreakClearStyle?: boolean;
 	/**
 	 * - Line properties that should be reset when changing lines. Delimiter: `"|"`.
 	 * ```js
@@ -1325,6 +1406,10 @@ export type EditorBaseOptions = {
 	 * - `offset` is the sticky position when a virtual keyboard shifts the viewport (e.g., on tablets, touch devices).
 	 * - When the virtual keyboard is active, `offset` replaces `top` so the toolbar doesn't leave a gap
 	 * - for a page header that has scrolled out of view. Default `offset` is `0`.
+	 * - `position` (default `"sticky"`): the positioning engine.
+	 * - `"sticky"` uses native CSS `position: sticky` (with a JS `position: fixed` fallback where unsupported).
+	 * `"fixed"` forces the JS `position: fixed` engine
+	 * - even when CSS sticky is supported — for environments where CSS sticky silently misbehaves and can't be
 	 * ```js
 	 * // Basic usage — sticky at top with 0px offset
 	 * toolbar_sticky: 0
@@ -1334,13 +1419,17 @@ export type EditorBaseOptions = {
 	 *
 	 * // 92px header on desktop, but 0px when virtual keyboard pushes the viewport
 	 * toolbar_sticky: { top: 92, offset: 0 }
+	 *
+	 * // Force the JS position:fixed engine (CSS sticky unreliable in this environment)
+	 * toolbar_sticky: { top: 0, position: 'fixed' }
 	 * ```
 	 */
 	toolbar_sticky?:
 		| number
 		| {
 				top: number;
-				offset: number;
+				offset?: number;
+				position?: 'sticky' | 'fixed';
 		  };
 	/**
 	 * - Hides toolbar initially.
@@ -1654,6 +1743,7 @@ export type TransformedOptionKeys =
 	| 'toolbar_container'
 	| '_toolbar_sticky'
 	| '_toolbar_sticky_offset'
+	| '_toolbar_sticky_fixed'
 	| 'strictMode'
 	| 'lineAttrReset';
 export type StrictModeOptions = {
@@ -1707,6 +1797,7 @@ export type TransformedOptions = {
 	toolbar_container: HTMLElement | null;
 	_toolbar_sticky: number;
 	_toolbar_sticky_offset: number;
+	_toolbar_sticky_fixed: boolean;
 	strictMode: StrictModeOptions;
 	lineAttrReset: string[];
 };

package/types/modules/ui/CommandMenu.d.ts

@@ -111,6 +111,13 @@ export type CommandMenuParams = {
 			icons: any;
 		},
 	) => string;
+	/**
+	 * - Optional owner hook run once,
+	 * - immediately before the user commits inside a dropdown-free flyout (SlashCommand uses it to delete the typed `/query`).
+	 * - A native submenu gets this for free — its commit routes back through `SelectMenu`'s select callback —
+	 * - but a flyout is the plugin's own DOM, so the moment has to be intercepted.
+	 */
+	prepareCommit?: () => void;
 };
 /**
  * @typedef {Object} CommandMenuItem
@@ -148,6 +155,10 @@ export type CommandMenuParams = {
  * @property {Object} selectMenuParams - Base SelectMenu params (`position`, `minWidth`, `keydownTarget`, etc.).
  * @property {function(CommandMenuItem, { icons: Object }): string} [renderCustomItem] - Optional renderer
  *   applied to custom (object) items only. Plugin-string items always render with `buildRowHTML`.
+ * @property {function(): void} [prepareCommit] - Optional owner hook run once,
+ * - immediately before the user commits inside a dropdown-free flyout (SlashCommand uses it to delete the typed `/query`).
+ * - A native submenu gets this for free — its commit routes back through `SelectMenu`'s select callback —
+ * - but a flyout is the plugin's own DOM, so the moment has to be intercepted.
  */
 /**
  * @class

package/types/modules/ui/SelectMenu.d.ts

@@ -31,11 +31,15 @@ export type SelectMenuParams = {
 	 */
 	closeMethod?: () => void;
 	/**
-	 * Optional owner hook invoked on ESC before the menu closes.
-	 * Return `true` if it dismissed an owner-managed sub-panel (e.g. CommandMenu's flyout), so ESC only
-	 * closes that sub-panel and keeps the menu open.
+	 * Optional owner hook that dismisses an owner-managed sub-panel (e.g. CommandMenu's dropdown-free flyout) and puts the cursor back on its row.
+	 * Return `true` when a sub-panel was actually dismissed.
 	 */
 	subEscMethod?: () => boolean;
+	/**
+	 * Optional owner hook answering "does the row at `index` own a sub-panel?".
+	 * - A query only — it must not open anything.
+	 */
+	subCheckMethod?: (index: number) => boolean;
 	/**
 	 * Optional max-height CSS value (e.g. `"200px"`). Enables scrolling when items exceed this height.
 	 */
@@ -66,9 +70,10 @@ export type SelectMenuParams = {
  * @property {number} [splitNum=0] Optional split number for horizontal positioning; defines how many items per row
  * @property {() => void} [openMethod] Optional method to call when the menu is opened
  * @property {() => void} [closeMethod] Optional method to call when the menu is closed
- * @property {() => boolean} [subEscMethod] Optional owner hook invoked on ESC before the menu closes.
- * Return `true` if it dismissed an owner-managed sub-panel (e.g. CommandMenu's flyout), so ESC only
- * closes that sub-panel and keeps the menu open.
+ * @property {() => boolean} [subEscMethod] Optional owner hook that dismisses an owner-managed sub-panel (e.g. CommandMenu's dropdown-free flyout) and puts the cursor back on its row.
+ * Return `true` when a sub-panel was actually dismissed.
+ * @property {(index: number) => boolean} [subCheckMethod] Optional owner hook answering "does the row at `index` own a sub-panel?".
+ * - A query only — it must not open anything.
  * @property {string} [maxHeight] Optional max-height CSS value (e.g. `"200px"`). Enables scrolling when items exceed this height.
  * @property {string} [minWidth] Optional min-width CSS value (e.g. `"130px"`).
  * @property {*} [keydownTarget]  Optional override for the keyboard navigation target. By default `on()` listens
@@ -104,6 +109,7 @@ declare class SelectMenu {
 	openMethod: () => void;
 	closeMethod: () => void;
 	subEscMethod: () => boolean;
+	subCheckMethod: (index: number) => boolean;
 	maxHeight: string;
 	minWidth: string;
 	/**
@@ -193,6 +199,6 @@ declare class SelectMenu {
 	 * @returns {boolean}
 	 */
 	hasOpenSubmenu(): boolean;
-	_onItem: Element;
+	_onItem: any;
 	#private;
 }

package/types/plugins/dropdown/table/index.d.ts

@@ -153,6 +153,17 @@ declare class Table extends PluginDropdownFree {
 	 * @description Closes table-related controllers and table figure
 	 */
 	_closeTableSelectInfo(): void;
+	/**
+	 * @description Insert a table of the given size at the caret and place the caret in its first cell.
+	 * @param {number} [cols=3] - Column count
+	 * @param {number} [rows=3] - Row count
+	 * @returns {boolean} `true` when the table was inserted
+	 * @example
+	 * // insert a 3x3 table without going through the size picker
+	 * editor.plugins.table.insert();
+	 * editor.plugins.table.insert(4, 2);
+	 */
+	insert(cols?: number, rows?: number): boolean;
 	#private;
 }
 import { PluginDropdownFree } from '../../../interfaces';

package/types/plugins/dropdown/table/shared/table.constants.d.ts

@@ -2,6 +2,7 @@ import type {} from '../../../../typedef';
 export const ROW_SELECT_MARGIN: 6;
 export const CELL_SELECT_MARGIN: 6;
 export const CELL_DECIMAL_END: 0;
+export const DEFAULT_SIZE: number[];
 export const RESIZE_CELL_CLASS: '.se-table-resize-line';
 export const RESIZE_CELL_PREV_CLASS: '.se-table-resize-line-prev';
 export const RESIZE_ROW_CLASS: '.se-table-resize-row';

package/types/plugins/field/slashCommand.d.ts

@@ -54,9 +54,18 @@ export type SlashCommandPluginOptions = {
 	 */
 	delayTime?: number;
 	/**
-	 * - Maximum number of items shown in the dropdown.
+	 * - Maximum number of items kept after filtering. `0` (default) keeps every match
+	 * - the list scrolls within `maxHeight`, so a cap only hides matches the user can no longer reach.
 	 */
 	limitSize?: number;
+	/**
+	 * - Max height of the menu list. Any CSS length; the list scrolls past it.
+	 */
+	maxHeight?: string;
+	/**
+	 * - Min width of the menu.
+	 */
+	minWidth?: string;
 	/**
 	 * - Message shown when no items match the query. If unset, the menu closes on no match.
 	 */
@@ -93,6 +102,15 @@ export type SlashCommandPluginOptions = {
 	 * // A container block (BLOCKQUOTE, DIV…): `applyBlock` WRAPS the selected lines → `<blockquote>…</blockquote>`.
 	 * action: ($) => $.format.applyBlock(document.createElement('BLOCKQUOTE')),
 	 * },
+	 * {
+	 * key: 'table',
+	 * title: 'Table',
+	 * icon: 'table',
+	 * // A plugin-name entry (`'table'`) opens that plugin's own UI — for table, the size picker,
+	 * // which is driven by the pointer. A custom item skips it and inserts straight away, which
+	 * // keeps the whole gesture on the keyboard: type the trigger, press Enter, done.
+	 * action: ($) => $.plugins.table.insert(3, 3),
+	 * },
 	 * 'bold',
 	 * 'image',
 	 * 'blockStyle',
@@ -131,7 +149,10 @@ export type SlashCommandPluginOptions = {
  *   (plugin names, built-in commands like `'bold'`); objects are custom items with their own `action`.
  *   Required.
  * @property {number} [delayTime=120] - Debounce delay (ms) before the input is inspected for the trigger.
- * @property {number} [limitSize=10] - Maximum number of items shown in the dropdown.
+ * @property {number} [limitSize=0] - Maximum number of items kept after filtering. `0` (default) keeps every match
+ *   - the list scrolls within `maxHeight`, so a cap only hides matches the user can no longer reach.
+ * @property {string} [maxHeight='320px'] - Max height of the menu list. Any CSS length; the list scrolls past it.
+ * @property {string} [minWidth='200px'] - Min width of the menu.
  * @property {string} [emptyMessage] - Message shown when no items match the query. If unset, the menu closes on no match.
  * @property {function(SlashCommandItem, { icons: Object }): string} [renderItem] - Custom item HTML renderer.
  *   Applied only to custom item objects; plugin-name entries always render with the canonical BlockHandle row.
@@ -164,6 +185,15 @@ export type SlashCommandPluginOptions = {
  *         // A container block (BLOCKQUOTE, DIV…): `applyBlock` WRAPS the selected lines → `<blockquote>…</blockquote>`.
  *         action: ($) => $.format.applyBlock(document.createElement('BLOCKQUOTE')),
  *       },
+ *       {
+ *         key: 'table',
+ *         title: 'Table',
+ *         icon: 'table',
+ *         // A plugin-name entry (`'table'`) opens that plugin's own UI — for table, the size picker,
+ *         // which is driven by the pointer. A custom item skips it and inserts straight away, which
+ *         // keeps the whole gesture on the keyboard: type the trigger, press Enter, done.
+ *         action: ($) => $.plugins.table.insert(3, 3),
+ *       },
  *       'bold',
  *       'image',
  *       'blockStyle',
@@ -191,6 +221,17 @@ declare class SlashCommand extends PluginField {
 	controller: Controller;
 	onInput(params: SunEditor.HookParams.InputWithData): void;
 	onKeyDown(params: SunEditor.HookParams.KeyEvent): void | boolean;
+	/**
+	 * @description Open the command menu programmatically, with no trigger character typed and the full tem list shown.
+	 * - Intended for host UI that wants the same menu without the `/` shortcut — e.g. the
+	 * - block handle's plus button:
+	 * ```js
+	 * blockHandle: { onPlusClick: ($, { block }) => $.plugins.slashCommand.open(block) }
+	 * ```
+	 * @param {Node} anchorNode - Node the menu anchors to (typically the line the caret sits on).
+	 * @returns {boolean} `true` if the menu was opened
+	 */
+	open(anchorNode: Node): boolean;
 	#private;
 }
 import { PluginField } from '../../interfaces';