@react-native-oh-tpl/react-native-gesture-handler 2.14.15 → 2.14.17-rc.0

package/harmony/gesture_handler/src/main/ets/core/LeastSquareSolver.ts

@@ -1,182 +0,0 @@
-// Implementation taken from Flutter's LeastSquareSolver
-// https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/gestures/lsq_solver.dart
-
-class Vector {
-  private offset: number;
-  private length: number;
-  private elements: number[];
-
-  constructor(length: number) {
-    this.offset = 0;
-    this.length = length;
-    this.elements = new Array<number>(length);
-  }
-
-  public static fromVOL(
-    values: number[],
-    offset: number,
-    length: number
-  ): Vector {
-    const result = new Vector(0);
-
-    result.offset = offset;
-    result.length = length;
-    result.elements = values;
-
-    return result;
-  }
-
-  public get(index: number): number {
-    return this.elements[this.offset + index];
-  }
-
-  public set(index: number, value: number): void {
-    this.elements[this.offset + index] = value;
-  }
-
-  public dot(other: Vector): number {
-    let result = 0;
-    for (let i = 0; i < this.length; i++) {
-      result += this.get(i) * other.get(i);
-    }
-    return result;
-  }
-
-  public norm() {
-    return Math.sqrt(this.dot(this));
-  }
-}
-
-class Matrix {
-  private columns: number;
-  private elements: number[];
-
-  constructor(rows: number, columns: number) {
-    this.columns = columns;
-    this.elements = new Array<number>(rows * columns);
-  }
-
-  public get(row: number, column: number): number {
-    return this.elements[row * this.columns + column];
-  }
-
-  public set(row: number, column: number, value: number): void {
-    this.elements[row * this.columns + column] = value;
-  }
-
-  public getRow(row: number): Vector {
-    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.
-  public coefficients: number[];
-
-  /// Creates a polynomial fit of the given degree.
-  ///
-  /// There are n + 1 coefficients in a fit of degree n.
-  constructor(degree: number) {
-    this.coefficients = new Array<number>(degree + 1);
-  }
-}
-
-const precisionErrorTolerance = 1e-10;
-
-/// Uses the least-squares algorithm to fit a polynomial to a set of data.
-export class LeastSquareSolver {
-  /// The x-coordinates of each data point.
-  private x: number[];
-  /// The y-coordinates of each data point.
-  private y: number[];
-  /// The weight to use for each data point.
-  private w: number[];
-
-  /// Creates a least-squares solver.
-  ///
-  /// The [x], [y], and [w] arguments must not be null.
-  constructor(x: number[], y: number[], w: number[]) {
-    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.
-  public solve(degree: number): PolynomialFit | null {
-    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;
-  }
-}

package/harmony/gesture_handler/src/main/ets/core/Multiset.ts

@@ -1,26 +0,0 @@
-export class Multiset<T> {
-  private multiplicityByElement: Map<T, number> = new Map();
-  private elements: T[] = [];
-
-  add(element: T) {
-    const count = this.multiplicityByElement.get(element) || 0;
-    if (count === 0) {
-      this.elements.push(element);
-    }
-    this.multiplicityByElement.set(element, count + 1);
-  }
-
-  remove(element: T) {
-    const count = this.multiplicityByElement.get(element) || 0;
-    if (count > 1) {
-      this.multiplicityByElement.set(element, count - 1);
-    } else {
-      this.multiplicityByElement.delete(element);
-      this.elements = this.elements.filter(v => v !== element);
-    }
-  }
-
-  getElements() {
-    return this.elements;
-  }
-}

package/harmony/gesture_handler/src/main/ets/core/OutgoingEvent.ts

@@ -1,34 +0,0 @@
-import { State } from "./State"
-import { TouchEventType } from "./IncomingEvent"
-
-export interface GestureEventPayload {
-  handlerTag: number;
-  numberOfPointers: number;
-  state: State;
-}
-
-export interface HandlerStateChangeEventPayload extends GestureEventPayload {
-  oldState: State;
-}
-
-export type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> = GestureEventPayload
-  & GestureEventPayloadT
-
-export type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT
-
-export type TouchData = {
-  id: number;
-  x: number;
-  y: number;
-  absoluteX: number;
-  absoluteY: number;
-};
-
-export type GestureTouchEvent = {
-  handlerTag: number;
-  numberOfTouches: number;
-  state: State;
-  eventType: TouchEventType;
-  allTouches: TouchData[];
-  changedTouches: TouchData[];
-};

package/harmony/gesture_handler/src/main/ets/core/OutgoingEventDispatcher.ts

@@ -1,12 +0,0 @@
-import {
-  GestureStateChangeEvent,
-  GestureUpdateEvent,
-  GestureTouchEvent,
-} from './OutgoingEvent';
-
-export interface OutgoingEventDispatcher {
-  onGestureHandlerStateChange(event: GestureStateChangeEvent): void;
-  onGestureHandlerEvent(
-    event: GestureStateChangeEvent | GestureUpdateEvent | GestureTouchEvent,
-  ): void;
-}

package/harmony/gesture_handler/src/main/ets/core/PointerTracker.ts

@@ -1,239 +0,0 @@
-import { VelocityTracker, TrackerElement } from './VelocityTracker';
-import { IncomingEvent } from "./IncomingEvent"
-import { Vector2D } from './Vector2D';
-
-const MAX_POINTERS = 20;
-
-export class PointerTracker {
-  private velocityTracker = new VelocityTracker();
-  private trackedPointers: Map<number, TrackerElement> = new Map<
-  number,
-  TrackerElement
-  >();
-
-  private touchEventsIds: Map<number, number> = new Map<number, number>();
-
-  private lastMovedPointerId: number;
-
-  private cachedAverages: { x: number; y: number } = { x: 0, y: 0 };
-
-  public constructor() {
-    this.lastMovedPointerId = NaN;
-
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-
-  public addToTracker(event: IncomingEvent): void {
-    if (this.trackedPointers.has(event.pointerId)) {
-      return;
-    }
-
-    this.lastMovedPointerId = event.pointerId;
-
-    const newElement: TrackerElement = {
-      lastX: event.x,
-      lastY: event.y,
-      timeStamp: event.time,
-      velocityX: 0,
-      velocityY: 0,
-    };
-
-    this.trackedPointers.set(event.pointerId, newElement);
-    this.mapTouchEventId(event.pointerId);
-
-    this.cachedAverages = {
-      x: this.getLastAvgX(),
-      y: this.getLastAvgY(),
-    };
-  }
-
-  public removeFromTracker(pointerId: number): void {
-    this.trackedPointers.delete(pointerId);
-    this.removeMappedTouchId(pointerId);
-  }
-
-  public track(event: IncomingEvent): void {
-    const element: TrackerElement = this.trackedPointers.get(
-      event.pointerId
-    ) as TrackerElement;
-
-    if (!element) {
-      return;
-    }
-
-    this.lastMovedPointerId = event.pointerId;
-
-    this.velocityTracker.add(event);
-    const [velocityX, velocityY] = this.velocityTracker.getVelocity();
-
-    element.velocityX = velocityX;
-    element.velocityY = velocityY;
-
-    element.lastX = event.x;
-    element.lastY = event.y;
-
-    this.trackedPointers.set(event.pointerId, element);
-
-    const avgX: number = this.getLastAvgX();
-    const avgY: number = this.getLastAvgY();
-
-    this.cachedAverages = {
-      x: avgX,
-      y: avgY,
-    };
-  }
-
-  //Mapping TouchEvents ID
-  private mapTouchEventId(id: number): void {
-    for (const [mappedId, touchId] of this.touchEventsIds) {
-      if (isNaN(touchId)) {
-        this.touchEventsIds.set(mappedId, id);
-        break;
-      }
-    }
-  }
-
-  private removeMappedTouchId(id: number): void {
-    const mappedId: number = this.getMappedTouchEventId(id);
-    if (!isNaN(mappedId)) {
-      this.touchEventsIds.set(mappedId, NaN);
-    }
-  }
-
-  public getMappedTouchEventId(touchEventId: number): number {
-    for (const [key, value] of this.touchEventsIds.entries()) {
-      if (value === touchEventId) {
-        return key;
-      }
-    }
-
-    return NaN;
-  }
-
-  public getVelocity(pointerId: number) {
-    return new Vector2D({x: this.getVelocityX(pointerId), y: this.getVelocityY(pointerId)})
-  }
-
-  public getVelocityX(pointerId: number): number {
-    return this.trackedPointers.get(pointerId)?.velocityX as number;
-  }
-  public getVelocityY(pointerId: number): number {
-    return this.trackedPointers.get(pointerId)?.velocityY as number;
-  }
-
-  /**
-   * Returns X coordinate of last moved pointer
-   */
-  public getLastX(): number;
-
-  /**
-   *
-   * @param pointerId
-   * Returns X coordinate of given pointer
-   */
-  // eslint-disable-next-line @typescript-eslint/unified-signatures
-  public getLastX(pointerId: number): number;
-
-  public getLastX(pointerId?: number): number {
-    if (pointerId !== undefined) {
-      return this.trackedPointers.get(pointerId)?.lastX as number;
-    } else {
-      return this.trackedPointers.get(this.lastMovedPointerId)?.lastX as number;
-    }
-  }
-
-  /**
-   * Returns Y coordinate of last moved pointer
-   */
-  public getLastY(): number;
-
-  /**
-   *
-   * @param pointerId
-   * Returns Y coordinate of given pointer
-   */
-  // eslint-disable-next-line @typescript-eslint/unified-signatures
-  public getLastY(pointerId: number): number;
-
-  public getLastY(pointerId?: number): number {
-    if (pointerId !== undefined) {
-      return this.trackedPointers.get(pointerId)?.lastY as number;
-    } else {
-      return this.trackedPointers.get(this.lastMovedPointerId)?.lastY as number;
-    }
-  }
-
-  public getLastAvgPos() {
-    return new Vector2D({x: this.getLastAvgX(), y: this.getLastAvgY()})
-  }
-
-  // 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
-  public getLastAvgX(): number {
-    const avgX: number = this.getSumX() / this.trackedPointers.size;
-    return isNaN(avgX) ? this.cachedAverages.x : avgX;
-  }
-  public getLastAvgY(): number {
-    const avgY: number = this.getSumY() / this.trackedPointers.size;
-    return isNaN(avgY) ? this.cachedAverages.y : avgY;
-  }
-  public getSumX(ignoredPointer?: number): number {
-    let sumX = 0;
-
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sumX += value.lastX;
-      }
-    });
-
-    return sumX;
-  }
-  public getSumY(ignoredPointer?: number): number {
-    let sumY = 0;
-
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sumY += value.lastY;
-      }
-    });
-
-    return sumY;
-  }
-  public getTrackedPointersCount(): number {
-    return this.trackedPointers.size;
-  }
-  public getTrackedPointersID(): number[] {
-    const keys: number[] = [];
-
-    this.trackedPointers.forEach((_value, key) => {
-      keys.push(key);
-    });
-
-    return keys;
-  }
-
-  public getData(): Map<number, TrackerElement> {
-    return this.trackedPointers;
-  }
-
-  public resetTracker(): void {
-    this.velocityTracker.reset();
-    this.trackedPointers.clear();
-    this.lastMovedPointerId = NaN;
-
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-
-  public static shareCommonPointers(
-    stPointers: number[],
-    ndPointers: number[]
-  ): boolean {
-    return stPointers.some((pointerId) => ndPointers.includes(pointerId));
-  }
-}

