@amazon-devices/react-native-gesture-handler 4.0.1 → 4.0.2

package/lib/module/web/tools/LeastSquareSolver.js

@@ -1,154 +0,0 @@
-"use strict";
-
-// Implementation taken from Flutter's LeastSquareSolver
-// https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/gestures/lsq_solver.dart
-
-class Vector {
-  constructor(length) {
-    this.offset = 0;
-    this.length = length;
-    this.elements = new Array(length);
-  }
-  static fromVOL(values, offset, length) {
-    const result = new Vector(0);
-    result.offset = offset;
-    result.length = length;
-    result.elements = values;
-    return result;
-  }
-  get(index) {
-    return this.elements[this.offset + index];
-  }
-  set(index, value) {
-    this.elements[this.offset + index] = value;
-  }
-  dot(other) {
-    let result = 0;
-    for (let i = 0; i < this.length; i++) {
-      result += this.get(i) * other.get(i);
-    }
-    return result;
-  }
-  norm() {
-    return Math.sqrt(this.dot(this));
-  }
-}
-class Matrix {
-  constructor(rows, columns) {
-    this.columns = columns;
-    this.elements = new Array(rows * columns);
-  }
-  get(row, column) {
-    return this.elements[row * this.columns + column];
-  }
-  set(row, column, value) {
-    this.elements[row * this.columns + column] = value;
-  }
-  getRow(row) {
-    return Vector.fromVOL(this.elements, row * this.columns, this.columns);
-  }
-}
-
-// An nth degree polynomial fit to a dataset.
-class PolynomialFit {
-  // The polynomial coefficients of the fit.
-  //
-  // For each `i`, the element `coefficients[i]` is the coefficient of
-  // the `i`-th power of the variable.
-
-  // Creates a polynomial fit of the given degree.
-  //
-  // There are n + 1 coefficients in a fit of degree n.
-  constructor(degree) {
-    this.coefficients = new Array(degree + 1);
-  }
-}
-const precisionErrorTolerance = 1e-10;
-
-// Uses the least-squares algorithm to fit a polynomial to a set of data.
-export default class LeastSquareSolver {
-  // The x-coordinates of each data point.
-
-  // The y-coordinates of each data point.
-
-  // The weight to use for each data point.
-
-  // Creates a least-squares solver.
-  //
-  // The [x], [y], and [w] arguments must not be null.
-  constructor(x, y, w) {
-    this.x = x;
-    this.y = y;
-    this.w = w;
-  }
-
-  // Fits a polynomial of the given degree to the data points.
-  //
-  // When there is not enough data to fit a curve null is returned.
-  solve(degree) {
-    if (degree > this.x.length) {
-      // Not enough data to fit a curve.
-      return null;
-    }
-    const result = new PolynomialFit(degree);
-
-    // Shorthands for the purpose of notation equivalence to original C++ code.
-    const m = this.x.length;
-    const n = degree + 1;
-
-    // Expand the X vector to a matrix A, pre-multiplied by the weights.
-    const a = new Matrix(n, m);
-    for (let h = 0; h < m; h++) {
-      a.set(0, h, this.w[h]);
-      for (let i = 1; i < n; i++) {
-        a.set(i, h, a.get(i - 1, h) * this.x[h]);
-      }
-    }
-
-    // Apply the Gram-Schmidt process to A to obtain its QR decomposition.
-
-    // Orthonormal basis, column-major ordVectorer.
-    const q = new Matrix(n, m);
-    // Upper triangular matrix, row-major order.
-    const r = new Matrix(n, m);
-    for (let j = 0; j < n; j += 1) {
-      for (let h = 0; h < m; h += 1) {
-        q.set(j, h, a.get(j, h));
-      }
-      for (let i = 0; i < j; i += 1) {
-        const dot = q.getRow(j).dot(q.getRow(i));
-        for (let h = 0; h < m; h += 1) {
-          q.set(j, h, q.get(j, h) - dot * q.get(i, h));
-        }
-      }
-      const norm = q.getRow(j).norm();
-      if (norm < precisionErrorTolerance) {
-        // Vectors are linearly dependent or zero so no solution.
-        return null;
-      }
-      const inverseNorm = 1.0 / norm;
-      for (let h = 0; h < m; h += 1) {
-        q.set(j, h, q.get(j, h) * inverseNorm);
-      }
-      for (let i = 0; i < n; i += 1) {
-        r.set(j, i, i < j ? 0.0 : q.getRow(j).dot(a.getRow(i)));
-      }
-    }
-
-    // Solve R B = Qt W Y to find B. This is easy because R is upper triangular.
-    // We just work from bottom-right to top-left calculating B's coefficients.
-    const wy = new Vector(m);
-    for (let h = 0; h < m; h += 1) {
-      wy.set(h, this.y[h] * this.w[h]);
-    }
-    for (let i = n - 1; i >= 0; i -= 1) {
-      result.coefficients[i] = q.getRow(i).dot(wy);
-      for (let j = n - 1; j > i; j -= 1) {
-        result.coefficients[i] -= r.get(i, j) * result.coefficients[j];
-      }
-      result.coefficients[i] /= r.get(i, i);
-    }
-    return result;
-  }
-}
-//# sourceMappingURL=LeastSquareSolver.js.map

