@astryxdesign/core 0.7.6-canary.f73623d → 0.7.6-canary.f77aaf2

package/src/gestures/__tests__/TapGestureRecognizer.test.ts

@@ -1,154 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file TapGestureRecognizer.test.ts
- * @input Synthetic touches with explicit timestamps through a GestureArena
- * @output TapGestureRecognizer's state machine: single and multiple taps with one or more fingers: recognition at the lift, the movement, interval, separation and hold limits
- * @position Unit tests of packages/core/src/gestures/TapGestureRecognizer.ts
- */
-
-import {describe, expect, it} from 'vitest';
-import {UIKIT_GESTURES} from '../../motion/uikit/gestures';
-import {TapGestureRecognizer} from '../TapGestureRecognizer';
-import {createHarness} from './harness';
-
-describe('TapGestureRecognizer', () => {
-  it('recognizes a single tap at the lift', () => {
-    const h = createHarness();
-    const tap = new TapGestureRecognizer({name: 'tap'});
-    const actions: string[] = [];
-    tap.addListener(r => actions.push(`${r.state}@${h.arena.now()}`));
-    h.finger(1)
-      .down(100, 100, 0, {recognizers: [tap]})
-      .move(103, 101, 40);
-    expect(tap.state).toBe('possible');
-    h.finger(1).up(80, 103, 101);
-    expect(actions).toEqual(['ended@80']);
-    expect(h.log).toEqual(['tap:ended@80', 'tap:possible@80']);
-    expect(tap.location()).toEqual({x: 103, y: 101});
-  });
-
-  it('fails once a finger travels past the allowable movement', () => {
-    const h = createHarness();
-    const tap = new TapGestureRecognizer({name: 'tap'});
-    const allowed = UIKIT_GESTURES.tap.allowableMovement.value;
-    h.finger(1)
-      .down(0, 0, 0, {recognizers: [tap]})
-      .move(allowed, 0, 16);
-    expect(tap.state).toBe('possible');
-    h.finger(1).move(allowed + 0.5, 0, 32);
-    expect(tap.state).toBe('failed');
-    h.finger(1).up(48);
-    expect(h.log).toEqual(['tap:failed@32', 'tap:possible@48']);
-  });
-
-  it('fails when more fingers land than required, and taps with two', () => {
-    const h = createHarness();
-    const one = new TapGestureRecognizer({name: 'one'});
-    const two = new TapGestureRecognizer({
-      name: 'two',
-      numberOfTouchesRequired: 2,
-    });
-    h.finger(1).down(0, 0, 0, {recognizers: [one, two]});
-    h.finger(2).down(40, 0, 20, {recognizers: [one, two]});
-    expect(one.state).toBe('failed');
-    h.finger(1).up(60);
-    expect(two.state).toBe('possible');
-    h.finger(2).up(70);
-    expect(h.log).toEqual([
-      'one:failed@20',
-      'two:ended@70',
-      'one:possible@70',
-      'two:possible@70',
-    ]);
-  });
-
-  it('recognizes a double tap inside the interval and fails outside it', () => {
-    const interval = UIKIT_GESTURES.tap.maximumIntervalBetweenTaps.value;
-    const h = createHarness();
-    const double = new TapGestureRecognizer({
-      name: 'double',
-      numberOfTapsRequired: 2,
-    });
-    h.finger(1).down(0, 0, 0, {recognizers: [double]});
-    h.finger(1).up(60);
-    expect(double.state).toBe('possible');
-    expect(double.completedTaps).toBe(1);
-    h.finger(2).down(4, 2, 60 + interval - 1, {recognizers: [double]});
-    h.finger(2).up(60 + interval + 50);
-    expect(h.log).toEqual([
-      `double:ended@${60 + interval + 50}`,
-      `double:possible@${60 + interval + 50}`,
-    ]);
-
-    const late = createHarness();
-    const slow = new TapGestureRecognizer({
-      name: 'slow',
-      numberOfTapsRequired: 2,
-    });
-    late.finger(1).down(0, 0, 0, {recognizers: [slow]});
-    late.finger(1).up(60);
-    late.finger(2).down(0, 0, 60 + interval + 1, {recognizers: [slow]});
-    // The interval timer fired at its own deadline, before the late touch.
-    expect(late.log[0]).toBe(`slow:failed@${60 + interval}`);
-  });
-
-  it('fails a second tap that lands too far from the first', () => {
-    const h = createHarness();
-    const double = new TapGestureRecognizer({
-      name: 'double',
-      numberOfTapsRequired: 2,
-    });
-    const separation = UIKIT_GESTURES.tap.allowableSeparation.value;
-    h.finger(1).down(0, 0, 0, {recognizers: [double]});
-    h.finger(1).up(50);
-    h.finger(2).down(separation + 1, 0, 100, {recognizers: [double]});
-    expect(double.state).toBe('failed');
-  });
-
-  it('recognizes a two-finger double tap, placing each tap at its fingers’ centroid', () => {
-    const separation = UIKIT_GESTURES.tap.allowableSeparation.value;
-    const make = () => {
-      const h = createHarness();
-      const tap = new TapGestureRecognizer({
-        name: 'two',
-        numberOfTapsRequired: 2,
-        numberOfTouchesRequired: 2,
-      });
-      // First tap: fingers 80 px apart, the right one lifting last.
-      h.finger(1).down(0, 0, 0, {recognizers: [tap]});
-      h.finger(2).down(80, 0, 10, {recognizers: [tap]});
-      h.finger(1).up(50);
-      h.finger(2).up(60);
-      expect(tap.completedTaps).toBe(1);
-      return {h, tap};
-    };
-    // The same two fingers again, a few px off: one double tap, though the
-    // first finger lands 78 px from where the last one lifted.
-    const near = make();
-    near.h.finger(3).down(2, 1, 150, {recognizers: [near.tap]});
-    near.h.finger(4).down(82, 1, 160, {recognizers: [near.tap]});
-    near.h.finger(3).up(200);
-    near.h.finger(4).up(210);
-    expect(near.h.log).toEqual(['two:ended@210', 'two:possible@210']);
-    // A second tap whose centroid lands too far from the first's fails.
-    const far = make();
-    far.h.finger(3).down(separation + 1, 0, 150, {recognizers: [far.tap]});
-    expect(far.tap.state).toBe('possible');
-    far.h.finger(4).down(separation + 81, 0, 160, {recognizers: [far.tap]});
-    expect(far.tap.state).toBe('failed');
-  });
-
-  it('fails a hold past a finite maximum tap duration', () => {
-    const h = createHarness();
-    const tap = new TapGestureRecognizer({
-      name: 'tap',
-      maximumTapDuration: 400,
-    });
-    h.finger(1).down(0, 0, 0, {recognizers: [tap]});
-    h.advance(399);
-    expect(tap.state).toBe('possible');
-    h.advance(400);
-    expect(tap.state).toBe('failed');
-  });
-});

