@tempots/beatui 0.81.0 → 0.82.1

package/dist/types/components/json-structure/controls/control-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared utilities for JSON Structure controls
+ */
+import type { StructureContext } from '../structure-context';
+import type { TypeDefinition } from '../structure-types';
+/**
+ * Create input wrapper options from context
+ * Shared by all control components
+ */
+export declare function createInputOptions(ctx: StructureContext): {
+    label: string | undefined;
+    description: string | undefined;
+    required: boolean;
+};
+/**
+ * Get the default value for a type based on its definition
+ * Used when creating new items in arrays, sets, maps, tuples, and objects
+ */
+export declare function makeDefaultValue(definition: TypeDefinition): unknown;

package/dist/types/components/json-structure/controls/index.d.ts

@@ -1,6 +1,7 @@
 /**
  * Controls module exports
  */
+export * from './control-utils';
 export * from './generic-control';
 export * from './string-control';
 export * from './boolean-control';

package/dist/types/components/lexical/bare-editor.d.ts

@@ -0,0 +1,29 @@
+import { Renderable } from '@tempots/dom';
+import type { BareEditorOptions } from '../../lexical/types';
+/**
+ * BareEditor - Foundational headless rich text editor component
+ *
+ * A minimal Lexical editor surface with no UI chrome. This is the base component
+ * that Docked and Contextual presets will build upon.
+ *
+ * Features:
+ * - Headless editor surface (contenteditable)
+ * - Plugin-based architecture (rich-text, plain-text, history, clipboard, list, link)
+ * - Multiple content formats (markdown, JSON)
+ * - Theme integration (light/dark)
+ * - Reactive value binding
+ * - Read-only mode support
+ * - Event callbacks (onInput, onChange, onBlur, onReady, onError)
+ *
+ * @example
+ * ```ts
+ * const content = prop('')
+ * BareEditor({
+ *   value: content,
+ *   format: 'markdown',
+ *   plugins: { richText: true, history: true },
+ *   onInput: (value) => console.log('Input:', value),
+ * })
+ * ```
+ */
+export declare const BareEditor: (options: BareEditorOptions) => Renderable;

package/dist/types/components/lexical/code/index.d.ts

@@ -0,0 +1 @@
+export * from './language-selector';

package/dist/types/components/lexical/code/language-selector.d.ts

@@ -0,0 +1,13 @@
+import { Signal, TNode } from '@tempots/dom';
+import type { LexicalEditor } from 'lexical';
+export interface LanguageSelectorOptions {
+    editor: Signal<LexicalEditor | null>;
+    stateUpdate: Signal<number>;
+    readOnly?: Signal<boolean>;
+    languages?: string[];
+}
+/**
+ * Language selector that appears when a code block is selected.
+ * Allows changing the programming language for syntax highlighting.
+ */
+export declare function LanguageSelector({ editor, stateUpdate, readOnly, languages, }: LanguageSelectorOptions): TNode;

package/dist/types/components/lexical/contextual-editor.d.ts

@@ -0,0 +1,22 @@
+import { Renderable } from '@tempots/dom';
+import type { ContextualEditorOptions } from '../../lexical/types';
+/**
+ * ContextualEditor - Rich text editor with floating toolbar and block handle
+ *
+ * A clean editor surface that shows a floating toolbar when text is selected
+ * and a block handle at the left of each block for changing block types.
+ * No permanent UI chrome.
+ *
+ * Default plugins: richText, history, clipboard, list, link
+ *
+ * @example
+ * ```ts
+ * const content = prop('')
+ * ContextualEditor({
+ *   value: content,
+ *   format: 'markdown',
+ *   onInput: (value) => console.log('Input:', value),
+ * })
+ * ```
+ */
+export declare const ContextualEditor: (options: ContextualEditorOptions) => Renderable;

package/dist/types/components/lexical/docked-editor.d.ts

