@seekbuddy/dsh-ui 0.0.0-stage → 0.2.0-beta.1

package/dist/tokens.css.d.ts

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

package/dist/types/AnimatedRows.d.ts

@@ -0,0 +1,45 @@
+/** React-commit-driven movement and entry/exit fades for keyed rows. */
+import { Component, type AriaRole, type ReactNode } from 'react';
+/** Keyed row content, list semantics, and animation readiness. */
+export interface AnimatedRowsProps {
+    children: ReactNode;
+    className: string;
+    role?: AriaRole;
+    label?: string;
+    /** Unique DOM-order keys matching the rendered data-row-key attributes. */
+    rowKeys: readonly string[];
+    ready: boolean;
+    /** Changes that replace the view or reveal hidden rows settle immediately. */
+    resetKey: string;
+}
+interface RowPosition {
+    element: HTMLElement;
+    rect: DOMRect;
+    opacity: number;
+}
+interface RowSnapshot {
+    positions: Map<string, RowPosition>;
+    removed: Map<string, RowPosition>;
+}
+/**
+ * Animates keyed rows only when their rendered membership or order changes.
+ * Motion starts after the first pointer or keyboard input inside the mounted list.
+ * The parent supplies a positioned container for the inert exit overlay.
+ */
+export declare class AnimatedRows extends Component<AnimatedRowsProps> {
+    private armed;
+    private readonly list;
+    private readonly overlay;
+    private readonly movements;
+    private readonly exits;
+    getSnapshotBeforeUpdate(previous: AnimatedRowsProps): RowSnapshot | null;
+    componentDidUpdate(previous: AnimatedRowsProps, _state: unknown, snapshot: RowSnapshot | null): void;
+    componentWillUnmount(): void;
+    private readPositions;
+    private move;
+    private cancelMovements;
+    private removeExit;
+    private clear;
+    render(): ReactNode;
+}
+export {};

package/dist/types/Button.d.ts

@@ -0,0 +1,18 @@
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+/** Visual variant, each backed by its --dsw-alias-button-* token family. */
+export type ButtonVariant = 'primary' | 'ghost' | 'outline' | 'toolbar';
+/**
+ * Render a button.
+ * @param props.variant - visual family (default 'ghost'); outlined buttons use a DPR-aware inset stroke.
+ * @param props.size - 'md' 36px control with 12px corners or 'sm' 28px control with 8px corners.
+ * @param props.icon - optional leading 16px icon node.
+ * @param ref - native button for focus management and overlay anchors.
+ * @returns the button element; native button attributes pass through.
+ */
+export declare const Button: import("react").ForwardRefExoticComponent<{
+    variant?: ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: ReactNode;
+    className?: string | undefined;
+    children?: ReactNode;
+} & ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/Checkbox.d.ts

