@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/modules/useResponderEvents/ResponderSystem.js.flow

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+/**
+ * RESPONDER EVENT SYSTEM
+ *
+ * A single, global "interaction lock" on views. For a view to be the "responder" means
+ * that pointer interactions are exclusive to that view and none other. The "interaction
+ * lock" can be transferred (only) to ancestors of the current "responder" as long as
+ * pointers continue to be active.
+ *
+ * Responder being granted:
+ *
+ * A view can become the "responder" after the following events:
+ *  * "pointerdown" (implemented using "touchstart", "mousedown")
+ *  * "pointermove" (implemented using "touchmove", "mousemove")
+ *  * "scroll" (while a pointer is down)
+ *  * "selectionchange" (while a pointer is down)
+ *
+ * If nothing is already the "responder", the event propagates to (capture) and from
+ * (bubble) the event target until a view returns `true` for
+ * `on*ShouldSetResponder(Capture)`.
+ *
+ * If something is already the responder, the event propagates to (capture) and from
+ * (bubble) the lowest common ancestor of the event target and the current "responder".
+ * Then negotiation happens between the current "responder" and a view that wants to
+ * become the "responder": see the timing diagram below.
+ *
+ * (NOTE: Scrolled views either automatically become the "responder" or release the
+ * "interaction lock". A native scroll view that isn't built on top of the responder
+ * system must result in the current "responder" being notified that it no longer has
+ * the "interaction lock" - the native system has taken over.
+ *
+ * Responder being released:
+ *
+ * As soon as there are no more active pointers that *started* inside descendants
+ * of the *current* "responder", an `onResponderRelease` event is dispatched to the
+ * current "responder", and the responder lock is released.
+ *
+ * Typical sequence of events:
+ *  * startShouldSetResponder
+ *  * responderGrant/Reject
+ *  * responderStart
+ *  * responderMove
+ *  * responderEnd
+ *  * responderRelease
+ */
+
+/*                                             Negotiation Performed
+                                             +-----------------------+
+                                            /                         \
+Process low level events to    +     Current Responder      +   wantsResponderID
+determine who to perform negot-|   (if any exists at all)   |
+iation/transition              | Otherwise just pass through|
+-------------------------------+----------------------------+------------------+
+Bubble to find first ID        |                            |
+to return true:wantsResponderID|                            |
+                               |                            |
+     +--------------+          |                            |
+     | onTouchStart |          |                            |
+     +------+-------+    none  |                            |
+            |            return|                            |
++-----------v-------------+true| +------------------------+ |
+|onStartShouldSetResponder|----->| onResponderStart (cur) |<-----------+
++-----------+-------------+    | +------------------------+ |          |
+            |                  |                            | +--------+-------+
+            | returned true for|       false:REJECT +-------->|onResponderReject
+            | wantsResponderID |                    |       | +----------------+
+            | (now attempt     | +------------------+-----+ |
+            |  handoff)        | | onResponder            | |
+            +------------------->|    TerminationRequest  | |
+                               | +------------------+-----+ |
+                               |                    |       | +----------------+
+                               |         true:GRANT +-------->|onResponderGrant|
+                               |                            | +--------+-------+
+                               | +------------------------+ |          |
+                               | | onResponderTerminate   |<-----------+
+                               | +------------------+-----+ |
+                               |                    |       | +----------------+
+                               |                    +-------->|onResponderStart|
+                               |                            | +----------------+
+Bubble to find first ID        |                            |
+to return true:wantsResponderID|                            |
+                               |                            |
+     +-------------+           |                            |
+     | onTouchMove |           |                            |
+     +------+------+     none  |                            |
+            |            return|                            |
++-----------v-------------+true| +------------------------+ |
+|onMoveShouldSetResponder |----->| onResponderMove (cur)  |<-----------+
++-----------+-------------+    | +------------------------+ |          |
+            |                  |                            | +--------+-------+
+            | returned true for|       false:REJECT +-------->|onResponderReject
+            | wantsResponderID |                    |       | +----------------+
+            | (now attempt     | +------------------+-----+ |
+            |  handoff)        | |   onResponder          | |
+            +------------------->|      TerminationRequest| |
+                               | +------------------+-----+ |
+                               |                    |       | +----------------+
+                               |         true:GRANT +-------->|onResponderGrant|
+                               |                            | +--------+-------+
+                               | +------------------------+ |          |
+                               | |   onResponderTerminate |<-----------+
+                               | +------------------+-----+ |
+                               |                    |       | +----------------+
+                               |                    +-------->|onResponderMove |
+                               |                            | +----------------+
+                               |                            |
+                               |                            |
+      Some active touch started|                            |
+      inside current responder | +------------------------+ |
+      +------------------------->|      onResponderEnd    | |
+      |                        | +------------------------+ |
+  +---+---------+              |                            |
+  | onTouchEnd  |              |                            |
+  +---+---------+              |                            |
+      |                        | +------------------------+ |
+      +------------------------->|     onResponderEnd     | |
+      No active touches started| +-----------+------------+ |
+      inside current responder |             |              |
+                               |             v              |
+                               | +------------------------+ |
+                               | |    onResponderRelease  | |
+                               | +------------------------+ |
+                               |                            |
+                               +                            + */
+
+import type { ResponderEvent } from './createResponderEvent';
+import createResponderEvent from './createResponderEvent';
+import { isCancelish, isEndish, isMoveish, isScroll, isSelectionChange, isStartish } from './ResponderEventTypes';
+import { getLowestCommonAncestor, getResponderPaths, hasTargetTouches, hasValidSelection, isPrimaryPointerDown, setResponderId } from './utils';
+import { ResponderTouchHistoryStore } from './ResponderTouchHistoryStore';
+import canUseDOM from '../canUseDom';
+
+/* ------------ TYPES ------------ */
+
+type ResponderId = number;
+type ActiveResponderInstance = {
+  id: ResponderId,
+  idPath: Array<number>,
+  node: any,
+};
+type EmptyResponderInstance = {
+  id: null,
+  idPath: null,
+  node: null,
+};
+type ResponderInstance = ActiveResponderInstance | EmptyResponderInstance;
+export type ResponderConfig = {
+  // Direct responder events dispatched directly to responder. Do not bubble.
+  onResponderEnd?: ?(e: ResponderEvent) => void,
+  onResponderGrant?: ?(e: ResponderEvent) => void | boolean,
+  onResponderMove?: ?(e: ResponderEvent) => void,
+  onResponderRelease?: ?(e: ResponderEvent) => void,
+  onResponderReject?: ?(e: ResponderEvent) => void,
+  onResponderStart?: ?(e: ResponderEvent) => void,
+  onResponderTerminate?: ?(e: ResponderEvent) => void,
+  onResponderTerminationRequest?: ?(e: ResponderEvent) => boolean,
+  // On pointer down, should this element become the responder?
+  onStartShouldSetResponder?: ?(e: ResponderEvent) => boolean,
+  onStartShouldSetResponderCapture?: ?(e: ResponderEvent) => boolean,
+  // On pointer move, should this element become the responder?
+  onMoveShouldSetResponder?: ?(e: ResponderEvent) => boolean,
+  onMoveShouldSetResponderCapture?: ?(e: ResponderEvent) => boolean,
+  // On scroll, should this element become the responder? Do no bubble
+  onScrollShouldSetResponder?: ?(e: ResponderEvent) => boolean,
+  onScrollShouldSetResponderCapture?: ?(e: ResponderEvent) => boolean,
+  // On text selection change, should this element become the responder?
+  onSelectionChangeShouldSetResponder?: ?(e: ResponderEvent) => boolean,
+  onSelectionChangeShouldSetResponderCapture?: ?(e: ResponderEvent) => boolean,
+};
+const emptyObject = {};
+
+/* ------------ IMPLEMENTATION ------------ */
+
+const startRegistration = ['onStartShouldSetResponderCapture', 'onStartShouldSetResponder', {
+  bubbles: true
+}];
+const moveRegistration = ['onMoveShouldSetResponderCapture', 'onMoveShouldSetResponder', {
+  bubbles: true
+}];
+const scrollRegistration = ['onScrollShouldSetResponderCapture', 'onScrollShouldSetResponder', {
+  bubbles: false
+}];
+const shouldSetResponderEvents = {
+  touchstart: startRegistration,
+  mousedown: startRegistration,
+  touchmove: moveRegistration,
+  mousemove: moveRegistration,
+  scroll: scrollRegistration
+};
+const emptyResponder = {
+  id: null,
+  idPath: null,
+  node: null
+};
+const responderListenersMap = new Map();
+let isEmulatingMouseEvents = false;
+let trackedTouchCount = 0;
+let currentResponder: ResponderInstance = {
+  id: null,
+  node: null,
+  idPath: null
+};
+const responderTouchHistoryStore = new ResponderTouchHistoryStore();
+declare function changeCurrentResponder(responder: ResponderInstance): any;
+declare function getResponderConfig(id: ResponderId): ResponderConfig | Object;
+/**
+ * Process native events
+ *
+ * A single event listener is used to manage the responder system.
+ * All pointers are tracked in the ResponderTouchHistoryStore. Native events
+ * are interpreted in terms of the Responder System and checked to see if
+ * the responder should be transferred. Each host node that is attached to
+ * the Responder System has an ID, which is used to look up its associated
+ * callbacks.
+ */
+declare function eventListener(domEvent: any): any;
+/**
+ * Walk the event path to/from the target node. At each node, stop and call the
+ * relevant "shouldSet" functions for the given event type. If any of those functions
+ * call "stopPropagation" on the event, stop searching for a responder.
+ */
+declare function findWantsResponder(eventPaths: any, domEvent: any, responderEvent: any): any;
+/**
+ * Attempt to transfer the responder.
+ */
+declare function attemptTransfer(responderEvent: ResponderEvent, wantsResponder: ActiveResponderInstance): any;
+/* ------------ PUBLIC API ------------ */
+/**
+ * Attach Listeners
+ *
+ * Use native events as ReactDOM doesn't have a non-plugin API to implement
+ * this system.
+ */
+const documentEventsCapturePhase = ['blur', 'scroll'];
+const documentEventsBubblePhase = [
+// mouse
+'mousedown', 'mousemove', 'mouseup', 'dragstart',
+// touch
+'touchstart', 'touchmove', 'touchend', 'touchcancel',
+// other
+'contextmenu', 'select', 'selectionchange'];
+declare export function attachListeners(): any;
+/**
+ * Register a node with the ResponderSystem.
+ */
+declare export function addNode(id: ResponderId, node: any, config: ResponderConfig): any;
+/**
+ * Unregister a node with the ResponderSystem.
+ */
+declare export function removeNode(id: ResponderId): any;
+/**
+ * Allow the current responder to be terminated from within components to support
+ * more complex requirements, such as use with other React libraries for working
+ * with scroll views, input views, etc.
+ */
+declare export function terminateResponder(): any;
+/**
+ * Allow unit tests to inspect the current responder in the system.
+ * FOR TESTING ONLY.
+ */
+declare export function getResponderNode(): any;

