@tempots/beatui 0.82.0 → 0.83.0

package/dist/types/components/prosemirror/utils.d.ts

@@ -1,12 +1,124 @@
+/**
+ * Utility functions for inspecting ProseMirror editor state.
+ *
+ * Provides helpers to check whether specific marks or nodes are active in the
+ * current selection and to create reactive signals that track mark/node
+ * activity as the user navigates the document.
+ *
+ * @module
+ */
 import { Signal } from '@tempots/dom';
 import { Mark, MarkType, NodeType } from 'prosemirror-model';
 import { EditorState } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
+/**
+ * Checks whether a mark of the given type is active in the current editor
+ * selection.
+ *
+ * Works for both empty (collapsed) and non-empty selections. For empty
+ * selections it also inspects `storedMarks` and adjacent nodes.
+ *
+ * @param state - The current ProseMirror editor state.
+ * @param markType - The mark type to look for.
+ * @returns `true` if the mark type is present in the selection.
+ *
+ * @example
+ * ```ts
+ * const bold = editorView.state.schema.marks.strong
+ * if (isMarkActive(editorView.state, bold)) {
+ *   console.log('Bold is active')
+ * }
+ * ```
+ */
 export declare function isMarkActive(state: EditorState, markType: MarkType): boolean;
+/**
+ * Returns the first `Mark` instance of the given type found in the current
+ * selection, or `null` if no such mark is present.
+ *
+ * For empty (collapsed) selections the function checks, in order:
+ * 1. `storedMarks` (marks queued for the next typed character)
+ * 2. Marks at the resolved cursor position
+ * 3. Marks on the node immediately after the cursor
+ *
+ * For non-empty selections the function iterates over all nodes in the range.
+ *
+ * Comparisons are done by mark-type name to avoid object-identity issues
+ * that can occur with ProseMirror schemas.
+ *
+ * @param state - The current ProseMirror editor state.
+ * @param markType - The mark type to retrieve.
+ * @returns The found `Mark` instance, or `null`.
+ *
+ * @example
+ * ```ts
+ * const linkMark = getMarkByType(editorView.state, editorView.state.schema.marks.link)
+ * if (linkMark) {
+ *   console.log('Link href:', linkMark.attrs.href)
+ * }
+ * ```
+ */
 export declare function getMarkByType(state: EditorState, markType: MarkType): Mark | null;
+/**
+ * Creates a reactive `Signal<boolean>` that tracks whether a mark of the
+ * given type is active in the current ProseMirror selection.
+ *
+ * The signal recomputes whenever the `state` ticker updates (which is
+ * triggered on every editor transaction).
+ *
+ * @param state - A ticker signal that increments on every editor state change.
+ * @param view - A signal holding the current `EditorView`.
+ * @param markType - The name of the mark type to track (e.g. `'strong'`, `'em'`, `'link'`).
+ * @returns A derived `Signal<boolean>` that is `true` when the mark is active.
+ *
+ * @example
+ * ```ts
+ * const isBold = makeActiveMarkSignal(stateUpdate, editorView, 'strong')
+ * isBold.on(active => {
+ *   console.log('Bold active:', active)
+ * })
+ * ```
+ */
 export declare function makeActiveMarkSignal(state: Signal<number>, view: Signal<EditorView>, markType: string): import("@tempots/dom").Computed<boolean>;
 /**
- * Check if a node type is active at the current selection
+ * Checks whether a node of the given type is active at the current selection
+ * position.
+ *
+ * Walks up the document tree from the resolved cursor position and also
+ * checks the node at the exact position. If `attrs` are provided, the
+ * function additionally verifies that the node's attributes match.
+ *
+ * @param state - The current ProseMirror editor state.
+ * @param nodeType - The node type to look for.
+ * @param attrs - Optional attribute constraints to match against the node's attributes.
+ * @returns `true` if a matching node is found in the current selection.
+ *
+ * @example
+ * ```ts
+ * const heading = editorView.state.schema.nodes.heading
+ * if (isNodeActive(editorView.state, heading, { level: 2 })) {
+ *   console.log('Currently inside an H2')
+ * }
+ * ```
  */
 export declare function isNodeActive(state: EditorState, nodeType: NodeType, attrs?: Record<string, unknown>): boolean;