@@ -0,0 +1,23 @@
+import { Renderable } from '@tempots/dom';
+import type { DockedEditorOptions } from '../../lexical/types';
+/**
+ * DockedEditor - Rich text editor with a persistent toolbar
+ *
+ * Extends the BareEditor pattern by adding a configurable toolbar above
+ * (or below) the editor surface. Includes all standard formatting groups:
+ * text-formatting, headings, lists, blocks, links, and history.
+ *
+ * Default plugins: richText, history, clipboard, list, link
+ *
+ * @example
+ * ```ts
+ * const content = prop('')
+ * DockedEditor({
+ *   value: content,
+ *   format: 'markdown',
+ *   toolbar: { maxHeadingLevel: 3, hiddenGroups: ['tables'] },
+ *   onInput: (value) => console.log('Input:', value),
+ * })
+ * ```
+ */
+export declare const DockedEditor: (options: DockedEditorOptions) => Renderable;

package/dist/types/components/lexical/floating/block-handle.d.ts

@@ -0,0 +1,16 @@
+import { Signal, TNode } from '@tempots/dom';
+import type { LexicalEditor } from 'lexical';
+export interface BlockCommand {
+    id: string;
+    label: string;
+    icon: string;
+    handler: (editor: LexicalEditor) => void;
+}
+export declare const DEFAULT_BLOCK_COMMANDS: BlockCommand[];
+export interface BlockHandleOptions {
+    editor: Signal<LexicalEditor | null>;
+    stateUpdate: Signal<number>;
+    readOnly?: Signal<boolean>;
+    commands?: BlockCommand[];
+}
+export declare function BlockHandle({ editor, stateUpdate, readOnly, commands, }: BlockHandleOptions): TNode;

package/dist/types/components/lexical/floating/floating-toolbar.d.ts

@@ -0,0 +1,12 @@
+import { Signal, TNode } from '@tempots/dom';
+import type { LexicalEditor } from 'lexical';
+import type { ToolbarGroupId } from '../../../lexical/types';
+import { ControlSize } from '../../theme';
+export interface FloatingToolbarOptions {
+    editor: Signal<LexicalEditor | null>;
+    stateUpdate: Signal<number>;
+    groups?: ToolbarGroupId[];
+    readOnly?: Signal<boolean>;
+    size?: ControlSize;
+}
+export declare function FloatingToolbar({ editor, stateUpdate, groups, readOnly, size, }: FloatingToolbarOptions): TNode;

package/dist/types/components/lexical/floating/index.d.ts

@@ -0,0 +1,6 @@
+export { FloatingToolbar } from './floating-toolbar';
+export type { FloatingToolbarOptions } from './floating-toolbar';
+export { SlashCommandPalette, DEFAULT_SLASH_COMMANDS, } from './slash-command-palette';
+export type { SlashCommandPaletteOptions } from './slash-command-palette';
+export { BlockHandle, DEFAULT_BLOCK_COMMANDS } from './block-handle';
+export type { BlockHandleOptions, BlockCommand } from './block-handle';

package/dist/types/components/lexical/floating/slash-command-palette.d.ts

@@ -0,0 +1,20 @@
+import { Signal, Prop, TNode } from '@tempots/dom';
+import type { LexicalEditor } from 'lexical';
+import type { SlashCommandDefinition } from '../../../lexical/types';
+export interface SlashCommandPaletteOptions {
+    editor: Signal<LexicalEditor | null>;
+    commands: SlashCommandDefinition[];
+    isVisible: Prop<boolean>;
+    filterText: Signal<string>;
+    position: Signal<{
+        top: number;
+        left: number;
+    }>;
+    onSelect: (command: SlashCommandDefinition) => void;
+    onDismiss: () => void;
+}
+/**
+ * Default slash commands for the editor
+ */
+export declare const DEFAULT_SLASH_COMMANDS: SlashCommandDefinition[];
+export declare function SlashCommandPalette({ commands, isVisible, filterText, position, onSelect, onDismiss, }: SlashCommandPaletteOptions): TNode;

package/dist/types/components/lexical/index.d.ts

