malice

import assert from 'node:assert/strict';

import { test } from 'node:test';

import { PressTracker, type Timers } from '../src/lib/longpress.ts';

function clock() {

  let now = 0;

  let next = 1;

  const queue = new Map<number, { at: number; fn: () => void }>();

  const timers: Timers = {

    set(fn, ms) {

      const id = next++;

      queue.set(id, { at: now + ms, fn });

      return id;

    },

    clear(handle) {

      queue.delete(handle as number);

    }

  };

  const advance = (ms: number) => {

    now += ms;

    for (const [id, t] of [...queue]) {

      if (t.at <= now) {

        queue.delete(id);

        t.fn();

      }

    }

  };

  return { timers, advance };

}

function setup() {

  const c = clock();

  const fires: Array<[number, number]> = [];

  const tracker = new PressTracker((x, y) => fires.push([x, y]), c.timers);

  return { ...c, tracker, fires };

}

test('fires with the press origin after the delay', () => {

  const { tracker, advance, fires } = setup();

  tracker.start(10, 20);

  advance(449);

  assert.deepEqual(fires, []);

  advance(1);

  assert.deepEqual(fires, [[10, 20]]);

  assert.equal(tracker.fired, true);

});

test('release before the delay cancels', () => {

  const { tracker, advance, fires } = setup();

  tracker.start(0, 0);

  advance(200);

  tracker.cancel();

  advance(1000);

  assert.deepEqual(fires, []);

  assert.equal(tracker.fired, false);

});

test('small jitter is tolerated, a drag cancels', () => {

  const a = setup();

  a.tracker.start(0, 0);

  a.tracker.move(4, 4);

  a.advance(450);

  assert.equal(a.fires.length, 1);

  const b = setup();

  b.tracker.start(0, 0);

  b.tracker.move(9, 0);

  b.advance(450);

  assert.equal(b.fires.length, 0);

});

test('a new press clears the fired flag', () => {

  const { tracker, advance } = setup();

  tracker.start(0, 0);

  advance(450);

  tracker.start(5, 5);

  assert.equal(tracker.fired, false);

  assert.equal(tracker.pending, true);

});

test('flush fires a pending press once and ignores an idle tracker', () => {

  const { tracker, advance, fires } = setup();

  tracker.flush();

  assert.equal(fires.length, 0);

  tracker.start(3, 4);

  tracker.flush();

  advance(1000);

  assert.deepEqual(fires, [[3, 4]]);

  assert.equal(tracker.fired, true);

});