Files
kandev/apps/web/lib/state/dockview-right-panel-visibility.test.ts
T

592 lines
18 KiB
TypeScript

import { beforeEach, expect, it, vi } from "vitest";
import type { DockviewApi, SerializedDockview } from "dockview-react";
import { removeEnvMaximizeState, setEnvLayout } from "@/lib/local-storage";
const CENTER_COLUMN_ID = "center";
const CENTER_GROUP_ID = "group-center";
const RIGHT_COLUMN_ID = "right";
const RIGHT_GROUP_ID = "group-right-top";
const SESSION_PANEL_ID = "session:session-a";
const PR_DETAILS_PANEL_ID = "pr-detail";
const PR_DETAILS_PANEL_TITLE = "PR Details";
const MOCK_TERMINAL = vi.hoisted(() => ({ id: "terminal-default" }));
vi.mock("@/lib/local-storage", () => ({
setEnvLayout: vi.fn(),
getEnvLayout: vi.fn(() => null),
getEnvLayoutProfile: vi.fn(() => null),
setEnvLayoutProfile: vi.fn(),
getEnvMaximizeState: vi.fn(() => null),
setEnvMaximizeState: vi.fn(),
removeEnvMaximizeState: vi.fn(),
getGlobalSidebarWidth: vi.fn(() => null),
setGlobalSidebarWidth: vi.fn(),
clearGlobalSidebarWidth: vi.fn(),
}));
vi.mock("@/lib/layout/panel-portal-manager", () => ({
panelPortalManager: { releaseByEnv: vi.fn(), reconcile: vi.fn() },
}));
vi.mock("./dockview-scroll-preserve", () => ({
preserveChatScrollDuringLayout: vi.fn(),
}));
vi.mock("./dockview-measure", () => ({
measureDockviewContainer: vi.fn(() => ({ width: 800, height: 600 })),
}));
vi.mock("./dockview-pinned-enforce", () => ({
enforcePinnedTargets: vi.fn(),
}));
vi.mock("./dockview-layout-builders", () => ({
applyLayoutFixups: vi.fn(() => ({
sidebarGroupId: "g-sidebar",
centerGroupId: "g-center",
rightTopGroupId: "g-right-top",
rightBottomGroupId: "g-right-bottom",
})),
focusOrAddPanel: vi.fn(),
}));
vi.mock("./layout-manager", async (importOriginal) => {
const actual = await importOriginal<typeof import("./layout-manager")>();
return {
...actual,
SIDEBAR_GROUP: "sidebar",
CENTER_GROUP: "group-center",
RIGHT_TOP_GROUP: "group-right-top",
RIGHT_BOTTOM_GROUP: "group-right-bottom",
TERMINAL_DEFAULT_ID: MOCK_TERMINAL.id,
LAYOUT_SIDEBAR_RATIO: 0.2,
LAYOUT_RIGHT_RATIO: 0.25,
LAYOUT_PINNED_MIN_PX: 200,
computeSidebarMaxPx: vi.fn(() => 350),
computeRightMaxPx: vi.fn(() => 500),
getPresetLayout: vi.fn(() => ({ columns: [] })),
applyLayout: vi.fn(() => ({
sidebarGroupId: "g-sidebar",
centerGroupId: "g-center",
rightTopGroupId: "g-right-top",
rightBottomGroupId: "g-right-bottom",
})),
getPinnedWidth: vi.fn(() => 350),
getRootSplitview: vi.fn(() => null),
fromDockviewApi: vi.fn(() => ({ columns: [] })),
filterEphemeral: vi.fn((state: unknown) => state),
defaultLayout: vi.fn(() => ({ columns: [] })),
mergeCurrentPanelsIntoPreset: vi.fn((_api: unknown, preset: unknown) => preset),
toSerializedDockview: vi.fn((state: unknown) => state),
injectIntentPanels: vi.fn(),
applyActivePanelOverrides: vi.fn(),
resolveNamedIntent: vi.fn(),
setPinnedTarget: vi.fn(),
clearPinnedTarget: vi.fn(),
getPinnedTarget: vi.fn(() => undefined),
layoutStructuresMatch: vi.fn(() => false),
savedLayoutMatchesLive: vi.fn(() => false),
};
});
import { applyLayout, defaultLayout, fromDockviewApi } from "./layout-manager";
import { captureRightPane } from "./dockview-right-pane";
import { hasRightColumn, useDockviewStore } from "./dockview-store";
function makeStoreApi(): DockviewApi {
return {
width: 800,
height: 600,
panels: [],
groups: [],
layout: vi.fn(),
fromJSON: vi.fn(),
toJSON: vi.fn(() => ({ columns: [{ id: CENTER_COLUMN_ID }] })),
getPanel: vi.fn(() => null),
addPanel: vi.fn(),
activeGroup: null,
hasMaximizedGroup: vi.fn(() => false),
exitMaximizedGroup: vi.fn(),
onDidActivePanelChange: vi.fn(() => ({ dispose: vi.fn() })),
} as unknown as DockviewApi;
}
function flushRaf(): Promise<void> {
return new Promise((resolve) => requestAnimationFrame(() => resolve()));
}
function resetStore() {
vi.clearAllMocks();
useDockviewStore.setState({
api: null,
currentLayoutEnvId: null,
preMaximizeLayout: null,
maximizedGroupId: null,
isRestoringLayout: false,
pinnedWidths: new Map(),
userDefaultLayout: null,
userDefaultLayoutProfile: { kind: "built-in", id: "default" },
activeLayoutProfile: { kind: "built-in", id: "default" },
defaultPreset: "default",
rightPanelsVisible: true,
rightPaneVisible: true,
rightPaneAvailable: false,
hiddenRightPane: null,
});
}
beforeEach(resetStore);
it("hides the actual rightmost Plan region instead of rebuilding the default sidebar", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: "plan",
groups: [{ id: "group-plan", panels: [{ id: "plan", component: "plan", title: "Plan" }] }],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: true, defaultPreset: "plan" });
useDockviewStore.getState().toggleRightPanels();
const appliedState = vi.mocked(applyLayout).mock.calls.at(-1)?.[1];
expect(appliedState?.columns.map((column) => column.id)).toEqual([CENTER_COLUMN_ID]);
await flushRaf();
});
it("retains the hidden pane when applying a toggle layout fails", () => {
const api = makeStoreApi();
const originalDockview = {
grid: { root: { type: "branch", data: ["agent", "plan"], size: 600 } },
panels: { [SESSION_PANEL_ID]: { id: SESSION_PANEL_ID, contentComponent: "chat" } },
} as unknown as SerializedDockview;
let liveDockview: SerializedDockview = originalDockview;
let fromJsonCalls = 0;
vi.mocked(api.toJSON).mockImplementation(() => liveDockview);
vi.mocked(api.fromJSON).mockImplementation((next) => {
liveDockview = next;
if (fromJsonCalls++ === 0) throw new Error("Dockview rejected the new layout");
});
const fullLayout = {
rootOrientation: "HORIZONTAL" as const,
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: "plan",
groups: [{ id: "group-plan", panels: [{ id: "plan", component: "plan", title: "Plan" }] }],
},
],
};
const captured = captureRightPane(fullLayout)!;
vi.mocked(fromDockviewApi).mockReturnValue(captured.layout);
vi.mocked(applyLayout).mockImplementationOnce((dockviewApi) => {
dockviewApi.fromJSON({ grid: { root: { type: "branch", data: [] } }, panels: {} } as never);
throw new Error("layout failed");
});
useDockviewStore.setState({
api,
hiddenRightPane: captured.hiddenRightPane,
rightPaneVisible: false,
rightPaneAvailable: true,
});
useDockviewStore.getState().toggleRightPanels();
expect(useDockviewStore.getState().hiddenRightPane).toEqual(captured.hiddenRightPane);
expect(useDockviewStore.getState().rightPaneVisible).toBe(false);
expect(useDockviewStore.getState().rightPaneAvailable).toBe(true);
expect(useDockviewStore.getState().isRestoringLayout).toBe(false);
expect(api.fromJSON).toHaveBeenCalledTimes(2);
expect(api.fromJSON).toHaveBeenLastCalledWith(originalDockview);
expect(liveDockview).toBe(originalDockview);
expect(setEnvLayout).not.toHaveBeenCalled();
});
it("recognizes the right column from its stable column or group identity", () => {
expect(
hasRightColumn({
columns: [
{ id: CENTER_COLUMN_ID, groups: [{ id: CENTER_GROUP_ID, panels: [] }] },
{ id: RIGHT_COLUMN_ID, groups: [] },
],
}),
).toBe(true);
expect(
hasRightColumn({
columns: [{ id: "custom-column", groups: [{ id: RIGHT_GROUP_ID, panels: [] }] }],
}),
).toBe(true);
expect(
hasRightColumn({
columns: [{ id: CENTER_COLUMN_ID, groups: [{ id: CENTER_GROUP_ID, panels: [] }] }],
}),
).toBe(false);
});
it("does not fabricate a right column when the layout has one workbench region", async () => {
const api = makeStoreApi();
vi.mocked(defaultLayout).mockReturnValue({
columns: [
{
id: RIGHT_COLUMN_ID,
pinned: true,
groups: [
{
id: RIGHT_GROUP_ID,
panels: [
{ id: "files", component: "files", title: "Files" },
{ id: "changes", component: "changes", title: "Changes" },
],
},
{
id: "group-right-bottom",
panels: [{ id: MOCK_TERMINAL.id, component: "terminal", title: "Terminal" }],
},
],
},
],
});
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [
{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" },
{ id: "browser", component: "browser", title: "Browser" },
{
id: PR_DETAILS_PANEL_ID,
component: PR_DETAILS_PANEL_ID,
title: PR_DETAILS_PANEL_TITLE,
},
{ id: "files", component: "files", title: "Files" },
{ id: "changes", component: "changes", title: "Changes" },
{ id: MOCK_TERMINAL.id, component: "terminal", title: "Terminal" },
],
},
],
},
],
});
useDockviewStore.setState({
api,
rightPanelsVisible: false,
defaultPreset: "compact",
activeLayoutProfile: { kind: "built-in", id: "compact" },
});
useDockviewStore.getState().toggleRightPanels();
expect(applyLayout).not.toHaveBeenCalled();
expect(defaultLayout).not.toHaveBeenCalled();
expect(useDockviewStore.getState().rightPaneAvailable).toBe(false);
await flushRaf();
});
it("does not mutate the temporary maximized layout", () => {
const api = makeStoreApi();
useDockviewStore.setState({
api,
rightPanelsVisible: true,
preMaximizeLayout: {
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: RIGHT_COLUMN_ID,
groups: [
{ id: RIGHT_GROUP_ID, panels: [{ id: "files", component: "files", title: "Files" }] },
],
},
],
},
});
useDockviewStore.getState().toggleRightPanels();
expect(applyLayout).not.toHaveBeenCalled();
expect(api.layout).not.toHaveBeenCalled();
expect(useDockviewStore.getState().rightPanelsVisible).toBe(true);
});
it("keeps visibility coherent through maximize, exit, and regular-layout persistence", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: RIGHT_COLUMN_ID,
groups: [
{ id: RIGHT_GROUP_ID, panels: [{ id: "files", component: "files", title: "Files" }] },
],
},
],
});
useDockviewStore.setState({
api,
currentLayoutEnvId: "env-maximize",
rightPanelsVisible: false,
});
useDockviewStore.getState().maximizeGroup(CENTER_GROUP_ID);
expect(useDockviewStore.getState().preMaximizeLayout).not.toBeNull();
expect(useDockviewStore.getState().rightPanelsVisible).toBe(true);
await flushRaf();
useDockviewStore.getState().exitMaximizedLayout();
expect(useDockviewStore.getState().preMaximizeLayout).toBeNull();
expect(useDockviewStore.getState().rightPanelsVisible).toBe(true);
await flushRaf();
expect(removeEnvMaximizeState).toHaveBeenCalledWith("env-maximize");
expect(setEnvLayout).toHaveBeenCalledWith("env-maximize", expect.anything());
});
it("preserves right-named panels that belong to a mixed center column", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [
{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" },
{ id: "files", component: "files", title: "Files" },
{
id: PR_DETAILS_PANEL_ID,
component: PR_DETAILS_PANEL_ID,
title: PR_DETAILS_PANEL_TITLE,
},
],
},
],
},
{
id: RIGHT_COLUMN_ID,
groups: [
{
id: RIGHT_GROUP_ID,
panels: [{ id: "terminal", component: "terminal", title: "Terminal" }],
},
],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: true, defaultPreset: "default" });
useDockviewStore.getState().toggleRightPanels();
const appliedState = vi.mocked(applyLayout).mock.calls.at(-1)?.[1];
expect(appliedState?.columns.map((column) => column.id)).toEqual([CENTER_COLUMN_ID]);
expect(appliedState?.columns[0]?.groups[0]?.panels.map((panel) => panel.id)).toEqual([
SESSION_PANEL_ID,
"files",
PR_DETAILS_PANEL_ID,
]);
await flushRaf();
});
it("removes an identified right column even when it contains a custom panel", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: RIGHT_COLUMN_ID,
groups: [
{ id: RIGHT_GROUP_ID, panels: [{ id: "plugin", component: "plugin", title: "Plugin" }] },
],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: true, defaultPreset: "default" });
useDockviewStore.getState().toggleRightPanels();
const appliedState = vi.mocked(applyLayout).mock.calls.at(-1)?.[1];
expect(appliedState?.columns.map((column) => column.id)).toEqual([CENTER_COLUMN_ID]);
await flushRaf();
});
it("does not restore a fabricated right column when only the center remains", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [
{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" },
{ id: "files", component: "files", title: "Files" },
],
},
],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: false, defaultPreset: "default" });
useDockviewStore.getState().toggleRightPanels();
expect(applyLayout).not.toHaveBeenCalled();
expect(defaultLayout).not.toHaveBeenCalled();
expect(useDockviewStore.getState().rightPaneAvailable).toBe(false);
await flushRaf();
});
it("keeps a center fallback PR Details tab when hiding right panels", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [
{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" },
{
id: PR_DETAILS_PANEL_ID,
component: PR_DETAILS_PANEL_ID,
title: PR_DETAILS_PANEL_TITLE,
},
],
},
],
},
{
id: RIGHT_COLUMN_ID,
pinned: true,
groups: [
{ id: RIGHT_GROUP_ID, panels: [{ id: "files", component: "files", title: "Files" }] },
],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: true, defaultPreset: "default" });
useDockviewStore.getState().toggleRightPanels();
const appliedState = vi.mocked(applyLayout).mock.calls.at(-1)?.[1];
expect(appliedState?.columns.map((column) => column.id)).toEqual([CENTER_COLUMN_ID]);
expect(appliedState?.columns[0]?.groups[0]?.panels.map((panel) => panel.id)).toEqual([
SESSION_PANEL_ID,
PR_DETAILS_PANEL_ID,
]);
await flushRaf();
});
it("does not show a default sidebar when showing from a single workbench region", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [
{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" },
{
id: PR_DETAILS_PANEL_ID,
component: PR_DETAILS_PANEL_ID,
title: PR_DETAILS_PANEL_TITLE,
},
],
},
],
},
],
});
useDockviewStore.setState({ api, rightPanelsVisible: false, defaultPreset: "default" });
useDockviewStore.getState().toggleRightPanels();
expect(applyLayout).not.toHaveBeenCalled();
expect(defaultLayout).not.toHaveBeenCalled();
expect(useDockviewStore.getState().rightPaneAvailable).toBe(false);
await flushRaf();
});
it("persists a settled visibility toggle for the current environment", async () => {
const api = makeStoreApi();
vi.mocked(fromDockviewApi).mockReturnValue({
columns: [
{
id: CENTER_COLUMN_ID,
groups: [
{
id: CENTER_GROUP_ID,
panels: [{ id: SESSION_PANEL_ID, component: "chat", title: "Agent" }],
},
],
},
{
id: RIGHT_COLUMN_ID,
groups: [
{ id: RIGHT_GROUP_ID, panels: [{ id: "files", component: "files", title: "Files" }] },
],
},
],
});
useDockviewStore.setState({
api,
currentLayoutEnvId: "env-1",
rightPanelsVisible: true,
defaultPreset: "default",
});
useDockviewStore.getState().toggleRightPanels();
await flushRaf();
expect(setEnvLayout).toHaveBeenCalledWith("env-1", expect.anything());
});