@tempots/beatui 0.82.0 → 0.83.0

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';

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

@@ -0,0 +1,6 @@
+import { type LexicalEditor } from 'lexical';
+/**
+ * Register link support.
+ * Wraps @lexical/link functionality.
+ */
+export declare function registerLinkPlugin(editor: LexicalEditor): Promise<() => void>;

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

@@ -0,0 +1,6 @@
+import { type LexicalEditor } from 'lexical';
+/**
+ * Register list support (ordered, unordered, check lists).
+ * Wraps @lexical/list functionality including check list click handling.
+ */
+export declare function registerListPlugin(editor: LexicalEditor): Promise<() => void>;

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

@@ -0,0 +1,15 @@
+import { type LexicalEditor } from 'lexical';
+import type { MarkMetadata, MarkPluginCallbacks } from '../types';
+/**
+ * Register mark/annotation support.
+ * Allows highlighting and annotating text with custom metadata.
+ */
+export declare function registerMarkPlugin(editor: LexicalEditor, callbacks?: MarkPluginCallbacks): Promise<() => void>;
+/**
+ * Apply a mark to the current selection.
+ */
+export declare function applyMark(editor: LexicalEditor, id: string, _metadata?: Partial<MarkMetadata>): Promise<void>;
+/**
+ * Remove a mark by its ID.
+ */
+export declare function removeMark(editor: LexicalEditor, id: string): Promise<void>;

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

@@ -0,0 +1,13 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Convert the editor content to a Markdown string.
+ */
+export declare function exportToMarkdown(editor: LexicalEditor): Promise<string>;
+/**
+ * Import Markdown content into the editor, replacing current content.
+ */
+export declare function importFromMarkdown(editor: LexicalEditor, markdown: string): Promise<void>;
+/**
+ * Get all markdown transformers including BeatUI custom ones.
+ */
+export declare function getMarkdownTransformers(): Promise<import("@lexical/markdown").Transformer[]>;

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

@@ -0,0 +1,6 @@
+import * as offsetModule from '@lexical/offset';
+/**
+ * Offset utilities for mapping between editor positions and plain-text offsets.
+ * Re-exports @lexical/offset functionality for use by selection and mark features.
+ */
+export declare function loadOffsetUtils(): Promise<typeof offsetModule>;

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

@@ -0,0 +1,7 @@
+import { type LexicalEditor } from 'lexical';
+import type { OverflowPluginOptions } from '../types';
+/**
+ * Register overflow/character limit detection.
+ * Monitors content length and triggers callbacks when limits are exceeded.
+ */
+export declare function registerOverflowPlugin(editor: LexicalEditor, options: OverflowPluginOptions): Promise<() => void>;

package/dist/types/lexical/plugins/plain-text.d.ts

@@ -0,0 +1,6 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Register plain text editing support.
+ * Wraps @lexical/plain-text's registerPlainText.
+ */
+export declare function registerPlainTextPlugin(editor: LexicalEditor): Promise<() => void>;

package/dist/types/lexical/plugins/rich-text.d.ts

@@ -0,0 +1,6 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Register rich text editing support.
+ * Wraps @lexical/rich-text's registerRichText.
+ */
+export declare function registerRichTextPlugin(editor: LexicalEditor): Promise<() => void>;

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

@@ -0,0 +1,6 @@
+import type { LexicalEditor } from 'lexical';
+import type { SelectionInfo } from '../types';
+/**
+ * Get information about the current selection.
+ */
+export declare function getSelectionInfo(editor: LexicalEditor): SelectionInfo;

package/dist/types/lexical/plugins/slash-commands.d.ts

@@ -0,0 +1,26 @@
+import type { LexicalEditor } from 'lexical';
+import { TextNode } from 'lexical';
+import type { SlashCommandPluginOptions } from '../types';
+export interface SlashCommandState {
+    isActive: boolean;
+    filterText: string;
+    anchorNode: TextNode | null;
+    anchorOffset: number;
+}
+export interface SlashCommandCallbacks {
+    onTrigger?: (state: SlashCommandState, removeText: () => void) => void;
+    onUpdate?: (state: SlashCommandState, removeText: () => void) => void;
+    onDismiss?: () => void;
+    onExecute?: (commandId: string, removeText: () => void) => void;
+}
+/**
+ * Register slash commands plugin.
+ * Detects "/" input and manages the command palette lifecycle.
+ */
+export declare function registerSlashCommandsPlugin(editor: LexicalEditor, options?: SlashCommandPluginOptions, callbacks?: SlashCommandCallbacks): Promise<() => void>;
+/**
+ * Execute a slash command by removing the trigger text and running the handler.
+ */
+export declare function executeSlashCommand(editor: LexicalEditor, command: {
+    handler: (editor: LexicalEditor) => void;
+}, removeText: () => void): void;

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

@@ -0,0 +1,11 @@
+import type { LexicalEditor } from 'lexical';
+import type { TablePluginOptions } from '../types';
+/**
+ * Register table support.
+ * Wraps @lexical/table functionality.
+ */
+export declare function registerTablePlugin(editor: LexicalEditor, _options?: TablePluginOptions): Promise<() => void>;
+/**
+ * Insert a new table at the current selection.
+ */
+export declare function insertTable(editor: LexicalEditor, rows?: number, columns?: number): Promise<void>;

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

@@ -0,0 +1,13 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Get the text content of the editor (plain text, no formatting).
+ */
+export declare function getTextContent(editor: LexicalEditor): string;
+/**
+ * Get the character count of the editor content.
+ */
+export declare function getCharacterCount(editor: LexicalEditor): number;
+/**
+ * Get the word count of the editor content.
+ */
+export declare function getWordCount(editor: LexicalEditor): number;

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

@@ -0,0 +1,9 @@
+import type { LexicalEditor } from 'lexical';
+import type { CollaborationConfig } from '../types';
+/**
+ * Register Yjs collaborative editing support.
+ * Enables real-time collaboration using Yjs CRDT.
+ *
+ * Note: This plugin requires the `yjs` package to be installed as a peer dependency.
+ */
+export declare function registerYjsPlugin(editor: LexicalEditor, config: CollaborationConfig): Promise<() => void>;

package/dist/types/lexical/styles-url.d.ts

@@ -0,0 +1,2 @@
+declare const cssHref: string;
+export default cssHref;

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;