import { resolveEnvironmentMachineKind } from "@t3tools/contracts";
import { useLocation } from "@tanstack/react-router";
import { CheckIcon, ChevronDownIcon, LayersIcon } from "lucide-react";
import { Fragment, useState, type ReactNode } from "react";
import type { SidebarProjectSnapshot } from "../../sidebarProjectGrouping";
import { useEnvironments, type EnvironmentPresentation } from "../../state/environments";
import { EnvironmentMachineIcon } from "../EnvironmentMachineIcon";
import { ProjectFavicon } from "../ProjectFavicon";
import { Button } from "../ui/button";
import {
Combobox,
ComboboxEmpty,
ComboboxItem,
ComboboxList,
ComboboxPopup,
ComboboxSearchInput,
ComboboxTrigger,
} from "../ui/combobox";
import {
Menu,
MenuPopup,
MenuRadioGroup,
MenuRadioItem,
MenuRadioItemIndicator,
MenuSeparator,
MenuTrigger,
} from "../ui/menu";
import { useOptionalSettingsScope } from "./SettingsScopeContext";
import { resolveSettingsScope, type SettingsScopeSearch } from "./settingsScope";
import {
ALL_ENVIRONMENTS_VALUE,
ALL_PROJECTS_VALUE,
environmentAxisValue,
projectAxisValue,
projectScopeMenuGroups,
selectEnvironmentAxis,
selectProjectAxis,
settingsScopeEnvironmentAddress,
settingsScopeEnvironmentLabel,
settingsScopeEnvironmentLabels,
settingsScopeProjectMachines,
} from "./settingsScopeAxis";
export const SETTINGS_DEVICE_ONLY_PATHS: ReadonlySet<string> = new Set([
"/settings/general",
"/settings/appearance",
"/settings/chat",
"/settings/diffs",
"/settings/snap-shot",
"/settings/connections",
// Access picks its environment on the page itself.
"/settings/access",
"/settings/about",
]);
interface SettingsScopeMenuProps {
readonly value: SettingsScopeSearch;
readonly groups: readonly SidebarProjectSnapshot[];
readonly environments: readonly EnvironmentPresentation[];
readonly singleEnvironment: boolean;
readonly onChange: (next: SettingsScopeSearch) => void;
}
export function SettingsScopeSentence() {
const scope = useOptionalSettingsScope();
const pathname = useLocation({ select: (location) => location.pathname });
const { environments } = useEnvironments();
if (scope === null || SETTINGS_DEVICE_ONLY_PATHS.has(pathname)) return null;
const props: SettingsScopeMenuProps = {
value: scope.search,
singleEnvironment: scope.singleEnvironment,
groups: scope.groups,
environments,
onChange: scope.selectScope,
};
return (
<p className="flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-1 px-3 text-sm text-muted-foreground sm:px-4">
<span className="flex min-w-0 items-center gap-1.5">
<span className="shrink-0">Applying settings for</span>
<ProjectScopeMenu {...props} />
</span>
<span className="flex min-w-0 items-center gap-1.5">
<span className="shrink-0">
{scope.search.machine || scope.scope.kind === "checkout" ? "on" : "across"}
</span>
<EnvironmentScopeMenu {...props} />
</span>
</p>
);
}
interface ScopeOption {
value: string;
label: string;
secondary?: string;
icon?: ReactNode;
offline?: boolean;
}
function ScopeOptionLabel({ option }: { option: ScopeOption }) {
return (
<>
{option.icon}
<span className="min-w-0 flex-1">
<span className="block truncate">{option.label}</span>
{option.secondary ? (
<span className="block truncate text-xs text-muted-foreground">{option.secondary}</span>
) : null}
</span>
{option.offline ? (
<span className="shrink-0 text-xs text-muted-foreground">Offline</span>
) : null}
</>
);
}
function ScopeMenu({
ariaLabel,
icon,
label,
value,
options,
allOption,
searchLabel,
onChange,
}: {
ariaLabel: string;
icon: ReactNode;
label: string;
value: string;
options: ScopeOption[];
allOption: ScopeOption | null;
searchLabel: string;
onChange: (next: string) => void;
}) {
const [query, setQuery] = useState("");
const Trigger = options.length > 6 ? ComboboxTrigger : MenuTrigger;
const trigger = (
<Trigger
aria-label={`${ariaLabel}: ${label}`}
render={<Button variant="outline" size="sm" />}
className="min-w-0 max-w-72"
>
{icon}
<span className="min-w-0 truncate">{label}</span>
<ChevronDownIcon
aria-hidden
strokeWidth={1.75}
className="-me-0.5 size-3.5 shrink-0 text-muted-foreground opacity-70"
/>
</Trigger>
);
const choices = allOption ? [allOption, ...options] : options;
if (options.length > 6) {
const needle = query.trim().toLowerCase();
const filteredItems = choices.filter((option) =>
`${option.label} ${option.secondary ?? ""} ${option.value}`.toLowerCase().includes(needle),
);
return (
<Combobox
items={choices}
filteredItems={filteredItems}
filter={null}
autoHighlight
itemToStringLabel={(option) => option.label}
isItemEqualToValue={(a, b) => a.value === b.value}
value={choices.find((option) => option.value === value) ?? null}
onOpenChange={(open) => {
if (!open) setQuery("");
}}
onValueChange={(option) => {
if (option) onChange(option.value);
}}
>
{trigger}
<ComboboxPopup align="start" className="w-80">
<ComboboxSearchInput
aria-label={searchLabel}
placeholder={searchLabel}
value={query}
onChange={(event) => setQuery(event.target.value)}
/>
<ComboboxEmpty>No matches found.</ComboboxEmpty>
<ComboboxList>
{(option: ScopeOption) => (
<ComboboxItem key={option.value} value={option}>
<ScopeOptionLabel option={option} />
{option.value === value ? (
<CheckIcon aria-hidden className="size-3.5 shrink-0" />
) : null}
</ComboboxItem>
)}
</ComboboxList>
</ComboboxPopup>
</Combobox>
);
}
return (
<Menu>
{trigger}
<MenuPopup align="start">
<div className="w-72 max-w-full">
<MenuRadioGroup
value={value}
onValueChange={(next) => {
if (typeof next === "string") onChange(next);
}}
>
{choices.map((option, index) => (
<Fragment key={option.value}>
<MenuRadioItem value={option.value} closeOnClick>
<span className="flex min-w-0 items-center gap-2">
<ScopeOptionLabel option={option} />
<MenuRadioItemIndicator />
</span>
</MenuRadioItem>
{index === 0 && allOption ? <MenuSeparator /> : null}
</Fragment>
))}
</MenuRadioGroup>
</div>
</MenuPopup>
</Menu>
);
}
function EnvironmentScopeMenu({
value,
groups,
environments,
onChange,
singleEnvironment,
}: SettingsScopeMenuProps) {
const resolved = resolveSettingsScope(value, groups, environments);
const environmentValue = environmentAxisValue(
value,
resolved.kind === "checkout" ? resolved.environmentId : null,
);
const selected = environments.find(
(environment) => environment.environmentId === environmentValue,
);
const project = groups.find((group) => group.projectKey === value.project);
const memberEnvironmentIds = project
? new Set(project.memberProjects.map((member) => member.environmentId))
: null;
const options = memberEnvironmentIds
? environments.filter((environment) => memberEnvironmentIds.has(environment.environmentId))
: environments;
return (
<ScopeMenu
ariaLabel="Environment scope"
icon={
selected ? (
<EnvironmentMachineIcon
aria-hidden
kind={resolveEnvironmentMachineKind(selected.serverConfig)}
className="size-3.5 shrink-0"
/>
) : null
}
label={
selected
? settingsScopeEnvironmentLabel(selected, environments)
: environmentValue !== ALL_ENVIRONMENTS_VALUE
? "Unavailable environment"
: singleEnvironment
? "No environments"
: "All environments"
}
value={environmentValue}
onChange={(next) => onChange(selectEnvironmentAxis(value, next))}
searchLabel="Search environments"
allOption={
singleEnvironment
? null
: {
value: ALL_ENVIRONMENTS_VALUE,
label: "All environments",
icon: <LayersIcon aria-hidden className="size-3.5 shrink-0" />,
}
}
options={options.map((environment) => {
const { primary, secondary } = settingsScopeEnvironmentLabels(environment, environments);
return {
value: environment.environmentId,
label: primary,
secondary:
environments.length <= 1
? ""
: secondary || settingsScopeEnvironmentAddress(environment),
icon: (
<EnvironmentMachineIcon
aria-hidden
kind={resolveEnvironmentMachineKind(environment.serverConfig)}
className="size-3.5 shrink-0"
/>
),
offline: environment.connection.phase !== "connected",
};
})}
/>
);
}
function ProjectScopeMenu({ value, groups, environments, onChange }: SettingsScopeMenuProps) {
const selected = groups.find((group) => group.projectKey === value.project);
const projects = projectScopeMenuGroups(groups, value).map((group) => ({
group,
machines: settingsScopeProjectMachines(group, environments, true).join(", "),
}));
return (
<ScopeMenu
ariaLabel="Project scope"
icon={selected ? <ProjectFavicon project={selected} className="size-3.5 shrink-0" /> : null}
label={selected?.displayName ?? (value.project ? "Unavailable project" : "All projects")}
value={projectAxisValue(value)}
onChange={(next) => onChange(selectProjectAxis(value, next))}
searchLabel="Search projects"
allOption={{ value: ALL_PROJECTS_VALUE, label: "All projects" }}
options={projects.map(({ group, machines }) => {
const sameName = projects.filter(
(other) =>
other.group.projectKey !== group.projectKey &&
other.group.displayName === group.displayName,
);
const location =
sameName.length === 0
? environments.length > 1
? group.workspaceRoot
: ""
: sameName.some((other) => other.machines === machines)
? `${machines} · ${group.workspaceRoot}`
: machines;
return {
value: group.projectKey,
label: group.displayName,
secondary: group.archived ? ["Archived", location].filter(Boolean).join(" · ") : location,
icon: <ProjectFavicon project={group} className="size-3.5 shrink-0" />,
};
})}
/>
);
}