@samitouri / QOS-React / commits / 81e30c7ff6

Remove unused modules from legacy event responders (#17907)

Nicolas Gallagher committed Jan 24, 2020 at 10:50 UTC 81e30c7ff67d4c5d6e9b9f2bb3d9af44bd40c621

10 files changed -1353

packages/react-interactions/events/drag.js deleted

-12

@@ -1,12 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -'use strict';

11 -

12 -module.exports = require('./src/dom/Drag');

packages/react-interactions/events/scroll.js deleted

-12

@@ -1,12 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -'use strict';

11 -

12 -module.exports = require('./src/dom/Scroll');

packages/react-interactions/events/src/dom/Drag.js deleted

-253

@@ -1,253 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -import type {

11 - ReactDOMResponderEvent,

12 - ReactDOMResponderContext,

13 -} from 'shared/ReactDOMTypes';

14 -import type {

15 - EventPriority,

16 - ReactEventResponderListener,

17 -} from 'shared/ReactTypes';

18 -

19 -import React from 'react';

20 -import {DiscreteEvent, UserBlockingEvent} from 'shared/ReactTypes';

21 -

22 -const targetEventTypes = ['pointerdown'];

23 -const rootEventTypes = ['pointerup', 'pointercancel', 'pointermove_active'];

24 -

25 -type DragProps = {

26 - disabled: boolean,

27 - shouldClaimOwnership: () => boolean,

28 - onDragStart: (e: DragEvent) => void,

29 - onDragMove: (e: DragEvent) => void,

30 - onDragEnd: (e: DragEvent) => void,

31 - onDragChange: boolean => void,

32 - ...

33 -};

34 -

35 -type DragState = {|

36 - dragTarget: null | Element | Document,

37 - isPointerDown: boolean,

38 - isDragging: boolean,

39 - startX: number,

40 - startY: number,

41 - x: number,

42 - y: number,

43 -|};

44 -

45 -// In the case we don't have PointerEvents (Safari), we listen to touch events

46 -// too

47 -if (typeof window !== 'undefined' && window.PointerEvent === undefined) {

48 - targetEventTypes.push('touchstart', 'mousedown');

49 - rootEventTypes.push(

50 - 'mouseup',

51 - 'mousemove',

52 - 'touchend',

53 - 'touchcancel',

54 - 'touchmove_active',

55 - );

56 -}

57 -

58 -type EventData = {

59 - diffX: number,

60 - diffY: number,

61 - ...

62 -};

63 -type DragEventType = 'dragstart' | 'dragend' | 'dragchange' | 'dragmove';

64 -

65 -type DragEvent = {|

66 - target: Element | Document,

67 - type: DragEventType,

68 - timeStamp: number,

69 - diffX?: number,

70 - diffY?: number,

71 -|};

72 -

73 -function createDragEvent(

74 - context: ReactDOMResponderContext,

75 - type: DragEventType,

76 - target: Element | Document,

77 - eventData?: EventData,

78 -): DragEvent {

79 - return {

80 - target,

81 - type,

82 - timeStamp: context.getTimeStamp(),

83 - ...eventData,

84 - };

85 -}

86 -

87 -function isFunction(obj): boolean {

88 - return typeof obj === 'function';

89 -}

90 -

91 -function dispatchDragEvent(

92 - context: ReactDOMResponderContext,

93 - listener: DragEvent => void,

94 - name: DragEventType,

95 - state: DragState,

96 - eventPriority: EventPriority,

97 - eventData?: EventData,

98 -): void {

99 - const target = ((state.dragTarget: any): Element | Document);

100 - const syntheticEvent = createDragEvent(context, name, target, eventData);

101 - context.dispatchEvent(syntheticEvent, listener, eventPriority);

102 -}

103 -

104 -const dragResponderImpl = {

105 - targetEventTypes,

106 - getInitialState(): DragState {

107 - return {

108 - dragTarget: null,

109 - isPointerDown: false,

110 - isDragging: false,

111 - startX: 0,

112 - startY: 0,

113 - x: 0,

114 - y: 0,

115 - };

116 - },

117 - onEvent(

118 - event: ReactDOMResponderEvent,

119 - context: ReactDOMResponderContext,

120 - props: DragProps,

121 - state: DragState,

122 - ): void {

123 - const {target, type, nativeEvent} = event;

124 -

125 - switch (type) {

126 - case 'touchstart':

127 - case 'mousedown':

128 - case 'pointerdown': {

129 - if (!state.isDragging) {

130 - const obj =

131 - type === 'touchstart'

132 - ? (nativeEvent: any).changedTouches[0]

133 - : nativeEvent;

134 - const x = (state.startX = (obj: any).screenX);

135 - const y = (state.startY = (obj: any).screenY);

136 - state.x = x;

137 - state.y = y;

138 - state.dragTarget = target;

139 - state.isPointerDown = true;

140 - const onDragStart = props.onDragStart;

141 -

142 - if (isFunction(onDragStart)) {

143 - dispatchDragEvent(

144 - context,

145 - onDragStart,

146 - 'dragstart',

147 - state,

148 - DiscreteEvent,

149 - );

150 - }

151 - context.addRootEventTypes(rootEventTypes);

152 - }

153 - break;

154 - }

155 - }

156 - },

157 - onRootEvent(

158 - event: ReactDOMResponderEvent,

159 - context: ReactDOMResponderContext,

160 - props: DragProps,

161 - state: DragState,

162 - ): void {

163 - const {type, nativeEvent} = event;

164 -

165 - switch (type) {

166 - case 'touchmove':

167 - case 'mousemove':

168 - case 'pointermove': {

169 - if (event.passive) {

170 - return;

171 - }

172 - if (state.isPointerDown) {

173 - const obj =

174 - type === 'touchmove'

175 - ? (nativeEvent: any).changedTouches[0]

176 - : nativeEvent;

177 - const x = (obj: any).screenX;

178 - const y = (obj: any).screenY;

179 - state.x = x;

180 - state.y = y;

181 - if (x === state.startX && y === state.startY) {

182 - return;

183 - }

184 - if (!state.isDragging) {

185 - state.isDragging = true;

186 - const onDragChange = props.onDragChange;

187 - if (isFunction(onDragChange)) {

188 - context.dispatchEvent(true, onDragChange, UserBlockingEvent);

189 - }

190 - } else {

191 - const onDragMove = props.onDragMove;

192 - if (isFunction(onDragMove)) {

193 - const eventData = {

194 - diffX: x - state.startX,

195 - diffY: y - state.startY,

196 - };

197 - dispatchDragEvent(

198 - context,

199 - onDragMove,

200 - 'dragmove',

201 - state,

202 - UserBlockingEvent,

203 - eventData,

204 - );

205 - }

206 - (nativeEvent: any).preventDefault();

207 - }

208 - }

209 - break;

210 - }

211 - case 'pointercancel':

212 - case 'touchcancel':

213 - case 'touchend':

214 - case 'mouseup':

215 - case 'pointerup': {

216 - if (state.isDragging) {

217 - const onDragEnd = props.onDragEnd;

218 - if (isFunction(onDragEnd)) {

219 - dispatchDragEvent(

220 - context,

221 - onDragEnd,

222 - 'dragend',

223 - state,

224 - DiscreteEvent,

225 - );

226 - }

227 - const onDragChange = props.onDragChange;

228 - if (isFunction(onDragChange)) {

229 - context.dispatchEvent(false, onDragChange, UserBlockingEvent);

230 - }

231 - state.isDragging = false;

232 - }

233 - if (state.isPointerDown) {

234 - state.dragTarget = null;

235 - state.isPointerDown = false;

236 - context.removeRootEventTypes(rootEventTypes);

237 - }

238 - break;

239 - }

240 - }

241 - },

242 -};

243 -

244 -export const DragResponder = React.DEPRECATED_createResponder(

245 - 'Drag',

246 - dragResponderImpl,

247 -);

248 -

249 -export function useDrag(

250 - props: DragProps,

251 -): ReactEventResponderListener<any, any> {

252 - return React.DEPRECATED_useResponder(DragResponder, props);

253 -}

packages/react-interactions/events/src/dom/Scroll.js deleted

-319

@@ -1,319 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -import type {

11 - ReactDOMResponderEvent,

12 - ReactDOMResponderContext,

13 - PointerType,

14 -} from 'shared/ReactDOMTypes';

15 -import {UserBlockingEvent} from 'shared/ReactTypes';

16 -import type {

17 - EventPriority,

18 - ReactEventResponderListener,

19 -} from 'shared/ReactTypes';

20 -

21 -import React from 'react';

22 -

23 -type ScrollProps = {

24 - disabled: boolean,

25 - onScroll: ScrollEvent => void,

26 - onScrollDragStart: ScrollEvent => void,

27 - onScrollDragEnd: ScrollEvent => void,

28 - ...

29 -};

30 -

31 -type ScrollState = {

32 - direction: ScrollDirection,

33 - pointerType: PointerType,

34 - scrollTarget: null | Element | Document,

35 - isDragging: boolean,

36 - isTouching: boolean,

37 - scrollLeft: number,

38 - scrollTop: number,

39 - ...

40 -};

41 -

42 -type ScrollEventType =

43 - | 'scroll'

44 - | 'scrolldragstart'

45 - | 'scrolldragend'

46 - | 'scrollmomentumstart'

47 - | 'scrollmomentumend';

48 -

49 -type ScrollDirection = '' | 'up' | 'down' | 'left' | 'right';

50 -

51 -type ScrollEvent = {|

52 - direction: ScrollDirection,

53 - target: Element | Document,

54 - type: ScrollEventType,

55 - pointerType: PointerType,

56 - timeStamp: number,

57 - clientX: null | number,

58 - clientY: null | number,

59 - pageX: null | number,

60 - pageY: null | number,

61 - screenX: null | number,

62 - screenY: null | number,

63 - x: null | number,

64 - y: null | number,

65 -|};

66 -

67 -const hasPointerEvents =

68 - typeof window !== 'undefined' && window.PointerEvent !== undefined;

69 -

70 -const targetEventTypes = hasPointerEvents

71 - ? ['scroll', 'pointerdown', 'keyup', 'wheel']

72 - : ['scroll', 'mousedown', 'touchstart', 'keyup', 'wheel'];

73 -

74 -const rootEventTypes = hasPointerEvents

75 - ? ['pointercancel', 'pointerup']

76 - : ['touchcancel', 'touchend'];

77 -

78 -function isFunction(obj): boolean {

79 - return typeof obj === 'function';

80 -}

81 -

82 -function createScrollEvent(

83 - event: ?ReactDOMResponderEvent,

84 - context: ReactDOMResponderContext,

85 - type: ScrollEventType,

86 - target: Element | Document,

87 - pointerType: PointerType,

88 - direction: ScrollDirection,

89 -): ScrollEvent {

90 - let clientX = null;

91 - let clientY = null;

92 - let pageX = null;

93 - let pageY = null;

94 - let screenX = null;

95 - let screenY = null;

96 -

97 - if (event) {

98 - const nativeEvent = (event.nativeEvent: any);

99 - ({clientX, clientY, pageX, pageY, screenX, screenY} = nativeEvent);

100 - }

101 -

102 - return {

103 - target,

104 - type,

105 - pointerType,

106 - direction,

107 - timeStamp: context.getTimeStamp(),

108 - clientX,

109 - clientY,

110 - pageX,

111 - pageY,

112 - screenX,

113 - screenY,

114 - x: clientX,

115 - y: clientY,

116 - };

117 -}

118 -

119 -function dispatchEvent(

120 - event: ?ReactDOMResponderEvent,

121 - listener: ScrollEvent => void,

122 - context: ReactDOMResponderContext,

123 - state: ScrollState,

124 - name: ScrollEventType,

125 - eventPriority: EventPriority,

126 -): void {

127 - const target = ((state.scrollTarget: any): Element | Document);

128 - const pointerType = state.pointerType;

129 - const direction = state.direction;

130 - const syntheticEvent = createScrollEvent(

131 - event,

132 - context,

133 - name,

134 - target,

135 - pointerType,

136 - direction,

137 - );

138 - context.dispatchEvent(syntheticEvent, listener, eventPriority);

139 -}

140 -

141 -const scrollResponderImpl = {

142 - targetEventTypes,

143 - getInitialState() {

144 - return {

145 - direction: '',

146 - isTouching: false,

147 - pointerType: '',

148 - prevScrollTop: 0,

149 - prevScrollLeft: 0,

150 - scrollTarget: null,

151 - };

152 - },

153 - onEvent(

154 - event: ReactDOMResponderEvent,

155 - context: ReactDOMResponderContext,

156 - props: ScrollProps,

157 - state: ScrollState,

158 - ): void {

159 - const {pointerType, target, type} = event;

160 -

161 - if (props.disabled) {

162 - if (state.isTouching) {

163 - state.isTouching = false;

164 - state.scrollTarget = null;

165 - state.isDragging = false;

166 - state.direction = '';

167 - context.removeRootEventTypes(rootEventTypes);

168 - }

169 - return;

170 - }

171 -

172 - switch (type) {

173 - case 'scroll': {

174 - const prevScrollTarget = state.scrollTarget;

175 - let scrollLeft = 0;

176 - let scrollTop = 0;

177 -

178 - // Check if target is the document

179 - if (target.nodeType === 9) {

180 - const bodyNode = ((target: any): Document).body;

181 - if (bodyNode !== null) {

182 - scrollLeft = bodyNode.offsetLeft;

183 - scrollTop = bodyNode.offsetTop;

184 - }

185 - } else {

186 - scrollLeft = ((target: any): Element).scrollLeft;

187 - scrollTop = ((target: any): Element).scrollTop;

188 - }

189 -

190 - if (prevScrollTarget !== null) {

191 - if (scrollTop === state.scrollTop) {

192 - if (scrollLeft > state.scrollLeft) {

193 - state.direction = 'right';

194 - } else {

195 - state.direction = 'left';

196 - }

197 - } else {

198 - if (scrollTop > state.scrollTop) {

199 - state.direction = 'down';

200 - } else {

201 - state.direction = 'up';

202 - }

203 - }

204 - } else {

205 - state.direction = '';

206 - }

207 - state.scrollTarget = ((target: any): Element | Document);

208 - state.scrollLeft = scrollLeft;

209 - state.scrollTop = scrollTop;

210 -

211 - if (state.isTouching && !state.isDragging) {

212 - state.isDragging = true;

213 - const onScrollDragStart = props.onScrollDragStart;

214 -

215 - if (isFunction(onScrollDragStart)) {

216 - dispatchEvent(

217 - event,

218 - onScrollDragStart,

219 - context,

220 - state,

221 - 'scrolldragstart',

222 - UserBlockingEvent,

223 - );

224 - }

225 - }

226 - const onScroll = props.onScroll;

227 -

228 - if (isFunction(onScroll)) {

229 - dispatchEvent(

230 - event,

231 - onScroll,

232 - context,

233 - state,

234 - 'scroll',

235 - UserBlockingEvent,

236 - );

237 - }

238 - break;

239 - }

240 - case 'keyup': {

241 - state.pointerType = pointerType;

242 - break;

243 - }

244 - case 'mousedown':

245 - case 'wheel': {

246 - state.pointerType = 'mouse';

247 - break;

248 - }

249 - case 'pointerdown': {

250 - state.pointerType = pointerType;

251 - if (pointerType === 'touch' && !state.isTouching) {

252 - state.isTouching = true;

253 - context.addRootEventTypes(rootEventTypes);

254 - }

255 - break;

256 - }

257 - case 'touchstart': {

258 - if (!state.isTouching) {

259 - state.isTouching = true;

260 - state.pointerType = 'touch';

261 - context.addRootEventTypes(rootEventTypes);

262 - }

263 - }

264 - }

265 - },

266 - onRootEvent(

267 - event: ReactDOMResponderEvent,

268 - context: ReactDOMResponderContext,

269 - props: ScrollProps,

270 - state: ScrollState,

271 - ) {

272 - const {type} = event;

273 -

274 - switch (type) {

275 - case 'pointercancel':

276 - case 'pointerup':

277 - case 'touchcancel':

278 - case 'touchend': {

279 - if (state.isTouching) {

280 - const onScrollDragEnd = props.onScrollDragEnd;

281 -

282 - if (state.isDragging && isFunction(onScrollDragEnd)) {

283 - dispatchEvent(

284 - event,

285 - onScrollDragEnd,

286 - context,

287 - state,

288 - 'scrolldragend',

289 - UserBlockingEvent,

290 - );

291 - }

292 - state.isTouching = false;

293 - state.isDragging = false;

294 - state.scrollTarget = null;

295 - state.pointerType = '';

296 - context.removeRootEventTypes(rootEventTypes);

297 - }

298 - }

299 - }

300 - },

301 - onUnmount(

302 - context: ReactDOMResponderContext,

303 - props: ScrollProps,

304 - state: ScrollState,

305 - ) {

306 - // TODO

307 - },

308 -};

309 -

310 -export const ScrollResponder = React.DEPRECATED_createResponder(

311 - 'Scroll',

312 - scrollResponderImpl,

313 -);

314 -

315 -export function useScroll(

316 - props: ScrollProps,

317 -): ReactEventResponderListener<any, any> {

318 - return React.DEPRECATED_useResponder(ScrollResponder, props);

319 -}

packages/react-interactions/events/src/dom/Swipe.js deleted

-291

@@ -1,291 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -import type {

11 - ReactDOMResponderEvent,

12 - ReactDOMResponderContext,

13 -} from 'shared/ReactDOMTypes';

14 -import type {

15 - EventPriority,

16 - ReactEventResponderListener,

17 -} from 'shared/ReactTypes';

18 -

19 -import React from 'react';

20 -import {UserBlockingEvent, DiscreteEvent} from 'shared/ReactTypes';

21 -

22 -type SwipeProps = {

23 - disabled: boolean,

24 - shouldClaimOwnership: () => boolean,

25 - onSwipeMove: (e: SwipeEvent) => void,

26 - onSwipeEnd: (e: SwipeEvent) => void,

27 - onSwipeLeft: (e: SwipeEvent) => void,

28 - onSwipeRight: (e: SwipeEvent) => void,

29 - ...

30 -};

31 -

32 -const targetEventTypes = ['pointerdown'];

33 -const rootEventTypes = ['pointerup', 'pointercancel', 'pointermove_active'];

34 -

35 -// In the case we don't have PointerEvents (Safari), we listen to touch events

36 -// too

37 -if (typeof window !== 'undefined' && window.PointerEvent === undefined) {

38 - targetEventTypes.push('touchstart', 'mousedown');

39 - rootEventTypes.push(

40 - 'mouseup',

41 - 'mousemove',

42 - 'touchend',

43 - 'touchcancel',

44 - 'touchmove_active',

45 - );

46 -}

47 -

48 -type EventData = {

49 - diffX: number,

50 - diffY: number,

51 - ...

52 -};

53 -type SwipeEventType = 'swipeleft' | 'swiperight' | 'swipeend' | 'swipemove';

54 -

55 -type SwipeEvent = {|

56 - target: Element | Document,

57 - type: SwipeEventType,

58 - timeStamp: number,

59 - diffX?: number,

60 - diffY?: number,

61 -|};

62 -

63 -function isFunction(obj): boolean {

64 - return typeof obj === 'function';

65 -}

66 -

67 -function createSwipeEvent(

68 - context: ReactDOMResponderContext,

69 - type: SwipeEventType,

70 - target: Element | Document,

71 - eventData?: EventData,

72 -): SwipeEvent {

73 - return context.objectAssign(

74 - {

75 - target,

76 - type,

77 - timeStamp: context.getTimeStamp(),

78 - },

79 - eventData,

80 - );

81 -}

82 -

83 -function dispatchSwipeEvent(

84 - context: ReactDOMResponderContext,

85 - listener: SwipeEvent => void,

86 - name: SwipeEventType,

87 - state: SwipeState,

88 - eventPriority: EventPriority,

89 - eventData?: EventData,

90 -) {

91 - const target = ((state.swipeTarget: any): Element | Document);

92 - const syntheticEvent = createSwipeEvent(context, name, target, eventData);

93 - context.dispatchEvent(syntheticEvent, listener, eventPriority);

94 -}

95 -

96 -type SwipeState = {

97 - direction: number,

98 - isSwiping: boolean,

99 - lastDirection: number,

100 - startX: number,

101 - startY: number,

102 - touchId: null | number,

103 - swipeTarget: null | Element | Document,

104 - x: number,

105 - y: number,

106 - ...

107 -};

108 -

109 -const swipeResponderImpl = {

110 - targetEventTypes,

111 - getInitialState(): SwipeState {

112 - return {

113 - direction: 0,

114 - isSwiping: false,

115 - lastDirection: 0,

116 - startX: 0,

117 - startY: 0,

118 - touchId: null,

119 - swipeTarget: null,

120 - x: 0,

121 - y: 0,

122 - };

123 - },

124 - onEvent(

125 - event: ReactDOMResponderEvent,

126 - context: ReactDOMResponderContext,

127 - props: SwipeProps,

128 - state: SwipeState,

129 - ): void {

130 - const {target, type, nativeEvent} = event;

131 -

132 - switch (type) {

133 - case 'touchstart':

134 - case 'mousedown':

135 - case 'pointerdown': {

136 - if (!state.isSwiping) {

137 - let obj = nativeEvent;

138 - if (type === 'touchstart') {

139 - obj = (nativeEvent: any).targetTouches[0];

140 - state.touchId = obj.identifier;

141 - }

142 - const x = (obj: any).screenX;

143 - const y = (obj: any).screenY;

144 -

145 - state.isSwiping = true;

146 - state.startX = x;

147 - state.startY = y;

148 - state.x = x;

149 - state.y = y;

150 - state.swipeTarget = target;

151 - context.addRootEventTypes(rootEventTypes);

152 - }

153 - break;

154 - }

155 - }

156 - },

157 - onRootEvent(

158 - event: ReactDOMResponderEvent,

159 - context: ReactDOMResponderContext,

160 - props: SwipeProps,

161 - state: SwipeState,

162 - ): void {

163 - const {type, nativeEvent} = event;

164 -

165 - switch (type) {

166 - case 'touchmove':

167 - case 'mousemove':

168 - case 'pointermove': {

169 - if (event.passive) {

170 - return;

171 - }

172 - if (state.isSwiping) {

173 - let obj = null;

174 - if (type === 'touchmove') {

175 - const targetTouches = (nativeEvent: any).targetTouches;

176 - for (let i = 0; i < targetTouches.length; i++) {

177 - if (state.touchId === targetTouches[i].identifier) {

178 - obj = targetTouches[i];

179 - break;

180 - }

181 - }

182 - } else {

183 - obj = nativeEvent;

184 - }

185 - if (obj === null) {

186 - state.isSwiping = false;

187 - state.swipeTarget = null;

188 - state.touchId = null;

189 - context.removeRootEventTypes(rootEventTypes);

190 - return;

191 - }

192 - const x = (obj: any).screenX;

193 - const y = (obj: any).screenY;

194 - if (x < state.x) {

195 - state.direction = 3;

196 - } else if (x > state.x) {

197 - state.direction = 1;

198 - }

199 - state.x = x;

200 - state.y = y;

201 - const eventData = {

202 - diffX: x - state.startX,

203 - diffY: y - state.startY,

204 - };

205 - const onSwipeMove = props.onSwipeMove;

206 -

207 - if (isFunction(onSwipeMove)) {

208 - dispatchSwipeEvent(

209 - context,

210 - onSwipeMove,

211 - 'swipemove',

212 - state,

213 - UserBlockingEvent,

214 - eventData,

215 - );

216 - }

217 - (nativeEvent: any).preventDefault();

218 - }

219 - break;

220 - }

221 - case 'pointercancel':

222 - case 'touchcancel':

223 - case 'touchend':

224 - case 'mouseup':

225 - case 'pointerup': {

226 - if (state.isSwiping) {

227 - if (state.x === state.startX && state.y === state.startY) {

228 - return;

229 - }

230 - const direction = state.direction;

231 - const lastDirection = state.lastDirection;

232 - if (direction !== lastDirection) {

233 - if (direction === 3) {

234 - const onSwipeLeft = props.onSwipeLeft;

235 -

236 - if (isFunction(onSwipeLeft)) {

237 - dispatchSwipeEvent(

238 - context,

239 - onSwipeLeft,

240 - 'swipeleft',

241 - state,

242 - DiscreteEvent,

243 - );

244 - }

245 - } else if (direction === 1) {

246 - const onSwipeRight = props.onSwipeRight;

247 -

248 - if (isFunction(onSwipeRight)) {

249 - dispatchSwipeEvent(

250 - context,

251 - onSwipeRight,

252 - 'swiperight',

253 - state,

254 - DiscreteEvent,

255 - );

256 - }

257 - }

258 - }

259 - const onSwipeEnd = props.onSwipeEnd;

260 -

261 - if (isFunction(onSwipeEnd)) {

262 - dispatchSwipeEvent(

263 - context,

264 - onSwipeEnd,

265 - 'swipeend',

266 - state,

267 - DiscreteEvent,

268 - );

269 - }

270 - state.lastDirection = direction;

271 - state.isSwiping = false;

272 - state.swipeTarget = null;

273 - state.touchId = null;

274 - context.removeRootEventTypes(rootEventTypes);

275 - }

276 - break;

277 - }

278 - }

279 - },

280 -};

281 -

282 -export const SwipeResponder = React.DEPRECATED_createResponder(

283 - 'Swipe',

284 - swipeResponderImpl,

285 -);

286 -

287 -export function useSwipe(

288 - props: SwipeProps,

289 -): ReactEventResponderListener<any, any> {

290 - return React.DEPRECATED_useResponder(SwipeResponder, props);

291 -}

packages/react-interactions/events/src/dom/__tests__/Drag-test.internal.js deleted

-205

@@ -1,205 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @emails react-core

8 - */

9 -

10 -'use strict';

11 -

12 -let React;

13 -let ReactFeatureFlags;

14 -let ReactDOM;

15 -let useDrag;

16 -

17 -describe('Drag event responder', () => {

18 - let container;

19 -

20 - beforeEach(() => {

21 - jest.resetModules();

22 - ReactFeatureFlags = require('shared/ReactFeatureFlags');

23 - ReactFeatureFlags.enableDeprecatedFlareAPI = true;

24 - React = require('react');

25 - ReactDOM = require('react-dom');

26 - useDrag = require('react-interactions/events/drag').useDrag;

27 -

28 - container = document.createElement('div');

29 - document.body.appendChild(container);

30 - });

31 -

32 - afterEach(() => {

33 - ReactDOM.render(null, container);

34 - document.body.removeChild(container);

35 - container = null;

36 - });

37 -

38 - it('should support onDragChange', () => {

39 - let divRef = React.createRef();

40 - let events = [];

41 -

42 - function handleOnDrag() {

43 - events.push({isChanged: true});

44 - }

45 -

46 - function Component() {

47 - const listener = useDrag({

48 - onDragChange: handleOnDrag,

49 - });

50 - return (

51 - <div ref={divRef} DEPRECATED_flareListeners={listener}>

52 - Drag me!

53 - </div>

54 - );

55 - }

56 -

57 - ReactDOM.render(<Component />, container);

58 -

59 - const mouseOverEvent = document.createEvent('MouseEvents');

60 - mouseOverEvent.initEvent('mousedown', true, true);

61 - divRef.current.dispatchEvent(mouseOverEvent);

62 -

63 - const mouseMoveEvent = document.createEvent('MouseEvents');

64 - for (let index = 0; index <= 20; index++) {

65 - mouseMoveEvent.initMouseEvent(

66 - 'mousemove',

67 - true,

68 - true,

69 - window,

70 - 1,

71 - index,

72 - index,

73 - 50,

74 - 50,

75 - );

76 - divRef.current.dispatchEvent(mouseMoveEvent);

77 - }

78 - divRef.current.dispatchEvent(mouseMoveEvent);

79 -

80 - const mouseUpEvent = document.createEvent('MouseEvents');

81 - mouseUpEvent.initEvent('mouseup', true, true);

82 - divRef.current.dispatchEvent(mouseUpEvent);

83 -

84 - expect(events).toHaveLength(2);

85 - expect(events).toEqual(

86 - expect.arrayContaining([expect.objectContaining({isChanged: true})]),

87 - );

88 - });

89 -

90 - it('should support onDragStart and onDragEnd', () => {

91 - let divRef = React.createRef();

92 - let events = [];

93 -

94 - function handleDragStart() {

95 - events.push('dragstart');

96 - }

97 -

98 - function handleDragEnd() {

99 - events.push('dragend');

100 - }

101 -

102 - function Component() {

103 - const listener = useDrag({

104 - onDragStart: handleDragStart,

105 - onDragEnd: handleDragEnd,

106 - });

107 - return (

108 - <div ref={divRef} DEPRECATED_flareListeners={listener}>

109 - Drag me!

110 - </div>

111 - );

112 - }

113 -

114 - ReactDOM.render(<Component />, container);

115 -

116 - const mouseOverEvent = document.createEvent('MouseEvents');

117 - mouseOverEvent.initEvent('mousedown', true, true);

118 - divRef.current.dispatchEvent(mouseOverEvent);

119 -

120 - const mouseMoveEvent = document.createEvent('MouseEvents');

121 - for (let index = 0; index <= 20; index++) {

122 - mouseMoveEvent.initMouseEvent(

123 - 'mousemove',

124 - true,

125 - true,

126 - window,

127 - 1,

128 - index,

129 - index,

130 - 50,

131 - 50,

132 - );

133 - divRef.current.dispatchEvent(mouseMoveEvent);

134 - }

135 - divRef.current.dispatchEvent(mouseMoveEvent);

136 -

137 - const mouseUpEvent = document.createEvent('MouseEvents');

138 - mouseUpEvent.initEvent('mouseup', true, true);

139 - divRef.current.dispatchEvent(mouseUpEvent);

140 -

141 - expect(events).toEqual(['dragstart', 'dragend']);

142 - });

143 -

144 - it('should support onDragMove', () => {

145 - let divRef = React.createRef();

146 - let events = [];

147 -

148 - function handleDragMove(e) {

149 - events.push({

150 - diffX: e.diffX,

151 - diffY: e.diffY,

152 - });

153 - }

154 -

155 - function Component() {

156 - const listener = useDrag({

157 - onDragMove: handleDragMove,

158 - });

159 - return (

160 - <div ref={divRef} DEPRECATED_flareListeners={listener}>

161 - Drag me!

162 - </div>

163 - );

164 - }

165 -

166 - ReactDOM.render(<Component />, container);

167 -

168 - const mouseOverEvent = document.createEvent('MouseEvents');

169 - mouseOverEvent.initEvent('mousedown', true, true, window, 1, 0, 0);

170 - divRef.current.dispatchEvent(mouseOverEvent);

171 -

172 - const mouseMoveEvent = document.createEvent('MouseEvents');

173 - for (let index = 0; index <= 20; index++) {

174 - mouseMoveEvent.initMouseEvent(

175 - 'mousemove',

176 - true,

177 - true,

178 - window,

179 - 1,

180 - index + 1,

181 - index + 1,

182 - 50,

183 - 50,

184 - );

185 - divRef.current.dispatchEvent(mouseMoveEvent);

186 - }

187 -

188 - const mouseUpEvent = document.createEvent('MouseEvents');

189 - mouseUpEvent.initEvent('mouseup', true, true);

190 - divRef.current.dispatchEvent(mouseUpEvent);

191 - expect(events).toHaveLength(20);

192 - expect(events).toEqual(

193 - expect.arrayContaining([

194 - expect.objectContaining({

195 - diffX: 2,

196 - diffY: 2,

197 - }),

198 - expect.objectContaining({

199 - diffX: 21,

200 - diffY: 21,

201 - }),

202 - ]),

203 - );

204 - });

205 -});

packages/react-interactions/events/src/dom/__tests__/Scroll-test.internal.js deleted

-201

@@ -1,201 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @emails react-core

8 - */

9 -

10 -'use strict';

11 -

12 -import {createEventTarget, setPointerEvent} from 'dom-event-testing-library';

13 -

14 -let React;

15 -let ReactFeatureFlags;

16 -let ReactDOM;

17 -let useScroll;

18 -

19 -const forcePointerEvents = true;

20 -const table = [[forcePointerEvents], [!forcePointerEvents]];

21 -

22 -const initializeModules = hasPointerEvents => {

23 - setPointerEvent(hasPointerEvents);

24 - jest.resetModules();

25 - ReactFeatureFlags = require('shared/ReactFeatureFlags');

26 - ReactFeatureFlags.enableDeprecatedFlareAPI = true;

27 - React = require('react');

28 - ReactDOM = require('react-dom');

29 - useScroll = require('react-interactions/events/scroll').useScroll;

30 -};

31 -

32 -describe.each(table)('Scroll responder', hasPointerEvents => {

33 - let container;

34 -

35 - beforeEach(() => {

36 - initializeModules(hasPointerEvents);

37 - container = document.createElement('div');

38 - document.body.appendChild(container);

39 - });

40 -

41 - afterEach(() => {

42 - ReactDOM.render(null, container);

43 - document.body.removeChild(container);

44 - container = null;

45 - });

46 -

47 - describe('disabled', () => {

48 - let onScroll, ref;

49 -

50 - beforeEach(() => {

51 - onScroll = jest.fn();

52 - ref = React.createRef();

53 - const Component = () => {

54 - const listener = useScroll({

55 - disabled: true,

56 - onScroll,

57 - });

58 - return <div ref={ref} DEPRECATED_flareListeners={listener} />;

59 - };

60 - ReactDOM.render(<Component />, container);

61 - });

62 -

63 - it('prevents custom events being dispatched', () => {

64 - const target = createEventTarget(ref.current);

65 - target.scroll();

66 - expect(onScroll).not.toBeCalled();

67 - });

68 - });

69 -

70 - describe('onScroll', () => {

71 - let onScroll, ref;

72 -

73 - beforeEach(() => {

74 - onScroll = jest.fn();

75 - ref = React.createRef();

76 - const Component = () => {

77 - const listener = useScroll({

78 - onScroll,

79 - });

80 - return <div ref={ref} DEPRECATED_flareListeners={listener} />;

81 - };

82 - ReactDOM.render(<Component />, container);

83 - });

84 -

85 - describe('is called after "scroll" event', () => {

86 - const pointerTypesTable = hasPointerEvents

87 - ? [['mouse'], ['touch'], ['pen']]

88 - : [['mouse'], ['touch']];

89 - it.each(pointerTypesTable)('with pointerType: %s', pointerType => {

90 - const node = ref.current;

91 - const target = createEventTarget(node);

92 - target.pointerdown({pointerType});

93 - target.scroll();

94 - expect(onScroll).toHaveBeenCalledTimes(1);

95 - expect(onScroll).toHaveBeenCalledWith(

96 - expect.objectContaining({

97 - pointerType,

98 - type: 'scroll',

99 - direction: '',

100 - }),

101 - );

102 - onScroll.mockReset();

103 - node.scrollTop = -1;

104 - target.scroll();

105 - expect(onScroll).toHaveBeenCalledWith(

106 - expect.objectContaining({

107 - pointerType,

108 - type: 'scroll',

109 - direction: 'up',

110 - }),

111 - );

112 - onScroll.mockReset();

113 - node.scrollTop = 1;

114 - target.scroll();

115 - expect(onScroll).toHaveBeenCalledWith(

116 - expect.objectContaining({

117 - pointerType,

118 - type: 'scroll',

119 - direction: 'down',

120 - }),

121 - );

122 - });

123 -

124 - it('with pointerType: keyboard', () => {

125 - const target = createEventTarget(ref.current);

126 - target.keydown({key: 'A'});

127 - target.keyup({key: 'A'});

128 - target.scroll();

129 - expect(onScroll).toHaveBeenCalledTimes(1);

130 - expect(onScroll).toHaveBeenCalledWith(

131 - expect.objectContaining({

132 - pointerType: 'keyboard',

133 - type: 'scroll',

134 - direction: '',

135 - }),

136 - );

137 - });

138 - });

139 - });

140 -

141 - describe('onScrollDragStart', () => {

142 - let onScrollDragStart, ref;

143 -

144 - beforeEach(() => {

145 - onScrollDragStart = jest.fn();

146 - ref = React.createRef();

147 - const Component = () => {

148 - const listener = useScroll({

149 - onScrollDragStart,

150 - });

151 - return <div ref={ref} DEPRECATED_flareListeners={listener} />;

152 - };

153 - ReactDOM.render(<Component />, container);

154 - });

155 -

156 - it('works as expected with touch events', () => {

157 - const target = createEventTarget(ref.current);

158 - target.pointerdown({pointerType: 'touch'});

159 - target.scroll();

160 - expect(onScrollDragStart).toHaveBeenCalledTimes(1);

161 - expect(onScrollDragStart).toHaveBeenCalledWith(

162 - expect.objectContaining({

163 - pointerType: 'touch',

164 - type: 'scrolldragstart',

165 - direction: '',

166 - }),

167 - );

168 - });

169 - });

170 -

171 - describe('onScrollDragEnd', () => {

172 - let onScrollDragEnd, ref;

173 -

174 - beforeEach(() => {

175 - onScrollDragEnd = jest.fn();

176 - ref = React.createRef();

177 - const Component = () => {

178 - const listener = useScroll({

179 - onScrollDragEnd,

180 - });

181 - return <div ref={ref} DEPRECATED_flareListeners={listener} />;

182 - };

183 - ReactDOM.render(<Component />, container);

184 - });

185 -

186 - it('works as expected with touch events', () => {

187 - const target = createEventTarget(ref.current);

188 - target.pointerdown({pointerType: 'touch'});

189 - target.scroll();

190 - target.pointerup({pointerType: 'touch'});

191 - expect(onScrollDragEnd).toHaveBeenCalledTimes(1);

192 - expect(onScrollDragEnd).toHaveBeenCalledWith(

193 - expect.objectContaining({

194 - pointerType: 'touch',

195 - type: 'scrolldragend',

196 - direction: '',

197 - }),

198 - );

199 - });

200 - });

201 -});

packages/react-interactions/events/swipe.js deleted

-12

@@ -1,12 +0,0 @@

1 -/**

2 - * Copyright (c) Facebook, Inc. and its affiliates.

3 - *

4 - * This source code is licensed under the MIT license found in the

5 - * LICENSE file in the root directory of this source tree.

6 - *

7 - * @flow

8 - */

9 -

10 -'use strict';

11 -

12 -module.exports = require('./src/dom/Swipe');

packages/react-interactions/package.json

-3

@@ -14,15 +14,12 @@

14 "README.md",

15 "events/README.md",

16 "events/context-menu.js",

17 - "events/drag.js",

17 "events/focus.js",

18 "events/hover.js",

19 "events/input.js",

20 "events/keyboard.js",

21 "events/press.js",

22 "events/press-legacy.js",

24 - "events/scroll.js",

25 - "events/swipe.js",

23 "events/tap.js",

24 "build-info.json",

25 "cjs/",

scripts/rollup/bundles.js

-45

@@ -578,21 +578,6 @@ const bundles = [

578 externals: ['react'],

579 },

580

581 - {

582 - bundleTypes: [

583 - UMD_DEV,

584 - UMD_PROD,

585 - NODE_DEV,

586 - NODE_PROD,

587 - FB_WWW_DEV,

588 - FB_WWW_PROD,

589 - ],

590 - moduleType: NON_FIBER_RENDERER,

591 - entry: 'react-interactions/events/drag',

592 - global: 'ReactEventsDrag',

593 - externals: ['react'],

594 - },

595 -

581 {

582 bundleTypes: [

583 UMD_DEV,

@@ -687,36 +672,6 @@ const bundles = [

672 externals: ['react'],

673 },

674

690 - {

691 - bundleTypes: [

692 - UMD_DEV,

693 - UMD_PROD,

694 - NODE_DEV,

695 - NODE_PROD,

696 - FB_WWW_DEV,

697 - FB_WWW_PROD,

698 - ],

699 - moduleType: NON_FIBER_RENDERER,

700 - entry: 'react-interactions/events/scroll',

701 - global: 'ReactEventsScroll',

702 - externals: ['react'],

703 - },

704 -

705 - {

706 - bundleTypes: [

707 - UMD_DEV,

708 - UMD_PROD,

709 - NODE_DEV,

710 - NODE_PROD,

711 - FB_WWW_DEV,

712 - FB_WWW_PROD,

713 - ],

714 - moduleType: NON_FIBER_RENDERER,

715 - entry: 'react-interactions/events/swipe',

716 - global: 'ReactEventsSwipe',

717 - externals: ['react'],

718 - },

719 -

675 {

676 bundleTypes: [

677 UMD_DEV,