package/lib/module/web/tools/NodeManager.js

@@ -1,34 +0,0 @@
-"use strict";
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export default class NodeManager {
-  static gestures = {};
-  static getHandler(tag) {
-    if (tag in this.gestures) {
-      return this.gestures[tag];
-    }
-    throw new Error(`No handler for tag ${tag}`);
-  }
-  static createGestureHandler(handlerTag, handler) {
-    if (handlerTag in this.gestures) {
-      throw new Error(`Handler with tag ${handlerTag} already exists. Please ensure that no Gesture instance is used across multiple GestureDetectors.`);
-    }
-    this.gestures[handlerTag] = handler;
-    this.gestures[handlerTag].handlerTag = handlerTag;
-  }
-  static dropGestureHandler(handlerTag) {
-    if (!(handlerTag in this.gestures)) {
-      return;
-    }
-    this.gestures[handlerTag].onDestroy();
-
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-    delete this.gestures[handlerTag];
-  }
-  static get nodes() {
-    return {
-      ...this.gestures
-    };
-  }
-}
-//# sourceMappingURL=NodeManager.js.map

package/lib/module/web/tools/PointerEventManager.js

@@ -1,183 +0,0 @@
-"use strict";
-
-import EventManager from './EventManager';
-import { MouseButton } from '../../handlers/gestureHandlerCommon';
-import { EventTypes } from '../interfaces';
-import { PointerTypeMapping, calculateViewScale, tryExtractStylusData, isPointerInBounds } from '../utils';
-import { PointerType } from '../../PointerType';
-const POINTER_CAPTURE_EXCLUDE_LIST = new Set(['SELECT', 'INPUT']);
-export default class PointerEventManager extends EventManager {
-  trackedPointers = new Set();
-  mouseButtonsMapper = new Map();
-  constructor(view) {
-    super(view);
-    this.mouseButtonsMapper.set(0, MouseButton.LEFT);
-    this.mouseButtonsMapper.set(1, MouseButton.MIDDLE);
-    this.mouseButtonsMapper.set(2, MouseButton.RIGHT);
-    this.mouseButtonsMapper.set(3, MouseButton.BUTTON_4);
-    this.mouseButtonsMapper.set(4, MouseButton.BUTTON_5);
-    this.lastPosition = {
-      x: -Infinity,
-      y: -Infinity
-    };
-  }
-  pointerDownCallback = event => {
-    if (!isPointerInBounds(this.view, {
-      x: event.clientX,
-      y: event.clientY
-    })) {
-      return;
-    }
-    const adaptedEvent = this.mapEvent(event, EventTypes.DOWN);
-    const target = event.target;
-    if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.setPointerCapture(adaptedEvent.pointerId);
-    }
-    this.markAsInBounds(adaptedEvent.pointerId);
-    this.trackedPointers.add(adaptedEvent.pointerId);
-    if (++this.activePointersCounter > 1) {
-      adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_DOWN;
-      this.onPointerAdd(adaptedEvent);
-    } else {
-      this.onPointerDown(adaptedEvent);
-    }
-  };
-  pointerUpCallback = event => {
-    // When we call reset on gesture handlers, it also resets their event managers
-    // In some handlers (like RotationGestureHandler) reset is called before all pointers leave view
-    // This means, that activePointersCounter will be set to 0, while there are still remaining pointers on view
-    // Removing them will end in activePointersCounter going below 0, therefore handlers won't behave properly
-    if (this.activePointersCounter === 0) {
-      return;
-    }
-    const adaptedEvent = this.mapEvent(event, EventTypes.UP);
-    const target = event.target;
-    if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.releasePointerCapture(adaptedEvent.pointerId);
-    }
-    this.markAsOutOfBounds(adaptedEvent.pointerId);
-    this.trackedPointers.delete(adaptedEvent.pointerId);
-    if (--this.activePointersCounter > 0) {
-      adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_UP;
-      this.onPointerRemove(adaptedEvent);
-    } else {
-      this.onPointerUp(adaptedEvent);
-    }
-  };
-  pointerMoveCallback = event => {
-    const adaptedEvent = this.mapEvent(event, EventTypes.MOVE);
-    const target = event.target;
-
-    // You may be wondering why are we setting pointer capture here, when we
-    // already set it in `pointerdown` handler. Well, that's a great question,
-    // for which I don't have an answer. Specification (https://www.w3.org/TR/pointerevents2/#dom-element-setpointercapture)
-    // says that the requirement for `setPointerCapture` to work is that pointer
-    // must be in 'active buttons state`, otherwise it will fail silently, which
-    // is lovely. Obviously, when `pointerdown` is fired, one of the buttons
-    // (when using mouse) is pressed, but that doesn't mean that `setPointerCapture`
-    // will succeed, for some reason. Since it fails silently, we don't actually know
-    // if it worked or not (there's `gotpointercapture` event, but the complexity of
-    // incorporating it here seems stupid), so we just call it again here, every time
-    // pointer moves until it succeeds.
-    // God, I do love web development.
-    if (!target?.hasPointerCapture(event.pointerId) && !POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.setPointerCapture(event.pointerId);
-    }
-    const inBounds = isPointerInBounds(this.view, {
-      x: adaptedEvent.x,
-      y: adaptedEvent.y
-    });
-    const pointerIndex = this.pointersInBounds.indexOf(adaptedEvent.pointerId);
-    if (inBounds) {
-      if (pointerIndex < 0) {
-        adaptedEvent.eventType = EventTypes.ENTER;
-        this.onPointerEnter(adaptedEvent);
-        this.markAsInBounds(adaptedEvent.pointerId);
-      } else {
-        this.onPointerMove(adaptedEvent);
-      }
-    } else {
-      if (pointerIndex >= 0) {
-        adaptedEvent.eventType = EventTypes.LEAVE;
-        this.onPointerLeave(adaptedEvent);
-        this.markAsOutOfBounds(adaptedEvent.pointerId);
-      } else {
-        this.onPointerOutOfBounds(adaptedEvent);
-      }
-    }
-    this.lastPosition.x = event.x;
-    this.lastPosition.y = event.y;
-  };
-  pointerCancelCallback = event => {
-    const adaptedEvent = this.mapEvent(event, EventTypes.CANCEL);
-    this.onPointerCancel(adaptedEvent);
-    this.markAsOutOfBounds(adaptedEvent.pointerId);
-    this.activePointersCounter = 0;
-    this.trackedPointers.clear();
-  };
-  pointerEnterCallback = event => {
-    const adaptedEvent = this.mapEvent(event, EventTypes.ENTER);
-    this.onPointerMoveOver(adaptedEvent);
-  };
-  pointerLeaveCallback = event => {
-    const adaptedEvent = this.mapEvent(event, EventTypes.LEAVE);
-    this.onPointerMoveOut(adaptedEvent);
-  };
-  lostPointerCaptureCallback = event => {
-    const adaptedEvent = this.mapEvent(event, EventTypes.CANCEL);
-    if (this.trackedPointers.has(adaptedEvent.pointerId)) {
-      // In some cases the `pointerup` event is not fired, but `lostpointercapture` is.
-      // Here we simulate the `pointercancel` event to make sure the gesture handler stops tracking it.
-      this.onPointerCancel(adaptedEvent);
-      this.activePointersCounter = 0;
-      this.trackedPointers.clear();
-    }
-  };
-  registerListeners() {
-    this.view.addEventListener('pointerdown', this.pointerDownCallback);
-    this.view.addEventListener('pointerup', this.pointerUpCallback);
-    this.view.addEventListener('pointermove', this.pointerMoveCallback);
-    this.view.addEventListener('pointercancel', this.pointerCancelCallback);
-
-    // onPointerEnter and onPointerLeave are triggered by a custom logic responsible for
-    // handling shouldCancelWhenOutside flag, and are unreliable unless the pointer is down.
-    // We therefore use pointerenter and pointerleave events to handle the hover gesture,
-    // mapping them to onPointerMoveOver and onPointerMoveOut respectively.
-    this.view.addEventListener('pointerenter', this.pointerEnterCallback);
-    this.view.addEventListener('pointerleave', this.pointerLeaveCallback);
-    this.view.addEventListener('lostpointercapture', this.lostPointerCaptureCallback);
-  }
-  unregisterListeners() {
-    this.view.removeEventListener('pointerdown', this.pointerDownCallback);
-    this.view.removeEventListener('pointerup', this.pointerUpCallback);
-    this.view.removeEventListener('pointermove', this.pointerMoveCallback);
-    this.view.removeEventListener('pointercancel', this.pointerCancelCallback);
-    this.view.removeEventListener('pointerenter', this.pointerEnterCallback);
-    this.view.removeEventListener('pointerleave', this.pointerLeaveCallback);
-    this.view.removeEventListener('lostpointercapture', this.lostPointerCaptureCallback);
-  }
-  mapEvent(event, eventType) {
-    const rect = this.view.getBoundingClientRect();
-    const {
-      scaleX,
-      scaleY
-    } = calculateViewScale(this.view);
-    return {
-      x: event.clientX,
-      y: event.clientY,
-      offsetX: (event.clientX - rect.left) / scaleX,
-      offsetY: (event.clientY - rect.top) / scaleY,
-      pointerId: event.pointerId,
-      eventType: eventType,
-      pointerType: PointerTypeMapping.get(event.pointerType) ?? PointerType.OTHER,
-      button: this.mouseButtonsMapper.get(event.button),
-      time: event.timeStamp,
-      stylusData: tryExtractStylusData(event)
-    };
-  }
-  resetManager() {
-    super.resetManager();
-    this.trackedPointers.clear();
-  }
-}
-//# sourceMappingURL=PointerEventManager.js.map

