@pstdio/ui 0.6.0 → 0.7.1

package/dist/components/chat-ui/components/ai-message.d.ts

@@ -8,7 +8,9 @@ declare const recipe: import('@chakra-ui/react').SlotRecipeDefinition<"content"
             };
             content: {
                 borderTopWidth: "1px";
+                borderRightWidth: "1px";
                 borderBottomWidth: "1px";
+                borderLeftWidth: "1px";
                 borderColor: "border.muted";
                 bg: "bg.subtle";
                 px: "xs";

package/dist/components/chat-ui/components/chat-message-list.d.ts

@@ -0,0 +1,12 @@
+import { MessageGroup, SessionMessage } from './message-types';
+interface ChatMessageListProps {
+    leadingResponses: SessionMessage[];
+    groups: MessageGroup[];
+    streaming: boolean;
+    hideActiveQuestionForms: boolean;
+    expandedStickyMessageIds: Set<string>;
+    onToggleStickyMessage: (messageId: string) => void;
+    onReady?: () => void;
+}
+export declare const ChatMessageList: (props: ChatMessageListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/chat-ui/components/chat-panel.d.ts

@@ -2,12 +2,14 @@ import { ReactNode } from 'react';
 import { ChatInputQuestionPrompt, ChatInputQuestionResponse } from './chat-input-question-prompt';
 import { SessionMessage } from './message-types';
 interface ChatPanelProps {
+    conversationKey?: string;
     messages: SessionMessage[];
+    loading?: boolean;
     streaming?: boolean;
     emptyStateTitle: string;
     emptyStateDescription: string;
     emptyStateContent?: ReactNode;
-    loadingContent?: ReactNode;
+    loaderComponent?: ReactNode;
     chatInputPlaceholder: string;
     chatInputDefaultValue?: string;
     onSubmitMessage?: (text: string, attachments: string[], questionResponse?: ChatInputQuestionResponse) => void;

package/dist/components/chat-ui/components/message-action-panel.d.ts

@@ -0,0 +1,10 @@
+import { SessionMessage } from './message-types';
+interface MessageActionPanelProps {
+    message: SessionMessage;
+    alwaysVisible?: boolean;
+    copyAlwaysVisible?: boolean;
+}
+export declare const getMessageCopyText: (message: SessionMessage) => string;
+export declare const getMessageTimestampLabel: (message: SessionMessage, locale?: string, timeZone?: string) => string;
+export declare const MessageActionPanel: (props: MessageActionPanelProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/chat-ui/performance/chat-mount-metrics.d.ts

@@ -0,0 +1,37 @@
+export type ChatMountMetric = {
+    id: string;
+    scenario: string;
+    label: string;
+    totalMs: number;
+    messageCount: number;
+    perMessageMs: number | null;
+    startedAtMs: number;
+    completedAtMs: number;
+};
+type PendingChatMountMetric = {
+    scenario: string;
+    label: string;
+    messageCount: number;
+    startedAtMs: number;
+};
+type StartChatMountMetricInput = {
+    scenario: string;
+    label: string;
+    messageCount: number;
+    startMarkName?: string;
+};
+type FinishChatMountMetricInput = {
+    id: string;
+    messageCount: number;
+    readyMarkName?: string;
+};
+declare global {
+    interface Window {
+        __chatPanelMountMetrics?: ChatMountMetric[];
+        __chatPanelPendingMountMetrics?: Record<string, PendingChatMountMetric>;
+    }
+}
+export declare const startChatMountMetric: (input: StartChatMountMetricInput) => string;
+export declare const finishChatMountMetricAfterPaint: (input: FinishChatMountMetricInput) => void;
+export declare const readLatestChatMountMetric: (scenario: string) => ChatMountMetric | null;
+export {};

package/dist/components/chat-ui/performance/chat-panel.perf.d.ts

@@ -0,0 +1,18 @@
+import { ChatMountMetric } from './chat-mount-metrics';
+type ProfilerSample = {
+    scenario: string;
+    phase: string;
+    actualDuration: number;
+    baseDuration: number;
+    commitTime: number;
+};
+declare global {
+    interface Window {
+        __chatPanelPerf?: ProfilerSample[];
+        __chatPanelMountMetrics?: ChatMountMetric[];
+        __longTasks?: Array<{
+            duration: number;
+        }>;
+    }
+}
+export {};

package/dist/components/chat-ui/performance/chat-performance-fixtures.d.ts

@@ -0,0 +1,29 @@
+import { SessionMessage } from '../agent-types';
+export interface LargeChatConversationOptions {
+    sessionId: string;
+    turns: number;
+    textRepeat?: number;
+    toolCallsPerTurn?: number;
+}
+export interface ChatPerformanceSession {
+    id: string;
+    label: string;
+    messages: SessionMessage[];
+}
+export declare const CHAT_PERFORMANCE_STRESS_TURNS = 500;
+export declare const CHAT_PERFORMANCE_STRESS_MESSAGE_COUNT: number;
+export declare const buildLargeChatConversation: (options: LargeChatConversationOptions) => SessionMessage[];
+export declare const buildChatSessionSwitchFixture: () => {
+    primarySession: {
+        id: string;
+        label: string;
+        messages: SessionMessage[];
+    };
+    secondarySession: {
+        id: string;
+        label: string;
+        messages: SessionMessage[];
+    };
+};
+export declare const seedStreamingMessage: (message: SessionMessage) => SessionMessage;
+export declare const updateStreamingTextPart: (messages: SessionMessage[], messageId: string, partIndex: number, text: string) => SessionMessage[];

package/dist/components/chat-ui/performance/chat-performance-panel.d.ts

@@ -0,0 +1,23 @@
+export type ChatPerfSample = {
+    scenario: string;
+    phase: string;
+    actualDuration: number;
+    baseDuration: number;
+    commitTime: number;
+};
+declare global {
+    interface Window {
+        __chatPanelPerf?: ChatPerfSample[];
+    }
+}
+export declare const ensureChatPerfBuffer: () => {
+    scenario: string;
+    phase: string;
+    actualDuration: number;
+    baseDuration: number;
+    commitTime: number;
+}[] | null;
+export declare const ChatPerformancePanel: (props: {
+    scenario: string;
+    messageCount: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/chat-ui/performance/chat-performance-story-utils.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { SessionMessage } from '../agent-types';
+export declare const defaultChatPanelProps: {
+    readonly emptyStateTitle: "No messages";
+    readonly emptyStateDescription: "";
+    readonly chatInputPlaceholder: "Benchmark prompt";
+};
+export type ActiveMountMeasurement = {
+    id: string;
+    readyMarkName?: string;
+};
+export declare const markAfterPaint: (markName: string) => void;
+export declare const nextFrame: () => Promise<void>;
+export declare const streamMessages: (input: {
+    messages: SessionMessage[];
+    isCancelled: () => boolean;
+    appendMessage: (message: SessionMessage) => void;
+    updateText: (messageId: string, partIndex: number, text: string) => void;
+}) => Promise<void>;
+export declare function ChatMountReadyMarker(props: {
+    measurement: ActiveMountMeasurement | null;
+    messageCount: number;
+}): null;
+export declare function ChatPerfShell(props: {
+    scenario: string;
+    activeLabel: string;
+    messageCount: number;
+    actions?: ReactNode;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/code-editor.d.ts

@@ -1,6 +1,6 @@
 export declare const customTheme: {
     base: "vs-dark";
-    inherit: boolean;
+    inherit: true;
     rules: never[];
     colors: {
         "editor.background": string;

package/dist/components/diff-viewer/build-changed-files-tree.d.ts

@@ -0,0 +1,4 @@
+import { ChangedFilesViewMode, ChangedFileTreeNode } from './types';
+export declare const buildChangedFilesTree: (paths: string[], mode: ChangedFilesViewMode) => ChangedFileTreeNode[];
+export declare const collectExpandedFolderIds: (nodes: ChangedFileTreeNode[]) => string[];
+export declare const sortPathsByViewMode: (paths: string[], mode: ChangedFilesViewMode) => string[];

package/dist/components/diff-viewer/diff-card-body.d.ts

@@ -0,0 +1,34 @@
+import { Diff } from './diff-card';
+import { BuiltDiffViewData, buildDiffViewData } from './diff-view-adapter';
+import { DiffViewMode } from './types';
+interface DiffCardBodyProps {
+    diff: Diff;
+    filePath: string;
+    oldContent: string;
+    newContent: string;
+    isLargeDiff: boolean;
+    hasOptedIntoLargeDiff: boolean;
+    onShowFullDiff?: () => void;
+    diffViewMode?: DiffViewMode;
+}
+interface DiffCardBodyModelInput extends DiffCardBodyProps {
+    buildViewData?: typeof buildDiffViewData;
+}
+export declare const createDiffCardBodyModel: (input: DiffCardBodyModelInput) => {
+    kind: "placeholder";
+    filePath: string;
+    renderedLineCount: number;
+    onShowFullDiff: (() => void) | undefined;
+    diffViewData?: undefined;
+    sideBySide?: undefined;
+} | {
+    kind: "editor";
+    diffViewData: BuiltDiffViewData;
+    sideBySide: boolean;
+    filePath?: undefined;
+    renderedLineCount?: undefined;
+    onShowFullDiff?: undefined;
+};
+export declare const DiffCardBody: (props: DiffCardBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type TestDiffViewData = BuiltDiffViewData;
+export {};

package/dist/components/diff-viewer/diff-card-content.d.ts

@@ -0,0 +1,22 @@
+import { Diff } from './diff-card';
+import { DiffViewMode } from './types';
+interface DiffCardContentProps {
+    diff: Diff;
+    filePath: string;
+    oldContent: string;
+    newContent: string;
+    isExpanded: boolean;
+    isLargeDiff: boolean;
+    isGeneratedDiff: boolean;
+    hasDiffContent: boolean;
+    canLoadDiff: boolean;
+    shouldAutoLoadDiff: boolean;
+    loadError: boolean;
+    isLoadingDiff: boolean;
+    onLoadDiff: () => Promise<void>;
+    hasOptedIntoLargeDiff: boolean;
+    onShowFullDiff?: () => void;
+    diffViewMode?: DiffViewMode;
+}
+export declare const DiffCardContent: (props: DiffCardContentProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/diff-viewer/diff-card-load-state.d.ts

@@ -0,0 +1,9 @@
+interface DeferredDiffLoadProps {
+    title: string;
+    actionLabel?: string;
+    isLoadingDiff: boolean;
+    onAction?: () => void;
+}
+export declare const DeferredDiffLoad: (props: DeferredDiffLoadProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LoadingDiffContent: () => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/diff-viewer/diff-card.d.ts

@@ -0,0 +1,43 @@
+import { DiffViewMode } from './types';
+export interface Diff {
+    change: "added" | "deleted" | "modified" | "renamed" | "copied" | "permissionChange";
+    oldPath?: string;
+    newPath?: string;
+    oldContent?: string;
+    newContent?: string;
+    additions?: number;
+    deletions?: number;
+}
+interface DiffCardProps {
+    diff: Diff;
+    isSelected?: boolean;
+    isExpanded?: boolean;
+    onToggleExpanded?: () => void;
+    onSelect?: () => void;
+    onLoadDiff?: (path: string) => Promise<void>;
+    hasOptedIntoLargeDiff?: boolean;
+    onShowFullDiff?: () => void;
+    diffViewMode?: DiffViewMode;
+}
+interface DiffCardHeaderProps {
+    diff: Diff;
+    isExpanded?: boolean;
+    onToggleExpanded?: () => void;
+}
+export declare const shouldAutoLoadDiffContent: (input: {
+    isExpanded: boolean;
+    isSelected: boolean;
+    hasDiffContent: boolean;
+    isLargeDiff: boolean;
+    isGeneratedDiff: boolean;
+    requestedPath: string | null;
+    filePath: string;
+}) => boolean;
+export declare const resolveRequestedDiffPath: (input: {
+    requestedPath: string | null;
+    filePath: string;
+    hasDiffContent: boolean;
+}) => string | null;
+export declare const DiffCard: (props: DiffCardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DiffCardHeader: (props: DiffCardHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/diff-viewer/diff-drawer.d.ts

@@ -0,0 +1,33 @@
+import { Diff } from './diff-card';
+import { DiffViewMode } from './types';
+interface DiffDrawerProps {
+    diffs: Diff[];
+    selectedDiffPath?: string | null;
+    onLoadDiff?: (path: string) => Promise<void>;
+    onSelectDiffPath?: (path: string) => void;
+    onExpansionStateChange?: (state: DiffDrawerExpansionState) => void;
+    expansionCommand?: DiffExpansionCommand | null;
+    diffViewMode?: DiffViewMode;
+}
+export interface DiffExpansionCommand {
+    action: "expand" | "collapse" | "expand-selected";
+    id: number;
+    path?: string;
+}
+export interface DiffDrawerExpansionState {
+    allExpanded: boolean;
+    allCollapsed: boolean;
+}
+export type { Diff };
+interface EstimateDiffCardHeightInput {
+    diff: Diff;
+    isCollapsed: boolean;
+    hasOptedIntoLargeDiff?: boolean;
+    diffViewMode?: DiffViewMode;
+}
+export declare const estimateDiffCardHeight: (input: EstimateDiffCardHeightInput) => number;
+export declare const buildInitialCollapsedPaths: (diffs: Diff[]) => Set<string>;
+export declare const buildAllCollapsedPaths: (diffs: Diff[]) => Set<string>;
+export declare const toggleCollapsedPath: (collapsedPaths: Set<string>, path: string) => Set<string>;
+export declare const resolveCollapsedPathsForSelectedDiff: (diffs: Diff[], collapsedPaths: Set<string>, selectedDiffPath: string | null) => Set<string>;
+export declare function DiffDrawer(props: DiffDrawerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/diff-viewer/diff-editor.d.ts

@@ -0,0 +1,20 @@
+import { DiffViewData } from './diff-view-adapter';
+export interface DiffEditorInput {
+    original: string;
+    modified: string;
+    language?: string;
+    oldPath?: string;
+    newPath?: string;
+}
+interface DiffEditorProps extends DiffEditorInput {
+    sideBySide?: boolean;
+    disableScroll?: boolean;
+    data?: DiffViewData;
+}
+export interface DiffEditorDataState {
+    input: DiffEditorInput;
+    data: DiffViewData;
+}
+export declare const resolveDiffEditorDataState: (current: DiffEditorDataState | null, input: DiffEditorInput, createData: () => DiffViewData) => DiffEditorDataState;
+export declare function DiffEditor(props: DiffEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/diff-viewer/diff-size.d.ts

@@ -0,0 +1,14 @@
+export declare const LARGE_DIFF_LINE_THRESHOLD = 1000;
+export declare const getDiffLineCount: (input: {
+    additions?: number;
+    deletions?: number;
+    oldContent?: string;
+    newContent?: string;
+}) => number;
+export declare const isLargeDiffContent: (input: {
+    additions?: number;
+    deletions?: number;
+    oldContent?: string;
+    newContent?: string;
+}) => boolean;
+export declare const isGeneratedDiffPath: (path: string) => boolean;

package/dist/components/diff-viewer/diff-view-adapter.d.ts

@@ -0,0 +1,27 @@
+import { DiffViewProps } from '@git-diff-view/react';
+interface ResolveDiffLanguageInput {
+    language?: string;
+    oldPath?: string;
+    newPath?: string;
+}
+interface BuildDiffViewDataInput extends ResolveDiffLanguageInput {
+    original: string;
+    modified: string;
+}
+export type DiffViewData = NonNullable<DiffViewProps<unknown>["data"]>;
+/**
+ * Diff view data enriched with the row counts the renderer will actually paint. The renderer
+ * collapses unchanged context, so only lines inside the hunks are rendered — these counts come
+ * from the hunk patch, not the full file length.
+ */
+export interface BuiltDiffViewData extends DiffViewData {
+    /** Content rows painted in unified layout (one per added/removed/context line). */
+    unifiedContentRows: number;
+    /** Content rows painted in split layout (paired add/remove lines share a row). */
+    splitContentRows: number;
+    /** Hunk header rows — one per `@@` section, taller than content rows. */
+    hunkRows: number;
+}
+export declare const resolveDiffLanguage: ({ language, oldPath, newPath }: ResolveDiffLanguageInput) => string;
+export declare const buildDiffViewData: (input: BuildDiffViewDataInput) => BuiltDiffViewData;
+export {};

package/dist/components/diff-viewer/diff-viewer.d.ts

@@ -0,0 +1,14 @@
+import { Diff } from './diff-card';
+import { FileIconInfo } from './types';
+export interface DiffViewerProps {
+    diffs: Diff[];
+    changedFilePaths?: string[];
+    defaultSelectedPath?: string | null;
+    loading?: boolean;
+    onLoadDiff?: (path: string) => Promise<void>;
+    resolveFileIcon?: (path: string, options?: {
+        isFolder?: boolean;
+        isExpanded?: boolean;
+    }) => FileIconInfo | undefined;
+}
+export declare const DiffViewer: (props: DiffViewerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/diff-viewer/diff-viewer.store.d.ts

@@ -0,0 +1,21 @@
+import { ChangedFilesViewMode, DiffViewMode } from './types';
+interface DiffViewerState {
+    isTreePanelOpen: boolean;
+    viewMode: ChangedFilesViewMode;
+    diffViewMode: DiffViewMode;
+    searchQuery: string;
+    selectedPath: string | null;
+    expandedFolderIds: Set<string>;
+    setTreePanelOpen: (open: boolean) => void;
+    toggleTreePanel: () => void;
+    setViewMode: (viewMode: ChangedFilesViewMode) => void;
+    setDiffViewMode: (diffViewMode: DiffViewMode) => void;
+    setSearchQuery: (searchQuery: string) => void;
+    setSelectedPath: (selectedPath: string | null) => void;
+    setExpandedFolderIds: (folderIds: string[]) => void;
+    toggleFolder: (folderId: string) => void;
+    expandAll: (folderIds: string[]) => void;
+    collapseAll: () => void;
+}
+export declare const useDiffViewerStore: import('zustand').UseBoundStore<import('zustand').StoreApi<DiffViewerState>>;
+export {};

package/dist/components/diff-viewer/file-list-panel.d.ts

@@ -0,0 +1,19 @@
+import { ChangedFilesViewMode, FileIconInfo } from './types';
+interface FileListPanelProps {
+    title: string;
+    paths: string[];
+    selectedPath: string | null;
+    viewMode: ChangedFilesViewMode;
+    searchQuery: string;
+    expandedFolderIds: Set<string>;
+    onSelectPath: (path: string) => void;
+    onSearchQueryChange: (value: string) => void;
+    onToggleFolder: (id: string) => void;
+    resolveFileIcon?: (path: string, options?: {
+        isFolder?: boolean;
+        isExpanded?: boolean;
+    }) => FileIconInfo | undefined;
+    changeByPath?: Map<string, string>;
+}
+export declare const FileListPanel: (props: FileListPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/diff-viewer/index.d.ts

@@ -0,0 +1,5 @@
+export type { Diff } from './diff-card';
+export { DiffDrawer } from './diff-drawer';
+export { DiffViewer, type DiffViewerProps } from './diff-viewer';
+export { useDiffViewerStore } from './diff-viewer.store';
+export type { ChangedFilesViewMode, DiffViewMode, FileIconInfo } from './types';

package/dist/components/diff-viewer/types.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+export type ChangedFilesViewMode = "nested" | "flat";
+export type DiffViewMode = "unified" | "split";
+export interface ChangedFileTreeNode {
+    id: string;
+    name: string;
+    type: "folder" | "file";
+    children?: ChangedFileTreeNode[];
+}
+export interface FileIconInfo {
+    icon: ReactNode;
+    color: string;
+}

package/dist/components/integration-card.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface IntegrationCardProps {
+    icon: ReactNode;
+    name: string;
+    description: string;
+    id: string;
+    version?: string;
+    category?: string;
+    active?: boolean;
+    actionLabel?: string;
+}
+export declare const IntegrationCard: (props: IntegrationCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/list-row/list-row-menu.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+import { ListRowActionMenuItem, ListRowMenuPlacement } from './list-row.types';
+interface ListRowMenuProps {
+    items: ListRowActionMenuItem[];
+    open: boolean;
+    placement?: ListRowMenuPlacement;
+    children: ReactElement;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (item: ListRowActionMenuItem) => void;
+}
+export declare const ListRowMenu: (props: ListRowMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/list-row/list-row.types.d.ts

@@ -16,12 +16,16 @@ export interface ListRowActionMenuItem {
         size?: number | string;
     }>;
     disabled?: boolean;
+    /** Trailing content rendered after the label. Use for Kbd shortcuts, counts, or badges. */
+    endContent?: ReactNode;
     onAction?: () => void;
 }
 export interface ListRowAction {
     id: string;
     label: string;
     icon?: ReactNode;
+    /** Tooltip shown when the action button is hovered or focused. Can include label + Kbd hint. */
+    tooltip?: ReactNode;
     searchPlaceholder?: string;
     emptyMenuLabel?: string;
     menuItems?: ListRowActionMenuItem[];
@@ -29,6 +33,7 @@ export interface ListRowAction {
 }
 export type ListRowVariant = "default" | "compact" | "tree";
 export type ListRowTone = "default" | "danger";
+export type ListRowMenuPlacement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "right" | "right-start" | "right-end" | "left" | "left-start" | "left-end";
 export interface ListRowItem {
     id?: string;
     label: ReactNode;
@@ -51,6 +56,9 @@ export interface ListRowItem {
     href?: string;
     navigationIntent?: ListRowNavigationIntent;
     onActivate?: () => void;
+    /** Left-click menu opened from the row surface. */
+    menuItems?: ListRowActionMenuItem[];
+    menuPlacement?: ListRowMenuPlacement;
     contextMenuItems?: ListRowActionMenuItem[];
     actions?: ListRowAction[];
     children?: ListRowItem[];

package/dist/components/palette-filter.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+export declare const DEFAULT_PALETTE_ASSET_LIMIT = 48;
+export interface PaletteSearchEntry {
+    id: string;
+    mode?: string;
+    label: ReactNode;
+    searchText?: string;
+    secondaryLabel?: ReactNode;
+    assetType?: string;
+}
+export interface PaletteMode {
+    id: string;
+    inputPrefix?: string;
+}
+export interface FilterPaletteEntriesOptions {
+    query: string;
+    mode?: string;
+    getEffectiveQuery?: (query: string) => string;
+    defaultAssetLimit?: number;
+}
+export declare const resolvePaletteMode: (query: string, modes?: readonly PaletteMode[], fallbackMode?: string) => string;
+export declare const getPaletteEffectiveQuery: (query: string, modes?: readonly PaletteMode[], modeId?: string) => string;
+export declare const filterPaletteEntries: <T extends PaletteSearchEntry>(entries: T[], options: FilterPaletteEntriesOptions) => T[];

package/dist/components/palette-list.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+import { PaletteEntry } from './palette';
+interface PaletteListProps<T extends PaletteEntry> {
+    entries: T[];
+    activeIndex: number;
+    emptyLabel: string;
+    onHover: (index: number) => void;
+    scrollRef: RefObject<HTMLDivElement | null>;
+}
+export declare const PaletteList: <T extends PaletteEntry>(props: PaletteListProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/palette-shortcut.d.ts

@@ -0,0 +1,4 @@
+export type PaletteShortcutBinding = string | string[];
+export declare const PaletteShortcut: (props: {
+    binding: PaletteShortcutBinding;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/palette.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode, SetStateAction } from 'react';
+import { DEFAULT_PALETTE_ASSET_LIMIT, FilterPaletteEntriesOptions, filterPaletteEntries, PaletteMode, PaletteSearchEntry } from './palette-filter';
+export type { FilterPaletteEntriesOptions, PaletteMode, PaletteSearchEntry };
+export { DEFAULT_PALETTE_ASSET_LIMIT, filterPaletteEntries };
+export interface PaletteEntry extends PaletteSearchEntry {
+    description?: ReactNode;
+    icon?: ReactNode;
+    shortcut?: ReactNode;
+    endContent?: ReactNode;
+    group?: string;
+    isSelected?: boolean;
+    onActivate: () => void;
+}
+export interface PaletteState<T extends PaletteEntry> {
+    query: string;
+    mode?: string;
+    activeIndex: number;
+    entries: T[];
+}
+export interface PaletteEscapeContext<T extends PaletteEntry> extends PaletteState<T> {
+    activeEntry: T | null;
+    entryCount: number;
+    setQuery: (query: string) => void;
+    setActiveIndex: (index: SetStateAction<number>) => void;
+    runActiveEntry: () => void;
+    closePalette: () => void;
+}
+export type PaletteStateValue<T extends PaletteEntry, TValue> = TValue | ((state: PaletteState<T>) => TValue);
+export interface PaletteProps<T extends PaletteEntry = PaletteEntry> {
+    open: boolean;
+    entries: T[];
+    initialQuery?: string;
+    initialActiveIndex?: number;
+    mode?: string;
+    modes?: PaletteMode[];
+    resetKey?: string;
+    inputIcon?: PaletteStateValue<T, ReactNode>;
+    placeholder?: PaletteStateValue<T, string>;
+    emptyLabel?: string;
+    footerStart?: ReactNode;
+    footerEnd?: ReactNode;
+    filterEntries?: (entries: T[], query: string, mode?: string) => T[];
+    onActiveEntryChange?: (entry: T | null, index: number) => void;
+    onClose: () => void;
+    onEscape?: (ctx: PaletteEscapeContext<T>) => boolean | undefined;
+}
+export declare const Palette: <T extends PaletteEntry>(props: PaletteProps<T>) => import("react/jsx-runtime").JSX.Element;