@tamagui/react-native-use-responder-events 2.0.0-rc.4 → 2.0.0-rc.40

package/dist/cjs/ResponderSystem.cjs

@@ -3,20 +3,22 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var ResponderSystem_exports = {};
 __export(ResponderSystem_exports, {
@@ -27,117 +29,191 @@ __export(ResponderSystem_exports, {
   terminateResponder: () => terminateResponder
 });
 module.exports = __toCommonJS(ResponderSystem_exports);
-var import_createResponderEvent = require("./createResponderEvent.cjs"),
-  import_ResponderTouchHistoryStore = require("./ResponderTouchHistoryStore.cjs"),
-  import_types = require("./types.cjs"),
-  import_utils = require("./utils.cjs"),
-  import_utils2 = require("./utils.cjs");
-const emptyObject = {},
-  startRegistration = ["onStartShouldSetResponderCapture", "onStartShouldSetResponder", {
-    bubbles: !0
-  }],
-  moveRegistration = ["onMoveShouldSetResponderCapture", "onMoveShouldSetResponder", {
-    bubbles: !0
-  }],
-  scrollRegistration = ["onScrollShouldSetResponderCapture", "onScrollShouldSetResponder", {
-    bubbles: !1
-  }],
-  shouldSetResponderEvents = {
-    touchstart: startRegistration,
-    mousedown: startRegistration,
-    touchmove: moveRegistration,
-    mousemove: moveRegistration,
-    scroll: scrollRegistration
-  },
-  emptyResponder = {
-    id: null,
-    idPath: null,
-    node: null
-  },
-  responderListenersMap = /* @__PURE__ */new Map();
-let isEmulatingMouseEvents = !1,
-  trackedTouchCount = 0,
-  currentResponder = {
-    id: null,
-    node: null,
-    idPath: null
-  };
+var import_createResponderEvent = require("./createResponderEvent.cjs");
+var import_ResponderTouchHistoryStore = require("./ResponderTouchHistoryStore.cjs");
+var import_types = require("./types.cjs");
+var import_utils = require("./utils.cjs");
+var import_utils2 = require("./utils.cjs");
+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 import_ResponderTouchHistoryStore.ResponderTouchHistoryStore();
 function changeCurrentResponder(responder) {
   currentResponder = responder;
 }
 function getResponderConfig(id) {
   const config = responderListenersMap.get(id);
-  return config ?? emptyObject;
+  return config != null ? config : emptyObject;
 }
 function eventListener(domEvent) {
-  const eventType = domEvent.type,
-    eventTarget = domEvent.target;
-  if (eventType === "touchstart" && (isEmulatingMouseEvents = !0), (eventType === "touchmove" || trackedTouchCount > 1) && (isEmulatingMouseEvents = !1),
+  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;
+  eventType === "mousemove" && trackedTouchCount < 1) {
+    return;
+  }
   if (isEmulatingMouseEvents && eventType === "mouseup") {
-    trackedTouchCount === 0 && (isEmulatingMouseEvents = !1);
+    if (trackedTouchCount === 0) {
+      isEmulatingMouseEvents = false;
+    }
     return;
   }
-  const isStartEvent = (0, import_types.isStartish)(eventType) && (0, import_utils2.isPrimaryPointerDown)(domEvent),
-    isMoveEvent = (0, import_types.isMoveish)(eventType),
-    isEndEvent = (0, import_types.isEndish)(eventType),
-    isScrollEvent = (0, import_types.isScroll)(eventType),
-    isSelectionChangeEvent = (0, import_types.isSelectionChange)(eventType),
-    responderEvent = (0, import_createResponderEvent.createResponderEvent)(domEvent, responderTouchHistoryStore);
-  (isStartEvent || isMoveEvent || isEndEvent) && (domEvent.touches ? trackedTouchCount = domEvent.touches.length : isStartEvent ? trackedTouchCount = 1 : isEndEvent && (trackedTouchCount = 0), responderTouchHistoryStore.recordTouchTrack(eventType, responderEvent.nativeEvent));
-  let eventPaths = (0, import_utils2.getResponderPaths)(domEvent),
-    wasNegotiated = !1,
-    wantsResponder;
+  const isStartEvent = (0, import_types.isStartish)(eventType) && (0, import_utils2.isPrimaryPointerDown)(domEvent);
+  const isMoveEvent = (0, import_types.isMoveish)(eventType);
+  const isEndEvent = (0, import_types.isEndish)(eventType);
+  const isScrollEvent = (0, import_types.isScroll)(eventType);
+  const isSelectionChangeEvent = (0, import_types.isSelectionChange)(eventType);
+  const responderEvent = (0, import_createResponderEvent.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 = (0, import_utils2.getResponderPaths)(domEvent);
+  let wasNegotiated = false;
+  let wantsResponder;
   if (isStartEvent || isMoveEvent || isScrollEvent && trackedTouchCount > 0) {
-    const currentResponderIdPath = currentResponder.idPath,
-      eventIdPath = eventPaths.idPath;
+    const currentResponderIdPath = currentResponder.idPath;
+    const eventIdPath = eventPaths.idPath;
     if (currentResponderIdPath != null && eventIdPath != null) {
       const lowestCommonAncestor = (0, import_utils2.getLowestCommonAncestor)(currentResponderIdPath, eventIdPath);
       if (lowestCommonAncestor != null) {
-        const index = eventIdPath.indexOf(lowestCommonAncestor) + (lowestCommonAncestor === currentResponder.id ? 1 : 0);
+        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;
+      } else {
+        eventPaths = null;
+      }
+    }
+    if (eventPaths != null) {
+      wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent);
+      if (wantsResponder != null) {
+        attemptTransfer(responderEvent, wantsResponder);
+        wasNegotiated = true;
+      }
     }
-    eventPaths != null && (wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent), wantsResponder != null && (attemptTransfer(responderEvent, wantsResponder), wasNegotiated = !0));
   }
   if (currentResponder.id != null && currentResponder.node != null) {
     const {
-        id,
-        node
-      } = currentResponder,
-      {
-        onResponderStart,
-        onResponderMove,
-        onResponderEnd,
-        onResponderRelease,
-        onResponderTerminate,
-        onResponderTerminationRequest
-      } = getResponderConfig(id);
-    if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, isStartEvent) onResponderStart != null && (responderEvent.dispatchConfig.registrationName = "onResponderStart", onResponderStart(responderEvent));else if (isMoveEvent) onResponderMove != null && (responderEvent.dispatchConfig.registrationName = "onResponderMove", onResponderMove(responderEvent));else {
+      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 = (0, import_types.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 && (0, import_utils2.hasValidSelection)(domEvent),
-        isReleaseEvent = isEndEvent && !isTerminateEvent && !(0, import_utils2.hasTargetTouches)(node, domEvent.touches);
-      if (isEndEvent && onResponderEnd != null && (responderEvent.dispatchConfig.registrationName = "onResponderEnd", onResponderEnd(responderEvent)), isReleaseEvent && (onResponderRelease != null && (responderEvent.dispatchConfig.registrationName = "onResponderRelease", onResponderRelease(responderEvent)), changeCurrentResponder(emptyResponder)), isTerminateEvent) {
-        let shouldTerminate = !0;
-        (eventType === "contextmenu" || eventType === "scroll" || eventType === "selectionchange") && (wasNegotiated ? shouldTerminate = !1 : onResponderTerminationRequest != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (shouldTerminate = !1))), shouldTerminate && (onResponderTerminate != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), changeCurrentResponder(emptyResponder), isEmulatingMouseEvents = !1, trackedTouchCount = 0);
+      // 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 && (0, import_utils2.hasValidSelection)(domEvent);
+      const isReleaseEvent = isEndEvent && !isTerminateEvent && !(0, import_utils2.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;
+        }
       }
     }
   }
