perf: isolate board grid previews

This commit is contained in:
Thomas Camlong authored and ajnart committed 2026-08-14 11:07:07 +02:00
1 parent 6e455760a3
commit a2400f8412
8 files changed
+517 -100

No files matched your search

@@ -5,22 +5,37 @@ import { afterEach, beforeEach, describe, expect, test } from "vitest";
import type { DndGridEntryProps } from "../grid-entry-memo";
import { areDndGridEntryPropsEqual } from "../grid-entry-memo";
import { createGridPreviewDomState, syncGridPreviewGeometry } from "../grid-preview-geometry";
describe("grid entry memoization", () => {
let container: HTMLDivElement;
let root: Root;
let renders: number;
let renders = 0;
let widgetRenders = 0;
const Probe = memo((props: DndGridEntryProps) => {
renders += 1;
return createElement("span", { "data-x": props.placement.x });
return createElement(
"span",
{
"data-grid-id": props.placement.id,
"data-x": props.placement.x,
ref: (element: HTMLSpanElement | null) => props.registerElement(props.placement.id, element),
},
createElement(WidgetProbe),
);
}, areDndGridEntryPropsEqual);
const WidgetProbe = () => {
widgetRenders += 1;
return null;
};
beforeEach(() => {
container = document.createElement("div");
document.body.append(container);
root = createRoot(container);
renders = 0;
widgetRenders = 0;
});
afterEach(() => {
@@ -61,10 +76,52 @@ describe("grid entry memoization", () => {
expect(renders).toBe(101);
});
test("keeps 100 entry and widget renders frozen while preview geometry changes", () => {
const elements = new Map<string, HTMLElement>();
const registerElement = (id: string, element: HTMLElement | null) => {
if (element) elements.set(id, element);
else elements.delete(id);
};
const entries = Array.from({ length: 100 }, (_, index) => ({
...createProps(),
registerElement,
placement: { ...createProps().placement, id: `item-${index}`, x: index % 10, y: Math.floor(index / 10) },
}));
renderBoard(entries);
expect(renders).toBe(100);
expect(widgetRenders).toBe(100);
let previewState = createGridPreviewDomState();
for (let revision = 1; revision <= 20; revision += 1) {
previewState = syncGridPreviewGeometry({
elements,
placements: entries.map((entry) => entry.placement),
previewPlacements: entries.map((entry, index) =>
index === 42 ? { ...entry.placement, y: entry.placement.y + revision } : entry.placement,
),
activeId: "item-0",
mode: "drag",
previous: previewState,
});
}
expect(renders).toBe(100);
expect(widgetRenders).toBe(100);
expect(elements.get("item-42")?.getAttribute("data-grid-preview")).toBe("true");
renderBoard(
entries.map((entry, index) =>
index === 42 ? { ...entry, placement: { ...entry.placement, y: entry.placement.y + 20 } } : entry,
),
);
expect(renders).toBe(101);
expect(widgetRenders).toBe(101);
});
test.each([
["active state", (props: DndGridEntryProps) => ({ ...props, isActive: true })],
["label", (props: DndGridEntryProps) => ({ ...props, label: "Changed" })],
["grid limits", (props: DndGridEntryProps) => ({ ...props, maxRowCount: 10 })],
["element registration", (props: DndGridEntryProps) => ({ ...props, registerElement: () => undefined })],
[
"minimum size",
(props: DndGridEntryProps) => ({
@@ -102,5 +159,5 @@ const createProps = (): DndGridEntryProps => ({
label: "Weather",
columnCount: 12,
maxRowCount: null,
isActive: false,
registerElement: () => undefined,
});
@@ -0,0 +1,86 @@
import { beforeEach, describe, expect, test } from "vitest";
import { createGridPreviewDomState, syncGridPreviewGeometry } from "../grid-preview-geometry";
describe("grid preview geometry", () => {
let elements: Map<string, HTMLElement>;
beforeEach(() => {
elements = new Map([
["active", createEntry("active", 0, 0, 2, 2)],
["displaced", createEntry("displaced", 2, 0, 1, 1)],
]);
});
test("moves displaced entries without moving the active drag source", () => {
const placements = [placement("active", 0, 0, 2, 2), placement("displaced", 2, 0, 1, 1)];
const state = syncGridPreviewGeometry({
elements,
placements,
previewPlacements: [placement("active", 2, 0, 2, 2), placement("displaced", 0, 2, 1, 1)],
activeId: "active",
mode: "drag",
previous: createGridPreviewDomState(),
});
expect(elements.get("active")?.hasAttribute("data-grid-preview")).toBe(false);
expect(elements.get("active")?.getAttribute("data-dnd-active")).toBe("true");
expect(elements.get("displaced")?.style.getPropertyValue("--board-grid-preview-x")).toBe("-448px");
expect(elements.get("displaced")?.style.getPropertyValue("--board-grid-preview-y")).toBe("448px");
expect(elements.get("displaced")?.dataset.gridX).toBe("0");
expect(elements.get("displaced")?.dataset.gridY).toBe("2");
syncGridPreviewGeometry({
elements,
placements,
previewPlacements: null,
activeId: null,
mode: null,
previous: state,
});
expect(elements.get("active")?.hasAttribute("data-dnd-active")).toBe(false);
expect(elements.get("displaced")?.hasAttribute("data-grid-preview")).toBe(false);
expect(elements.get("displaced")?.dataset.gridX).toBe("2");
expect(elements.get("displaced")?.dataset.gridY).toBe("0");
});
test("applies snapped size and position to the active resize shell", () => {
syncGridPreviewGeometry({
elements,
placements: [placement("active", 0, 0, 2, 2)],
previewPlacements: [placement("active", 1, 1, 3, 4)],
activeId: "active",
mode: "resize",
previous: createGridPreviewDomState(),
});
const active = elements.get("active");
expect(active?.getAttribute("data-grid-preview")).toBe("true");
expect(active?.style.getPropertyValue("--board-grid-preview-x")).toBe("224px");
expect(active?.style.getPropertyValue("--board-grid-preview-y")).toBe("224px");
expect(active?.style.getPropertyValue("--board-grid-preview-width")).toBe("648px");
expect(active?.style.getPropertyValue("--board-grid-preview-height")).toBe("872px");
expect(active?.dataset.gridW).toBe("3");
expect(active?.dataset.gridH).toBe("4");
});
});
const placement = (id: string, x: number, y: number, w: number, h: number) => ({
id,
type: "item" as const,
x,
y,
w,
h,
});
const createEntry = (id: string, x: number, y: number, w: number, h: number) => {
const element = document.createElement("div");
element.dataset.gridItemId = id;
element.dataset.gridX = String(x);
element.dataset.gridY = String(y);
element.dataset.gridW = String(w);
element.dataset.gridH = String(h);
return element;
};
@@ -0,0 +1,49 @@
import { afterEach, describe, expect, test, vi } from "vitest";
import { createGridResizeOutlineController } from "../grid-resize-outline";
describe("grid resize outline", () => {
afterEach(() => vi.restoreAllMocks());
test("coalesces pointer updates and removes the outline synchronously", () => {
const frame = { callback: undefined as FrameRequestCallback | undefined };
const requestFrame = vi.spyOn(window, "requestAnimationFrame").mockImplementation((callback) => {
frame.callback = callback;
return 7;
});
const cancelFrame = vi.spyOn(window, "cancelAnimationFrame").mockImplementation(() => undefined);
const shell = document.createElement("div");
const controlled = placement(1, 2, 2, 2);
const controller = createGridResizeOutlineController(
() => shell,
() => controlled,
);
controller.schedule({ placement: placement(1, 2, 2, 2), valid: true });
controller.schedule({ placement: placement(1, 2, 1, 2), valid: false });
expect(requestFrame).toHaveBeenCalledTimes(1);
expect(shell.querySelector("[data-grid-resize-outline]")).toBeNull();
frame.callback?.(0);
const outline = shell.querySelector<HTMLElement>("[data-grid-resize-outline]");
expect(outline?.style.left).toBe("0px");
expect(outline?.style.top).toBe("0px");
expect(outline?.style.width).toBe("200px");
expect(outline?.style.height).toBe("424px");
expect(outline?.dataset.gridResizeValid).toBe("false");
controller.schedule(null);
expect(cancelFrame).toHaveBeenCalledWith(0);
expect(shell.querySelector("[data-grid-resize-outline]")).toBeNull();
controller.destroy();
});
});
const placement = (x: number, y: number, w: number, h: number) => ({
id: "item",
type: "item" as const,
x,
y,
w,
h,
});