mirror of
https://github.com/facebook/react-native.git
synced 2025-11-01 09:14:26 +00:00
RN: Open Source Pressability
Summary: Makes `Pressability` available the open source `react-native` repository. This abstraction is intended to replace `Touchable.Mixin` and enable us to finally stop depending on `createReactClass` (et al). Changelog: [Internal] Reviewed By: TheSavior Differential Revision: D18715853 fbshipit-source-id: 21af8652cfb4557c60babd31b2776bcaeaed8447
This commit is contained in:
1 parent
8c0c860e38
commit
c5cc181c7e
4 files changed
+1627
No files matched your search
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @flow strict-local
|
||||
* @format
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import {Platform} from 'react-native';
|
||||
|
||||
let isEnabled = false;
|
||||
|
||||
if (Platform.OS === 'web') {
|
||||
const canUseDOM = Boolean(
|
||||
typeof window !== 'undefined' &&
|
||||
window.document &&
|
||||
window.document.createElement,
|
||||
);
|
||||
|
||||
if (canUseDOM) {
|
||||
/**
|
||||
* Web browsers emulate mouse events (and hover states) after touch events.
|
||||
* This code infers when the currently-in-use modality supports hover
|
||||
* (including for multi-modality devices) and considers "hover" to be enabled
|
||||
* if a mouse movement occurs more than 1 second after the last touch event.
|
||||
* This threshold is long enough to account for longer delays between the
|
||||
* browser firing touch and mouse events on low-powered devices.
|
||||
*/
|
||||
const HOVER_THRESHOLD_MS = 1000;
|
||||
let lastTouchTimestamp = 0;
|
||||
|
||||
const enableHover = () => {
|
||||
if (isEnabled || Date.now() - lastTouchTimestamp < HOVER_THRESHOLD_MS) {
|
||||
return;
|
||||
}
|
||||
isEnabled = true;
|
||||
};
|
||||
|
||||
const disableHover = () => {
|
||||
lastTouchTimestamp = Date.now();
|
||||
if (isEnabled) {
|
||||
isEnabled = false;
|
||||
}
|
||||
};
|
||||
|
||||
document.addEventListener('touchstart', disableHover, true);
|
||||
document.addEventListener('touchmove', disableHover, true);
|
||||
document.addEventListener('mousemove', enableHover, true);
|
||||
}
|
||||
}
|
||||
|
||||
export function isHoverEnabled(): boolean {
|
||||
return isEnabled;
|
||||
}
|
||||
@@ -0,0 +1,834 @@
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @flow strict-local
|
||||
* @format
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import {isHoverEnabled} from './HoverState.js';
|
||||
import invariant from 'invariant';
|
||||
import SoundManager from '../Components/Sound/SoundManager.js';
|
||||
import type {EdgeInsetsProp} from '../StyleSheet/EdgeInsetsPropType.js';
|
||||
import type {
|
||||
BlurEvent,
|
||||
FocusEvent,
|
||||
PressEvent,
|
||||
MouseEvent,
|
||||
} from '../Types/CoreEventTypes.js';
|
||||
import {type HostComponent, Platform, UIManager} from 'react-native';
|
||||
import * as React from 'react';
|
||||
|
||||
export type PressabilityConfig = $ReadOnly<{|
|
||||
/**
|
||||
* Returns the amount to extend the `VisualRect` by to create `HitRect`.
|
||||
*/
|
||||
getHitSlop?: ?() => ?EdgeInsetsProp,
|
||||
|
||||
/**
|
||||
* Returns the duration to wait after hover in before activation.
|
||||
*/
|
||||
getHoverInDelayMS?: ?() => ?number,
|
||||
|
||||
/**
|
||||
* Returns the duration to wait after hover out before deactivation.
|
||||
*/
|
||||
getHoverOutDelayMS?: ?() => ?number,
|
||||
|
||||
/**
|
||||
* Returns the duration (in addition to the value from `getPressDelayMS`)
|
||||
* after which a press gesture becomes a long press gesture.
|
||||
*/
|
||||
getLongPressDelayMS?: ?() => ?number,
|
||||
|
||||
/**
|
||||
* Returns the duration to wait after press down before activation.
|
||||
*/
|
||||
getPressDelayMS?: ?() => ?number,
|
||||
|
||||
/**
|
||||
* Returns the duration to wait after letting up before deactivation.
|
||||
*/
|
||||
getPressOutDelayMS?: ?() => ?number,
|
||||
|
||||
/**
|
||||
* Returns the amount to extend the `HitRect` by to create `PressRect`.
|
||||
*/
|
||||
getPressRectOffset?: ?() => ?EdgeInsetsProp,
|
||||
|
||||
/**
|
||||
* Returns true to disable playing system sound on touch (Android Only)
|
||||
**/
|
||||
getTouchSoundDisabled?: ?() => ?boolean,
|
||||
|
||||
/**
|
||||
* Called after the element loses focus.
|
||||
*/
|
||||
onBlur?: ?(event: BlurEvent) => void,
|
||||
|
||||
/**
|
||||
* Called after the element is focused.
|
||||
*/
|
||||
onFocus?: ?(event: FocusEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when the hover is activated to provide visual feedback.
|
||||
*/
|
||||
onHoverIn?: ?(event: MouseEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when the hover is deactivated to undo visual feedback.
|
||||
*/
|
||||
onHoverOut?: ?(event: MouseEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when a long press gesture has been triggered.
|
||||
*/
|
||||
onLongPress?: ?(event: PressEvent) => void,
|
||||
|
||||
/**
|
||||
* Returns whether a long press gesture should cancel the press gesture.
|
||||
* Defaults to true.
|
||||
*/
|
||||
onLongPressShouldCancelPress?: ?() => boolean,
|
||||
|
||||
/**
|
||||
* Called when a press gestute has been triggered.
|
||||
*/
|
||||
onPress?: ?(event: PressEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when the press is activated to provide visual feedback.
|
||||
*/
|
||||
onPressIn?: ?(event: PressEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when the press location moves. (This should rarely be used.)
|
||||
*/
|
||||
onPressMove?: ?(event: PressEvent) => void,
|
||||
|
||||
/**
|
||||
* Called when the press is deactivated to undo visual feedback.
|
||||
*/
|
||||
onPressOut?: ?(event: PressEvent) => void,
|
||||
|
||||
/**
|
||||
* Returns whether to yield to a lock termination request (e.g. if a native
|
||||
* scroll gesture attempts to steal the responder lock).
|
||||
*/
|
||||
onResponderTerminationRequest?: ?() => boolean,
|
||||
|
||||
/**
|
||||
* Returns whether to start a press gesture.
|
||||
*/
|
||||
onStartShouldSetResponder?: ?() => boolean,
|
||||
|}>;
|
||||
|
||||
type EventHandlers = $ReadOnly<{|
|
||||
onBlur: (event: BlurEvent) => void,
|
||||
onClick: (event: PressEvent) => void,
|
||||
onFocus: (event: FocusEvent) => void,
|
||||
onMouseEnter?: (event: MouseEvent) => void,
|
||||
onMouseLeave?: (event: MouseEvent) => void,
|
||||
onResponderGrant: (event: PressEvent) => void,
|
||||
onResponderMove: (event: PressEvent) => void,
|
||||
onResponderRelease: (event: PressEvent) => void,
|
||||
onResponderTerminate: (event: PressEvent) => void,
|
||||
onResponderTerminationRequest: () => boolean,
|
||||
onStartShouldSetResponder: () => boolean,
|
||||
|}>;
|
||||
|
||||
type TouchState =
|
||||
| 'NOT_RESPONDER'
|
||||
| 'RESPONDER_INACTIVE_PRESS_IN'
|
||||
| 'RESPONDER_INACTIVE_PRESS_OUT'
|
||||
| 'RESPONDER_ACTIVE_PRESS_IN'
|
||||
| 'RESPONDER_ACTIVE_PRESS_OUT'
|
||||
| 'RESPONDER_ACTIVE_LONG_PRESS_IN'
|
||||
| 'RESPONDER_ACTIVE_LONG_PRESS_OUT'
|
||||
| 'ERROR';
|
||||
|
||||
type TouchSignal =
|
||||
| 'DELAY'
|
||||
| 'RESPONDER_GRANT'
|
||||
| 'RESPONDER_RELEASE'
|
||||
| 'RESPONDER_TERMINATED'
|
||||
| 'ENTER_PRESS_RECT'
|
||||
| 'LEAVE_PRESS_RECT'
|
||||
| 'LONG_PRESS_DETECTED';
|
||||
|
||||
const Transitions = Object.freeze({
|
||||
NOT_RESPONDER: {
|
||||
DELAY: 'ERROR',
|
||||
RESPONDER_GRANT: 'RESPONDER_INACTIVE_PRESS_IN',
|
||||
RESPONDER_RELEASE: 'ERROR',
|
||||
RESPONDER_TERMINATED: 'ERROR',
|
||||
ENTER_PRESS_RECT: 'ERROR',
|
||||
LEAVE_PRESS_RECT: 'ERROR',
|
||||
LONG_PRESS_DETECTED: 'ERROR',
|
||||
},
|
||||
RESPONDER_INACTIVE_PRESS_IN: {
|
||||
DELAY: 'RESPONDER_ACTIVE_PRESS_IN',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'ERROR',
|
||||
},
|
||||
RESPONDER_INACTIVE_PRESS_OUT: {
|
||||
DELAY: 'RESPONDER_ACTIVE_PRESS_OUT',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'ERROR',
|
||||
},
|
||||
RESPONDER_ACTIVE_PRESS_IN: {
|
||||
DELAY: 'ERROR',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
|
||||
},
|
||||
RESPONDER_ACTIVE_PRESS_OUT: {
|
||||
DELAY: 'ERROR',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'ERROR',
|
||||
},
|
||||
RESPONDER_ACTIVE_LONG_PRESS_IN: {
|
||||
DELAY: 'ERROR',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
|
||||
},
|
||||
RESPONDER_ACTIVE_LONG_PRESS_OUT: {
|
||||
DELAY: 'ERROR',
|
||||
RESPONDER_GRANT: 'ERROR',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
|
||||
LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT',
|
||||
LONG_PRESS_DETECTED: 'ERROR',
|
||||
},
|
||||
ERROR: {
|
||||
DELAY: 'NOT_RESPONDER',
|
||||
RESPONDER_GRANT: 'RESPONDER_INACTIVE_PRESS_IN',
|
||||
RESPONDER_RELEASE: 'NOT_RESPONDER',
|
||||
RESPONDER_TERMINATED: 'NOT_RESPONDER',
|
||||
ENTER_PRESS_RECT: 'NOT_RESPONDER',
|
||||
LEAVE_PRESS_RECT: 'NOT_RESPONDER',
|
||||
LONG_PRESS_DETECTED: 'NOT_RESPONDER',
|
||||
},
|
||||
});
|
||||
|
||||
const isActiveSignal = signal =>
|
||||
signal === 'RESPONDER_ACTIVE_PRESS_IN' ||
|
||||
signal === 'RESPONDER_ACTIVE_LONG_PRESS_IN';
|
||||
|
||||
const isActivationSignal = signal =>
|
||||
signal === 'RESPONDER_ACTIVE_PRESS_OUT' ||
|
||||
signal === 'RESPONDER_ACTIVE_PRESS_IN';
|
||||
|
||||
const isPressInSignal = signal =>
|
||||
signal === 'RESPONDER_INACTIVE_PRESS_IN' ||
|
||||
signal === 'RESPONDER_ACTIVE_PRESS_IN' ||
|
||||
signal === 'RESPONDER_ACTIVE_LONG_PRESS_IN';
|
||||
|
||||
const isTerminalSignal = signal =>
|
||||
signal === 'RESPONDER_TERMINATED' || signal === 'RESPONDER_RELEASE';
|
||||
|
||||
const DEFAULT_LONG_PRESS_DELAY_MS = 500;
|
||||
const DEFAULT_PRESS_DELAY_MS = 0;
|
||||
const DEFAULT_PRESS_RECT_OFFSETS = {
|
||||
bottom: 30,
|
||||
left: 20,
|
||||
right: 20,
|
||||
top: 20,
|
||||
};
|
||||
|
||||
/**
|
||||
* Pressability implements press handling capabilities.
|
||||
*
|
||||
* =========================== Pressability Tutorial ===========================
|
||||
*
|
||||
* The `Pressability` class helps you create press interactions by analyzing the
|
||||
* geometry of elements and observing when another responder (e.g. ScrollView)
|
||||
* has stolen the touch lock. It offers hooks for your component to provide
|
||||
* interaction feedback to the user:
|
||||
*
|
||||
* - When a press has activated (e.g. highlight an element)
|
||||
* - When a press has deactivated (e.g. un-highlight an element)
|
||||
* - When a press sould trigger an action, meaning it activated and deactivated
|
||||
* while within the geometry of the element without the lock being stolen.
|
||||
*
|
||||
* A high quality interaction isn't as simple as you might think. There should
|
||||
* be a slight delay before activation. Moving your finger beyond an element's
|
||||
* bounds should trigger deactivation, but moving the same finger back within an
|
||||
* element's bounds should trigger reactivation.
|
||||
*
|
||||
* In order to use `Pressability`, do the following:
|
||||
*
|
||||
* 1. Instantiate `Pressability` and store it on your component's state.
|
||||
*
|
||||
* state = {
|
||||
* pressability: new Pressability({
|
||||
* // ...
|
||||
* }),
|
||||
* };
|
||||
*
|
||||
* 2. Choose the rendered component who should collect the press events. On that
|
||||
* element, spread `pressability.getEventHandlers()` into its props.
|
||||
*
|
||||
* return (
|
||||
* <View {...this.state.pressability.getEventHandlers()} />
|
||||
* );
|
||||
*
|
||||
* 3. Reset `Pressability` when your component unmounts.
|
||||
*
|
||||
* componentWillUnmount() {
|
||||
* this.state.pressability.reset();
|
||||
* }
|
||||
*
|
||||
* ==================== Pressability Implementation Details ====================
|
||||
*
|
||||
* `Pressability` only assumes that there exists a `HitRect` node. The `PressRect`
|
||||
* is an abstract box that is extended beyond the `HitRect`.
|
||||
*
|
||||
* # Geometry
|
||||
*
|
||||
* ┌────────────────────────┐
|
||||
* │ ┌──────────────────┐ │ - Presses start anywhere within `HitRect`, which
|
||||
* │ │ ┌────────────┐ │ │ is expanded via the prop `getHitSlop`.
|
||||
* │ │ │ VisualRect │ │ │
|
||||
* │ │ └────────────┘ │ │ - When pressed down for sufficient amount of time
|
||||
* │ │ HitRect │ │ before letting up, `VisualRect` activates for
|
||||
* │ └──────────────────┘ │ as long as the press stays within `PressRect`.
|
||||
* │ PressRect o │
|
||||
* └────────────────────│───┘
|
||||
* Out Region └────── `PressRect`, which is expanded via the prop
|
||||
* `getPressRectOffset`, allows presses to move
|
||||
* beyond `HitRect` while maintaining activation
|
||||
* and being eligible for a "press".
|
||||
*
|
||||
* # State Machine
|
||||
*
|
||||
* ┌───────────────┐ ◀──── RESPONDER_RELEASE
|
||||
* │ NOT_RESPONDER │
|
||||
* └───┬───────────┘ ◀──── RESPONDER_TERMINATED
|
||||
* │
|
||||
* │ RESPONDER_GRANT (HitRect)
|
||||
* │
|
||||
* ▼
|
||||
* ┌─────────────────────┐ ┌───────────────────┐ ┌───────────────────┐
|
||||
* │ RESPONDER_INACTIVE_ │ DELAY │ RESPONDER_ACTIVE_ │ T + DELAY │ RESPONDER_ACTIVE_ │
|
||||
* │ PRESS_IN ├────────▶ │ PRESS_IN ├────────────▶ │ LONG_PRESS_IN │
|
||||
* └─┬───────────────────┘ └─┬─────────────────┘ └─┬─────────────────┘
|
||||
* │ ▲ │ ▲ │ ▲
|
||||
* │LEAVE_ │ │LEAVE_ │ │LEAVE_ │
|
||||
* │PRESS_RECT │ENTER_ │PRESS_RECT │ENTER_ │PRESS_RECT │ENTER_
|
||||
* │ │PRESS_RECT │ │PRESS_RECT │ │PRESS_RECT
|
||||
* ▼ │ ▼ │ ▼ │
|
||||
* ┌─────────────┴───────┐ ┌─────────────┴─────┐ ┌─────────────┴─────┐
|
||||
* │ RESPONDER_INACTIVE_ │ DELAY │ RESPONDER_ACTIVE_ │ │ RESPONDER_ACTIVE_ │
|
||||
* │ PRESS_OUT ├────────▶ │ PRESS_OUT │ │ LONG_PRESS_OUT │
|
||||
* └─────────────────────┘ └───────────────────┘ └───────────────────┘
|
||||
*
|
||||
* T + DELAY => LONG_PRESS_DELAY + DELAY
|
||||
*
|
||||
* Not drawn are the side effects of each transition. The most important side
|
||||
* effect is the invocation of `onPress` and `onLongPress` that occur when a
|
||||
* responder is release while in the "press in" states.
|
||||
*/
|
||||
export default class Pressability {
|
||||
_config: PressabilityConfig;
|
||||
_eventHandlers: ?EventHandlers = null;
|
||||
_hoverInDelayTimeout: ?TimeoutID = null;
|
||||
_hoverOutDelayTimeout: ?TimeoutID = null;
|
||||
_isHovered: boolean = false;
|
||||
_longPressDelayTimeout: ?TimeoutID = null;
|
||||
_pressDelayTimeout: ?TimeoutID = null;
|
||||
_pressOutDelayTimeout: ?TimeoutID = null;
|
||||
_responderID: ?number | React.ElementRef<HostComponent<mixed>> = null;
|
||||
_responderRegion: ?$ReadOnly<{|
|
||||
bottom: number,
|
||||
left: number,
|
||||
right: number,
|
||||
top: number,
|
||||
|}> = null;
|
||||
_touchActivatePosition: ?$ReadOnly<{|
|
||||
pageX: number,
|
||||
pageY: number,
|
||||
|}>;
|
||||
_touchState: TouchState = 'NOT_RESPONDER';
|
||||
|
||||
constructor(config: PressabilityConfig) {
|
||||
this._config = config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets any pending timers. This should be called on unmount.
|
||||
*/
|
||||
reset(): void {
|
||||
this._cancelHoverInDelayTimeout();
|
||||
this._cancelHoverOutDelayTimeout();
|
||||
this._cancelLongPressDelayTimeout();
|
||||
this._cancelPressDelayTimeout();
|
||||
this._cancelPressOutDelayTimeout();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a set of props to spread into the interactive element.
|
||||
*/
|
||||
getEventHandlers(): EventHandlers {
|
||||
if (this._eventHandlers == null) {
|
||||
this._eventHandlers = this._createEventHandlers();
|
||||
}
|
||||
return this._eventHandlers;
|
||||
}
|
||||
|
||||
_createEventHandlers(): EventHandlers {
|
||||
const focusEventHandlers = {
|
||||
onBlur: (event: BlurEvent): void => {
|
||||
const {onBlur} = this._config;
|
||||
if (onBlur != null) {
|
||||
onBlur(event);
|
||||
}
|
||||
},
|
||||
onFocus: (event: FocusEvent): void => {
|
||||
const {onFocus} = this._config;
|
||||
if (onFocus != null) {
|
||||
onFocus(event);
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const responderEventHandlers = {
|
||||
onStartShouldSetResponder: () => {
|
||||
const {onStartShouldSetResponder} = this._config;
|
||||
return onStartShouldSetResponder == null
|
||||
? true
|
||||
: onStartShouldSetResponder();
|
||||
},
|
||||
|
||||
onResponderGrant: (event: PressEvent): void => {
|
||||
event.persist();
|
||||
|
||||
this._cancelPressOutDelayTimeout();
|
||||
|
||||
this._responderID = event.currentTarget;
|
||||
this._touchState = 'NOT_RESPONDER';
|
||||
this._receiveSignal('RESPONDER_GRANT', event);
|
||||
|
||||
const {getLongPressDelayMS, getPressDelayMS} = this._config;
|
||||
|
||||
const pressDelay = getDelayMS(
|
||||
getPressDelayMS,
|
||||
0,
|
||||
DEFAULT_PRESS_DELAY_MS,
|
||||
);
|
||||
if (pressDelay > 0) {
|
||||
this._pressDelayTimeout = setTimeout(() => {
|
||||
this._receiveSignal('DELAY', event);
|
||||
}, pressDelay);
|
||||
} else {
|
||||
this._receiveSignal('DELAY', event);
|
||||
}
|
||||
|
||||
const longPressDelay = getDelayMS(
|
||||
getLongPressDelayMS,
|
||||
10,
|
||||
DEFAULT_LONG_PRESS_DELAY_MS,
|
||||
);
|
||||
this._longPressDelayTimeout = setTimeout(() => {
|
||||
this._handleLongPress(event);
|
||||
}, longPressDelay + pressDelay);
|
||||
},
|
||||
|
||||
onResponderMove: (event: PressEvent): void => {
|
||||
if (this._config.onPressMove != null) {
|
||||
this._config.onPressMove(event);
|
||||
}
|
||||
|
||||
// Region may not have finished being measured, yet.
|
||||
const responderRegion = this._responderRegion;
|
||||
if (responderRegion == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
const touch = getTouchFromPressEvent(event);
|
||||
if (touch == null) {
|
||||
this._cancelLongPressDelayTimeout();
|
||||
this._receiveSignal('LEAVE_PRESS_RECT', event);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._touchActivatePosition != null) {
|
||||
const deltaX = this._touchActivatePosition.pageX - touch.pageX;
|
||||
const deltaY = this._touchActivatePosition.pageY - touch.pageY;
|
||||
if (Math.hypot(deltaX, deltaY) > 10) {
|
||||
this._cancelLongPressDelayTimeout();
|
||||
}
|
||||
}
|
||||
|
||||
if (this._isTouchWithinResponderRegion(touch, responderRegion)) {
|
||||
this._receiveSignal('ENTER_PRESS_RECT', event);
|
||||
} else {
|
||||
this._cancelLongPressDelayTimeout();
|
||||
this._receiveSignal('LEAVE_PRESS_RECT', event);
|
||||
}
|
||||
},
|
||||
|
||||
onResponderRelease: (event: PressEvent): void => {
|
||||
this._receiveSignal('RESPONDER_RELEASE', event);
|
||||
},
|
||||
|
||||
onResponderTerminate: (event: PressEvent): void => {
|
||||
this._receiveSignal('RESPONDER_TERMINATED', event);
|
||||
},
|
||||
|
||||
onResponderTerminationRequest: (): boolean => {
|
||||
const {onResponderTerminationRequest} = this._config;
|
||||
return onResponderTerminationRequest == null
|
||||
? true
|
||||
: onResponderTerminationRequest();
|
||||
},
|
||||
|
||||
onClick: (event: PressEvent) => {
|
||||
const {onPress} = this._config;
|
||||
if (onPress != null) {
|
||||
onPress(event);
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
const mouseEventHandlers =
|
||||
Platform.OS === 'ios' || Platform.OS === 'android'
|
||||
? null
|
||||
: {
|
||||
onMouseEnter: (event: MouseEvent): void => {
|
||||
if (isHoverEnabled()) {
|
||||
this._isHovered = true;
|
||||
this._cancelHoverOutDelayTimeout();
|
||||
const {onHoverIn, getHoverInDelayMS} = this._config;
|
||||
if (onHoverIn != null) {
|
||||
const delay = getDelayMS(getHoverInDelayMS);
|
||||
if (delay > 0) {
|
||||
this._hoverInDelayTimeout = setTimeout(() => {
|
||||
onHoverIn(event);
|
||||
}, delay);
|
||||
} else {
|
||||
onHoverIn(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
onMouseLeave: (event: MouseEvent): void => {
|
||||
if (this._isHovered) {
|
||||
this._isHovered = false;
|
||||
this._cancelHoverInDelayTimeout();
|
||||
const {onHoverOut, getHoverOutDelayMS} = this._config;
|
||||
if (onHoverOut != null) {
|
||||
const delay = getDelayMS(getHoverOutDelayMS);
|
||||
if (delay > 0) {
|
||||
this._hoverInDelayTimeout = setTimeout(() => {
|
||||
onHoverOut(event);
|
||||
}, delay);
|
||||
} else {
|
||||
onHoverOut(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
return {
|
||||
...focusEventHandlers,
|
||||
...responderEventHandlers,
|
||||
...mouseEventHandlers,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Receives a state machine signal, performs side effects of the transition
|
||||
* and stores the new state. Validates the transition as well.
|
||||
*/
|
||||
_receiveSignal(signal: TouchSignal, event: PressEvent): void {
|
||||
const prevState = this._touchState;
|
||||
const nextState = Transitions[prevState]?.[signal];
|
||||
if (this._responderID == null && signal === 'RESPONDER_RELEASE') {
|
||||
return;
|
||||
}
|
||||
invariant(
|
||||
nextState != null && nextState !== 'ERROR',
|
||||
'Pressability: Invalid signal `%s` for state `%s` on responder: %s',
|
||||
signal,
|
||||
prevState,
|
||||
typeof this._responderID === 'number'
|
||||
? this._responderID
|
||||
: '<<host component>>',
|
||||
);
|
||||
if (prevState !== nextState) {
|
||||
this._performTransitionSideEffects(prevState, nextState, signal, event);
|
||||
this._touchState = nextState;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a transition between touchable states and identify any activations
|
||||
* or deactivations (and callback invocations).
|
||||
*/
|
||||
_performTransitionSideEffects(
|
||||
prevState: TouchState,
|
||||
nextState: TouchState,
|
||||
signal: TouchSignal,
|
||||
event: PressEvent,
|
||||
): void {
|
||||
if (isTerminalSignal(signal)) {
|
||||
this._cancelLongPressDelayTimeout();
|
||||
}
|
||||
|
||||
const isInitialTransition =
|
||||
prevState === 'NOT_RESPONDER' &&
|
||||
nextState === 'RESPONDER_INACTIVE_PRESS_IN';
|
||||
|
||||
const isActivationTransiton =
|
||||
!isActivationSignal(prevState) && isActivationSignal(nextState);
|
||||
|
||||
if (isInitialTransition || isActivationTransiton) {
|
||||
this._measureResponderRegion();
|
||||
}
|
||||
|
||||
if (isPressInSignal(prevState) && signal === 'LONG_PRESS_DETECTED') {
|
||||
const {onLongPress} = this._config;
|
||||
if (onLongPress != null) {
|
||||
onLongPress(event);
|
||||
}
|
||||
}
|
||||
|
||||
const isPrevActive = isActiveSignal(prevState);
|
||||
const isNextActive = isActiveSignal(nextState);
|
||||
|
||||
if (!isPrevActive && isNextActive) {
|
||||
this._activate(event);
|
||||
} else if (isPrevActive && !isNextActive) {
|
||||
this._deactivate(event);
|
||||
}
|
||||
|
||||
if (isPressInSignal(prevState) && signal === 'RESPONDER_RELEASE') {
|
||||
const {onLongPress, onPress, getTouchSoundDisabled} = this._config;
|
||||
if (onPress != null) {
|
||||
const isPressCanceledByLongPress =
|
||||
onLongPress != null &&
|
||||
prevState === 'RESPONDER_ACTIVE_LONG_PRESS_IN' &&
|
||||
this._shouldLongPressCancelPress();
|
||||
if (!isPressCanceledByLongPress) {
|
||||
// If we never activated (due to delays), activate and deactivate now.
|
||||
if (!isNextActive && !isPrevActive) {
|
||||
this._activate(event);
|
||||
this._deactivate(event);
|
||||
}
|
||||
const isTouchSoundDisabled =
|
||||
(getTouchSoundDisabled == null ? null : getTouchSoundDisabled()) ??
|
||||
false;
|
||||
if (Platform.OS === 'android' && !isTouchSoundDisabled) {
|
||||
SoundManager.playTouchSound();
|
||||
}
|
||||
onPress(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this._cancelPressDelayTimeout();
|
||||
}
|
||||
|
||||
_activate(event: PressEvent): void {
|
||||
const {onPressIn} = this._config;
|
||||
const touch = getTouchFromPressEvent(event);
|
||||
this._touchActivatePosition = {
|
||||
pageX: touch.pageX,
|
||||
pageY: touch.pageY,
|
||||
};
|
||||
if (onPressIn != null) {
|
||||
onPressIn(event);
|
||||
}
|
||||
}
|
||||
|
||||
_deactivate(event: PressEvent): void {
|
||||
const {onPressOut, getPressOutDelayMS} = this._config;
|
||||
if (onPressOut != null) {
|
||||
const delay = getDelayMS(getPressOutDelayMS);
|
||||
if (delay > 0) {
|
||||
this._pressOutDelayTimeout = setTimeout(() => {
|
||||
onPressOut(event);
|
||||
}, delay);
|
||||
} else {
|
||||
onPressOut(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_measureResponderRegion(): void {
|
||||
if (this._responderID == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof this._responderID === 'number') {
|
||||
UIManager.measure(this._responderID, this._measureCallback);
|
||||
} else {
|
||||
this._responderID.measure(this._measureCallback);
|
||||
}
|
||||
}
|
||||
|
||||
_measureCallback = (left, top, width, height, pageX, pageY) => {
|
||||
if (!left && !top && !width && !height && !pageX && !pageY) {
|
||||
return;
|
||||
}
|
||||
this._responderRegion = {
|
||||
bottom: pageY + height,
|
||||
left: pageX,
|
||||
right: pageX + width,
|
||||
top: pageY,
|
||||
};
|
||||
};
|
||||
|
||||
_isTouchWithinResponderRegion(
|
||||
touch: $PropertyType<PressEvent, 'nativeEvent'>,
|
||||
responderRegion: $ReadOnly<{|
|
||||
bottom: number,
|
||||
left: number,
|
||||
right: number,
|
||||
top: number,
|
||||
|}>,
|
||||
): boolean {
|
||||
const {getHitSlop, getPressRectOffset} = this._config;
|
||||
|
||||
let regionBottom = responderRegion.bottom;
|
||||
let regionLeft = responderRegion.left;
|
||||
let regionRight = responderRegion.right;
|
||||
let regionTop = responderRegion.top;
|
||||
|
||||
const hitSlop = getHitSlop == null ? null : getHitSlop();
|
||||
if (hitSlop != null) {
|
||||
if (hitSlop.bottom != null) {
|
||||
regionBottom += hitSlop.bottom;
|
||||
}
|
||||
if (hitSlop.left != null) {
|
||||
regionLeft -= hitSlop.left;
|
||||
}
|
||||
if (hitSlop.right != null) {
|
||||
regionRight += hitSlop.right;
|
||||
}
|
||||
if (hitSlop.top != null) {
|
||||
regionTop -= hitSlop.top;
|
||||
}
|
||||
}
|
||||
|
||||
const rectOffset = getPressRectOffset == null ? null : getPressRectOffset();
|
||||
regionBottom +=
|
||||
rectOffset == null || rectOffset.bottom == null
|
||||
? DEFAULT_PRESS_RECT_OFFSETS.bottom
|
||||
: rectOffset.bottom;
|
||||
regionLeft -=
|
||||
rectOffset == null || rectOffset.left == null
|
||||
? DEFAULT_PRESS_RECT_OFFSETS.left
|
||||
: rectOffset.left;
|
||||
regionRight +=
|
||||
rectOffset == null || rectOffset.right == null
|
||||
? DEFAULT_PRESS_RECT_OFFSETS.right
|
||||
: rectOffset.right;
|
||||
regionTop -=
|
||||
rectOffset == null || rectOffset.top == null
|
||||
? DEFAULT_PRESS_RECT_OFFSETS.top
|
||||
: rectOffset.top;
|
||||
|
||||
return (
|
||||
touch.pageX > regionLeft &&
|
||||
touch.pageX < regionRight &&
|
||||
touch.pageY > regionTop &&
|
||||
touch.pageY < regionBottom
|
||||
);
|
||||
}
|
||||
|
||||
_handleLongPress(event: PressEvent): void {
|
||||
if (
|
||||
this._touchState === 'RESPONDER_ACTIVE_PRESS_IN' ||
|
||||
this._touchState === 'RESPONDER_ACTIVE_LONG_PRESS_IN'
|
||||
) {
|
||||
this._receiveSignal('LONG_PRESS_DETECTED', event);
|
||||
}
|
||||
}
|
||||
|
||||
_shouldLongPressCancelPress(): boolean {
|
||||
return (
|
||||
this._config.onLongPressShouldCancelPress == null ||
|
||||
this._config.onLongPressShouldCancelPress()
|
||||
);
|
||||
}
|
||||
|
||||
_cancelHoverInDelayTimeout(): void {
|
||||
if (this._hoverInDelayTimeout != null) {
|
||||
clearTimeout(this._hoverInDelayTimeout);
|
||||
this._hoverInDelayTimeout = null;
|
||||
}
|
||||
}
|
||||
|
||||
_cancelHoverOutDelayTimeout(): void {
|
||||
if (this._hoverOutDelayTimeout != null) {
|
||||
clearTimeout(this._hoverOutDelayTimeout);
|
||||
this._hoverOutDelayTimeout = null;
|
||||
}
|
||||
}
|
||||
|
||||
_cancelLongPressDelayTimeout(): void {
|
||||
if (this._longPressDelayTimeout != null) {
|
||||
clearTimeout(this._longPressDelayTimeout);
|
||||
this._longPressDelayTimeout = null;
|
||||
}
|
||||
}
|
||||
|
||||
_cancelPressDelayTimeout(): void {
|
||||
if (this._pressDelayTimeout != null) {
|
||||
clearTimeout(this._pressDelayTimeout);
|
||||
this._pressDelayTimeout = null;
|
||||
}
|
||||
}
|
||||
|
||||
_cancelPressOutDelayTimeout(): void {
|
||||
if (this._pressOutDelayTimeout != null) {
|
||||
clearTimeout(this._pressOutDelayTimeout);
|
||||
this._pressOutDelayTimeout = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const getDelayMS = (getDelay: ?() => ?number, min = 0, fallback = 0) => {
|
||||
return Math.max(min, (getDelay == null ? null : getDelay()) ?? fallback);
|
||||
};
|
||||
|
||||
const getTouchFromPressEvent = (event: PressEvent) => {
|
||||
const {changedTouches, touches} = event.nativeEvent;
|
||||
|
||||
if (touches != null && touches.length > 0) {
|
||||
return touches[0];
|
||||
}
|
||||
if (changedTouches != null && changedTouches.length > 0) {
|
||||
return changedTouches[0];
|
||||
}
|
||||
return event.nativeEvent;
|
||||
};
|
||||
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @flow strict-local
|
||||
* @format
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import normalizeColor from '../Color/normalizeColor.js';
|
||||
import {Touchable, View} from 'react-native';
|
||||
import * as React from 'react';
|
||||
|
||||
type Props = $ReadOnly<{|
|
||||
color: string,
|
||||
hitSlop: ?$ReadOnly<{|
|
||||
bottom?: ?number,
|
||||
left?: ?number,
|
||||
right?: ?number,
|
||||
top?: ?number,
|
||||
|}>,
|
||||
|}>;
|
||||
|
||||
/**
|
||||
* Displays a debug overlay to visualize press targets when enabled via the
|
||||
* React Native Inspector. Calls to this module should be guarded by `__DEV__`,
|
||||
* for example:
|
||||
*
|
||||
* return (
|
||||
* <View>
|
||||
* {children}
|
||||
* {__DEV__ ? (
|
||||
* <PressabilityDebugView color="..." hitSlop={props.hitSlop} />
|
||||
* ) : null}
|
||||
* </View>
|
||||
* );
|
||||
*
|
||||
*/
|
||||
export function PressabilityDebugView({color, hitSlop}: Props): React.Node {
|
||||
if (__DEV__) {
|
||||
if (isEnabled()) {
|
||||
const baseColor =
|
||||
'#' + (normalizeColor(color) ?? 0).toString(16).padStart(8, '0');
|
||||
|
||||
return (
|
||||
<View
|
||||
pointerEvents="none"
|
||||
style={{
|
||||
backgroundColor: baseColor.slice(0, -2) + '0F', // 15%
|
||||
borderColor: baseColor.slice(0, -2) + '55', // 85%
|
||||
borderStyle: 'dashed',
|
||||
borderWidth: 1,
|
||||
bottom: -(hitSlop?.bottom ?? 0),
|
||||
left: -(hitSlop?.left ?? 0),
|
||||
position: 'absolute',
|
||||
right: -(hitSlop?.right ?? 0),
|
||||
top: -(hitSlop?.top ?? 0),
|
||||
}}
|
||||
/>
|
||||
);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
export function isEnabled(): boolean {
|
||||
if (__DEV__) {
|
||||
return Touchable.TOUCH_TARGET_DEBUG;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,661 @@
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @emails oncall+react_native
|
||||
* @format
|
||||
* @flow strict-local
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import type {PressEvent} from '../../Types/CoreEventTypes.js';
|
||||
import * as HoverState from '../HoverState.js';
|
||||
import Pressability from '../Pressability.js';
|
||||
import invariant from 'invariant';
|
||||
import nullthrows from 'nullthrows';
|
||||
import {Platform, UIManager} from 'react-native';
|
||||
|
||||
// TODO: Move this util to a shared location.
|
||||
function getMock<TArguments: $ReadOnlyArray<mixed>, TReturn>(
|
||||
fn: (...args: TArguments) => TReturn,
|
||||
): JestMockFn<TArguments, TReturn> {
|
||||
if (!jest.isMockFunction(fn)) {
|
||||
throw new Error('Function must be mock function');
|
||||
}
|
||||
return (fn: $FlowFixMe);
|
||||
}
|
||||
|
||||
const createMockPressability = overrides => {
|
||||
const config = {
|
||||
getHitSlop: jest.fn(),
|
||||
getHoverInDelayMS: jest.fn(() => null),
|
||||
getHoverOutDelayMS: jest.fn(() => null),
|
||||
getLongPressDelayMS: jest.fn(() => null),
|
||||
getPressDelayMS: jest.fn(() => null),
|
||||
getPressOutDelayMS: jest.fn(() => null),
|
||||
getPressRectOffset: jest.fn(),
|
||||
onBlur: jest.fn(),
|
||||
onFocus: jest.fn(),
|
||||
onHoverIn: jest.fn(),
|
||||
onHoverOut: jest.fn(),
|
||||
onLongPress: jest.fn(),
|
||||
onLongPressShouldCancelPress: jest.fn(),
|
||||
onPress: jest.fn(),
|
||||
onPressIn: jest.fn(),
|
||||
onPressOut: jest.fn(),
|
||||
onResponderTerminationRequest: jest.fn(() => true),
|
||||
onStartShouldSetResponder: jest.fn(() => true),
|
||||
...overrides,
|
||||
};
|
||||
const touchable = new Pressability(config);
|
||||
const handlers = touchable.getEventHandlers();
|
||||
return {
|
||||
config,
|
||||
handlers,
|
||||
touchable,
|
||||
};
|
||||
};
|
||||
|
||||
const mockRegion = {
|
||||
left: 0,
|
||||
top: 0,
|
||||
width: 50,
|
||||
height: 50,
|
||||
pageX: 0,
|
||||
pageY: 0,
|
||||
};
|
||||
|
||||
const mockSlop = {
|
||||
top: 10,
|
||||
left: 10,
|
||||
bottom: 10,
|
||||
right: 10,
|
||||
};
|
||||
|
||||
const mockUIManagerMeasure = (options?: {|delay: number|}) => {
|
||||
getMock(UIManager.measure).mockImplementation((id, fn) => {
|
||||
if (options && options.delay) {
|
||||
setTimeout(
|
||||
() =>
|
||||
fn(
|
||||
mockRegion.left,
|
||||
mockRegion.top,
|
||||
mockRegion.width,
|
||||
mockRegion.height,
|
||||
mockRegion.pageX,
|
||||
mockRegion.pageY,
|
||||
),
|
||||
options.delay,
|
||||
);
|
||||
} else {
|
||||
fn(
|
||||
mockRegion.left,
|
||||
mockRegion.top,
|
||||
mockRegion.width,
|
||||
mockRegion.height,
|
||||
mockRegion.pageX,
|
||||
mockRegion.pageY,
|
||||
);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
const createMockTargetEvent = registrationName => {
|
||||
const nativeEvent = {
|
||||
target: 42,
|
||||
};
|
||||
|
||||
return {
|
||||
bubbles: null,
|
||||
cancelable: null,
|
||||
currentTarget: 42,
|
||||
defaultPrevented: null,
|
||||
dispatchConfig: {
|
||||
registrationName,
|
||||
},
|
||||
eventPhase: null,
|
||||
preventDefault: jest.fn(() => undefined),
|
||||
isDefaultPrevented: jest.fn(() => false),
|
||||
stopPropagation: jest.fn(() => undefined),
|
||||
isPropagationStopped: jest.fn(() => false),
|
||||
isTrusted: null,
|
||||
nativeEvent,
|
||||
persist: jest.fn(),
|
||||
target: null,
|
||||
timeStamp: 1075881600000,
|
||||
type: null,
|
||||
};
|
||||
};
|
||||
|
||||
const createMockMouseEvent = registrationName => {
|
||||
const nativeEvent = {
|
||||
clientX: 0,
|
||||
clientY: 0,
|
||||
pageX: 0,
|
||||
pageY: 0,
|
||||
timestamp: 1075881600000,
|
||||
};
|
||||
|
||||
return {
|
||||
bubbles: null,
|
||||
cancelable: null,
|
||||
currentTarget: 42,
|
||||
defaultPrevented: null,
|
||||
dispatchConfig: {
|
||||
registrationName,
|
||||
},
|
||||
eventPhase: null,
|
||||
preventDefault: jest.fn(() => undefined),
|
||||
isDefaultPrevented: jest.fn(() => false),
|
||||
stopPropagation: jest.fn(() => undefined),
|
||||
isPropagationStopped: jest.fn(() => false),
|
||||
isTrusted: null,
|
||||
nativeEvent,
|
||||
persist: jest.fn(),
|
||||
target: null,
|
||||
timeStamp: 1075881600000,
|
||||
type: null,
|
||||
};
|
||||
};
|
||||
|
||||
const createMockPressEvent = (
|
||||
nameOrOverrides:
|
||||
| string
|
||||
| $ReadOnly<{|
|
||||
registrationName: string,
|
||||
pageX: number,
|
||||
pageY: number,
|
||||
|}>,
|
||||
): PressEvent => {
|
||||
let registrationName = '';
|
||||
let pageX = 0;
|
||||
let pageY = 0;
|
||||
|
||||
if (typeof nameOrOverrides === 'string') {
|
||||
registrationName = nameOrOverrides;
|
||||
} else if (typeof nameOrOverrides === 'object' || nameOrOverrides != null) {
|
||||
registrationName = nameOrOverrides.registrationName;
|
||||
pageX = nameOrOverrides.pageX;
|
||||
pageY = nameOrOverrides.pageY;
|
||||
}
|
||||
|
||||
const nativeEvent = {
|
||||
changedTouches: [],
|
||||
force: 1,
|
||||
identifier: 42,
|
||||
locationX: pageX,
|
||||
locationY: pageY,
|
||||
pageX,
|
||||
pageY,
|
||||
target: 42,
|
||||
timestamp: 1075881600000,
|
||||
touches: [],
|
||||
};
|
||||
|
||||
nativeEvent.changedTouches.push(nativeEvent);
|
||||
nativeEvent.touches.push(nativeEvent);
|
||||
|
||||
return {
|
||||
bubbles: null,
|
||||
cancelable: null,
|
||||
currentTarget: 42,
|
||||
defaultPrevented: null,
|
||||
dispatchConfig: {
|
||||
registrationName,
|
||||
},
|
||||
eventPhase: null,
|
||||
preventDefault: jest.fn(() => undefined),
|
||||
isDefaultPrevented: jest.fn(() => false),
|
||||
stopPropagation: jest.fn(() => undefined),
|
||||
isPropagationStopped: jest.fn(() => false),
|
||||
isTrusted: null,
|
||||
nativeEvent,
|
||||
persist: jest.fn(),
|
||||
target: null,
|
||||
timeStamp: 1075881600000,
|
||||
touchHistory: {
|
||||
indexOfSingleActiveTouch: 0,
|
||||
mostRecentTimeStamp: 1075881600000,
|
||||
numberActiveTouches: 1,
|
||||
touchBank: [],
|
||||
},
|
||||
type: null,
|
||||
};
|
||||
};
|
||||
|
||||
describe('Pressability', () => {
|
||||
beforeEach(() => {
|
||||
jest.resetModules();
|
||||
jest.spyOn(HoverState, 'isHoverEnabled');
|
||||
});
|
||||
|
||||
describe('onBlur', () => {
|
||||
it('is called if provided in config', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
handlers.onBlur(createMockTargetEvent('onBlur'));
|
||||
expect(config.onBlur).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('onFocus', () => {
|
||||
it('is called if provided in config', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
handlers.onFocus(createMockTargetEvent('onFocus'));
|
||||
expect(config.onFocus).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('onHoverIn', () => {
|
||||
let originalPlatform;
|
||||
|
||||
beforeEach(() => {
|
||||
originalPlatform = Platform.OS;
|
||||
Platform.OS = 'web';
|
||||
// $FlowExpectedError
|
||||
HoverState.isHoverEnabled.mockReturnValue(true);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
Platform.OS = originalPlatform;
|
||||
});
|
||||
|
||||
it('is ignored on unsupported platforms`', () => {
|
||||
Platform.OS = 'ios';
|
||||
const {handlers} = createMockPressability();
|
||||
expect(handlers.onMouseEnter).toBeUndefined();
|
||||
});
|
||||
|
||||
it('is called after `onMouseEnter`', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
invariant(
|
||||
typeof handlers.onMouseEnter === 'function',
|
||||
'Expected to find "onMouseEnter" function',
|
||||
);
|
||||
// $FlowExpectedError
|
||||
handlers.onMouseEnter(createMockMouseEvent('onMouseEnter'));
|
||||
expect(config.onHoverIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called after no delay by default', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHoverInDelayMS: () => null,
|
||||
});
|
||||
invariant(
|
||||
typeof handlers.onMouseEnter === 'function',
|
||||
'Expected to find "onMouseEnter" function',
|
||||
);
|
||||
// $FlowExpectedError
|
||||
handlers.onMouseEnter(createMockMouseEvent('onMouseEnter'));
|
||||
expect(config.onHoverIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('falls back to no delay if `getHoverInDelayMS` is omitted', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHoverInDelayMS: null,
|
||||
});
|
||||
invariant(
|
||||
typeof handlers.onMouseEnter === 'function',
|
||||
'Expected to find "onMouseEnter" function',
|
||||
);
|
||||
// $FlowExpectedError
|
||||
handlers.onMouseEnter(createMockMouseEvent('onMouseEnter'));
|
||||
expect(config.onHoverIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called after a configured delay', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHoverInDelayMS: () => 500,
|
||||
});
|
||||
invariant(
|
||||
typeof handlers.onMouseEnter === 'function',
|
||||
'Expected to find "onMouseEnter" function',
|
||||
);
|
||||
// $FlowExpectedError
|
||||
handlers.onMouseEnter(createMockMouseEvent('onMouseEnter'));
|
||||
jest.advanceTimersByTime(499);
|
||||
expect(config.onHoverIn).not.toBeCalled();
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onHoverIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called synchronously if delay is 0ms', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHoverInDelayMS: () => 0,
|
||||
});
|
||||
invariant(
|
||||
typeof handlers.onMouseEnter === 'function',
|
||||
'Expected to find "onMouseEnter" function',
|
||||
);
|
||||
// $FlowExpectedError
|
||||
handlers.onMouseEnter(createMockMouseEvent('onMouseEnter'));
|
||||
expect(config.onHoverIn).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
// TODO: onHoverOut tests
|
||||
|
||||
describe('onLongPress', () => {
|
||||
it('is called if pressed for 500ms', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
jest.advanceTimersByTime(499);
|
||||
expect(config.onLongPress).not.toBeCalled();
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onLongPress).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called if pressed for 500ms after the press delay', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => 100,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
jest.advanceTimersByTime(599);
|
||||
expect(config.onLongPress).not.toBeCalled();
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onLongPress).toBeCalled();
|
||||
});
|
||||
|
||||
it('is not called if released before delay', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
jest.advanceTimersByTime(499);
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
jest.advanceTimersByTime(1);
|
||||
|
||||
expect(config.onLongPress).not.toBeCalled();
|
||||
});
|
||||
|
||||
it('falls back to a minimum of 10ms before calling `onLongPress`', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getLongPressDelayMS: () => 0,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
jest.advanceTimersByTime(9);
|
||||
expect(config.onLongPress).not.toBeCalled();
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onLongPress).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
// TODO: onLongPressShouldCancelPress tests
|
||||
|
||||
describe('onPress', () => {
|
||||
it('is called even when `measure` does not finish', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
jest.runOnlyPendingTimers();
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
|
||||
expect(config.onPress).toBeCalled();
|
||||
expect(config.onPressOut).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('onPressIn', () => {
|
||||
it('is called after `onResponderGrant`', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
jest.runOnlyPendingTimers();
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called after no delay by default', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => null,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('falls back to no delay if `getPressDelayMS` is omitted', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: null,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called after a configured delay', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => 500,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
jest.advanceTimersByTime(499);
|
||||
expect(config.onPressIn).not.toBeCalled();
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
});
|
||||
|
||||
it('is called synchronously if delay is 0ms', () => {
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => 0,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
handlers.onResponderMove(createMockPressEvent('onResponderMove'));
|
||||
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
// TODO: onPressOut tests
|
||||
|
||||
describe('`onPress*` with movement', () => {
|
||||
describe('within bounds of hit rect', () => {
|
||||
it('`onPress*` are called when no delay', () => {
|
||||
mockUIManagerMeasure();
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHitSlop: () => mockSlop,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
/** ┌──────────────────┐
|
||||
* │ ┌────────────┐ │
|
||||
* │ │ VisualRect │ │
|
||||
* │ └────────────┘ │
|
||||
* │ HitRect X │ <= Move to X and release
|
||||
* └──────────────────┘
|
||||
*/
|
||||
handlers.onResponderMove(
|
||||
createMockPressEvent({
|
||||
registrationName: 'onResponderMove',
|
||||
pageX: mockRegion.width + mockSlop.right / 2,
|
||||
pageY: mockRegion.height + mockSlop.bottom / 2,
|
||||
}),
|
||||
);
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
expect(config.onPress).toBeCalled();
|
||||
expect(config.onPressOut).toBeCalled();
|
||||
});
|
||||
|
||||
it('`onPress*` are called after a delay', () => {
|
||||
mockUIManagerMeasure();
|
||||
const {config, handlers} = createMockPressability({
|
||||
getHitSlop: () => mockSlop,
|
||||
getPressDelayMS: () => 500,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
/** ┌──────────────────┐
|
||||
* │ ┌────────────┐ │
|
||||
* │ │ VisualRect │ │
|
||||
* │ └────────────┘ │
|
||||
* │ HitRect X │ <= Move to X and release
|
||||
* └──────────────────┘
|
||||
*/
|
||||
handlers.onResponderMove(
|
||||
createMockPressEvent({
|
||||
registrationName: 'onResponderMove',
|
||||
pageX: mockRegion.width + mockSlop.right / 2,
|
||||
pageY: mockRegion.height + mockSlop.bottom / 2,
|
||||
}),
|
||||
);
|
||||
jest.advanceTimersByTime(499);
|
||||
expect(config.onPressIn).not.toBeCalled();
|
||||
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
|
||||
expect(config.onPress).toBeCalled();
|
||||
expect(config.onPressOut).toBeCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe('beyond bounds of hit rect', () => {
|
||||
it('`onPress` only is not called when no delay', () => {
|
||||
mockUIManagerMeasure();
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
handlers.onResponderMove(
|
||||
createMockPressEvent({
|
||||
registrationName: 'onResponderMove',
|
||||
pageX: mockRegion.width * 2,
|
||||
pageY: mockRegion.height * 2,
|
||||
}),
|
||||
);
|
||||
jest.runOnlyPendingTimers();
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
expect(config.onPress).not.toBeCalled();
|
||||
expect(config.onPressOut).toBeCalled();
|
||||
});
|
||||
|
||||
it('`onPress*` are not called after a delay', () => {
|
||||
mockUIManagerMeasure();
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => 500,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
handlers.onResponderMove(
|
||||
createMockPressEvent({
|
||||
registrationName: 'onResponderMove',
|
||||
pageX: mockRegion.width * 2,
|
||||
pageY: mockRegion.height * 2,
|
||||
}),
|
||||
);
|
||||
jest.runOnlyPendingTimers();
|
||||
expect(config.onPressIn).not.toBeCalled();
|
||||
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
|
||||
expect(config.onPress).not.toBeCalled();
|
||||
expect(config.onPressOut).not.toBeCalled();
|
||||
});
|
||||
|
||||
it('`onPress*` are called when press is released before measure completes', () => {
|
||||
mockUIManagerMeasure({delay: 1000});
|
||||
const {config, handlers} = createMockPressability({
|
||||
getPressDelayMS: () => 500,
|
||||
});
|
||||
|
||||
handlers.onStartShouldSetResponder();
|
||||
handlers.onResponderGrant(createMockPressEvent('onResponderGrant'));
|
||||
|
||||
expect(UIManager.measure).toBeCalled();
|
||||
|
||||
handlers.onResponderMove(
|
||||
createMockPressEvent({
|
||||
registrationName: 'onResponderMove',
|
||||
pageX: mockRegion.width * 2,
|
||||
pageY: mockRegion.height * 2,
|
||||
}),
|
||||
);
|
||||
jest.advanceTimersByTime(499);
|
||||
expect(config.onPressIn).not.toBeCalled();
|
||||
|
||||
jest.advanceTimersByTime(1);
|
||||
expect(config.onPressIn).toBeCalled();
|
||||
|
||||
handlers.onResponderRelease(createMockPressEvent('onResponderRelease'));
|
||||
|
||||
expect(config.onPress).toBeCalled();
|
||||
expect(config.onPressOut).toBeCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('onStartShouldSetResponder', () => {
|
||||
it('if omitted the responder is set by default', () => {
|
||||
const {handlers} = createMockPressability({
|
||||
onStartShouldSetResponder: null,
|
||||
});
|
||||
|
||||
expect(handlers.onStartShouldSetResponder()).toBe(true);
|
||||
});
|
||||
|
||||
it('if supplied it is called', () => {
|
||||
const {config, handlers} = createMockPressability();
|
||||
|
||||
nullthrows(config.onStartShouldSetResponder).mockReturnValue(false);
|
||||
expect(handlers.onStartShouldSetResponder()).toBe(false);
|
||||
|
||||
nullthrows(config.onStartShouldSetResponder).mockReturnValue(true);
|
||||
expect(handlers.onStartShouldSetResponder()).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user