DWVv0.37.0
tests/tools/layerGroupPointer.test.jsjavascript
// @vitest-environment jsdom
import {describe, test, assert, vi, beforeEach, afterEach} from 'vitest';

// Import chain hits `tools/index` → tool `windowLevel` → `layerGroupPointer`
// before export completes.
vi.mock('../../src/tools/index.js', () => ({
  toolList: {},
  toolOptions: {},
  defaultToolList: {},
  defaultToolOptions: {
    draw: {},
    filter: {}
  }
}));

// `behaviors/doubleClickBehavior.js` imports `app/application.js` (same graph).
vi.mock('../../src/app/application.js', () => ({
  App: class App {}
}));

import {Point2D} from '../../src/math/point.js';
import {LayerGroupPointer} from '../../src/tools/layerGroupPointer.js';
import {DragBehavior} from '../../src/tools/behaviors/dragBehavior.js';
import {TwoTouchBehavior} from '../../src/tools/behaviors/twoTouchBehavior.js';
import * as generic from '../../src/gui/generic.js';

/**
 * Minimal layer DOM: canvas inside `.layer` div
 * (see {@link getLayerDetailsFromEvent}).
 *
 * @param {string} groupDivId Layer group id (e.g. `layerGroup0`).
 * @returns {{canvas: HTMLCanvasElement, groupDivId: string}} Canvas and id.
 */
function setupLayerCanvas(groupDivId = 'layerGroupPtrTest') {
  const layer = document.createElement('div');
  layer.className = 'layer';
  layer.id = `${groupDivId}-layer-0`;
  const canvas = document.createElement('canvas');
  canvas.width = 64;
  canvas.height = 64;
  layer.appendChild(canvas);
  document.body.appendChild(layer);
  return {canvas, groupDivId};
}

/**
 * @param {string} type The DOM event type.
 * @param {EventTarget} target The event target node.
 * @param {number} offsetX Horizontal offset on the target.
 * @param {number} offsetY Vertical offset on the target.
 * @returns {MouseEvent} Synthetic mouse event for tests.
 */
function mouseEvent(type, target, offsetX, offsetY) {
  const ev = new MouseEvent(type, {bubbles: true, cancelable: true});
  Object.defineProperty(ev, 'target', {value: target, enumerable: true});
  Object.defineProperty(ev, 'offsetX', {value: offsetX});
  Object.defineProperty(ev, 'offsetY', {value: offsetY});
  return ev;
}

/**
 * @param {string} type Touch event type.
 * @param {EventTarget} target Usually the canvas under `.layer`.
 * @returns {TouchEvent} Synthetic touch event for tests.
 */
function touchEvent(type, target) {
  const ev = new TouchEvent(type, {bubbles: true, cancelable: true});
  Object.defineProperty(ev, 'target', {value: target, enumerable: true});
  return ev;
}

/**
 * @param {EventTarget} target The event target, usually the canvas under a
 *   `.layer` div.
 * @param {object} [opts] Optional deltaY and wheelDeltaY for tick shaping.
 * @returns {WheelEvent} Synthetic wheel event for tests.
 */
function wheelEvent(target, opts = {}) {
  const deltaY = opts.deltaY ?? 0;
  const {wheelDeltaY} = opts;
  const ev = new WheelEvent('wheel', {bubbles: true, cancelable: true, deltaY});
  Object.defineProperty(ev, 'target', {value: target, enumerable: true});
  if (typeof wheelDeltaY === 'number') {
    Object.defineProperty(ev, 'wheelDeltaY', {value: wheelDeltaY});
  }
  return ev;
}