package/harmony/gesture_handler/src/main/ets/core/RNGHError.ts

@@ -1,5 +0,0 @@
-export class RNGHError extends Error {
-  constructor(message: string) {
-    super("rnoh-gesture-handler: " + message)
-  }
-}

package/harmony/gesture_handler/src/main/ets/core/RNGHLogger.ts

@@ -1,16 +0,0 @@
-export type RNGHLoggerMessage = string | Object
-
-export interface RNGHLogger {
-  cloneAndJoinPrefix(prefix: string): RNGHLogger;
-
-  debug(msg: RNGHLoggerMessage);
-
-  info(msg: string): void;
-
-  warn(warn: string);
-
-  error(msg: string);
-
-  startTracing(): () => void
-}
-

package/harmony/gesture_handler/src/main/ets/core/State.ts

@@ -1,47 +0,0 @@
-export enum State {
-  /** This is the initial state of each handler and it goes into this state after it's done recognizing a gesture. */
-  UNDETERMINED,
-
-  /** A handler received some touches but for some reason didn't recognize them. For example, if a finger travels more
-   * distance than a defined maxDist property allows, then the handler won't become active but will fail instead.
-   * Afterwards, it's state will be reset to UNDETERMINED. */
-  FAILED,
-
-  /** Handler has started receiving touch stream but hasn't yet received enough data to either fail or activate. */
-  BEGAN,
-
-  /** The gesture recognizer has received a signal (possibly new touches or a command from the touch system controller)
-   * resulting in the cancellation of a continuous gesture. The gesture's state will become CANCELLED until it is
-   * finally reset to the initial state, UNDETERMINED. */
-  CANCELLED,
-
-  /** Handler has recognized a gesture. It will become and stay in the ACTIVE state until the gesture finishes
-   * (e.g. when user lifts the finger) or gets cancelled by the touch system. Under normal circumstances the state will
-   * then turn into END. In the case that a gesture is cancelled by the touch system, its state would then become
-   * CANCELLED. Learn about discrete and continuous handlers here to understand how long a handler can be kept in the
-   * ACTIVE state.
-   * */
-  ACTIVE,
-
-  /** The gesture recognizer has received touches signalling the end of a gesture. Its state will become END until it is
-   * reset to UNDETERMINED.
-   * */
-  END,
-}
-
-export function getStateName(state: State): string {
-  switch (state) {
-    case State.UNDETERMINED:
-      return "UNDETERMINED"
-    case State.FAILED:
-      return "FAILED"
-    case State.BEGAN:
-      return "BEGAN"
-    case State.CANCELLED:
-      return "CANCELLED"
-    case State.ACTIVE:
-      return "ACTIVE"
-    case State.END:
-      return "END"
-  }
-}