+/**
+ * Creates a reactive `Signal<boolean>` that tracks whether a node of the
+ * given type (and optional attributes) is active at the current selection.
+ *
+ * The signal recomputes whenever the `state` ticker updates.
+ *
+ * @param state - A ticker signal that increments on every editor state change.
+ * @param view - A signal holding the current `EditorView`.
+ * @param nodeTypeName - The name of the node type to track (e.g. `'heading'`, `'bullet_list'`).
+ * @param attrs - Optional attribute constraints (e.g. `{ level: 2 }` for H2 headings).
+ * @returns A derived `Signal<boolean>` that is `true` when the node is active.
+ *
+ * @example
+ * ```ts
+ * const isH2 = makeActiveNodeSignal(stateUpdate, editorView, 'heading', { level: 2 })
+ * isH2.on(active => {
+ *   console.log('Inside H2:', active)
+ * })
+ * ```
+ */
 export declare function makeActiveNodeSignal(state: Signal<number>, view: Signal<EditorView>, nodeTypeName: string, attrs?: Record<string, unknown>): import("@tempots/dom").Computed<boolean>;

package/dist/types/components/theme/style-utils.d.ts

@@ -1,16 +1,111 @@
 import { ThemeColorName } from '../../tokens/colors';
+/**
+ * Extended color type that includes theme colors and the special `'transparent'` value.
+ */
 export type ExtendedColor = ThemeColorName | 'transparent';
+/**
+ * Theme appearance mode.
+ * Either `'light'` or `'dark'`.
+ */
 export type Mode = 'light' | 'dark';
+/**
+ * Background style variant.
+ * - `'solid'`: Full-intensity solid background
+ * - `'light'`: Light, subtle background
+ * - `'soft'`: Medium-intensity background
+ * - `'lighter'`: Very subtle background
+ */
 export type BackgroundVariant = 'solid' | 'light' | 'soft' | 'lighter';
+/**
+ * Foreground color tone for text and icons.
+ * - `'solid'`: High-contrast, vibrant color
+ * - `'soft'`: Lower-contrast, muted color
+ */
 export type ForegroundTone = 'solid' | 'soft';
+/**
+ * Computes background and text colors for a given color, variant, and theme mode.
+ * Applies variant-specific styling (solid, light, soft, lighter) and mode-specific shades.
+ *
+ * @param color - The theme color name
+ * @param variant - The background style variant
+ * @param mode - The theme mode ('light' or 'dark')
+ * @returns An object containing `backgroundColor` and `textColor` CSS values
+ *
+ * @example
+ * ```ts
+ * const { backgroundColor, textColor } = backgroundValue('primary', 'solid', 'light')
+ * // Returns: { backgroundColor: 'var(--color-primary-500)', textColor: 'var(--color-white)' }
+ * ```
+ */
 export declare function backgroundValue(color: ExtendedColor, variant: BackgroundVariant, mode: Mode): {
     backgroundColor: string;
     textColor: string;
 };
+/**
+ * Computes hover state background and text colors for interactive elements.
+ * Applies darker/lighter shades depending on the variant and mode.
+ *
+ * @param color - The theme color name
+ * @param variant - The background style variant ('solid', 'light', or 'soft')
+ * @param mode - The theme mode ('light' or 'dark')
+ * @returns An object containing `backgroundColor` and `textColor` CSS values for hover state
+ *
+ * @example
+ * ```ts
+ * const hover = hoverBackgroundValue('primary', 'solid', 'dark')
+ * // Returns darker shade for hover effect
+ * ```
+ */
 export declare function hoverBackgroundValue(color: ExtendedColor, variant: 'solid' | 'light' | 'soft', mode: Mode): {
     backgroundColor: string;
     textColor: string;
 };