@@ -146,17 +222,20 @@ function findWantsResponder(eventPaths, domEvent, responderEvent) {
   const shouldSetCallbacks = shouldSetResponderEvents[domEvent.type];
   if (shouldSetCallbacks != null) {
     const {
-        idPath,
-        nodePath
-      } = eventPaths,
-      shouldSetCallbackCaptureName = shouldSetCallbacks[0],
-      shouldSetCallbackBubbleName = shouldSetCallbacks[1],
-      {
-        bubbles
-      } = shouldSetCallbacks[2],
-      check = (id, node, callbackName) => {
-        const shouldSetCallback = getResponderConfig(id)[callbackName];
-        if (shouldSetCallback != null && (responderEvent.currentTarget = node, shouldSetCallback(responderEvent) === !0)) {
+      idPath,
+      nodePath
+    } = eventPaths;
+    const shouldSetCallbackCaptureName = shouldSetCallbacks[0];
+    const shouldSetCallbackBubbleName = shouldSetCallbacks[1];
+    const {
+      bubbles
+    } = shouldSetCallbacks[2];
+    const check = (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,
@@ -164,70 +243,130 @@ function findWantsResponder(eventPaths, domEvent, responderEvent) {
             idPath: prunedIdPath
           };
         }
-      };
+      }
+    };
     for (let i = idPath.length - 1; i >= 0; i--) {
-      const id = idPath[i],
-        node = nodePath[i],
-        result = check(id, node, shouldSetCallbackCaptureName);
-      if (result != null) return result;
-      if (responderEvent.isPropagationStopped() === !0) return;
+      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],
-        node = nodePath[i],
-        result = check(id, node, shouldSetCallbackBubbleName);
-      if (result != null) return result;
-      if (responderEvent.isPropagationStopped() === !0) 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],
-        node = nodePath[0];
-      if (domEvent.target === node) return check(id, node, shouldSetCallbackBubbleName);
+      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,
-    {
-      id,
-      node
-    } = wantsResponder,
-    {
-      onResponderGrant,
-      onResponderReject
-    } = getResponderConfig(id);
-  if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, currentId == null) onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder);else {
+    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 = !0;
-    onResponderTerminationRequest != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (allowTransfer = !1)), allowTransfer ? (onResponderTerminate != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder)) : onResponderReject != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderReject", onResponderReject(responderEvent));
+    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"],
-  documentEventsBubblePhase = [
-  // mouse
-  "mousedown", "mousemove", "mouseup", "dragstart",
-  // touch
-  "touchstart", "touchmove", "touchend", "touchcancel",
-  // other
-  "contextmenu", "select", "selectionchange"],
-  isTamaguiResponderActive = /* @__PURE__ */Symbol();
+const documentEventsCapturePhase = ["blur", "scroll"];
+const documentEventsBubblePhase = [
+// mouse
+"mousedown", "mousemove", "mouseup", "dragstart",
+// touch
+"touchstart", "touchmove", "touchend", "touchcancel",
+// other
+"contextmenu", "select", "selectionchange"];
+const isTamaguiResponderActive = /* @__PURE__ */Symbol();
 function attachListeners() {
-  import_utils.canUseDOM && !window[isTamaguiResponderActive] && (window.addEventListener("blur", eventListener), documentEventsBubblePhase.forEach(eventType => {
-    document.addEventListener(eventType, eventListener);
-  }), documentEventsCapturePhase.forEach(eventType => {
-    document.addEventListener(eventType, eventListener, !0);
-  }), window[isTamaguiResponderActive] = !0);
+  if (import_utils.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) {
-  (0, import_utils2.setResponderId)(node, id), responderListenersMap.set(id, config);
+  (0, import_utils2.setResponderId)(node, id);
+  responderListenersMap.set(id, config);
 }
 function removeNode(id) {
-  currentResponder.id === id && terminateResponder(), responderListenersMap.has(id) && responderListenersMap.delete(id);
+  if (currentResponder.id === id) {
+    terminateResponder();
+  }
+  if (responderListenersMap.has(id)) {
+    responderListenersMap.delete(id);
+  }
 }
 function terminateResponder() {
   const {
@@ -240,11 +379,13 @@ function terminateResponder() {
     } = getResponderConfig(id);
     if (onResponderTerminate != null) {
       const event = (0, import_createResponderEvent.createResponderEvent)({}, responderTouchHistoryStore);
-      event.currentTarget = node, onResponderTerminate(event);
+      event.currentTarget = node;
+      onResponderTerminate(event);
     }
     changeCurrentResponder(emptyResponder);
   }
-  isEmulatingMouseEvents = !1, trackedTouchCount = 0;
+  isEmulatingMouseEvents = false;
+  trackedTouchCount = 0;
 }
 function getResponderNode() {
   return currentResponder.node;