Skip to content

Commit 525c89f

Browse files
committed
fix(web): unify panel resizing and retain final drag width
1 parent 3138f57 commit 525c89f

4 files changed

Lines changed: 243 additions & 310 deletions

File tree

‎apps/web/src/components/ui/sidebar.tsx‎

Lines changed: 73 additions & 183 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ import {
1717
} from "~/components/ui/sheet";
1818
import { Skeleton } from "~/components/ui/skeleton";
1919
import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
20+
import { useResizeDrag } from "~/hooks/useResizeDrag";
2021
import { useIsMobile } from "~/hooks/useMediaQuery";
2122
import { getLocalStorageItem, setLocalStorageItem } from "~/hooks/useLocalStorage";
2223
import { resolveSidebarState, type ResponsiveSidebarState } from "./sidebarState";
@@ -353,6 +354,7 @@ function SidebarRail({
353354
className,
354355
onClick,
355356
onPointerCancel,
357+
onLostPointerCapture,
356358
onPointerDown,
357359
onPointerMove,
358360
onPointerUp,
@@ -362,182 +364,68 @@ function SidebarRail({
362364
const sidebarInstance = React.use(SidebarInstanceContext);
363365
const railRef = React.useRef<HTMLButtonElement | null>(null);
364366
const suppressClickRef = React.useRef(false);
365-
const resizeStateRef = React.useRef<{
366-
moved: boolean;
367-
pointerId: number;
368-
pendingWidth: number;
369-
rail: HTMLButtonElement;
370-
rafId: number | null;
371-
sidebarRoot: HTMLElement;
372-
side: "left" | "right";
373-
startWidth: number;
374-
startX: number;
375-
transitionTargets: HTMLElement[];
376-
width: number;
377-
wrapper: HTMLElement;
378-
} | null>(null);
379367
const resolvedResizable = sidebarInstance?.resizable ?? null;
380368
const canResize = resolvedResizable !== null && open;
381369
const railLabel = canResize ? "Resize Sidebar" : "Toggle Sidebar";
382370
const railTitle = canResize ? "Drag to resize sidebar" : "Toggle Sidebar";
371+
const resize = useResizeDrag<HTMLButtonElement>((event) => {
372+
if (!resolvedResizable || !open) return null;
373+
const rail = event.currentTarget;
374+
const wrapper = rail.closest<HTMLElement>("[data-slot='sidebar-wrapper']");
375+
const sidebarRoot = rail.closest<HTMLElement>("[data-slot='sidebar']");
376+
const sidebarContainer = sidebarRoot?.querySelector<HTMLElement>(
377+
"[data-slot='sidebar-container']",
378+
);
379+
if (!wrapper || !sidebarRoot || !sidebarContainer) return null;
383380

384-
const stopResize = React.useCallback(
385-
(pointerId: number) => {
386-
const resizeState = resizeStateRef.current;
387-
if (!resizeState) {
388-
return;
389-
}
390-
if (resizeState.rafId !== null) {
391-
window.cancelAnimationFrame(resizeState.rafId);
392-
}
393-
resizeState.transitionTargets.forEach((element) => {
394-
element.style.removeProperty("transition-duration");
395-
});
396-
if (resolvedResizable?.storageKey && typeof window !== "undefined") {
397-
setLocalStorageItem(resolvedResizable.storageKey, resizeState.width, Schema.Finite);
398-
}
399-
resolvedResizable?.onResize?.(resizeState.width);
400-
resizeStateRef.current = null;
401-
if (resizeState.rail.hasPointerCapture(pointerId)) {
402-
resizeState.rail.releasePointerCapture(pointerId);
403-
}
404-
document.body.style.removeProperty("cursor");
405-
document.body.style.removeProperty("user-select");
406-
},
407-
[resolvedResizable],
408-
);
409-
410-
const handlePointerDown = React.useCallback(
411-
(event: React.PointerEvent<HTMLButtonElement>) => {
412-
onPointerDown?.(event);
413-
if (event.defaultPrevented) return;
414-
if (!resolvedResizable || !open || event.button !== 0) return;
415-
416-
const wrapper = event.currentTarget.closest<HTMLElement>("[data-slot='sidebar-wrapper']");
417-
const sidebarRoot = event.currentTarget.closest<HTMLElement>("[data-slot='sidebar']");
418-
if (!wrapper || !sidebarRoot) {
419-
return;
420-
}
421-
422-
const sidebarContainer = sidebarRoot.querySelector<HTMLElement>(
423-
"[data-slot='sidebar-container']",
424-
);
425-
if (!sidebarContainer) {
426-
return;
427-
}
428-
429-
const startWidth = sidebarContainer.getBoundingClientRect().width;
430-
const initialWidth = clampSidebarWidth(startWidth, resolvedResizable);
431-
const transitionTargets = [
432-
sidebarRoot.querySelector<HTMLElement>("[data-slot='sidebar-gap']"),
433-
sidebarRoot.querySelector<HTMLElement>("[data-slot='sidebar-container']"),
434-
].filter((element): element is HTMLElement => element !== null);
435-
transitionTargets.forEach((element) => {
436-
element.style.setProperty("transition-duration", "0ms");
437-
});
438-
439-
event.preventDefault();
440-
event.stopPropagation();
441-
resizeStateRef.current = {
442-
moved: false,
443-
pointerId: event.pointerId,
444-
pendingWidth: initialWidth,
445-
rail: event.currentTarget,
446-
rafId: null,
447-
sidebarRoot,
448-
side: sidebarInstance?.side ?? "left",
449-
startWidth: initialWidth,
450-
startX: event.clientX,
451-
transitionTargets,
452-
width: initialWidth,
453-
wrapper,
454-
};
455-
wrapper.style.setProperty("--sidebar-width", `${initialWidth}px`);
456-
event.currentTarget.setPointerCapture(event.pointerId);
457-
document.body.style.cursor = "col-resize";
458-
document.body.style.userSelect = "none";
459-
},
460-
[onPointerDown, open, resolvedResizable, sidebarInstance?.side],
461-
);
462-
463-
const handlePointerMove = React.useCallback(
464-
(event: React.PointerEvent<HTMLButtonElement>) => {
465-
onPointerMove?.(event);
466-
if (event.defaultPrevented) return;
467-
const resizeState = resizeStateRef.current;
468-
if (!resizeState || resizeState.pointerId !== event.pointerId || !resolvedResizable) return;
469-
470-
event.preventDefault();
471-
const delta =
472-
resizeState.side === "right"
473-
? resizeState.startX - event.clientX
474-
: event.clientX - resizeState.startX;
475-
if (Math.abs(delta) > 2) {
476-
resizeState.moved = true;
477-
}
478-
resizeState.pendingWidth = clampSidebarWidth(
479-
resizeState.startWidth + delta,
480-
resolvedResizable,
481-
);
482-
if (resizeState.rafId !== null) {
483-
return;
484-
}
485-
486-
resizeState.rafId = window.requestAnimationFrame(() => {
487-
const activeResizeState = resizeStateRef.current;
488-
if (!activeResizeState || !resolvedResizable) return;
381+
const side = sidebarInstance?.side ?? "left";
382+
let width = clampSidebarWidth(
383+
sidebarContainer.getBoundingClientRect().width,
384+
resolvedResizable,
385+
);
386+
const transitionTargets = [
387+
sidebarRoot.querySelector<HTMLElement>("[data-slot='sidebar-gap']"),
388+
sidebarContainer,
389+
].filter((element): element is HTMLElement => element !== null);
390+
transitionTargets.forEach((element) => {
391+
element.style.setProperty("transition-duration", "0ms");
392+
});
393+
wrapper.style.setProperty("--sidebar-width", `${width}px`);
489394

490-
activeResizeState.rafId = null;
491-
const nextWidth = activeResizeState.pendingWidth;
395+
return {
396+
width,
397+
edge: side === "left" ? "right" : "left",
398+
resize(value) {
399+
const nextWidth = clampSidebarWidth(value, resolvedResizable);
492400
const accepted =
493401
resolvedResizable.shouldAcceptWidth?.({
494-
currentWidth: activeResizeState.width,
402+
currentWidth: width,
495403
nextWidth,
496-
rail: activeResizeState.rail,
497-
side: activeResizeState.side,
498-
sidebarRoot: activeResizeState.sidebarRoot,
499-
wrapper: activeResizeState.wrapper,
404+
rail,
405+
side,
406+
sidebarRoot,
407+
wrapper,
500408
}) ?? true;
501-
if (!accepted) {
502-
return;
409+
if (accepted) {
410+
wrapper.style.setProperty("--sidebar-width", `${nextWidth}px`);
411+
width = nextWidth;
503412
}
504-
505-
activeResizeState.wrapper.style.setProperty("--sidebar-width", `${nextWidth}px`);
506-
activeResizeState.width = nextWidth;
507-
});
508-
},
509-
[onPointerMove, resolvedResizable],
510-
);
511-
512-
const endResizeInteraction = React.useCallback(
513-
(event: React.PointerEvent<HTMLButtonElement>) => {
514-
const resizeState = resizeStateRef.current;
515-
if (!resizeState || resizeState.pointerId !== event.pointerId) return;
516-
517-
event.preventDefault();
518-
suppressClickRef.current = resizeState.moved;
519-
stopResize(event.pointerId);
520-
},
521-
[stopResize],
522-
);
523-
524-
const handlePointerUp = React.useCallback(
525-
(event: React.PointerEvent<HTMLButtonElement>) => {
526-
onPointerUp?.(event);
527-
if (event.defaultPrevented) return;
528-
endResizeInteraction(event);
529-
},
530-
[endResizeInteraction, onPointerUp],
531-
);
532-
533-
const handlePointerCancel = React.useCallback(
534-
(event: React.PointerEvent<HTMLButtonElement>) => {
535-
onPointerCancel?.(event);
536-
if (event.defaultPrevented) return;
537-
endResizeInteraction(event);
538-
},
539-
[endResizeInteraction, onPointerCancel],
540-
);
413+
return width;
414+
},
415+
finish(finalWidth, moved) {
416+
suppressClickRef.current = moved;
417+
if (resolvedResizable.storageKey) {
418+
setLocalStorageItem(resolvedResizable.storageKey, finalWidth, Schema.Finite);
419+
}
420+
resolvedResizable.onResize?.(finalWidth);
421+
},
422+
cleanup() {
423+
transitionTargets.forEach((element) => {
424+
element.style.removeProperty("transition-duration");
425+
});
426+
},
427+
};
428+
});
541429

542430
const handleClick = React.useCallback(
543431
(event: React.MouseEvent<HTMLButtonElement>) => {
@@ -579,20 +467,6 @@ function SidebarRail({
579467
resolvedResizable.onResize?.(clampedWidth);
580468
}, [resolvedResizable]);
581469

582-
React.useEffect(() => {
583-
return () => {
584-
const resizeState = resizeStateRef.current;
585-
if (resizeState?.rafId != null) {
586-
window.cancelAnimationFrame(resizeState.rafId);
587-
}
588-
resizeState?.transitionTargets.forEach((element) => {
589-
element.style.removeProperty("transition-duration");
590-
});
591-
document.body.style.removeProperty("cursor");
592-
document.body.style.removeProperty("user-select");
593-
};
594-
}, []);
595-
596470
return (
597471
<Tooltip>
598472
<TooltipTrigger
@@ -613,10 +487,26 @@ function SidebarRail({
613487
data-sidebar="rail"
614488
data-slot="sidebar-rail"
615489
onClick={handleClick}
616-
onPointerCancel={handlePointerCancel}
617-
onPointerDown={handlePointerDown}
618-
onPointerMove={handlePointerMove}
619-
onPointerUp={handlePointerUp}
490+
onLostPointerCapture={(event) => {
491+
onLostPointerCapture?.(event);
492+
if (!event.defaultPrevented) resize.onLostPointerCapture(event);
493+
}}
494+
onPointerCancel={(event) => {
495+
onPointerCancel?.(event);
496+
if (!event.defaultPrevented) resize.onPointerCancel(event);
497+
}}
498+
onPointerDown={(event) => {
499+
onPointerDown?.(event);
500+
if (!event.defaultPrevented) resize.onPointerDown(event);
501+
}}
502+
onPointerMove={(event) => {
503+
onPointerMove?.(event);
504+
if (!event.defaultPrevented) resize.onPointerMove(event);
505+
}}
506+
onPointerUp={(event) => {
507+
onPointerUp?.(event);
508+
if (!event.defaultPrevented) resize.onPointerUp(event);
509+
}}
620510
ref={railRef}
621511
tabIndex={-1}
622512
type="button"

‎apps/web/src/hooks/useResizableWidth.test.tsx‎

Lines changed: 41 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -40,13 +40,13 @@ function pointer(clientX = 100) {
4040
} as unknown as PointerEvent<HTMLElement>;
4141
}
4242

43-
function Panel() {
43+
function Panel({ edge = "left" }: { edge?: "left" | "right" }) {
4444
const resize = useResizableWidth({
4545
storageKey: "test-panel-width",
4646
defaultWidth: 400,
4747
minWidth: 200,
4848
maxWidth: 800,
49-
edge: "left",
49+
edge,
5050
});
5151
useLayoutEffect(() => {
5252
result = resize;
@@ -107,11 +107,48 @@ describe("panel resize cleanup", () => {
107107
expect(style.userSelect).toBe("");
108108
expect(captured).toBe(false);
109109
expect(cancelAnimationFrame).toHaveBeenCalledWith(42);
110-
expect(setItem).not.toHaveBeenCalled();
111-
if (reason !== "unmount") expect(result.width).toBe(400);
110+
if (reason === "unmount") {
111+
expect(setItem).not.toHaveBeenCalled();
112+
} else {
113+
expect(result.width).toBe(475);
114+
expect(setItem).toHaveBeenCalledExactlyOnceWith("test-panel-width", "475");
115+
}
112116
},
113117
);
114118

119+
it.each(["left", "right"] as const)(
120+
"uses the release position for a fast %s-edge drag",
121+
async (edge) => {
122+
await act(() => renderer.update(<Panel edge={edge} />));
123+
await act(() => {
124+
result.handlers.onPointerDown(pointer());
125+
result.handlers.onPointerMove(pointer(edge === "left" ? 50 : 150));
126+
result.handlers.onPointerUp(pointer(edge === "left" ? 25 : 175));
127+
});
128+
expect(result.width).toBe(475);
129+
expect(setItem).toHaveBeenCalledExactlyOnceWith("test-panel-width", "475");
130+
expect(cancelAnimationFrame).toHaveBeenCalledWith(42);
131+
},
132+
);
133+
134+
it("handles release before any move event", async () => {
135+
await act(() => {
136+
result.handlers.onPointerDown(pointer());
137+
result.handlers.onPointerUp(pointer(25));
138+
});
139+
expect(result.width).toBe(475);
140+
expect(setItem).toHaveBeenCalledExactlyOnceWith("test-panel-width", "475");
141+
});
142+
143+
it("clamps the release position to the panel bounds", async () => {
144+
await act(() => {
145+
result.handlers.onPointerDown(pointer());
146+
result.handlers.onPointerUp(pointer(-1000));
147+
});
148+
expect(result.width).toBe(800);
149+
expect(setItem).toHaveBeenCalledExactlyOnceWith("test-panel-width", "800");
150+
});
151+
115152
it("saves the final width when release is followed by lost capture", async () => {
116153
await act(() => {
117154
result.handlers.onPointerDown(pointer());

0 commit comments

Comments
 (0)