@react-native-oh-tpl/react-native-gesture-handler 2.12.6-1 → 2.12.6-2

package/harmony/gesture_handler/src/main/ets/TapGestureHandler.ts

@@ -1,206 +1,206 @@
-import { GestureHandler, GestureHandlerDependencies } from "./GestureHandler"
-import { AdaptedEvent, EventType } from "./Event"
-import { State, getStateName } from "./State"
-
-const DEFAULT_MAX_DURATION_MS = 500;
-const DEFAULT_NUMBER_OF_TAPS = 1;
-const DEFAULT_MAX_DELAY_MS = 500;
-
-export class TapGestureHandler extends GestureHandler {
-  private startX = 0;
-  private startY = 0;
-  private offsetX = 0;
-  private offsetY = 0;
-  private lastX = 0;
-  private lastY = 0;
-  private maxNumberOfPointersSoFar = 0;
-  private numberOfTapsSoFar: number = 0;
-  private waitTimeout: number | undefined;
-  private delayTimeout: number | undefined;
-
-  constructor(deps: GestureHandlerDependencies) {
-    super({...deps, logger: deps.logger.cloneWithPrefix("TapGestureHandler")})
-  }
-
-  onPointerDown(event) {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-    this.trySettingPosition(event);
-    this.lastX = event.x;
-    this.lastY = event.y;
-    this.updateState(event);
-  }
-
-  onAdditionalPointerAdd(event: AdaptedEvent): void {
-    super.onAdditionalPointerAdd(event);
-    this.tracker.addToTracker(event);
-    this.trySettingPosition(event);
-
-    this.offsetX += this.lastX - this.startX;
-    this.offsetY += this.lastY - this.startY;
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.startX = this.tracker.getLastAvgX();
-    this.startY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-  }
-
-  onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.tracker.removeFromTracker(event.pointerId);
-
-    this.updateState(event);
-  }
-
-  onAdditionalPointerRemove(event: AdaptedEvent): void {
-    super.onAdditionalPointerRemove(event);
-    this.tracker.removeFromTracker(event.pointerId);
-
-    this.offsetX += this.lastX - this.startX;
-    this.offsetY += this.lastY = this.startY;
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.startX = this.lastX;
-    this.startY = this.lastY;
-
-    this.updateState(event);
-  }
-
-  onPointerMove(event: AdaptedEvent): void {
-    this.trySettingPosition(event);
-    this.tracker.track(event);
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-
-    super.onPointerMove(event);
-  }
-
-  onPointerOutOfBounds(event: AdaptedEvent): void {
-    this.trySettingPosition(event);
-    this.tracker.track(event);
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-
-    super.onPointerOutOfBounds(event);
-  }
-
-  getDefaultConfig() {
-    return {}
-  }
-
-  private trySettingPosition(event: AdaptedEvent): void {
-    if (this.currentState !== State.UNDETERMINED) return;
-    this.offsetX = 0;
-    this.offsetY = 0;
-    this.startX = event.x;
-    this.startY = event.y;
-  }
-
-  private updateState(event: AdaptedEvent): void {
-    const logger = this.logger.cloneWithPrefix("updateState")
-    if (this.maxNumberOfPointersSoFar < this.tracker.getTrackedPointersCount()) {
-      this.maxNumberOfPointersSoFar = this.tracker.getTrackedPointersCount()
-    }
-    if (this.shouldFail()) {
-      logger.info("fail")
-      this.fail()
-      return;
-    }
-    switch (this.currentState) {
-      case State.UNDETERMINED:
-        if (event.eventType === EventType.DOWN) {
-          this.begin()
-        }
-        this.startTap();
-        break;
-      case State.BEGAN:
-        if (event.eventType === EventType.UP) {
-          logger.info("endTap")
-          this.endTap();
-        }
-        if (event.eventType === EventType.DOWN) {
-          this.startTap();
-        }
-        break;
-      default:
-        logger.info(`default case - currentState ${getStateName(this.currentState)}`)
-        break;
-    }
-  }
-
-  private shouldFail(): boolean {
-    const maxDeltaX = this.config.maxDeltaX ?? Number.MIN_SAFE_INTEGER
-    const maxDeltaY = this.config.maxDeltaY ?? Number.MIN_SAFE_INTEGER
-    const maxDistSq = this.config.maxDistSq ?? Number.MIN_SAFE_INTEGER
-
-    const dx = this.lastX - this.startX + this.offsetX;
-    if (
-      maxDeltaX !== Number.MIN_SAFE_INTEGER &&
-        Math.abs(dx) > maxDeltaX
-    ) {
-      return true;
-    }
-    const dy = this.lastY - this.startY + this.offsetY;
-    if (
-      maxDeltaY !== Number.MIN_SAFE_INTEGER &&
-        Math.abs(dy) > maxDeltaY
-    ) {
-      return true;
-    }
-    const distSq = dy * dy + dx * dx;
-    const result = maxDistSq !== Number.MIN_SAFE_INTEGER && distSq > maxDistSq
-    return result;
-  }
-
-  private startTap() {
-    this.clearTimeouts();
-    this.waitTimeout = setTimeout(() => this.fail(), this.config.maxDurationMs ?? DEFAULT_MAX_DURATION_MS);
-  }
-
-  private clearTimeouts() {
-    clearTimeout(this.waitTimeout);
-    clearTimeout(this.delayTimeout);
-  }
-
-  private endTap() {
-    this.clearTimeouts();
-    if (
-      ++this.numberOfTapsSoFar === (this.config.numberOfTaps ?? DEFAULT_NUMBER_OF_TAPS) &&
-        this.maxNumberOfPointersSoFar >= (this.config.minNumberOfPointers ?? 0)
-    ) {
-      this.activate();
-    } else {
-      this.delayTimeout = setTimeout(() => this.fail(), this.config.maxDelayMs ?? DEFAULT_MAX_DELAY_MS);
-    }
-  }
-
-  public activate(): void {
-    super.activate();
-    this.end();
-  }
-
-  protected onCancel() {
-    super.onCancel()
-    this.resetProgress()
-  }
-
-  protected resetProgress(): void {
-    this.clearTimeouts();
-    this.numberOfTapsSoFar = 0;
-    this.maxNumberOfPointersSoFar = 0;
-  }
+import { GestureHandler, GestureHandlerDependencies } from "./GestureHandler"
+import { AdaptedEvent, EventType } from "./Event"
+import { State, getStateName } from "./State"
+
+const DEFAULT_MAX_DURATION_MS = 500;
+const DEFAULT_NUMBER_OF_TAPS = 1;
+const DEFAULT_MAX_DELAY_MS = 500;
+
+export class TapGestureHandler extends GestureHandler {
+  private startX = 0;
+  private startY = 0;
+  private offsetX = 0;
+  private offsetY = 0;
+  private lastX = 0;
+  private lastY = 0;
+  private maxNumberOfPointersSoFar = 0;
+  private numberOfTapsSoFar: number = 0;
+  private waitTimeout: number | undefined;
+  private delayTimeout: number | undefined;
+
+  constructor(deps: GestureHandlerDependencies) {
+    super({...deps, logger: deps.logger.cloneWithPrefix("TapGestureHandler")})
+  }
+
+  onPointerDown(event) {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.trySettingPosition(event);
+    this.lastX = event.x;
+    this.lastY = event.y;
+    this.updateState(event);
+  }
+
+  onAdditionalPointerAdd(event: AdaptedEvent): void {
+    super.onAdditionalPointerAdd(event);
+    this.tracker.addToTracker(event);
+    this.trySettingPosition(event);
+
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY - this.startY;
+
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+
+    this.startX = this.tracker.getLastAvgX();
+    this.startY = this.tracker.getLastAvgY();
+
+    this.updateState(event);
+  }
+
+  onPointerUp(event: AdaptedEvent): void {
+    super.onPointerUp(event);
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+
+    this.tracker.removeFromTracker(event.pointerId);
+
+    this.updateState(event);
+  }
+
+  onAdditionalPointerRemove(event: AdaptedEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    this.offsetX += this.lastX - this.startX;
+    this.offsetY += this.lastY = this.startY;
+
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+
+    this.startX = this.lastX;
+    this.startY = this.lastY;
+
+    this.updateState(event);
+  }
+
+  onPointerMove(event: AdaptedEvent): void {
+    this.trySettingPosition(event);
+    this.tracker.track(event);
+
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+
+    this.updateState(event);
+
+    super.onPointerMove(event);
+  }
+
+  onPointerOutOfBounds(event: AdaptedEvent): void {
+    this.trySettingPosition(event);
+    this.tracker.track(event);
+
+    this.lastX = this.tracker.getLastAvgX();
+    this.lastY = this.tracker.getLastAvgY();
+
+    this.updateState(event);
+
+    super.onPointerOutOfBounds(event);
+  }
+
+  getDefaultConfig() {
+    return {}
+  }
+
+  private trySettingPosition(event: AdaptedEvent): void {
+    if (this.currentState !== State.UNDETERMINED) return;
+    this.offsetX = 0;
+    this.offsetY = 0;
+    this.startX = event.x;
+    this.startY = event.y;
+  }
+
+  private updateState(event: AdaptedEvent): void {
+    const logger = this.logger.cloneWithPrefix("updateState")
+    if (this.maxNumberOfPointersSoFar < this.tracker.getTrackedPointersCount()) {
+      this.maxNumberOfPointersSoFar = this.tracker.getTrackedPointersCount()
+    }
+    if (this.shouldFail()) {
+      logger.info("fail")
+      this.fail()
+      return;
+    }
+    switch (this.currentState) {
+      case State.UNDETERMINED:
+        if (event.eventType === EventType.DOWN) {
+          this.begin()
+        }
+        this.startTap();
+        break;
+      case State.BEGAN:
+        if (event.eventType === EventType.UP) {
+          logger.info("endTap")
+          this.endTap();
+        }
+        if (event.eventType === EventType.DOWN) {
+          this.startTap();
+        }
+        break;
+      default:
+        logger.info(`default case - currentState ${getStateName(this.currentState)}`)
+        break;
+    }
+  }
+
+  private shouldFail(): boolean {
+    const maxDeltaX = this.config.maxDeltaX ?? Number.MIN_SAFE_INTEGER
+    const maxDeltaY = this.config.maxDeltaY ?? Number.MIN_SAFE_INTEGER
+    const maxDistSq = this.config.maxDistSq ?? Number.MIN_SAFE_INTEGER
+
+    const dx = this.lastX - this.startX + this.offsetX;
+    if (
+      maxDeltaX !== Number.MIN_SAFE_INTEGER &&
+        Math.abs(dx) > maxDeltaX
+    ) {
+      return true;
+    }
+    const dy = this.lastY - this.startY + this.offsetY;
+    if (
+      maxDeltaY !== Number.MIN_SAFE_INTEGER &&
+        Math.abs(dy) > maxDeltaY
+    ) {
+      return true;
+    }
+    const distSq = dy * dy + dx * dx;
+    const result = maxDistSq !== Number.MIN_SAFE_INTEGER && distSq > maxDistSq
+    return result;
+  }
+
+  private startTap() {
+    this.clearTimeouts();
+    this.waitTimeout = setTimeout(() => this.fail(), this.config.maxDurationMs ?? DEFAULT_MAX_DURATION_MS);
+  }
+
+  private clearTimeouts() {
+    clearTimeout(this.waitTimeout);
+    clearTimeout(this.delayTimeout);
+  }
+
+  private endTap() {
+    this.clearTimeouts();
+    if (
+      ++this.numberOfTapsSoFar === (this.config.numberOfTaps ?? DEFAULT_NUMBER_OF_TAPS) &&
+        this.maxNumberOfPointersSoFar >= (this.config.minNumberOfPointers ?? 0)
+    ) {
+      this.activate();
+    } else {
+      this.delayTimeout = setTimeout(() => this.fail(), this.config.maxDelayMs ?? DEFAULT_MAX_DELAY_MS);
+    }
+  }
+
+  public activate(): void {
+    super.activate();
+    this.end();
+  }
+
+  protected onCancel() {
+    super.onCancel()
+    this.resetProgress()
+  }
+
+  protected resetProgress(): void {
+    this.clearTimeouts();
+    this.numberOfTapsSoFar = 0;
+    this.maxNumberOfPointersSoFar = 0;
+  }
 }

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