@@ -0,0 +1,8 @@
+export { BareEditor } from './bare-editor';
+export { DockedEditor } from './docked-editor';
+export { LexicalToolbar } from './toolbar';
+export type { LexicalToolbarOptions } from './toolbar';
+export { ContextualEditor } from './contextual-editor';
+export { LexicalEditorInput } from './lexical-editor-input';
+export { FloatingToolbar, SlashCommandPalette, DEFAULT_SLASH_COMMANDS, BlockHandle, DEFAULT_BLOCK_COMMANDS, } from './floating';
+export type { FloatingToolbarOptions, SlashCommandPaletteOptions, BlockHandleOptions, BlockCommand, } from './floating';

package/dist/types/components/lexical/lexical-editor-input.d.ts

@@ -0,0 +1,30 @@
+import { Renderable } from '@tempots/dom';
+import type { LexicalInputOptions } from '../../lexical/types';
+/**
+ * LexicalEditorInput - Form-compatible rich text editor input
+ *
+ * Wraps BareEditor with BeatUI's form system integration (InputContainer).
+ * Supports markdown, HTML, and JSON formats. Compatible with form controllers
+ * and validation.
+ *
+ * @example
+ * ```ts
+ * const content = prop('')
+ * LexicalEditorInput({
+ *   value: content,
+ *   format: 'markdown',
+ *   placeholder: 'Enter text...',
+ *   onInput: (v) => console.log(v),
+ * })
+ * ```
+ *
+ * @example With form controller:
+ * ```ts
+ * Control(LexicalEditorInput, {
+ *   controller: formController.field('description'),
+ *   label: 'Description',
+ *   format: 'markdown',
+ * })
+ * ```
+ */
+export declare const LexicalEditorInput: (options: LexicalInputOptions) => Renderable;

package/dist/types/components/lexical/table/index.d.ts

@@ -0,0 +1 @@
+export * from './table-controls';

package/dist/types/components/lexical/table/table-controls.d.ts

@@ -0,0 +1,12 @@
+import { Signal, TNode } from '@tempots/dom';
+import type { LexicalEditor } from 'lexical';
+export interface TableControlsOptions {
+    editor: Signal<LexicalEditor | null>;
+    stateUpdate: Signal<number>;
+    readOnly?: Signal<boolean>;
+}
+/**
+ * Table context menu that appears when a table cell is selected.
+ * Provides operations like insert/delete rows/columns.
+ */
+export declare function TableControls({ editor, stateUpdate, readOnly, }: TableControlsOptions): TNode;

package/dist/types/components/lexical/toolbar/index.d.ts

@@ -0,0 +1,6 @@
+export { LexicalToolbar } from './lexical-toolbar';
+export type { LexicalToolbarOptions } from './lexical-toolbar';
+export { LexicalToolbarButton } from './toolbar-button';
+export type { LexicalToolbarButtonOptions } from './toolbar-button';
+export { LexicalToolbarGroup } from './toolbar-group';
+export { createToolbarHelpers, createButtonFactory } from './toolbar-helpers';

package/dist/types/components/lexical/toolbar/lexical-toolbar.d.ts

@@ -0,0 +1,12 @@
+import { Signal, Value, TNode } from '@tempots/dom';
+import { type LexicalEditor } from 'lexical';
+import type { ToolbarConfig } from '../../../lexical/types';
+import { ControlSize } from '../../theme';
+export interface LexicalToolbarOptions {
+    editor: Signal<LexicalEditor | null>;
+    stateUpdate: Signal<number>;
+    toolbar?: ToolbarConfig;
+    readOnly?: Signal<boolean>;
+    size?: Value<ControlSize>;
+}
+export declare function LexicalToolbar({ editor, stateUpdate, toolbar, readOnly, size, }: LexicalToolbarOptions): TNode;

package/dist/types/components/lexical/toolbar/toolbar-button.d.ts

@@ -0,0 +1 @@
+export { EditorToolbarButton as LexicalToolbarButton, type EditorToolbarButtonOptions as LexicalToolbarButtonOptions, } from '../../editor-toolbar';