package/src/gestures/__tests__/VelocityTracker.streams.test.ts

@@ -1,243 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file VelocityTracker.streams.test.ts
- * @input Recorded pointer and touch streams (fixtures/pointer-streams): what
- *   real browsers delivered for a slow drag, a fling and a stop-then-release —
- *   Chromium and Firefox on an Android emulator, Safari on an iOS simulator,
- *   and desktop Chromium's mouse, pen and touch — each with its events'
- *   timestamps and `getCoalescedEvents()` samples, and the injected ground
- *   truth
- * @output VelocityTracker's release velocity on each, fed one sample per
- *   pointermove as PanGestureRecognizer reads them: within 10% of the
- *   injected speed for the slow drag and the fling (the iOS streams miss it
- *   and are checked for direction only), 0 for the stop-then-release; the
- *   same under a busy main thread that dispatches one event per four input
- *   samples; the touch stream agrees with the pointer stream; a shifted clock
- *   changes nothing (spec:AST-100 FR4)
- * @position Evidence for the velocity source on real input streams; the
- *   synthetic cases are in VelocityTracker.test.ts. The fixtures' README says
- *   how they were captured and what the rig's input is not.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import {describe, expect, it} from 'vitest';
-import {VelocityTracker} from '../VelocityTracker';
-
-/** [time ms after the pointerdown, x, y] in CSS px from where it went down. */
-type Sample = readonly [number, number, number];
-type StreamEvent =
-  | readonly [string, number, number, number]
-  | readonly [
-      string,
-      number,
-      number,
-      number,
-      ReadonlyArray<Sample>,
-      number | null,
-    ];
-
-interface Fixture {
-  readonly file: string;
-  readonly schema: 1;
-  readonly platform: string;
-  readonly browser: string;
-  readonly pointerType: 'touch' | 'pen' | 'mouse';
-  readonly gesture: 'slow' | 'fling' | 'stop-release';
-  readonly caveat: string;
-  /** `speed`: px/s along y while the contact moved. */
-  readonly injected: {readonly speed: number};
-  /**
-   * Where the replay releases (the lift, or the last move). Its velocity is
-   * checked against the injected speed, except (`shape`) for a stream that
-   * misses it by more than 10%: only its direction and axis are checked.
-   * `note` says why.
-   */
-  readonly release: {
-    readonly at: 'pointerup' | 'lastMove';
-    readonly check?: 'shape';
-    readonly note?: string;
-  };
-  readonly events: ReadonlyArray<StreamEvent>;
-}
-
-const DIR = path.resolve(__dirname, 'fixtures/pointer-streams');
-const FIXTURES: Fixture[] = fs
-  .readdirSync(DIR)
-  .filter(name => name.endsWith('.json'))
-  .sort()
-  .map(name => ({
-    file: name,
-    ...(JSON.parse(fs.readFileSync(path.join(DIR, name), 'utf8')) as Omit<
-      Fixture,
-      'file'
-    >),
-  }));
-
-const of = (f: Fixture, type: string) => f.events.filter(e => e[0] === type);
-
-/**
- * What PanGestureRecognizer feeds its tracker: the touch-down, then each
- * pointermove event's own position and time, one sample per event (it does
- * not read `getCoalescedEvents()`).
- */
-function pointerSamples(f: Fixture): Sample[] {
-  return [...of(f, 'pointerdown').slice(0, 1), ...of(f, 'pointermove')].map(
-    e => [e[1], e[2], e[3]] as const,
-  );
-}
-
-/**
- * The input the browser received: the touch-down, then each pointermove's
- * coalesced samples in order, or the event itself when its list is empty.
- */
-function inputSamples(f: Fixture): Sample[] {
-  const down = of(f, 'pointerdown')[0];
-  const samples: Sample[] = [[down[1], down[2], down[3]]];
-  for (const move of of(f, 'pointermove')) {
-    const coalesced: ReadonlyArray<Sample> =
-      (move.length > 4 ? move[4] : undefined) ?? [];
-    samples.push(
-      ...(coalesced.length > 0
-        ? coalesced
-        : [[move[1], move[2], move[3]] as const]),
-    );
-  }
-  return samples;
-}
-
-/**
- * What the recognizer reads when the main thread is busy: the browser
- * dispatches one pointermove per `every` input samples, at the latest of
- * them, and folds the rest into its coalesced list.
- */
-function busySamples(f: Fixture, every: number): Sample[] {
-  const input = inputSamples(f);
-  const samples: Sample[] = [input[0]];
-  for (let i = 1; i < input.length; i += every) {
-    samples.push(input[Math.min(i + every - 1, input.length - 1)]);
-  }
-  return samples;
-}
-
-/** The same contact from its touch events: the touchstart, then each touchmove. */
-function touchSamples(f: Fixture): Sample[] {
-  return [...of(f, 'touchstart'), ...of(f, 'touchmove')].map(
-    e => [e[1], e[2], e[3]] as const,
-  );
-}
-
-function releaseTime(
-  f: Fixture,
-  lift: string,
-  moves: ReadonlyArray<Sample>,
-): number {
-  return f.release.at === 'lastMove'
-    ? moves[moves.length - 1][0]
-    : of(f, lift)[0][1];
-}
-
-/** Replays samples through a tracker, on a clock shifted by `shift` ms. */
-function replay(
-  samples: ReadonlyArray<Sample>,
-  release: number,
-  {shift = 0}: {shift?: number} = {},
-) {
-  const tracker = new VelocityTracker();
-  for (const [time, x, y] of samples) {
-    tracker.add(x, y, time + shift);
-  }
-  return {
-    pan: tracker.velocity(release + shift),
-    scroll: tracker.scrollVelocity(release + shift),
-  };
-}
-
-describe('VelocityTracker on recorded pointer streams (spec:AST-100 FR4)', () => {
-  it('has a slow drag, a fling and a stop-then-release for every platform, browser and pointer type', () => {
-    const sources = [
-      'android-chromium',
-      'android-firefox',
-      'ios-safari',
-      'desktop-chromium-mouse',
-      'desktop-chromium-pen',
-      'desktop-chromium-touch',
-    ];
-    expect(FIXTURES.map(f => f.file)).toEqual(
-      sources
-        .flatMap(source =>
-          ['fling', 'slow', 'stop-release'].map(g => `${source}-${g}.json`),
-        )
-        .sort(),
-    );
-    for (const f of FIXTURES) {
-      expect(f.schema).toBe(1);
-      expect(f.caveat).toMatch(/not a finger/);
-    }
-  });
-
-  for (const f of FIXTURES) {
-    describe(`${f.file} (${f.browser}, ${f.pointerType})`, () => {
-      const samples = pointerSamples(f);
-      const release = releaseTime(f, 'pointerup', samples);
-      const pointer = replay(samples, release);
-
-      if (f.gesture === 'stop-release') {
-        it('releases at 0 after holding still', () => {
-          expect(pointer.pan).toEqual({x: 0, y: 0});
-          expect(pointer.scroll).toEqual({x: 0, y: 0});
-        });
-      } else if (f.release.check === 'shape') {
-        it('is not velocity evidence: it releases moving along +y, with x under 10% of y', () => {
-          expect(pointer.pan.y).toBeGreaterThan(0);
-          expect(Math.abs(pointer.pan.x)).toBeLessThanOrEqual(
-            0.1 * pointer.pan.y,
-          );
-        });
-      } else {
-        it('releases within 10% of the injected speed', () => {
-          const speed = f.injected.speed;
-          expect(Math.abs(pointer.pan.y - speed)).toBeLessThanOrEqual(
-            0.1 * speed,
-          );
-          expect(Math.abs(pointer.scroll.y - speed)).toBeLessThanOrEqual(
-            0.1 * speed,
-          );
-          expect(Math.abs(pointer.pan.x)).toBeLessThanOrEqual(0.1 * speed);
-        });
-      }
-
-      const touches = touchSamples(f);
-      if (touches.length > 1) {
-        it('reads the same velocity from the touch stream, within 10%', () => {
-          const touch = replay(touches, releaseTime(f, 'touchend', touches));
-          const scale = Math.max(Math.abs(pointer.pan.y), 1);
-          expect(Math.abs(touch.pan.y - pointer.pan.y)).toBeLessThanOrEqual(
-            0.1 * scale,
-          );
-        });
-      }
-
-      if (f.release.check !== 'shape') {
-        it('reads the same under a busy main thread: one event per four input samples', () => {
-          const busy = replay(busySamples(f, 4), release);
-          if (f.gesture === 'stop-release') {
-            expect(busy.pan).toEqual({x: 0, y: 0});
-          } else {
-            const speed = f.injected.speed;
-            expect(Math.abs(busy.pan.y - speed)).toBeLessThanOrEqual(
-              0.1 * speed,
-            );
-          }
-        });
-      }
-
-      it('reads each event’s own time: a shifted clock changes nothing', () => {
-        const shifted = replay(samples, release, {shift: 123_456.789});
-        expect(shifted.pan.x).toBeCloseTo(pointer.pan.x, 6);
-        expect(shifted.pan.y).toBeCloseTo(pointer.pan.y, 6);
-      });
-    });
-  }
-});