package/lib/module/web/tools/PointerTracker.js

@@ -1,186 +0,0 @@
-"use strict";
-
-import VelocityTracker from './VelocityTracker';
-const MAX_POINTERS = 20;
-export default class PointerTracker {
-  velocityTracker = new VelocityTracker();
-  _trackedPointers = new Map();
-  touchEventsIds = new Map();
-  cachedAbsoluteAverages = {
-    x: 0,
-    y: 0
-  };
-  cachedRelativeAverages = {
-    x: 0,
-    y: 0
-  };
-  constructor() {
-    this.lastMovedPointerId = NaN;
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-  addToTracker(event) {
-    if (this.trackedPointers.has(event.pointerId)) {
-      return;
-    }
-    this.lastMovedPointerId = event.pointerId;
-    const newElement = {
-      abosoluteCoords: {
-        x: event.x,
-        y: event.y
-      },
-      relativeCoords: {
-        x: event.offsetX,
-        y: event.offsetY
-      },
-      timestamp: event.time,
-      velocityX: 0,
-      velocityY: 0
-    };
-    this.trackedPointers.set(event.pointerId, newElement);
-    this.mapTouchEventId(event.pointerId);
-    this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
-    this.cachedRelativeAverages = this.getRelativeCoordsAverage();
-  }
-  removeFromTracker(pointerId) {
-    this.trackedPointers.delete(pointerId);
-    this.removeMappedTouchId(pointerId);
-  }
-  track(event) {
-    const pointerData = this.trackedPointers.get(event.pointerId);
-    if (!pointerData) {
-      return;
-    }
-    this.lastMovedPointerId = event.pointerId;
-    this.velocityTracker.add(event);
-    const [velocityX, velocityY] = this.velocityTracker.velocity;
-    pointerData.velocityX = velocityX;
-    pointerData.velocityY = velocityY;
-    pointerData.abosoluteCoords = {
-      x: event.x,
-      y: event.y
-    };
-    pointerData.relativeCoords = {
-      x: event.offsetX,
-      y: event.offsetY
-    };
-    this.trackedPointers.set(event.pointerId, pointerData);
-    this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
-    this.cachedRelativeAverages = this.getRelativeCoordsAverage();
-  }
-
-  // Mapping TouchEvents ID
-  mapTouchEventId(id) {
-    for (const [mappedId, touchId] of this.touchEventsIds) {
-      if (isNaN(touchId)) {
-        this.touchEventsIds.set(mappedId, id);
-        break;
-      }
-    }
-  }
-  removeMappedTouchId(id) {
-    const mappedId = this.getMappedTouchEventId(id);
-    if (!isNaN(mappedId)) {
-      this.touchEventsIds.set(mappedId, NaN);
-    }
-  }
-  getMappedTouchEventId(touchEventId) {
-    for (const [key, value] of this.touchEventsIds.entries()) {
-      if (value === touchEventId) {
-        return key;
-      }
-    }
-    return NaN;
-  }
-  getVelocity(pointerId) {
-    const pointerData = this.trackedPointers.get(pointerId);
-    return pointerData ? {
-      x: pointerData.velocityX,
-      y: pointerData.velocityY
-    } : null;
-  }
-  getLastAbsoluteCoords(pointerId) {
-    return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)?.abosoluteCoords;
-  }
-  getLastRelativeCoords(pointerId) {
-    return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)?.relativeCoords;
-  }
-
-  // Some handlers use these methods to send average values in native event.
-  // This may happen when pointers have already been removed from tracker (i.e. pointerup event).
-  // In situation when NaN would be sent as a response, we return cached value.
-  // That prevents handlers from crashing
-
-  getAbsoluteCoordsAverage() {
-    const coordsSum = this.getAbsoluteCoordsSum();
-    const avgX = coordsSum.x / this.trackedPointers.size;
-    const avgY = coordsSum.y / this.trackedPointers.size;
-    const averages = {
-      x: isNaN(avgX) ? this.cachedAbsoluteAverages.x : avgX,
-      y: isNaN(avgY) ? this.cachedAbsoluteAverages.y : avgY
-    };
-    return averages;
-  }
-  getRelativeCoordsAverage() {
-    const coordsSum = this.getRelativeCoordsSum();
-    const avgX = coordsSum.x / this.trackedPointers.size;
-    const avgY = coordsSum.y / this.trackedPointers.size;
-    const averages = {
-      x: isNaN(avgX) ? this.cachedRelativeAverages.x : avgX,
-      y: isNaN(avgY) ? this.cachedRelativeAverages.y : avgY
-    };
-    return averages;
-  }
-  getAbsoluteCoordsSum(ignoredPointer) {
-    const sum = {
-      x: 0,
-      y: 0
-    };
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sum.x += value.abosoluteCoords.x;
-        sum.y += value.abosoluteCoords.y;
-      }
-    });
-    return sum;
-  }
-  getRelativeCoordsSum(ignoredPointer) {
-    const sum = {
-      x: 0,
-      y: 0
-    };
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sum.x += value.relativeCoords.x;
-        sum.y += value.relativeCoords.y;
-      }
-    });
-    return sum;
-  }
-  resetTracker() {
-    this.velocityTracker.reset();
-    this.trackedPointers.clear();
-    this.lastMovedPointerId = NaN;
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-  static shareCommonPointers(stPointers, ndPointers) {
-    return stPointers.some(pointerId => ndPointers.includes(pointerId));
-  }
-  get trackedPointersCount() {
-    return this.trackedPointers.size;
-  }
-  get trackedPointersIDs() {
-    const keys = [];
-    this.trackedPointers.forEach((_value, key) => {
-      keys.push(key);
-    });
-    return keys;
-  }
-  get trackedPointers() {
-    return this._trackedPointers;
-  }
-}
-//# sourceMappingURL=PointerTracker.js.map

