The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { setupGeometryGlobals } from '@/testing/setupGeometryGlobals';
import { GEOMETRY_IDLE_FRAME_THRESHOLD } from '@/host/geometry/constants/GeometryIdleFrameThreshold';
import { createGeometryTracker } from '../createGeometryTracker';
const geometryGlobals = setupGeometryGlobals();
const armedTrackers: ReturnType<typeof createGeometryTracker>[] = [];
const createArmedTracker = () => {
const tracker = createGeometryTracker();
const pushGeometryUpdates = jest.fn();
tracker.setPushGeometryUpdates(pushGeometryUpdates);
armedTrackers.push(tracker);
return { tracker, pushGeometryUpdates };
};
const flushFrames = (frameCount: number) => {
for (let frameIndex = 0; frameIndex < frameCount; frameIndex += 1) {
geometryGlobals.flushAnimationFrame();
}
};
describe('createGeometryTracker', () => {
beforeEach(() => {
geometryGlobals.clearScheduledFrames();
document.body.innerHTML = '';
jest.clearAllMocks();
});
afterEach(() => {
for (const tracker of armedTrackers) {
tracker.reset();
}
armedTrackers.length = 0;
});
it('should not schedule a frame when created', () => {
armedTrackers.push(createGeometryTracker());
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should place the portal layer on the root container and follow it on the next frame', () => {
const { tracker } = createArmedTracker();
const root = geometryGlobals.createStubNode({
x: 20,
y: 30,
width: 320,
height: 180,
});
const portalLayer = document.createElement('div');
tracker.setRoot(root.node);
tracker.setPortalLayer(portalLayer);
expect(portalLayer.style.left).toBe('calc(20px / var(--t-zoom, 1))');
expect(portalLayer.style.top).toBe('calc(30px / var(--t-zoom, 1))');
root.setGeometry({ x: 40, y: 50, width: 360, height: 220 });
geometryGlobals.flushAnimationFrame();
expect(portalLayer.style.left).toBe('calc(40px / var(--t-zoom, 1))');
expect(portalLayer.style.top).toBe('calc(50px / var(--t-zoom, 1))');
expect(portalLayer.style.width).toBe('calc(360px / var(--t-zoom, 1))');
expect(portalLayer.style.height).toBe('calc(220px / var(--t-zoom, 1))');
});
it('should hide the portal layer while the root container is not interactive', () => {
const { tracker } = createArmedTracker();
const root = geometryGlobals.createStubNode({
x: 20,
y: 30,
width: 320,
height: 180,
});
root.node.getClientRects = () =>
[root.node.getBoundingClientRect()] as unknown as DOMRectList;
const portalLayer = document.createElement('div');
tracker.setRoot(root.node);
tracker.setPortalLayer(portalLayer);
expect(portalLayer.style.display).toBe('');
root.node.style.pointerEvents = 'none';
geometryGlobals.flushAnimationFrame();
expect(portalLayer.style.display).toBe('none');
root.node.style.pointerEvents = '';
geometryGlobals.flushAnimationFrame();
expect(portalLayer.style.display).toBe('');
});
it('should resume scheduling on scroll only while a portal layer is mounted', () => {
const { tracker } = createArmedTracker();
tracker.setPortalLayer(document.createElement('div'));
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
document.dispatchEvent(new Event('scroll'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
tracker.setPortalLayer(null);
document.dispatchEvent(new Event('scroll'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should keep resuming on scroll for a portal layer after the last id is unobserved', () => {
const { tracker } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
tracker.setPortalLayer(document.createElement('div'));
tracker.unobserve(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
document.dispatchEvent(new Event('scroll'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should find the remote element id of a node through its nearest registered ancestor', () => {
const tracker = createGeometryTracker();
const tabList = document.createElement('div');
const tab = document.createElement('button');
const tabIcon = document.createElement('span');
tab.append(tabIcon);
tabList.append(tab);
document.body.append(tabList);
tracker.registerNode('tab-list', tabList);
tracker.registerNode('tab', tab);
expect(tracker.findRemoteElementIdContainingNode(tabIcon)).toBe('tab');
expect(tracker.findRemoteElementIdContainingNode(tabList)).toBe('tab-list');
expect(
tracker.findRemoteElementIdContainingNode(document.body),
).toBeUndefined();
expect(tracker.findRemoteElementIdContainingNode(null)).toBeUndefined();
tracker.unregisterNode('tab', tab);
expect(tracker.findRemoteElementIdContainingNode(tabIcon)).toBe('tab-list');
});
it('should not schedule a frame when observing before being armed', () => {
const tracker = createGeometryTracker();
armedTrackers.push(tracker);
tracker.observe(['1']);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should push ids observed before it was armed', () => {
const tracker = createGeometryTracker();
armedTrackers.push(tracker);
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 13,
height: 13,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
const pushGeometryUpdates = jest.fn();
tracker.setPushGeometryUpdates(pushGeometryUpdates);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
expect(pushGeometryUpdates.mock.calls[0][0].elements['1'].width).toBe(13);
});
it('should not schedule a frame when arming with nothing observed', () => {
const tracker = createGeometryTracker();
armedTrackers.push(tracker);
tracker.setPushGeometryUpdates(jest.fn());
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should not schedule a frame when every observed id is rejected', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
tracker.observe([42, null, '']);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
expect(pushGeometryUpdates).not.toHaveBeenCalled();
});
it('should not schedule a frame when re-observing an already observed id', () => {
const { tracker } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
tracker.observe(['1']);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should never push while nothing is observed', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', stub.node);
flushFrames(5);
expect(pushGeometryUpdates).not.toHaveBeenCalled();
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should push a batch containing only observed nodes', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 1,
y: 2,
width: 3,
height: 4,
});
const unobserved = geometryGlobals.createStubNode({
x: 9,
y: 9,
width: 9,
height: 9,
});
tracker.registerNode('1', observed.node);
tracker.registerNode('2', unobserved.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
const batch = pushGeometryUpdates.mock.calls[0][0];
expect(Object.keys(batch.elements)).toEqual(['1']);
expect(batch.elements['1'].width).toBe(3);
});
it('should not push a second batch when nothing changed', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(3);
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
});
it('should push when a rect changes by more than the epsilon', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
observed.setGeometry({ x: 0, y: 0, width: 20, height: 10 });
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(2);
expect(pushGeometryUpdates.mock.calls[1][0].elements['1'].width).toBe(20);
});
it('should not push when a rect changes by less than the epsilon', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
observed.setGeometry({ x: 0, y: 0, width: 10.01, height: 10 });
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
});
it('should omit an unchanged computed style from later pushes', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
observed.node.style.paddingTop = '2px';
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
observed.setGeometry({ x: 5, y: 0, width: 10, height: 10 });
geometryGlobals.flushAnimationFrame();
observed.node.style.paddingTop = '3px';
geometryGlobals.flushAnimationFrame();
const [firstBatch, secondBatch, thirdBatch] =
pushGeometryUpdates.mock.calls.map(([batch]) => batch);
expect(firstBatch.elements['1'].computedStyle['padding-top']).toBe('2px');
expect(firstBatch.viewport.computedStyle).toBeDefined();
expect(secondBatch.elements['1'].x).toBe(5);
expect(secondBatch.elements['1'].computedStyle).toBeUndefined();
expect(secondBatch.viewport.computedStyle).toBeUndefined();
expect(thirdBatch.elements['1'].computedStyle['padding-top']).toBe('3px');
});
it('should include the viewport in every pushed batch', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates.mock.calls[0][0].viewport.innerWidth).toBe(
window.innerWidth,
);
});
it('should stop scheduling frames after the idle threshold', () => {
const { tracker } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should resume scheduling after a window resize following an idle stop', () => {
const { tracker } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
window.dispatchEvent(new Event('resize'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should push the resized viewport after a window resize following an idle stop', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
const initialInnerWidth = window.innerWidth;
Object.defineProperty(window, 'innerWidth', {
value: initialInnerWidth + 100,
configurable: true,
});
pushGeometryUpdates.mockClear();
window.dispatchEvent(new Event('resize'));
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
expect(pushGeometryUpdates.mock.calls[0][0].viewport.innerWidth).toBe(
initialInnerWidth + 100,
);
Object.defineProperty(window, 'innerWidth', {
value: initialInnerWidth,
configurable: true,
});
});
it('should resume scheduling when the resize observer fires', () => {
const { tracker } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
geometryGlobals.triggerResizeObserver();
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should resume scheduling when the mutation observer fires', () => {
const { tracker } = createArmedTracker();
const rootContainer = document.createElement('div');
document.body.append(rootContainer);
tracker.setRoot(rootContainer);
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
geometryGlobals.triggerMutationObserver();
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should resume scheduling when a transition starts inside the root after an idle stop', () => {
const { tracker } = createArmedTracker();
const rootContainer = document.createElement('div');
document.body.append(rootContainer);
tracker.setRoot(rootContainer);
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
rootContainer.append(observed.node);
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
observed.node.dispatchEvent(new Event('transitionrun', { bubbles: true }));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should resume scheduling when a transition ends inside the root after an idle stop', () => {
const { tracker } = createArmedTracker();
const rootContainer = document.createElement('div');
document.body.append(rootContainer);
tracker.setRoot(rootContainer);
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
rootContainer.append(observed.node);
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
observed.node.dispatchEvent(new Event('transitionend', { bubbles: true }));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
});
it('should idle despite an animation outside the root', () => {
const { tracker } = createArmedTracker();
const rootContainer = document.createElement('div');
const unrelatedContainer = document.createElement('div');
document.body.append(rootContainer, unrelatedContainer);
tracker.setRoot(rootContainer);
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
rootContainer.append(observed.node);
tracker.registerNode('1', observed.node);
tracker.observe(['1']);
unrelatedContainer.dispatchEvent(
new Event('transitionrun', { bubbles: true }),
);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should cap the observed set at the configured maximum', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const remoteElementIds = Array.from({ length: 10000 }, (_, index) =>
String(index),
);
for (const remoteElementId of remoteElementIds) {
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode(remoteElementId, stub.node);
}
tracker.observe(remoteElementIds);
geometryGlobals.flushAnimationFrame();
expect(
Object.keys(pushGeometryUpdates.mock.calls[0][0].elements).length,
).toBe(500);
});
it('should not grow the observed set when the same ids are observed repeatedly', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
tracker.observe(['1']);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(Object.keys(pushGeometryUpdates.mock.calls[0][0].elements)).toEqual([
'1',
]);
});
it('should keep an id observed when its node unregisters', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
tracker.unregisterNode('1', stub.node);
stub.node.remove();
geometryGlobals.flushAnimationFrame();
tracker.registerNode('1', stub.node);
document.body.append(stub.node);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(3);
expect(pushGeometryUpdates.mock.calls[2][0].elements['1'].width).toBe(1);
});
it('should push again when an id is re-observed after unobserve', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
tracker.unobserve(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
pushGeometryUpdates.mockClear();
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).toHaveBeenCalledTimes(1);
expect(pushGeometryUpdates.mock.calls[0][0].elements['1'].width).toBe(10);
});
it('should detach element wake sources when the last id is unobserved', () => {
const { tracker } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
document.dispatchEvent(new Event('scroll'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(1);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
tracker.unobserve(['1']);
document.dispatchEvent(new Event('scroll'));
expect(geometryGlobals.getScheduledFrameCount()).toBe(0);
});
it('should expire an observed id whose node never registers', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const observed = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', observed.node);
tracker.observe(['1', '404']);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
const removalBatches = pushGeometryUpdates.mock.calls.filter(
(call) => call[0].removedRemoteElementIds.length > 0,
);
expect(removalBatches).toHaveLength(1);
expect(removalBatches[0][0].removedRemoteElementIds).toEqual(['404']);
});
it('should not expire an observed id that registers before the limit', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const anchor = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 10,
height: 10,
});
tracker.registerNode('1', anchor.node);
tracker.observe(['1', '2']);
flushFrames(5);
const lateStub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 7,
height: 7,
});
tracker.registerNode('2', lateStub.node);
flushFrames(GEOMETRY_IDLE_FRAME_THRESHOLD + 2);
for (const call of pushGeometryUpdates.mock.calls) {
expect(call[0].removedRemoteElementIds).toEqual([]);
}
const lastPushWithLateNode = pushGeometryUpdates.mock.calls.find(
(call) => call[0].elements['2'] !== undefined,
);
expect(lastPushWithLateNode?.[0].elements['2'].width).toBe(7);
});
it('should report a removed id exactly once', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
tracker.unregisterNode('1', stub.node);
flushFrames(3);
const removalBatches = pushGeometryUpdates.mock.calls.filter(
(call) => call[0].removedRemoteElementIds.length > 0,
);
expect(removalBatches).toHaveLength(1);
expect(removalBatches[0][0].removedRemoteElementIds).toEqual(['1']);
});
it('should not report a removal for an id that was never measured', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
tracker.observe(['404']);
flushFrames(3);
for (const call of pushGeometryUpdates.mock.calls) {
expect(call[0].removedRemoteElementIds).toEqual([]);
}
});
it('should measure an id registered after it was observed', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 7,
height: 7,
});
tracker.registerNode('1', stub.node);
geometryGlobals.flushAnimationFrame();
const lastBatch =
pushGeometryUpdates.mock.calls[pushGeometryUpdates.mock.calls.length - 1];
expect(lastBatch[0].elements['1'].width).toBe(7);
});
it('should not evict a live node when a stale unregister for the same id arrives', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const staleStub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
const liveStub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 2,
height: 2,
});
tracker.registerNode('1', liveStub.node);
tracker.unregisterNode('1', staleStub.node);
tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates.mock.calls[0][0].elements['1'].width).toBe(2);
});
it('should ignore non-array and non-string ids', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe('not-an-array');
tracker.observe([42, null, '']);
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).not.toHaveBeenCalled();
});
it('should not push after reset and should be idempotent when reset twice', () => {
const { tracker, pushGeometryUpdates } = createArmedTracker();
const stub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 1,
height: 1,
});
tracker.registerNode('1', stub.node);
tracker.observe(['1']);
tracker.reset();
tracker.reset();
geometryGlobals.flushAnimationFrame();
expect(pushGeometryUpdates).not.toHaveBeenCalled();
});
it('should keep two trackers independent', () => {
const first = createArmedTracker();
const second = createArmedTracker();
const firstStub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 11,
height: 11,
});
const secondStub = geometryGlobals.createStubNode({
x: 0,
y: 0,
width: 22,
height: 22,
});
first.tracker.registerNode('1', firstStub.node);
second.tracker.registerNode('1', secondStub.node);
first.tracker.observe(['1']);
geometryGlobals.flushAnimationFrame();
expect(first.pushGeometryUpdates).toHaveBeenCalledTimes(1);
expect(first.pushGeometryUpdates.mock.calls[0][0].elements['1'].width).toBe(
11,
);
expect(second.pushGeometryUpdates).not.toHaveBeenCalled();
});
});