package/dist/types/components/lexical/toolbar/toolbar-group.d.ts

@@ -0,0 +1 @@
+export { EditorToolbarGroup as LexicalToolbarGroup } from '../../editor-toolbar';

package/dist/types/components/lexical/toolbar/toolbar-helpers.d.ts

@@ -0,0 +1,30 @@
+import { Signal, Value } from '@tempots/dom';
+import { type LexicalEditor, type TextFormatType, type RangeSelection, type ElementNode, type LexicalCommand } from 'lexical';
+import { ControlSize } from '../../theme';
+/**
+ * Create reactive state and action helpers for Lexical toolbar integration.
+ * Both the docked toolbar and floating toolbar share these helpers.
+ */
+export declare function createToolbarHelpers(ed: Signal<LexicalEditor>, stateUpdate: Signal<number>): {
+    withSelection: <T>(fn: (sel: RangeSelection) => T, fallback: T) => Signal<T>;
+    getAnchorElement: (sel: RangeSelection) => ElementNode | import("lexical").TextNode;
+    textFormatActive: (fmt: TextFormatType) => Signal<boolean>;
+    blockTypeActive: (type: string) => Signal<boolean>;
+    listTypeActive: (listType: string) => Signal<boolean>;
+    headingActive: (level: number) => import("@tempots/dom").Computed<boolean>;
+    linkActive: () => Signal<boolean>;
+    dispatch: <T>(command: LexicalCommand<T>, payload: T) => () => void;
+    toggleBlock: (type: string, create: () => ElementNode) => () => void;
+    toggleLink: () => void;
+};
+/**
+ * Create a button factory bound to shared readOnly and size props.
+ * Returns a function that takes a display signal and produces
+ * a group-specific button builder.
+ */
+export declare function createButtonFactory(readOnly: Signal<boolean>, size: Value<ControlSize>): (display: Signal<boolean>) => (opts: {
+    active: Signal<boolean>;
+    onClick: () => void;
+    label: string;
+    icon: string;
+}) => import("@tempots/dom").Renderable;

package/dist/types/components/prosemirror/etoolbar-button.d.ts

@@ -1,11 +1 @@
-import { Signal, Value } from '@tempots/dom';
-import { ControlSize } from '../theme';
-export declare function EToolbarButton({ active, display, onClick, disabled, label, icon, size, }: {
-    active: Signal<boolean>;
-    display: Signal<boolean>;
-    onClick: () => void;
-    disabled: Signal<boolean>;
-    label: Value<string>;
-    icon: Value<string>;
-    size: Value<ControlSize>;
-}): import("@tempots/dom").Renderable;
+export { EditorToolbarButton as EToolbarButton } from '../editor-toolbar';

package/dist/types/components/prosemirror/etoolbar-group.d.ts

@@ -1,4 +1 @@
-import { Signal, TNode } from '@tempots/dom';
-export declare function EToolbarGroup({ display, }: {
-    display: Signal<boolean>[];
-}, ...children: TNode[]): import("@tempots/dom").Renderable;
+export { EditorToolbarGroup as EToolbarGroup } from '../editor-toolbar';

package/dist/types/json-schema-display/index.d.ts

@@ -0,0 +1 @@
+export * from '../components/json-schema-display';

package/dist/types/lexical/commands/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Lexical commands re-exports and custom BeatUI commands.
+ *
+ * Re-exports commonly used Lexical commands so consumers don't need
+ * to import from 'lexical' directly for basic operations.
+ */
+export { FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, UNDO_COMMAND, REDO_COMMAND, INDENT_CONTENT_COMMAND, OUTDENT_CONTENT_COMMAND, SELECTION_CHANGE_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, INSERT_PARAGRAPH_COMMAND, PASTE_COMMAND, COPY_COMMAND, CUT_COMMAND, CLEAR_EDITOR_COMMAND, CLICK_COMMAND, FOCUS_COMMAND, BLUR_COMMAND, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, createCommand, } from 'lexical';
+export { INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, INSERT_CHECK_LIST_COMMAND, REMOVE_LIST_COMMAND, } from '@lexical/list';
+/** Command to toggle the slash command palette */
+export declare const TOGGLE_SLASH_COMMAND_PALETTE: import("lexical").LexicalCommand<void>;
+/** Command to insert a horizontal rule */
+export declare const INSERT_HORIZONTAL_RULE_COMMAND: import("lexical").LexicalCommand<void>;
+/** Command to insert an image (future use) */
+export declare const INSERT_IMAGE_COMMAND: import("lexical").LexicalCommand<{
+    src: string;
+    alt?: string;
+}>;