@@ -0,0 +1,19 @@
+/** Controlled native checkbox with a caller-owned visible and accessible label. */
+/**
+ * Render a labeled checkbox with native keyboard and form semantics.
+ * @param props.checked - current checked state.
+ * @param props.onChange - receives the requested checked state.
+ * @param props.label - localized visible and accessible label.
+ * @param props.disabled - whether the control refuses changes.
+ * @param props.title - optional localized hover text.
+ * @param props.className - extra class for the label's placement.
+ * @returns the label containing its checkbox.
+ */
+export declare function Checkbox({ checked, onChange, label, disabled, title, className, }: {
+    checked: boolean;
+    onChange: (next: boolean) => void;
+    label: string;
+    disabled?: boolean;
+    title?: string | undefined;
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/CodeFileIcon.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+import type { CodeFileType } from './code-file-types.js';
+/**
+ * Render one full-color square code-file glyph from the embedded icon set.
+ * @param props - Detailed code type, optional size, and optional CSS class.
+ * @returns The selected decorative SVG with its identifying palette intact.
+ */
+export declare function CodeFileIcon({ type, size, className }: IconProps & {
+    readonly type: CodeFileType;
+}): ReactNode;

package/dist/types/CodeToolbar.d.ts

@@ -0,0 +1,29 @@
+/** Localized language fallback and wrapping actions supplied by the card owner. */
+export interface CodeToolbarLabels {
+    /** Title for an absent or unsupported language. */
+    codeLabel: string;
+    /** Action that enables wrapping. */
+    wrapLabel: string;
+    /** Action that preserves source columns with horizontal scrolling. */
+    unwrapLabel: string;
+}
+/** Display state and callbacks for a code card's toolbar. */
+interface CodeToolbarProps {
+    lang?: string | undefined;
+    title?: string | undefined;
+    status?: string | undefined;
+    labels: CodeToolbarLabels;
+    copyLabel: string;
+    copiedLabel: string;
+    copied: boolean;
+    wrapped: boolean;
+    onCopy?: (() => void) | undefined;
+    onWrap?: (() => void) | undefined;
+}
+/**
+ * Render a language label and keyboard-accessible icon actions with tooltips.
+ * @param props - Localized labels, current state, and card-owned actions.
+ * @returns The shared code-card header.
+ */
+export declare function CodeToolbar({ lang, title, status, labels, copyLabel, copiedLabel, copied, wrapped, onCopy, onWrap, }: CodeToolbarProps): import("react").JSX.Element;
+export {};

package/dist/types/CommandText.d.ts

@@ -0,0 +1,15 @@
+/** Display text and owner-localized identification for a command scrollport. */
+export interface CommandTextProps {
+    /** Original command or formatted command arguments, without truncation. */
+    text: string;
+    /** Accessible name while the text can scroll horizontally. */
+    label: string;
+    /** Owner typography and positioning. */
+    className?: string | undefined;
+}
+/**
+ * Render command text without adding Tab stops for content that fits.
+ * @param props - Text, localized scrollport name, and owner styling.
+ * @returns A horizontal text scrollport, named and keyboard-focusable only when overflowing.
+ */
+export declare function CommandText({ text, label, className }: CommandTextProps): import("react").JSX.Element;

package/dist/types/ConfigField.d.ts

@@ -0,0 +1,32 @@
+/** Field state and localized controls supplied by the owning form. */
+export interface ConfigFieldProps {
+    /** Display label from the owning plugin. */
+    label: string;
+    /** Editable text; containers may use JSON. */
+    value: string;
+    /** Hide the input text and disable browser password autofill. */
+    secret: boolean;
+    /** Finite choices; an empty list uses a text control. */
+    choices: readonly string[];
+    /** Whether the field is currently read-only. */
+    disabled: boolean;
+    /** Whether the field has a user override. */
+    overridden: boolean;
+    /** Whether the draft fails validation. */
+    invalid: boolean;
+    /** Localized reset, inherited-value choice, and validation text. */
+    labels: {
+        reset: string;
+        inherited: string;
+        invalid: string;
+    };
+    /** Stage a new text value. */
+    onChange: (value: string) => void;
+    /** Stage removal of the user override. */
+    onReset: () => void;
+}
+/** Render a field without owning its schema, draft, or persistence.
+ * @param props Controlled field state and actions.
+ * @returns A labelled input with reset and validation feedback.
+ */
+export declare function ConfigField(props: ConfigFieldProps): import("react").JSX.Element;

package/dist/types/ConnectionIndicator.d.ts

@@ -0,0 +1,25 @@
+/** Visual state rendered by {@link ConnectionIndicator}. */
+export type ConnectionIndicatorState = 'disconnected' | 'connecting' | 'recovered';
+/**
+ * Render an inline connection-recovery control. The outage and retry-attempt
+ * states are one button whose static label already names the retry action;
+ * clicking it requests an immediate reconnect. The indicator animates in on
+ * appearance and fades out for {@link EXIT_MS} before unmounting.
+ * @param props.state - visible outage, retry-attempt, or recovered state.
+ * @param props.disconnectedLabel - localized outage text naming the retry action.
+ * @param props.connectingLabel - localized retry text followed by the attempt dots.
+ * @param props.recoveredLabel - localized recovery confirmation.
+ * @param props.reconnectActionLabel - accessible label for the outage action.
+ * @param props.restartActionLabel - accessible label for replacing an active attempt.
+ * @param props.onReconnect - request an immediate reconnect attempt.
+ * @returns the indicator, or null when no connection feedback is active.
+ */
+export declare function ConnectionIndicator({ state, disconnectedLabel, connectingLabel, recoveredLabel, reconnectActionLabel, restartActionLabel, onReconnect, }: {
+    state: ConnectionIndicatorState | undefined;
+    disconnectedLabel: string;
+    connectingLabel: string;
+    recoveredLabel: string;
+    reconnectActionLabel: string;
+    restartActionLabel: string;
+    onReconnect: () => void;
+}): import("react").JSX.Element | null;

package/dist/types/DetailDocument.d.ts

@@ -0,0 +1,77 @@
+import { type ReactNode } from 'react';
+import { type MarkdownLabels, type MarkdownPathImages } from './markdown/MarkdownText.js';
+/** One read of a long Markdown description, such as a plugin's detail document. */
+export type DetailDocumentState = {
+    readonly status: 'loading';
+} | {
+    readonly status: 'found';
+    readonly markdown: string;
+} | {
+    readonly status: 'none';
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+/** A read as owners track it: in flight, settled with a document or none, or failed with a localized message. */
+export type DetailDocumentRead = undefined | {
+    readonly status: 'loading';
+} | {
+    readonly status: 'ready';
+    readonly markdown: string | undefined;
+} | {
+    readonly status: 'error';
+    readonly message: string;
+};
+/**
+ * The state {@link DetailDocument} shows for an owner's read: loading until it settles, then the document, none, or the
+ * failure.
+ * @param read - the owner's read; undefined before it starts.
+ * @returns the state to show.
+ */
+export declare function detailDocumentState(read: DetailDocumentRead): DetailDocumentState;
+/** Translated strings of a detail document's chrome, as an owner's dictionary supplies them. */
+export interface DetailDocumentCopy {
+    readonly title: string;
+    readonly loading: string;
+    readonly retry: string;
+    readonly copy: string;
+    readonly copied: string;
+    readonly codeBlock: string;
+    readonly wrap: string;
+    readonly unwrap: string;
+    readonly footnotes: string;
+}
+/**
+ * Assemble reference-stable labels for {@link DetailDocument} from translated strings.
+ * @param copy - the translated strings.
+ * @returns labels that keep their identity while the strings stay equal.
+ */
+export declare function useDetailDocumentLabels(copy: DetailDocumentCopy): DetailDocumentLabels;
+/** Localized chrome of a detail document. */
+export interface DetailDocumentLabels {
+    /** Accessible name of the scrollable document region; the section shows no heading of its own. */
+    readonly title: string;
+    /** Accessible name of the loading placeholder. */
+    readonly loading: string;
+    /** Retry button text. */
+    readonly retry: string;
+    readonly markdown: MarkdownLabels;
+}
+/**
+ * A section showing a long Markdown description, without a heading of its own: three skeleton lines while it loads, the
+ * document once found, or the owner's failure message with a retry. Nothing renders for `none`. A document taller than
+ * the section's height limit scrolls inside it, and the scroll region, named by `labels.title`, takes keyboard focus.
+ * Raw HTML is omitted, relative links stay text, and only images the owner's `images` resolver accepts, or absolute
+ * HTTP(S) images, load.
+ * @param props.state - the read to show.
+ * @param props.labels - localized region name, placeholder name, retry text, and Markdown chrome; keep `markdown` reference-stable.
+ * @param props.images - resolves the document's relative image destinations to displayable URLs.
+ * @param props.onRetry - reads the document again after a failure.
+ * @returns the section, or null.
+ */
+export declare function DetailDocument({ state, labels, images, onRetry, }: {
+    readonly state: DetailDocumentState;
+    readonly labels: DetailDocumentLabels;
+    readonly images?: MarkdownPathImages | undefined;
+    readonly onRetry: () => void;
+}): ReactNode;

package/dist/types/DiffBlock.d.ts

@@ -0,0 +1,51 @@
+import { type CodeToolbarLabels } from './CodeToolbar.js';
+/** Output lines shown before the height cap collapses the middle. */
+export declare const DEFAULT_DIFF_MAX_LINES = 16;
+/**
+ * One file change in the form {@link DiffBlock} renders. It is declared here
+ * so this primitive stays independent of the tool contract.
+ */
+export interface DiffHunk {
+    /** The changed file's path, drawn verbatim as the hunk's header (the tool's model-facing path). */
+    path: string;
+    /** Prior content including context, or `null` when no prior content is available. */
+    oldText: string | null;
+    /** Content after the change, including any shared context. */
+    newText: string;
+}
+export interface DiffBlockProps {
+    /** One entry per applied hunk, in file order; empty renders nothing. */
+    diffs: DiffHunk[];
+    /** Localized chrome supplied by the owning render site. */
+    labels: DiffBlockLabels;
+    /** Height cap in body lines before the middle collapses (default {@link DEFAULT_DIFF_MAX_LINES}). */
+    maxLines?: number | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+}
+/** Localized chrome for {@link DiffBlock}. */
+export interface DiffBlockLabels extends CodeToolbarLabels {
+    copy: string;
+    copied: string;
+    collapseAria: string;
+    expandAria: (hidden: number) => string;
+    collapse: string;
+    expand: (hidden: number) => string;
+}
+/**
+ * Count displayed additions and deletions. Exact patches exclude shared context;
+ * comparisons exceeding the edit limit count both complete fragments as replaced.
+ * Text follows {@link contentLines}'s terminator rule.
+ * @param diffs - the hunks to count.
+ * @returns the +/- totals for tool summaries.
+ */
+export declare function diffTotals(diffs: DiffHunk[]): {
+    added: number;
+    removed: number;
+};
+/**
+ * Render a file mutation as an inline diff surface.
+ * @param props - see {@link DiffBlockProps}.
+ * @returns the diff block element.
+ */
+export declare function DiffBlock({ diffs, labels, maxLines, className }: DiffBlockProps): import("react").JSX.Element | null;

package/dist/types/DisclosureRow.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from 'react';
+/** Shared 24px process row: tertiary text and icons, secondary on hover. */
+export interface DisclosureRowProps {
+    icon: ReactNode;
+    title: string;
+    open: boolean;
+    expandable: boolean;
+    onToggle: () => void;
+    /** Animate the complete header while its owning operation is running. */
+    running?: boolean | undefined;
+    /** Makes the title row the disclosure target; with an accessory, it shrinks to its content width. */
+    expandOnRowClick?: boolean | undefined;
+    /** Replaces the collapsed icon with a chevron while the row is hovered. */
+    previewChevron?: boolean | undefined;
+    /** Keeps `collapsedContent` inline while open. */
+    keepContentWhenOpen?: boolean | undefined;
+    collapsedContent?: ReactNode;
+    /** Independent action beside the title, outside the disclosure target and shimmer. */
+    headerAccessory?: ReactNode;
+    children?: ReactNode;
+    className?: string | undefined;
+    rowClassName?: string | undefined;
+    /** Sizing class for the header text area, beside the leading icon. */
+    contentClassName?: string | undefined;
+    /** Layout class shared by the header text and its decorative copy. */
+    contentLayoutClassName?: string | undefined;
+    leadingClassName?: string | undefined;
+    chevronClassName?: string | undefined;
+    titleClassName?: string | undefined;
+}
+/**
+ * Render one disclosure header and its controlled expanded content.
+ * Shallow prop comparison requires stable callbacks and React nodes to skip unchanged renders.
+ * @param props - Visual content, controlled state, and interaction policy.
+ * @returns the disclosure row.
+ */
+export declare const DisclosureRow: import("react").MemoExoticComponent<({ icon, title, open, expandable, onToggle, running, expandOnRowClick, previewChevron, keepContentWhenOpen, collapsedContent, headerAccessory, children, className, rowClassName, contentClassName, contentLayoutClassName, leadingClassName, chevronClassName, titleClassName, }: DisclosureRowProps) => import("react").JSX.Element>;

package/dist/types/DraggableImage.d.ts

@@ -0,0 +1,18 @@
+/** Original-image drag gestures owned by a presentation primitive. */
+import { type ImgHTMLAttributes } from 'react';
+import type { FileDragActions } from './file-drag-actions.js';
+/** Image presentation plus original content and explicit file preparation callbacks. */
+export interface DraggableImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'draggable' | 'onDragStart' | 'onDragEnd' | 'onPointerEnter' | 'onPointerLeave' | 'onPointerDown' | 'onPointerUp' | 'onClickCapture'> {
+    readonly fileDrag: FileDragActions;
+    readonly src: string;
+    readonly name: string;
+    readonly resourceAddress?: string | undefined;
+    readonly original?: File | undefined;
+}
+/**
+ * Render an image with original-file dragging; using explicit application-owned callbacks.
+ * @param props - image attributes, original filename and file preparation callbacks.
+ * @param ref - image element for measurement and pointer-mode bindings.
+ * @returns a draggable image that suppresses only the mouse click following its drag.
+ */
+export declare const DraggableImage: import("react").ForwardRefExoticComponent<DraggableImageProps & import("react").RefAttributes<HTMLImageElement>>;

package/dist/types/FileTypeIcon.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+import { type CodeFileType, type FileTypeProjectContext } from './code-file-types.js';
+import type { IconProps } from './icons/props.js';
+/** File categories with distinct 28px glyphs. */
+export type FileType = CodeFileType | 'code' | 'excel' | 'folder' | 'html' | 'image' | 'markdown' | 'other' | 'pdf' | 'ppt' | 'video' | 'word';
+/** Compatibility name for consumers that pass an already resolved category. */
+export type FileTypeKind = FileType;
+type ClassifiedFileType = Exclude<FileType, 'folder'>;
+export type { CodeFileType, FileTypeProjectContext } from './code-file-types.js';
+/** Props for {@link FileTypeIcon}: either a path to classify or an already resolved kind. */
+export type FileTypeIconProps = IconProps & ({
+    /** File path or name to classify. */
+    readonly path: string;
+    /** Optional project-file snapshot for context-sensitive code icons such as Flutter. */
+    readonly context?: FileTypeProjectContext | undefined;
+} | {
+    /** Explicit category for callers that already resolved the file type. */
+    readonly kind: FileTypeKind;
+});
+/**
+ * Extract the final suffix from a file path without changing its case.
+ * A leading dot starts a suffix, while a missing or trailing dot returns an empty string.
+ * @param path - File path or basename using either path separator.
+ * @returns The characters after the basename's final dot.
+ */
+export declare function fileExtension(path: string): string;
+/**
+ * Classify a file path or name for file-card presentation.
+ * Matching is case-insensitive and applies code filename rules before extension rules;
+ * unknown names fall back to `other`.
+ * @param path - File path or basename using either path separator.
+ * @param context - Optional project files used by context-sensitive code mappings.
+ * @returns The file's closed presentation category.
+ */
+export declare function classifyFileType(path: string, context?: FileTypeProjectContext): ClassifiedFileType;
+/**
+ * Render a decorative file-type glyph for a path or an explicitly resolved kind.
+ * @param props - Path or kind selection, optional project context, size, and CSS class.
+ * @returns The category-colored SVG; the caller owns the accessible name and may override
+ * the color through `--dsh-file-type-icon-color`.
+ */
+export declare function FileTypeIcon(props: FileTypeIconProps): ReactNode;

package/dist/types/FoldToggle.d.ts

@@ -0,0 +1,19 @@
+interface FoldToggleProps {
+    className: string | undefined;
+    expanded: boolean;
+    hidden: number;
+    labels: {
+        collapseAria: string;
+        expandAria: (hidden: number) => string;
+        collapse: string;
+        expand: (hidden: number) => string;
+    };
+    onToggle: () => void;
+}
+/**
+ * Render the shared head-tail fold control with caller-owned localized copy.
+ * @param props - Fold state, localized labels, and toggle callback.
+ * @returns The accessible expand or collapse button.
+ */
+export declare function FoldToggle({ className, expanded, hidden, labels, onToggle }: FoldToggleProps): import("react").JSX.Element;
+export {};

package/dist/types/HoverCard.d.ts

@@ -0,0 +1,44 @@
+import type { ReactNode, RefObject } from 'react';
+/**
+ * Render an anchor with a hover-triggered preview card independently of nested tooltips.
+ * Touch entry does not open a preview or intercept the anchor's action.
+ * @param props.anchor - the hover target (rendered in place inside a wrapper span).
+ * @param props.content - card content; the pointer may rest on it, so it is
+ * readable and selectable, but it carries no dismissal affordance of its own.
+ * @param props.openDelayMs - hover dwell before the card shows (default 500).
+ * @param props.variant - compact card beside the anchor, or a preview above/below it
+ * with 24px side insets, a 420px height cap, the frame-top clearance (capped below an anchor inside the top strip),
+ * and 100ms opacity transitions.
+ * @param props.widthAnchorRef - optional element whose width and horizontal position size the preview.
+ * @param props.inline - keep the anchor in prose; show a contained preview on hover or keyboard focus.
+ * Its hover region connects the anchor and preview across the visual gap.
+ * @param props.fitContent - size an inline card to its content within the usual width cap.
+ * @param props.disabled - suppress opening; turning true dismisses an open card.
+ * @param props.grouped - share first-display dwell across the surrounding list and active portal.
+ * Group replacement removes the previous card immediately, including a fading preview.
+ * @param props.copyText - optional primary value copied by activation and
+ * included in the card's accessible name.
+ * @param props.copyLabel - localized accessible activation-label prefix.
+ * @param props.copiedLabel - localized visible success label.
+ * @returns anchor wrapper with the conditional portaled card.
+ */
+export declare function HoverCard({ anchor, content, openDelayMs, disabled, grouped, copyText, copyLabel, copiedLabel, variant, widthAnchorRef, inline, fitContent, }: {
+    anchor: ReactNode;
+    /** Inline media preview using the shared menu material and keyboard focus. */
+    inline?: boolean;
+    fitContent?: boolean;
+    content: ReactNode;
+    openDelayMs?: number;
+    disabled?: boolean;
+    grouped?: boolean;
+    variant?: 'compact' | 'preview';
+    widthAnchorRef?: RefObject<HTMLElement | null>;
+} & ({
+    copyText?: string | undefined;
+    copyLabel: string;
+    copiedLabel: string;
+} | {
+    copyText?: undefined;
+    copyLabel?: string;
+    copiedLabel?: string;
+})): import("react").JSX.Element;

package/dist/types/HoverCardGroup.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+interface GroupState {
+    isWarm: () => boolean;
+    enter: (overCard: boolean) => void;
+    leave: () => void;
+    containsCard: (target: EventTarget | null) => boolean;
+    shown: (owner: symbol, dismiss: () => void, element: HTMLElement) => void;
+    release: (owner: symbol) => void;
+}
+/** Private coordination shared only by opted-in HoverCards inside one mounted group. */
+export declare const HoverCardGroupContext: import("react").Context<GroupState | null>;
+/**
+ * Share first-display dwell across a list and its active portal, including the card's existing pointer grace.
+ * @param props.children - list contents, including opted-in HoverCards.
+ * @param props.className - classes for the physical list container.
+ * @param props.as - physical container tag; use span to preserve inline text layout.
+ * @returns the list container and its private hover coordinator.
+ */
+export declare function HoverCardGroup({ children, className, as: Container, }: {
+    children: ReactNode;
+    className?: string | undefined;
+    as?: 'div' | 'span';
+}): import("react").JSX.Element;
+export {};

package/dist/types/ImageLightbox.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes } from 'react';
+/** Lightbox strings the owner resolves from its own locale namespace. */
+export interface ImageLightboxLabels {
+    /** Accessible name of the preview dialog. */
+    dialog: string;
+    /** Accessible label of the close control. */
+    close: string;
+}
+/**
+ * Document-level original-image preview opened by clicking a thumbnail.
+ * Closes on Escape, backdrop press, or the close control, and restores focus
+ * to the opener on unmount. Rendered through a body portal: an opener inside
+ * a transformed or filtered ancestor would otherwise trap the fixed backdrop
+ * in that ancestor's box instead of covering the viewport.
+ *
+ * @param props.src - the original image URL.
+ * @param props.alt - the image's alt text.
+ * @param props.labels - dialog and close-control strings.
+ * @param props.contextMenuProps - optional original-image gesture bindings.
+ * @param props.onClose - dismiss callback owned by the opener.
+ * @returns the modal preview dialog.
+ */
+export declare function ImageLightbox({ src, alt, labels, onClose, contextMenuProps, }: {
+    src: string;
+    alt: string;
+    labels: ImageLightboxLabels;
+    onClose: () => void;
+    contextMenuProps?: Pick<HTMLAttributes<HTMLElement>, 'onContextMenu' | 'onKeyDown' | 'tabIndex'> | undefined;
+}): import("react").ReactPortal;

package/dist/types/ImagePreview.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Render an image without introducing a second activation target.
+ * @param props - Source, accessible description, localized status.
+ * @returns A contained preview with loading or failure status.
+ */
+export declare function ImagePreview({ src, alt, loadingLabel, failedLabel, }: {
+    src: string;
+    alt: string;
+    loadingLabel: string;
+    failedLabel: string;
+}): import("react").JSX.Element;

package/dist/types/InlineEditor.d.ts

@@ -0,0 +1,22 @@
+/** Multi-line inline editor for short saved-on-Enter drafts such as queued messages and goals. */
+/**
+ * Render an autofocused textarea that grows with its text up to six lines, then scrolls.
+ * A textarea rather than an input: HTML strips newlines from single-line input values.
+ * Enter saves, Shift+Enter breaks the line, Enter during IME composition does nothing,
+ * and Escape cancels.
+ * @param props.value - current draft text.
+ * @param props.label - localized accessible name.
+ * @param props.onChange - receives the edited text.
+ * @param props.onSave - called for a plain Enter.
+ * @param props.onCancel - called for Escape.
+ * @param props.className - extra class for the editor's placement.
+ * @returns the textarea.
+ */
+export declare function InlineEditor({ value, label, onChange, onSave, onCancel, className, }: {
+    value: string;
+    label: string;
+    onChange: (value: string) => void;
+    onSave: () => void;
+    onCancel: () => void;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/types/Input.d.ts

@@ -0,0 +1,11 @@
+import { type InputHTMLAttributes, type ReactNode } from 'react';
+/**
+ * Render a text input with an optional leading icon.
+ * @param props.icon - optional 16px leading icon node.
+ * @param ref - the native input, cleared when it unmounts.
+ * @returns wrapper span containing the native input; input attributes pass through.
+ */
+export declare const Input: import("react").ForwardRefExoticComponent<{
+    icon?: ReactNode;
+    className?: string;
+} & InputHTMLAttributes<HTMLInputElement> & import("react").RefAttributes<HTMLInputElement>>;