+/**
+ * Computes the border color for a given color and theme mode.
+ * Uses medium-intensity shades (500 for light, 600 for dark).
+ *
+ * @param color - The theme color name
+ * @param mode - The theme mode ('light' or 'dark')
+ * @returns A CSS color value string
+ *
+ * @example
+ * ```ts
+ * const border = borderColorValue('primary', 'light')
+ * // Returns 'var(--color-primary-500)'
+ * ```
+ */
 export declare function borderColorValue(color: ExtendedColor, mode: Mode): string;
+/**
+ * Computes the text color for a given color and theme mode.
+ * Uses high-contrast shades (800 for light, 200 for dark) for readability.
+ *
+ * @param color - The theme color name
+ * @param mode - The theme mode ('light' or 'dark')
+ * @returns A CSS color value string
+ *
+ * @example
+ * ```ts
+ * const text = textColorValue('primary', 'light')
+ * // Returns 'var(--color-primary-800)'
+ * ```
+ */
 export declare function textColorValue(color: ExtendedColor, mode: Mode): string;
+/**
+ * Computes the foreground color (for icons, accents) with a specified tone.
+ * Supports both solid (vibrant) and soft (muted) tones.
+ *
+ * @param color - The theme color name
+ * @param tone - The foreground tone ('solid' for vibrant, 'soft' for muted)
+ * @param mode - The theme mode ('light' or 'dark')
+ * @returns A CSS color value string
+ *
+ * @example
+ * ```ts
+ * const icon = foregroundColorValue('success', 'solid', 'light')
+ * // Returns 'var(--color-success-500)'
+ *
+ * const mutedIcon = foregroundColorValue('success', 'soft', 'light')
+ * // Returns 'var(--color-success-300)'
+ * ```
+ */
 export declare function foregroundColorValue(color: ThemeColorName, tone: ForegroundTone, mode: Mode): string;

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

@@ -1,9 +1,48 @@
 import { Provider } from '@tempots/dom';
 import '../../styles/index.css';
 import { AppearancePreference, ThemeValue } from './types';
+/**
+ * Configuration options for the Theme provider.
+ */
 export interface ThemeOptions {
+    /** Initial appearance preference. Defaults to `'system'`. */
     defaultAppearance?: AppearancePreference;
+    /** localStorage key for persisting appearance preference. Defaults to `'bui-appearance'`. */
     appearancePreferenceKey?: string;
 }
+/**
+ * Theme provider that manages light/dark appearance mode.
+ * Tracks system appearance, user preference, and persists settings to localStorage.
+ * The resolved appearance is available as a reactive signal.
+ *
+ * @example
+ * ```ts
+ * import { Provide } from '@tempots/dom'
+ * import { Theme } from '@tempots/beatui'
+ *
+ * Provide(Theme, { defaultAppearance: 'dark' },
+ *   html.div({},
+ *     html.p({}, 'Theme is active!')
+ *   )
+ * )
+ * ```
+ */
 export declare const Theme: Provider<ThemeValue, ThemeOptions>;
+/**
+ * Reactive attribute that applies the current theme appearance as a CSS class.
+ * Maps the resolved appearance ('light' or 'dark') to class names `'b-light'` or `'b-dark'`.
+ * Typically attached to the document body or root element.
+ *
+ * @returns A reactive `attr.class` attribute
+ *
+ * @example
+ * ```ts
+ * import { html } from '@tempots/dom'
+ * import { ThemeAppearance } from '@tempots/beatui'
+ *
+ * html.body(ThemeAppearance(),
+ *   html.div({}, 'Content inherits theme appearance')
+ * )
+ * ```
+ */
 export declare const ThemeAppearance: () => import("@tempots/dom").Renderable;

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

@@ -1,30 +1,162 @@
 import { BackgroundColorName, ThemeColorName } from '../../tokens';
 import { Signal } from '@tempots/dom';
 import { AppearanceType } from '@tempots/ui';
