{"version":3,"sources":["webpack:///../src/types.ts","webpack:///../src/utils.ts","webpack:///../src/defaults.ts","webpack:///../src/recognizers/Recognizer.ts","webpack:///../src/recognizers/CoordinatesRecognizer.ts","webpack:///../src/recognizers/DragRecognizer.ts","webpack:///../src/recognizers/ScrollRecognizer.ts","webpack:///../src/recognizers/WheelRecognizer.ts","webpack:///../src/recognizers/MoveRecognizer.ts","webpack:///../src/recognizers/HoverRecognizer.ts","webpack:///../src/recognizers/DistanceAngleRecognizer.ts","webpack:///../src/recognizers/PinchRecognizer.ts","webpack:///../src/recognizers/PinchWheelRecognizer.ts","webpack:///../src/recognizers/PinchWebKitGestureRecognizer.ts","webpack:///../src/controllers/GestureController.ts","webpack:///../src/hooks.ts"],"names":["GestureFlag","noop","chainFns","fns","Array","_len","_key","arguments","args","_len2","_key2","forEach","fn","addV","v1","v2","map","v","i","subV","setListeners","add","el","listeners","options","action","_ref","type","addListeners","removeListeners","getModifierKeys","event","shiftKey","altKey","metaKey","ctrlKey","getWheelEventData","xy","deltaX","deltaY","getPointerEventData","touches","buttons","changedTouches","touchEvents","clientX","clientY","down","length","getTwoTouchesEventData","dx","dy","da","Math","PI","origin","calculateVelocities","delta","delta_t","calculateDirection","len","calculateAllKinematics","movement","velocities","velocity","calculateVelocity","distance","calculateDistance","direction","mappedKeys","drag","stateKey","handlerKey","pinch","move","scroll","wheel","hover","defaultConfig","domTarget","undefined","passive","capture","window","dragDelay","passiveEvents","pointerEvents","enabled","initialCommon","currentTarget","pointerId","values","offset","initial","previous","first","last","active","time","cancel","canceled","memo","initialCoordinates","vxvy","initialDistanceAngle","vdva","turns","initialState","shared","hovering","scrolling","wheeling","dragging","moving","pinching","genericEndState","Recognizer","gestureKey","controller","continuousGesture","setTimeout","callback","ms","_this","timeouts","_window","apply","concat","clearTimeout","addWindowListeners","removeWindowListeners","updateState","sharedState","gestureState","fireGestureHandler","gestureFlag","onStart","payload","getPayloadFromEvent","gesturePayload","sharedPayload","startState","_extends","timeStamp","state","prevValues","Object","sharedStartState","OnStart","onChange","kinematics","getKinematics","OnChange","onEnd","sharedEndState","OnEnd","onCancel","requestAnimationFrame","timeoutHandler","this","config","CoordinatesRecognizer","DEFAULT_DRAG_DELAY","DragRecognizer","delayedEvent","onDragStart","dragListeners","onDragChange","onDragEnd","persist","startDrag","getEventBindings","ScrollRecognizer","scrollX","scrollY","scrollLeft","scrollTop","getScrollEventData","WheelRecognizer","onWheel","actions","has","prevXY","MoveRecognizer","HoverRecognizer","onPointerEnter","onPointerLeave","DistanceAngleRecognizer","_Recognizer","call","d","a","delta_d","delta_a","newTurns","PinchRecognizer","onPinchStart","onPinchChange","PinchWheelRecognizer","preventDefault","prev_d","prev_a","PinchWebKitGestureRecognizer","onGestureEnd","updateTouchData","rotation","GestureController","handlers","bindings","domListeners","windowListeners","clean","cleanOnBind","newGestureState","_extends2","handlerStart","handler","newMemo","handlerEnd","addRecognizer","recognizer","addEventBindings","eventNames","eventNamesArray","eventName","addDomTargetListeners","_ref2","push","toLowerCase","getBindings","output","captureString","_ref3","fnsArray","bind","genuineHandlers","onDrag","onScroll","onScrollStart","onScrollEnd","onWheelStart","onWheelEnd","onMove","onMoveStart","onMoveEnd","onHover","GestureEvent","e","gestureEventSupported","onPinch","onPinchEnd","_ref4","Set","keys","k","useGesture","gestureController","React","useRef","current","getDerivedConfig","derivedConfig","realDomTarget"],"mappings":"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","file":"vendor~slider.bundle.08fc1a34c54f88085e5f.js","sourcesContent":["import React from 'react'\n\nexport type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>\nexport type AtLeastOneOf<T, U = { [K in keyof T]: Pick<T, K> }> = Partial<T> & U[keyof U]\n\nexport type Vector2 = [number, number]\nexport type Fn = (...args: any[]) => any\n\nexport type EventOptions = { capture?: boolean; passive?: boolean }\n\nexport interface GestureConfig {\n  domTarget?: EventTarget | React.RefObject<EventTarget> | null\n  event: EventOptions\n  window?: EventTarget\n  dragDelay: boolean | number\n  passiveEvents: boolean\n  pointerEvents: boolean\n  enabled: boolean\n  drag: boolean\n  pinch: boolean\n  scroll: boolean\n  wheel: boolean\n  hover: boolean\n  move: boolean\n}\n\nexport enum GestureFlag {\n  OnStart = 'start',\n  OnChange = 'change',\n  OnEnd = 'end',\n}\n\nexport type WebKitGestureEvent = React.PointerEvent & { scale: number; rotation: number }\nexport type UseGestureEvent<\n  T extends React.SyntheticEvent = React.MouseEvent | React.TouchEvent | React.WheelEvent | React.PointerEvent | WebKitGestureEvent\n> = T & {\n  gesture?: GestureKey\n}\n\nexport interface ReactEventHandlers {\n  // Mouse Events\n  onMouseDown?: React.MouseEventHandler\n  onMouseDownCapture?: React.MouseEventHandler\n  onMouseEnter?: React.MouseEventHandler\n  onMouseLeave?: React.MouseEventHandler\n  onMouseMove?: React.MouseEventHandler\n  onMouseMoveCapture?: React.MouseEventHandler\n  onMouseOut?: React.MouseEventHandler\n  onMouseOutCapture?: React.MouseEventHandler\n  onMouseOver?: React.MouseEventHandler\n  onMouseOverCapture?: React.MouseEventHandler\n  onMouseUp?: React.MouseEventHandler\n  onMouseUpCapture?: React.MouseEventHandler\n  // Touch Events\n  onTouchCancel?: React.TouchEventHandler\n  onTouchCancelCapture?: React.TouchEventHandler\n  onTouchEnd?: React.TouchEventHandler\n  onTouchEndCapture?: React.TouchEventHandler\n  onTouchMove?: React.TouchEventHandler\n  onTouchMoveCapture?: React.TouchEventHandler\n  onTouchStart?: React.TouchEventHandler\n  onTouchStartCapture?: React.TouchEventHandler\n\n  // Pointer Events\n  onPointerDown?: React.PointerEventHandler\n  onPointerDownCapture?: React.PointerEventHandler\n  onPointerMove?: React.PointerEventHandler\n  onPointerMoveCapture?: React.PointerEventHandler\n  onPointerUp?: React.PointerEventHandler\n  onPointerUpCapture?: React.PointerEventHandler\n  onPointerCancel?: React.PointerEventHandler\n  onPointerCancelCapture?: React.PointerEventHandler\n  onPointerEnter?: React.PointerEventHandler\n  onPointerEnterCapture?: React.PointerEventHandler\n  onPointerLeave?: React.PointerEventHandler\n  onPointerLeaveCapture?: React.PointerEventHandler\n  onPointerOver?: React.PointerEventHandler\n  onPointerOverCapture?: React.PointerEventHandler\n  onPointerOut?: React.PointerEventHandler\n  onPointerOutCapture?: React.PointerEventHandler\n  onGotPointerCapture?: React.PointerEventHandler\n  onGotPointerCaptureCapture?: React.PointerEventHandler\n  onLostPointerCapture?: React.PointerEventHandler\n  onLostPointerCaptureCapture?: React.PointerEventHandler\n\n  // UI Events\n  onScroll?: React.UIEventHandler\n  onScrollCapture?: React.UIEventHandler\n\n  // Wheel Events\n  onWheel?: React.WheelEventHandler\n  onWheelCapture?: React.WheelEventHandler\n\n  // Cheat mode for Gesture Events\n  onGestureStart?: Fn\n  onGestureChange?: Fn\n  onGestureEnd?: Fn\n}\n\nexport type ReactEventHandlerKey = keyof ReactEventHandlers\n\nexport type GestureKey = 'drag' | 'pinch' | 'move' | 'scroll' | 'wheel' | 'hover'\nexport type StateKey = Exclude<GestureKey, 'hover'>\n\nexport interface SharedGestureState {\n  hovering: boolean\n  scrolling: boolean\n  wheeling: boolean\n  dragging: boolean\n  moving: boolean\n  pinching: boolean\n  touches: number\n  down: boolean\n  buttons: number\n  shiftKey: boolean\n  altKey: boolean\n  metaKey: boolean\n  ctrlKey: boolean\n}\n\nexport interface CommonGestureState {\n  event?: UseGestureEvent\n  currentTarget?: EventTarget | null\n  pointerId?: number | null\n  values: Vector2\n  delta: Vector2\n  movement: Vector2\n  offset: Vector2\n  initial: Vector2\n  previous: Vector2\n  direction: Vector2\n  first: boolean\n  last: boolean\n  active: boolean\n  time?: number\n  cancel?(): void\n  canceled: boolean\n  memo?: any\n  args?: any\n}\n\nexport interface Coordinates {\n  xy: Vector2\n  velocity: number\n  vxvy: Vector2\n  distance: number\n}\n\nexport interface DistanceAngle {\n  da: Vector2\n  vdva: Vector2\n  origin?: Vector2\n  turns: number\n}\n\nexport type GestureState<T extends Coordinates | DistanceAngle = Coordinates | DistanceAngle> = T & CommonGestureState\nexport type FullGestureState<T extends Coordinates | DistanceAngle> = SharedGestureState & GestureState<T>\n\nexport type StateObject = { shared: SharedGestureState } & { [K in StateKey]: GestureState<Coordinates | DistanceAngle> }\n\nexport type Handler<T extends Coordinates | DistanceAngle> = (state: FullGestureState<T>) => any | void\nexport type HandlerKey = 'onDrag' | 'onPinch' | 'onMove' | 'onHover' | 'onScroll' | 'onWheel'\n\nexport type GestureHandlers = {\n  onDrag: Handler<Coordinates>\n  onDragStart: Handler<Coordinates>\n  onDragEnd: Handler<Coordinates>\n  onHover: Handler<Coordinates>\n  onMove: Handler<Coordinates>\n  onMoveStart: Handler<Coordinates>\n  onMoveEnd: Handler<Coordinates>\n  onScroll: Handler<Coordinates>\n  onScrollStart: Handler<Coordinates>\n  onScrollEnd: Handler<Coordinates>\n  onWheel: Handler<Coordinates>\n  onWheelStart: Handler<Coordinates>\n  onWheelEnd: Handler<Coordinates>\n  onPinch: Handler<DistanceAngle>\n  onPinchStart: Handler<DistanceAngle>\n  onPinchEnd: Handler<DistanceAngle>\n}\n\n/* Handlers should also accept DomAttributes to prevent overrides */\nexport type GestureHandlersPartial = AtLeastOneOf<GestureHandlers> &\n  Partial<Omit<React.DOMAttributes<Element>, 'onDrag' | 'onScroll' | 'onWheel'>>\n","import React from 'react'\nimport { Fn, Vector2, EventOptions, Coordinates, FullGestureState, DistanceAngle, UseGestureEvent } from './types'\n\n// blank function\nexport const noop = () => {}\n\n// returns a function that chains all functions given as parameters\nexport const chainFns = (...fns: Fn[]): Fn => (...args: any[]) => fns.forEach(fn => fn(...args))\n\n// vector add\nexport const addV = <T extends number[]>(v1: T, v2: T): T => <T>v1.map((v, i) => v + v2[i])\n\n// vector substract\nexport const subV = <T extends number[]>(v1: T, v2: T): T => <T>v1.map((v, i) => v - v2[i])\n\nconst setListeners = (add: boolean) => (el: EventTarget, listeners: [string, Fn][], options: EventOptions): void => {\n  const action = add ? 'addEventListener' : 'removeEventListener'\n  listeners.forEach(([type, fn]) => el[action](type, fn, options))\n}\n\nexport const addListeners = setListeners(true)\nexport const removeListeners = setListeners(false)\n\ninterface ModifierKeys {\n  shiftKey: boolean\n  altKey: boolean\n  metaKey: boolean\n  ctrlKey: boolean\n}\n\n/**\n * Gets modifier keys from event\n * @param event\n * @returns modifier keys\n */\nexport function getModifierKeys(event: UseGestureEvent): ModifierKeys {\n  const { shiftKey, altKey, metaKey, ctrlKey } = event\n  return { shiftKey, altKey, metaKey, ctrlKey }\n}\ntype ScrollEventData = Pick<FullGestureState<Coordinates>, 'xy'> & ModifierKeys\n\n/**\n * Gets scroll event data\n * @param event\n * @returns scroll event data\n */\nexport function getScrollEventData(event: UseGestureEvent): ScrollEventData {\n  // If the currentTarget is the window then we return the scrollX/Y position.\n  // If not (ie the currentTarget is a DOM element), then we return scrollLeft/Top\n  const { scrollX, scrollY, scrollLeft, scrollTop } = <Element & Window>event.currentTarget\n  return { xy: [scrollX || scrollLeft || 0, scrollY || scrollTop || 0], ...getModifierKeys(event) }\n}\n\ntype WheelEventData = Pick<FullGestureState<Coordinates>, 'xy'> & ModifierKeys\n\n/**\n * Gets wheel event data\n * @param event\n * @returns wheel event data\n */\nexport function getWheelEventData(event: UseGestureEvent<React.WheelEvent>): WheelEventData {\n  const { deltaX, deltaY } = event\n  //TODO implement polyfill ?\n  // https://developer.mozilla.org/en-US/docs/Web/Events/wheel#Polyfill\n  return { xy: [deltaX, deltaY], ...getModifierKeys(event) }\n}\n\ntype PointerEventData = Pick<FullGestureState<Coordinates>, 'xy' | 'touches' | 'down' | 'buttons'> & ModifierKeys\n/**\n * Gets pointer event data\n * @param event\n * @returns pointer event data\n */\nexport function getPointerEventData(event: React.MouseEvent | React.TouchEvent | React.PointerEvent): PointerEventData {\n  const { touches, buttons, changedTouches } = event as any\n  const touchEvents = touches && touches.length > 0 ? touches : changedTouches && changedTouches.length > 0 ? changedTouches : null\n  const { clientX, clientY } = touchEvents ? touchEvents[0] : event\n  const down = (touchEvents && touchEvents.length > 0) || buttons > 0\n  return {\n    xy: [clientX, clientY],\n    touches: (touchEvents && touchEvents.length) || 0,\n    down,\n    buttons,\n    ...getModifierKeys(event),\n  }\n}\n\ntype TwoTouchesEventData = Pick<FullGestureState<DistanceAngle>, 'da' | 'touches' | 'down' | 'origin'> & ModifierKeys\n\n/**\n * Gets two touches event data\n * @param event\n * @returns two touches event data\n */\nexport function getTwoTouchesEventData(event: React.TouchEvent): TwoTouchesEventData {\n  const { touches } = event\n  const dx = touches[1].clientX - touches[0].clientX\n  const dy = touches[1].clientY - touches[0].clientY\n\n  const da: Vector2 = [Math.hypot(dx, dy), -(Math.atan2(dx, dy) * 180) / Math.PI]\n  const origin: Vector2 = [(touches[1].clientX + touches[0].clientX) / 2, (touches[1].clientY + touches[0].clientY) / 2]\n\n  return { da, origin, touches: 2, down: touches.length > 0, ...getModifierKeys(event) }\n}\n\n/**\n * Calculates velocity\n * @param delta the difference between current and previous vectors\n * @param delta_t the time offset\n * @param len the length of the delta vector\n * @returns velocity\n */\nexport function calculateVelocity(delta: number[], delta_t: number, len: number): number {\n  len = len || Math.hypot(...delta)\n  return delta_t ? len / delta_t : 0\n}\n\n/**\n * Calculates velocities vector\n * @template T the expected vector type\n * @param delta the difference between current and previous vectors\n * @param delta_t the time offset\n * @returns velocities vector\n */\nexport function calculateVelocities<T extends number[]>(delta: T, delta_t: number): T {\n  return delta_t ? <T>delta.map(v => v / delta_t) : <T>Array(delta.length).fill(0)\n}\n\n/**\n * Calculates distance\n * @param movement the difference between current and initial vectors\n * @returns distance\n */\nexport function calculateDistance(movement: number[]): number {\n  return Math.hypot(...movement)\n}\n\n/**\n * Calculates direction\n * @template T the expected vector type\n * @param delta\n * @param len\n * @returns direction\n */\nexport function calculateDirection<T extends number[]>(delta: T, len?: number): T {\n  len = len || Math.hypot(...delta) || 1\n  return <T>delta.map(v => v / len!)\n}\n\ninterface Kinematics<T extends number[]> {\n  velocities: T\n  velocity: number\n  distance: number\n  direction: T\n}\n\n/**\n * Calculates all kinematics\n * @template T the expected vector type\n * @param movement the difference between current and initial vectors\n * @param delta the difference between current and previous vectors\n * @param delta_t the time difference between current and previous timestamps\n * @returns all kinematics\n */\nexport function calculateAllKinematics<T extends number[]>(movement: T, delta: T, delta_t: number): Kinematics<T> {\n  const len = Math.hypot(...delta)\n\n  return {\n    velocities: calculateVelocities(delta, delta_t),\n    velocity: calculateVelocity(delta, delta_t, len),\n    distance: calculateDistance(movement),\n    direction: calculateDirection(delta, len),\n  }\n}\n\n/**\n * Whether the browser supports GestureEvent (ie Safari)\n * @returns true if the browser supports gesture event\n */\nexport function gestureEventSupported(): boolean {\n  try {\n    // TODO [TS] possibly find GestureEvent definitions?\n    // @ts-ignore: Unreachable code error\n    return 'constructor' in GestureEvent\n  } catch (e) {\n    return false\n  }\n}\n","import { noop } from './utils'\nimport { GestureConfig, HandlerKey, CommonGestureState, Coordinates, DistanceAngle, StateObject, StateKey, GestureKey } from './types'\n\ntype MappedKeys = { [K in GestureKey]: { stateKey: StateKey; handlerKey: HandlerKey } }\n\n/**\n * Some gestures might use the state key from another gesture (i.e. hover)\n * so mappedKeys is a commodity object to get the state key and handler key\n * for every gesture\n */\nexport const mappedKeys: MappedKeys = {\n  drag: { stateKey: 'drag', handlerKey: 'onDrag' },\n  pinch: { stateKey: 'pinch', handlerKey: 'onPinch' },\n  move: { stateKey: 'move', handlerKey: 'onMove' },\n  scroll: { stateKey: 'scroll', handlerKey: 'onScroll' },\n  wheel: { stateKey: 'wheel', handlerKey: 'onWheel' },\n  hover: { stateKey: 'move', handlerKey: 'onHover' },\n}\n\n// default config (will extend user config)\nexport const defaultConfig: GestureConfig = {\n  domTarget: undefined,\n  event: { passive: true, capture: false },\n  window: typeof window !== 'undefined' ? window : undefined,\n  dragDelay: false,\n  passiveEvents: true,\n  pointerEvents: false,\n  enabled: true,\n  drag: true,\n  pinch: true,\n  scroll: true,\n  wheel: true,\n  hover: true,\n  move: true,\n}\n\n// common initial state for all gestures\nexport const initialCommon: CommonGestureState = {\n  event: undefined,\n  currentTarget: undefined,\n  pointerId: undefined,\n  values: [0, 0],\n  delta: [0, 0],\n  movement: [0, 0],\n  offset: [0, 0],\n  direction: [0, 0],\n  initial: [0, 0],\n  previous: [0, 0],\n  first: false,\n  last: false,\n  active: false,\n  time: undefined,\n  cancel: noop,\n  canceled: false,\n  memo: undefined,\n  args: undefined,\n}\n\n// initial state for coordinates-based gestures\nconst initialCoordinates: Coordinates = { xy: [0, 0], vxvy: [0, 0], velocity: 0, distance: 0 } // xy coordinates\n\n// initial state for distance and angle-based gestures (pinch)\nconst initialDistanceAngle: DistanceAngle = { da: [0, 0], vdva: [0, 0], origin: undefined, turns: 0 } // distance and angle\n\n// initial state object (used by the gesture controller)\nexport const initialState: StateObject = {\n  shared: {\n    hovering: false,\n    scrolling: false,\n    wheeling: false,\n    dragging: false,\n    moving: false,\n    pinching: false,\n    touches: 0,\n    buttons: 0,\n    down: false,\n    shiftKey: false,\n    altKey: false,\n    metaKey: false,\n    ctrlKey: false,\n  },\n  move: { ...initialCommon, ...initialCoordinates },\n  drag: { ...initialCommon, ...initialCoordinates },\n  scroll: { ...initialCommon, ...initialCoordinates },\n  wheel: { ...initialCommon, ...initialCoordinates },\n  pinch: { ...initialCommon, ...initialDistanceAngle },\n}\n\n// generic end state for all gestures\nexport const genericEndState: Partial<CommonGestureState> = { first: false, last: true, active: false }\n","import { mappedKeys, genericEndState, initialState } from '../defaults'\nimport GestureController from '../controllers/GestureController'\nimport {\n  Coordinates,\n  DistanceAngle,\n  StateKey,\n  GestureState,\n  GestureKey,\n  SharedGestureState,\n  Fn,\n  ReactEventHandlerKey,\n  GestureFlag,\n  UseGestureEvent,\n  Vector2,\n} from '../types'\nimport { noop, subV, calculateAllKinematics } from '../utils'\n\ntype PayloadFromEvent = {\n  values: Vector2\n  gesturePayload?: Partial<GestureState>\n  sharedPayload?: Partial<SharedGestureState>\n}\n\n/**\n * Recognizer abstract class\n * @template GestureType whether the Recognizer should deal with coordinates or distance / angle\n */\nexport default abstract class Recognizer<GestureType extends Coordinates | DistanceAngle = Coordinates | DistanceAngle> {\n  protected stateKey: StateKey\n  protected sharedStartState?: Partial<SharedGestureState>\n  protected sharedEndState?: Partial<SharedGestureState>\n\n  /**\n   * Continuous gestures are scroll or wheel, where the next gesture continues the previous one.\n   * In other words, these gestures also start with a delta.\n   */\n  protected continuousGesture = false\n\n  /**\n   * Creates an instance of a gesture recognizer.\n   * @param gestureKey drag, move, hover, pinch, etc.\n   * @param controller the controller attached to the gesture\n   * @param [args] the args that should be passed to the gesture handler\n   */\n  constructor(\n    protected readonly gestureKey: GestureKey,\n    protected readonly controller: GestureController,\n    protected readonly args: any[] = []\n  ) {\n    // mapping this.stateKey to the state key the gesture handles\n    // (ie hover actually deals with the move gesture state)\n    this.stateKey = mappedKeys[gestureKey].stateKey\n  }\n\n  // is the gesture enabled\n  protected get enabled(): boolean {\n    return this.controller.config.enabled && this.controller.config[this.gestureKey]\n  }\n  // get the controller state for a given gesture\n  protected get state() {\n    return this.controller.state[this.stateKey] as GestureState<GestureType>\n  }\n\n  // convenience method to set a timeout for a given gesture\n  protected setTimeout = (callback: (...args: any[]) => void, ms: number = 140, ...args: any[]): void => {\n    this.controller.timeouts[this.stateKey] = window.setTimeout(callback, ms, ...args)\n  }\n\n  // convenience method to clear a timeout for a given gesture\n  protected clearTimeout = () => {\n    clearTimeout(this.controller.timeouts[this.stateKey])\n  }\n\n  // convenience method to add window listeners for a given gesture\n  protected addWindowListeners = (listeners: [string, Fn][]) => {\n    this.controller.addWindowListeners(this.stateKey, listeners)\n  }\n\n  // convenience method to remove window listeners for a given gesture\n  protected removeWindowListeners = () => {\n    this.controller.removeWindowListeners(this.stateKey)\n  }\n\n  protected abstract getPayloadFromEvent(event: UseGestureEvent): PayloadFromEvent\n\n  /**\n   * Utility function to get kinematics of the gesture\n   * @values values we want to calculate the kinematics from\n   * @event\n   * @returns set of values including movement, velocity, velocities, distance and direction\n   */\n  protected abstract getKinematics(values: [number, number | undefined], event: UseGestureEvent): Partial<GestureState<GestureType>>\n\n  // should return the bindings for a given gesture\n  public abstract getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][]\n\n  /**\n   * convenience method to update the controller state for a given gesture\n   * @param sharedState shared partial state object\n   * @param gestureState partial state object for the gesture handled by the recognizer\n   * @param [gestureFlag] if set, will also fire the gesture handler set by the user\n   */\n  protected updateState = (sharedState: Partial<SharedGestureState> | null, gestureState: Partial<GestureState<GestureType>>): void => {\n    this.controller.updateState(sharedState, gestureState, this.stateKey)\n  }\n\n  protected fireGestureHandler = (gestureFlag: GestureFlag): void => {\n    this.controller.fireGestureHandler(this.gestureKey, gestureFlag)\n  }\n\n  // generic onStart function\n  protected onStart = (event: UseGestureEvent, payload?: Partial<GestureState<GestureType>>): void => {\n    const { values, gesturePayload, sharedPayload } = this.getPayloadFromEvent(event)\n\n    // TODO probably needs some rework, initialState and resetState should be different\n\n    const startState: GestureState<GestureType> = {\n      ...(initialState[this.stateKey] as GestureState<GestureType>),\n      values,\n      event,\n      first: true,\n      active: true,\n      time: event.timeStamp,\n      args: this.args,\n    }\n\n    const { values: prevValues, offset } = this.state\n\n    if (this.continuousGesture) {\n      startState.initial = startState.previous = prevValues\n      startState.delta = startState.movement = subV(values, prevValues)\n      startState.offset = values\n      Object.assign(startState, calculateAllKinematics(startState.movement, startState.delta, 0))\n    } else {\n      startState.initial = startState.previous = values\n      startState.offset = offset\n    }\n\n    this.updateState({ ...this.sharedStartState, ...sharedPayload }, { ...startState, ...gesturePayload, ...payload })\n    this.fireGestureHandler(GestureFlag.OnStart)\n  }\n\n  // generic onChange function\n  protected onChange = (event: UseGestureEvent, payload?: Partial<GestureState<GestureType>>): void => {\n    const { values, gesturePayload, sharedPayload } = this.getPayloadFromEvent(event)\n    const kinematics = this.getKinematics(values, event)\n    this.updateState({ ...sharedPayload }, { first: false, ...kinematics, ...gesturePayload, ...payload })\n    this.fireGestureHandler(GestureFlag.OnChange)\n  }\n\n  // generic onEnd function\n  protected onEnd = (event: UseGestureEvent, payload?: Partial<GestureState<GestureType>>): void => {\n    if (!this.state.active) return\n    this.removeWindowListeners()\n    this.updateState(this.sharedEndState!, { event, ...genericEndState, ...payload } as Partial<GestureState<GestureType>>)\n    this.fireGestureHandler(GestureFlag.OnEnd)\n  }\n\n  // generic cancel function\n  protected onCancel = (event: UseGestureEvent): void => {\n    this.updateState(null, { canceled: true, cancel: noop } as Partial<GestureState<GestureType>>)\n    requestAnimationFrame(() => this.onEnd(event))\n  }\n\n  // generic gesture handler for timeout-based gestures\n  protected timeoutHandler = (event: UseGestureEvent) => {\n    if (!this.enabled) return\n\n    this.clearTimeout()\n    this.setTimeout(this.onEnd)\n\n    if (!this.state.active) this.onStart(event)\n    else this.onChange(event)\n  }\n}\n","import Recognizer from './Recognizer'\nimport { addV, subV, calculateAllKinematics } from '../utils'\nimport { Coordinates, GestureState, Vector2, UseGestureEvent } from '../types'\n\n/**\n * Abstract class for coordinates-based gesture recongizers\n */\nexport default abstract class CoordinatesRecognizer extends Recognizer<Coordinates> {\n  getKinematics(values: Vector2, event: UseGestureEvent): Partial<GestureState<Coordinates>> {\n    // we get the gesture specific state\n    const { values: xy, initial, offset, time } = this.state\n\n    // offset is the difference between the current and initial value vectors\n    const movement = subV(values, initial)\n    // delta is the difference between the current and previous value vectors\n    const delta = subV(values, xy)\n\n    const delta_t = event.timeStamp - time!\n    const { velocity, velocities, distance, direction } = calculateAllKinematics(movement, delta, delta_t)\n\n    return {\n      event,\n      values,\n      movement,\n      offset: addV(offset, delta),\n      delta,\n      velocity,\n      vxvy: velocities,\n      distance,\n      direction,\n      previous: xy,\n      time: event.timeStamp,\n    }\n  }\n}\n","import { PointerEvent } from 'react'\nimport CoordinatesRecognizer from './CoordinatesRecognizer'\nimport { getPointerEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\n\nconst DEFAULT_DRAG_DELAY = 180\n\nexport default class DragRecognizer extends CoordinatesRecognizer {\n  sharedStartState = { dragging: true, down: true }\n  sharedEndState = { dragging: false, down: false, buttons: 0, touches: 0 }\n\n  delayedEvent = false\n\n  constructor(controller: GestureController, args: any[]) {\n    super('drag', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent) {\n    const { xy, ...sharedPayload } = getPointerEventData(event)\n    return { values: xy, sharedPayload }\n  }\n\n  onDragStart = (event: UseGestureEvent): void => {\n    if (!this.enabled) return\n\n    // making sure we're not dragging the element when more than one finger press the screen\n    const { touches } = getPointerEventData(event)\n    if (touches > 1) return\n\n    const { currentTarget, pointerId } = event as PointerEvent\n    if (this.controller.config.pointerEvents) {\n      // if pointers events\n      currentTarget && (currentTarget as any).setPointerCapture(pointerId)\n    } else {\n      this.removeWindowListeners()\n      const dragListeners: [string, Fn][] = [\n        ['mousemove', this.onDragChange],\n        ['touchmove', this.onDragChange],\n        ['mouseup', this.onDragEnd],\n        ['touchend', this.onDragEnd],\n        ['touchcancel', this.onDragEnd],\n      ]\n      this.addWindowListeners(dragListeners)\n    }\n\n    if (this.controller.config.dragDelay) {\n      const dragDelay = typeof this.controller.config.dragDelay === 'number' ? this.controller.config.dragDelay : DEFAULT_DRAG_DELAY\n      if (typeof event.persist === 'function') event.persist()\n      this.delayedEvent = true\n      this.setTimeout(() => this.startDrag(event), dragDelay)\n    } else {\n      this.startDrag(event)\n    }\n  }\n\n  startDrag = (event: UseGestureEvent): void => {\n    const { currentTarget, pointerId } = event as PointerEvent\n    this.onStart(event, { currentTarget, pointerId, cancel: () => this.onCancel(event) })\n    this.delayedEvent = false\n  }\n\n  onDragChange = (event: UseGestureEvent): void => {\n    const { canceled, active } = this.state\n    if (canceled) return\n\n    if (!active) {\n      if (this.delayedEvent) {\n        this.clearTimeout()\n        this.startDrag(event)\n      }\n      return\n    }\n\n    const { buttons, touches } = getPointerEventData(event)\n\n    if (buttons === 0 && touches === 0) {\n      this.onEnd(event)\n      return\n    }\n\n    this.onChange(event, { cancel: () => this.onCancel(event) })\n  }\n\n  onDragEnd = (event: UseGestureEvent): void => {\n    this.clearTimeout()\n    this.delayedEvent = false\n\n    if (!this.state.active) return\n\n    const { currentTarget, pointerId } = this.state\n    if (currentTarget && this.controller.config.pointerEvents) (currentTarget as any).releasePointerCapture(pointerId)\n    this.onEnd(event)\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    if (this.controller.config.pointerEvents) {\n      return [['onPointerDown', this.onDragStart], ['onPointerMove', this.onDragChange], [['onPointerUp'], this.onDragEnd]]\n    }\n    return [[['onMouseDown', 'onTouchStart'], this.onDragStart]]\n  }\n}\n","import CoordinatesRecognizer from './CoordinatesRecognizer'\nimport { getScrollEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\n\nexport default class ScrollRecognizer extends CoordinatesRecognizer {\n  sharedStartState = { scrolling: true }\n  sharedEndState = { scrolling: false, velocity: 0, vxvy: [0, 0] }\n  continuousGesture = true\n\n  constructor(controller: GestureController, args: any[]) {\n    super('scroll', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent) {\n    const { xy, ...sharedPayload } = getScrollEventData(event)\n    return { values: xy, sharedPayload }\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    return [['onScroll', this.timeoutHandler]]\n  }\n}\n","import { WheelEvent } from 'react'\nimport CoordinatesRecognizer from './CoordinatesRecognizer'\nimport { addV, getWheelEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\n\nexport default class WheelRecognizer extends CoordinatesRecognizer {\n  sharedStartState = { wheeling: true }\n  sharedEndState = { wheeling: false, velocity: 0, vxvy: [0, 0] }\n  continuousGesture = true\n\n  constructor(controller: GestureController, args: any[]) {\n    super('wheel', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent<WheelEvent>) {\n    const { xy: prevXY } = this.state\n    const { xy, ...sharedPayload } = getWheelEventData(event)\n    const values = addV(xy, prevXY)\n\n    return { values, sharedPayload }\n  }\n\n  onWheel = (event: UseGestureEvent<WheelEvent>): void => {\n    if (event.ctrlKey && this.controller.actions.has('onPinch')) return\n    this.timeoutHandler(event)\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    return [['onWheel', this.onWheel]]\n  }\n}\n","import CoordinatesRecognizer from './CoordinatesRecognizer'\nimport { getPointerEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\n\nexport default class MoveRecognizer extends CoordinatesRecognizer {\n  sharedStartState = { moving: true }\n  sharedEndState = { moving: false, velocity: 0, vxvy: [0, 0] }\n\n  constructor(controller: GestureController, args: any[]) {\n    super('move', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent) {\n    const { xy, ...sharedPayload } = getPointerEventData(event)\n    return { values: xy, sharedPayload }\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    if (this.controller.config.pointerEvents) {\n      return [['onPointerMove', this.timeoutHandler]]\n    }\n    return [['onMouseMove', this.timeoutHandler]]\n  }\n}\n","import CoordinatesRecognizer from './CoordinatesRecognizer'\nimport { getPointerEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { GestureFlag, UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\nimport { genericEndState } from '../defaults'\n\nexport default class HoverRecognizer extends CoordinatesRecognizer {\n  constructor(controller: GestureController, args: any[]) {\n    super('hover', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent) {\n    const { xy, ...sharedPayload } = getPointerEventData(event)\n    return { values: xy, sharedPayload }\n  }\n\n  onPointerEnter = (event: UseGestureEvent): void => {\n    if (!this.enabled) return\n    const { values, sharedPayload } = this.getPayloadFromEvent(event)\n    this.updateState({ hovering: true, ...sharedPayload }, { values, event, args: this.args })\n    this.fireGestureHandler(GestureFlag.OnChange)\n  }\n\n  onPointerLeave = (event: UseGestureEvent): void => {\n    if (!this.enabled) return\n    const { values, sharedPayload } = this.getPayloadFromEvent(event)\n    const kinematics = this.getKinematics(values, event)\n\n    this.updateState({ hovering: false, moving: false, ...sharedPayload }, { ...kinematics, ...genericEndState, velocity: 0, vxvy: [0, 0] })\n\n    // when the mouse leaves the element, we also fire the move handler\n    // without waiting for move to end with debounce\n    this.controller.fireGestureHandler('move', GestureFlag.OnEnd)\n    this.controller.fireGestureHandler('hover', GestureFlag.OnChange)\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    if (this.controller.config.pointerEvents) {\n      return [['onPointerEnter', this.onPointerEnter], ['onPointerLeave', this.onEnd]]\n    }\n    return [['onMouseEnter', this.onPointerEnter], ['onMouseLeave', this.onPointerLeave]]\n  }\n}\n","import Recognizer from './Recognizer'\nimport { addV, calculateVelocities, calculateDirection } from '../utils'\nimport { DistanceAngle, GestureState, Vector2, UseGestureEvent, GestureKey } from '../types'\nimport GestureController from '../controllers/GestureController'\n\n/**\n * Abstract class for distance/angle-based gesture recongizers\n */\nexport default abstract class DistanceAngleRecognizer extends Recognizer<DistanceAngle> {\n  constructor(gestureKey: GestureKey, controller: GestureController, args: any[] = []) {\n    super(gestureKey, controller, args)\n  }\n\n  getKinematics([d, a]: [number, number?], event: UseGestureEvent): Partial<GestureState<DistanceAngle>> {\n    const { values: da, turns, initial, offset, time } = this.state\n\n    // angle might not be defined when ctrl wheel is used for zoom only\n    // in that case we set it to the previous angle value\n    a = a !== void 0 ? a : da[1]\n\n    const delta_d = d - da[0]\n    let delta_a = a - da[1]\n\n    /**\n     * The angle value might jump from 179deg to -179deg when we actually want to\n     * read 181deg to ensure continuity. To make that happen, we detect when the jump\n     * is supsiciously high (ie > 270deg) and increase the `turns` value\n     */\n    const newTurns = Math.abs(delta_a) > 270 ? turns + Math.sign(delta_a) : turns\n\n    // we update the angle difference to its corrected value\n    delta_a -= 360 * (newTurns - turns)\n    const delta = [delta_d, delta_a] as Vector2\n\n    const movement_d = d - initial[0]\n    const movement_a = a - 360 * newTurns - initial[1]\n    const movement: Vector2 = [movement_d, movement_a]\n\n    const delta_t = event.timeStamp - time!\n    const vdva = calculateVelocities(delta, delta_t)\n    const direction = calculateDirection(delta)\n    return {\n      event,\n      values: [d, a],\n      movement,\n      delta,\n      offset: addV(offset, delta),\n      vdva,\n      direction,\n      turns: newTurns,\n      previous: da,\n      time: event.timeStamp,\n    }\n  }\n}\n","import { TouchEvent } from 'react'\nimport DistanceAngleRecognizer from './DistanceAngleRecognizer'\nimport { getTwoTouchesEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn } from '../types'\n\nexport default class PinchRecognizer extends DistanceAngleRecognizer {\n  sharedStartState = { pinching: true }\n  sharedEndState = { pinching: false, down: false, touches: 0 }\n\n  constructor(controller: GestureController, args: any[]) {\n    super('pinch', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent<TouchEvent>) {\n    const { da, origin, ...sharedPayload } = getTwoTouchesEventData(event)\n    return { values: da, gesturePayload: { origin }, sharedPayload }\n  }\n\n  onPinchStart = (event: UseGestureEvent<TouchEvent>): void => {\n    if (!this.enabled || event.touches.length !== 2) return\n    this.onStart(event, { cancel: () => this.onCancel(event) })\n  }\n\n  onPinchChange = (event: UseGestureEvent<TouchEvent>): void => {\n    const { canceled, active, time } = this.state\n    if (canceled || !active || event.touches.length !== 2 || event.timeStamp === time) return\n\n    this.onChange(event, { cancel: () => this.onCancel(event) })\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    return [['onTouchStart', this.onPinchStart], ['onTouchMove', this.onPinchChange], [['onTouchEnd', 'onTouchCancel'], this.onEnd]]\n  }\n}\n","import { WheelEvent } from 'react'\nimport DistanceAngleRecognizer from './DistanceAngleRecognizer'\nimport { getWheelEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, Fn, Vector2 } from '../types'\n\nexport default class PinchWheelRecognizer extends DistanceAngleRecognizer {\n  sharedStartState = { pinching: true }\n  sharedEndState = { pinching: false }\n\n  constructor(controller: GestureController, args: any[]) {\n    super('pinch', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent<WheelEvent>) {\n    const {\n      xy: [, delta_d],\n      ...sharedPayload\n    } = getWheelEventData(event)\n    const {\n      da: [prev_d, prev_a],\n    } = this.state\n    const d = prev_d - delta_d\n    const a = prev_a !== void 0 ? prev_a : 0\n    const origin: Vector2 = [event.clientX, event.clientY]\n    return { values: [d, a] as Vector2, gesturePayload: { origin }, sharedPayload }\n  }\n\n  onWheel = (event: UseGestureEvent<WheelEvent>): void => {\n    if (!event.ctrlKey) return\n\n    if (!this.controller.config.passiveEvents) event.preventDefault()\n    else if (process.env.NODE_ENV === 'development')\n      console.warn(\n        'To support zoom on trackpads, try using the `domTarget` option and `config.event.passive` set to `false`. This message will only appear in development mode.'\n      )\n\n    this.timeoutHandler(event)\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    return [['onWheel', this.onWheel]]\n  }\n}\n","import { TouchEvent } from 'react'\nimport DistanceAngleRecognizer from './DistanceAngleRecognizer'\nimport { getTwoTouchesEventData } from '../utils'\nimport GestureController from '../controllers/GestureController'\nimport { UseGestureEvent, ReactEventHandlerKey, WebKitGestureEvent, Fn, Vector2 } from '../types'\n\nconst SCALE_FACTOR = 260\n\nexport default class PinchWebKitGestureRecognizer extends DistanceAngleRecognizer {\n  sharedStartState = { pinching: true, down: true, touches: 2 }\n  sharedEndState = { pinching: false, down: false, touches: 0 }\n  private origin?: Vector2\n\n  constructor(controller: GestureController, args: any[]) {\n    super('pinch', controller, args)\n  }\n\n  getPayloadFromEvent(event: UseGestureEvent<WebKitGestureEvent>) {\n    return { values: [event.scale * SCALE_FACTOR, event.rotation] as Vector2 }\n  }\n\n  onPinchStart = (event: WebKitGestureEvent): void => {\n    if (!this.enabled) return\n    event.preventDefault()\n    const origin: Vector2 = this.origin ? this.origin : [event.clientX, event.clientY]\n\n    this.onStart(event, { origin, cancel: () => this.onCancel(event) })\n  }\n\n  onPinchChange = (event: WebKitGestureEvent): void => {\n    const { canceled, active } = this.state\n    if (canceled || !active) return\n    event.preventDefault()\n\n    this.onChange(event, { cancel: () => this.onCancel(event) })\n  }\n\n  onGestureEnd = (event: WebKitGestureEvent): void => {\n    this.onEnd(event)\n    event.preventDefault()\n    this.origin = undefined\n  }\n\n  updateTouchData = (event: UseGestureEvent<TouchEvent>): void => {\n    if (!this.enabled || event.touches.length !== 2) return\n    const { origin } = getTwoTouchesEventData(event)\n    this.origin = origin\n  }\n\n  getEventBindings(): [ReactEventHandlerKey | ReactEventHandlerKey[], Fn][] {\n    return [\n      ['onGestureStart', this.onPinchStart],\n      ['onGestureChange', this.onPinchChange],\n      [['onGestureEnd', 'onTouchCancel'], this.onGestureEnd],\n      [['onTouchStart', 'onTouchMove'], this.updateTouchData],\n    ]\n  }\n}\n","import {\n  StateKey,\n  StateObject,\n  GestureState,\n  SharedGestureState,\n  GestureKey,\n  Fn,\n  ReactEventHandlerKey,\n  GestureFlag,\n  ReactEventHandlers,\n  GestureConfig,\n  GestureHandlers,\n  HandlerKey,\n  GestureHandlersPartial,\n} from '../types'\n\nimport { initialState, mappedKeys } from '../defaults'\nimport { addListeners, removeListeners, gestureEventSupported, chainFns } from '../utils'\n\nimport DragRecognizer from '../recognizers/DragRecognizer'\nimport ScrollRecognizer from '../recognizers/ScrollRecognizer'\nimport WheelRecognizer from '../recognizers/WheelRecognizer'\nimport MoveRecognizer from '../recognizers/MoveRecognizer'\nimport HoverRecognizer from '../recognizers/HoverRecognizer'\nimport PinchRecognizer from '../recognizers/PinchRecognizer'\nimport PinchWheelRecognizer from '../recognizers/PinchWheelRecognizer'\nimport PinchWebKitGestureRecognizer from '../recognizers/PinchWebKitGestureRecognizer'\nimport Recognizer from 'recognizers/Recognizer'\n\ntype GestureTimeouts = Partial<{ [stateKey in StateKey]: number }>\ntype WindowListeners = Partial<{ [stateKey in StateKey]: [string, Fn][] }>\ntype Bindings = Partial<{ [eventName in ReactEventHandlerKey]: Fn[] | Fn }>\n\n/**\n * Gesture controller will create gesture recognizers (which handle the gesture logic)\n * and keep track of the state for all gestures\n *\n * @template BinderType the type the bind function should return\n */\nexport default class GestureController {\n  public state: StateObject = initialState // state for all gestures\n  public timeouts: GestureTimeouts = {} // keeping track of timeouts for debounced gestures (such as move, scroll, wheel)\n  public actions: Set<HandlerKey>\n  private bindings: Bindings = {} // an object holding the handlers associated to the gestures\n  private domListeners: [string, Fn][] = [] // when config.domTarget is set, we attach events directly to the dom\n  private windowListeners: WindowListeners = {} // keeps track of window listeners added by gestures (drag only at the moment)\n  constructor(public handlers: GestureHandlersPartial, public config: GestureConfig) {\n    // if handlers contains {onDragStart, onDrag, onDragEnd, onMoveStart, onMove}\n    // actions will include 'onDrag' and 'onMove'\n    this.actions = new Set(Object.keys(this.handlers).map(k => <HandlerKey>k.replace(/End|Start/, '')))\n  }\n\n  /**\n   * Function run on component unmount\n   * Cleans timeouts and removes dom listeners set by the bind function\n   */\n  public clean = (): void => {\n    this.cleanOnBind()\n    Object.values(this.timeouts).forEach(clearTimeout)\n    Object.keys(this.windowListeners).forEach(stateKey => this.removeWindowListeners(<StateKey>stateKey))\n  }\n\n  /**\n   * Function run every time the bind function is run (ie on every render)\n   * Reset the binding object and remove dom listeners attached to config.domTarget\n   */\n  private cleanOnBind = (): void => {\n    this.bindings = {}\n    const { domTarget } = this.config\n    if (domTarget) {\n      removeListeners(<EventTarget>domTarget, this.domListeners, this.config.event)\n      this.domListeners = []\n    }\n  }\n\n  /**\n   * Commodity function to let gesture recognizer update global state\n   * @param sharedState shared partial state object\n   * @param gestureState partial gesture specific state object\n   * @param stateKey the state key ('drag', 'move'...)\n   */\n  public updateState = (sharedState: Partial<SharedGestureState> | null, gestureState: Partial<GestureState>, stateKey: StateKey): void => {\n    const newGestureState = { ...this.state[stateKey], ...gestureState }\n\n    if ('da' in newGestureState) newGestureState.da = newGestureState.values\n    else if ('xy' in newGestureState) newGestureState.xy = newGestureState.values\n\n    this.state = {\n      ...this.state,\n      shared: { ...this.state.shared, ...sharedState },\n      [stateKey]: newGestureState,\n    }\n  }\n\n  // fire the gesture handler defined by the user\n  public fireGestureHandler = (gestureKey: GestureKey, gestureFlag: GestureFlag): void => {\n    // gets the state key and handler key from the gesture key\n    // gestureKey: 'hover' -> stateKey: 'move', handlerKey: 'onHover'\n    const { stateKey, handlerKey } = mappedKeys[gestureKey]\n    const state = { ...this.state.shared, ...this.state[stateKey] }\n    if (state.event) state.event.gesture = gestureKey\n\n    if (gestureFlag === GestureFlag.OnStart) {\n      const handlerStart = `${handlerKey}Start` as keyof GestureHandlers\n      const handler = this.handlers[handlerStart] as any\n      handler && handler(state)\n    }\n\n    // whenever a flag is set, we run the default on[Gesture] function\n    // i.e. GestureFlag.OnStart would trigger both onDragStart and onDrag\n    const handler = this.handlers[handlerKey] as any\n    if (handler) {\n      const newMemo = handler(state)\n      this.state[stateKey].memo = newMemo !== void 0 ? newMemo : this.state[stateKey].memo\n    }\n\n    if (gestureFlag === GestureFlag.OnEnd) {\n      const handlerEnd = `${handlerKey}End` as keyof GestureHandlers\n      const handler = this.handlers[handlerEnd] as any\n      handler && handler(state)\n    }\n  }\n\n  /**\n   * Commodity function to let recognizers simply add listeners to config.window\n   * @param stateKey\n   * @param listeners\n   */\n  public addWindowListeners = (stateKey: StateKey, listeners: [string, Fn][]): void => {\n    if (!this.config.window) return\n    // we use this.windowListeners to keep track of the listeners we add\n    this.windowListeners[stateKey] = listeners\n    addListeners(this.config.window, listeners, this.config.event)\n  }\n\n  // commodity function to let recognizers simply remove listeners from config.window\n  public removeWindowListeners = (stateKey: StateKey): void => {\n    if (!this.config.window) return\n    const listeners = this.windowListeners[stateKey]\n    if (listeners) {\n      removeListeners(this.config.window, listeners, this.config.event)\n      delete this.windowListeners[stateKey]\n    }\n  }\n\n  /**\n   * Adds a recognizer to this.bindings\n   * @param recognizer\n   */\n  private addRecognizer = (recognizer: Recognizer): void => {\n    recognizer.getEventBindings().map(this.addEventBindings)\n  }\n\n  /**\n   * this.bindings is an object which keys match ReactEventHandlerKeys (onMouseMove, onTouchStart...).\n   * Since a recognizer might want to bind a handler function to an event key already used by a previously\n   * added recognizer, we need to make sure that each event key is an array of all the functions mapped for\n   * that key.\n   */\n  private addEventBindings = ([eventNames, fn]: [ReactEventHandlerKey | ReactEventHandlerKey[], Fn]): void => {\n    const eventNamesArray = !Array.isArray(eventNames) ? [eventNames] : eventNames\n\n    eventNamesArray.forEach(eventName => {\n      this.bindings[eventName] = this.bindings[eventName] ? [...(<Fn[]>this.bindings[eventName]), fn] : [fn]\n    })\n  }\n\n  /**\n   * When config.domTarget is set, this function will add dom listeners to it\n   */\n  private addDomTargetListeners = (): void => {\n    const { domTarget } = this.config\n\n    // we iterate on the entries of this.binding\n    // for each event, we chain the array of functions mapped to it\n    // and push it to this.domListeners\n    Object.entries(this.bindings).forEach(([event, fns]) => {\n      this.domListeners.push([event.substr(2).toLowerCase(), chainFns(...(<Fn[]>fns))])\n    })\n\n    addListeners(<EventTarget>domTarget, this.domListeners, this.config.event)\n  }\n\n  /**\n   * getBindings will return an object that will be bound by users\n   * to the react component they want to interact with\n   */\n  private getBindings = (): ReactEventHandlers => {\n    const output: ReactEventHandlers = {}\n    const captureString = this.config.event.capture ? 'Capture' : ''\n\n    Object.entries(this.bindings).forEach(([event, fns]) => {\n      const fnsArray = Array.isArray(fns) ? fns : [fns]\n      const key = (event + captureString) as ReactEventHandlerKey\n      output[key] = chainFns(...(<Fn[]>fnsArray))\n    })\n\n    return output\n  }\n\n  public bind = (...args: any[]): Fn | ReactEventHandlers => {\n    const { domTarget } = this.config\n\n    const genuineHandlers = { ...this.handlers }\n\n    // cleaning before adding\n    this.cleanOnBind()\n\n    if (this.actions.has('onDrag')) {\n      this.addRecognizer(new DragRecognizer(this, args))\n      delete genuineHandlers.onDrag\n      delete genuineHandlers.onDragStart\n      delete genuineHandlers.onDragEnd\n    }\n    if (this.actions.has('onScroll')) {\n      this.addRecognizer(new ScrollRecognizer(this, args))\n      delete genuineHandlers.onScroll\n      delete genuineHandlers.onScrollStart\n      delete genuineHandlers.onScrollEnd\n    }\n    if (this.actions.has('onWheel')) {\n      this.addRecognizer(new WheelRecognizer(this, args))\n      delete genuineHandlers.onWheel\n      delete genuineHandlers.onWheelStart\n      delete genuineHandlers.onWheelEnd\n    }\n    if (this.actions.has('onMove')) {\n      this.addRecognizer(new MoveRecognizer(this, args))\n      delete genuineHandlers.onMove\n      delete genuineHandlers.onMoveStart\n      delete genuineHandlers.onMoveEnd\n    }\n    if (this.actions.has('onHover')) {\n      this.addRecognizer(new HoverRecognizer(this, args))\n      delete genuineHandlers.onHover\n    }\n    if (this.actions.has('onPinch')) {\n      // since react doesn't have handlers for gesture events we can only use them\n      // domTarget is set (and when the browser supprots them).\n      if (domTarget && gestureEventSupported()) {\n        this.addRecognizer(new PinchWebKitGestureRecognizer(this, args))\n      } else {\n        this.addRecognizer(new PinchRecognizer(this, args))\n        this.addRecognizer(new PinchWheelRecognizer(this, args))\n      }\n      delete genuineHandlers.onPinch\n      delete genuineHandlers.onPinchStart\n      delete genuineHandlers.onPinchEnd\n    }\n\n    // we also add event bindings for genuine handlers\n    Object.entries(genuineHandlers).map(([event, fn]) => {\n      // we're cheating when it comes to event type :(\n      this.addEventBindings([<ReactEventHandlerKey>event, <Fn>fn])\n    })\n\n    // if config.domTarget is set we add event listeners to it and return the clean function\n    if (domTarget) {\n      this.addDomTargetListeners()\n      return this.clean\n    }\n\n    // if not, we return an object that contains gesture handlers mapped to react handler event keys\n    return this.getBindings()\n  }\n}\n","import React from 'react'\nimport GestureController from './controllers/GestureController'\nimport { Handler, GestureHandlersPartial, GestureConfig, Coordinates, Fn, ReactEventHandlers, DistanceAngle, Omit } from './types'\nimport { defaultConfig } from './defaults'\n\n/** API\n * const bind = useDrag(() => { ... })\n * const bind = usePinch(() => { ... })\n * const bind = useMove(() => { ... })\n * const bind = useScroll(() => { ... })\n * const bind = useWheel(() => { ... })\n *\n * Handlers object:\n * const bind = useGesture({ onDrag: () => { ... }, onMove: () => { ... } })\n *\n * DomTarget:\n * const bind = useGesture({ onScroll: () => { ... } }, { domTarget: window })\n * React.useEffect(bind, [bind])\n */\n\ntype PartialGestureConfig = Partial<Omit<GestureConfig, 'passiveEvents'>>\ntype GetBinderTypeFromDomTarget<T extends PartialGestureConfig> = T['domTarget'] extends object ? Fn : ReactEventHandlers\n\nexport function useGesture<Config extends PartialGestureConfig>(\n  handlers: GestureHandlersPartial,\n  config?: Config\n): (...args: any[]) => GetBinderTypeFromDomTarget<Config> {\n  // the gesture controller will keep track of all gesture states\n  const gestureController = React.useRef<GestureController>()\n\n  if (!gestureController.current) {\n    // we initialize the gesture controller once\n    gestureController.current = new GestureController(handlers, getDerivedConfig(config))\n  }\n\n  React.useEffect(() => {\n    // every time handlers or config change, we let the gesture controller compute\n    // them so that the gesture handlers functions are aware of the changes\n    gestureController.current!.config = getDerivedConfig(config)\n    gestureController.current!.handlers = handlers\n  }, [handlers, config])\n\n  // when the user component unmounts, we run our gesture controller clean function\n  React.useEffect(() => gestureController.current!.clean, [])\n\n  // we return the bind function of our controller, which returns an binding object or\n  // a cleaning function depending on whether config.domTarget is set\n  return gestureController.current.bind as (...args: any[]) => GetBinderTypeFromDomTarget<Config>\n}\n\n/* SHORTHAND HANDLERS */\nexport const useDrag = (handler: Handler<Coordinates>, config?: PartialGestureConfig) => useGesture({ onDrag: handler }, config)\nexport const useMove = (handler: Handler<Coordinates>, config?: PartialGestureConfig) => useGesture({ onMove: handler }, config)\nexport const useHover = (handler: Handler<Coordinates>, config?: PartialGestureConfig) => useGesture({ onHover: handler }, config)\nexport const useScroll = (handler: Handler<Coordinates>, config?: PartialGestureConfig) => useGesture({ onScroll: handler }, config)\nexport const useWheel = (handler: Handler<Coordinates>, config?: PartialGestureConfig) => useGesture({ onWheel: handler }, config)\nexport const usePinch = (handler: Handler<DistanceAngle>, config?: PartialGestureConfig) => useGesture({ onPinch: handler }, config)\n\nfunction getDerivedConfig(config?: Partial<GestureConfig>): GestureConfig {\n  const derivedConfig = { ...defaultConfig, ...config }\n  const { domTarget } = derivedConfig\n  const realDomTarget = domTarget && 'current' in domTarget ? domTarget.current : domTarget\n  derivedConfig.domTarget = realDomTarget\n\n  const passive = derivedConfig.event.passive !== void 0 ? derivedConfig.event.passive : true\n\n  // TODO make test to check if passive is correctly passed to config\n\n  // if there isn't a domtarget or if event.passive is true, then passiveEvents is true\n  derivedConfig.passiveEvents = !derivedConfig.domTarget || passive\n\n  return derivedConfig\n}\n"],"sourceRoot":""}