@tamagui/react-native-use-responder-events 1.2.8 → 1.2.10

package/dist/esm/ResponderSystem.mjs

@@ -0,0 +1,365 @@
+import createResponderEvent from "./createResponderEvent";
+import { ResponderTouchHistoryStore } from "./ResponderTouchHistoryStore";
+import {
+  isCancelish,
+  isEndish,
+  isMoveish,
+  isScroll,
+  isSelectionChange,
+  isStartish
+} from "./types";
+import { canUseDOM } from "./utils";
+import {
+  getLowestCommonAncestor,
+  getResponderPaths,
+  hasTargetTouches,
+  hasValidSelection,
+  isPrimaryPointerDown,
+  setResponderId
+} from "./utils";
+const emptyObject = {};
+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 = /* @__PURE__ */ new Map();
+let isEmulatingMouseEvents = false;
+let trackedTouchCount = 0;
+let currentResponder = {
+  id: null,
+  node: null,
+  idPath: null
+};
+const responderTouchHistoryStore = new ResponderTouchHistoryStore();
+function changeCurrentResponder(responder) {
+  currentResponder = responder;
+}
+function getResponderConfig(id) {
+  const config = responderListenersMap.get(id);
+  return config != null ? config : emptyObject;
+}
+function eventListener(domEvent) {
+  const eventType = domEvent.type;
+  const eventTarget = domEvent.target;
+  if (eventType === "touchstart") {
+    isEmulatingMouseEvents = true;
+  }
+  if (eventType === "touchmove" || trackedTouchCount > 1) {
+    isEmulatingMouseEvents = false;
+  }
+  if (
+    // Ignore browser emulated mouse events
+    eventType === "mousedown" && isEmulatingMouseEvents || eventType === "mousemove" && isEmulatingMouseEvents || // Ignore mousemove if a mousedown didn't occur first
+    eventType === "mousemove" && trackedTouchCount < 1
+  ) {
+    return;
+  }
+  if (isEmulatingMouseEvents && eventType === "mouseup") {
+    if (trackedTouchCount === 0) {
+      isEmulatingMouseEvents = false;
+    }
+    return;
+  }
+  const isStartEvent = isStartish(eventType) && isPrimaryPointerDown(domEvent);
+  const isMoveEvent = isMoveish(eventType);
+  const isEndEvent = isEndish(eventType);
+  const isScrollEvent = isScroll(eventType);
+  const isSelectionChangeEvent = isSelectionChange(eventType);
+  const responderEvent = createResponderEvent(domEvent, responderTouchHistoryStore);
+  if (isStartEvent || isMoveEvent || isEndEvent) {
+    if (domEvent.touches) {
+      trackedTouchCount = domEvent.touches.length;
+    } else {
+      if (isStartEvent) {
+        trackedTouchCount = 1;
+      } else if (isEndEvent) {
+        trackedTouchCount = 0;
+      }
+    }
+    responderTouchHistoryStore.recordTouchTrack(
+      eventType,
+      responderEvent.nativeEvent
+    );
+  }
+  let eventPaths = getResponderPaths(domEvent);
+  let wasNegotiated = false;
+  let wantsResponder;
+  if (isStartEvent || isMoveEvent || isScrollEvent && trackedTouchCount > 0) {
+    const currentResponderIdPath = currentResponder.idPath;
+    const eventIdPath = eventPaths.idPath;
+    if (currentResponderIdPath != null && eventIdPath != null) {
+      const lowestCommonAncestor = getLowestCommonAncestor(
+        currentResponderIdPath,
+        eventIdPath
+      );
+      if (lowestCommonAncestor != null) {
+        const indexOfLowestCommonAncestor = eventIdPath.indexOf(lowestCommonAncestor);
+        const index = indexOfLowestCommonAncestor + (lowestCommonAncestor === currentResponder.id ? 1 : 0);
+        eventPaths = {
+          idPath: eventIdPath.slice(index),
+          nodePath: eventPaths.nodePath.slice(index)
+        };
+      } else {
+        eventPaths = null;
+      }
+    }
+    if (eventPaths != null) {
+      wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent);
+      if (wantsResponder != null) {
+        attemptTransfer(responderEvent, wantsResponder);
+        wasNegotiated = true;
+      }
+    }
+  }
+  if (currentResponder.id != null && currentResponder.node != null) {
+    const { id, node } = currentResponder;
+    const {
+      onResponderStart,
+      onResponderMove,
+      onResponderEnd,
+      onResponderRelease,
+      onResponderTerminate,
+      onResponderTerminationRequest
+    } = getResponderConfig(id);
+    responderEvent.bubbles = false;
+    responderEvent.cancelable = false;
+    responderEvent.currentTarget = node;
+    if (isStartEvent) {
+      if (onResponderStart != null) {
+        responderEvent.dispatchConfig.registrationName = "onResponderStart";
+        onResponderStart(responderEvent);
+      }
+    } else if (isMoveEvent) {
+      if (onResponderMove != null) {
+        responderEvent.dispatchConfig.registrationName = "onResponderMove";
+        onResponderMove(responderEvent);
+      }
+    } else {
+      const isTerminateEvent = isCancelish(eventType) || // native context menu
+      eventType === "contextmenu" || // window blur
+      eventType === "blur" && eventTarget === window || // responder (or ancestors) blur
+      eventType === "blur" && eventTarget.contains(node) && domEvent.relatedTarget !== node || // native scroll without using a pointer
+      isScrollEvent && trackedTouchCount === 0 || // native scroll on node that is parent of the responder (allow siblings to scroll)
+      isScrollEvent && eventTarget.contains(node) && eventTarget !== node || // native select/selectionchange on node
+      isSelectionChangeEvent && hasValidSelection(domEvent);
+      const isReleaseEvent = isEndEvent && !isTerminateEvent && !hasTargetTouches(node, domEvent.touches);
+      if (isEndEvent) {
+        if (onResponderEnd != null) {
+          responderEvent.dispatchConfig.registrationName = "onResponderEnd";
+          onResponderEnd(responderEvent);
+        }
+      }
+      if (isReleaseEvent) {
+        if (onResponderRelease != null) {
+          responderEvent.dispatchConfig.registrationName = "onResponderRelease";
+          onResponderRelease(responderEvent);
+        }
+        changeCurrentResponder(emptyResponder);
+      }
+      if (isTerminateEvent) {
+        let shouldTerminate = true;
+        if (eventType === "contextmenu" || eventType === "scroll" || eventType === "selectionchange") {
+          if (wasNegotiated) {
+            shouldTerminate = false;
+          } else if (onResponderTerminationRequest != null) {
+            responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest";
+            if (onResponderTerminationRequest(responderEvent) === false) {
+              shouldTerminate = false;
+            }
+          }
+        }
+        if (shouldTerminate) {
+          if (onResponderTerminate != null) {
+            responderEvent.dispatchConfig.registrationName = "onResponderTerminate";
+            onResponderTerminate(responderEvent);
+          }
+          changeCurrentResponder(emptyResponder);
+          isEmulatingMouseEvents = false;
+          trackedTouchCount = 0;
+        }
+      }
+    }
+  }
+}
+function findWantsResponder(eventPaths, domEvent, responderEvent) {
+  const shouldSetCallbacks = shouldSetResponderEvents[domEvent.type];
+  if (shouldSetCallbacks != null) {
+    const { idPath, nodePath } = eventPaths;
+    const shouldSetCallbackCaptureName = shouldSetCallbacks[0];
+    const shouldSetCallbackBubbleName = shouldSetCallbacks[1];
+    const { bubbles } = shouldSetCallbacks[2];
+    const check = function(id, node, callbackName) {
+      const config = getResponderConfig(id);
+      const shouldSetCallback = config[callbackName];
+      if (shouldSetCallback != null) {
+        responderEvent.currentTarget = node;
+        if (shouldSetCallback(responderEvent) === true) {
+          const prunedIdPath = idPath.slice(idPath.indexOf(id));
+          return { id, node, idPath: prunedIdPath };
+        }
+      }
+    };
+    for (let i = idPath.length - 1; i >= 0; i--) {
+      const id = idPath[i];
+      const node = nodePath[i];
+      const result = check(id, node, shouldSetCallbackCaptureName);
+      if (result != null) {
+        return result;
+      }
+      if (responderEvent.isPropagationStopped() === true) {
+        return;
+      }
+    }
+    if (bubbles) {
+      for (let i = 0; i < idPath.length; i++) {
+        const id = idPath[i];
+        const node = nodePath[i];
+        const result = check(id, node, shouldSetCallbackBubbleName);
+        if (result != null) {
+          return result;
+        }
+        if (responderEvent.isPropagationStopped() === true) {
+          return;
+        }
+      }
+    } else {
+      const id = idPath[0];
+      const node = nodePath[0];
+      const target = domEvent.target;
+      if (target === node) {
+        return check(id, node, shouldSetCallbackBubbleName);
+      }
+    }
+  }
+}
+function attemptTransfer(responderEvent, wantsResponder) {
+  const { id: currentId, node: currentNode } = currentResponder;
+  const { id, node } = wantsResponder;
+  const { onResponderGrant, onResponderReject } = getResponderConfig(id);
+  responderEvent.bubbles = false;
+  responderEvent.cancelable = false;
+  responderEvent.currentTarget = node;
+  if (currentId == null) {
+    if (onResponderGrant != null) {
+      responderEvent.currentTarget = node;
+      responderEvent.dispatchConfig.registrationName = "onResponderGrant";
+      onResponderGrant(responderEvent);
+    }
+    changeCurrentResponder(wantsResponder);
+  } else {
+    const { onResponderTerminate, onResponderTerminationRequest } = getResponderConfig(currentId);
+    let allowTransfer = true;
+    if (onResponderTerminationRequest != null) {
+      responderEvent.currentTarget = currentNode;
+      responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest";
+      if (onResponderTerminationRequest(responderEvent) === false) {
+        allowTransfer = false;
+      }
+    }
+    if (allowTransfer) {
+      if (onResponderTerminate != null) {
+        responderEvent.currentTarget = currentNode;
+        responderEvent.dispatchConfig.registrationName = "onResponderTerminate";
+        onResponderTerminate(responderEvent);
+      }
+      if (onResponderGrant != null) {
+        responderEvent.currentTarget = node;
+        responderEvent.dispatchConfig.registrationName = "onResponderGrant";
+        onResponderGrant(responderEvent);
+      }
+      changeCurrentResponder(wantsResponder);
+    } else {
+      if (onResponderReject != null) {
+        responderEvent.currentTarget = node;
+        responderEvent.dispatchConfig.registrationName = "onResponderReject";
+        onResponderReject(responderEvent);
+      }
+    }
+  }
+}
+const documentEventsCapturePhase = ["blur", "scroll"];
+const documentEventsBubblePhase = [
+  // mouse
+  "mousedown",
+  "mousemove",
+  "mouseup",
+  "dragstart",
+  // touch
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "touchcancel",
+  // other
+  "contextmenu",
+  "select",
+  "selectionchange"
+];
+const isTamaguiResponderActive = Symbol();
+function attachListeners() {
+  if (canUseDOM && !window[isTamaguiResponderActive]) {
+    window.addEventListener("blur", eventListener);
+    documentEventsBubblePhase.forEach((eventType) => {
+      document.addEventListener(eventType, eventListener);
+    });
+    documentEventsCapturePhase.forEach((eventType) => {
+      document.addEventListener(eventType, eventListener, true);
+    });
+    window[isTamaguiResponderActive] = true;
+  }
+}
+function addNode(id, node, config) {
+  setResponderId(node, id);
+  responderListenersMap.set(id, config);
+}
+function removeNode(id) {
+  if (currentResponder.id === id) {
+    terminateResponder();
+  }
+  if (responderListenersMap.has(id)) {
+    responderListenersMap.delete(id);
+  }
+}
+function terminateResponder() {
+  const { id, node } = currentResponder;
+  if (id != null && node != null) {
+    const { onResponderTerminate } = getResponderConfig(id);
+    if (onResponderTerminate != null) {
+      const event = createResponderEvent({}, responderTouchHistoryStore);
+      event.currentTarget = node;
+      onResponderTerminate(event);
+    }
+    changeCurrentResponder(emptyResponder);
+  }
+  isEmulatingMouseEvents = false;
+  trackedTouchCount = 0;
+}
+function getResponderNode() {
+  return currentResponder.node;
+}
+export {
+  addNode,
+  attachListeners,
+  getResponderNode,
+  removeNode,
+  terminateResponder
+};
+//# sourceMappingURL=ResponderSystem.mjs.map

