Skip to content

Commit 69eb05f

Browse files
committed
feat(web): simplify the window project chooser
Fork-Domain: workspaces Fork-Tier: qol
1 parent 486b691 commit 69eb05f

16 files changed

Lines changed: 251 additions & 120 deletions

‎apps/web/src/components/CommandPalette.fork.tsx‎

Lines changed: 16 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,8 @@ export function buildProjectChooserActionItemFork(
108108
const NEW_THREAD_IN_VIEW = "projects";
109109

110110
export interface CommandPaletteProjectScope {
111+
/** Explicit inclusion can intentionally show no projects. */
112+
readonly preserveEmpty?: boolean;
111113
/** The project keys the palette shows; `null` shows every project. */
112114
readonly projectKeys: ReadonlySet<string> | null;
113115
/** The toggle between the filter and every project; `null` when unscoped. */
@@ -153,8 +155,12 @@ export function useCommandPaletteProjectScopeFork(): CommandPaletteProjectScope
153155
keepOpen: true,
154156
run: async () => setSearchAll(true),
155157
};
156-
return { projectKeys: searchAll ? null : filterKeys, toggle };
157-
}, [filterKeys, label, searchAll]);
158+
return {
159+
projectKeys: searchAll ? null : filterKeys,
160+
toggle,
161+
preserveEmpty: filter?.mode === "include",
162+
};
163+
}, [filterKeys, label, searchAll, filter?.mode]);
158164
}
159165

160166
/**
@@ -206,17 +212,20 @@ export function useScopedPaletteThreadsFork<
206212
}
207213

208214
/**
209-
* The palette's project picker entries under the scope. A scope that leaves no
210-
* entry (its projects not loaded yet) shows every project, so the picker is
211-
* never empty.
215+
* Explicit inclusion keeps an empty picker empty. Legacy/exclusion filters
216+
* retain the existing fallback when none of their projects are available.
212217
*/
213218
export function scopePaletteProjectEntriesFork<
214219
Entry extends { readonly group: { readonly memberProjectRefs: ReadonlyArray<ScopedProjectRef> } },
215-
>(entries: ReadonlyArray<Entry>, projectKeys: ReadonlySet<string> | null): ReadonlyArray<Entry> {
220+
>(
221+
entries: ReadonlyArray<Entry>,
222+
projectKeys: ReadonlySet<string> | null,
223+
preserveEmpty = false,
224+
): ReadonlyArray<Entry> {
216225
const scoped = scopeToProjectKeys(entries, projectKeys, (entry) =>
217226
entry.group.memberProjectRefs.map((ref) => `${ref.environmentId}:${ref.projectId}`),
218227
);
219-
return scoped.length > 0 ? scoped : entries;
228+
return scoped.length === 0 && !preserveEmpty ? entries : scoped;
220229
}
221230

222231
/**

‎apps/web/src/components/CommandPalette.logic.fork.test.ts‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,15 @@ describe("palette project scope", () => {
6969
expect(scopePaletteProjectEntriesFork(entries, null)).toBe(entries);
7070
});
7171

72+
it("explicit inclusion keeps No projects empty, with Search all as the escape", () => {
73+
const entries = [entryOf("api"), entryOf("web")];
74+
expect(scopePaletteProjectEntriesFork(entries, new Set(), true)).toEqual([]);
75+
expect(scopePaletteProjectEntriesFork(entries, new Set(["local:gone"]), true)).toEqual([]);
76+
expect(scopePaletteProjectEntriesFork(entries, null, true)).toBe(entries);
77+
// Preserve the known parent all-excluded picker fallback.
78+
expect(scopePaletteProjectEntriesFork(entries, new Set())).toBe(entries);
79+
});
80+
7281
it("Search all: the pushed new-thread picker follows the scope, keeping its lead first", () => {
7382
const pushed = [{ value: "projects", label: "Projects", items: [item("b"), item("a")] }];
7483
const refreshed = refreshNewThreadInViewFork(pushed, [item("a"), item("b"), item("c")]);

‎apps/web/src/components/CommandPalette.tsx‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1003,13 +1003,15 @@ function OpenCommandPaletteDialog(props: {
10031003
);
10041004
const pickerProjects = useMemo(
10051005
() =>
1006-
scopePaletteProjectEntriesFork(projectPickerEntries, paletteProjectScope.projectKeys).map(
1007-
({ group, targetProject }) => ({
1008-
...targetProject,
1009-
displayName: group.displayName,
1010-
}),
1011-
), // fork-hook: workspaces/palette-scope-projects
1012-
[projectPickerEntries, paletteProjectScope.projectKeys], // fork-hook: workspaces/palette-scope-projects
1006+
scopePaletteProjectEntriesFork(
1007+
projectPickerEntries,
1008+
paletteProjectScope.projectKeys,
1009+
paletteProjectScope.preserveEmpty,
1010+
).map(({ group, targetProject }) => ({
1011+
...targetProject,
1012+
displayName: group.displayName,
1013+
})), // fork-hook: workspaces/palette-scope-projects
1014+
[projectPickerEntries, paletteProjectScope.projectKeys, paletteProjectScope.preserveEmpty], // fork-hook: workspaces/palette-scope-projects
10131015
);
10141016
const projectGroupByTargetKey = useMemo(
10151017
() =>

‎apps/web/src/components/Sidebar.tsx‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5276,12 +5276,6 @@ export default function Sidebar() {
52765276
anchor={headerSearchRef}
52775277
className="max-w-[min(18rem,var(--available-width))] overflow-hidden"
52785278
>
5279-
{/* fork-hook: workspaces/chooser-mode */}
5280-
<ProjectChooserModeFork
5281-
filter={windowFilter.filter}
5282-
setFilter={windowFilter.setFilter}
5283-
/>
5284-
{/* fork-hook-end */}
52855279
<ComboboxSearchInput
52865280
aria-label="Search projects"
52875281
placeholder="Search projects..."
@@ -5337,6 +5331,14 @@ export default function Sidebar() {
53375331
<FolderIcon className="size-4 shrink-0" />
53385332
)}
53395333
<span className="min-w-0 flex-1 truncate text-sm">{item.label}</span>
5334+
{/* fork-hook: workspaces/chooser-mode */}
5335+
{item.value === "all" ? (
5336+
<ProjectChooserModeFork
5337+
filter={windowFilter.filter}
5338+
setFilter={windowFilter.setFilter}
5339+
/>
5340+
) : null}
5341+
{/* fork-hook-end */}
53405342
{/* fork-hook: workspaces/chooser-row-unavailable */}
53415343
<ProjectChooserUnavailableFork
53425344
unavailable={projectChooser.unavailableValues.has(item.value)}

