"use client";
import { useMemo } from "react";
import { IconChevronDown, IconCode, IconLoader2 } from "@tabler/icons-react";
import { Button } from "@kandev/ui/button";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from "@kandev/ui/dropdown-menu";
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
import { useEditors } from "@/hooks/domains/settings/use-editors";
import { useOpenSessionInEditor } from "@/hooks/use-open-session-in-editor";
import { useSessionWorktrees } from "@/hooks/domains/session/use-session-worktrees";
import { useAppStore } from "@/components/state-provider";
import type { EditorOption } from "@/lib/types/http";
import {
buildWorktreeOptions,
type WorktreeOption,
} from "@/components/task/editor-worktree-options";
import {
getAvailableTaskTopbarEditors,
resolveTaskTopbarEditorId,
} from "@/components/task/editors-menu-availability";
import { useTranslation } from "react-i18next";
const menuItemClass = "cursor-pointer";
type EditorsMenuProps = {
activeSessionId: string | null;
embeddedVscodeSupported: boolean;
};
function useWorktreeOptions(sessionId: string | null): WorktreeOption[] {
const worktrees = useSessionWorktrees(sessionId);
const repositoriesByWorkspace = useAppStore((state) => state.repositories.itemsByWorkspaceId);
return useMemo(
() => buildWorktreeOptions(worktrees, Object.values(repositoriesByWorkspace).flat()),
[worktrees, repositoriesByWorkspace],
);
}
function WorktreeItems({
options,
onSelect,
}: {
options: WorktreeOption[];
onSelect: (worktreeId: string) => void;
}) {
return (
<>
{options.map((option) => (
onSelect(option.worktreeId)}
>
{option.label}
{option.branch && (
{option.branch}
)}
))}
>
);
}
function OpenEditorButton({
disabled,
isLoading,
tooltip,
worktreeOptions,
onOpen,
}: {
disabled: boolean;
isLoading: boolean;
tooltip: string;
worktreeOptions: WorktreeOption[];
onOpen: (worktreeId?: string) => void;
}) {
const icon = isLoading ? (
) : (
);
const buttonClass = "rounded-none border-0 cursor-pointer px-2 focus-visible:ring-inset";
// Multi-worktree sessions get a picker instead of opening the first worktree.
// The focusable span keeps the tooltip reachable while the button is
// disabled (disabled buttons receive no pointer/focus events).
if (worktreeOptions.length > 1) {
return (
{tooltip}
onOpen(worktreeId)} />
);
}
return (
{tooltip}
);
}
function EditorMenuEntry({
editor,
worktreeOptions,
onOpen,
}: {
editor: EditorOption;
worktreeOptions: WorktreeOption[];
onOpen: (editorId: string, worktreeId?: string) => void;
}) {
if (worktreeOptions.length > 1) {
return (
{editor.name}
onOpen(editor.id, worktreeId)}
/>
);
}
return (
onOpen(editor.id)}>
{editor.name}
);
}
export function EditorsMenu({ activeSessionId, embeddedVscodeSupported }: EditorsMenuProps) {
const { t } = useTranslation();
const openEditor = useOpenSessionInEditor(activeSessionId ?? null);
const { editors } = useEditors();
const defaultEditorId = useAppStore((state) => state.userSettings.defaultEditorId);
const worktreeOptions = useWorktreeOptions(activeSessionId ?? null);
const enabledEditors = useMemo(
() => getAvailableTaskTopbarEditors(editors, embeddedVscodeSupported),
[editors, embeddedVscodeSupported],
);
const resolvedEditorId = useMemo(() => {
return resolveTaskTopbarEditorId(defaultEditorId, enabledEditors);
}, [defaultEditorId, enabledEditors]);
const openWith = (editorId: string, worktreeId?: string) => {
if (!editorId) return;
void openEditor.open({ editorId, worktreeId });
};
return (
openWith(resolvedEditorId, worktreeId)}
/>
{enabledEditors.length === 0 ? (
{t("task:noEditorsAvailable")}
) : (
enabledEditors.map((editor: EditorOption) => (
))
)}
);
}