@tamagui/react-native-use-responder-events 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/ResponderSystem.native.cjs

@@ -0,0 +1,357 @@
+"use strict";
+
+
+var __defProp = Object.defineProperty;
+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: 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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ResponderSystem_exports = {};
+__export(ResponderSystem_exports, {
+	addNode: () => addNode,
+	attachListeners: () => attachListeners,
+	getResponderNode: () => getResponderNode,
+	removeNode: () => removeNode,
+	terminateResponder: () => terminateResponder
+});
+module.exports = __toCommonJS(ResponderSystem_exports);
+var import_createResponderEvent = require("./createResponderEvent.native.js");
+var import_ResponderTouchHistoryStore = require("./ResponderTouchHistoryStore.native.js");
+var import_types = require("./types.native.js");
+var import_utils = require("./utils.native.js");
+var import_utils2 = require("./utils.native.js");
+var emptyObject = {};
+var startRegistration = [
+	"onStartShouldSetResponderCapture",
+	"onStartShouldSetResponder",
+	{ bubbles: true }
+];
+var moveRegistration = [
+	"onMoveShouldSetResponderCapture",
+	"onMoveShouldSetResponder",
+	{ bubbles: true }
+];
+var scrollRegistration = [
+	"onScrollShouldSetResponderCapture",
+	"onScrollShouldSetResponder",
+	{ bubbles: false }
+];
+var shouldSetResponderEvents = {
+	touchstart: startRegistration,
+	mousedown: startRegistration,
+	touchmove: moveRegistration,
+	mousemove: moveRegistration,
+	scroll: scrollRegistration
+};
+var emptyResponder = {
+	id: null,
+	idPath: null,
+	node: null
+};
+var responderListenersMap = /* @__PURE__ */ new Map();
+var isEmulatingMouseEvents = false;
+var trackedTouchCount = 0;
+var currentResponder = {
+	id: null,
+	node: null,
+	idPath: null
+};
+var responderTouchHistoryStore = new import_ResponderTouchHistoryStore.ResponderTouchHistoryStore();
+function changeCurrentResponder(responder) {
+	currentResponder = responder;
+}
+function getResponderConfig(id) {
+	var config = responderListenersMap.get(id);
+	return config != null ? config : emptyObject;
+}
+function eventListener(domEvent) {
+	var eventType = domEvent.type;
+	var eventTarget = domEvent.target;
+	if (eventType === "touchstart") {
+		isEmulatingMouseEvents = true;
+	}
+	if (eventType === "touchmove" || trackedTouchCount > 1) {
+		isEmulatingMouseEvents = false;
+	}
+	if (eventType === "mousedown" && isEmulatingMouseEvents || eventType === "mousemove" && isEmulatingMouseEvents || eventType === "mousemove" && trackedTouchCount < 1) {
+		return;
+	}
+	if (isEmulatingMouseEvents && eventType === "mouseup") {
+		if (trackedTouchCount === 0) {
+			isEmulatingMouseEvents = false;
+		}
+		return;
+	}
+	var isStartEvent = (0, import_types.isStartish)(eventType) && (0, import_utils2.isPrimaryPointerDown)(domEvent);
+	var isMoveEvent = (0, import_types.isMoveish)(eventType);
+	var isEndEvent = (0, import_types.isEndish)(eventType);
+	var isScrollEvent = (0, import_types.isScroll)(eventType);
+	var isSelectionChangeEvent = (0, import_types.isSelectionChange)(eventType);
+	var 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);
+	}
+	var eventPaths = (0, import_utils2.getResponderPaths)(domEvent);
+	var wasNegotiated = false;
+	var wantsResponder;
+	if (isStartEvent || isMoveEvent || isScrollEvent && trackedTouchCount > 0) {
+		var currentResponderIdPath = currentResponder.idPath;
+		var eventIdPath = eventPaths.idPath;
+		if (currentResponderIdPath != null && eventIdPath != null) {
+			var lowestCommonAncestor = (0, import_utils2.getLowestCommonAncestor)(currentResponderIdPath, eventIdPath);
+			if (lowestCommonAncestor != null) {
+				var indexOfLowestCommonAncestor = eventIdPath.indexOf(lowestCommonAncestor);
+				var 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) {
+		var { id, node } = currentResponder;
+		var { 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 {
+			var isTerminateEvent = (0, import_types.isCancelish)(eventType) || eventType === "contextmenu" || eventType === "blur" && eventTarget === window || eventType === "blur" && eventTarget.contains(node) && domEvent.relatedTarget !== node || isScrollEvent && trackedTouchCount === 0 || isScrollEvent && eventTarget.contains(node) && eventTarget !== node || isSelectionChangeEvent && (0, import_utils2.hasValidSelection)(domEvent);
+			var 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) {
+				var 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) {
+	var shouldSetCallbacks = shouldSetResponderEvents[domEvent.type];
+	if (shouldSetCallbacks != null) {
+		var { idPath, nodePath } = eventPaths;
+		var shouldSetCallbackCaptureName = shouldSetCallbacks[0];
+		var shouldSetCallbackBubbleName = shouldSetCallbacks[1];
+		var { bubbles } = shouldSetCallbacks[2];
+		var check = function(id3, node3, callbackName) {
+			var config = getResponderConfig(id3);
+			var shouldSetCallback = config[callbackName];
+			if (shouldSetCallback != null) {
+				responderEvent.currentTarget = node3;
+				if (shouldSetCallback(responderEvent) === true) {
+					var prunedIdPath = idPath.slice(idPath.indexOf(id3));
+					return {
+						id: id3,
+						node: node3,
+						idPath: prunedIdPath
+					};
+				}
+			}
+		};
+		for (var i = idPath.length - 1; i >= 0; i--) {
+			var id = idPath[i];
+			var node = nodePath[i];
+			var result = check(id, node, shouldSetCallbackCaptureName);
+			if (result != null) {
+				return result;
+			}
+			if (responderEvent.isPropagationStopped() === true) {
+				return;
+			}
+		}
+		if (bubbles) {
+			for (var i1 = 0; i1 < idPath.length; i1++) {
+				var id1 = idPath[i1];
+				var node1 = nodePath[i1];
+				var result1 = check(id1, node1, shouldSetCallbackBubbleName);
+				if (result1 != null) {
+					return result1;
+				}
+				if (responderEvent.isPropagationStopped() === true) {
+					return;
+				}
+			}
+		} else {
+			var id2 = idPath[0];
+			var node2 = nodePath[0];
+			var target = domEvent.target;
+			if (target === node2) {
+				return check(id2, node2, shouldSetCallbackBubbleName);
+			}
+		}
+	}
+}
+function attemptTransfer(responderEvent, wantsResponder) {
+	var { id: currentId, node: currentNode } = currentResponder;
+	var { id, node } = wantsResponder;
+	var { 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 {
+		var { onResponderTerminate, onResponderTerminationRequest } = getResponderConfig(currentId);
+		var 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);
+			}
+		}
+	}
+}
+var documentEventsCapturePhase = ["blur", "scroll"];
+var documentEventsBubblePhase = [
+	"mousedown",
+	"mousemove",
+	"mouseup",
+	"dragstart",
+	"touchstart",
+	"touchmove",
+	"touchend",
+	"touchcancel",
+	"contextmenu",
+	"select",
+	"selectionchange"
+];
+var isTamaguiResponderActive = /* @__PURE__ */ Symbol();
+function attachListeners() {
+	if (import_utils.canUseDOM && !window[isTamaguiResponderActive]) {
+		window.addEventListener("blur", eventListener);
+		documentEventsBubblePhase.forEach(function(eventType) {
+			document.addEventListener(eventType, eventListener);
+		});
+		documentEventsCapturePhase.forEach(function(eventType) {
+			document.addEventListener(eventType, eventListener, true);
+		});
+		window[isTamaguiResponderActive] = true;
+	}
+}
+function addNode(id, node, config) {
+	(0, import_utils2.setResponderId)(node, id);
+	responderListenersMap.set(id, config);
+}
+function removeNode(id) {
+	if (currentResponder.id === id) {
+		terminateResponder();
+	}
+	if (responderListenersMap.has(id)) {
+		responderListenersMap.delete(id);
+	}
+}
+function terminateResponder() {
+	var { id, node } = currentResponder;
+	if (id != null && node != null) {
+		var { onResponderTerminate } = getResponderConfig(id);
+		if (onResponderTerminate != null) {
+			var event = (0, import_createResponderEvent.createResponderEvent)({}, responderTouchHistoryStore);
+			event.currentTarget = node;
+			onResponderTerminate(event);
+		}
+		changeCurrentResponder(emptyResponder);
+	}
+	isEmulatingMouseEvents = false;
+	trackedTouchCount = 0;
+}
+function getResponderNode() {
+	return currentResponder.node;
+}