‎apps/web/src/components/sidebar/SidebarProjectChooser.fork.tsx‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,18 @@ import { useCallback, useMemo, useRef, type MouseEvent as ReactMouseEvent } from
99
import { cn } from "~/lib/utils";
1010
import {
1111
projectChooserState,
12+
projectChooserMode,
13+
projectFilterFromMode,
1214
projectFilterFromChooser,
1315
showOnlyProjectFilter,
1416
useProjectChooserHost,
1517
type ProjectChooserGroup,
1618
type ProjectChooserItem,
1719
} from "../../projectChooser.fork";
1820
import { Button } from "../ui/button";
21+
import { Label } from "../ui/label";
1922
import { useSidebar } from "../ui/sidebar";
20-
import { Toggle, ToggleGroup } from "../ui/toggle-group";
23+
import { Switch } from "../ui/switch";
2124

2225
export function useSidebarProjectChooserFork<Group extends ProjectChooserGroup>(input: {
2326
readonly filter: ProjectFilter;
@@ -99,34 +102,31 @@ export function ProjectChooserRowMarkFork({
99102
return <Icon aria-hidden className={cn("size-3.5 shrink-0", selected ? null : "invisible")} />;
100103
}
101104

102-
/** Switching modes keeps the picks; their meaning changes explicitly, not via a modifier key. */
105+
/** The All projects row's exclusion switch changes the picks' meaning without resetting them. */
103106
export function ProjectChooserModeFork({
104107
filter,
105108
setFilter,
106109
}: {
107110
readonly filter: ProjectFilter;
108111
readonly setFilter: (filter: ProjectFilter) => void;
109112
}) {
110-
const mode = filter.mode ?? "include";
113+
const mode = projectChooserMode(filter);
111114
return (
112-
<div className="flex flex-col gap-2 px-2 pt-2 pb-1">
113-
<ToggleGroup
114-
aria-label="Project filter mode"
115-
value={[mode]}
116-
onValueChange={(values) => {
117-
const next = values[0];
118-
if (next === "include" || next === "exclude") setFilter({ ...filter, mode: next });
119-
}}
120-
>
121-
<Toggle value="include">Only selected</Toggle>
122-
<Toggle value="exclude">All except selected</Toggle>
123-
</ToggleGroup>
124-
<p className="text-xs text-muted-foreground">
125-
{mode === "exclude"
126-
? "Select projects to hide. New projects stay visible."
127-
: "Select projects to show. No selection shows all."}
128-
</p>
129-
</div>
115+
<Label
116+
className="shrink-0"
117+
onPointerDown={(event) => event.stopPropagation()}
118+
onClick={(event) => event.stopPropagation()}
119+
onKeyDown={(event) => event.stopPropagation()}
120+
onFocus={(event) => event.stopPropagation()}
121+
>
122+
Exclude
123+
<Switch
124+
checked={mode === "exclude"}
125+
onCheckedChange={(checked) =>
126+
setFilter(projectFilterFromMode(filter, checked ? "exclude" : "include"))
127+
}
128+
/>
129+
</Label>
130130
);
131131
}
132132

‎apps/web/src/projectChooser.fork.test.ts‎

Lines changed: 60 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,8 @@ import { EnvironmentId, ProjectId, type ScopedProjectRef } from "@t3tools/contra
66
import { describe, expect, it } from "vite-plus/test";
77

88
import {
9-
ALL_PROJECTS_CHOOSER_VALUE,
9+
projectChooserMode,
10+
projectFilterFromMode,
1011
projectChooserState,
1112
projectFilterFromChooser,
1213
showOnlyProjectFilter,
@@ -30,6 +31,7 @@ const web = {
3031
const groups = [api, web];
3132

3233
const filterOf = (...selected: Array<typeof api>): ProjectFilter => ({
34+
mode: "include",
3335
entries: selected.map((group) => ({ key: group.projectKey, members: group.memberProjectRefs })),
3436
});
3537
const values = (filter: ProjectFilter) =>
@@ -48,31 +50,48 @@ describe("project chooser", () => {
4850
mode: "exclude",
4951
});
5052
expect(projectFilterFromChooser(filter, [], groups)).toEqual({ entries: [], mode: "exclude" });
51-
expect(
52-
projectFilterFromChooser(filter, [web.projectKey, ALL_PROJECTS_CHOOSER_VALUE], groups),
53-
).toEqual({ entries: [], mode: "exclude" });
5453
expect(showOnlyProjectFilter(api)).toEqual(filterOf(api));
5554
});
5655

5756
it("exclusion can pick its first hidden project from an empty selection", () => {
5857
const empty: ProjectFilter = { mode: "exclude", entries: [] };
5958
expect(projectChooserState(empty, groups).label).toBe("Projects: All");
60-
expect(
61-
projectFilterFromChooser(empty, [ALL_PROJECTS_CHOOSER_VALUE, web.projectKey], groups),
62-
).toEqual({ ...filterOf(web), mode: "exclude" });
59+
expect(projectFilterFromChooser(empty, [web.projectKey], groups)).toEqual({
60+
...filterOf(web),
61+
mode: "exclude",
62+
});
6363
});
6464

65-
it("Empty: an empty filter selects All projects and reads Projects: All", () => {
65+
it("All heads the list and is selected without counting as a project pick", () => {
6666
const state = projectChooserState(ALL_PROJECTS_FILTER, groups);
67-
expect(state.value.map((item) => item.value)).toEqual([ALL_PROJECTS_CHOOSER_VALUE]);
67+
expect(state.value.map((item) => item.value)).toEqual(["all"]);
6868
expect(state.label).toBe("Projects: All");
6969
expect(state.count).toBe(0);
7070
expect(state.single).toBeNull();
71-
expect(state.items.map((item) => item.value)).toEqual([
72-
ALL_PROJECTS_CHOOSER_VALUE,
73-
api.projectKey,
74-
web.projectKey,
75-
]);
71+
expect(state.items.map((item) => item.value)).toEqual(["all", api.projectKey, web.projectKey]);
72+
});
73+
74+
it("All resets picks, while picking a project from All drops its sentinel", () => {
75+
expect(projectFilterFromChooser(filterOf(api), [api.projectKey, "all"], groups)).toBe(
76+
ALL_PROJECTS_FILTER,
77+
);
78+
expect(
79+
projectFilterFromChooser(
80+
{ ...filterOf(web), mode: "exclude" },
81+
[web.projectKey, "all"],
82+
groups,
83+
),
84+
).toBe(ALL_PROJECTS_FILTER);
85+
expect(projectFilterFromChooser(ALL_PROJECTS_FILTER, ["all", api.projectKey], groups)).toEqual(
86+
filterOf(api),
87+
);
88+
const excluding: ProjectFilter = { mode: "exclude", entries: [] };
89+
expect(projectFilterFromChooser(excluding, ["all", web.projectKey], groups)).toEqual({
90+
...filterOf(web),
91+
mode: "exclude",
92+
});
93+
expect(projectFilterFromChooser(excluding, [], groups)).toBe(ALL_PROJECTS_FILTER);
94+
expect(projectFilterFromChooser(ALL_PROJECTS_FILTER, [], groups)).toBe(ALL_PROJECTS_FILTER);
7695
});
7796

7897
it("Label: one entry shows its name, several show a count", () => {
@@ -108,24 +127,36 @@ describe("project chooser", () => {
108127
const removed = projectFilterFromChooser(added, [web.projectKey], groups);
109128
expect(removed).toEqual(filterOf(web));
110129

111-
// From All projects, the combobox reports All beside the new pick.
112-
const fromAll = projectFilterFromChooser(
113-
ALL_PROJECTS_FILTER,
114-
[ALL_PROJECTS_CHOOSER_VALUE, api.projectKey],
115-
groups,
116-
);
130+
const fromAll = projectFilterFromChooser(ALL_PROJECTS_FILTER, [api.projectKey], groups);
117131
expect(fromAll).toEqual(filterOf(api));
118132
});
119133

120-
it("Toggle: All projects clears the filter, and unpicking the last entry returns to all", () => {
121-
expect(
122-
projectFilterFromChooser(
123-
filterOf(api, web),
124-
[api.projectKey, web.projectKey, ALL_PROJECTS_CHOOSER_VALUE],
125-
groups,
126-
),
127-
).toBe(ALL_PROJECTS_FILTER);
128-
expect(projectFilterFromChooser(filterOf(api), [], groups)).toBe(ALL_PROJECTS_FILTER);
134+
it("unselecting the last project shows none until All resets the filter", () => {
135+
const none = projectFilterFromChooser(filterOf(api), [], groups);
136+
expect(none).toEqual({ mode: "include", entries: [] });
137+
expect(projectChooserState(none, groups)).toMatchObject({
138+
label: "Projects: None",
139+
titleLabel: "No projects",
140+
value: [],
141+
single: null,
142+
});
143+
expect(projectFilterFromMode(none, "all")).toBe(ALL_PROJECTS_FILTER);
144+
expect(projectFilterFromMode(filterOf(api, web), "all")).toBe(ALL_PROJECTS_FILTER);
145+
});
146+
147+
it("mode switches preserve picks, including empty selections and legacy filters", () => {
148+
expect(projectChooserMode(ALL_PROJECTS_FILTER)).toBe("all");
149+
expect(projectChooserMode({ entries: filterOf(api).entries })).toBe("include");
150+
const excluded = projectFilterFromMode(filterOf(api, web), "exclude");
151+
expect(projectChooserMode(excluded)).toBe("exclude");
152+
expect(excluded.entries).toEqual(filterOf(api, web).entries);
153+
expect(projectFilterFromMode(excluded, "include")).toEqual(filterOf(api, web));
154+
const none = projectFilterFromMode(ALL_PROJECTS_FILTER, "include");
155+
expect(projectChooserMode(none)).toBe("include");
156+
expect(projectChooserState(none, groups).label).toBe("Projects: None");
157+
const allExceptNone = projectFilterFromMode(none, "exclude");
158+
expect(projectChooserState(allExceptNone, groups).label).toBe("Projects: All");
159+
expect(projectChooserMode(allExceptNone)).toBe("exclude");
129160
});
130161

131162
it("Offline: an entry no group carries stays selected and is marked unavailable", () => {

0 commit comments

Comments
 (0)