{"ast":null,"code":"import _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\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\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; } }\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; }\nimport { ContinousBaseGesture } from \"./gesture\";\nfunction changeEventCalculator(current, previous) {\n  'worklet';\n\n  var changePayload;\n  if (previous === undefined) {\n    changePayload = {\n      scaleChange: current.scale\n    };\n  } else {\n    changePayload = {\n      scaleChange: current.scale / previous.scale\n    };\n  }\n  return _objectSpread(_objectSpread({}, current), changePayload);\n}\nexport var PinchGesture = function (_ContinousBaseGesture) {\n  _inherits(PinchGesture, _ContinousBaseGesture);\n  var _super = _createSuper(PinchGesture);\n  function PinchGesture() {\n    var _this;\n    _classCallCheck(this, PinchGesture);\n    _this = _super.call(this);\n    _this.handlerName = 'PinchGestureHandler';\n    return _this;\n  }\n  _createClass(PinchGesture, [{\n    key: \"onChange\",\n    value: function onChange(callback) {\n      this.handlers.changeEventCalculator = changeEventCalculator;\n      return _get(_getPrototypeOf(PinchGesture.prototype), \"onChange\", this).call(this, callback);\n    }\n  }]);\n  return PinchGesture;\n}(ContinousBaseGesture);","map":{"version":3,"sources":["pinchGesture.ts"],"names":["ContinousBaseGesture","changeEventCalculator","current","previous","changePayload","undefined","scaleChange","scale","PinchGesture","constructor","handlerName","onChange","callback","handlers"],"mappings":";;;;;;;;;;;AAAA,SAASA,oBAAT;AAQA,SAASC,qBAAT,CACEC,OADF,EAEEC,QAFF,EAGE;EACA,SAAA;;EACA,IAAIC,aAAJ;EACA,IAAID,QAAQ,KAAKE,SAAjB,EAA4B;IAC1BD,aAAa,GAAG;MACdE,WAAW,EAAEJ,OAAO,CAACK;IADP,CAAhBH;EAGD,CAJD,MAIO;IACLA,aAAa,GAAG;MACdE,WAAW,EAAEJ,OAAO,CAACK,KAARL,GAAgBC,QAAQ,CAACI;IADxB,CAAhBH;EAGD;EAED,uCAAYF,OAAL,GAAiBE,aAAAA;AACzB;AAED,WAAaI,YAAN;EAAA;EAAA;EAILC,wBAAc;IAAA;IAAA;IACZ;IAEA,MAAKC,WAAL,GAAmB,qBAAnB;IAAA;EACD;EAAA;IAAA;IAAA,OAEDC,kBACEC,QADM,EAMN;MAEA,IAAA,CAAKC,QAAL,CAAcZ,qBAAd,GAAsCA,qBAAtC;MACA,kFAAsBW,QAAtB;IACD;EAAA;EAAA;AAAA,EApB+BZ,oBAA3B","sourcesContent":["import { ContinousBaseGesture } from './gesture';\nimport { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';\nimport { GestureUpdateEvent } from '../gestureHandlerCommon';\n\nexport type PinchGestureChangeEventPayload = {\n  scaleChange: number;\n};\n\nfunction changeEventCalculator(\n  current: GestureUpdateEvent<PinchGestureHandlerEventPayload>,\n  previous?: GestureUpdateEvent<PinchGestureHandlerEventPayload>\n) {\n  'worklet';\n  let changePayload: PinchGestureChangeEventPayload;\n  if (previous === undefined) {\n    changePayload = {\n      scaleChange: current.scale,\n    };\n  } else {\n    changePayload = {\n      scaleChange: current.scale / previous.scale,\n    };\n  }\n\n  return { ...current, ...changePayload };\n}\n\nexport class PinchGesture extends ContinousBaseGesture<\n  PinchGestureHandlerEventPayload,\n  PinchGestureChangeEventPayload\n> {\n  constructor() {\n    super();\n\n    this.handlerName = 'PinchGestureHandler';\n  }\n\n  onChange(\n    callback: (\n      event: GestureUpdateEvent<\n        PinchGestureHandlerEventPayload & PinchGestureChangeEventPayload\n      >\n    ) => void\n  ) {\n    // @ts-ignore TS being overprotective, PinchGestureHandlerEventPayload is Record\n    this.handlers.changeEventCalculator = changeEventCalculator;\n    return super.onChange(callback);\n  }\n}\n\nexport type PinchGestureType = InstanceType<typeof PinchGesture>;\n"]},"metadata":{},"sourceType":"module"}