package/lib/module/web/tools/Vector.js

@@ -1,32 +0,0 @@
-"use strict";
-
-import { DiagonalDirections, Directions } from '../../Directions';
-import { MINIMAL_RECOGNIZABLE_MAGNITUDE } from '../constants';
-export default class Vector {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-    this._magnitude = Math.hypot(this.x, this.y);
-    const isMagnitudeSufficient = this._magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE;
-    this.unitX = isMagnitudeSufficient ? this.x / this._magnitude : 0;
-    this.unitY = isMagnitudeSufficient ? this.y / this._magnitude : 0;
-  }
-  static fromDirection(direction) {
-    return DirectionToVectorMappings.get(direction) ?? new Vector(0, 0);
-  }
-  static fromVelocity(tracker, pointerId) {
-    const velocity = tracker.getVelocity(pointerId);
-    return velocity ? new Vector(velocity.x, velocity.y) : null;
-  }
-  get magnitude() {
-    return this._magnitude;
-  }
-  computeSimilarity(vector) {
-    return this.unitX * vector.unitX + this.unitY * vector.unitY;
-  }
-  isSimilar(vector, threshold) {
-    return this.computeSimilarity(vector) > threshold;
-  }
-}
-const DirectionToVectorMappings = new Map([[Directions.LEFT, new Vector(-1, 0)], [Directions.RIGHT, new Vector(1, 0)], [Directions.UP, new Vector(0, -1)], [Directions.DOWN, new Vector(0, 1)], [DiagonalDirections.UP_RIGHT, new Vector(1, -1)], [DiagonalDirections.DOWN_RIGHT, new Vector(1, 1)], [DiagonalDirections.UP_LEFT, new Vector(-1, -1)], [DiagonalDirections.DOWN_LEFT, new Vector(-1, 1)]]);
-//# sourceMappingURL=Vector.js.map