-export type ButtonVariant = 'filled' | 'light' | 'outline' | 'default' | 'text';
+/**
+ * Visual style variant for button components.
+ * - `'filled'`: Solid background with theme color
+ * - `'light'`: Light background with colored text
+ * - `'outline'`: Transparent background with colored border
+ * - `'default'`: Default subtle styling
+ * - `'text'`: No background, text-only styling
+ */
+export type ButtonVariant = 'filled' | 'light' | 'outline' | 'dashed' | 'default' | 'text';
+/**
+ * Size options for form controls and interactive elements.
+ * Ranges from `'xs'` (extra small) to `'xl'` (extra large).
+ */
 export type ControlSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Size options for icon elements.
+ * Ranges from `'xs'` (extra small) to `'xl'` (extra large).
+ */
 export type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Increases or decreases a size value by a specified number of steps.
+ * Automatically clamps the result to valid size boundaries.
+ *
+ * @param size - The current size value
+ * @param steps - Number of steps to increase (positive) or decrease (negative). Default is 1.
+ * @returns The new size value after adjustment
+ * @throws {Error} If the provided size is invalid
+ *
+ * @example
+ * ```ts
+ * increaseSize('sm', 1)  // Returns 'md'
+ * increaseSize('xl', 2)  // Returns 'xl' (clamped)
+ * increaseSize('lg', -2) // Returns 'sm'
+ * ```
+ */
 export declare function increaseSize(size: IconSize | ControlSize, steps?: number): "sm" | "md" | "lg" | "xl" | "xs";
+/**
+ * Visual effect for overlay backgrounds.
+ * - `'transparent'`: Semi-transparent background (e.g., modal backdrop)
+ * - `'opaque'`: Fully opaque background
+ * - `'none'`: No visual overlay effect
+ */
 export type OverlayEffect = 'transparent' | 'opaque' | 'none';
+/**
+ * Interaction mode for overlay elements.
+ * - `'capturing'`: Captures clicks and prevents interaction with underlying content
+ * - `'non-capturing'`: Allows click-through to underlying content
+ */
 export type OverlayMode = 'capturing' | 'non-capturing';
+/**
+ * State of a fade transition animation.
+ * - `'initial'`: Before animation begins
+ * - `'entering'`: Fade-in animation in progress
+ * - `'entered'`: Fade-in complete, element fully visible
+ * - `'exiting'`: Fade-out animation in progress
+ * - `'exited'`: Fade-out complete, element hidden
+ */
 export type FadeTransitionState = 'initial' | 'entering' | 'entered' | 'exiting' | 'exited';
+/**
+ * Specification for which sides of a box to apply styling (e.g., borders, padding).
+ * - `'left' | 'right' | 'top' | 'bottom'`: Single side
+ * - `'none'`: No sides
+ * - `'all'`: All four sides
+ * - Array of sides: Multiple specific sides
+ */
 export type Side = 'left' | 'right' | 'top' | 'bottom' | 'none' | 'all' | ('left' | 'right' | 'top' | 'bottom')[];
+/**
+ * Color options for panel components.
+ * Includes background color names, theme colors, and special values like `'white'`, `'black'`, and `'transparent'`.
+ */
 export type PanelColor = BackgroundColorName | ThemeColorName | 'white' | 'black' | 'transparent';
+/**
+ * Shadow intensity for panel components.
+ * Ranges from `'none'` (no shadow) to `'lg'` (large shadow).
+ */
 export type PanelShadow = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * Semantic type for label text styling.
+ * - `'emphasis'`: High-contrast, emphasized text
+ * - `'default'`: Standard text appearance
+ * - `'muted'`: Low-contrast, de-emphasized text
+ * - `'danger'`: Error or warning styling
+ */
 export type LabelType = 'emphasis' | 'default' | 'muted' | 'danger';
+/**
+ * CSS `justify-content` property values for flexbox layouts.
+ * Controls alignment of flex items along the main axis.
+ */
 export type JustifyContent = 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe center' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch' | 'baseline' | 'normal';
