@tempots/beatui 0.82.0 → 0.82.1

package/dist/types/better-auth/types.d.ts

@@ -0,0 +1,164 @@
+import { Signal } from '@tempots/dom';
+import { AuthContainerLabels, AuthContainerOptions, AuthProviderInfo, AuthProviderName, PasswordRules, ResetPasswordFormOptions, SignInFormOptions, SignUpFormOptions } from '../components/auth';
+export interface BetterAuthClient {
+    signIn: {
+        email: (opts: {
+            email: string;
+            password: string;
+            rememberMe?: boolean;
+            callbackURL?: string;
+        }) => Promise<BetterAuthResult<unknown>>;
+        social: (opts: {
+            provider: string;
+            callbackURL?: string;
+            errorCallbackURL?: string;
+        }) => Promise<BetterAuthResult<unknown>>;
+        magicLink?: (opts: {
+            email: string;
+            callbackURL?: string;
+        }) => Promise<BetterAuthResult<unknown>>;
+        passkey?: (opts?: {
+            autoFill?: boolean;
+        }) => Promise<BetterAuthResult<unknown>>;
+    };
+    signUp: {
+        email: (opts: {
+            name?: string;
+            email: string;
+            password: string;
+            callbackURL?: string;
+        }) => Promise<BetterAuthResult<unknown>>;
+    };
+    signOut: (opts?: object) => Promise<BetterAuthResult<unknown>>;
+    getSession: () => Promise<BetterAuthResult<{
+        session: unknown;
+        user: BetterAuthUser;
+    }>>;
+    requestPasswordReset: (opts: {
+        email: string;
+        redirectTo?: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    resetPassword?: (opts: {
+        newPassword: string;
+        token: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    changePassword?: (opts: {
+        newPassword: string;
+        currentPassword: string;
+        revokeOtherSessions?: boolean;
+    }) => Promise<BetterAuthResult<unknown>>;
+    sendVerificationEmail?: (opts: {
+        email: string;
+        callbackURL: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    twoFactor?: TwoFactorClient;
+    passkey?: PasskeyClient;
+    magicLink?: {
+        verify: (opts: {
+            token: string;
+        }) => Promise<BetterAuthResult<unknown>>;
+    };
+}
+export interface BetterAuthResult<T> {
+    data: T | null;
+    error: {
+        message: string;
+        status: number;
+        statusText: string;
+    } | null;
+}
+export interface BetterAuthUser {
+    id: string;
+    name?: string;
+    email: string;
+    image?: string;
+}
+export interface TwoFactorClient {
+    enable: (opts: {
+        password: string;
+        issuer?: string;
+    }) => Promise<BetterAuthResult<{
+        totpURI: string;
+        backupCodes: string[];
+    }>>;
+    disable: (opts: {
+        password: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    getTotpUri: (opts: {
+        password: string;
+    }) => Promise<BetterAuthResult<{
+        totpURI: string;
+    }>>;
+    verifyTotp: (opts: {
+        code: string;
+        trustDevice?: boolean;
+    }) => Promise<BetterAuthResult<unknown>>;
+    sendOtp?: (opts?: {
+        trustDevice?: boolean;
+    }) => Promise<BetterAuthResult<unknown>>;
+    verifyOtp?: (opts: {
+        code: string;
+        trustDevice?: boolean;
+    }) => Promise<BetterAuthResult<unknown>>;
+    generateBackupCodes: (opts: {
+        password: string;
+    }) => Promise<BetterAuthResult<{
+        backupCodes: string[];
+    }>>;
+    verifyBackupCode: (opts: {
+        code: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+}
+export interface PasskeyClient {
+    addPasskey: (opts?: {
+        name?: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    listUserPasskeys: () => Promise<BetterAuthResult<PasskeyInfo[]>>;
+    deletePasskey: (opts: {
+        id: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+    updatePasskey: (opts: {
+        id: string;
+        name: string;
+    }) => Promise<BetterAuthResult<unknown>>;
+}
+export interface PasskeyInfo {
+    id: string;
+    name?: string;
+    createdAt: string;
+}
+export interface BetterAuthBridgeOptions {
+    callbackURL?: string;
+    errorCallbackURL?: string;
+    socialProviders?: AuthProviderName[];
+    passwordRules?: PasswordRules;
+    showRememberMe?: boolean;
+    showNameField?: boolean;
+    showConfirmPassword?: boolean;
+    showPasswordStrength?: boolean;
+    refreshInterval?: number;
+    onSessionChange?: (session: BetterAuthSession | null) => void;
+    onError?: (error: {
+        message: string;
+        status: number;
+    }) => void;
+    labels?: AuthContainerLabels;
+}
+export interface BetterAuthSession {
+    user: BetterAuthUser;
+    [key: string]: unknown;
+}
+export interface BetterAuthBridge {
+    session: Signal<BetterAuthSession | null>;
+    isPending: Signal<boolean>;
+    user: Signal<BetterAuthUser | null>;
+    isAuthenticated: Signal<boolean>;
+    containerOptions: AuthContainerOptions;
+    signInOptions: SignInFormOptions;
+    signUpOptions: SignUpFormOptions;
+    resetOptions: ResetPasswordFormOptions;
+    socialProviders: AuthProviderInfo[];
+    signOut: () => Promise<void>;
+    refreshSession: () => Promise<void>;
+    dispose: () => void;
+}

package/dist/types/components/auth/auth-container.d.ts

@@ -1,6 +1,6 @@
 import { TNode } from '@tempots/dom';
 import { AuthContainerOptions } from './index';
-export declare function AuthContainer({ mode: initialMode, socialProviders, initialName, initialEmail, passwordRules, showRememberMe, showSocialDivider, showPasswordStrength, labels, onSignIn, onSignUp, onResetPassword, onModeChange, showContainer, }: AuthContainerOptions, ...children: TNode[]): TNode;
+export declare function AuthContainer({ mode: initialMode, socialProviders, initialName, initialEmail, passwordRules, showRememberMe, showSocialDivider, showPasswordStrength, labels, onSignIn, onSignUp, onResetPassword, onModeChange, onSocialLogin, showContainer, }: AuthContainerOptions, ...children: TNode[]): TNode;
 export declare function AuthModal(fn: (open: (options: AuthContainerOptions & {
     modalTitle?: () => string;
 }) => void) => TNode): TNode;

package/dist/types/components/auth/social-providers.d.ts

@@ -1,2 +1,2 @@
 import { SocialProvidersOptions } from './types';
-export declare function SocialProviders({ providers }: SocialProvidersOptions): import("@tempots/dom").Renderable;
+export declare function SocialProviders({ providers, onSocialLogin }: SocialProvidersOptions): import("@tempots/dom").Renderable;

package/dist/types/components/auth/types.d.ts

@@ -73,6 +73,7 @@ export interface AuthContainerOptions {
     onSignUp?: (data: SignUpData) => Promise<string | null>;
     onResetPassword?: (data: ResetPasswordData) => Promise<string | null>;
     onModeChange?: (mode: AuthMode) => void;
+    onSocialLogin?: (provider: AuthProviderName) => Promise<void>;
     showPasswordStrength?: Value<boolean>;
     showAlreadyHaveAccountLink?: boolean;
     showNameField?: boolean;
@@ -83,6 +84,7 @@ export interface AuthContainerOptions {
 }
 export interface SocialProvidersOptions {
     providers: AuthProviderInfo[];
+    onSocialLogin?: (provider: AuthProviderName) => Promise<void>;
 }
 export interface SignInFormLabels {
     emailLabel?: Value<string>;

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

@@ -0,0 +1,16 @@
+import { Signal, Value } from '@tempots/dom';
+import { ControlSize } from '../theme';
+export interface EditorToolbarButtonOptions {
+    active: Signal<boolean>;
+    display: Signal<boolean>;
+    onClick: () => void;
+    disabled: Signal<boolean>;
+    label: Value<string>;
+    icon: Value<string>;
+    size: Value<ControlSize>;
+}
+/**
+ * A reusable toolbar button component for rich text editors.
+ * Used by both Lexical and ProseMirror editor toolbars.
+ */
+export declare function EditorToolbarButton(options: EditorToolbarButtonOptions): import("@tempots/dom").Renderable;

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

@@ -0,0 +1,9 @@
+import { Signal, TNode } from '@tempots/dom';
+/**
+ * A reusable toolbar group component for rich text editors.
+ * Shows the group only when at least one of the display signals is true.
+ * Used by both Lexical and ProseMirror editor toolbars.
+ */
+export declare function EditorToolbarGroup({ display, }: {
+    display: Signal<boolean>[];
+}, ...children: TNode[]): import("@tempots/dom").Renderable;

package/dist/types/components/editor-toolbar/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorToolbarButton, type EditorToolbarButtonOptions, } from './editor-toolbar-button';
+export { EditorToolbarGroup } from './editor-toolbar-group';

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