package/harmony/gesture_handler/src/main/ets/core/Vector2D.ts

@@ -1,80 +0,0 @@
-import { Directions, DiagonalDirections } from "./IncomingEvent"
-
-type Cosine = number
-
-export class Vector2D {
-  private static VECTOR_BY_DIRECTION = new Map<
-      Directions | DiagonalDirections,
-      Vector2D
-    >([
-      [Directions.LEFT, new Vector2D({ x: -1, y: 0 })],
-      [Directions.RIGHT, new Vector2D({ x: 1, y: 0 })],
-      [Directions.UP, new Vector2D({ x: 0, y: -1 })],
-      [Directions.DOWN, new Vector2D({ x: 0, y: 1 })],
-      [DiagonalDirections.UP_RIGHT, new Vector2D({ x: 1, y: -1 })],
-      [DiagonalDirections.DOWN_RIGHT, new Vector2D({ x: 1, y: 1 })],
-      [DiagonalDirections.UP_LEFT, new Vector2D({ x: -1, y: -1 })],
-      [DiagonalDirections.DOWN_LEFT, new Vector2D({ x: -1, y: 1 })],
-    ]);
-
-  static fromDirection(direction: Directions | DiagonalDirections): Vector2D {
-    return Vector2D.VECTOR_BY_DIRECTION.get(direction)!;
-  }
-
-
-  constructor(
-    private val: {
-      x: number;
-      y: number;
-    } = {x: 0, y: 0},
-  ) {}
-
-  get x() {
-    return this.val.x;
-  }
-
-  get y() {
-    return this.val.y;
-  }
-
-  get value() {
-    return {...this.val};
-  }
-
-  public clone() {
-    return new Vector2D({...this.val});
-  }
-
-  public subtract(vec: Vector2D) {
-    this.val.x -= vec.x;
-    this.val.y -= vec.y;
-    return this;
-  }
-
-  public add(vec: Vector2D) {
-    this.val.x += vec.x;
-    this.val.y += vec.y;
-    return this;
-  }
-
-  public createUnitVector(): Vector2D {
-    const magnitude = this.magnitude
-    if (magnitude === 0) {
-      return new Vector2D({ x: 0, y: 0 });
-    }
-    return new Vector2D({
-      x: this.val.x / magnitude,
-      y: this.val.y / magnitude
-    });
-  }
-
-  public computeCosine(other: Vector2D): Cosine {
-    const thisUnit = this.createUnitVector();
-    const otherUnit = other.createUnitVector();
-    return thisUnit.val.x * otherUnit.val.x + thisUnit.val.y * otherUnit.val.y;
-  }
-
-  public get magnitude() {
-    return Math.hypot(this.x, this.y);
-  }
-}