An open source design system that's fully customizable and agent ready
TypeScript
// Copyright (c) Meta Platforms, Inc. and affiliates.
/**
* @file gestureCounter.test.ts
* @input claimPress and claimContextMenuPress with a stubbed layer box,
* stubbed pointer capture, and a layer inside an open shadow root
* @output The claim compares the pointer with the layer's box read once (no
* hit test or layout read per move), lets go over the layer, and ends when
* the layer closes while the button is still down. A primary press's claim
* ends at its release and runs once per press and layer. A release target
* holds the pointer while the pointer is over it, and no window listener
* stays after the press. The context-menu claim takes only a press that
* fired `contextmenu`
* @position Unit test of packages/core/src/Layer/gestureCounter.ts
*/
import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
import {
claimContextMenuPress,
claimPress,
currentGesture,
isPressInFlight,
} from './gestureCounter';
/** A pointer event of `type` for `pointerId`, which jsdom's events lack. */
function pointerEvent(
type: string,
pointerId: number,
{button = 0, x = 0, y = 0} = {},
): Event {
return Object.assign(
new MouseEvent(type, {
bubbles: true,
composed: true,
button,
clientX: x,
clientY: y,
}),
{pointerId},
);
}
describe('claimContextMenuPress', () => {
let captured: number[];
let released: number[];
let isCaptured: boolean;
beforeEach(() => {
captured = [];
released = [];
isCaptured = false;
HTMLElement.prototype.setPointerCapture = (pointerId: number) => {
captured.push(pointerId);
isCaptured = true;
};
HTMLElement.prototype.hasPointerCapture = () => isCaptured;
HTMLElement.prototype.releasePointerCapture = (pointerId: number) => {
released.push(pointerId);
isCaptured = false;
};
});
afterEach(() => {
document.dispatchEvent(pointerEvent('pointerup', 7));
document.body.replaceChildren();
vi.restoreAllMocks();
delete (HTMLElement.prototype as Partial<HTMLElement>).setPointerCapture;
delete (HTMLElement.prototype as Partial<HTMLElement>).hasPointerCapture;
delete (HTMLElement.prototype as Partial<HTMLElement>)
.releasePointerCapture;
});
/** Presses the right button on `zone` and claims the press for `layer`. */
function openFromRightClick(zone: Element, layer: HTMLElement) {
// Reading the gesture installs its listeners before the press.
currentGesture();
zone.dispatchEvent(pointerEvent('pointerdown', 7, {button: 2}));
zone.dispatchEvent(
new MouseEvent('contextmenu', {bubbles: true, composed: true}),
);
claimContextMenuPress(layer);
}
function stubLayerBox(layer: HTMLElement) {
return vi.spyOn(layer, 'getBoundingClientRect').mockReturnValue({
left: 100,
right: 200,
top: 100,
bottom: 200,
width: 100,
height: 100,
x: 100,
y: 100,
toJSON() {
return this;
},
});
}
it('keeps no pointerup listener at rest, only while a press is down', () => {
const zone = document.createElement('div');
document.body.append(zone);
currentGesture();
const added = vi.spyOn(window, 'addEventListener');
const removed = vi.spyOn(window, 'removeEventListener');
const types = (spy: typeof added | typeof removed) =>
spy.mock.calls.map(([type]) => type);
zone.dispatchEvent(pointerEvent('pointerdown', 9));
expect(types(added)).toContain('pointerup');
zone.dispatchEvent(pointerEvent('pointerup', 9));
expect(types(removed)).toContain('pointerup');
});
it('lets go over the layer and holds outside it, reading the layer box once', () => {
const zone = document.createElement('div');
const layer = document.createElement('div');
document.body.append(zone, layer);
const box = stubLayerBox(layer);
openFromRightClick(zone, layer);
expect(captured).toEqual([7]);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(released).toEqual([7]);
zone.dispatchEvent(pointerEvent('pointermove', 7, {x: 20, y: 20}));
expect(captured).toEqual([7, 7]);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 120, y: 180}));
expect(released).toEqual([7, 7]);
expect(box).toHaveBeenCalledTimes(1);
});
it('reads the layer box again after a scroll', () => {
const zone = document.createElement('div');
const layer = document.createElement('div');
document.body.append(zone, layer);
const box = stubLayerBox(layer);
openFromRightClick(zone, layer);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(box).toHaveBeenCalledTimes(1);
document.dispatchEvent(new Event('scroll'));
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(box).toHaveBeenCalledTimes(2);
});
it('works for a layer inside an open shadow root', () => {
const host = document.createElement('div');
document.body.append(host);
const shadow = host.attachShadow({mode: 'open'});
const zone = document.createElement('div');
const layer = document.createElement('div');
shadow.append(zone, layer);
stubLayerBox(layer);
openFromRightClick(zone, layer);
expect(captured).toEqual([7]);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(released).toEqual([7]);
});
it('lets the pointer go when the layer closes while the button is still down', () => {
const zone = document.createElement('div');
const layer = document.createElement('div');
document.body.append(zone, layer);
stubLayerBox(layer);
openFromRightClick(zone, layer);
expect(captured).toEqual([7]);
// Escape closes the layer before the release.
layer.dispatchEvent(
Object.assign(new Event('toggle'), {newState: 'closed'}),
);
expect(released).toEqual([7]);
// The claim has ended: a later move outside captures nothing.
zone.dispatchEvent(pointerEvent('pointermove', 7, {x: 20, y: 20}));
expect(captured).toEqual([7]);
});
});
describe('claimPress', () => {
let captured: number[];
let released: number[];
beforeEach(() => {
captured = [];
released = [];
HTMLElement.prototype.setPointerCapture = (pointerId: number) => {
captured.push(pointerId);
};
HTMLElement.prototype.hasPointerCapture = () => true;
HTMLElement.prototype.releasePointerCapture = (pointerId: number) => {
released.push(pointerId);
};
});
afterEach(() => {
document.dispatchEvent(pointerEvent('pointerup', 7));
document.body.replaceChildren();
vi.restoreAllMocks();
delete (HTMLElement.prototype as Partial<HTMLElement>).setPointerCapture;
delete (HTMLElement.prototype as Partial<HTMLElement>).hasPointerCapture;
delete (HTMLElement.prototype as Partial<HTMLElement>)
.releasePointerCapture;
});
/** A trigger and a layer whose box spans 100 to 200 on both axes. */
function mountLayer() {
const trigger = document.createElement('button');
const layer = document.createElement('div');
document.body.append(trigger, layer);
vi.spyOn(layer, 'getBoundingClientRect').mockReturnValue(
new DOMRect(100, 100, 100, 100),
);
// Reading the gesture installs its listeners before the press.
currentGesture();
return {trigger, layer};
}
it('captures a primary press outside the layer, lets go over it, and ends at the release', () => {
const {trigger, layer} = mountLayer();
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
expect(isPressInFlight()).toBe(true);
claimPress(layer);
expect(captured).toEqual([7]);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(released).toEqual([7]);
trigger.dispatchEvent(pointerEvent('pointermove', 7, {x: 20, y: 20}));
expect(captured).toEqual([7, 7]);
trigger.dispatchEvent(pointerEvent('pointerup', 7, {x: 20, y: 20}));
expect(isPressInFlight()).toBe(false);
// The claim ended with its press.
trigger.dispatchEvent(pointerEvent('pointermove', 7, {x: 20, y: 20}));
expect(captured).toEqual([7, 7]);
});
it('claims a press once for a layer', () => {
const {trigger, layer} = mountLayer();
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
claimPress(layer);
claimPress(layer);
expect(captured).toEqual([7]);
// One claim follows the pointer, not two.
trigger.dispatchEvent(pointerEvent('pointermove', 7, {x: 20, y: 20}));
expect(captured).toEqual([7, 7]);
});
it('claims nothing when no press is down', () => {
const {trigger, layer} = mountLayer();
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
trigger.dispatchEvent(pointerEvent('pointerup', 7));
claimPress(layer);
expect(captured).toEqual([]);
});
it('gives the pointer to the release target over it, lets go over the layer, and gives it to the layer outside both', () => {
const {trigger, layer} = mountLayer();
vi.spyOn(trigger, 'getBoundingClientRect').mockReturnValue(
new DOMRect(0, 0, 50, 20),
);
// One element holds the pointer at a time, as in a browser.
let holder: Element | null = null;
const holders: Element[] = [];
const take = (element: Element) => {
holder = element;
holders.push(element);
};
const letGo = (element: Element) => {
if (holder === element) {
holder = null;
}
};
HTMLElement.prototype.setPointerCapture = function (this: HTMLElement) {
take(this);
};
HTMLElement.prototype.hasPointerCapture = function (this: HTMLElement) {
return holder === this;
};
HTMLElement.prototype.releasePointerCapture = function (this: HTMLElement) {
letGo(this);
};
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
claimPress(layer, {releaseTarget: trigger});
// The press began on the release target, so it holds the pointer.
expect(holders).toEqual([trigger]);
layer.dispatchEvent(pointerEvent('pointermove', 7, {x: 150, y: 150}));
expect(holder).toBeNull();
document.body.dispatchEvent(
pointerEvent('pointermove', 7, {x: 300, y: 300}),
);
expect(holder).toBe(layer);
trigger.dispatchEvent(pointerEvent('pointermove', 7, {x: 10, y: 10}));
expect(holder).toBe(trigger);
expect(holders).toEqual([trigger, layer, trigger]);
});
it('leaves the window listening as before once its press ends', () => {
const {trigger, layer} = mountLayer();
// Spies that pass through: each add and remove still reaches the window.
const add = vi.spyOn(window, 'addEventListener');
const remove = vi.spyOn(window, 'removeEventListener');
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
claimPress(layer, {releaseTarget: trigger});
trigger.dispatchEvent(pointerEvent('pointermove', 7, {x: 300, y: 300}));
trigger.dispatchEvent(pointerEvent('pointerup', 7, {x: 300, y: 300}));
const listening = new Map<string, number>();
for (const [type] of add.mock.calls) {
listening.set(type, (listening.get(type) ?? 0) + 1);
}
for (const [type] of remove.mock.calls) {
listening.set(type, (listening.get(type) ?? 0) - 1);
}
// Every window listener the press and its claim added is gone.
expect(add).toHaveBeenCalled();
expect([...listening].filter(([, n]) => n !== 0)).toEqual([]);
});
it('claims a press for the context menu only once that press fired contextmenu', () => {
const {trigger, layer} = mountLayer();
trigger.dispatchEvent(pointerEvent('pointerdown', 7));
claimContextMenuPress(layer);
expect(captured).toEqual([]);
trigger.dispatchEvent(
new MouseEvent('contextmenu', {bubbles: true, composed: true}),
);
claimContextMenuPress(layer);
expect(captured).toEqual([7]);
});
});