describe('tools/layerGroupPointer', () => {
  let getTouchPointsSpy;

  beforeEach(() => {
    getTouchPointsSpy = vi.spyOn(generic, 'getTouchPoints');
  });

  afterEach(() => {
    document.body.replaceChildren();
    vi.restoreAllMocks();
  });

  test('LayerGroupPointer extends EventTarget', () => {
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: new DragBehavior()
    });
    assert.ok(pointer instanceof EventTarget);
    assert.equal(typeof pointer.addEventListener, 'function');
    assert.equal(typeof pointer.dispatchEvent, 'function');
  });

  test('mousedown starts drag when canStart; mousemove updates drag', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const layerGroup = {};
    const onStart = vi.fn();
    const onUpdate = vi.fn();
    const onEnd = vi.fn();

    class T extends DragBehavior {
      onStart(p, lg) {
        onStart(p, lg);
        super.onStart(p, lg);
      }
      onUpdate(p, lg) {
        onUpdate(p, lg);
        super.onUpdate(p, lg);
      }
      onEnd() {
        onEnd();
        super.onEnd();
      }
    }

    const drag = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? layerGroup : undefined)
      },
      dragBehavior: drag
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 4, 5));
    assert.equal(onStart.mock.calls.length, 1);
    assert.ok(drag.isActive());

    pointer.mousemove(mouseEvent('mousemove', canvas, 10, 12));
    assert.equal(onUpdate.mock.calls.length, 1);

    pointer.mouseup(mouseEvent('mouseup', canvas, 10, 12));
    assert.equal(onEnd.mock.calls.length, 1);
    assert.equal(drag.isActive(), false);
  });

  test('mouseout ends active drag and calls hoverBehavior.onEnd', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onDragEnd = vi.fn();
    const onHoverEnd = vi.fn();

    class T extends DragBehavior {
      onEnd() {
        onDragEnd();
        super.onEnd();
      }
    }

    const drag = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: drag,
      hoverBehavior: {
        onUpdate: vi.fn(),
        onEnd: onHoverEnd
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 2, 3));
    assert.ok(drag.isActive());

    pointer.mouseout(new MouseEvent('mouseout', {bubbles: true}));
    assert.equal(onDragEnd.mock.calls.length, 1);
    assert.equal(onHoverEnd.mock.calls.length, 1);
    assert.equal(drag.isActive(), false);
  });

  test('mouseout calls hoverBehavior.onEnd when drag is inactive', () => {
    const {groupDivId} = setupLayerCanvas();
    const onHoverEnd = vi.fn();
    const drag = new DragBehavior();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: drag,
      hoverBehavior: {
        onUpdate: vi.fn(),
        onEnd: onHoverEnd
      }
    });

    pointer.mouseout(new MouseEvent('mouseout', {bubbles: true}));
    assert.equal(onHoverEnd.mock.calls.length, 1);
    assert.equal(drag.isActive(), false);
  });

  test('mouseout clears pressed-button state so hover moves resume', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onHoverUpdate = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      hoverBehavior: {
        onUpdate: onHoverUpdate,
        onEnd: vi.fn()
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 1, 1));
    pointer.mouseout(new MouseEvent('mouseout', {bubbles: true}));
    pointer.mousemove(mouseEvent('mousemove', canvas, 5, 6));
    assert.equal(onHoverUpdate.mock.calls.length, 1);
  });

  test('mouseout calls tapBehavior.onEnd when tap is active', () => {
    const {groupDivId} = setupLayerCanvas();
    const onTapEnd = vi.fn();
    const tap = {
      isActive: () => true,
      onTap() {
        // no-op
      },
      onUpdate() {
        // no-op
      },
      onEnd: onTapEnd
    };
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      tapBehavior: tap
    });

    pointer.mouseout(new MouseEvent('mouseout', {bubbles: true}));
    assert.equal(onTapEnd.mock.calls.length, 1);
  });

  test('touchstart, touchmove, touchend drive drag lifecycle', () => {
    vi.useFakeTimers();
    const {canvas, groupDivId} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(4, 5)]);
    const onStart = vi.fn();
    const onUpdate = vi.fn();
    const onEnd = vi.fn();

    class T extends DragBehavior {
      onStart(p, lg) {
        onStart(p, lg);
        super.onStart(p, lg);
      }
      onUpdate(p, lg) {
        onUpdate(p, lg);
        super.onUpdate(p, lg);
      }
      onEnd() {
        onEnd();
        super.onEnd();
      }
    }

    const drag = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: drag,
      longTouchToDblClickMs: 500
    });

    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.equal(onStart.mock.calls.length, 1);
    assert.ok(drag.isActive());

    getTouchPointsSpy.mockReturnValue([new Point2D(10, 12)]);
    pointer.touchmove(touchEvent('touchmove', canvas));
    assert.equal(onUpdate.mock.calls.length, 1);

    pointer.touchend(touchEvent('touchend', canvas));
    assert.equal(onEnd.mock.calls.length, 1);
    assert.equal(drag.isActive(), false);

    vi.advanceTimersByTime(600);
    vi.useRealTimers();
  });

  test('touchstart with two touches ends active one-finger drag', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const p1 = new Point2D(1, 2);
    const p2 = new Point2D(3, 4);
    const reset = vi.fn();

    class T extends DragBehavior {
      reset() {
        reset();
        super.reset();
      }
    }

    const drag = new T();
    const twoOnStart = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: drag,
      twoTouchBehavior: {
        onStart: twoOnStart,
        onUpdate: vi.fn(),
        onEnd: vi.fn(),
        reset: vi.fn()
      }
    });

    // touchstart reads touch points twice: once for branch selection and once
    // when building the drag start context.
    getTouchPointsSpy.mockReturnValue([p1]);
    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.ok(drag.isActive());

    getTouchPointsSpy.mockReturnValue([p1, p2]);
    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.equal(reset.mock.calls.length, 1);
    assert.equal(drag.isActive(), false);
    assert.equal(twoOnStart.mock.calls.length, 1);
  });

  test('two-touch events drive TwoTouchBehavior lifecycle', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const layerGroup = {};
    const p1 = new Point2D(1, 2);
    const p2 = new Point2D(3, 4);
    const p1m = new Point2D(5, 6);
    const p2m = new Point2D(7, 8);

    const onStart = vi.fn();
    const onUpdate = vi.fn();
    const onEnd = vi.fn();

    class T extends TwoTouchBehavior {
      #active = false;
      isActive() {
        return this.#active;
      }
      onStart(points) {
        onStart(points);
        this.#active = true;
      }
      onUpdate(points, lg) {
        onUpdate(points, lg);
        return true;
      }
      onEnd() {
        onEnd();
        this.#active = false;
      }
    }

    const twoTouch = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? layerGroup : undefined)
      },
      dragBehavior: new DragBehavior(),
      twoTouchBehavior: twoTouch
    });

    getTouchPointsSpy.mockReturnValue([p1, p2]);
    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.equal(onStart.mock.calls.length, 1);
    assert.deepEqual(onStart.mock.calls[0][0], [p1, p2]);
    assert.ok(twoTouch.isActive());

    getTouchPointsSpy.mockReturnValue([p1m, p2m]);
    pointer.touchmove(touchEvent('touchmove', canvas));
    assert.equal(onUpdate.mock.calls.length, 1);
    assert.deepEqual(onUpdate.mock.calls[0][0], [p1m, p2m]);
    assert.equal(onUpdate.mock.calls[0][1], layerGroup);

    pointer.touchend(touchEvent('touchend', canvas));
    assert.equal(onEnd.mock.calls.length, 1);
    assert.equal(twoTouch.isActive(), false);
  });

  test('cancel ends active TwoTouchBehavior', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([
      new Point2D(0, 0),
      new Point2D(10, 10)
    ]);
    const reset = vi.fn();

    class T extends TwoTouchBehavior {
      #active = false;
      isActive() {
        return this.#active;
      }
      onStart() {
        this.#active = true;
      }
      reset() {
        this.#active = false;
        reset();
      }
      onEnd() {
        this.reset();
      }
    }

    const twoTouch = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      twoTouchBehavior: twoTouch
    });

    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.ok(twoTouch.isActive());

    pointer.cancel();
    assert.equal(reset.mock.calls.length, 1);
    assert.equal(twoTouch.isActive(), false);
  });

  test('mousedown does not start drag when canStart returns false', () => {
    const {canvas} = setupLayerCanvas();
    const onStart = vi.fn();

    class NoDrag extends DragBehavior {
      canStart() {
        return false;
      }
      onStart(p, lg) {
        onStart(p, lg);
        super.onStart(p, lg);
      }
    }

    const drag = new NoDrag();
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: drag
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 1, 1));
    assert.equal(onStart.mock.calls.length, 0);
    assert.equal(drag.isActive(), false);
  });

  test('undefined dragBehavior skips drag; hover and tap still work', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onHoverUpdate = vi.fn();
    const onHoverEnd = vi.fn();
    const onTap = vi.fn();

    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: undefined,
      hoverBehavior: {
        reset() {},
        onUpdate: onHoverUpdate,
        onEnd: onHoverEnd
      },
      tapBehavior: {
        onTap,
        isActive() {
          return false;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousemove(mouseEvent('mousemove', canvas, 1, 1));
    assert.equal(onHoverUpdate.mock.calls.length, 1);

    pointer.mousedown(mouseEvent('mousedown', canvas, 1, 1));
    pointer.mousemove(mouseEvent('mousemove', canvas, 20, 20));
    assert.equal(onHoverUpdate.mock.calls.length, 1);
    assert.equal(onHoverEnd.mock.calls.length, 1);

    pointer.mouseup(mouseEvent('mouseup', canvas, 20, 20));

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    pointer.mouseup(mouseEvent('mouseup', canvas, 0, 0));
    assert.equal(onTap.mock.calls.length, 1);

    pointer.mouseout(new MouseEvent('mouseout', {bubbles: true}));
    assert.equal(onHoverEnd.mock.calls.length, 2);

    pointer.cancel();
  });

  test('mousemove calls hoverBehavior.onUpdate when drag is inactive', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onHoverUpdate = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      hoverBehavior: {
        onUpdate: onHoverUpdate,
        onEnd: vi.fn()
      }
    });

    pointer.mousemove(mouseEvent('mousemove', canvas, 7, 8));
    assert.equal(onHoverUpdate.mock.calls.length, 1);
  });

  test('wheel calls onWheel, preventDefault, and onWheelTick on tick', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const layerGroup = {};
    const onWheel = vi.fn();
    const onWheelTick = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? layerGroup : undefined)
      },
      dragBehavior: new DragBehavior(),
      wheelBehavior: {onWheel, onWheelTick}
    });

    const ev = wheelEvent(canvas, {wheelDeltaY: 120});
    pointer.wheel(ev);
    assert.ok(ev.defaultPrevented);
    assert.equal(onWheel.mock.calls.length, 1);
    assert.equal(onWheel.mock.calls[0][0], ev);
    assert.equal(onWheel.mock.calls[0][1], layerGroup);
    assert.equal(onWheelTick.mock.calls.length, 1);
    assert.equal(onWheelTick.mock.calls[0][0], true);
    assert.equal(onWheelTick.mock.calls[0][1], layerGroup);
  });

  test('wheel without wheelBehavior does not prevent default', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior()
    });

    const ev = wheelEvent(canvas, {wheelDeltaY: 120});
    pointer.wheel(ev);
    assert.equal(ev.defaultPrevented, false);
  });

  test('wheel onWheel each move; onWheelTick when tick threshold met', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onWheel = vi.fn();
    const onWheelTick = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) =>
          (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      wheelBehavior: {onWheel, onWheelTick}
    });

    pointer.wheel(wheelEvent(canvas, {deltaY: 0.5}));
    assert.equal(onWheel.mock.calls.length, 1);
    assert.equal(onWheelTick.mock.calls.length, 0);

    pointer.wheel(wheelEvent(canvas, {deltaY: 0.5}));
    assert.equal(onWheel.mock.calls.length, 2);
    assert.equal(onWheelTick.mock.calls.length, 1);
    assert.equal(onWheelTick.mock.calls[0][0], false);
  });

  test('mouseup invokes tap when there was no move', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onTap = vi.fn();
    class NoStartDrag extends DragBehavior {
      canStart() {
        return false;
      }
    }
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new NoStartDrag(),
      tapBehavior: {
        onTap,
        isActive() {
          return false;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 2, 3));
    pointer.mouseup(mouseEvent('mouseup', canvas, 2, 3));
    assert.equal(onTap.mock.calls.length, 1);
  });

  test('mouseup does reset active drag if pointer did not move', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onEnd = vi.fn();
    class T extends DragBehavior {
      onEnd() {
        onEnd();
        super.onEnd();
      }
    }
    const drag = new T();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: drag
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 1, 1));
    assert.ok(drag.isActive());

    pointer.mouseup(mouseEvent('mouseup', canvas, 1, 1));
    assert.equal(onEnd.mock.calls.length, 0);
    assert.equal(drag.isActive(), false);
  });

  test('mouseup does not tap after mousemove past tolerance', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onTap = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      tapBehavior: {
        onTap,
        isActive() {
          return false;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    pointer.mousemove(mouseEvent('mousemove', canvas, 20, 20));
    pointer.mouseup(mouseEvent('mouseup', canvas, 20, 20));
    assert.equal(onTap.mock.calls.length, 0);
  });

  test('mouseup still taps after a small mousemove within tolerance', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onTap = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      tapBehavior: {
        onTap,
        isActive() {
          return false;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    pointer.mousemove(mouseEvent('mousemove', canvas, 1, 1));
    pointer.mouseup(mouseEvent('mouseup', canvas, 1, 1));
    assert.equal(onTap.mock.calls.length, 1);
  });

  test('mouseup taps on a live tolerance check: a move far from the down ' +
    'point that returns within tolerance still taps', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onTap = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new DragBehavior(),
      tapBehavior: {
        onTap,
        isActive() {
          return false;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    pointer.mousemove(mouseEvent('mousemove', canvas, 20, 20));
    pointer.mouseup(mouseEvent('mouseup', canvas, 1, 1));
    assert.equal(onTap.mock.calls.length, 1);
  });

  test('mouseup invokes tap when tap is active even after mousemove', () => {
    const {canvas, groupDivId} = setupLayerCanvas();
    const onTap = vi.fn();
    class NoStartDrag extends DragBehavior {
      canStart() {
        return false;
      }
    }
    const pointer = new LayerGroupPointer({
      stageController: {
        getLayerGroupByDivId: (id) => (id === groupDivId ? {} : undefined)
      },
      dragBehavior: new NoStartDrag(),
      tapBehavior: {
        onTap,
        isActive() {
          return true;
        },
        onUpdate() {
          // no-op
        },
        reset() {
          // no-op
        }
      }
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    pointer.mousemove(mouseEvent('mousemove', canvas, 4, 4));
    pointer.mouseup(mouseEvent('mouseup', canvas, 4, 4));
    assert.equal(onTap.mock.calls.length, 1);
  });

  test('cancel clears long-touch timer', () => {
    vi.useFakeTimers();
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
    const reset = vi.fn();
    class T extends DragBehavior {
      reset() {
        reset();
        super.reset();
      }
    }
    const drag = new T();
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: drag
    });

    pointer.mousedown(mouseEvent('mousedown', canvas, 0, 0));
    assert.ok(drag.isActive());

    pointer.touchstart(touchEvent('touchstart', canvas));
    pointer.cancel();
    // touchstart resets active drag before starting touch drag, then cancel
    // resets the active touch drag state once more.
    assert.equal(reset.mock.calls.length, 2);
    assert.equal(drag.isActive(), false);

    vi.advanceTimersByTime(600);
    vi.useRealTimers();
  });

  test('touchstart schedules dblclick after default delay', () => {
    vi.useFakeTimers();
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
    const onDoubleClick = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: new DragBehavior(),
      doubleClickBehavior: {onDoubleClick}
    });

    pointer.touchstart(touchEvent('touchstart', canvas));
    vi.advanceTimersByTime(499);
    assert.equal(onDoubleClick.mock.calls.length, 0);
    vi.advanceTimersByTime(2);
    assert.equal(onDoubleClick.mock.calls.length, 1);
    vi.useRealTimers();
  });

  test('touchmove clears long-touch dblclick timer', () => {
    vi.useFakeTimers();
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
    const onDoubleClick = vi.fn();
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: new DragBehavior(),
      doubleClickBehavior: {onDoubleClick}
    });

    pointer.touchstart(touchEvent('touchstart', canvas));
    pointer.touchmove(touchEvent('touchmove', canvas));
    vi.advanceTimersByTime(600);
    assert.equal(onDoubleClick.mock.calls.length, 0);
    vi.useRealTimers();
  });

  test('touchstart prevents default without long-touch delay', () => {
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: new DragBehavior(),
      longTouchToDblClickMs: null
    });

    const ev = touchEvent('touchstart', canvas);
    pointer.touchstart(ev);
    assert.ok(ev.defaultPrevented);
  });

  test('touchstart prevents default with two touches', () => {
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1), new Point2D(2, 2)]);
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})}
    });

    const ev = touchEvent('touchstart', canvas);
    pointer.touchstart(ev);
    assert.ok(ev.defaultPrevented);
  });

  test('preventDefault is only called on non passive interaction events',
    () => {
      const {canvas} = setupLayerCanvas();
      getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
      const pointer = new LayerGroupPointer({
        stageController: {getLayerGroupByDivId: () => ({})},
        dragBehavior: new DragBehavior(),
        wheelBehavior: {onWheel: vi.fn(), onWheelTick: vi.fn()},
        longTouchToDblClickMs: null
      });

      for (const name of generic.InteractionEventNames) {
        // not all events are handled by the pointer
        if (typeof pointer[name] === 'undefined') {
          continue;
        }
        let ev;
        if (name === 'wheel') {
          ev = wheelEvent(canvas, {wheelDeltaY: 120});
        } else if (name.startsWith('touch')) {
          ev = touchEvent(name, canvas);
        } else {
          ev = mouseEvent(name, canvas, 1, 1);
        }
        pointer[name](ev);
        if (ev.defaultPrevented) {
          assert.ok(generic.NonPassiveInteractionEventNames.includes(name),
            `${name} default prevented but listened to as passive`);
        }
      }
    });

  test('touchcancel clears long-touch timer and resets drag', () => {
    vi.useFakeTimers();
    const {canvas} = setupLayerCanvas();
    getTouchPointsSpy.mockReturnValue([new Point2D(1, 1)]);
    const onDoubleClick = vi.fn();
    const drag = new DragBehavior();
    const pointer = new LayerGroupPointer({
      stageController: {getLayerGroupByDivId: () => ({})},
      dragBehavior: drag,
      doubleClickBehavior: {onDoubleClick}
    });

    pointer.touchstart(touchEvent('touchstart', canvas));
    assert.ok(drag.isActive());
    pointer.touchcancel(touchEvent('touchcancel', canvas));
    assert.equal(drag.isActive(), false);
    vi.advanceTimersByTime(600);
    assert.equal(onDoubleClick.mock.calls.length, 0);
    vi.useRealTimers();
  });
});