+/**
+ * CSS `justify-items` property values for grid layouts.
+ * Controls alignment of grid items along the inline (row) axis.
+ */
 export type JustifyItems = 'start' | 'end' | 'safe end' | 'center' | 'safe center' | 'stretch' | 'normal';
+/**
+ * CSS `justify-self` property values for individual grid/flex items.
+ * Controls alignment of a single item along the inline (row) axis.
+ */
 export type JustifySelf = 'auto' | 'start' | 'center' | 'safe center' | 'end' | 'safe end' | 'stretch';
+/**
+ * CSS `align-content` property values for multi-line flex containers.
+ * Controls alignment of flex lines along the cross axis.
+ */
 export type AlignContent = 'normal' | 'center' | 'flex-start' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly' | 'baseline' | 'stretch';
+/**
+ * CSS `align-items` property values for flexbox layouts.
+ * Controls alignment of flex items along the cross axis.
+ */
 export type AlignItems = 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe-center' | 'baseline' | 'last-baseline' | 'stretch';
+/**
+ * CSS `align-self` property values for individual flex/grid items.
+ * Controls alignment of a single item along the cross axis.
+ */
 export type AlignSelf = 'auto' | 'flex-start' | 'flex-end' | 'safe flex-end' | 'center' | 'safe center' | 'stretch' | 'baseline' | 'last baseline';
+/**
+ * Visual style variant for card components.
+ * - `'default'`: Standard card appearance
+ * - `'elevated'`: Card with shadow elevation
+ * - `'flat'`: Minimal card with no shadow
+ * - `'outlined'`: Card with border outline
+ */
 export type CardVariant = 'default' | 'elevated' | 'flat' | 'outlined';
+/**
+ * Gap spacing size for centered layouts.
+ * Ranges from `'none'` (no gap) to `'xl'` (extra large gap).
+ */
 export type CenterGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Visual depth variant for sink/inset components.
+ * - `'default'`: Standard inset depth
+ * - `'deep'`: Stronger inset effect
+ * - `'shallow'`: Subtle inset effect
+ * - `'flat'`: Minimal or no inset effect
+ */
 export type SinkVariant = 'default' | 'deep' | 'shallow' | 'flat';
+/**
+ * User's appearance preference setting.
+ * - `'light'`: Light theme
+ * - `'dark'`: Dark theme
+ * - `'system'`: Follow system preference
+ */
 export type AppearancePreference = 'light' | 'dark' | 'system';
+/**
+ * Resolved appearance mode (excludes system option).
+ * Either `'light'` or `'dark'`.
+ */
 export type Appearance = 'light' | 'dark';
+/**
+ * Theme context value provided by the Theme provider.
+ * Contains reactive signals for appearance state and a setter for user preferences.
+ */
 export interface ThemeValue {
+    /** Function to update the user's appearance preference. */
     setAppearancePreference: (appearance: AppearancePreference) => void;
+    /** Signal representing the user's selected appearance preference (including 'system'). */
     appearancePreference: Signal<AppearancePreference>;
+    /** Signal representing the resolved appearance mode ('light' or 'dark'). */
     appearance: Signal<AppearanceType>;
 }

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

@@ -1 +1,2 @@
+export * from './kbd';
 export * from './label';

package/dist/types/components/typography/kbd.d.ts

@@ -0,0 +1,48 @@
+import { TNode, Value } from '@tempots/dom';
+/**
+ * Size variants for the keyboard key component.
+ *
+ * - `'xs'` - Extra small (12px)
+ * - `'sm'` - Small (14px, default)
+ * - `'md'` - Medium (16px)
+ */
+export type KbdSize = 'xs' | 'sm' | 'md';
+/**
+ * Configuration options for the {@link Kbd} component.
+ */
+export interface KbdOptions {
+    /** Size of the keyboard key element. @default 'sm' */
+    size?: Value<KbdSize>;
+}
+/**
+ * A styled keyboard key indicator component for displaying keyboard shortcuts.
+ * Renders keys with a 3D pressed appearance using monospace font.
+ *
+ * @param options - Configuration for size
+ * @param children - Key text content (e.g., "Ctrl", "⌘", "K")
+ * @returns A styled `<kbd>` element
+ *
+ * @example
+ * ```typescript
+ * // Single key
+ * Kbd({ size: 'sm' }, 'K')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Keyboard shortcut combination
+ * html.span(
+ *   Kbd({}, '⌘'),
+ *   ' + ',
+ *   Kbd({}, 'K')
+ * )
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Different sizes
+ * Kbd({ size: 'xs' }, 'Esc')
+ * Kbd({ size: 'md' }, 'Enter')
+ * ```
+ */
+export declare function Kbd({ size }?: KbdOptions, ...children: TNode[]): import("@tempots/dom").Renderable;

