{"ast":null,"code":"import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _get from \"@babel/runtime/helpers/get\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\nimport Hammer from '@egjs/hammerjs';\nimport { MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD, MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD } from \"./constants\";\nimport DraggingGestureHandler from \"./DraggingGestureHandler\";\nimport { isValidNumber, isnan, TEST_MIN_IF_NOT_NAN, VEC_LEN_SQ } from \"./utils\";\nimport { State } from \"../State\";\nvar PanGestureHandler = function (_DraggingGestureHandl) {\n  _inherits(PanGestureHandler, _DraggingGestureHandl);\n  var _super = _createSuper(PanGestureHandler);\n  function PanGestureHandler() {\n    _classCallCheck(this, PanGestureHandler);\n    return _super.apply(this, arguments);\n  }\n  _createClass(PanGestureHandler, [{\n    key: \"name\",\n    get: function get() {\n      return 'pan';\n    }\n  }, {\n    key: \"NativeGestureClass\",\n    get: function get() {\n      return Hammer.Pan;\n    }\n  }, {\n    key: \"getHammerConfig\",\n    value: function getHammerConfig() {\n      return _objectSpread(_objectSpread({}, _get(_getPrototypeOf(PanGestureHandler.prototype), \"getHammerConfig\", this).call(this)), {}, {\n        direction: this.getDirection()\n      });\n    }\n  }, {\n    key: \"getState\",\n    value: function getState(type) {\n      var nextState = _get(_getPrototypeOf(PanGestureHandler.prototype), \"getState\", this).call(this, type);\n      if (this.previousState === State.UNDETERMINED && nextState === State.ACTIVE) {\n        return State.BEGAN;\n      }\n      return nextState;\n    }\n  }, {\n    key: \"getDirection\",\n    value: function getDirection() {\n      var config = this.getConfig();\n      var activeOffsetXStart = config.activeOffsetXStart,\n        activeOffsetXEnd = config.activeOffsetXEnd,\n        activeOffsetYStart = config.activeOffsetYStart,\n        activeOffsetYEnd = config.activeOffsetYEnd,\n        minDist = config.minDist;\n      var directions = [];\n      var horizontalDirections = [];\n      if (!isnan(minDist)) {\n        return Hammer.DIRECTION_ALL;\n      }\n      if (!isnan(activeOffsetXStart)) {\n        horizontalDirections.push(Hammer.DIRECTION_LEFT);\n      }\n      if (!isnan(activeOffsetXEnd)) {\n        horizontalDirections.push(Hammer.DIRECTION_RIGHT);\n      }\n      if (horizontalDirections.length === 2) {\n        horizontalDirections = [Hammer.DIRECTION_HORIZONTAL];\n      }\n      directions = directions.concat(horizontalDirections);\n      var verticalDirections = [];\n      if (!isnan(activeOffsetYStart)) {\n        verticalDirections.push(Hammer.DIRECTION_UP);\n      }\n      if (!isnan(activeOffsetYEnd)) {\n        verticalDirections.push(Hammer.DIRECTION_DOWN);\n      }\n      if (verticalDirections.length === 2) {\n        verticalDirections = [Hammer.DIRECTION_VERTICAL];\n      }\n      directions = directions.concat(verticalDirections);\n      if (!directions.length) {\n        return Hammer.DIRECTION_NONE;\n      }\n      if (directions[0] === Hammer.DIRECTION_HORIZONTAL && directions[1] === Hammer.DIRECTION_VERTICAL) {\n        return Hammer.DIRECTION_ALL;\n      }\n      if (horizontalDirections.length && verticalDirections.length) {\n        return Hammer.DIRECTION_ALL;\n      }\n      return directions[0];\n    }\n  }, {\n    key: \"getConfig\",\n    value: function getConfig() {\n      if (!this.hasCustomActivationCriteria) {\n        return {\n          minDistSq: 10\n        };\n      }\n      return this.config;\n    }\n  }, {\n    key: \"shouldFailUnderCustomCriteria\",\n    value: function shouldFailUnderCustomCriteria(_ref, criteria) {\n      var deltaX = _ref.deltaX,\n        deltaY = _ref.deltaY;\n      return !isnan(criteria.failOffsetXStart) && deltaX < criteria.failOffsetXStart || !isnan(criteria.failOffsetXEnd) && deltaX > criteria.failOffsetXEnd || !isnan(criteria.failOffsetYStart) && deltaY < criteria.failOffsetYStart || !isnan(criteria.failOffsetYEnd) && deltaY > criteria.failOffsetYEnd;\n    }\n  }, {\n    key: \"shouldActivateUnderCustomCriteria\",\n    value: function shouldActivateUnderCustomCriteria(_ref2, criteria) {\n      var deltaX = _ref2.deltaX,\n        deltaY = _ref2.deltaY,\n        velocity = _ref2.velocity;\n      return !isnan(criteria.activeOffsetXStart) && deltaX < criteria.activeOffsetXStart || !isnan(criteria.activeOffsetXEnd) && deltaX > criteria.activeOffsetXEnd || !isnan(criteria.activeOffsetYStart) && deltaY < criteria.activeOffsetYStart || !isnan(criteria.activeOffsetYEnd) && deltaY > criteria.activeOffsetYEnd || TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ({\n        x: deltaX,\n        y: deltaY\n      }), criteria.minDistSq) || TEST_MIN_IF_NOT_NAN(velocity.x, criteria.minVelocityX) || TEST_MIN_IF_NOT_NAN(velocity.y, criteria.minVelocityY) || TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ(velocity), criteria.minVelocitySq);\n    }\n  }, {\n    key: \"shouldMultiFingerPanFail\",\n    value: function shouldMultiFingerPanFail(_ref3) {\n      var pointerLength = _ref3.pointerLength,\n        scale = _ref3.scale,\n        deltaRotation = _ref3.deltaRotation;\n      if (pointerLength <= 1) {\n        return false;\n      }\n      var deltaScale = Math.abs(scale - 1);\n      var absDeltaRotation = Math.abs(deltaRotation);\n      if (deltaScale > MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD) {\n        return true;\n      }\n      if (absDeltaRotation > MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD) {\n        return true;\n      }\n      return false;\n    }\n  }, {\n    key: \"updateHasCustomActivationCriteria\",\n    value: function updateHasCustomActivationCriteria(criteria) {\n      return isValidNumber(criteria.minDistSq) || isValidNumber(criteria.minVelocityX) || isValidNumber(criteria.minVelocityY) || isValidNumber(criteria.minVelocitySq) || isValidNumber(criteria.activeOffsetXStart) || isValidNumber(criteria.activeOffsetXEnd) || isValidNumber(criteria.activeOffsetYStart) || isValidNumber(criteria.activeOffsetYEnd);\n    }\n  }, {\n    key: \"isGestureEnabledForEvent\",\n    value: function isGestureEnabledForEvent(props, _recognizer, inputData) {\n      if (this.shouldFailUnderCustomCriteria(inputData, props)) {\n        return {\n          failed: true\n        };\n      }\n      var velocity = {\n        x: inputData.velocityX,\n        y: inputData.velocityY\n      };\n      if (this.hasCustomActivationCriteria && this.shouldActivateUnderCustomCriteria({\n        deltaX: inputData.deltaX,\n        deltaY: inputData.deltaY,\n        velocity: velocity\n      }, props)) {\n        if (this.shouldMultiFingerPanFail({\n          pointerLength: inputData.maxPointers,\n          scale: inputData.scale,\n          deltaRotation: inputData.deltaRotation\n        })) {\n          return {\n            failed: true\n          };\n        }\n        return {\n          success: true\n        };\n      }\n      return {\n        success: false\n      };\n    }\n  }]);\n  return PanGestureHandler;\n}(DraggingGestureHandler);\nexport default PanGestureHandler;","map":{"version":3,"mappings":"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","names":["Hammer","MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD","MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD","DraggingGestureHandler","isValidNumber","isnan","TEST_MIN_IF_NOT_NAN","VEC_LEN_SQ","State","PanGestureHandler","Pan","getHammerConfig","direction","getDirection","getState","type","nextState","previousState","UNDETERMINED","ACTIVE","BEGAN","config","getConfig","activeOffsetXStart","activeOffsetXEnd","activeOffsetYStart","activeOffsetYEnd","minDist","directions","horizontalDirections","DIRECTION_ALL","push","DIRECTION_LEFT","DIRECTION_RIGHT","length","DIRECTION_HORIZONTAL","concat","verticalDirections","DIRECTION_UP","DIRECTION_DOWN","DIRECTION_VERTICAL","DIRECTION_NONE","hasCustomActivationCriteria","minDistSq","shouldFailUnderCustomCriteria","criteria","deltaX","deltaY","failOffsetXStart","failOffsetXEnd","failOffsetYStart","failOffsetYEnd","shouldActivateUnderCustomCriteria","velocity","x","y","minVelocityX","minVelocityY","minVelocitySq","shouldMultiFingerPanFail","pointerLength","scale","deltaRotation","deltaScale","Math","abs","absDeltaRotation","updateHasCustomActivationCriteria","isGestureEnabledForEvent","props","_recognizer","inputData","failed","velocityX","velocityY","maxPointers","success"],"sources":["/Users/mathildejean/Documents/BUT/LaSuperMeteo/LaSuperMeteo/iut-expo-starter/node_modules/react-native-gesture-handler/lib/module/web_hammer/PanGestureHandler.ts"],"sourcesContent":["import Hammer from '@egjs/hammerjs';\n\nimport {\n  EventMap,\n  MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD,\n  MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD,\n} from './constants';\nimport DraggingGestureHandler from './DraggingGestureHandler';\nimport { isValidNumber, isnan, TEST_MIN_IF_NOT_NAN, VEC_LEN_SQ } from './utils';\nimport { State } from '../State';\n\nimport { Config, HammerInputExt } from './GestureHandler';\nclass PanGestureHandler extends DraggingGestureHandler {\n  get name() {\n    return 'pan';\n  }\n\n  get NativeGestureClass() {\n    return Hammer.Pan;\n  }\n\n  getHammerConfig() {\n    return {\n      ...super.getHammerConfig(),\n      direction: this.getDirection(),\n    };\n  }\n\n  getState(type: keyof typeof EventMap) {\n    const nextState = super.getState(type);\n    // Ensure that the first state sent is `BEGAN` and not `ACTIVE`\n    if (\n      this.previousState === State.UNDETERMINED &&\n      nextState === State.ACTIVE\n    ) {\n      return State.BEGAN;\n    }\n    return nextState;\n  }\n\n  getDirection() {\n    const config = this.getConfig();\n    const {\n      activeOffsetXStart,\n      activeOffsetXEnd,\n      activeOffsetYStart,\n      activeOffsetYEnd,\n      minDist,\n    } = config;\n    let directions: number[] = [];\n    let horizontalDirections = [];\n\n    if (!isnan(minDist)) {\n      return Hammer.DIRECTION_ALL;\n    }\n\n    if (!isnan(activeOffsetXStart)) {\n      horizontalDirections.push(Hammer.DIRECTION_LEFT);\n    }\n    if (!isnan(activeOffsetXEnd)) {\n      horizontalDirections.push(Hammer.DIRECTION_RIGHT);\n    }\n    if (horizontalDirections.length === 2) {\n      horizontalDirections = [Hammer.DIRECTION_HORIZONTAL];\n    }\n\n    directions = directions.concat(horizontalDirections);\n    let verticalDirections = [];\n\n    if (!isnan(activeOffsetYStart)) {\n      verticalDirections.push(Hammer.DIRECTION_UP);\n    }\n    if (!isnan(activeOffsetYEnd)) {\n      verticalDirections.push(Hammer.DIRECTION_DOWN);\n    }\n\n    if (verticalDirections.length === 2) {\n      verticalDirections = [Hammer.DIRECTION_VERTICAL];\n    }\n\n    directions = directions.concat(verticalDirections);\n\n    if (!directions.length) {\n      return Hammer.DIRECTION_NONE;\n    }\n    if (\n      directions[0] === Hammer.DIRECTION_HORIZONTAL &&\n      directions[1] === Hammer.DIRECTION_VERTICAL\n    ) {\n      return Hammer.DIRECTION_ALL;\n    }\n    if (horizontalDirections.length && verticalDirections.length) {\n      return Hammer.DIRECTION_ALL;\n    }\n\n    return directions[0];\n  }\n\n  getConfig() {\n    if (!this.hasCustomActivationCriteria) {\n      // Default config\n      // If no params have been defined then this config should emulate the native gesture as closely as possible.\n      return {\n        minDistSq: 10,\n      };\n    }\n    return this.config;\n  }\n\n  shouldFailUnderCustomCriteria(\n    { deltaX, deltaY }: HammerInputExt,\n    criteria: any\n  ) {\n    return (\n      (!isnan(criteria.failOffsetXStart) &&\n        deltaX < criteria.failOffsetXStart) ||\n      (!isnan(criteria.failOffsetXEnd) && deltaX > criteria.failOffsetXEnd) ||\n      (!isnan(criteria.failOffsetYStart) &&\n        deltaY < criteria.failOffsetYStart) ||\n      (!isnan(criteria.failOffsetYEnd) && deltaY > criteria.failOffsetYEnd)\n    );\n  }\n\n  shouldActivateUnderCustomCriteria(\n    { deltaX, deltaY, velocity }: any,\n    criteria: any\n  ) {\n    return (\n      (!isnan(criteria.activeOffsetXStart) &&\n        deltaX < criteria.activeOffsetXStart) ||\n      (!isnan(criteria.activeOffsetXEnd) &&\n        deltaX > criteria.activeOffsetXEnd) ||\n      (!isnan(criteria.activeOffsetYStart) &&\n        deltaY < criteria.activeOffsetYStart) ||\n      (!isnan(criteria.activeOffsetYEnd) &&\n        deltaY > criteria.activeOffsetYEnd) ||\n      TEST_MIN_IF_NOT_NAN(\n        VEC_LEN_SQ({ x: deltaX, y: deltaY }),\n        criteria.minDistSq\n      ) ||\n      TEST_MIN_IF_NOT_NAN(velocity.x, criteria.minVelocityX) ||\n      TEST_MIN_IF_NOT_NAN(velocity.y, criteria.minVelocityY) ||\n      TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ(velocity), criteria.minVelocitySq)\n    );\n  }\n\n  shouldMultiFingerPanFail({\n    pointerLength,\n    scale,\n    deltaRotation,\n  }: {\n    deltaRotation: number;\n    pointerLength: number;\n    scale: number;\n  }) {\n    if (pointerLength <= 1) {\n      return false;\n    }\n\n    // Test if the pan had too much pinching or rotating.\n    const deltaScale = Math.abs(scale - 1);\n    const absDeltaRotation = Math.abs(deltaRotation);\n    if (deltaScale > MULTI_FINGER_PAN_MAX_PINCH_THRESHOLD) {\n      // > If the threshold doesn't seem right.\n      // You can log the value which it failed at here:\n      return true;\n    }\n    if (absDeltaRotation > MULTI_FINGER_PAN_MAX_ROTATION_THRESHOLD) {\n      // > If the threshold doesn't seem right.\n      // You can log the value which it failed at here:\n      return true;\n    }\n\n    return false;\n  }\n\n  updateHasCustomActivationCriteria(\n    criteria: Config & { minVelocityX?: number; minVelocityY?: number }\n  ) {\n    return (\n      isValidNumber(criteria.minDistSq) ||\n      isValidNumber(criteria.minVelocityX) ||\n      isValidNumber(criteria.minVelocityY) ||\n      isValidNumber(criteria.minVelocitySq) ||\n      isValidNumber(criteria.activeOffsetXStart) ||\n      isValidNumber(criteria.activeOffsetXEnd) ||\n      isValidNumber(criteria.activeOffsetYStart) ||\n      isValidNumber(criteria.activeOffsetYEnd)\n    );\n  }\n\n  isGestureEnabledForEvent(\n    props: any,\n    _recognizer: any,\n    inputData: HammerInputExt & { deltaRotation: number }\n  ) {\n    if (this.shouldFailUnderCustomCriteria(inputData, props)) {\n      return { failed: true };\n    }\n\n    const velocity = { x: inputData.velocityX, y: inputData.velocityY };\n    if (\n      this.hasCustomActivationCriteria &&\n      this.shouldActivateUnderCustomCriteria(\n        { deltaX: inputData.deltaX, deltaY: inputData.deltaY, velocity },\n        props\n      )\n    ) {\n      if (\n        this.shouldMultiFingerPanFail({\n          pointerLength: inputData.maxPointers,\n          scale: inputData.scale,\n          deltaRotation: inputData.deltaRotation,\n        })\n      ) {\n        return {\n          failed: true,\n        };\n      }\n      return { success: true };\n    }\n    return { success: false };\n  }\n}\n\nexport default PanGestureHandler;\n"]},"metadata":{},"sourceType":"module","externalDependencies":[]}