package/dist/modules/useResponderEvents/ResponderTouchHistoryStore.js

@@ -0,0 +1,170 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import { isStartish, isMoveish, isEndish } from './ResponderEventTypes';
+/**
+ * Tracks the position and time of each active touch by `touch.identifier`. We
+ * should typically only see IDs in the range of 1-20 because IDs get recycled
+ * when touches end and start again.
+ */
+
+var __DEV__ = process.env.NODE_ENV !== 'production';
+var MAX_TOUCH_BANK = 20;
+function timestampForTouch(touch) {
+  // The legacy internal implementation provides "timeStamp", which has been
+  // renamed to "timestamp".
+  return touch.timeStamp || touch.timestamp;
+}
+
+/**
+ * TODO: Instead of making gestures recompute filtered velocity, we could
+ * include a built in velocity computation that can be reused globally.
+ */
+function createTouchRecord(touch) {
+  return {
+    touchActive: true,
+    startPageX: touch.pageX,
+    startPageY: touch.pageY,
+    startTimeStamp: timestampForTouch(touch),
+    currentPageX: touch.pageX,
+    currentPageY: touch.pageY,
+    currentTimeStamp: timestampForTouch(touch),
+    previousPageX: touch.pageX,
+    previousPageY: touch.pageY,
+    previousTimeStamp: timestampForTouch(touch)
+  };
+}
+function resetTouchRecord(touchRecord, touch) {
+  touchRecord.touchActive = true;
+  touchRecord.startPageX = touch.pageX;
+  touchRecord.startPageY = touch.pageY;
+  touchRecord.startTimeStamp = timestampForTouch(touch);
+  touchRecord.currentPageX = touch.pageX;
+  touchRecord.currentPageY = touch.pageY;
+  touchRecord.currentTimeStamp = timestampForTouch(touch);
+  touchRecord.previousPageX = touch.pageX;
+  touchRecord.previousPageY = touch.pageY;
+  touchRecord.previousTimeStamp = timestampForTouch(touch);
+}
+function getTouchIdentifier(_ref) {
+  var identifier = _ref.identifier;
+  if (identifier == null) {
+    console.error('Touch object is missing identifier.');
+  }
+  if (__DEV__) {
+    if (identifier > MAX_TOUCH_BANK) {
+      console.error('Touch identifier %s is greater than maximum supported %s which causes ' + 'performance issues backfilling array locations for all of the indices.', identifier, MAX_TOUCH_BANK);
+    }
+  }
+  return identifier;
+}
+function recordTouchStart(touch, touchHistory) {
+  var identifier = getTouchIdentifier(touch);
+  var touchRecord = touchHistory.touchBank[identifier];
+  if (touchRecord) {
+    resetTouchRecord(touchRecord, touch);
+  } else {
+    touchHistory.touchBank[identifier] = createTouchRecord(touch);
+  }
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+}
+function recordTouchMove(touch, touchHistory) {
+  var touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = true;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.warn('Cannot record touch move without a touch start.\n', "Touch Move: " + printTouch(touch) + "\n", "Touch Bank: " + printTouchBank(touchHistory));
+  }
+}
+function recordTouchEnd(touch, touchHistory) {
+  var touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = false;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.warn('Cannot record touch end without a touch start.\n', "Touch End: " + printTouch(touch) + "\n", "Touch Bank: " + printTouchBank(touchHistory));
+  }
+}
+function printTouch(touch) {
+  return JSON.stringify({
+    identifier: touch.identifier,
+    pageX: touch.pageX,
+    pageY: touch.pageY,
+    timestamp: timestampForTouch(touch)
+  });
+}
+function printTouchBank(touchHistory) {
+  var touchBank = touchHistory.touchBank;
+  var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+  if (touchBank.length > MAX_TOUCH_BANK) {
+    printed += ' (original size: ' + touchBank.length + ')';
+  }
+  return printed;
+}
+export class ResponderTouchHistoryStore {
+  constructor() {
+    this._touchHistory = {
+      touchBank: [],
+      //Array<TouchRecord>
+      numberActiveTouches: 0,
+      // If there is only one active touch, we remember its location. This prevents
+      // us having to loop through all of the touches all the time in the most
+      // common case.
+      indexOfSingleActiveTouch: -1,
+      mostRecentTimeStamp: 0
+    };
+  }
+  recordTouchTrack(topLevelType, nativeEvent) {
+    var touchHistory = this._touchHistory;
+    if (isMoveish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchMove(touch, touchHistory));
+    } else if (isStartish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchStart(touch, touchHistory));
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
+      }
+    } else if (isEndish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(touch => recordTouchEnd(touch, touchHistory));
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        var touchBank = touchHistory.touchBank;
+        for (var i = 0; i < touchBank.length; i++) {
+          var touchTrackToCheck = touchBank[i];
+          if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+            touchHistory.indexOfSingleActiveTouch = i;
+            break;
+          }
+        }
+        if (__DEV__) {
+          var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+          if (!(activeRecord != null && activeRecord.touchActive)) {
+            console.error('Cannot find single active touch.');
+          }
+        }
+      }
+    }
+  }
+  get touchHistory() {
+    return this._touchHistory;
+  }
+}