package/dist/types/components/typography/label.d.ts

@@ -1,5 +1,50 @@
 import { TNode } from '@tempots/dom';
+/**
+ * Renders an emphasized inline label with stronger visual weight.
+ * Useful for highlighting important terms or key values.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with emphasis label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Status: ', EmphasisLabel('Active'))
+ * ```
+ */
 export declare const EmphasisLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a standard inline label with default text styling.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with default label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Name: ', Label('John Doe'))
+ * ```
+ */
 export declare const Label: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a muted inline label with subdued color for secondary information.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with muted label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p(Label('Primary info'), ' ', MutedLabel('(optional)'))
+ * ```
+ */
 export declare const MutedLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;
+/**
+ * Renders a danger-styled inline label for error messages or destructive context.
+ *
+ * @param children - Content nodes to render inside the label span.
+ * @returns A `<span>` element with danger label styling.
+ *
+ * @example
+ * ```typescript
+ * html.p('Validation: ', DangerLabel('Required field'))
+ * ```
+ */
 export declare const DangerLabel: (...children: TNode[]) => import("@tempots/dom").Renderable;

package/dist/types/index.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Main entry point for the `@tempots/beatui` component library.
+ *
+ * Exports all core UI components (buttons, forms, layout, overlays, navigation,
+ * typography, data display), the theme system, design tokens, i18n utilities,
+ * and helper functions. For optional modules (editors, auth, JSON schema), use
+ * the dedicated subpath imports.
+ *
+ * ```ts
+ * import { Button, TextInput, Modal, Theme } from '@tempots/beatui'
+ * ```
+ *
+ * @module
+ */
 export { Use } from '@tempots/dom';
 export * from './beatui-i18n';
 export * from './components/beatui';

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

@@ -1 +1,14 @@
+/**
+ * JSON Schema form generation for `@tempots/beatui/json-schema`.
+ *
+ * Automatically generates validated form UIs from JSON Schema definitions.
+ * Supports custom widget registration, nested objects/arrays, conditional
+ * schemas, and integrates with BeatUI's form controller system.
+ *
+ * ```ts
+ * import { JsonSchemaForm } from '@tempots/beatui/json-schema'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/json-schema';

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

@@ -1 +1,13 @@
+/**
+ * Read-only JSON Schema display for `@tempots/beatui/json-schema-display`.
+ *
+ * Renders JSON Schema structures as formatted, non-editable documentation.
+ * Useful for API reference pages, schema explorers, and data dictionaries.
+ *
+ * ```ts
+ * import { JsonSchemaDisplay } from '@tempots/beatui/json-schema-display'
+ * ```
+ *
+ * @module
+ */
 export * from '../components/json-schema-display';

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

@@ -1,9 +1,14 @@
 /**
- * JSON Structure Form Components
+ * JSON Structure form components for `@tempots/beatui/json-structure`.
  *
- * Entry point for the json-structure subpackage.
- * Import from '@tempots/beatui/json-structure'
+ * Provides form controls for editing structured JSON data with type-safe
+ * value handling, validation, and support for complex nested structures
+ * including objects, arrays, unions, and optional fields.
  *
- * @packageDocumentation
+ * ```ts
+ * import { JsonStructureForm } from '@tempots/beatui/json-structure'
+ * ```
+ *
+ * @module
  */
 export * from '../components/json-structure';

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;
+}>;