package/dist/esm/ResponderSystem.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ResponderSystem.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Nicolas Gallagher\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport type { ResponderEvent } from './createResponderEvent'\nimport createResponderEvent from './createResponderEvent'\nimport { ResponderTouchHistoryStore } from './ResponderTouchHistoryStore'\nimport {\n  isCancelish,\n  isEndish,\n  isMoveish,\n  isScroll,\n  isSelectionChange,\n  isStartish,\n} from './types'\nimport { canUseDOM } from './utils'\nimport {\n  getLowestCommonAncestor,\n  getResponderPaths,\n  hasTargetTouches,\n  hasValidSelection,\n  isPrimaryPointerDown,\n  setResponderId,\n} from './utils'\n\n/* ------------ TYPES ------------ */\n\ntype ResponderId = string\n\ntype ActiveResponderInstance = {\n  id: ResponderId\n  idPath: Array<number>\n  node: any\n}\n\ntype EmptyResponderInstance = {\n  id: null\n  idPath: null\n  node: null\n}\n\ntype ResponderInstance = ActiveResponderInstance | EmptyResponderInstance\n\nexport type ResponderConfig = {\n  // Direct responder events dispatched directly to responder. Do not bubble.\n  onResponderEnd?: ((e: ResponderEvent) => void) | null\n  onResponderGrant?: ((e: ResponderEvent) => void | boolean) | null\n  onResponderMove?: ((e: ResponderEvent) => void) | null\n  onResponderRelease?: ((e: ResponderEvent) => void) | null\n  onResponderReject?: ((e: ResponderEvent) => void) | null\n  onResponderStart?: ((e: ResponderEvent) => void) | null\n  onResponderTerminate?: ((e: ResponderEvent) => void) | null\n  onResponderTerminationRequest?: ((e: ResponderEvent) => boolean) | null\n  // On pointer down, should this element become the responder?\n  onStartShouldSetResponder?: ((e: ResponderEvent) => boolean) | null\n  onStartShouldSetResponderCapture?: ((e: ResponderEvent) => boolean) | null\n  // On pointer move, should this element become the responder?\n  onMoveShouldSetResponder?: ((e: ResponderEvent) => boolean) | null\n  onMoveShouldSetResponderCapture?: ((e: ResponderEvent) => boolean) | null\n  // On scroll, should this element become the responder? Do no bubble\n  onScrollShouldSetResponder?: ((e: ResponderEvent) => boolean) | null\n  onScrollShouldSetResponderCapture?: ((e: ResponderEvent) => boolean) | null\n  // On text selection change, should this element become the responder?\n  onSelectionChangeShouldSetResponder?: ((e: ResponderEvent) => boolean) | null\n  onSelectionChangeShouldSetResponderCapture?: ((e: ResponderEvent) => boolean) | null\n}\n\nconst emptyObject = {}\n\n/* ------------ IMPLEMENTATION ------------ */\n\nconst startRegistration = [\n  'onStartShouldSetResponderCapture',\n  'onStartShouldSetResponder',\n  { bubbles: true },\n]\nconst moveRegistration = [\n  'onMoveShouldSetResponderCapture',\n  'onMoveShouldSetResponder',\n  { bubbles: true },\n]\nconst scrollRegistration = [\n  'onScrollShouldSetResponderCapture',\n  'onScrollShouldSetResponder',\n  { bubbles: false },\n]\nconst shouldSetResponderEvents = {\n  touchstart: startRegistration,\n  mousedown: startRegistration,\n  touchmove: moveRegistration,\n  mousemove: moveRegistration,\n  scroll: scrollRegistration,\n}\n\nconst emptyResponder = { id: null, idPath: null, node: null }\nconst responderListenersMap = new Map()\n\nlet isEmulatingMouseEvents = false\nlet trackedTouchCount = 0\nlet currentResponder: ResponderInstance = {\n  id: null,\n  node: null,\n  idPath: null,\n}\nconst responderTouchHistoryStore = new ResponderTouchHistoryStore()\n\nfunction changeCurrentResponder(responder: ResponderInstance) {\n  currentResponder = responder\n}\n\nfunction getResponderConfig(id: ResponderId): ResponderConfig | any {\n  const config = responderListenersMap.get(id)\n  return config != null ? config : emptyObject\n}\n\n/**\n * Process native events\n *\n * A single event listener is used to manage the responder system.\n * All pointers are tracked in the ResponderTouchHistoryStore. Native events\n * are interpreted in terms of the Responder System and checked to see if\n * the responder should be transferred. Each host node that is attached to\n * the Responder System has an ID, which is used to look up its associated\n * callbacks.\n */\nfunction eventListener(domEvent: any) {\n  const eventType = domEvent.type\n  const eventTarget = domEvent.target\n\n  /**\n   * Manage emulated events and early bailout.\n   * Since PointerEvent is not used yet (lack of support in older Safari), it's\n   * necessary to manually manage the mess of browser touch/mouse events.\n   * And bailout early for termination events when there is no active responder.\n   */\n\n  // Flag when browser may produce emulated events\n  if (eventType === 'touchstart') {\n    isEmulatingMouseEvents = true\n  }\n  // Remove flag when browser will not produce emulated events\n  if (eventType === 'touchmove' || trackedTouchCount > 1) {\n    isEmulatingMouseEvents = false\n  }\n  // Ignore various events in particular circumstances\n  if (\n    // Ignore browser emulated mouse events\n    (eventType === 'mousedown' && isEmulatingMouseEvents) ||\n    (eventType === 'mousemove' && isEmulatingMouseEvents) ||\n    // Ignore mousemove if a mousedown didn't occur first\n    (eventType === 'mousemove' && trackedTouchCount < 1)\n  ) {\n    return\n  }\n  // Remove flag after emulated events are finished\n  if (isEmulatingMouseEvents && eventType === 'mouseup') {\n    if (trackedTouchCount === 0) {\n      isEmulatingMouseEvents = false\n    }\n    return\n  }\n\n  const isStartEvent = isStartish(eventType) && isPrimaryPointerDown(domEvent)\n  const isMoveEvent = isMoveish(eventType)\n  const isEndEvent = isEndish(eventType)\n  const isScrollEvent = isScroll(eventType)\n  const isSelectionChangeEvent = isSelectionChange(eventType)\n  const responderEvent = createResponderEvent(domEvent, responderTouchHistoryStore)\n\n  /**\n   * Record the state of active pointers\n   */\n\n  if (isStartEvent || isMoveEvent || isEndEvent) {\n    if (domEvent.touches) {\n      trackedTouchCount = domEvent.touches.length\n    } else {\n      if (isStartEvent) {\n        trackedTouchCount = 1\n      } else if (isEndEvent) {\n        trackedTouchCount = 0\n      }\n    }\n    responderTouchHistoryStore.recordTouchTrack(\n      eventType,\n      responderEvent.nativeEvent as any\n    )\n  }\n\n  /**\n   * Responder System logic\n   */\n\n  let eventPaths: any = getResponderPaths(domEvent)\n  let wasNegotiated = false\n  let wantsResponder\n\n  // If an event occured that might change the current responder...\n  if (isStartEvent || isMoveEvent || (isScrollEvent && trackedTouchCount > 0)) {\n    // If there is already a responder, prune the event paths to the lowest common ancestor\n    // of the existing responder and deepest target of the event.\n    const currentResponderIdPath = currentResponder.idPath\n    const eventIdPath = eventPaths.idPath\n\n    if (currentResponderIdPath != null && eventIdPath != null) {\n      const lowestCommonAncestor = getLowestCommonAncestor(\n        currentResponderIdPath,\n        eventIdPath\n      )\n      if (lowestCommonAncestor != null) {\n        const indexOfLowestCommonAncestor = eventIdPath.indexOf(lowestCommonAncestor)\n        // Skip the current responder so it doesn't receive unexpected \"shouldSet\" events.\n        const index =\n          indexOfLowestCommonAncestor +\n          (lowestCommonAncestor === currentResponder.id ? 1 : 0)\n        eventPaths = {\n          idPath: eventIdPath.slice(index),\n          nodePath: eventPaths.nodePath.slice(index),\n        }\n      } else {\n        eventPaths = null\n      }\n    }\n\n    if (eventPaths != null) {\n      // If a node wants to become the responder, attempt to transfer.\n      wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent)\n      if (wantsResponder != null) {\n        // Sets responder if none exists, or negotates with existing responder.\n        attemptTransfer(responderEvent, wantsResponder)\n        wasNegotiated = true\n      }\n    }\n  }\n\n  // If there is now a responder, invoke its callbacks for the lifecycle of the gesture.\n  if (currentResponder.id != null && currentResponder.node != null) {\n    const { id, node } = currentResponder\n    const {\n      onResponderStart,\n      onResponderMove,\n      onResponderEnd,\n      onResponderRelease,\n      onResponderTerminate,\n      onResponderTerminationRequest,\n    } = getResponderConfig(id)\n\n    responderEvent.bubbles = false\n    responderEvent.cancelable = false\n    responderEvent.currentTarget = node\n\n    // Start\n    if (isStartEvent) {\n      if (onResponderStart != null) {\n        responderEvent.dispatchConfig.registrationName = 'onResponderStart'\n        onResponderStart(responderEvent)\n      }\n    }\n    // Move\n    else if (isMoveEvent) {\n      if (onResponderMove != null) {\n        responderEvent.dispatchConfig.registrationName = 'onResponderMove'\n        onResponderMove(responderEvent)\n      }\n    } else {\n      const isTerminateEvent =\n        isCancelish(eventType) ||\n        // native context menu\n        eventType === 'contextmenu' ||\n        // window blur\n        (eventType === 'blur' && eventTarget === window) ||\n        // responder (or ancestors) blur\n        (eventType === 'blur' &&\n          eventTarget.contains(node) &&\n          domEvent.relatedTarget !== node) ||\n        // native scroll without using a pointer\n        (isScrollEvent && trackedTouchCount === 0) ||\n        // native scroll on node that is parent of the responder (allow siblings to scroll)\n        (isScrollEvent && eventTarget.contains(node) && eventTarget !== node) ||\n        // native select/selectionchange on node\n        (isSelectionChangeEvent && hasValidSelection(domEvent))\n\n      const isReleaseEvent =\n        isEndEvent && !isTerminateEvent && !hasTargetTouches(node, domEvent.touches)\n\n      // End\n      if (isEndEvent) {\n        if (onResponderEnd != null) {\n          responderEvent.dispatchConfig.registrationName = 'onResponderEnd'\n          onResponderEnd(responderEvent)\n        }\n      }\n      // Release\n      if (isReleaseEvent) {\n        if (onResponderRelease != null) {\n          responderEvent.dispatchConfig.registrationName = 'onResponderRelease'\n          onResponderRelease(responderEvent)\n        }\n        changeCurrentResponder(emptyResponder)\n      }\n      // Terminate\n      if (isTerminateEvent) {\n        let shouldTerminate = true\n\n        // Responders can still avoid termination but only for these events.\n        if (\n          eventType === 'contextmenu' ||\n          eventType === 'scroll' ||\n          eventType === 'selectionchange'\n        ) {\n          // Only call this function is it wasn't already called during negotiation.\n          if (wasNegotiated) {\n            shouldTerminate = false\n          } else if (onResponderTerminationRequest != null) {\n            responderEvent.dispatchConfig.registrationName =\n              'onResponderTerminationRequest'\n            if (onResponderTerminationRequest(responderEvent) === false) {\n              shouldTerminate = false\n            }\n          }\n        }\n\n        if (shouldTerminate) {\n          if (onResponderTerminate != null) {\n            responderEvent.dispatchConfig.registrationName = 'onResponderTerminate'\n            onResponderTerminate(responderEvent)\n          }\n          changeCurrentResponder(emptyResponder)\n          isEmulatingMouseEvents = false\n          trackedTouchCount = 0\n        }\n      }\n    }\n  }\n}\n\n/**\n * Walk the event path to/from the target node. At each node, stop and call the\n * relevant \"shouldSet\" functions for the given event type. If any of those functions\n * call \"stopPropagation\" on the event, stop searching for a responder.\n */\nfunction findWantsResponder(eventPaths, domEvent, responderEvent) {\n  const shouldSetCallbacks = shouldSetResponderEvents[domEvent.type as any] // for Flow\n\n  if (shouldSetCallbacks != null) {\n    const { idPath, nodePath } = eventPaths\n\n    const shouldSetCallbackCaptureName = shouldSetCallbacks[0]\n    const shouldSetCallbackBubbleName = shouldSetCallbacks[1]\n    const { bubbles } = shouldSetCallbacks[2]\n\n    const check = function (id, node, callbackName) {\n      const config = getResponderConfig(id)\n      const shouldSetCallback = config[callbackName]\n      if (shouldSetCallback != null) {\n        responderEvent.currentTarget = node\n        if (shouldSetCallback(responderEvent) === true) {\n          // Start the path from the potential responder\n          const prunedIdPath = idPath.slice(idPath.indexOf(id))\n          return { id, node, idPath: prunedIdPath }\n        }\n      }\n    }\n\n    // capture\n    for (let i = idPath.length - 1; i >= 0; i--) {\n      const id = idPath[i]\n      const node = nodePath[i]\n      const result = check(id, node, shouldSetCallbackCaptureName)\n      if (result != null) {\n        return result\n      }\n      if (responderEvent.isPropagationStopped() === true) {\n        return\n      }\n    }\n\n    // bubble\n    if (bubbles) {\n      for (let i = 0; i < idPath.length; i++) {\n        const id = idPath[i]\n        const node = nodePath[i]\n        const result = check(id, node, shouldSetCallbackBubbleName)\n        if (result != null) {\n          return result\n        }\n        if (responderEvent.isPropagationStopped() === true) {\n          return\n        }\n      }\n    } else {\n      const id = idPath[0]\n      const node = nodePath[0]\n      const target = domEvent.target\n      if (target === node) {\n        return check(id, node, shouldSetCallbackBubbleName)\n      }\n    }\n  }\n}\n\n/**\n * Attempt to transfer the responder.\n */\nfunction attemptTransfer(\n  responderEvent: ResponderEvent,\n  wantsResponder: ActiveResponderInstance\n) {\n  const { id: currentId, node: currentNode } = currentResponder\n  const { id, node } = wantsResponder\n\n  const { onResponderGrant, onResponderReject } = getResponderConfig(id)\n\n  responderEvent.bubbles = false\n  responderEvent.cancelable = false\n  responderEvent.currentTarget = node\n\n  // Set responder\n  if (currentId == null) {\n    if (onResponderGrant != null) {\n      responderEvent.currentTarget = node\n      responderEvent.dispatchConfig.registrationName = 'onResponderGrant'\n      onResponderGrant(responderEvent)\n    }\n    changeCurrentResponder(wantsResponder)\n  }\n  // Negotiate with current responder\n  else {\n    const { onResponderTerminate, onResponderTerminationRequest } =\n      getResponderConfig(currentId)\n\n    let allowTransfer = true\n    if (onResponderTerminationRequest != null) {\n      responderEvent.currentTarget = currentNode\n      responderEvent.dispatchConfig.registrationName = 'onResponderTerminationRequest'\n      if (onResponderTerminationRequest(responderEvent) === false) {\n        allowTransfer = false\n      }\n    }\n\n    if (allowTransfer) {\n      // Terminate existing responder\n      if (onResponderTerminate != null) {\n        responderEvent.currentTarget = currentNode\n        responderEvent.dispatchConfig.registrationName = 'onResponderTerminate'\n        onResponderTerminate(responderEvent)\n      }\n      // Grant next responder\n      if (onResponderGrant != null) {\n        responderEvent.currentTarget = node\n        responderEvent.dispatchConfig.registrationName = 'onResponderGrant'\n        onResponderGrant(responderEvent)\n      }\n      changeCurrentResponder(wantsResponder)\n    } else {\n      // Reject responder request\n      if (onResponderReject != null) {\n        responderEvent.currentTarget = node\n        responderEvent.dispatchConfig.registrationName = 'onResponderReject'\n        onResponderReject(responderEvent)\n      }\n    }\n  }\n}\n\n/* ------------ PUBLIC API ------------ */\n\n/**\n * Attach Listeners\n *\n * Use native events as ReactDOM doesn't have a non-plugin API to implement\n * this system.\n */\nconst documentEventsCapturePhase = ['blur', 'scroll']\nconst documentEventsBubblePhase = [\n  // mouse\n  'mousedown',\n  'mousemove',\n  'mouseup',\n  'dragstart',\n  // touch\n  'touchstart',\n  'touchmove',\n  'touchend',\n  'touchcancel',\n  // other\n  'contextmenu',\n  'select',\n  'selectionchange',\n]\n\nconst isTamaguiResponderActive = Symbol()\n\nexport function attachListeners() {\n  if (canUseDOM && !window[isTamaguiResponderActive]) {\n    window.addEventListener('blur', eventListener)\n    documentEventsBubblePhase.forEach((eventType) => {\n      document.addEventListener(eventType, eventListener)\n    })\n    documentEventsCapturePhase.forEach((eventType) => {\n      document.addEventListener(eventType, eventListener, true)\n    })\n    window[isTamaguiResponderActive] = true\n  }\n}\n\n/**\n * Register a node with the ResponderSystem.\n */\nexport function addNode(id: ResponderId, node: any, config: ResponderConfig) {\n  setResponderId(node, id)\n  responderListenersMap.set(id, config)\n}\n\n/**\n * Unregister a node with the ResponderSystem.\n */\nexport function removeNode(id: ResponderId) {\n  if (currentResponder.id === id) {\n    terminateResponder()\n  }\n  if (responderListenersMap.has(id)) {\n    responderListenersMap.delete(id)\n  }\n}\n\n/**\n * Allow the current responder to be terminated from within components to support\n * more complex requirements, such as use with other React libraries for working\n * with scroll views, input views, etc.\n */\nexport function terminateResponder() {\n  const { id, node } = currentResponder\n  if (id != null && node != null) {\n    const { onResponderTerminate } = getResponderConfig(id)\n    if (onResponderTerminate != null) {\n      const event = createResponderEvent({}, responderTouchHistoryStore)\n      event.currentTarget = node\n      onResponderTerminate(event)\n    }\n    changeCurrentResponder(emptyResponder)\n  }\n  isEmulatingMouseEvents = false\n  trackedTouchCount = 0\n}\n\n/**\n * Allow unit tests to inspect the current responder in the system.\n * FOR TESTING ONLY.\n */\nexport function getResponderNode(): any {\n  return currentResponder.node\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/ResponderTouchHistoryStore.mjs

@@ -0,0 +1,170 @@
+import { isEndish, isMoveish, isStartish } from "./types";
+const MAX_TOUCH_BANK = 20;
+function timestampForTouch(touch) {
+  return touch["timeStamp"] || touch.timestamp;
+}
+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({ identifier }) {
+  if (identifier == null) {
+    console.error("Touch object is missing identifier.");
+  }
+  if (process.env.NODE_ENV === "development") {
+    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) {
+  const identifier = getTouchIdentifier(touch);
+  const touchRecord = touchHistory.touchBank[identifier];
+  if (touchRecord) {
+    resetTouchRecord(touchRecord, touch);
+  } else {
+    touchHistory.touchBank[identifier] = createTouchRecord(touch);
+  }
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+}
+function recordTouchMove(touch, touchHistory) {
+  const 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)}
+`,
+      `Touch Bank: ${printTouchBank(touchHistory)}`
+    );
+  }
+}
+function recordTouchEnd(touch, touchHistory) {
+  const 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)}
+`,
+      `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) {
+  const { touchBank } = touchHistory;
+  let printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+  if (touchBank.length > MAX_TOUCH_BANK) {
+    printed += ` (original size: ${touchBank.length})`;
+  }
+  return printed;
+}
+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) {
+    const 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) {
+        const { touchBank } = touchHistory;
+        for (let i = 0; i < touchBank.length; i++) {
+          const touchTrackToCheck = touchBank[i];
+          if (touchTrackToCheck == null ? void 0 : touchTrackToCheck.touchActive) {
+            touchHistory.indexOfSingleActiveTouch = i;
+            break;
+          }
+        }
+        if (process.env.NODE_ENV === "development") {
+          const activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+          if (!(activeRecord == null ? void 0 : activeRecord.touchActive)) {
+            console.error("Cannot find single active touch.");
+          }
+        }
+      }
+    }
+  }
+  get touchHistory() {
+    return this._touchHistory;
+  }
+}
+export {
+  ResponderTouchHistoryStore
+};
+//# sourceMappingURL=ResponderTouchHistoryStore.mjs.map

package/dist/esm/ResponderTouchHistoryStore.mjs.map

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

package/dist/esm/createResponderEvent.mjs

@@ -0,0 +1,129 @@
+import { getBoundingClientRect } from "./utils";
+const emptyFunction = () => {
+};
+const emptyObject = {};
+const emptyArray = [];
+function normalizeIdentifier(identifier) {
+  return identifier > 20 ? identifier % 20 : identifier;
+}
+function createResponderEvent(domEvent, responderTouchHistoryStore) {
+  let rect;
+  let propagationWasStopped = false;
+  let changedTouches;
+  let touches;
+  const domEventChangedTouches = domEvent.changedTouches;
+  const domEventType = domEvent.type;
+  const metaKey = domEvent.metaKey === true;
+  const shiftKey = domEvent.shiftKey === true;
+  const force = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].force) || 0;
+  const identifier = normalizeIdentifier((domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].identifier) || 0);
+  const clientX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientX) || domEvent.clientX;
+  const clientY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientY) || domEvent.clientY;
+  const pageX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageX) || domEvent.pageX;
+  const pageY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageY) || domEvent.pageY;
+  const preventDefault = typeof domEvent.preventDefault === "function" ? domEvent.preventDefault.bind(domEvent) : emptyFunction;
+  const timestamp = domEvent.timeStamp;
+  function normalizeTouches(touches2) {
+    return Array.prototype.slice.call(touches2).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 {
+    const 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;
+  }
+  const 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
+  };
+  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;
+}
+export {
+  createResponderEvent as default
+};
+//# sourceMappingURL=createResponderEvent.mjs.map

package/dist/esm/createResponderEvent.mjs.map

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

package/dist/esm/index.mjs

@@ -0,0 +1,2 @@
+export * from "./useResponderEvents";
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["export * from './useResponderEvents'\n"],
+  "mappings": "AAAA,cAAc;",
+  "names": []
+}

package/dist/esm/types.mjs

@@ -0,0 +1,55 @@
+const BLUR = "blur";
+const CONTEXT_MENU = "contextmenu";
+const FOCUS_OUT = "focusout";
+const MOUSE_DOWN = "mousedown";
+const MOUSE_MOVE = "mousemove";
+const MOUSE_UP = "mouseup";
+const MOUSE_CANCEL = "dragstart";
+const TOUCH_START = "touchstart";
+const TOUCH_MOVE = "touchmove";
+const TOUCH_END = "touchend";
+const TOUCH_CANCEL = "touchcancel";
+const SCROLL = "scroll";
+const SELECT = "select";
+const SELECTION_CHANGE = "selectionchange";
+function isStartish(eventType) {
+  return eventType === TOUCH_START || eventType === MOUSE_DOWN;
+}
+function isMoveish(eventType) {
+  return eventType === TOUCH_MOVE || eventType === MOUSE_MOVE;
+}
+function isEndish(eventType) {
+  return eventType === TOUCH_END || eventType === MOUSE_UP || isCancelish(eventType);
+}
+function isCancelish(eventType) {
+  return eventType === TOUCH_CANCEL || eventType === MOUSE_CANCEL;
+}
+function isScroll(eventType) {
+  return eventType === SCROLL;
+}
+function isSelectionChange(eventType) {
+  return eventType === SELECT || eventType === SELECTION_CHANGE;
+}
+export {
+  BLUR,
+  CONTEXT_MENU,
+  FOCUS_OUT,
+  MOUSE_CANCEL,
+  MOUSE_DOWN,
+  MOUSE_MOVE,
+  MOUSE_UP,
+  SCROLL,
+  SELECT,
+  SELECTION_CHANGE,
+  TOUCH_CANCEL,
+  TOUCH_END,
+  TOUCH_MOVE,
+  TOUCH_START,
+  isCancelish,
+  isEndish,
+  isMoveish,
+  isScroll,
+  isSelectionChange,
+  isStartish
+};
+//# sourceMappingURL=types.mjs.map

package/dist/esm/types.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Nicolas Gallagher\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nexport type Touch = {\n  force: number\n  identifier: number\n  // The locationX and locationY properties are non-standard additions\n  locationX: any\n  locationY: any\n  pageX: number\n  pageY: number\n  target: any\n  // Touches in a list have a timestamp property\n  timestamp: number\n}\n\nexport type TouchEvent = {\n  altKey: boolean\n  ctrlKey: boolean\n  metaKey: boolean\n  shiftKey: boolean\n  // TouchList is an array in the Responder system\n  changedTouches: Array<Touch>\n  force: number\n  // React Native adds properties to the \"nativeEvent that are usually only found on W3C Touches \u203E\\_(\u30C4)_/\u203E\n  identifier: number\n  locationX: any\n  locationY: any\n  pageX: number\n  pageY: number\n  target: any\n  // The timestamp has a lowercase \"s\" in the Responder system\n  timestamp: number\n  // TouchList is an array in the Responder system\n  touches: Array<Touch>\n}\n\nexport const BLUR = 'blur'\nexport const CONTEXT_MENU = 'contextmenu'\nexport const FOCUS_OUT = 'focusout'\nexport const MOUSE_DOWN = 'mousedown'\nexport const MOUSE_MOVE = 'mousemove'\nexport const MOUSE_UP = 'mouseup'\nexport const MOUSE_CANCEL = 'dragstart'\nexport const TOUCH_START = 'touchstart'\nexport const TOUCH_MOVE = 'touchmove'\nexport const TOUCH_END = 'touchend'\nexport const TOUCH_CANCEL = 'touchcancel'\nexport const SCROLL = 'scroll'\nexport const SELECT = 'select'\nexport const SELECTION_CHANGE = 'selectionchange'\n\nexport function isStartish(eventType: unknown): boolean {\n  return eventType === TOUCH_START || eventType === MOUSE_DOWN\n}\n\nexport function isMoveish(eventType: unknown): boolean {\n  return eventType === TOUCH_MOVE || eventType === MOUSE_MOVE\n}\n\nexport function isEndish(eventType: unknown): boolean {\n  return eventType === TOUCH_END || eventType === MOUSE_UP || isCancelish(eventType)\n}\n\nexport function isCancelish(eventType: unknown): boolean {\n  return eventType === TOUCH_CANCEL || eventType === MOUSE_CANCEL\n}\n\nexport function isScroll(eventType: unknown): boolean {\n  return eventType === SCROLL\n}\n\nexport function isSelectionChange(eventType: unknown): boolean {\n  return eventType === SELECT || eventType === SELECTION_CHANGE\n}\n"],
+  "mappings": "AAwCO,MAAM,OAAO;AACb,MAAM,eAAe;AACrB,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,aAAa;AACnB,MAAM,WAAW;AACjB,MAAM,eAAe;AACrB,MAAM,cAAc;AACpB,MAAM,aAAa;AACnB,MAAM,YAAY;AAClB,MAAM,eAAe;AACrB,MAAM,SAAS;AACf,MAAM,SAAS;AACf,MAAM,mBAAmB;AAEzB,SAAS,WAAW,WAA6B;AACtD,SAAO,cAAc,eAAe,cAAc;AACpD;AAEO,SAAS,UAAU,WAA6B;AACrD,SAAO,cAAc,cAAc,cAAc;AACnD;AAEO,SAAS,SAAS,WAA6B;AACpD,SAAO,cAAc,aAAa,cAAc,YAAY,YAAY,SAAS;AACnF;AAEO,SAAS,YAAY,WAA6B;AACvD,SAAO,cAAc,gBAAgB,cAAc;AACrD;AAEO,SAAS,SAAS,WAA6B;AACpD,SAAO,cAAc;AACvB;AAEO,SAAS,kBAAkB,WAA6B;AAC7D,SAAO,cAAc,UAAU,cAAc;AAC/C;",
+  "names": []
+}

package/dist/esm/useResponderEvents.mjs

@@ -0,0 +1,45 @@
+import * as React from "react";
+import * as ResponderSystem from "./ResponderSystem";
+export * from "./utils";
+const emptyObject = {};
+function useResponderEvents(hostRef, config = emptyObject) {
+  const id = React.useId();
+  const isAttachedRef = React.useRef(false);
+  React.useEffect(() => {
+    ResponderSystem.attachListeners();
+    return () => {
+      ResponderSystem.removeNode(id);
+    };
+  }, [id]);
+  React.useEffect(() => {
+    const {
+      onMoveShouldSetResponder,
+      onMoveShouldSetResponderCapture,
+      onScrollShouldSetResponder,
+      onScrollShouldSetResponderCapture,
+      onSelectionChangeShouldSetResponder,
+      onSelectionChangeShouldSetResponderCapture,
+      onStartShouldSetResponder,
+      onStartShouldSetResponderCapture
+    } = config;
+    const requiresResponderSystem = onMoveShouldSetResponder != null || onMoveShouldSetResponderCapture != null || onScrollShouldSetResponder != null || onScrollShouldSetResponderCapture != null || onSelectionChangeShouldSetResponder != null || onSelectionChangeShouldSetResponderCapture != null || onStartShouldSetResponder != null || onStartShouldSetResponderCapture != null;
+    const node = hostRef.current;
+    if (requiresResponderSystem) {
+      ResponderSystem.addNode(id, node, config);
+      isAttachedRef.current = true;
+    } else if (isAttachedRef.current) {
+      ResponderSystem.removeNode(id);
+      isAttachedRef.current = false;
+    }
+  }, [config, hostRef, id]);
+  if (process.env.NODE_ENV === "development") {
+    React.useDebugValue({
+      isResponder: hostRef.current === ResponderSystem.getResponderNode()
+    });
+    React.useDebugValue(config);
+  }
+}
+export {
+  useResponderEvents
+};
+//# sourceMappingURL=useResponderEvents.mjs.map

package/dist/esm/useResponderEvents.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/useResponderEvents.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Nicolas Gallagher\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport * as React from 'react'\n\nimport * as ResponderSystem from './ResponderSystem'\n\nexport * from './utils'\n\nconst emptyObject = {}\n\nexport function useResponderEvents(\n  hostRef: any,\n  config: ResponderSystem.ResponderConfig = emptyObject,\n) {\n  const id = React.useId()\n  const isAttachedRef = React.useRef(false)\n\n  // This is a separate effects so it doesn't run when the config changes.\n  // On initial mount, attach global listeners if needed.\n  // On unmount, remove node potentially attached to the Responder System.\n  React.useEffect(() => {\n    ResponderSystem.attachListeners()\n    return () => {\n      ResponderSystem.removeNode(id)\n    }\n  }, [id])\n\n  // Register and unregister with the Responder System as necessary\n  React.useEffect(() => {\n    const {\n      onMoveShouldSetResponder,\n      onMoveShouldSetResponderCapture,\n      onScrollShouldSetResponder,\n      onScrollShouldSetResponderCapture,\n      onSelectionChangeShouldSetResponder,\n      onSelectionChangeShouldSetResponderCapture,\n      onStartShouldSetResponder,\n      onStartShouldSetResponderCapture,\n    } = config\n\n    const requiresResponderSystem =\n      onMoveShouldSetResponder != null ||\n      onMoveShouldSetResponderCapture != null ||\n      onScrollShouldSetResponder != null ||\n      onScrollShouldSetResponderCapture != null ||\n      onSelectionChangeShouldSetResponder != null ||\n      onSelectionChangeShouldSetResponderCapture != null ||\n      onStartShouldSetResponder != null ||\n      onStartShouldSetResponderCapture != null\n\n    const node = hostRef.current\n\n    if (requiresResponderSystem) {\n      ResponderSystem.addNode(id, node, config)\n      isAttachedRef.current = true\n    } else if (isAttachedRef.current) {\n      ResponderSystem.removeNode(id)\n      isAttachedRef.current = false\n    }\n  }, [config, hostRef, id])\n\n  if (process.env.NODE_ENV === 'development') {\n    React.useDebugValue({\n      isResponder: hostRef.current === ResponderSystem.getResponderNode(),\n    })\n    React.useDebugValue(config)\n  }\n}\n"],
+  "mappings": "AAMA,YAAY,WAAW;AAEvB,YAAY,qBAAqB;AAEjC,cAAc;AAEd,MAAM,cAAc,CAAC;AAEd,SAAS,mBACd,SACA,SAA0C,aAC1C;AACA,QAAM,KAAK,MAAM,MAAM;AACvB,QAAM,gBAAgB,MAAM,OAAO,KAAK;AAKxC,QAAM,UAAU,MAAM;AACpB,oBAAgB,gBAAgB;AAChC,WAAO,MAAM;AACX,sBAAgB,WAAW,EAAE;AAAA,IAC/B;AAAA,EACF,GAAG,CAAC,EAAE,CAAC;AAGP,QAAM,UAAU,MAAM;AACpB,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,UAAM,0BACJ,4BAA4B,QAC5B,mCAAmC,QACnC,8BAA8B,QAC9B,qCAAqC,QACrC,uCAAuC,QACvC,8CAA8C,QAC9C,6BAA6B,QAC7B,oCAAoC;AAEtC,UAAM,OAAO,QAAQ;AAErB,QAAI,yBAAyB;AAC3B,sBAAgB,QAAQ,IAAI,MAAM,MAAM;AACxC,oBAAc,UAAU;AAAA,IAC1B,WAAW,cAAc,SAAS;AAChC,sBAAgB,WAAW,EAAE;AAC7B,oBAAc,UAAU;AAAA,IAC1B;AAAA,EACF,GAAG,CAAC,QAAQ,SAAS,EAAE,CAAC;AAExB,MAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,UAAM,cAAc;AAAA,MAClB,aAAa,QAAQ,YAAY,gBAAgB,iBAAiB;AAAA,IACpE,CAAC;AACD,UAAM,cAAc,MAAM;AAAA,EAC5B;AACF;",
+  "names": []
+}

package/dist/esm/utils.mjs

@@ -0,0 +1,142 @@
+const keyName = "__reactResponderId";
+const canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+const getBoundingClientRect = (node) => {
+  if (!node)
+    return;
+  if (node.nodeType !== 1)
+    return;
+  if (node.getBoundingClientRect) {
+    return node.getBoundingClientRect();
+  }
+};
+function getEventPath(domEvent) {
+  var _a;
+  if (domEvent.type === "selectionchange") {
+    const target = (_a = window.getSelection()) == null ? void 0 : _a.anchorNode;
+    return composedPathFallback(target);
+  } else {
+    const path = domEvent.composedPath != null ? domEvent.composedPath() : composedPathFallback(domEvent.target);
+    return path;
+  }
+}
+function composedPathFallback(target) {
+  const path = [];
+  while (target != null && target !== document.body) {
+    path.push(target);
+    target = target.parentNode;
+  }
+  return path;
+}
+function getResponderId(node) {
+  if (node != null) {
+    return node[keyName];
+  }
+  return null;
+}
+function setResponderId(node, id) {
+  if (node != null) {
+    node[keyName] = id;
+  }
+}
+function getResponderPaths(domEvent) {
+  const idPath = [];
+  const nodePath = [];
+  const eventPath = getEventPath(domEvent);
+  for (let i = 0; i < eventPath.length; i++) {
+    const node = eventPath[i];
+    const id = getResponderId(node);
+    if (id != null) {
+      idPath.push(id);
+      nodePath.push(node);
+    }
+  }
+  return { idPath, nodePath };
+}
+function getLowestCommonAncestor(pathA, pathB) {
+  let pathALength = pathA.length;
+  let pathBLength = pathB.length;
+  if (
+    // If either path is empty
+    pathALength === 0 || pathBLength === 0 || // If the last elements aren't the same there can't be a common ancestor
+    // that is connected to the responder system
+    pathA[pathALength - 1] !== pathB[pathBLength - 1]
+  ) {
+    return null;
+  }
+  let itemA = pathA[0];
+  let indexA = 0;
+  let itemB = pathB[0];
+  let indexB = 0;
+  if (pathALength - pathBLength > 0) {
+    indexA = pathALength - pathBLength;
+    itemA = pathA[indexA];
+    pathALength = pathBLength;
+  }
+  if (pathBLength - pathALength > 0) {
+    indexB = pathBLength - pathALength;
+    itemB = pathB[indexB];
+    pathBLength = pathALength;
+  }
+  let depth = pathALength;
+  while (depth--) {
+    if (itemA === itemB) {
+      return itemA;
+    }
+    itemA = pathA[indexA++];
+    itemB = pathB[indexB++];
+  }
+  return null;
+}
+function hasTargetTouches(target, touches) {
+  if (!touches || touches.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < touches.length; i++) {
+    const node = touches[i].target;
+    if (node != null) {
+      if (target.contains(node)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasValidSelection(domEvent) {
+  if (domEvent.type === "selectionchange") {
+    return isSelectionValid();
+  }
+  return domEvent.type === "select";
+}
+function isPrimaryPointerDown(domEvent) {
+  const { altKey, button, buttons, ctrlKey, type } = domEvent;
+  const isTouch = type === "touchstart" || type === "touchmove";
+  const isPrimaryMouseDown = type === "mousedown" && (button === 0 || buttons === 1);
+  const isPrimaryMouseMove = type === "mousemove" && buttons === 1;
+  const noModifiers = altKey === false && ctrlKey === false;
+  if (isTouch || isPrimaryMouseDown && noModifiers || isPrimaryMouseMove && noModifiers) {
+    return true;
+  }
+  return false;
+}
+function isSelectionValid() {
+  const selection = window.getSelection();
+  if (!selection)
+    return false;
+  const string = selection.toString();
+  const anchorNode = selection.anchorNode;
+  const focusNode = selection.focusNode;
+  const isTextNode = anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE || focusNode && focusNode.nodeType === window.Node.TEXT_NODE;
+  return string.length >= 1 && string !== "\n" && !!isTextNode;
+}
+export {
+  canUseDOM,
+  getBoundingClientRect,
+  getLowestCommonAncestor,
+  getResponderPaths,
+  hasTargetTouches,
+  hasValidSelection,
+  isPrimaryPointerDown,
+  isSelectionValid,
+  setResponderId
+};
+//# sourceMappingURL=utils.mjs.map

package/dist/esm/utils.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Nicolas Gallagher\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nconst keyName = '__reactResponderId'\n\nexport const canUseDOM = !!(\n  typeof window !== 'undefined' &&\n  window.document &&\n  window.document.createElement\n)\n\nexport const getBoundingClientRect = (node: HTMLElement | null): void | DOMRect => {\n  if (!node) return\n  if (node.nodeType !== 1) return\n  if (node.getBoundingClientRect) {\n    return node.getBoundingClientRect()\n  }\n}\n\nfunction getEventPath(domEvent: any): Array<any> {\n  // The 'selectionchange' event always has the 'document' as the target.\n  // Use the anchor node as the initial target to reconstruct a path.\n  // (We actually only need the first \"responder\" node in practice.)\n  if (domEvent.type === 'selectionchange') {\n    const target = window.getSelection()?.anchorNode\n    return composedPathFallback(target)\n  } else {\n    const path =\n      domEvent.composedPath != null\n        ? domEvent.composedPath()\n        : composedPathFallback(domEvent.target)\n    return path\n  }\n}\n\nfunction composedPathFallback(target: any): Array<any> {\n  const path: any[] = []\n  while (target != null && target !== document.body) {\n    path.push(target)\n    target = target.parentNode\n  }\n  return path\n}\n\n/**\n * Retrieve the responderId from a host node\n */\nfunction getResponderId(node: any): number | null {\n  if (node != null) {\n    return node[keyName]\n  }\n  return null\n}\n\n/**\n * Store the responderId on a host node\n */\nexport function setResponderId(node: any, id: any) {\n  if (node != null) {\n    node[keyName] = id\n  }\n}\n\n/**\n * Filter the event path to contain only the nodes attached to the responder system\n */\nexport function getResponderPaths(domEvent: any): {\n  idPath: Array<number>\n  nodePath: Array<any>\n} {\n  const idPath: any[] = []\n  const nodePath: any[] = []\n  const eventPath = getEventPath(domEvent)\n  for (let i = 0; i < eventPath.length; i++) {\n    const node = eventPath[i]\n    const id = getResponderId(node)\n    if (id != null) {\n      idPath.push(id)\n      nodePath.push(node)\n    }\n  }\n  return { idPath, nodePath }\n}\n\n/**\n * Walk the paths and find the first common ancestor\n */\nexport function getLowestCommonAncestor(pathA: Array<any>, pathB: Array<any>): any {\n  let pathALength = pathA.length\n  let pathBLength = pathB.length\n  if (\n    // If either path is empty\n    pathALength === 0 ||\n    pathBLength === 0 ||\n    // If the last elements aren't the same there can't be a common ancestor\n    // that is connected to the responder system\n    pathA[pathALength - 1] !== pathB[pathBLength - 1]\n  ) {\n    return null\n  }\n\n  let itemA = pathA[0]\n  let indexA = 0\n  let itemB = pathB[0]\n  let indexB = 0\n\n  // If A is deeper, skip indices that can't match.\n  if (pathALength - pathBLength > 0) {\n    indexA = pathALength - pathBLength\n    itemA = pathA[indexA]\n    pathALength = pathBLength\n  }\n\n  // If B is deeper, skip indices that can't match\n  if (pathBLength - pathALength > 0) {\n    indexB = pathBLength - pathALength\n    itemB = pathB[indexB]\n    pathBLength = pathALength\n  }\n\n  // Walk in lockstep until a match is found\n  let depth = pathALength\n  while (depth--) {\n    if (itemA === itemB) {\n      return itemA\n    }\n    itemA = pathA[indexA++]\n    itemB = pathB[indexB++]\n  }\n  return null\n}\n\n/**\n * Determine whether any of the active touches are within the current responder.\n * This cannot rely on W3C `targetTouches`, as neither IE11 nor Safari implement it.\n */\nexport function hasTargetTouches(target: any, touches: any): boolean {\n  if (!touches || touches.length === 0) {\n    return false\n  }\n  for (let i = 0; i < touches.length; i++) {\n    const node = touches[i].target\n    if (node != null) {\n      if (target.contains(node)) {\n        return true\n      }\n    }\n  }\n  return false\n}\n\n/**\n * Ignore 'selectionchange' events that don't correspond with a person's intent to\n * select text.\n */\nexport function hasValidSelection(domEvent: any): boolean {\n  if (domEvent.type === 'selectionchange') {\n    return isSelectionValid()\n  }\n  return domEvent.type === 'select'\n}\n\n/**\n * Events are only valid if the primary button was used without specific modifier keys.\n */\nexport function isPrimaryPointerDown(domEvent: any): boolean {\n  const { altKey, button, buttons, ctrlKey, type } = domEvent\n  const isTouch = type === 'touchstart' || type === 'touchmove'\n  const isPrimaryMouseDown = type === 'mousedown' && (button === 0 || buttons === 1)\n  const isPrimaryMouseMove = type === 'mousemove' && buttons === 1\n  const noModifiers = altKey === false && ctrlKey === false\n\n  if (\n    isTouch ||\n    (isPrimaryMouseDown && noModifiers) ||\n    (isPrimaryMouseMove && noModifiers)\n  ) {\n    return true\n  }\n  return false\n}\n\nexport function isSelectionValid(): boolean {\n  const selection = window.getSelection()\n  if (!selection) return false\n  const string = selection.toString()\n  const anchorNode = selection.anchorNode\n  const focusNode = selection.focusNode\n  const isTextNode =\n    (anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE) ||\n    (focusNode && focusNode.nodeType === window.Node.TEXT_NODE)\n  return string.length >= 1 && string !== '\\n' && !!isTextNode\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/react-native-use-responder-events",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
   "module": "dist/esm",
@@ -21,7 +21,7 @@
     "react": "^18.2.0"
   },
   "devDependencies": {
-    "@tamagui/build": "^1.2.8",
+    "@tamagui/build": "^1.2.10",
     "@types/react": "^18.0.15"
   },
   "publishConfig": {