package/lib/module/web/tools/VelocityTracker.js

@@ -1,79 +0,0 @@
-"use strict";
-
-import CircularBuffer from './CircularBuffer';
-import LeastSquareSolver from './LeastSquareSolver';
-export default class VelocityTracker {
-  assumePointerMoveStoppedMilliseconds = 40;
-  historySize = 20;
-  horizonMilliseconds = 300;
-  minSampleSize = 3;
-  constructor() {
-    this.samples = new CircularBuffer(this.historySize);
-  }
-  add(event) {
-    this.samples.push(event);
-  }
-
-  // Returns an estimate of the velocity of the object being tracked by the
-  // tracker given the current information available to the tracker.
-  //
-  // Information is added using [addPosition].
-  //
-  // Returns null if there is no data on which to base an estimate.
-  getVelocityEstimate() {
-    const x = [];
-    const y = [];
-    const w = [];
-    const time = [];
-    let sampleCount = 0;
-    let index = this.samples.size - 1;
-    const newestSample = this.samples.get(index);
-    if (!newestSample) {
-      return null;
-    }
-    let previousSample = newestSample;
-
-    // Starting with the most recent PointAtTime sample, iterate backwards while
-    // the samples represent continuous motion.
-    while (sampleCount < this.samples.size) {
-      const sample = this.samples.get(index);
-      const age = newestSample.time - sample.time;
-      const delta = Math.abs(sample.time - previousSample.time);
-      previousSample = sample;
-      if (age > this.horizonMilliseconds || delta > this.assumePointerMoveStoppedMilliseconds) {
-        break;
-      }
-      x.push(sample.x);
-      y.push(sample.y);
-      w.push(1);
-      time.push(-age);
-      sampleCount++;
-      index--;
-    }
-    if (sampleCount >= this.minSampleSize) {
-      const xSolver = new LeastSquareSolver(time, x, w);
-      const xFit = xSolver.solve(2);
-      if (xFit !== null) {
-        const ySolver = new LeastSquareSolver(time, y, w);
-        const yFit = ySolver.solve(2);
-        if (yFit !== null) {
-          const xVelocity = xFit.coefficients[1] * 1000;
-          const yVelocity = yFit.coefficients[1] * 1000;
-          return [xVelocity, yVelocity];
-        }
-      }
-    }
-    return null;
-  }
-  get velocity() {
-    const estimate = this.getVelocityEstimate();
-    if (estimate !== null) {
-      return estimate;
-    }
-    return [0, 0];
-  }
-  reset() {
-    this.samples.clear();
-  }
-}
-//# sourceMappingURL=VelocityTracker.js.map