@@ -1,36 +1,36 @@
-export class Vector2D {
-  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;
-  }
-}
+export class Vector2D {
+  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;
+  }
+}

package/harmony/gesture_handler/src/main/ets/VelocityTracker.ts

@@ -1,98 +1,98 @@
-import { AdaptedEvent } from './Event';
-import { CircularBuffer } from './CircularBuffer';
-import { LeastSquareSolver } from './LeastSquareSolver';
-
-export default class VelocityTracker {
-  private assumePointerMoveStoppedMilliseconds = 40;
-  private historySize = 20;
-  private horizonMilliseconds = 300;
-  private minSampleSize = 3;
-
-  private samples: CircularBuffer<AdaptedEvent>;
-
-  constructor() {
-    this.samples = new CircularBuffer<AdaptedEvent>(this.historySize);
-  }
-
-  public add(event: AdaptedEvent): void {
-    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.
-  private getVelocityEstimate(): [number, number] | null {
-    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;
-  }
-
-  public getVelocity(): [number, number] {
-    const estimate = this.getVelocityEstimate();
-    if (estimate !== null) {
-      return estimate;
-    }
-    return [0, 0];
-  }
-
-  public reset(): void {
-    this.samples.clear();
-  }
-}
+import { AdaptedEvent } from './Event';
+import { CircularBuffer } from './CircularBuffer';
+import { LeastSquareSolver } from './LeastSquareSolver';
+
+export default class VelocityTracker {
+  private assumePointerMoveStoppedMilliseconds = 40;
+  private historySize = 20;
+  private horizonMilliseconds = 300;
+  private minSampleSize = 3;
+
+  private samples: CircularBuffer<AdaptedEvent>;
+
+  constructor() {
+    this.samples = new CircularBuffer<AdaptedEvent>(this.historySize);
+  }
+
+  public add(event: AdaptedEvent): void {
+    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.
+  private getVelocityEstimate(): [number, number] | null {
+    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;
+  }
+
+  public getVelocity(): [number, number] {
+    const estimate = this.getVelocityEstimate();
+    if (estimate !== null) {
+      return estimate;
+    }
+    return [0, 0];
+  }
+
+  public reset(): void {
+    this.samples.clear();
+  }
+}