package/dist/modules/useResponderEvents/ResponderTouchHistoryStore.js.flow

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import type { Touch, TouchEvent } from './ResponderEventTypes';
+import { isStartish, isMoveish, isEndish } from './ResponderEventTypes';
+type TouchRecord = {|
+  currentPageX: number,
+  currentPageY: number,
+  currentTimeStamp: number,
+  previousPageX: number,
+  previousPageY: number,
+  previousTimeStamp: number,
+  startPageX: number,
+  startPageY: number,
+  startTimeStamp: number,
+  touchActive: boolean,
+|};
+export type TouchHistory = $ReadOnly<{|
+  indexOfSingleActiveTouch: number,
+  mostRecentTimeStamp: number,
+  numberActiveTouches: number,
+  touchBank: Array<TouchRecord>,
+|}>;
+
+/**
+ * Tracks the position and time of each active touch by `touch.identifier`. We
+ * should typically only see IDs in the range of 1-20 because IDs get recycled
+ * when touches end and start again.
+ */
+
+const __DEV__ = process.env.NODE_ENV !== 'production';
+const MAX_TOUCH_BANK = 20;
+declare function timestampForTouch(touch: Touch): number;
+/**
+ * TODO: Instead of making gestures recompute filtered velocity, we could
+ * include a built in velocity computation that can be reused globally.
+ */
+declare function createTouchRecord(touch: Touch): TouchRecord;
+declare function resetTouchRecord(touchRecord: TouchRecord, touch: Touch): void;
+declare function getTouchIdentifier(arg0: Touch): number;
+declare function recordTouchStart(touch: Touch, touchHistory: any): void;
+declare function recordTouchMove(touch: Touch, touchHistory: any): void;
+declare function recordTouchEnd(touch: Touch, touchHistory: any): void;
+declare function printTouch(touch: Touch): string;
+declare function printTouchBank(touchHistory: any): string;
+declare export class ResponderTouchHistoryStore {
+  _touchHistory: any,
+  recordTouchTrack(topLevelType: string, nativeEvent: TouchEvent): void,
+  touchHistory(): TouchHistory,
+}

