@aria-cli/cli 1.0.14

package/dist/ui/App.d.ts

@@ -0,0 +1,288 @@
+import React from "react";
+import { type Command, type ArionOption, type ModelOption, type ThemeSelection, type BrowsableMemory, type MemoryBrowserMode, type StatusBarMetrics, type PairRequestInfo } from "./components/index.js";
+import { type ProviderOption } from "./components/ProviderPicker.js";
+import { type CopilotSourcePickerOption } from "./components/CopilotSourcePicker.js";
+import { type ProviderMethodOption } from "./components/ProviderMethodPicker.js";
+import type { AnthropicMethodOption, OpenAIMethodOption, GoogleMethodOption } from "../commands/login-handler.js";
+import type { TraceWaterfallSpan } from "./components/TraceWaterfall.js";
+import type { ArionSession } from "../session.js";
+import type { ConversationMessage } from "../history/conversation-message.js";
+import type { SessionSummary } from "../history/index.js";
+import type { DisplayMode, DisplayConfig } from "./display-mode.js";
+import { type ObservabilityContext } from "@aria-cli/aria";
+import type { EffortLevel } from "@aria-cli/types";
+import type { SelectableClient } from "../selectable-client.js";
+import type { SelectablePeer } from "../selectable-peer.js";
+export type ArionSelectorMode = "become" | "mention" | "rest" | "wake";
+export interface AppProps {
+    session: ArionSession;
+    model: string;
+    /** Max context window tokens for the current model */
+    maxContextTokens?: number;
+    banner?: React.ReactNode;
+    messages?: ConversationMessage[];
+    /** Preview messages from TurnAccumulator.snapshot() — rendered in live zone only */
+    previewMessages?: ConversationMessage[];
+    isStreaming?: boolean;
+    queuedMessage?: string | null;
+    /** Called when user cancels a queued message (Escape during streaming with queued text).
+     * Returns the cancelled text so it can be put back in the input for editing. */
+    onCancelQueuedMessage?: () => void;
+    responseTime?: number;
+    commands?: Command[];
+    arions?: ArionOption[];
+    models?: ModelOption[];
+    memories?: BrowsableMemory[];
+    memoryBrowserMode?: MemoryBrowserMode;
+    isLoadingMemories?: boolean;
+    userName?: string | null;
+    /** Total memory count shown in REPL status contexts */
+    memoryCount?: number;
+    /** Live observability metrics for the StatusBar */
+    metrics?: StatusBarMetrics;
+    /** Current display mode */
+    displayMode?: DisplayMode;
+    /** Resolved display config for the current mode */
+    displayConfig?: DisplayConfig;
+    /** Whether thinking blocks are visible */
+    showThinking?: boolean;
+    /** Whether cost metrics are visible in the StatusBar */
+    showCosts?: boolean;
+    /** Whether trace waterfall is visible */
+    showTraces?: boolean;
+    /** Completed trace spans for waterfall visualization */
+    spans?: TraceWaterfallSpan[];
+    /** Pipeline timing report for TTFT breakdown display */
+    pipelineTiming?: {
+        phases: Array<{
+            phase: string;
+            durationMs: number;
+            pct: number;
+        }>;
+        totalMs: number;
+    };
+    /** Name of the active/responding arion for the current run */
+    activeArion?: string;
+    onSubmit: (input: string) => void;
+    onCommand: (command: string, args?: string) => void;
+    onSelectArion?: (name: string, mode: ArionSelectorMode) => void;
+    onSelectModel?: (name: string, effort: EffortLevel) => void;
+    onSelectTheme?: (theme: ThemeSelection) => void;
+    onSelectMemory?: (memory: BrowsableMemory) => void;
+    onOpenMemoryBrowser?: (mode: MemoryBrowserMode) => void;
+    /** Callback to toggle thinking block visibility */
+    onToggleThinking?: () => void;
+    /** Callback to toggle cost display in StatusBar */
+    onToggleCosts?: () => void;
+    /** Callback to toggle trace waterfall visibility */
+    onToggleTraces?: () => void;
+    /** Callback to cycle display mode (minimal -> standard -> debug) */
+    onCycleDisplayMode?: () => void;
+    sessions?: SessionSummary[];
+    onSelectSession?: (sessionId: string) => void;
+    onLoadSessions?: () => void;
+    onSearchSessions?: (query: string) => void;
+    onLoadMoreSessions?: (direction: "next" | "prev") => void;
+    /** Legacy prop kept for compatibility after Static-based transcript rendering removal */
+    staticRenderEpoch?: number;
+    /** Incrementing signal to request opening session overlay (e.g. /resume) */
+    openSessionOverlaySignal?: number;
+    /** Incrementing signal to request opening theme overlay (e.g. /theme) */
+    openThemeOverlaySignal?: number;
+    inputHistory?: string[];
+    onSaveInput?: (input: string) => void;
+    /** Live ObservabilityContext for the current run — drives the indicator state machine */
+    obsCtx?: ObservabilityContext | null;
+    onCancel?: () => void;
+    /** Pending tool approval request — shown as a dialog */
+    approvalRequest?: {
+        id: number;
+        toolName: string;
+        input: unknown;
+        riskLevel: "low" | "moderate" | "high";
+        issues?: string[];
+    } | null;
+    /** Callback when user approves/denies tool execution */
+    onApprovalChoice?: (approved: boolean) => void;
+    /** Current effort level for the model selector */
+    effortLevel?: EffortLevel;
+    /** Whether the autonomy selector panel is open */
+    showAutonomySelector?: boolean;
+    /** Current autonomy level */
+    autonomyLevel?: "minimal" | "balanced" | "high" | "full";
+    /** Number of unread mesh messages (0 = hidden) */
+    meshMessageCount?: number;
+    /** Path to daemon's runtime socket for real-time message subscription */
+    runtimeSocket?: string | null;
+    /** Attached client ID for subscribeDirectClientInbox */
+    clientId?: string | null;
+    /** Attached client auth token for subscribeDirectClientInbox */
+    clientAuthToken?: string | null;
+    /** Resolve fresh credentials when existing ones are stale (daemon restarted) */
+    resolveCredentials?: () => Promise<{
+        clientId: string;
+        clientAuthToken: string;
+    } | null>;
+    /** Callback when user selects a new autonomy level */
+    onAutonomySelect?: (level: "minimal" | "balanced" | "high" | "full") => void;
+    /** Callback when user cancels the autonomy selector */
+    onAutonomyCancel?: () => void;
+    /** Callback to cycle autonomy level (Shift+Tab) */
+    onCycleAutonomy?: () => void;
+    /** Callback to cycle effort level (Ctrl+E) */
+    onCycleEffort?: () => void;
+    /** Provider list for the login picker (null = hidden) */
+    loginPickerProviders?: ProviderOption[] | null;
+    /** Callback when user selects a provider in the login picker */
+    onLoginProviderSelect?: (provider: ProviderOption) => void;
+    /** Callback when user cancels the login picker */
+    onLoginPickerCancel?: () => void;
+    /** Copilot source picker options (null = hidden) */
+    copilotSourceOptions?: CopilotSourcePickerOption[] | null;
+    /** Callback when user selects a Copilot source option */
+    onCopilotSourceSelect?: (option: CopilotSourcePickerOption) => void;
+    /** Callback when user cancels Copilot source picker */
+    onCopilotSourceCancel?: () => void;
+    /** Provider ID for the active OAuth login flow (null = hidden) */
+    oauthProvider?: string | null;
+    /** Prebuilt authorize URL for kernel-driven OAuth login */
+    oauthAuthorizeUrl?: string | null;
+    /** Expected callback state for localhost OAuth callback flows */
+    oauthExpectedState?: string | null;
+    /** Callback when OAuth login flow completes (success or failure) */
+    onOAuthComplete?: (result: {
+        success: boolean;
+        message: string;
+    }) => void;
+    /** Callback when kernel-driven OAuth login captures an authorization code */
+    onOAuthCodeSubmit?: (code: string) => Promise<void> | void;
+    /** Callback when user cancels the OAuth login flow */
+    onOAuthCancel?: () => void;
+    /** Provider ID for active GitHub Copilot device flow (null = hidden) */
+    copilotDeviceProvider?: string | null;
+    /** Optional Copilot auth profile label (e.g. personal, work, team-x) */
+    copilotDeviceProfileLabel?: string | null;
+    /** Verification URL for a kernel-driven GitHub Copilot device flow */
+    copilotDeviceVerificationUri?: string | null;
+    /** User code for a kernel-driven GitHub Copilot device flow */
+    copilotDeviceUserCode?: string | null;
+    /** Callback when GitHub Copilot device flow completes */
+    onCopilotDeviceComplete?: (result: {
+        success: boolean;
+        message: string;
+    }) => void;
+    /** Callback when the user confirms a kernel-driven GitHub Copilot device flow */
+    onCopilotDeviceApprove?: () => Promise<void> | void;
+    /** Callback when user cancels GitHub Copilot device flow */
+    onCopilotDeviceCancel?: () => void;
+    /** Anthropic method picker options (null = hidden) */
+    anthropicMethodOptions?: AnthropicMethodOption[] | null;
+    /** Callback when user selects an Anthropic method */
+    onAnthropicMethodSelect?: (option: AnthropicMethodOption) => void;
+    /** Callback when user cancels Anthropic method picker */
+    onAnthropicMethodCancel?: () => void;
+    /** Show API key text input overlay */
+    anthropicKeyInputVisible?: boolean;
+    /** Callback when user submits an API key */
+    onAnthropicKeySubmit?: (apiKey: string) => void;
+    /** Callback when user cancels API key input */
+    onAnthropicKeyCancel?: () => void;
+    /** Show setup-token text input overlay */
+    anthropicSetupTokenVisible?: boolean;
+    /** Callback when user submits a setup token */
+    onAnthropicSetupTokenSubmit?: (token: string) => void;
+    /** Callback when user cancels setup token input */
+    onAnthropicSetupTokenCancel?: () => void;
+    /** OpenAI method picker options (null = hidden) */
+    openaiMethodOptions?: OpenAIMethodOption[] | null;
+    /** Callback when user selects an OpenAI method */
+    onOpenAIMethodSelect?: (option: OpenAIMethodOption) => void;
+    /** Callback when user cancels OpenAI method picker */
+    onOpenAIMethodCancel?: () => void;
+    /** Show OpenAI API key text input overlay */
+    openaiKeyInputVisible?: boolean;
+    /** Callback when user submits an OpenAI API key */
+    onOpenAIKeySubmit?: (apiKey: string) => void;
+    /** Callback when user cancels OpenAI key input */
+    onOpenAIKeyCancel?: () => void;
+    /** Google method picker options (null = hidden) */
+    googleMethodOptions?: GoogleMethodOption[] | null;
+    /** Callback when user selects a Google method */
+    onGoogleMethodSelect?: (option: GoogleMethodOption) => void;
+    /** Callback when user cancels Google method picker */
+    onGoogleMethodCancel?: () => void;
+    /** Show Google API key text input overlay */
+    googleKeyInputVisible?: boolean;
+    /** Callback when user submits a Google API key */
+    onGoogleKeySubmit?: (apiKey: string) => void;
+    /** Callback when user cancels Google key input */
+    onGoogleKeyCancel?: () => void;
+    /** Generic auth selection overlay options (null = hidden) */
+    authInteractionOptions?: ProviderMethodOption[] | null;
+    /** Generic auth selection overlay title */
+    authInteractionTitle?: string | null;
+    /** Callback when user selects a generic auth option */
+    onAuthInteractionSelect?: (optionId: string) => void;
+    /** Callback when user cancels the generic auth selection */
+    onAuthInteractionCancel?: () => void;
+    /** Generic auth text input overlay (null = hidden) */
+    authInteractionInput?: {
+        title: string;
+        hint?: string;
+    } | null;
+    /** Callback when user submits the generic auth input */
+    onAuthInteractionInputSubmit?: (value: string) => void;
+    /** Callback when user cancels the generic auth input */
+    onAuthInteractionInputCancel?: () => void;
+    /** Nearby peers discovered via mDNS */
+    nearbyPeers?: SelectablePeer[];
+    /** Same-home attached clients discovered from the runtime */
+    localClients?: SelectableClient[];
+    /** Callback when user selects a peer to connect to */
+    onSelectPeer?: (peer: SelectablePeer) => void;
+    /** Callback when user selects a same-home client */
+    onSelectClient?: (client: SelectableClient) => void;
+    /** Callback when user cancels peer selection */
+    onPeerCancel?: () => void;
+    /** Callback when user cancels client selection */
+    onClientsCancel?: () => void;
+    /** Incrementing signal to request opening peers overlay */
+    openPeersOverlaySignal?: number;
+    /** Incrementing signal to request opening clients overlay */
+    openClientsOverlaySignal?: number;
+    /** Invite share payload opens the invite share overlay when present */
+    inviteShare?: {
+        inviteToken: string;
+        inviteLabel?: string;
+        expiresAt?: string | null;
+    } | null;
+    /** Callback when user closes the invite share overlay */
+    onInviteShareClose?: () => void;
+    /** Incrementing signal to request opening the join invite overlay */
+    openJoinInviteOverlaySignal?: number;
+    /** Callback when user submits an invite token to join */
+    onJoinInviteSubmit?: (inviteToken: string) => void;
+    /** Callback when user cancels the join invite overlay */
+    onJoinInviteCancel?: () => void;
+    /** Optional join overlay error message */
+    joinInviteError?: string | null;
+    /** Incoming pair request from another peer */
+    incomingPairRequest?: PairRequestInfo | null;
+    /** Callback when user accepts a pair request */
+    onAcceptPairRequest?: () => void;
+    /** Callback when user rejects a pair request */
+    onRejectPairRequest?: () => void;
+    /** Callback to cancel an in-flight pairing long-poll (Escape during wait) */
+    onCancelPairing?: () => void;
+    /** Signal to open the message-edit overlay (increment to trigger) */
+    openMessageEditOverlaySignal?: number;
+    /** All messages from the current session for the message-edit overlay */
+    editableMessages?: import("./components/overlays/MessageSelector.js").MessageSelectorEntry[];
+    /** Called when user selects a message to edit (messageIndex, messageText) */
+    onEditMessage?: (messageIndex: number, messageText: string) => void;
+    /** Prefill text to load into the input box (e.g., after edit-message selection) */
+    prefillInput?: string;
+    /** Called after the prefill has been consumed */
+    onPrefillConsumed?: () => void;
+}
+export declare function App({ session, model, maxContextTokens, banner, messages, previewMessages, isStreaming, queuedMessage, onCancelQueuedMessage, responseTime, commands, arions, models, memories, memoryBrowserMode, isLoadingMemories, userName, metrics, displayMode, displayConfig, showThinking, showCosts, showTraces, spans, pipelineTiming, activeArion, onSubmit, onCommand, onSelectArion, onSelectModel, onSelectTheme, onSelectMemory, onOpenMemoryBrowser, onToggleThinking, onToggleCosts, onToggleTraces, onCycleDisplayMode, sessions, onSelectSession, onLoadSessions, onSearchSessions, onLoadMoreSessions, staticRenderEpoch, openSessionOverlaySignal, openThemeOverlaySignal, inputHistory, onSaveInput, obsCtx, onCancel, approvalRequest, onApprovalChoice, effortLevel, showAutonomySelector, autonomyLevel, onAutonomySelect, onAutonomyCancel, onCycleAutonomy, onCycleEffort, loginPickerProviders, onLoginProviderSelect, onLoginPickerCancel, copilotSourceOptions, onCopilotSourceSelect, onCopilotSourceCancel, oauthProvider, oauthAuthorizeUrl, oauthExpectedState, onOAuthComplete, onOAuthCodeSubmit, onOAuthCancel, copilotDeviceProvider, copilotDeviceProfileLabel, copilotDeviceVerificationUri, copilotDeviceUserCode, onCopilotDeviceComplete, onCopilotDeviceApprove, onCopilotDeviceCancel, anthropicMethodOptions, onAnthropicMethodSelect, onAnthropicMethodCancel, anthropicKeyInputVisible, onAnthropicKeySubmit, onAnthropicKeyCancel, anthropicSetupTokenVisible, onAnthropicSetupTokenSubmit, onAnthropicSetupTokenCancel, openaiMethodOptions, onOpenAIMethodSelect, onOpenAIMethodCancel, openaiKeyInputVisible, onOpenAIKeySubmit, onOpenAIKeyCancel, googleMethodOptions, onGoogleMethodSelect, onGoogleMethodCancel, googleKeyInputVisible, onGoogleKeySubmit, onGoogleKeyCancel, authInteractionOptions, authInteractionTitle, onAuthInteractionSelect, onAuthInteractionCancel, authInteractionInput, onAuthInteractionInputSubmit, onAuthInteractionInputCancel, nearbyPeers, localClients, onSelectPeer, onSelectClient, onPeerCancel, onClientsCancel, openPeersOverlaySignal, openClientsOverlaySignal, inviteShare, onInviteShareClose, openJoinInviteOverlaySignal, onJoinInviteSubmit, onJoinInviteCancel, joinInviteError, incomingPairRequest, onAcceptPairRequest, onRejectPairRequest, onCancelPairing, openMessageEditOverlaySignal, editableMessages, onEditMessage, prefillInput, onPrefillConsumed, meshMessageCount, runtimeSocket, clientId, clientAuthToken, resolveCredentials, }: AppProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/AnthropicMethodPicker.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { AnthropicMethodOption } from "../../commands/login-handler.js";
+export interface AnthropicMethodPickerProps {
+    options: AnthropicMethodOption[];
+    onSelect: (option: AnthropicMethodOption) => void;
+    onCancel: () => void;
+    isActive?: boolean;
+}
+export declare function AnthropicMethodPicker({ options, onSelect, onCancel, isActive, }: AnthropicMethodPickerProps): React.ReactElement;

package/dist/ui/components/ArionPrompt.d.ts

@@ -0,0 +1,8 @@
+export interface ArionPromptProps {
+    userName?: string | null;
+}
+/**
+ * User prompt component - shows userName in cyan like the REPL's formatPrompt
+ * Design: "userName ❯ " or just "❯ " if no user name
+ */
+export declare function ArionPrompt({ userName }: ArionPromptProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/AutocompleteDropdown.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Suggestion } from '../hooks/useCommandAutocomplete.js';
+interface AutocompleteDropdownProps {
+    suggestions: Suggestion[];
+    selectedIndex: number;
+    width?: number;
+}
+export declare function AutocompleteDropdown({ suggestions, selectedIndex, width, }: AutocompleteDropdownProps): React.ReactElement | null;
+export {};

package/dist/ui/components/AutonomySelector.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { AUTONOMY_LEVELS } from "@aria-cli/aria";
+type AutonomyLevel = (typeof AUTONOMY_LEVELS)[number];
+export interface AutonomySelectorProps {
+    currentLevel: AutonomyLevel;
+    onSelect: (level: AutonomyLevel) => void;
+    onCancel: () => void;
+    /** When false, the selector stops capturing keystrokes. Defaults to true. */
+    isActive?: boolean;
+}
+export declare function AutonomySelector({ currentLevel, onSelect, onCancel, isActive, }: AutonomySelectorProps): React.ReactElement;
+export {};

package/dist/ui/components/Banner.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface BannerProps {
+    onComplete: () => void;
+    skipAnimation?: boolean;
+    version?: string;
+    whatsNew?: string[];
+}
+export declare function Banner({ onComplete, skipAnimation, version, whatsNew, }: BannerProps): React.ReactElement;
+export {};

package/dist/ui/components/ConversationHistory.d.ts

@@ -0,0 +1,59 @@
+import React from "react";
+import type { MessageArion } from "./Message.js";
+import type { ToolExecutionInfo } from "./tool-types.js";
+import type { DisplayConfig } from "../display-mode.js";
+/**
+ * HistoryMessage — discriminated union for all items in static conversation history.
+ *
+ * Text-based variants (user/assistant/system/tool) share a common shape with
+ * required `content`. Rich variants (tool_history/thinking_history/handoff_history)
+ * carry structured data for component rendering in Static scrollback.
+ */
+type BaseMsg = {
+    id: string;
+};
+type TextMessage = BaseMsg & {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    arion?: MessageArion;
+    userName?: string;
+    toolStatus?: "complete" | "error";
+};
+type ToolHistoryMessage = BaseMsg & {
+    role: "tool_history";
+    tool: ToolExecutionInfo;
+};
+type ThinkingHistoryMessage = BaseMsg & {
+    role: "thinking_history";
+    content: string;
+    wordCount: number;
+    durationSeconds?: number;
+    verb?: string;
+    arionName?: string;
+    arionEmoji?: string;
+    arionColor?: string;
+};
+type ErrorHistoryMessage = BaseMsg & {
+    role: "error";
+    content: string;
+    suggestion?: string;
+    level?: "inline" | "boxed";
+};
+type HandoffHistoryMessage = BaseMsg & {
+    role: "handoff_history";
+    target: string;
+    direction: "to" | "from";
+};
+export type HistoryMessage = TextMessage | ToolHistoryMessage | ThinkingHistoryMessage | HandoffHistoryMessage | ErrorHistoryMessage;
+export { type ToolExecutionInfo };
+export interface ConversationHistoryProps {
+    messages: HistoryMessage[];
+    header?: React.ReactNode;
+    displayConfig?: DisplayConfig;
+}
+/**
+ * Static conversation history using the new rendering pipeline.
+ * Converts HistoryMessage[] → RenderItem[] → RenderItemView.
+ * No normalize/reorder — tool use + result already combined.
+ */
+export declare function ConversationHistory({ messages, header, displayConfig }: ConversationHistoryProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/components/CopilotDeviceLoginFlow.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export interface CopilotDeviceLoginFlowProps {
+    provider: string;
+    profileLabel?: string;
+    onCancel: () => void;
+    isActive?: boolean;
+    onComplete?: (result: {
+        success: boolean;
+        message: string;
+    }) => void;
+    verificationUri?: string;
+    userCode?: string;
+    onApprove?: () => Promise<void> | void;
+}
+export declare function CopilotDeviceLoginFlow({ provider, profileLabel, onCancel, isActive, onComplete, verificationUri, userCode, onApprove, }: CopilotDeviceLoginFlowProps): React.ReactElement;

package/dist/ui/components/CopilotSourcePicker.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface CopilotSourcePickerOption {
+    id: string;
+    label: string;
+    status: "connected" | "none";
+}
+export interface CopilotSourcePickerProps {
+    options: CopilotSourcePickerOption[];
+    onSelect: (option: CopilotSourcePickerOption) => void;
+    onCancel: () => void;
+    isActive?: boolean;
+}
+export declare function CopilotSourcePicker({ options, onSelect, onCancel, isActive, }: CopilotSourcePickerProps): React.ReactElement;

package/dist/ui/components/Cost.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+type Props = {
+    costUSD: number;
+    durationMs: number;
+    debug: boolean;
+};
+export declare function Cost({ costUSD, durationMs, debug }: Props): React.ReactNode;
+export {};

package/dist/ui/components/CustomSelect/option-map.d.ts

@@ -0,0 +1,15 @@
+import { type OptionHeader } from "./select.js";
+export type Option = {
+    readonly label: string;
+    readonly value: string;
+};
+type OptionMapItem = (Option | OptionHeader) & {
+    previous: OptionMapItem | undefined;
+    next: OptionMapItem | undefined;
+    index: number;
+};
+export default class OptionMap extends Map<string, OptionMapItem> {
+    readonly first: OptionMapItem | undefined;
+    constructor(options: (Option | OptionHeader)[]);
+}
+export {};

package/dist/ui/components/CustomSelect/select-option.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+export type SelectOptionProps = {
+    /**
+     * Determines if option is focused.
+     */
+    readonly isFocused: boolean;
+    /**
+     * Determines if option is selected.
+     */
+    readonly isSelected: boolean;
+    /**
+     * Determines if pointer is shown when selected
+     */
+    readonly smallPointer?: boolean;
+    /**
+     * Option label.
+     */
+    readonly children: ReactNode;
+};
+export declare function SelectOption({ isFocused, isSelected, smallPointer, children }: SelectOptionProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/CustomSelect/select.d.ts

@@ -0,0 +1,55 @@
+import { type Option } from "./option-map.js";
+export type OptionSubtree = {
+    /**
+     * Header to show above sub-options.
+     */
+    readonly header?: string;
+    /**
+     * Options.
+     */
+    readonly options: (Option | OptionSubtree)[];
+};
+export type OptionHeader = {
+    readonly header: string;
+    readonly optionValues: string[];
+};
+export declare const optionHeaderKey: (optionHeader: OptionHeader) => string;
+export type SelectProps = {
+    /**
+     * When disabled, user input is ignored.
+     *
+     * @default false
+     */
+    readonly isDisabled?: boolean;
+    /**
+     * Number of visible options.
+     *
+     * @default 5
+     */
+    readonly visibleOptionCount?: number;
+    /**
+     * Highlight text in option labels.
+     */
+    readonly highlightText?: string;
+    /**
+     * Options.
+     */
+    readonly options: (Option | OptionSubtree)[];
+    /**
+     * Default value.
+     */
+    readonly defaultValue?: string;
+    /**
+     * Callback when selected option changes.
+     */
+    readonly onChange?: (value: string) => void;
+    /**
+     * Callback when focused option changes.
+     */
+    readonly onFocus?: (value: string) => void;
+    /**
+     * Value to focus
+     */
+    readonly focusValue?: string;
+};
+export declare function Select({ isDisabled, visibleOptionCount, highlightText, options, defaultValue, onChange, onFocus, focusValue, }: SelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/CustomSelect/use-select-state.d.ts

@@ -0,0 +1,99 @@
+import OptionMap, { type Option } from "./option-map.js";
+import type { OptionHeader, OptionSubtree } from "./select.js";
+type State = {
+    /**
+     * Map where key is option's value and value is option's index.
+     */
+    optionMap: OptionMap;
+    /**
+     * Number of visible options.
+     */
+    visibleOptionCount: number;
+    /**
+     * Value of the currently focused option.
+     */
+    focusedValue: string | undefined;
+    /**
+     * Index of the first visible option.
+     */
+    visibleFromIndex: number;
+    /**
+     * Index of the last visible option.
+     */
+    visibleToIndex: number;
+    /**
+     * Value of the previously selected option.
+     */
+    previousValue: string | undefined;
+    /**
+     * Value of the selected option.
+     */
+    value: string | undefined;
+};
+export type UseSelectStateProps = {
+    /**
+     * Number of items to display.
+     *
+     * @default 5
+     */
+    visibleOptionCount?: number;
+    /**
+     * Options.
+     */
+    options: (Option | OptionSubtree)[];
+    /**
+     * Initially selected option's value.
+     */
+    defaultValue?: string;
+    /**
+     * Callback for selecting an option.
+     */
+    onChange?: (value: string) => void;
+    /**
+     * Callback for focusing an option.
+     */
+    onFocus?: (value: string) => void;
+    /**
+     * Value to focus
+     */
+    focusValue?: string;
+};
+export type SelectState = Pick<State, "focusedValue" | "visibleFromIndex" | "visibleToIndex" | "value"> & {
+    /**
+     * Visible options.
+     */
+    visibleOptions: Array<(Option | OptionHeader) & {
+        index: number;
+    }>;
+    /**
+     * Focus next option and scroll the list down, if needed.
+     */
+    focusNextOption: () => void;
+    /**
+     * Focus previous option and scroll the list up, if needed.
+     */
+    focusPreviousOption: () => void;
+    /**
+     * Select currently focused option.
+     */
+    selectFocusedOption: () => void;
+};
+export declare const useSelectState: ({ visibleOptionCount, options, defaultValue, onChange, onFocus, focusValue, }: UseSelectStateProps) => {
+    focusedValue: string | undefined;
+    visibleFromIndex: number;
+    visibleToIndex: number;
+    value: string | undefined;
+    visibleOptions: ({
+        index: number;
+        label: string;
+        value: string;
+    } | {
+        index: number;
+        header: string;
+        optionValues: string[];
+    })[];
+    focusNextOption: () => void;
+    focusPreviousOption: () => void;
+    selectFocusedOption: () => void;
+};
+export {};

package/dist/ui/components/CustomSelect/use-select.d.ts

@@ -0,0 +1,14 @@
+import { type SelectState } from "./use-select-state.js";
+export type UseSelectProps = {
+    /**
+     * When disabled, user input is ignored.
+     *
+     * @default false
+     */
+    isDisabled?: boolean;
+    /**
+     * Select state.
+     */
+    state: SelectState;
+};
+export declare const useSelect: ({ isDisabled, state }: UseSelectProps) => void;