easy-gestures 2.0.5

package/src/position/relative.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { PI } from "../constants";
+
+export default class RelativePosition {
+  constructor(top, left, time, speed, magnitude, direction) {
+    this.top = top;
+    this.left = left;
+    this.time = time;
+    this.speed = speed;
+    this.magnitude = magnitude;
+    this.direction = direction;
+  }
+
+  getTop() {
+    return this.top;
+  }
+
+  getLeft() {
+    return this.left;
+  }
+
+  getTime() {
+    return this.time;
+  }
+
+  getSpeed() {
+    return this.speed;
+  }
+
+  getMagnitude() {
+    return this.magnitude;
+  }
+
+  getDirection() {
+    return this.direction;
+  }
+
+  static fromFirstPositionAndSecondPosition(firstPosition, secondPosition) {
+    const position = secondPosition.minus(firstPosition),
+          top = position.getTop(),
+          left = position.getLeft(),
+          time = position.getTime(),
+          magnitude = Math.sqrt(top * top + left * left),
+          speed = (time === 0) ?
+                    0 :
+                      magnitude / time;
+
+    let direction;
+
+    if (left === 0) {
+      direction = (top < 0) ?
+                   +PI / 2 :
+                    -PI / 2;
+    } else {
+      direction = Math.atan2(-top, left);
+    }
+
+    const relativePosition = new RelativePosition(top, left, time, speed, magnitude, direction);
+
+    return relativePosition;
+  }
+}

package/src/position.js

@@ -0,0 +1,74 @@
+"use strict";
+
+export default class Position {
+  constructor(top, left, time, identifier) {
+    this.top = top;
+    this.left = left;
+    this.time = time;
+    this.identifier = identifier;
+  }
+
+  getTop() {
+    return this.top;
+  }
+
+  getLeft() {
+    return this.left;
+  }
+
+  getTime() {
+    return this.time;
+  }
+
+  getIdentifier() {
+    return this.identifier;
+  }
+
+  minus(position) {
+    const positionTop = position.getTop(),
+          positionLeft = position.getLeft(),
+          positionTime = position.getTime(),
+          top = this.top - positionTop,
+          left = this.left - positionLeft,
+          time = this.time - positionTime,
+          identifier = this.identifier;
+
+    position = new Position(top, left, time, identifier); ///
+
+    return position;
+  }
+
+  match(position) {
+    const identifier = position.getIdentifier(),
+          matches = (this.identifier === identifier);
+
+    return matches;
+  }
+
+  static fromTouch(touch) {
+    const { pageX, pageY, identifier } = touch,
+          top = pageY,  ///
+          left = pageX, ///
+          time = getTime(),
+          position = new Position(top, left, time, identifier);
+
+    return position;
+  }
+
+  static fromMouseEvent(mouseEvent) {
+    const { pageX, pageY } = mouseEvent,
+          top = pageY,  ///
+          left = pageX, ///
+          time = getTime(),
+          identifier = null,
+          position = new Position(top, left, time, identifier);
+
+    return position;
+  }
+}
+
+function getTime() {
+  const time = Date.now();  ///
+
+  return time;
+}

package/src/preamble.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { React } from "easy";
+
+Object.assign(globalThis, {
+  React
+});

package/src/selectors.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const DIV_SELECTOR = "div";
+export const DIVS_SELECTOR = "body > div:not(.loading)"; ///
+export const LOADING_DIV_SELECTOR = "body > div.loading";

package/src/utilities/positions.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Position from "../position";
+
+const { clear, filter } = arrayUtilities;
+
+export function sortPositions(positionsA, positionsB) {
+  const positionAMap = positionsA.reduce((positionAMap, positionA) => {
+    const identifier = positionA.getIdentifier();
+
+    positionAMap[identifier] = positionA;
+
+    return positionAMap;
+  }, {});
+
+  clear(positionsA);
+
+  positionsB.forEach((positionB) => {
+    const identifier = positionB.getIdentifier(),
+          positionA = positionAMap[identifier];
+
+    positionsA.push(positionA);
+  });
+}
+
+export function matchPositions(positionsA, positionsB) {
+  let positionsMatch = false;
+
+  const positionsALength = positionsA.length,
+        positionsBLength = positionsB.length;
+
+  if (positionsALength === positionsBLength) {
+    const identifiersA = identifiersFromPositions(positionsA),
+          identifiersB = identifiersFromPositions(positionsB);
+
+    identifiersA.sort();
+
+    identifiersB.sort();
+
+    const identifiersMatch = identifiersA.every((identifierA, index) => {
+      const identifierB = identifiersB[index];
+
+      if (identifierA === identifierB) {
+        return true;
+      }
+    });
+
+    positionsMatch = identifiersMatch;  ///
+  }
+
+  return positionsMatch;
+}
+
+export function filterPositions(positionsA, positionsB) {
+  filter(positionsA, (positionA) => {
+    const matches = positionsB.some((positionB) => {
+      const matches = positionA.match(positionB);
+
+      if (matches) {
+        return true;
+      }
+    });
+
+    if (!matches) {
+      return true;
+    }
+  });
+}
+
+export function positionsFromMouseEvent(mouseEvent) {
+  const position = Position.fromMouseEvent(mouseEvent),
+        positions = [
+          position
+        ];
+
+  return positions;
+}
+
+export function positionsFromTouchEvent(touchEvent, changed = true) {
+  let touchesNodeList;
+
+  if (changed) {
+    ({ changedTouches: touchesNodeList } = touchEvent);
+  } else {
+    ({ touches: touchesNodeList } = touchEvent);
+  }
+
+  const touches = [
+          ...touchesNodeList
+        ],
+        positions = touches.map((touch) => {
+          const position = Position.fromTouch(touch);
+
+          return position;
+        });
+
+  compressPositions(positions);
+
+  return positions;
+}
+
+function compressPositions(positions) {
+  const positionMap = positions.reduce((positionMap, position) => {
+    const identifier = position.getIdentifier();
+
+    positionMap[identifier] = position;
+
+    return positionMap;
+  }, {});
+
+  positions = Object.values(positionMap);
+
+  return positions;
+}
+
+function identifiersFromPositions(positions) {
+  const identifiers = positions.map((position) => {
+    const identifier = position.getIdentifier();
+
+    return identifier;
+  });
+
+  return identifiers;
+}
+