Skip to content

The open alternative to Salesforce, designed for AI.

25.4 KB
Raw Blame
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();
  });
});