highmark-cli 0.0.135 → 0.0.138

package/src/mixins/touch.js

@@ -1,18 +1,40 @@
 "use strict";
 
 import { window } from "easy";
-
-import Position from "../position";
-import Velocity from "../velocity";
-
-import { TAP_CUSTOM_EVENT_TYPE, SWIPE_LEFT_CUSTOM_EVENT_TYPE, SWIPE_RIGHT_CUSTOM_EVENT_TYPE } from "../customEventTypes";
-import { MAXIMUM_TAP_TIME, MINIMUM_SWIPE_SPEED, ONE_HUNDRED_AND_EIGHTY, MAXIMUM_SWIPE_ABSOLUTE_DIRECTION } from "../constants";
+import { arrayUtilities } from "necessary";
+
+import RelativePosition from "../position/relative";
+
+import { TOUCHSTART_EVENT_TYPE, TOUCHMOVE_EVENT_TYPE, TOUCHEND_EVENT_TYPE } from "../eventTypes";
+import { PI, TAP_DELAY, PI_OVER_TWO, MAXIMUM_TAP_TIME, MINIMUM_SWIPE_SPEED, MAXIMUM_SPREAD } from "../constants";
+import { sortPositions, matchPositions, filterPositions, positionsFromMouseEvent, positionsFromTouchEvent } from "../utilities/positions";
+import { TAP_CUSTOM_EVENT_TYPE,
+         DRAG_UP_CUSTOM_EVENT_TYPE,
+         DRAG_DOWN_CUSTOM_EVENT_TYPE,
+         DRAG_LEFT_CUSTOM_EVENT_TYPE,
+         DRAG_RIGHT_CUSTOM_EVENT_TYPE,
+         DRAG_START_CUSTOM_EVENT_TYPE,
+         SWIPE_UP_CUSTOM_EVENT_TYPE,
+         SWIPE_DOWN_CUSTOM_EVENT_TYPE,
+         SWIPE_LEFT_CUSTOM_EVENT_TYPE,
+         SWIPE_RIGHT_CUSTOM_EVENT_TYPE,
+         PINCH_MOVE_CUSTOM_EVENT_TYPE,
+         PINCH_START_CUSTOM_EVENT_TYPE,
+         DOUBLE_TAP_CUSTOM_EVENT_TYPE } from "../customEventTypes";
+
+const { push, first, second } = arrayUtilities;
 
 function enableTouch() {
-  const startPosition = null;
+  const tapInterval = null,
+        startMagnitude = null,
+        startPositions = [],
+        movingPositions = [];
 
   this.updateState({
-    startPosition
+    tapInterval,
+    startMagnitude,
+    startPositions,
+    movingPositions
   });
 
   this.onMouseDown(this.mouseDownHandler);
@@ -36,6 +58,48 @@ function disableTouch() {
   this.offTouchEnd(this.touchEndHandler);
 }
 
+function onTouchStart(touchStartHandler) {
+  const eventType = TOUCHSTART_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.onEvent(eventType, handler);
+}
+
+function offTouchStart(touchStartHandler) {
+  const eventType = TOUCHSTART_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.offEvent(eventType, handler);
+}
+
+function onTouchMove(touchStartHandler) {
+  const eventType = TOUCHMOVE_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.onEvent(eventType, handler);
+}
+
+function offTouchMove(touchStartHandler) {
+  const eventType = TOUCHMOVE_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.offEvent(eventType, handler);
+}
+
+function onTouchEnd(touchStartHandler) {
+  const eventType = TOUCHEND_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.onEvent(eventType, handler);
+}
+
+function offTouchEnd(touchStartHandler) {
+  const eventType = TOUCHEND_EVENT_TYPE,
+        handler = touchStartHandler;  ///
+
+  this.offEvent(eventType, handler);
+}
+
 function onCustomTap(tapCustomHandler, element) {
   const customEventType = TAP_CUSTOM_EVENT_TYPE,
         customHandler = tapCustomHandler; ///
@@ -50,6 +114,104 @@ function offCustomTap(tapCustomHandler, element) {
   this.offCustomEvent(customEventType, customHandler, element);
 }
 
+function onCustomDragUp(dragUpCustomHandler, element) {
+  const customEventType = DRAG_UP_CUSTOM_EVENT_TYPE,
+        customHandler = dragUpCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDragUp(dragUpCustomHandler, element) {
+  const customEventType = DRAG_UP_CUSTOM_EVENT_TYPE,
+        customHandler = dragUpCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomDragDown(dragDownCustomHandler, element) {
+  const customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE,
+        customHandler = dragDownCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDragDown(dragDownCustomHandler, element) {
+  const customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE,
+        customHandler = dragDownCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomDragLeft(dragLeftCustomHandler, element) {
+  const customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE,
+        customHandler = dragLeftCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDragLeft(dragLeftCustomHandler, element) {
+  const customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE,
+        customHandler = dragLeftCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomDragRight(dragRightCustomHandler, element) {
+  const customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE,
+        customHandler = dragRightCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDragRight(dragRightCustomHandler, element) {
+  const customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE,
+        customHandler = dragRightCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomDragStart(dragStartCustomHandler, element) {
+  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE,
+        customHandler = dragStartCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDragStart(dragStartCustomHandler, element) {
+  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE,
+        customHandler = dragStartCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomSwipeUp(swipeUpCustomHandler, element) {
+  const customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE,
+        customHandler = swipeUpCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomSwipeUp(swipeUpCustomHandler, element) {
+  const customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE,
+        customHandler = swipeUpCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomSwipeDown(swipeDownCustomHandler, element) {
+  const customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE,
+        customHandler = swipeDownCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomSwipeDown(swipeDownCustomHandler, element) {
+  const customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE,
+        customHandler = swipeDownCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
 function onCustomSwipeLeft(swipeLeftCustomHandler, element) {
   const customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE,
         customHandler = swipeLeftCustomHandler; ///
@@ -78,154 +240,447 @@ function offCustomSwipeRight(swipeRightCustomHandler, element) {
   this.offCustomEvent(customEventType, customHandler, element);
 }
 
-function getStartPosition() {
-  const { startPosition } = this.getState();
+function onCustomPinchMove(pinchMoveCustomHandler, element) {
+  const customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,
+        customHandler = pinchMoveCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomPinchMove(pinchMoveCustomHandler, element) {
+  const customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,
+        customHandler = pinchMoveCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomPinchStart(pinchStartCustomHandler, element) {
+  const customEventType = PINCH_START_CUSTOM_EVENT_TYPE,
+        customHandler = pinchStartCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomPinchStart(pinchStartCustomHandler, element) {
+  const customEventType = PINCH_START_CUSTOM_EVENT_TYPE,
+        customHandler = pinchStartCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function onCustomDoubleTap(doubleTapCustomHandler, element) {
+  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE,
+        customHandler = doubleTapCustomHandler; ///
+
+  this.onCustomEvent(customEventType, customHandler, element);
+}
+
+function offCustomDoubleTap(doubleTapCustomHandler, element) {
+  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE,
+        customHandler = doubleTapCustomHandler; ///
+
+  this.offCustomEvent(customEventType, customHandler, element);
+}
+
+function getTapInterval() {
+  const { tapInterval } = this.getState();
 
-  return startPosition;
+  return tapInterval;
 }
 
-function setStartPosition(startPosition) {
+function setTapInterval(tapInterval) {
   this.updateState({
-    startPosition
+    tapInterval
+  });
+}
+
+function getStartMagnitude() {
+  const { startMagnitude } = this.getState();
+
+  return startMagnitude;
+}
+
+function setStartMagnitude(startMagnitude) {
+  this.updateState({
+    startMagnitude
+  });
+}
+
+function getStartPositions() {
+  const { startPositions } = this.getState();
+
+  return startPositions;
+}
+
+function setStartPositions(startPositions) {
+  this.updateState({
+    startPositions
+  });
+}
+
+function getMovingPositions() {
+  const { movingPositions } = this.getState();
+
+  return movingPositions;
+}
+
+function setMovingPositions(movingPositions) {
+  this.updateState({
+    movingPositions
   });
 }
 
 function touchStartHandler(event, element) {
   this.startHandler(event, element, (event) => {
     const touchEvent = event, ///
-          position = Position.fromTouchEvent(touchEvent);
+          changed = false,
+          positions = positionsFromTouchEvent(touchEvent, changed);
 
-    return position;
+    return positions;
   });
 }
 
 function mouseDownHandler(event, element) {
-  this.startHandler(event, element, (event) => {  ///
+  this.startHandler(event, element, (event) => {
     const mouseEvent = event, ///
-          position = Position.fromMouseEvent(mouseEvent);
+          positions = positionsFromMouseEvent(mouseEvent);
 
-    return position;
+    return positions;
   });
 }
 
 function touchMoveHandler(event, element) {
   this.moveHandler(event, element, (event) => {
     const touchEvent = event, ///
-          position = Position.fromTouchEvent(touchEvent);
+          changed = false,
+          positions = positionsFromTouchEvent(touchEvent, changed);
 
-    return position;
+    return positions;
   });
 }
 
 function mouseMoveHandler(event, element) {
   this.moveHandler(event, element, (event) => {
     const mouseEvent = event, ///
-          position = Position.fromMouseEvent(mouseEvent);
+          positions = positionsFromMouseEvent(mouseEvent);
 
-    return position;
+    return positions;
   });
 }
 
 function touchEndHandler(event, element) {
   this.endHandler(event, element, (event) => {
     const touchEvent = event, ///
-          position = Position.fromTouchEvent(touchEvent);
+          changed = true,
+          positions = positionsFromTouchEvent(touchEvent, changed);
 
-    return position;
+    return positions;
   });
 }
 
 function mouseUpHandler(event, element) {
-  this.endHandler(event, element, (event) => {  ///
+  this.endHandler(event, element, (event) => {
     const mouseEvent = event, ///
-          position = Position.fromMouseEvent(mouseEvent);
+          positions = positionsFromMouseEvent(mouseEvent);
 
-    return position;
+    return positions;
   });
 }
 
-function startHandler(event, element, positionFromEvent) {
-  const position = positionFromEvent(event),
-        startPosition = position;  ///
+function startHandler(event, element, positionsFromEvent) {
+  const positions = positionsFromEvent(event),
+        startPositions = this.getStartPositions();
+
+  filterPositions(startPositions, positions);
 
-  this.setStartPosition(startPosition);
+  push(startPositions, positions);
+
+  const startingPositionsLength = startPositions.length;
+
+  if (startingPositionsLength === 1) {
+    this.dragStart(event, element);
+  }
+
+  if (startingPositionsLength === 2) {
+    this.pinchStart(event, element);
+  }
 }
 
-function moveHandler(event, element, positionFromEvent) {
-  let startPosition = this.getStartPosition();
+function moveHandler(event, element, positionsFromEvent) {
+  const positions = positionsFromEvent(event),
+        startPositions = this.getStartPositions(),
+        movingPositions = this.getMovingPositions();
 
-  if (startPosition !== null) {
-    const position = positionFromEvent(event);
+  filterPositions(movingPositions, positions);
 
-    if (position !== null) {
-      const positionMatchesStartPosition = position.match(startPosition);
+  push(movingPositions, positions);
 
-      if (positionMatchesStartPosition) {
-        const velocity = Velocity.fromPositionAndStartPosition(position, startPosition),
-              speed = velocity.getSpeed();
+  const positionsMatch = matchPositions(startPositions, movingPositions);
 
-        if (speed > MINIMUM_SWIPE_SPEED) {
-          const absoluteDirection = velocity.getAbsoluteDirection();
+  if (positionsMatch) {
+    sortPositions(movingPositions, startPositions);
 
-          let customEventType = null;
+    const movingPositionsLength = movingPositions.length;
 
-          if (absoluteDirection < MAXIMUM_SWIPE_ABSOLUTE_DIRECTION) {
-            customEventType = SWIPE_RIGHT_CUSTOM_EVENT_TYPE;
-          }
+    if (movingPositionsLength === 1) {
+      this.drag(event, element);
+    }
 
-          if ((ONE_HUNDRED_AND_EIGHTY - absoluteDirection) < MAXIMUM_SWIPE_ABSOLUTE_DIRECTION) {
-            customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE;
-          }
+    if (movingPositionsLength === 2) {
+      this.pinch(event, element);
+    }
+  }
+}
+
+function endHandler(event, element, positionsFromEvent) {
+  const positions = positionsFromEvent(event),
+        startPositions = this.getStartPositions(),
+        movingPositions = this.getMovingPositions(),
+        positionsMatch = matchPositions(startPositions, movingPositions);
 
-          if (customEventType !== null) {
-            this.callCustomHandlers(customEventType, event, element);
-          }
-        }
-      }
+  if (positionsMatch) {
+    const startPositionsLength = startPositions.length,
+          movingPositionsLength = movingPositions.length;
+
+    if (movingPositionsLength === 0) {
+      this.tapOrDoubleTap(event, element);
+    } else if (startPositionsLength === 1) {
+      this.possibleTap(event, element);
+
+      this.possibleSwipe(event, element);
     }
   }
+
+  filterPositions(startPositions, positions);
+
+  filterPositions(movingPositions, positions);
 }
 
-function endHandler(event, element, positionFromEvent) {
-  let startPosition;
+function tap(event, element) {
+  const elementTarget = isElementTarget(event, element);
+
+  if (!elementTarget) {
+    return;
+  }
 
-  startPosition = this.getStartPosition();
+  const customEventType = TAP_CUSTOM_EVENT_TYPE;
 
-  if (startPosition !== null) {
-    const position = positionFromEvent(event);
+  this.callCustomHandlers(customEventType, event, element);
+}
 
-    if (position !== null) {
-      const positionMatchesStartPosition = position.match(startPosition);
+function drag(event, element) {
+  const startPositions = this.getStartPositions(),
+        movingPositions = this.getMovingPositions(),
+        firstStartPosition = first(startPositions),
+        firstMovingPosition = first(movingPositions),
+        firstPosition = firstStartPosition, ///
+        secondPosition = firstMovingPosition, ///
+        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),
+        top = relativePosition.getTop(),
+        left = relativePosition.getLeft(),
+        direction = relativePosition.getDirection();
+
+  let customEventType = null;
+
+  if ((Math.abs(direction)) < MAXIMUM_SPREAD) {
+    customEventType = DRAG_RIGHT_CUSTOM_EVENT_TYPE;
+  }
 
-      if (positionMatchesStartPosition) {
-        const velocity = Velocity.fromPositionAndStartPosition(position, startPosition),
-              speed = velocity.getSpeed();
+  if (Math.abs(PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {
+    customEventType = DRAG_UP_CUSTOM_EVENT_TYPE;
+  }
 
-        if (speed === 0) {
-          const time = velocity.getTime();
+  if (Math.abs(-PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {
+    customEventType = DRAG_DOWN_CUSTOM_EVENT_TYPE;
+  }
 
-          if (time < MAXIMUM_TAP_TIME) {
-            const customEventType = TAP_CUSTOM_EVENT_TYPE;
+  if ((PI - Math.abs(direction)) < MAXIMUM_SPREAD) {
+    customEventType = DRAG_LEFT_CUSTOM_EVENT_TYPE;
+  }
 
-            this.callCustomHandlers(customEventType, event, element);
-          }
-        }
-      }
-    }
+  if (customEventType !== null) {
+    this.callCustomHandlers(customEventType, event, element, top, left);
   }
 }
 
-const customEventMixins = {
+function pinch(event, element) {
+  const movingPositions = this.getMovingPositions(),
+        firstMovingPosition = first(movingPositions),
+        secondMovingPosition = second(movingPositions),
+        relativeMovingPosition = RelativePosition.fromFirstPositionAndSecondPosition(firstMovingPosition, secondMovingPosition),
+        customEventType = PINCH_MOVE_CUSTOM_EVENT_TYPE,
+        startMagnitude = this.getStartMagnitude(),
+        magnitude = relativeMovingPosition.getMagnitude(),
+        ratio = magnitude / startMagnitude;
+
+  this.callCustomHandlers(customEventType, event, element, ratio);
+}
+
+function swipe(event, element, speed, direction) {
+  let customEventType = null;
+
+  if ((Math.abs(direction)) < MAXIMUM_SPREAD) {
+    customEventType = SWIPE_RIGHT_CUSTOM_EVENT_TYPE;
+
+    speed = speed * Math.cos(direction);
+  }
+
+  if (Math.abs(PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {
+    customEventType = SWIPE_UP_CUSTOM_EVENT_TYPE;
+
+    speed = speed * Math.sin(direction);
+  }
+
+  if (Math.abs(-PI_OVER_TWO - direction) < MAXIMUM_SPREAD) {
+    customEventType = SWIPE_DOWN_CUSTOM_EVENT_TYPE;
+
+    speed = speed * Math.sin(direction);
+  }
+
+  if ((PI - Math.abs(direction)) < MAXIMUM_SPREAD) {
+    customEventType = SWIPE_LEFT_CUSTOM_EVENT_TYPE;
+
+    speed = speed * Math.cos(direction);
+  }
+
+  if (customEventType !== null) {
+    const startPositions = this.getStartPositions(),
+          firstStartPosition = first(startPositions),
+          startPosition = firstStartPosition, ///
+          top = startPosition.getTop(),
+          left = startPosition.getLeft();
+
+    this.callCustomHandlers(customEventType, event, element, top, left, speed);
+  }
+}
+
+function doubleTap(event, element) {
+  const customEventType = DOUBLE_TAP_CUSTOM_EVENT_TYPE;
+
+  this.callCustomHandlers(customEventType, event, element);
+}
+
+function dragStart(event, element) {
+  const customEventType = DRAG_START_CUSTOM_EVENT_TYPE;
+
+  this.callCustomHandlers(customEventType, event, element);
+}
+
+function pinchStart(event, element) {
+  const startPositions = this.getStartPositions(),
+        firstStartPosition = first(startPositions),
+        secondStartPosition = second(startPositions),
+        relativeStartPosition = RelativePosition.fromFirstPositionAndSecondPosition(firstStartPosition, secondStartPosition),
+        magnitude = relativeStartPosition.getMagnitude(),
+        startMagnitude = magnitude, ///
+        customEventType = PINCH_START_CUSTOM_EVENT_TYPE;
+
+  this.setStartMagnitude(startMagnitude);
+
+  this.callCustomHandlers(customEventType, event, element);
+}
+
+function possibleTap(event, element) {
+  const startPositions = this.getStartPositions(),
+        movingPositions = this.getMovingPositions(),
+        firstStartPosition = first(startPositions),
+        firstMovingPosition = first(movingPositions),
+        firstPosition = firstStartPosition, ///
+        secondPosition = firstMovingPosition, ///
+        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),
+        time = relativePosition.getTime(),
+        speed = relativePosition.getSpeed();
+
+  if ((speed === 0) && (time < MAXIMUM_TAP_TIME)){
+    this.tapOrDoubleTap(event, element);
+  }
+}
+
+function possibleSwipe(event, element) {
+  const startPositions = this.getStartPositions(),
+        movingPositions = this.getMovingPositions(),
+        firstStartPosition = first(startPositions),
+        firstMovingPosition = first(movingPositions),
+        firstPosition = firstStartPosition, ///
+        secondPosition = firstMovingPosition, ///
+        relativePosition = RelativePosition.fromFirstPositionAndSecondPosition(firstPosition, secondPosition),
+        direction = relativePosition.getDirection(),
+        speed = relativePosition.getSpeed();
+
+  if (speed > MINIMUM_SWIPE_SPEED) {
+    this.swipe(event, element, speed, direction);
+  }
+}
+
+function tapOrDoubleTap(event, element) {
+  let tapInterval = this.getTapInterval();
+
+  if (tapInterval !== null) {
+    clearTimeout(tapInterval);
+
+    tapInterval = null;
+
+    this.setTapInterval(tapInterval);
+
+    this.doubleTap(event, element);
+
+    return;
+  }
+
+  tapInterval = setTimeout(() => {
+    tapInterval = null;
+
+    this.setTapInterval(tapInterval);
+
+    this.tap(event, element);
+  }, TAP_DELAY);
+
+  this.setTapInterval(tapInterval);
+}
+
+const touchMixins = {
   enableTouch,
   disableTouch,
+  onTouchStart,
+  offTouchStart,
+  onTouchMove,
+  offTouchMove,
+  onTouchEnd,
+  offTouchEnd,
   onCustomTap,
   offCustomTap,
+  onCustomDragUp,
+  offCustomDragUp,
+  onCustomDragDown,
+  offCustomDragDown,
+  onCustomDragLeft,
+  offCustomDragLeft,
+  onCustomDragRight,
+  offCustomDragRight,
+  onCustomDragStart,
+  offCustomDragStart,
+  onCustomSwipeUp,
+  offCustomSwipeUp,
+  onCustomSwipeDown,
+  offCustomSwipeDown,
   onCustomSwipeLeft,
   offCustomSwipeLeft,
   onCustomSwipeRight,
   offCustomSwipeRight,
-  getStartPosition,
-  setStartPosition,
+  onCustomPinchMove,
+  offCustomPinchMove,
+  onCustomPinchStart,
+  offCustomPinchStart,
+  onCustomDoubleTap,
+  offCustomDoubleTap,
+  getTapInterval,
+  setTapInterval,
+  getStartMagnitude,
+  setStartMagnitude,
+  getStartPositions,
+  setStartPositions,
+  getMovingPositions,
+  setMovingPositions,
   touchStartHandler,
   mouseDownHandler,
   touchMoveHandler,
@@ -234,7 +689,30 @@ const customEventMixins = {
   mouseUpHandler,
   startHandler,
   moveHandler,
-  endHandler
+  endHandler,
+  tap,
+  drag,
+  pinch,
+  swipe,
+  doubleTap,
+  dragStart,
+  pinchStart,
+  possibleTap,
+  possibleSwipe,
+  tapOrDoubleTap
 };
 
-export default customEventMixins;
+export default touchMixins;
+
+function isElementTarget(event, element) {
+  if (element === window) {
+    debugger
+  }
+
+  const { target } = event,
+        domElement = element.getDOMElement(),
+        domElementTarget = (domElement === target),
+        elementTarget = domElementTarget;  ///
+
+  return elementTarget;
+}