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

package/{src/web/tools → harmony/gesture_handler/src/main/ets}/InteractionManager.ts

@@ -1,15 +1,8 @@
-import GestureHandler from '../handlers/GestureHandler';
-import { Config, Handler } from '../interfaces';
+import { GestureHandler, Handler, GestureConfig as Config } from "./GestureHandler"
 
-export default class InteractionManager {
-  private static instance: InteractionManager;
-  private readonly waitForRelations: Map<number, number[]> = new Map();
-  private readonly simultaneousRelations: Map<number, number[]> = new Map();
-  private readonly blocksHandlersRelations: Map<number, number[]> = new Map();
-
-  // Private becaues of singleton
-  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
-  private constructor() {}
+export class InteractionManager {
+  private readonly waitForRelations: Map<number, number[]> = new Map()
+  private readonly simultaneousRelations: Map<number, number[]> = new Map()
 
   public configureInteractions(handler: GestureHandler, config: Config) {
     this.dropRelationsForHandlerWithTag(handler.getTag());
@@ -41,19 +34,6 @@ export default class InteractionManager {
 
       this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);
     }
-
-    if (config.blocksHandlers) {
-      const blocksHandlers: number[] = [];
-      config.blocksHandlers.forEach((otherHandler: Handler): void => {
-        if (typeof otherHandler === 'number') {
-          blocksHandlers.push(otherHandler);
-        } else {
-          blocksHandlers.push(otherHandler.handlerTag);
-        }
-      });
-
-      this.blocksHandlersRelations.set(handler.getTag(), blocksHandlers);
-    }
   }
 
   public shouldWaitForHandlerFailure(
@@ -63,12 +43,20 @@ export default class InteractionManager {
     const waitFor: number[] | undefined = this.waitForRelations.get(
       handler.getTag()
     );
+    if (!waitFor) {
+      return false;
+    }
 
-    return (
-      waitFor?.find((tag: number) => {
-        return tag === otherHandler.getTag();
-      }) !== undefined
-    );
+    let shouldWait = false;
+
+    waitFor.forEach((tag: number): void => {
+      if (tag === otherHandler.getTag()) {
+        shouldWait = true;
+        return; //Returns from callback
+      }
+    });
+
+    return shouldWait;
   }
 
   public shouldRecognizeSimultaneously(
@@ -76,28 +64,29 @@ export default class InteractionManager {
     otherHandler: GestureHandler
   ): boolean {
     const simultaneousHandlers: number[] | undefined =
-      this.simultaneousRelations.get(handler.getTag());
+    this.simultaneousRelations.get(handler.getTag());
+    if (!simultaneousHandlers) {
+      return false;
+    }
 
-    return (
-      simultaneousHandlers?.find((tag: number) => {
-        return tag === otherHandler.getTag();
-      }) !== undefined
-    );
+    let shouldRecognizeSimultaneously = false;
+
+    simultaneousHandlers.forEach((tag: number): void => {
+      if (tag === otherHandler.getTag()) {
+        shouldRecognizeSimultaneously = true;
+        return;
+      }
+    });
+
+    return shouldRecognizeSimultaneously;
   }
 
   public shouldRequireHandlerToWaitForFailure(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
+    _handler: GestureHandler,
+    _otherHandler: GestureHandler
   ): boolean {
-    const waitFor: number[] | undefined = this.blocksHandlersRelations.get(
-      handler.getTag()
-    );
-
-    return (
-      waitFor?.find((tag: number) => {
-        return tag === otherHandler.getTag();
-      }) !== undefined
-    );
+    //TODO: Implement logic
+    return false;
   }
 
   public shouldHandlerBeCancelledBy(
@@ -111,20 +100,10 @@ export default class InteractionManager {
   public dropRelationsForHandlerWithTag(handlerTag: number): void {
     this.waitForRelations.delete(handlerTag);
     this.simultaneousRelations.delete(handlerTag);
-    this.blocksHandlersRelations.delete(handlerTag);
   }
 
   public reset() {
     this.waitForRelations.clear();
     this.simultaneousRelations.clear();
-    this.blocksHandlersRelations.clear();
-  }
-
-  public static getInstance(): InteractionManager {
-    if (!this.instance) {
-      this.instance = new InteractionManager();
-    }
-
-    return this.instance;
   }
-}
+}

package/{src/web/tools → harmony/gesture_handler/src/main/ets}/LeastSquareSolver.ts

@@ -88,7 +88,7 @@ class PolynomialFit {
 const precisionErrorTolerance = 1e-10;
 
 /// Uses the least-squares algorithm to fit a polynomial to a set of data.
-export default class LeastSquareSolver {
+export class LeastSquareSolver {
   /// The x-coordinates of each data point.
   private x: number[];
   /// The y-coordinates of each data point.

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

@@ -0,0 +1,115 @@
+import { GestureHandler, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP } from "./GestureHandler"
+import { Vector2D } from './Vector2D';
+import { State } from "./State"
+import { AdaptedEvent } from './Event';
+
+export class NativeViewGestureHandler extends GestureHandler {
+  private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
+
+  protected startPos = new Vector2D()
+
+  public canBeInterrupted() {
+    return !(this.config.disallowInterruption ?? false)
+  }
+
+  constructor(deps: GestureHandlerDependencies) {
+    super({ ...deps, logger: deps.logger.cloneWithPrefix("NativeViewGestureHandler") })
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  public onPointerDown(e: AdaptedEvent) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.onNewPointer();
+  }
+
+  protected onNewPointer() {
+    this.startPos = this.tracker.getLastAvgPos();
+    if (this.currentState !== State.UNDETERMINED)
+      return;
+    this.begin();
+    this.activate();
+  }
+
+  public onAdditionalPointerAdd(e: AdaptedEvent) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.onNewPointer();
+  }
+
+  public onPointerMove(e: AdaptedEvent): void {
+    this.tracker.track(e);
+    const {x: dx, y: dy} = this.startPos.clone().subtract(this.tracker.getLastAvgPos()).value
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq >= this.minDistSq) {
+      if (this.currentState === State.ACTIVE) {
+        this.cancel();
+      } else if (this.currentState === State.BEGAN) {
+        this.activate();
+      }
+    }
+  }
+
+  public onPointerLeave(): void {
+    // TODO: add this method to GestureHandler
+    if (this.currentState === State.BEGAN || this.currentState === State.ACTIVE) {
+      this.cancel();
+    }
+  }
+
+  public onPointerUp(event: AdaptedEvent): void {
+    super.onPointerUp(event);
+    this.onAnyPointerUp(event);
+  }
+
+  private onAnyPointerUp(e: AdaptedEvent) {
+    this.tracker.removeFromTracker(e.pointerId);
+    if (this.tracker.getTrackedPointersCount() === 0) {
+      if (this.currentState === State.ACTIVE) {
+        this.end();
+      } else {
+        this.fail();
+      }
+    }
+  }
+
+  public onAdditionalPointerRemove(e: AdaptedEvent) {
+    super.onAdditionalPointerRemove(e)
+    this.onAnyPointerUp(e)
+  }
+
+  public shouldRecognizeSimultaneously(handler: GestureHandler): boolean {
+    if (super.shouldRecognizeSimultaneously(handler)) {
+      return true;
+    }
+    if (
+      handler instanceof NativeViewGestureHandler &&
+        handler.getState() === State.ACTIVE &&
+        !handler.canBeInterrupted()
+    ) {
+      return false;
+    }
+
+    if (
+      this.currentState === State.ACTIVE &&
+        handler.getState() === State.ACTIVE &&
+        this.canBeInterrupted()
+    ) {
+      return false;
+    }
+
+    return (
+      this.currentState === State.ACTIVE &&
+        this.canBeInterrupted() &&
+        handler.getTag() > 0
+    );
+  }
+
+  public shouldBeCancelledByOther(_handler: GestureHandler): boolean {
+    return this.canBeInterrupted();
+  }
+}

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

@@ -0,0 +1,34 @@
+import { State } from "./State"
+import { TouchEventType } from "./Event"
+
+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/PanGestureHandler.ts

@@ -0,0 +1,328 @@
+import { GestureHandler, GestureConfig, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP } from "./GestureHandler"
+import { AdaptedEvent } from "./Event"
+import { State } from "./State"
+import { Vector2D } from "./Vector2D"
+
+const DEFAULT_MIN_DIST_SQ = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
+
+type PanGestureHandlerConfig = GestureConfig
+
+export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
+  private startPos = new Vector2D();
+  private offset = new Vector2D()
+  private lastPos = new Vector2D();
+  private velocity = new Vector2D();
+  private activationTimeout = 0;
+
+  private get failOffsetXStart() {
+    if (this.config.failOffsetXStart === undefined
+      && this.config.failOffsetXEnd === undefined)
+      return undefined
+    return this.config.failOffsetXStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get failOffsetXEnd() {
+    if (this.config.failOffsetXStart === undefined
+      && this.config.failOffsetXEnd === undefined)
+      return undefined
+    return this.config.failOffsetXEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get failOffsetYStart() {
+    if (this.config.failOffsetYStart === undefined
+      && this.config.failOffsetYEnd === undefined)
+      return undefined
+    return this.config.failOffsetYStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get failOffsetYEnd() {
+    return this.config.failOffsetYEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get activeOffsetXStart() {
+    if (this.config.activeOffsetXStart === undefined
+      && this.config.activeOffsetXEnd === undefined)
+      return undefined
+    return this.config.activeOffsetXStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get activeOffsetXEnd() {
+    if (this.config.activeOffsetXStart === undefined
+      && this.config.activeOffsetXEnd === undefined)
+      return undefined
+    return this.config.activeOffsetXEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get activeOffsetYStart() {
+    if (this.config.activeOffsetYStart === undefined
+      && this.config.activeOffsetYEnd === undefined)
+      return undefined
+    return this.config.activeOffsetYStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get activeOffsetYEnd() {
+    if (this.config.activeOffsetYStart === undefined
+      && this.config.activeOffsetYEnd === undefined)
+      return undefined
+    return this.config.activeOffsetYEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get minVelocityX() {
+    return this.config.minVelocityX ?? this.config.minVelocity ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get minVelocityY() {
+    return this.config.minVelocityY ?? this.config.minVelocityY ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private minVelocitySq = Number.MAX_SAFE_INTEGER
+
+  private get minPointers() {
+    return this.config.minPointers ?? 1
+  }
+
+  private unlockScrolls: (() => void) | undefined
+
+  public constructor(deps: GestureHandlerDependencies) {
+    super({ ...deps, logger: deps.logger.cloneWithPrefix("PanGestureHandler") })
+  }
+
+  public onPointerDown(e) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    this.tryBegin(e);
+    this.tryActivating();
+  }
+
+  private tryActivating(): void {
+    if (this.currentState === State.BEGAN) {
+      if (this.shouldFail()) {
+        this.fail();
+      } else if (this.shouldActivate()) {
+        this.activate();
+      }
+    }
+  }
+
+  private shouldFail(): boolean {
+    const {x: dx, y: dy} = this.getTranslation().value;
+    const distanceSq = dx * dx + dy * dy;
+    if (this.activateAfterLongPress > 0 && distanceSq > DEFAULT_MIN_DIST_SQ) {
+      this.clearActivationTimeout();
+      return true;
+    }
+    if (this.failOffsetXStart !== Number.MIN_SAFE_INTEGER && dx < this.failOffsetXStart) {
+      return true;
+    }
+    if (this.failOffsetXEnd !== Number.MAX_SAFE_INTEGER && dx > this.failOffsetXEnd) {
+      return true;
+    }
+    if (this.failOffsetYStart !== Number.MIN_SAFE_INTEGER && dy < this.failOffsetYStart) {
+      return true;
+    }
+    return (this.failOffsetYEnd !== Number.MAX_SAFE_INTEGER && dy > this.failOffsetYEnd);
+  }
+
+  private getTranslation() {
+    return this.lastPos.clone().subtract(this.startPos).add(this.offset)
+  }
+
+  private shouldActivate(): boolean {
+    const {x: dx, y: dy} = this.getTranslation().value;
+    if (this.activeOffsetXStart !== Number.MAX_SAFE_INTEGER && dx < this.activeOffsetXStart
+    ) {
+      return true;
+    }
+    if (this.activeOffsetXEnd !== Number.MIN_SAFE_INTEGER && dx > this.activeOffsetXEnd) {
+      return true;
+    }
+    if (this.activeOffsetYStart !== Number.MAX_SAFE_INTEGER && dy < this.activeOffsetYStart) {
+      return true;
+    }
+    if (this.activeOffsetYEnd !== Number.MIN_SAFE_INTEGER && dy > this.activeOffsetYEnd) {
+      return true;
+    }
+    const distanceSq: number = dx * dx + dy * dy;
+    if (this.minDistSq !== Number.MAX_SAFE_INTEGER && distanceSq >= this.minDistSq) {
+      return true;
+    }
+    const {x: vx, y: vy} = this.velocity
+    if (
+      this.minVelocityX !== Number.MAX_SAFE_INTEGER &&
+        ((this.minVelocityX < 0 && vx <= this.minVelocityX) ||
+          (this.minVelocityX >= 0 && this.minVelocityX <= vx))
+    ) {
+      return true;
+    }
+    if (
+      this.minVelocityY !== Number.MAX_SAFE_INTEGER &&
+        ((this.minVelocityY < 0 && vy <= this.minVelocityY) ||
+          (this.minVelocityY >= 0 && this.minVelocityY <= vy))
+    ) {
+      return true;
+    }
+    const velocitySq: number = vx * vx + vy * vy;
+    return (
+      this.minVelocitySq !== Number.MAX_SAFE_INTEGER &&
+        velocitySq >= this.minVelocitySq
+    );
+  }
+
+  private clearActivationTimeout(): void {
+    clearTimeout(this.activationTimeout);
+  }
+
+  private tryBegin(e: AdaptedEvent): void {
+    if (
+      this.currentState === State.UNDETERMINED &&
+        this.tracker.getTrackedPointersCount() >= this.minPointers
+    ) {
+      this.resetProgress();
+      this.offset = new Vector2D();
+      this.velocity = new Vector2D();
+
+      this.begin();
+
+      if (this.activateAfterLongPress > 0) {
+        this.activationTimeout = setTimeout(() => {
+          this.activate();
+        }, this.activateAfterLongPress);
+      }
+    } else {
+      this.velocity = this.tracker.getVelocity(e.pointerId)
+    }
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  private get activateAfterLongPress() {
+    return this.config.activateAfterLongPress ?? 0
+  }
+
+  private get minDistSq() {
+    if (this.config.minDist !== undefined) {
+      return this.config.minDist * this.config.minDist;
+    } else if (this.hasCustomActivationCriteria()) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return DEFAULT_MIN_DIST_SQ
+  }
+
+  private hasCustomActivationCriteria() {
+    const criterias: (keyof PanGestureHandlerConfig)[] = [
+      'activeOffsetXStart',
+      'activeOffsetXEnd',
+      'failOffsetXStart',
+      'failOffsetXEnd',
+      'activeOffsetYStart',
+      'activeOffsetYEnd',
+      'failOffsetYStart',
+      'failOffsetYEnd',
+      'minVelocityX',
+      'minVelocityY',
+    ]
+    for (const key in this.config) {
+      if (criterias.indexOf(key as keyof PanGestureHandlerConfig) >= 0) {
+        return true
+      }
+    }
+    return false
+  }
+
+  public onAdditionalPointerAdd(event: AdaptedEvent): void {
+    this.tracker.addToTracker(event);
+    super.onAdditionalPointerAdd(event);
+    this.tryBegin(event);
+    this.offset.add(this.lastPos).subtract(this.startPos)
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    if (this.tracker.getTrackedPointersCount() > (this.config.maxPointers ?? 10)) {
+      if (this.currentState === State.ACTIVE) {
+        this.cancel();
+      } else {
+        this.fail();
+      }
+    } else {
+      this.tryActivating();
+    }
+  }
+
+  public onPointerUp(event: AdaptedEvent): void {
+    super.onPointerUp(event);
+    if (this.currentState === State.ACTIVE) {
+      this.lastPos = this.tracker.getLastAvgPos();
+    }
+    this.tracker.removeFromTracker(event.pointerId);
+    if (this.currentState === State.ACTIVE) {
+      this.end();
+    } else {
+      this.resetProgress();
+      this.fail();
+    }
+  }
+
+  public onAdditionalPointerRemove(event: AdaptedEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+    this.offset.add(this.lastPos).subtract(this.startPos)
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    if (
+      !(
+        this.currentState === State.ACTIVE &&
+          this.tracker.getTrackedPointersCount() < this.minPointers
+      )
+    ) {
+      this.tryActivating();
+    }
+  }
+
+  public onPointerMove(event: AdaptedEvent): void {
+    this.tracker.track(event);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.velocity = this.tracker.getVelocity(event.pointerId)
+    this.tryActivating();
+    super.onPointerMove(event);
+  }
+
+  public onPointerOutOfBounds(event: AdaptedEvent): void {
+    if (this.shouldCancelWhenOutside) {
+      return;
+    }
+    this.tracker.track(event);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.velocity = this.tracker.getVelocity(event.pointerId)
+    this.tryActivating();
+    if (this.currentState === State.ACTIVE) {
+      super.onPointerOutOfBounds(event);
+    }
+  }
+
+  protected transformNativeEvent() {
+    const rect = this.view.getBoundingRect();
+    const translation = this.getTranslation()
+    return {
+      translationX: translation.x,
+      translationY: translation.y,
+      absoluteX: this.tracker.getLastAvgX(),
+      absoluteY: this.tracker.getLastAvgY(),
+      velocityX: this.velocity.x,
+      velocityY: this.velocity.y,
+      x: this.tracker.getLastAvgX() - rect.x,
+      y: this.tracker.getLastAvgY() - rect.y,
+    };
+  }
+
+  protected stateDidChange(newState: State, oldState: State) {
+    super.stateDidChange(newState, oldState)
+    if (newState === State.BEGAN) {
+      this.unlockScrolls = this.scrollLocker.lockScrollContainingViewTag(this.view.getTag())
+    } else if (newState !== State.ACTIVE) {
+      this.unlockScrolls?.()
+    }
+  }
+}

package/{src/web/tools → harmony/gesture_handler/src/main/ets}/PointerTracker.ts

@@ -1,23 +1,14 @@
-import { AdaptedEvent } from '../interfaces';
 import VelocityTracker from './VelocityTracker';
-
-export interface TrackerElement {
-  lastX: number;
-  lastY: number;
-
-  timeStamp: number;
-
-  velocityX: number;
-  velocityY: number;
-}
+import { TrackerElement, AdaptedEvent } from "./Event"
+import { Vector2D } from './Vector2D';
 
 const MAX_POINTERS = 20;
 
-export default class PointerTracker {
+export class PointerTracker {
   private velocityTracker = new VelocityTracker();
   private trackedPointers: Map<number, TrackerElement> = new Map<
-    number,
-    TrackerElement
+  number,
+  TrackerElement
   >();
 
   private touchEventsIds: Map<number, number> = new Map<number, number>();
@@ -121,6 +112,10 @@ export default class PointerTracker {
     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;
   }
@@ -170,6 +165,10 @@ export default class PointerTracker {
     }
   }
 
+  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.

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

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