package/dist/types/lexical/headless.d.ts

@@ -0,0 +1,39 @@
+import type { LexicalEditor, SerializedEditorState } from 'lexical';
+import type { HeadlessEditorOptions } from './types';
+/**
+ * Create a headless Lexical editor instance (no DOM mounting).
+ * Useful for server-side rendering, testing, or programmatic content manipulation.
+ *
+ * @example
+ * ```ts
+ * const editor = await createHeadlessEditor({
+ *   nodes: [MyCustomNode],
+ *   plugins: [myPlugin],
+ * })
+ *
+ * editor.update(() => {
+ *   const root = $getRoot()
+ *   root.clear()
+ *   // ... manipulate content
+ * })
+ *
+ * const json = editor.getEditorState().toJSON()
+ * ```
+ */
+export declare function createHeadlessEditor(options?: HeadlessEditorOptions): Promise<LexicalEditor>;
+/**
+ * Convert markdown string to Lexical JSON using a headless editor.
+ */
+export declare function markdownToLexicalJson(markdown: string): Promise<SerializedEditorState>;
+/**
+ * Convert Lexical JSON to markdown string using a headless editor.
+ */
+export declare function lexicalJsonToMarkdown(json: SerializedEditorState): Promise<string>;
+/**
+ * Convert HTML string to Lexical JSON using a headless editor.
+ */
+export declare function htmlToLexicalJson(html: string): Promise<SerializedEditorState>;
+/**
+ * Convert Lexical JSON to HTML string using a headless editor.
+ */
+export declare function lexicalJsonToHtml(json: SerializedEditorState): Promise<string>;

package/dist/types/lexical/horizontal-rule-node.d.ts