package/dist/modules/useResponderEvents/createResponderEvent.js

@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import getBoundingClientRect from '../../modules/getBoundingClientRect';
+var emptyFunction = () => {};
+var emptyObject = {};
+var emptyArray = [];
+
+/**
+ * Safari produces very large identifiers that would cause the `touchBank` array
+ * length to be so large as to crash the browser, if not normalized like this.
+ * In the future the `touchBank` should use an object/map instead.
+ */
+function normalizeIdentifier(identifier) {
+  return identifier > 20 ? identifier % 20 : identifier;
+}
+
+/**
+ * Converts a native DOM event to a ResponderEvent.
+ * Mouse events are transformed into fake touch events.
+ */
+export default function createResponderEvent(domEvent, responderTouchHistoryStore) {
+  var rect;
+  var propagationWasStopped = false;
+  var changedTouches;
+  var touches;
+  var domEventChangedTouches = domEvent.changedTouches;
+  var domEventType = domEvent.type;
+  var metaKey = domEvent.metaKey === true;
+  var shiftKey = domEvent.shiftKey === true;
+  var force = domEventChangedTouches && domEventChangedTouches[0].force || 0;
+  var identifier = normalizeIdentifier(domEventChangedTouches && domEventChangedTouches[0].identifier || 0);
+  var clientX = domEventChangedTouches && domEventChangedTouches[0].clientX || domEvent.clientX;
+  var clientY = domEventChangedTouches && domEventChangedTouches[0].clientY || domEvent.clientY;
+  var pageX = domEventChangedTouches && domEventChangedTouches[0].pageX || domEvent.pageX;
+  var pageY = domEventChangedTouches && domEventChangedTouches[0].pageY || domEvent.pageY;
+  var preventDefault = typeof domEvent.preventDefault === 'function' ? domEvent.preventDefault.bind(domEvent) : emptyFunction;
+  var timestamp = domEvent.timeStamp;
+  function normalizeTouches(touches) {
+    return Array.prototype.slice.call(touches).map(touch => {
+      return {
+        force: touch.force,
+        identifier: normalizeIdentifier(touch.identifier),
+        get locationX() {
+          return locationX(touch.clientX);
+        },
+        get locationY() {
+          return locationY(touch.clientY);
+        },
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        target: touch.target,
+        timestamp
+      };
+    });
+  }
+  if (domEventChangedTouches != null) {
+    changedTouches = normalizeTouches(domEventChangedTouches);
+    touches = normalizeTouches(domEvent.touches);
+  } else {
+    var emulatedTouches = [{
+      force,
+      identifier,
+      get locationX() {
+        return locationX(clientX);
+      },
+      get locationY() {
+        return locationY(clientY);
+      },
+      pageX,
+      pageY,
+      target: domEvent.target,
+      timestamp
+    }];
+    changedTouches = emulatedTouches;
+    touches = domEventType === 'mouseup' || domEventType === 'dragstart' ? emptyArray : emulatedTouches;
+  }
+  var responderEvent = {
+    bubbles: true,
+    cancelable: true,
+    // `currentTarget` is set before dispatch
+    currentTarget: null,
+    defaultPrevented: domEvent.defaultPrevented,
+    dispatchConfig: emptyObject,
+    eventPhase: domEvent.eventPhase,
+    isDefaultPrevented() {
+      return domEvent.defaultPrevented;
+    },
+    isPropagationStopped() {
+      return propagationWasStopped;
+    },
+    isTrusted: domEvent.isTrusted,
+    nativeEvent: {
+      altKey: false,
+      ctrlKey: false,
+      metaKey,
+      shiftKey,
+      changedTouches,
+      force,
+      identifier,
+      get locationX() {
+        return locationX(clientX);
+      },
+      get locationY() {
+        return locationY(clientY);
+      },
+      pageX,
+      pageY,
+      target: domEvent.target,
+      timestamp,
+      touches,
+      type: domEventType
+    },
+    persist: emptyFunction,
+    preventDefault,
+    stopPropagation() {
+      propagationWasStopped = true;
+    },
+    target: domEvent.target,
+    timeStamp: timestamp,
+    touchHistory: responderTouchHistoryStore.touchHistory
+  };
+
+  // Using getters and functions serves two purposes:
+  // 1) The value of `currentTarget` is not initially available.
+  // 2) Measuring the clientRect may cause layout jank and should only be done on-demand.
+  function locationX(x) {
+    rect = rect || getBoundingClientRect(responderEvent.currentTarget);
+    if (rect) {
+      return x - rect.left;
+    }
+  }
+  function locationY(y) {
+    rect = rect || getBoundingClientRect(responderEvent.currentTarget);
+    if (rect) {
+      return y - rect.top;
+    }
+  }
+  return responderEvent;
+}

