"use client"; import { useCallback, useRef, useState } from "react"; import { IconCheck } from "@tabler/icons-react"; import { cn } from "@/lib/utils"; import { prioritizeSelectedOption, selectorOptionClassName } from "@/lib/utils/selector-options"; import { Popover, PopoverContent, PopoverTrigger } from "@kandev/ui/popover"; import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip"; import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, } from "@kandev/ui/command"; import { BranchRefreshButton } from "@/components/branch-refresh-button"; import { useTaskCreateDialogPopoverContainer } from "@/hooks/use-task-create-dialog-popover-container"; import { usePillTooltipSuppression } from "@/hooks/use-pill-tooltip-suppression"; import { useTooltipMountGate } from "@/hooks/use-tooltip-mount-gate"; export type PillOption = { value: string; label: string; keywords?: string[]; renderLabel?: () => React.ReactNode; renderAccessory?: () => React.ReactNode; group?: string; groupLabel?: string; disabled?: boolean; disabledReason?: string; }; export type PillAction = { label: string; icon?: React.ReactNode; onSelect: () => void; }; /** * `Pill` wraps cmdk's `Command` / `CommandInput` / `CommandList`. Searchable * content must remain cmdk children so keyboard navigation and focus stay * correct. Contextual controls can use `popoverHeader`, which renders outside * `Command`; mixed searchable content still needs a custom `Popover`. */ type PillProps = { icon: React.ReactNode; value: string; /** Option value used for selected-first ordering when the trigger label differs. */ selectedValue?: string; placeholder: string; options: PillOption[]; onSelect: (value: string) => void; disabled?: boolean; /** When provided alongside `disabled`, surfaces a tooltip explaining why. */ disabledReason?: string; searchPlaceholder: string; emptyMessage: string; testId?: string; /** Optional refresh action rendered next to the search input. */ onRefresh?: () => void; /** Show the refresh icon as spinning + disabled while a refresh is in flight. */ refreshing?: boolean; /** Accessible label used for the optional refresh action. */ refreshLabel?: string; /** * Render without its own border/bg so the pill blends into a wrapping * grouped container (used by RepoChip to draw one rectangle around * repo + branch + remove). */ flat?: boolean; /** Optional cmdk scorer override. Branch pickers pass `scoreBranch`. */ filter?: (value: string, search: string, keywords?: string[]) => number; /** Optional hover tooltip for truncated labels or extra context. */ tooltip?: string; /** * Optional muted prefix shown before the value in the trigger button. * Used by the branch chip to distinguish "current: " (no-op), * "will switch to: " (destructive) and "from: " (worktree * base) without depending on the user reading a tooltip. */ prefix?: string; /** Optional icon action rendered beside the search input. */ action?: PillAction; /** Optional contextual controls rendered above the searchable list. */ popoverHeader?: React.ReactNode; }; /** Returns the active-state hover classes for the pill trigger button. */ function pillActiveClass(flat: boolean): string { if (flat) return "hover:bg-muted/60 cursor-pointer"; return "hover:bg-muted hover:border-border cursor-pointer"; } function PillCommandList({ options, value, onSelect, onPointerSelect, setOpen, emptyMessage, }: { options: PillOption[]; value: string; onSelect: (value: string) => void; onPointerSelect: (pointerType: string) => void; setOpen: (open: boolean) => void; emptyMessage: string; }) { const groups = new Map(); for (const option of options) { const key = option.group ?? ""; const group = groups.get(key) ?? { label: option.groupLabel, options: [] }; group.options.push(option); groups.set(key, group); } const groupOrder = new Map([ ["policies", 0], ["branches", 1], ]); const orderedGroups = Array.from(groups.entries()).sort( ([firstKey], [secondKey]) => (groupOrder.get(firstKey) ?? Number.MAX_SAFE_INTEGER) - (groupOrder.get(secondKey) ?? Number.MAX_SAFE_INTEGER), ); return ( {emptyMessage} {orderedGroups.map(([key, group]) => ( {prioritizeSelectedOption(group.options, value, (option) => option.value).map( (option) => { const selected = option.value === value; const item = ( onPointerSelect(event.pointerType)} onSelect={() => { onSelect(option.value); setOpen(false); }} className={cn( selectorOptionClassName(selected), option.renderAccessory && "pr-14", )} >
{option.renderLabel ? option.renderLabel() : option.label}
); if (!option.renderAccessory) return item; return (
{item}
{option.renderAccessory()}
); }, )}
))}
); } /** * Builds the className for the pill trigger button. Extracted so the inline * trigger JSX stays compact (the Pill function is right at the complexity cap). */ function pillTriggerClass(disabled: boolean, flat: boolean, hasValue: boolean): string { return cn( "h-7 inline-flex items-center gap-1.5 rounded-md px-2.5 text-xs", flat ? "bg-transparent" : "border border-border/60 bg-muted/30", disabled ? "opacity-50 cursor-not-allowed" : pillActiveClass(flat), !hasValue && "text-muted-foreground", ); } function DisabledPillTooltip({ open, onOpenChange, triggerButton, disabledReason, }: { open: boolean; onOpenChange: (open: boolean) => void; triggerButton: React.ReactNode; disabledReason: string; }) { return ( {disabledReason} ); } function renderDisabledPillTooltip( tooltipOpenState: boolean, onOpenChange: (open: boolean) => void, triggerButton: React.ReactNode, disabledReason: string, ): React.ReactElement { return ( ); } function PillPopoverContent({ filter, searchPlaceholder, onRefresh, refreshing, refreshLabel, options, value, onSelect, onPointerSelect, setOpen, emptyMessage, portalContainer, action, popoverHeader, }: { filter?: PillProps["filter"]; searchPlaceholder: string; onRefresh?: () => void; refreshing?: boolean; refreshLabel?: string; options: PillOption[]; value: string; onSelect: (value: string) => void; onPointerSelect: (pointerType: string) => void; setOpen: (open: boolean) => void; emptyMessage: string; portalContainer: HTMLElement | null; action?: PillAction; popoverHeader?: React.ReactNode; }) { return ( {popoverHeader}
{onRefresh ? ( ) : null} {action ? ( {action.label} ) : null}
); } function PillPopover({ open, setOpen, triggerButton, filter, searchPlaceholder, onRefresh, refreshing, refreshLabel, options, value, onSelect, onPointerSelect, emptyMessage, portalContainer, action, popoverHeader, }: { open: boolean; setOpen: (open: boolean) => void; triggerButton: React.ReactElement; filter?: PillProps["filter"]; searchPlaceholder: string; onRefresh?: () => void; refreshing?: boolean; refreshLabel?: string; options: PillOption[]; value: string; onSelect: (value: string) => void; onPointerSelect: (pointerType: string) => void; emptyMessage: string; portalContainer: HTMLElement | null; action?: PillAction; popoverHeader?: React.ReactNode; }) { return ( {triggerButton} ); } type PillPopoverShellProps = { open: boolean; setOpen: (open: boolean) => void; triggerButton: React.ReactElement; filter?: PillProps["filter"]; searchPlaceholder: string; onRefresh?: () => void; refreshing?: boolean; refreshLabel?: string; options: PillOption[]; value: string; onSelect: (value: string) => void; onPointerSelect: (pointerType: string) => void; emptyMessage: string; portalContainer: HTMLElement | null; action?: PillAction; popoverHeader?: React.ReactNode; tooltip?: string; tooltipOpenState: boolean; suppressTooltip: boolean; suppressTooltipRef: { current: boolean }; handlePillTooltipOpenChange: (open: boolean) => void; suppressForSelection: () => void; }; function renderPillPopover({ open, setOpen, triggerButton, filter, searchPlaceholder, onRefresh, refreshing, refreshLabel, options, value, onSelect, onPointerSelect, emptyMessage, portalContainer, action, popoverHeader, tooltip, tooltipOpenState, suppressTooltip, suppressTooltipRef, handlePillTooltipOpenChange, suppressForSelection, }: PillPopoverShellProps): React.ReactElement { const popover = ( { if (tooltip) suppressForSelection(); onSelect(selectedValue); }} emptyMessage={emptyMessage} portalContainer={portalContainer} action={action} popoverHeader={popoverHeader} /> ); if (!tooltip) return popover; const tooltipOpen = open || suppressTooltip || suppressTooltipRef.current ? false : tooltipOpenState; return ( {popover} {tooltip} ); } function renderPillTriggerButton({ icon, value, placeholder, disabled, flat, hasValue, testId, prefix, onPointerEnter, onPointerLeave, onBlur, }: Pick & { hasValue: boolean; onPointerEnter?: React.PointerEventHandler; onPointerLeave?: React.PointerEventHandler; onBlur?: React.FocusEventHandler; }): React.ReactElement { const showPrefix = !!prefix && hasValue; return ( ); } function usePillOpenHandlers( setOpenState: React.Dispatch>, closeTooltip: () => void, suppressTooltipUntilLeave: (releaseOnExit?: boolean) => void, ) { const selectionPointerTypeRef = useRef(""); const suppressForSelection = useCallback(() => { suppressTooltipUntilLeave(selectionPointerTypeRef.current !== "touch"); }, [suppressTooltipUntilLeave]); const setOpen = useCallback( (next: boolean) => { if (next) { closeTooltip(); selectionPointerTypeRef.current = ""; } else { suppressForSelection(); } setOpenState(next); }, [closeTooltip, setOpenState, suppressForSelection], ); const recordPointerSelection = useCallback((pointerType: string) => { selectionPointerTypeRef.current = pointerType; }, []); return { setOpen, suppressForSelection, recordPointerSelection }; } /** * Compact pill trigger that opens a popover with a search list. Auto-widths * to its content (no `w-full`, no chevron) so multiple pills can sit on one * line without overlapping or stretching to fill the row. */ export function Pill({ icon, value, selectedValue, placeholder, options, onSelect, disabled = false, disabledReason, searchPlaceholder, emptyMessage, testId, onRefresh, refreshing, refreshLabel, flat = false, filter, tooltip, prefix, action, popoverHeader, }: PillProps) { const [open, setOpenState] = useState(false); const { tooltipOpenState, handleTooltipOpenChange, closeTooltip } = useTooltipMountGate(); const portalContainer = useTaskCreateDialogPopoverContainer(); const { suppressTooltip, suppressTooltipRef, suppressTooltipUntilLeave, handlePointerEnter, handlePointerLeave, handleBlur, } = usePillTooltipSuppression(open); const { setOpen, suppressForSelection, recordPointerSelection } = usePillOpenHandlers( setOpenState, closeTooltip, suppressTooltipUntilLeave, ); const handlePillTooltipOpenChange = useCallback( (next: boolean) => { if (next && suppressTooltipRef.current) return; handleTooltipOpenChange(next); }, [handleTooltipOpenChange], ); const triggerButton = renderPillTriggerButton({ icon, value, placeholder, disabled, flat, hasValue: Boolean(value), testId, prefix, onPointerEnter: tooltip ? handlePointerEnter : undefined, onPointerLeave: tooltip ? handlePointerLeave : undefined, onBlur: tooltip ? handleBlur : undefined, }); // Disabled buttons swallow events, so the wrapper owns tooltip focus. if (disabled && disabledReason && !open) { return renderDisabledPillTooltip( tooltipOpenState, handleTooltipOpenChange, triggerButton, disabledReason, ); } return renderPillPopover({ open, setOpen, triggerButton: tooltip ? ( {triggerButton} ) : ( triggerButton ), filter, searchPlaceholder, onRefresh, refreshing, refreshLabel, options, value: selectedValue ?? value, onPointerSelect: recordPointerSelection, onSelect, emptyMessage, portalContainer, action, popoverHeader, tooltip, tooltipOpenState, suppressTooltip, suppressTooltipRef, handlePillTooltipOpenChange, suppressForSelection, }); }