@@ -0,0 +1,20 @@
+import { DecoratorNode, type DOMConversionMap, type DOMExportOutput, type LexicalNode, type SerializedLexicalNode, type Spread } from 'lexical';
+export type SerializedHorizontalRuleNode = Spread<{
+    type: 'horizontal-rule';
+    version: 1;
+}, SerializedLexicalNode>;
+export declare class HorizontalRuleNode extends DecoratorNode<null> {
+    static getType(): string;
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    static importJSON(_serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    static importDOM(): DOMConversionMap | null;
+    exportJSON(): SerializedHorizontalRuleNode;
+    exportDOM(): DOMExportOutput;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    getTextContent(): string;
+    isInline(): false;
+    decorate(): null;
+}
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;

package/dist/types/lexical/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lexical Editor Integration - Entry Point
+ * @module @tempots/beatui/lexical
+ *
+ * Provides rich text editing via Facebook's Lexical framework with three
+ * pre-configured presets (Bare, Docked, Contextual), full plugin coverage,
+ * multi-format I/O, form integration, and theme/i18n support.
+ */
+export type { ContentFormatType, StringContent, JsonContent, EditorContent, LexicalPluginDefinition, PluginConfig, HistoryPluginOptions, TablePluginOptions, AutoLinkPluginOptions, AutoLinkMatcher, CodePluginOptions, HashtagPluginOptions, OverflowPluginOptions, SlashCommandPluginOptions, SlashCommandDefinition, ToolbarGroupId, ToolbarConfig, MarkMetadata, MarkPluginCallbacks, CollaborationConfig, CollaborationUser, LexicalEditorBaseOptions, BareEditorOptions, DockedEditorOptions, ContextualEditorOptions, LexicalStringInputOptions, LexicalJsonInputOptions, LexicalInputOptions, HeadlessEditorOptions, CharacterCountInfo, SelectionInfo, EditorPresetType, EditorHeightMode, } from './types';
+export { getNodesForPlugins, createDefaultPluginConfig } from './nodes';
+export { HorizontalRuleNode, $createHorizontalRuleNode, $isHorizontalRuleNode, } from './horizontal-rule-node';
+export type { SerializedHorizontalRuleNode } from './horizontal-rule-node';
+export { loadLexicalCore } from './lazy-loader';
+export { registerRichTextPlugin, registerPlainTextPlugin, registerHistoryPlugin, registerClipboardPlugin, registerListPlugin, registerLinkPlugin, registerSlashCommandsPlugin, executeSlashCommand, exportToMarkdown, importFromMarkdown, getMarkdownTransformers, exportToHtml, importFromHtml, exportEditorToFile, importFileToEditor, registerTablePlugin, insertTable, registerCodePlugin, registerCodeShikiPlugin, registerHashtagPlugin, registerAutoLinkPlugin, registerMarkPlugin, applyMark, removeMark, registerOverflowPlugin, registerDragonPlugin, registerYjsPlugin, getSelectionInfo, getTextContent, getCharacterCount, getWordCount, loadOffsetUtils, registerHorizontalRulePlugin, HR_TRANSFORMER, } from './plugins';
+export type { SlashCommandState, SlashCommandCallbacks } from './plugins';
+export { createHeadlessEditor, markdownToLexicalJson, lexicalJsonToMarkdown, htmlToLexicalJson, lexicalJsonToHtml, } from './headless';
+export { createCommand, ElementNode, DecoratorNode, TextNode, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_CRITICAL, } from 'lexical';
+export type { LexicalEditor, LexicalNode, EditorState, SerializedEditorState, SerializedLexicalNode, NodeKey, EditorThemeClasses, } from 'lexical';
+export * from './commands';
+export * from '../components/lexical';

package/dist/types/lexical/lazy-loader.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Lexical module loaders.
+ *
+ * All imports are static to ensure a single module instance is shared
+ * across all code paths (avoiding Lexical error #195 - dual module instances).
+ *
+ * The async function signatures are preserved for backward compatibility.
+ */
+/**
+ * Get the Lexical core module.
+ * Returns the statically imported module to ensure a single instance
+ * is shared across all code paths (avoiding Lexical error #195).
+ */
+export declare function loadLexicalCore(): Promise<typeof import('lexical')>;
+export declare function loadRichText(): Promise<typeof import('@lexical/rich-text')>;
+export declare function loadPlainText(): Promise<typeof import('@lexical/plain-text')>;
+export declare function loadHistory(): Promise<typeof import('@lexical/history')>;
+export declare function loadList(): Promise<typeof import('@lexical/list')>;
+export declare function loadLink(): Promise<typeof import('@lexical/link')>;
+export declare function loadClipboard(): Promise<typeof import('@lexical/clipboard')>;
+export declare function loadMarkdown(): Promise<typeof import('@lexical/markdown')>;
+export declare function loadHtml(): Promise<typeof import('@lexical/html')>;
+export declare function loadTable(): Promise<typeof import('@lexical/table')>;
+export declare function loadCode(): Promise<typeof import('@lexical/code')>;
+export declare function loadHashtag(): Promise<typeof import('@lexical/hashtag')>;
+export declare function loadMark(): Promise<typeof import('@lexical/mark')>;
+export declare function loadOverflow(): Promise<typeof import('@lexical/overflow')>;
+export declare function loadSelection(): Promise<typeof import('@lexical/selection')>;
+export declare function loadText(): Promise<typeof import('@lexical/text')>;
+export declare function loadUtils(): Promise<typeof import('@lexical/utils')>;
+export declare function loadOffset(): Promise<typeof import('@lexical/offset')>;
+export declare function loadDragon(): Promise<typeof import('@lexical/dragon')>;
+export declare function loadFile(): Promise<typeof import('@lexical/file')>;
+export declare function loadYjs(): Promise<typeof import('@lexical/yjs')>;
+export declare function loadHeadless(): Promise<typeof import('@lexical/headless')>;

package/dist/types/lexical/nodes.d.ts

@@ -0,0 +1,29 @@
+import type { Klass, LexicalNode } from 'lexical';
+import type { EditorPresetType, PluginConfig } from './types';
+/**
+ * Compute the list of Lexical node classes required for the given plugin configuration.
+ * Each plugin maps to specific node types that must be registered with createEditor().
+ *
+ * Note: Node classes are imported statically (not lazily) because they are needed during
+ * editor initialization. These are small registration classes, not the full plugin logic.
+ *
+ * Common content nodes (HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode,
+ * CodeNode, CodeHighlightNode) are always registered so that content in any format
+ * (markdown, HTML, JSON) can be parsed and displayed correctly, even when the
+ * corresponding editing plugins are not enabled.
+ *
+ * @param config - The plugin configuration object
+ * @returns Array of Lexical node classes to register
+ */
+export declare function getNodesForPlugins(config: PluginConfig): Array<Klass<LexicalNode>>;
+/**
+ * Get the default plugin configuration for a given editor preset.
+ *
+ * - **bare**: Minimal (richText + history + clipboard)
+ * - **docked**: Batteries-included (richText + history + clipboard + list + link + autoLink + code + table)
+ * - **contextual**: Same as docked (block handle is managed by the component, not a plugin)
+ *
+ * @param preset - The editor preset type
+ * @returns Default plugin configuration for the preset
+ */
+export declare function createDefaultPluginConfig(preset: EditorPresetType): PluginConfig;

package/dist/types/lexical/plugins/auto-link.d.ts

@@ -0,0 +1,7 @@
+import { type LexicalEditor } from 'lexical';
+import type { AutoLinkPluginOptions } from '../types';
+/**
+ * Register automatic link detection and creation.
+ * Detects URLs and email addresses as you type and converts them to links.
+ */
+export declare function registerAutoLinkPlugin(editor: LexicalEditor, options?: AutoLinkPluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/clipboard.d.ts

@@ -0,0 +1,11 @@
+import type { LexicalEditor } from 'lexical';
+import '@lexical/clipboard';
+/**
+ * Register clipboard handling (copy/paste with rich text preservation).
+ * Wraps @lexical/clipboard functionality.
+ *
+ * Note: Lexical handles clipboard operations internally through its command system.
+ * This plugin ensures the clipboard utilities from @lexical/clipboard are available
+ * and registers paste handlers for HTML sanitization.
+ */
+export declare function registerClipboardPlugin(_editor: LexicalEditor): Promise<() => void>;

package/dist/types/lexical/plugins/code-shiki.d.ts

@@ -0,0 +1,11 @@
+import type { LexicalEditor } from 'lexical';
+import type { CodePluginOptions } from '../types';
+/**
+ * Register Shiki-based syntax highlighting for code blocks.
+ * This is an opt-in alternative to the default @lexical/code highlighting.
+ * Provides more accurate and theme-aware syntax highlighting using Shiki.
+ *
+ * Note: @lexical/code-shiki is an optional peer dependency and must be
+ * installed separately. If not available, falls back to default highlighting.
+ */
+export declare function registerCodeShikiPlugin(editor: LexicalEditor, _options?: CodePluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/code.d.ts

@@ -0,0 +1,7 @@
+import type { LexicalEditor } from 'lexical';
+import type { CodePluginOptions } from '../types';
+/**
+ * Register code block support with syntax highlighting.
+ * Wraps @lexical/code functionality.
+ */
+export declare function registerCodePlugin(editor: LexicalEditor, _options?: CodePluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/dragon.d.ts

@@ -0,0 +1,6 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Register Dragon NaturallySpeaking support.
+ * Provides compatibility with Dragon speech recognition software.
+ */
+export declare function registerDragonPlugin(editor: LexicalEditor): Promise<() => void>;

package/dist/types/lexical/plugins/file-io.d.ts

@@ -0,0 +1,10 @@
+import type { LexicalEditor } from 'lexical';
+import type { ContentFormatType } from '../types';
+/**
+ * Export editor content to a downloadable file.
+ */
+export declare function exportEditorToFile(editor: LexicalEditor, format: ContentFormatType, filename?: string): Promise<void>;
+/**
+ * Import content from a file into the editor.
+ */
+export declare function importFileToEditor(editor: LexicalEditor, file: File, format?: ContentFormatType): Promise<void>;

package/dist/types/lexical/plugins/hashtag.d.ts

@@ -0,0 +1,7 @@
+import type { LexicalEditor } from 'lexical';
+import type { HashtagPluginOptions } from '../types';
+/**
+ * Register hashtag support.
+ * Wraps @lexical/hashtag functionality.
+ */
+export declare function registerHashtagPlugin(editor: LexicalEditor, options?: HashtagPluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/history.d.ts

@@ -0,0 +1,7 @@
+import type { LexicalEditor } from 'lexical';
+import type { HistoryPluginOptions } from '../types';
+/**
+ * Register undo/redo history support.
+ * Wraps @lexical/history's registerHistory.
+ */
+export declare function registerHistoryPlugin(editor: LexicalEditor, options?: HistoryPluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/horizontal-rule.d.ts

@@ -0,0 +1,12 @@
+import type { LexicalEditor } from 'lexical';
+import type { ElementTransformer } from '@lexical/markdown';
+/**
+ * Register the INSERT_HORIZONTAL_RULE_COMMAND handler on the given editor.
+ * Returns a cleanup function to unregister the handler.
+ */
+export declare function registerHorizontalRulePlugin(editor: LexicalEditor): () => void;
+/**
+ * Markdown transformer for horizontal rules (---).
+ * Use this with $convertToMarkdownString / $convertFromMarkdownString.
+ */
+export declare const HR_TRANSFORMER: ElementTransformer;

package/dist/types/lexical/plugins/html-io.d.ts

@@ -0,0 +1,9 @@
+import { type LexicalEditor } from 'lexical';
+/**
+ * Export the editor content to HTML string.
+ */
+export declare function exportToHtml(editor: LexicalEditor): Promise<string>;
+/**
+ * Import HTML content into the editor, replacing current content.
+ */
+export declare function importFromHtml(editor: LexicalEditor, html: string): Promise<void>;

package/dist/types/lexical/plugins/index.d.ts

@@ -0,0 +1,24 @@
+export { registerRichTextPlugin } from './rich-text';
+export { registerPlainTextPlugin } from './plain-text';
+export { registerHistoryPlugin } from './history';
+export { registerClipboardPlugin } from './clipboard';
+export { registerListPlugin } from './list';
+export { registerLinkPlugin } from './link';
+export { registerSlashCommandsPlugin, executeSlashCommand, } from './slash-commands';
+export type { SlashCommandState, SlashCommandCallbacks } from './slash-commands';
+export { exportToMarkdown, importFromMarkdown, getMarkdownTransformers, } from './markdown-io';
+export { exportToHtml, importFromHtml } from './html-io';
+export { exportEditorToFile, importFileToEditor } from './file-io';
+export { registerTablePlugin, insertTable } from './table';
+export { registerCodePlugin } from './code';
+export { registerCodeShikiPlugin } from './code-shiki';
+export { registerHashtagPlugin } from './hashtag';
+export { registerAutoLinkPlugin } from './auto-link';
+export { registerMarkPlugin, applyMark, removeMark } from './mark';
+export { registerOverflowPlugin } from './overflow';
+export { registerDragonPlugin } from './dragon';
+export { registerYjsPlugin } from './yjs';
+export { getSelectionInfo } from './selection';
+export { getTextContent, getCharacterCount, getWordCount } from './text';
+export { loadOffsetUtils } from './offset';
+export { registerHorizontalRulePlugin, HR_TRANSFORMER } from './horizontal-rule';