package/dist/modules/useResponderEvents/createResponderEvent.js.flow

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Nicolas Gallagher
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import type { ResponderTouchHistoryStore, TouchHistory } from './ResponderTouchHistoryStore';
+import type { TouchEvent } from './ResponderEventTypes';
+import getBoundingClientRect from '../../modules/getBoundingClientRect';
+export type ResponderEvent = {|
+  bubbles: boolean,
+  cancelable: boolean,
+  currentTarget: any,
+  defaultPrevented: ?boolean,
+  dispatchConfig: {
+    registrationName?: string,
+    phasedRegistrationNames?: {
+      bubbled: string,
+      captured: string,
+    },
+  },
+  eventPhase: ?number,
+  isDefaultPrevented: () => boolean,
+  isPropagationStopped: () => boolean,
+  isTrusted: ?boolean,
+  preventDefault: () => void,
+  stopPropagation: () => void,
+  nativeEvent: TouchEvent,
+  persist: () => void,
+  target: ?any,
+  timeStamp: number,
+  touchHistory: TouchHistory,
+|};
+declare var emptyFunction: () => any;
+const emptyObject = {};
+const emptyArray = [];
+
+/**
+ * Safari produces very large identifiers that would cause the `touchBank` array
+ * length to be so large as to crash the browser, if not normalized like this.
+ * In the future the `touchBank` should use an object/map instead.
+ */
+declare function normalizeIdentifier(identifier: any): any;
+/**
+ * Converts a native DOM event to a ResponderEvent.
+ * Mouse events are transformed into fake touch events.
+ */
+declare export default function createResponderEvent(domEvent: any, responderTouchHistoryStore: ResponderTouchHistoryStore): ResponderEvent;