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

package/dist/types/ShortcutKeys.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Render one command's keycaps without owning binding defaults or localized copy.
+ * @param props - effective key labels, presentation variant and optional interaction styling.
+ * @returns unboxed keys by default, or tooltip keycaps with plus-separated combinations grouped together.
+ */
+export declare function ShortcutKeys({ keys, variant, className, }: {
+    keys: readonly string[];
+    variant?: 'plain' | 'tooltip';
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/SiteGlyph.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Site marks for well-known external link hosts. {@link LinkIconMedium} renders one in
+ * the leading glyph seat, so a familiar destination leads with its own mark
+ * instead of the generic globe. The marks are the `simple-icons` artwork set
+ * (CC0-1.0), pinned by this package's dependency on it; each mark takes the
+ * link's `currentColor` rather than the brand fill that set records.
+ */
+import type { ReactElement } from 'react';
+/** Props for {@link siteGlyph}: the destination plus the shared icon sizing seat. */
+interface SiteGlyphProps {
+    /** The link destination; only an absolute http(s) URL can name a host. */
+    href: string | undefined;
+    /** Square edge in px. */
+    size: number;
+    /** Extra class for layout placement. */
+    className?: string | undefined;
+}
+/**
+ * Render the site mark for a known external destination.
+ * @param props - The destination and the icon sizing seat.
+ * @returns The site's mark riding currentColor, or undefined for an unknown site.
+ */
+export declare function siteGlyph({ href, size, className }: SiteGlyphProps): ReactElement | undefined;
+export {};

package/dist/types/StateDot.d.ts

@@ -0,0 +1,19 @@
+/**
+ * State semantic: green done / amber user-attention / tertiary-grey loading /
+ * red error / neutral-grey idle for a tracked subject with nothing in progress.
+ */
+export type StateDotState = 'done' | 'warning' | 'ongoing' | 'error' | 'idle';
+/**
+ * Render a state dot.
+ * @param props.state - which of `done`, `warning`, `ongoing`, `error`, or `idle` to show.
+ * @param props.size - outer diameter in px; defaults to 14 for ongoing and 10 for solid states.
+ * @param props.className - extra class for layout placement.
+ * @param props.appearance - compact dot by default; step uses a filled check or hollow pending circle.
+ * @returns the dot element (aria-hidden; pair with text for accessibility).
+ */
+export declare function StateDot({ state, size, className, appearance, }: {
+    state: StateDotState;
+    size?: number | undefined;
+    className?: string | undefined;
+    appearance?: 'dot' | 'step';
+}): import("react").JSX.Element;

package/dist/types/Switch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Render a toggle switch.
+ * @param props.checked - the current state; the control is fully controlled.
+ * @param props.onChange - called with the state the click asks for.
+ * @param props.label - localized accessible name, owned by the render site.
+ * @param props.disabled - whether the control refuses input; owners also set it
+ * while a write is in flight, not only when a deployment locks the toggle.
+ * @param props.title - localized hover text, typically why the toggle is locked.
+ * @param props.className - extra class for layout placement.
+ * @returns the switch element.
+ */
+export declare function Switch({ 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/Tag.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+/** Palette selector; each tone names one shipped appearance. */
+export type TagTone = 
+/** Hairline outline on tertiary text: the read-only default. */
+'outline'
+/** Inverted fill: one tag per group that names the current selection. */
+ | 'solid'
+/** Platform-gray fill: a neutral fact with no status meaning. */
+ | 'neutral'
+/** Text only, no fill: a fact stated more quietly than `neutral`. */
+ | 'quiet'
+/** Tinted green: a healthy or enabled state. */
+ | 'success'
+/** Tinted blue: informational classification, not health. */
+ | 'info'
+/** Tinted amber: attention needed, not yet a failure. */
+ | 'warning'
+/** Tinted red: a failure. */
+ | 'danger';
+/**
+ * Render a read-only tag.
+ * @param props.tone - which palette to use (default `outline`).
+ * @param props.className - extra class for layout placement.
+ * @param props.children - the localized label, owned by the render site.
+ * @returns the tag element.
+ */
+export declare function Tag({ tone, className, children, }: {
+    tone?: TagTone;
+    className?: string | undefined;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/TerminalBlock.d.ts

@@ -0,0 +1,85 @@
+/** Output lines shown before the height cap collapses the middle. */
+export declare const DEFAULT_TERMINAL_MAX_LINES = 16;
+/**
+ * Display copy for the terminal surface; the owner passes localized labels
+ * (this package is cordis-free, so copy arrives via props).
+ */
+export interface TerminalBlockLabels {
+    /** Accessible name for an overflowing authored command line, numbered from one. */
+    commandLine: (line: number) => string;
+    /** Status pill text for a signal-terminated command. */
+    signal: (signal: string) => string;
+    /** Status pill text for a non-zero exit code. */
+    exitCode: (exitCode: number) => string;
+    /** Status pill text for a command that ended without an exit code: killed by a signal the view does not know, or never started. */
+    noExitCode: string;
+    /** Run-state text while the command is still running. */
+    running: string;
+    /** Run-state text for a signal or non-zero-exit settle. */
+    failed: string;
+    /** Run-state text for a clean settle. */
+    done: string;
+    /** Copy-button idle label. */
+    copy: string;
+    /** Copy-button label during the post-copy confirmation window. */
+    copied: string;
+    /** Placeholder when a settled command produced no visible output. */
+    noOutput: string;
+    /** Collapse-toggle aria label while expanded. */
+    collapseAria: string;
+    /** Collapse-toggle text while expanded. */
+    collapse: string;
+    /** Expand-toggle aria label while capped, given the hidden line count. */
+    expandAria: (hidden: number) => string;
+    /** Expand-toggle text while capped, given the hidden line count. */
+    expand: (hidden: number) => string;
+}
+export interface TerminalBlockProps {
+    /** The command, rendered verbatim after the prompt label; long lines scroll horizontally unless the host enables wrapping. */
+    command: string;
+    /** Working directory for the prompt label; absent renders a plain `$`. */
+    cwd?: string | undefined;
+    /** Absolute home directory, so a cwd equal to it collapses to `~`; absent disables that collapse. */
+    home?: string | undefined;
+    /** The command's output text; may contain ANSI escape sequences. */
+    output?: string | undefined;
+    /** Settled exit code; a non-zero value renders the status pill, and null (settled without one) the no-exit-code pill. */
+    exitCode?: number | null | undefined;
+    /** Settled terminating signal name; any value renders the status pill, taking precedence over the exit code. */
+    signal?: string | undefined;
+    /**
+     * The command is still running: with no `output` the block shows the prompt
+     * line alone; with output it renders the live text under the running state.
+     */
+    running?: boolean | undefined;
+    /**
+     * The call launches background work (default false). `running` describes the
+     * launch call only; after it returns, retain the command without job status
+     * or output. An explicit `copyText` override remains available.
+     */
+    background?: boolean | undefined;
+    /** Height cap in output lines before the middle collapses (default {@link DEFAULT_TERMINAL_MAX_LINES}); Infinity disables the cap. */
+    maxLines?: number | undefined;
+    /**
+     * Copy-control payload override; the control copies the raw output when
+     * absent. Supplying it also keeps the control rendered before any output
+     * exists — a command is copyable before it prints.
+     */
+    copyText?: string | undefined;
+    /**
+     * Draw the run-state dot and its assistive label in the card gutter
+     * (default true). Hosts whose surrounding row already carries the same
+     * state omit both and reclaim the gutter via `--dsl-terminal-gutter`.
+     */
+    runStateDot?: boolean | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+    /** Localized display copy supplied by the owning render site. */
+    labels: TerminalBlockLabels;
+}
+/**
+ * Render a shell command as a terminal surface.
+ * @param props - see {@link TerminalBlockProps}.
+ * @returns the terminal block element.
+ */
+export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, background, maxLines, copyText, runStateDot, className, labels, }: TerminalBlockProps): import("react").JSX.Element;

package/dist/types/TextShimmer.d.ts

@@ -0,0 +1,22 @@
+/** Text activity animation shared by a row and its nested text fragments. */
+import * as React from 'react';
+import { type ReactNode } from 'react';
+/** Text and activity supplied by the owning row. */
+export interface TextShimmerProps {
+    /** Text or presentational children with text in nested TextShimmer instances. No effects or element ids. */
+    children: ReactNode;
+    /** Whether to animate; nested instances share the containing row's activity. */
+    active?: boolean | undefined;
+    className?: string | undefined;
+    /** Layout class applied equally to the base and decorative content. */
+    contentClassName?: string | undefined;
+}
+/**
+ * Render text with one shared highlight while retaining selectable, accessible content.
+ * Nested instances inherit the outer animation. Keep icons outside; mark decorative
+ * separators with data-shimmer-decoration so their background follows the highlight.
+ * Active children also render in an inert, clipped decoration; supply only presentation.
+ * @param props - localized text, running state, and owner styling.
+ * @returns retained text and its optional decorative highlight.
+ */
+export declare const TextShimmer: React.MemoExoticComponent<({ children, active, className, contentClassName, }: TextShimmerProps) => React.JSX.Element>;

package/dist/types/Toast.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+/**
+ * Transient top-center banner: slides in, holds at full opacity, fades out,
+ * then reports done so the owner can unmount it. Re-showing the same text
+ * restarts the cycle when the owner remounts the component (key it by a
+ * per-show sequence). Rendered through a body portal so an owner inside a
+ * transformed or filtered ancestor cannot trap the fixed banner in that
+ * ancestor's box.
+ * With unchanged holdMs, parent rerenders do not extend the lifetime.
+ * Completion calls the latest onDone handler; fully faded actions receive no input.
+ *
+ * The hold is the owner's to set, because how long a banner has to stay
+ * depends on how much there is to read: a one-line limit lands in the default
+ * window, while a failure that names what broke does not. One value drives
+ * both the unmount timer and the stylesheet's fade delay — the stylesheet
+ * reads it as a custom property — so the two can no longer disagree and leave
+ * the banner unmounting mid-fade.
+ * @param props.text - resolved banner copy; the owner passes localized text.
+ * @param props.icon - optional leading glyph (e.g. a warning icon); ignored
+ * under `tone="success"`, which brings its own glyph.
+ * @param props.tone - 'success' renders the design's circled green check as
+ * the leading glyph; omitted, the icon seat keeps its warning tint.
+ * @param props.actions - optional inline actions continuing the sentence:
+ * each renders its plain-text `prefix` (a connective like 或) followed by its
+ * localized `label` as blue clickable text, flowing after `text` as one
+ * sentence. Each press is the owner's to handle (e.g. undo the reported
+ * change, then unmount the toast). The banner surface stays click-through —
+ * only the action text takes the pointer.
+ * @param props.holdMs - full-opacity hold before the fade; defaults to 3000.
+ * @param props.anchor - optional element whose horizontal center the banner
+ * follows (e.g. the composer card, so the banner centers over the chat column
+ * rather than the whole window); omitted, it centers on the viewport.
+ * @param props.onDone - called once the fade completes; unmount the toast here.
+ * @returns the floating banner.
+ */
+export declare function Toast({ text, icon, tone, anchor, holdMs, actions, onDone, }: {
+    text: string;
+    icon?: ReactNode;
+    tone?: 'success';
+    anchor?: HTMLElement | null;
+    holdMs?: number;
+    actions?: readonly {
+        label: string;
+        prefix?: string;
+        onClick: () => void;
+    }[];
+    onDone: () => void;
+}): import("react").ReactPortal;

package/dist/types/Tooltip.d.ts

@@ -0,0 +1,69 @@
+/** Anchor-preserving tooltips; an optional body portal escapes clipping containers and stacking contexts that cap the bubble's z-index. */
+import * as React from 'react';
+import type { Context, FocusEventHandler, MouseEventHandler, PointerEventHandler, ReactElement, Ref } from 'react';
+import { type TooltipSide } from './tooltip-placement.js';
+export type { TooltipSide } from './tooltip-placement.js';
+/**
+ * Suppression channel for nested tooltips: a visible descendant tooltip
+ * withdraws the enclosing tooltip while its bubble is shown.
+ */
+export declare const TooltipSuppression: Context<((suppressed: boolean) => void) | null>;
+/** Props Tooltip injects into its anchor child; the child's own handlers are chained ahead of the tooltip's. */
+interface AnchorProps {
+    'aria-describedby'?: string | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+    onPointerEnter?: PointerEventHandler | undefined;
+    onPointerLeave?: PointerEventHandler | undefined;
+    onPointerDown?: PointerEventHandler | undefined;
+    onClick?: MouseEventHandler | undefined;
+    onFocus?: FocusEventHandler | undefined;
+    onBlur?: FocusEventHandler | undefined;
+}
+type TooltipLabel = string | (() => string);
+/**
+ * Attach a hover/focus tooltip to an anchor element.
+ * @param props.label - bubble text, or a resolver evaluated only while visible; an empty string shows only shortcut keys.
+ * @param props.shortcutKeys - effective key labels rendered as platform-formatted keycaps after optional text.
+ * @param props.side - preferred placement (default 'right'); fitting tries the opposite then perpendicular sides.
+ * @param props.align - horizontal anchor-edge alignment for 'bottom'/'top' bubbles: 'end' pins
+ * the bubble's right edge to the anchor's (for anchors beside other hover surfaces the centered
+ * bubble would overlap); default 'center'. Horizontal placements ignore it.
+ * @param props.portal - render the bubble under document.body, so an ancestor's clipping or its
+ * stacking context (which confines the bubble's z-index to that context) cannot hide it.
+ * @param props.delayMs - hover delay in milliseconds (default 0).
+ * @param props.focusDelayMs - keyboard focus delay in milliseconds (default 0); blur, click,
+ * mouse leave, disabling, and unmount cancel a pending show.
+ * @param props.gap - anchor-to-bubble distance in pixels for 'bottom'/'top' bubbles (default 8);
+ * horizontal placements use 10px, including after a flip.
+ * @param props.disabled - suppress the bubble while true; the anchor renders identically so
+ * toggling never remounts it (which would cut its CSS transitions).
+ * @param props.maxWidth - bubble width cap in pixels, for labels long enough that the default
+ * half-viewport cap would render a slab wider than the surface the anchor sits on; always bounded by viewport margins.
+ * @param props.openOnClick - clicking or tapping also pins the bubble for reading; another click, Escape,
+ * Tab, or an outside pointerdown dismisses it. Defaults to false for ordinary action tooltips.
+ * @param props.onlyWhenClipped - show the bubble only when the anchor or an HTML element inside it
+ * overflows horizontally, measured when the bubble is about to show; for labels that repeat
+ * text an ellipsis may cut off. Defaults to false.
+ * @param props.children - a single anchor element; its own ref (callback or object) is forwarded alongside the tooltip's.
+ * @returns the cloned anchor plus a fixed-position bubble, optionally portaled to the body.
+ * The bubble stays hidden until ResizeObserver supplies its size for viewport fitting; clicking the
+ * anchor dismisses the bubble unless openOnClick is enabled, and focus arriving after a pointer
+ * interaction (a closing menu refocusing its trigger) never raises it. Touch cannot trigger hover
+ * tooltips; tapping still invokes the child's action and can open an openOnClick explanation.
+ * When no side fits, the viewport-bounded fallback may overlap the anchor; oversized content is scrollable when pinned.
+ */
+export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, focusDelayMs, gap, disabled, portal, maxWidth, openOnClick, onlyWhenClipped, children, }: {
+    label: TooltipLabel;
+    shortcutKeys?: readonly string[] | undefined;
+    side?: TooltipSide;
+    align?: 'center' | 'end';
+    delayMs?: number;
+    focusDelayMs?: number;
+    gap?: number;
+    disabled?: boolean;
+    portal?: boolean;
+    maxWidth?: number;
+    openOnClick?: boolean;
+    onlyWhenClipped?: boolean;
+    children: ReactElement<AnchorProps>;
+}): React.JSX.Element;

package/dist/types/UserMessageBubble.d.ts

@@ -0,0 +1,10 @@
+/** Shared user-message background, typography, and content inset. */
+import type { ComponentPropsWithoutRef } from 'react';
+/** Native div attributes for user-authored message content. */
+export type UserMessageBubbleProps = ComponentPropsWithoutRef<'div'>;
+/**
+ * Render user-style message content without row placement or actions.
+ * @param props - Native div attributes and the caller-owned content.
+ * @returns A theme-aware message surface that wraps its content.
+ */
+export declare function UserMessageBubble({ className, ...props }: UserMessageBubbleProps): import("react").JSX.Element;

package/dist/types/WebBlock.d.ts

@@ -0,0 +1,60 @@
+import { type MarkdownLabels } from './markdown/MarkdownText.js';
+/**
+ * One citeable source drawn in a search card: the projection of the contract's
+ * `WebSource`, with the optional fields kept optional so a provider that
+ * returned only a URL still renders (its hostname becomes the label).
+ */
+export interface WebSourceView {
+    /** The source URL; becomes a safe external link when it is http(s). */
+    url: string;
+    /** The source title; when absent the URL's hostname labels the link. */
+    title?: string | undefined;
+    /** A short excerpt or summary shown under the link. */
+    snippet?: string | undefined;
+    /** Publication/crawl timestamp, a provider-supplied string shown under the link. */
+    publishedAt?: string | undefined;
+}
+/** A `web_search` card: an optional answer over a capped citation list. */
+export interface WebSearchBlockProps {
+    kind: 'search';
+    /** Localized chrome supplied by the owning render site. */
+    labels: WebBlockLabels;
+    /** The provider-generated answer, rendered as markdown above the sources. */
+    answer?: string | undefined;
+    /** The cited sources, in provider order. */
+    sources: WebSourceView[];
+    /** True when the tool cut the source list to its result cap. */
+    truncated: boolean;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+}
+/** A `web_fetch` card: the retrieval summary for one fetched URL. */
+export interface WebFetchBlockProps {
+    kind: 'fetch';
+    /** Localized chrome supplied by the owning render site. */
+    labels: WebBlockLabels;
+    /** The final URL after allowed redirects; becomes a safe external link when http(s). */
+    url: string;
+    /** HTTP status code of the fetched response. */
+    statusCode: number;
+    /** True when the provider or the output cap cut the fetched content. */
+    truncated: boolean;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+}
+/** A completed web retrieval card, discriminated by `kind`. */
+export type WebBlockProps = WebSearchBlockProps | WebFetchBlockProps;
+/** Localized chrome for {@link WebBlock}. */
+export interface WebBlockLabels {
+    noResults: string;
+    sourcesTruncated: string;
+    http: string;
+    contentTruncated: string;
+    markdown: MarkdownLabels;
+}
+/**
+ * Render a completed web retrieval as a structured card.
+ * @param props - see {@link WebBlockProps}; `kind` selects the search or fetch body.
+ * @returns the web card element.
+ */
+export declare function WebBlock(props: WebBlockProps): import("react").JSX.Element;

package/dist/types/ZoomControls.d.ts

@@ -0,0 +1,26 @@
+import { type DocumentZoomLabels } from './document-zoom.js';
+/** Live percentage display updated independently from the document tree. */
+export interface ZoomControlsHandle {
+    /** @param zoom - current gesture scale multiplier. */
+    showZoom: (zoom: number) => void;
+}
+/**
+ * Present optional fitting, fixed presets, and incremental controls.
+ * @param props - committed `zoom`, optional `fit` row (omitted: no fitting row), localized labels, `visible`, optional
+ *   owner `className`, and zoom and activity callbacks.
+ * @param ref - `showZoom` displays a transient scale until `zoom` changes.
+ * @returns a localized zoom toolbar.
+ */
+export declare const ZoomControls: import("react").ForwardRefExoticComponent<{
+    readonly zoom: number;
+    readonly fit?: {
+        readonly label: string;
+        readonly selected: boolean;
+        readonly onSelect: () => void;
+    } | undefined;
+    readonly className?: string | undefined;
+    readonly labels: DocumentZoomLabels;
+    readonly visible: boolean;
+    readonly onZoom: (zoom: number) => void;
+    readonly onActiveChange: (active: boolean) => void;
+} & import("react").RefAttributes<ZoomControlsHandle>>;

package/dist/types/ansi.d.ts

@@ -0,0 +1,16 @@
+import type { CSSProperties } from 'react';
+/** One run of terminal text; `style` is undefined for text that carries no SGR state. */
+export interface AnsiSpan {
+    /** The run's plain text, free of escape sequences and newlines. */
+    text: string;
+    /** Resolved inline style, or undefined when the run needs no wrapper. */
+    style: CSSProperties | undefined;
+}
+/** The spans of one output line, in order. */
+export type AnsiLine = readonly AnsiSpan[];
+/**
+ * Parse command output into styled spans grouped by line.
+ * @param text - raw output text, which may contain ANSI escape sequences.
+ * @returns one entry per output line (always at least one, possibly empty).
+ */
+export declare function parseAnsiLines(text: string): AnsiLine[];

package/dist/types/blocks.d.ts

@@ -0,0 +1,21 @@
+export { JsonTree } from './JsonTree.js';
+export type { JsonTreeProps, JsonTreeLabels } from './JsonTree.js';
+export { TerminalBlock, DEFAULT_TERMINAL_MAX_LINES } from './TerminalBlock.js';
+export type { TerminalBlockProps, TerminalBlockLabels } from './TerminalBlock.js';
+export { CommandText } from './CommandText.js';
+export type { CommandTextProps } from './CommandText.js';
+export { ReadBlock, DEFAULT_READ_MAX_LINES } from './ReadBlock.js';
+export type { ReadBlockProps, ReadBlockLine, ReadBlockLabels } from './ReadBlock.js';
+export { DiffBlock, DEFAULT_DIFF_MAX_LINES, diffTotals } from './DiffBlock.js';
+export type { DiffBlockProps, DiffHunk, DiffBlockLabels } from './DiffBlock.js';
+export { SearchBlock, DEFAULT_SEARCH_MAX_LINES } from './SearchBlock.js';
+export type { SearchBlockProps, SearchMatchesBlockProps, SearchPathsBlockProps, SearchFileGroup, SearchBlockLineMatch, SearchBlockLabels, } from './SearchBlock.js';
+export { WebBlock } from './WebBlock.js';
+export type { WebBlockProps, WebSearchBlockProps, WebFetchBlockProps, WebSourceView, WebBlockLabels, } from './WebBlock.js';
+export { LinkIconMedium, LinkIconRegular, classifyLinkPath } from './LinkIcon.js';
+export type { LinkIconKind, LinkIconProps } from './LinkIcon.js';
+export { FileTypeIcon, classifyFileType, fileExtension } from './FileTypeIcon.js';
+export type { CodeFileType, FileType, FileTypeIconProps, FileTypeKind, FileTypeProjectContext, } from './FileTypeIcon.js';
+export type { CodeToolbarLabels } from './CodeToolbar.js';
+export { CODE_HIGHLIGHT_EXTENSIONS, languageForPath, useCodeHighlighter } from './code-highlighting.js';
+export type { CodeHighlighter, HighlightSpan } from './code-highlighting.js';

package/dist/types/clipboard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Write text to the host clipboard, preferring the async Clipboard API and
+ * falling back to `execCommand('copy')` on hosts (jsdom, insecure contexts)
+ * that omit it.
+ * @param text - the exact text to place on the clipboard.
+ * @returns true only when the host accepted the write.
+ */
+export declare function writeClipboard(text: string): Promise<boolean>;