package/src/gestures/__tests__/VelocityTracker.test.ts

@@ -1,261 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file VelocityTracker.test.ts
- * @input Synthetic finger traces with known velocities
- * @output UIKit's filter against the velocities UIKit reported on recorded
- *   touch streams; steady motion, a hard acceleration, the release rules
- *   (stillness, two moved samples), moved-only updates and the scroll-view
- *   release blend (architecture:interaction-modality INV10, spec:AST-100 FR2)
- * @position Unit tests of packages/core/src/gestures/VelocityTracker.ts
- */
-
-import {describe, expect, it} from 'vitest';
-import {VelocityTracker} from '../VelocityTracker';
-
-/** Feed `position(t)` sampled every `step` ms over [0, end]. */
-function trace(
-  tracker: VelocityTracker,
-  position: (t: number) => number,
-  end: number,
-  step = 8,
-): void {
-  for (let t = 0; t <= end; t += step) {
-    tracker.add(position(t), 0, t);
-  }
-}
-
-/**
- * Touch streams UIKit's UIPanGestureRecognizer reported on (iOS 26.2
- * simulator, HID touches at 60 Hz): [ms since touch-down, y in pt] per event,
- * and the velocity(in:).y UIKit reported at each event from the third on.
- */
-const UIKIT_STREAMS = {
-  steady: {
-    samples: [
-      [0, 840],
-      [57.702, 831.6666666666665],
-      [73.904, 815],
-      [91.286, 789.6666666666665],
-      [107.677, 773],
-      [125.123, 756.3333333333333],
-      [141.298, 739.6666666666665],
-      [157.709, 722.6666666666665],
-      [174.631, 706],
-      [191.78, 689.3333333333333],
-      [209.313, 672.6666666666666],
-      [226.956, 655.6666666666666],
-      [243.419, 639],
-      [260.223, 622.3333333333333],
-      [277.866, 605.6666666666666],
-      [294.774, 589],
-      [312.902, 572],
-      [333.081, 547],
-      [350.016, 530.3333333333333],
-      [368.475, 513.3333333333333],
-      [396.62, 488.33333333333326],
-    ],
-    velocities: [
-      -321.3, -1114.4, -1369.3, -1004.5, -970.3, -1031.5, -1025.7, -982.3,
-      -967.6, -953.2, -973.3, -1008.3, -982.4, -952.8, -976.1, -998.0, -1187.9,
-      -971.5, -914.4,
-    ],
-  },
-  accelerating: {
-    samples: [
-      [0, 840],
-      [70.032, 838.6666666666665],
-      [93.493, 827.6666666666665],
-      [110.376, 790],
-      [131.223, 701],
-      [147.373, 640],
-      [164.226, 567.6666666666666],
-      [181.326, 484.33333333333326],
-    ],
-    velocities: [-109.0, -821.3, -2638.6, -4170.8, -3880.1, -4408.3],
-  },
-} as const;
-
-describe('VelocityTracker', () => {
-  it.each(Object.entries(UIKIT_STREAMS))(
-    'uikit reproduces every velocity UIKit reported on the %s stream',
-    (_, {samples, velocities}) => {
-      const tracker = new VelocityTracker();
-      const errors: number[] = [];
-      samples.forEach(([time, y], index) => {
-        tracker.add(0, y, time);
-        if (index >= 2) {
-          errors.push(Math.abs(tracker.velocity().y - velocities[index - 2]));
-        }
-      });
-      expect(errors).toHaveLength(velocities.length);
-      // Within the rounding of the recorded values (0.1 pt/s) and of the
-      // timestamps (1 us).
-      expect(Math.max(...errors)).toBeLessThan(0.1);
-    },
-  );
-
-  it('keeps the last moving value through a rest while the finger is down', () => {
-    const tracker = new VelocityTracker();
-    trace(tracker, t => t * 2, 160);
-    // No event arrives while the finger rests: nothing changes the estimate.
-    expect(tracker.velocity().x).toBeCloseTo(2000, 6);
-  });
-
-  it('releases at 0 after a rest longer than the stillness interval (AST-100 FR2)', () => {
-    const tracker = new VelocityTracker({stillness: 40});
-    trace(tracker, t => t * 2, 160);
-    expect(tracker.velocity(168).x).toBeCloseTo(2000, 6);
-    expect(tracker.velocity(200).x).toBeCloseTo(2000, 6);
-    expect(tracker.velocity(201)).toEqual({x: 0, y: 0});
-    expect(tracker.scrollVelocity(201)).toEqual({x: 0, y: 0});
-  });
-
-  it('releases at 0 with fewer than two moved samples (AST-100)', () => {
-    const tracker = new VelocityTracker();
-    tracker.add(0, 0, 0);
-    tracker.add(10, 0, 8);
-    // One moved sample: the live value is that interval, the release is 0.
-    expect(tracker.velocity().x).toBeCloseTo(1250, 6);
-    expect(tracker.velocity(10)).toEqual({x: 0, y: 0});
-    expect(tracker.scrollVelocity(10)).toEqual({x: 0, y: 0});
-    tracker.add(20, 0, 16);
-    expect(tracker.velocity(18).x).toBeCloseTo(1250, 6);
-  });
-
-  it('updates only on moved samples (INV10)', () => {
-    const tracker = new VelocityTracker();
-    tracker.add(0, 0, 0);
-    tracker.add(10, 0, 10);
-    tracker.add(20, 0, 20);
-    const moving = tracker.velocity();
-    // An event at the same position is not motion: nothing changes, and the
-    // next move's interval runs from the last moved sample.
-    tracker.add(20, 0, 30);
-    expect(tracker.velocity()).toEqual(moving);
-    tracker.add(30, 0, 40);
-    // 10 px over the 20 ms since the last move: 500 px/s, after 1000 px/s.
-    expect(tracker.velocity().x).toBeCloseTo(0.2 * 500 + 0.8 * 1000, 6);
-  });
-
-  it('blends a scrolling surface\u2019s release from the last two pan values (INV10)', () => {
-    const tracker = new VelocityTracker();
-    tracker.add(0, 0, 0);
-    tracker.add(10, 0, 10);
-    tracker.add(20, 0, 20);
-    const previous = tracker.velocity().x;
-    tracker.add(40, 0, 30);
-    const newest = tracker.velocity().x;
-    expect(tracker.scrollVelocity(32).x).toBeCloseTo(
-      0.25 * newest + 0.75 * previous,
-      6,
-    );
-  });
-
-  // Four UIPickerView swipes, HID touches on the iOS 26.2 simulator: each
-  // stream is [ms since touch-down, y in pt], and the release is the velocity
-  // UIKit handed scrollViewWillEndDragging, in offset px/s.
-  it.each([
-    [
-      '200 pt in 50 ms',
-      [
-        [0, 368],
-        [46.48, 334.67],
-        [72.92, 201.33],
-      ],
-      933.4,
-    ],
-    [
-      '200 pt in 100 ms',
-      [
-        [0, 368],
-        [49.2, 351.33],
-        [65.27, 301.33],
-        [88.47, 251.33],
-        [104.68, 218],
-        [129.4, 168],
-      ],
-      2114,
-    ],
-    [
-      '200 pt in 200 ms',
-      [
-        [0, 368],
-        [46.01, 359.67],
-        [63.5, 334.67],
-        [81.36, 318],
-        [97.69, 301.33],
-        [120.12, 276.33],
-        [137.2, 259.67],
-        [171.83, 226.33],
-        [196.13, 201.33],
-        [212.66, 184.67],
-        [230.83, 168],
-      ],
-      1016.2,
-    ],
-    [
-      'a 90 pt flick',
-      [
-        [0, 353],
-        [41.5, 335],
-        [62.02, 281],
-      ],
-      543.6,
-    ],
-  ] as const)(
-    "reproduces UIKit's scroll release on a recorded UIPickerView swipe, %s (INV10)",
-    (_, stream, release) => {
-      const tracker = new VelocityTracker();
-      for (const [time, y] of stream) {
-        tracker.add(0, y, time);
-      }
-      const lift = stream[stream.length - 1][0];
-      // The content moves against the finger: its velocity is the finger's,
-      // negated.
-      const offset = -tracker.scrollVelocity(lift).y;
-      expect(Math.abs(offset - release) / release).toBeLessThan(0.001);
-    },
-  );
-
-  it('reads a steady 1000 px/s exactly', () => {
-    const tracker = new VelocityTracker();
-    trace(tracker, t => t, 200);
-    expect(tracker.velocity().x).toBeCloseTo(1000, 6);
-    expect(tracker.scrollVelocity(200).x).toBeCloseTo(1000, 6);
-  });
-
-  it('lags a hard acceleration by a frame, as UIKit does', () => {
-    // x = 0.02 t^2 (px, ms). UIKit's filter is 0.8 on the previous interval
-    // (its middle, 188 ms: 7520 px/s) and 0.2 on the newest (196 ms:
-    // 7840 px/s).
-    const tracker = new VelocityTracker();
-    trace(tracker, t => 0.02 * t * t, 200);
-    expect(tracker.velocity().x).toBeCloseTo(0.8 * 7520 + 0.2 * 7840, 3);
-  });
-
-  it('handles one and two samples, and repeated timestamps', () => {
-    const tracker = new VelocityTracker();
-    expect(tracker.velocity()).toEqual({x: 0, y: 0});
-    tracker.add(0, 0, 0);
-    expect(tracker.velocity()).toEqual({x: 0, y: 0});
-    tracker.add(10, 20, 10);
-    // One interval so far: reported whole.
-    expect(tracker.velocity()).toEqual({x: 1000, y: 2000});
-    // The same timestamp replaces the newest sample.
-    tracker.add(20, 20, 10);
-    expect(tracker.velocity().x).toBeCloseTo(2000, 6);
-    // An older timestamp is ignored.
-    tracker.add(500, 500, 5);
-    expect(tracker.lastSample).toEqual({x: 20, y: 20, time: 10});
-  });
-
-  it('forgets everything on reset', () => {
-    const tracker = new VelocityTracker();
-    trace(tracker, t => t, 80);
-    tracker.reset();
-    expect(tracker.lastSample).toBeNull();
-    expect(tracker.velocity()).toEqual({x: 0, y: 0});
-    expect(tracker.velocity(80)).toEqual({x: 0, y: 0});
-  });
-});