@samitouri / QOS-React-2 / commits / 90e90ac8e0

Revert useEvent PRs (#18438)

* Revert "ReactDOM.useEvent: enable on internal www and add inspection test (#18395)" This reverts commit e0ab1a429d178d86e13f073f8451d24033bc1838. * Revert "ReactDOM.useEvent: Add support for experimental scopes API (#18375)" This reverts commit a16b34974508cd23ce0844ad09a0e37a879d5591. * ReactDOM.useEvent: Add support for experimental scopes API

Andrew Clark committed Mar 30, 2020 at 19:16 UTC 90e90ac8e0d16113b9566ef5feea3da11e5f4458

12 files changed +48 -357

packages/react-debug-tools/src/ReactDebugHooks.js

+1 -5

@@ -15,7 +15,6 @@ import type {

15 ReactProviderType,

16 ReactEventResponder,

17 ReactEventResponderListener,

18 - ReactScopeMethods,

18 } from 'shared/ReactTypes';

19 import type {Fiber} from 'react-reconciler/src/ReactFiber';

20 import type {Hook, TimeoutConfig} from 'react-reconciler/src/ReactFiberHooks';

@@ -45,10 +44,7 @@ type HookLogEntry = {

45 type ReactDebugListenerMap = {|

46 clear: () => void,

48 - setListener: (

49 - target: EventTarget | ReactScopeMethods,

50 - callback: ?(Event) => void,

51 - ) => void,

47 + setListener: (target: EventTarget, callback: ?(Event) => void) => void,

48 |};

50 let hookLog: Array<HookLogEntry> = [];

packages/react-debug-tools/src/__tests__/ReactHooksInspection-test.internal.js

-43

@@ -11,7 +11,6 @@

11 'use strict';

13 let React;

14 -let ReactDOM;

14 let ReactDebugTools;

16 describe('ReactHooksInspection', () => {

@@ -19,9 +18,7 @@ describe('ReactHooksInspection', () => {

18 jest.resetModules();

19 const ReactFeatureFlags = require('shared/ReactFeatureFlags');

20 ReactFeatureFlags.enableDeprecatedFlareAPI = true;

22 - ReactFeatureFlags.enableUseEventAPI = true;

21 React = require('react');

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

22 ReactDebugTools = require('react-debug-tools');

23 });

@@ -50,44 +47,4 @@ describe('ReactHooksInspection', () => {

47 },

48 ]);

49 });

53 -

54 - it('should inspect a simple ReactDOM.useEvent hook', () => {

55 - let clickHandle;

56 - let ref;

57 -

58 - const effect = () => {

59 - clickHandle.setListener(ref.current, () => {});

60 - };

61 -

62 - function Foo(props) {

63 - ref = React.useRef(null);

64 - clickHandle = ReactDOM.unstable_useEvent('click');

65 - React.useEffect(effect);

66 - return <div ref={ref}>Hello world</div>;

67 - }

68 - let tree = ReactDebugTools.inspectHooks(Foo, {});

69 - expect(tree).toEqual([

70 - {

71 - isStateEditable: false,

72 - id: 0,

73 - name: 'Ref',

74 - subHooks: [],

75 - value: null,

76 - },

77 - {

78 - isStateEditable: false,

79 - id: 1,

80 - name: 'Event',

81 - value: {capture: false, passive: undefined, priority: 0, type: 'click'},

82 - subHooks: [],

83 - },

84 - {

85 - isStateEditable: false,

86 - id: 2,

87 - name: 'Effect',

88 - value: effect,

89 - subHooks: [],

90 - },

91 - ]);

92 - });

50 });

packages/react-dom/src/client/ReactDOMComponent.js

-4

@@ -1348,10 +1348,6 @@ export function listenToEventResponderEventTypes(

1348 const targetEventType = isPassive

1349 ? eventType

1350 : eventType.substring(0, eventType.length - 7);

1351 - // We don't listen to this as we actually emulate it in the host config

1352 - if (targetEventType === 'beforeblur') {

1353 - continue;

1354 - }

1351 if (!listenerMap.has(eventKey)) {

1352 if (isPassive) {

1353 const activeKey = targetEventType + '_active';

packages/react-dom/src/client/ReactDOMHostConfig.js

+13 -24

@@ -9,15 +9,6 @@

10 import type {TopLevelType} from 'legacy-events/TopLevelEventTypes';

11 import type {RootType} from './ReactDOMRoot';

12 -import type {

13 - ReactDOMEventResponder,

14 - ReactDOMEventResponderInstance,

15 - ReactDOMFundamentalComponentInstance,

16 - ReactDOMListener,

17 - ReactDOMListenerEvent,

18 - ReactDOMListenerMap,

19 -} from '../shared/ReactDOMTypes';

20 -import type {ReactScopeMethods} from 'shared/ReactTypes';

13 import {

14 precacheFiberNode,

@@ -58,6 +49,14 @@ import {

49 } from '../shared/HTMLNodeType';

50 import dangerousStyleValue from '../shared/dangerousStyleValue';

52 +import type {

53 + ReactDOMEventResponder,

54 + ReactDOMEventResponderInstance,

55 + ReactDOMFundamentalComponentInstance,

56 + ReactDOMListener,

57 + ReactDOMListenerEvent,

58 + ReactDOMListenerMap,

59 +} from '../shared/ReactDOMTypes';

60 import {

61 mountEventResponder,

62 unmountEventResponder,

@@ -70,7 +69,6 @@ import {

69 enableDeprecatedFlareAPI,

70 enableFundamentalAPI,

71 enableUseEventAPI,

73 - enableScopeAPI,

72 } from 'shared/ReactFeatureFlags';

73 import {HostComponent} from 'react-reconciler/src/ReactWorkTags';

74 import {

@@ -81,13 +79,10 @@ import {

79 isManagedDOMElement,

80 isValidEventTarget,

81 listenToTopLevelEvent,

84 - attachListenerToManagedDOMElement,

82 detachListenerFromManagedDOMElement,

86 - attachTargetEventListener,

83 + attachListenerFromManagedDOMElement,

84 detachTargetEventListener,

88 - isReactScope,

89 - attachListenerToReactScope,

90 - detachListenerFromReactScope,

85 + attachTargetEventListener,

86 } from '../events/DOMModernPluginEventSystem';

87 import {getListenerMapForElement} from '../events/DOMEventListenerMap';

88 import {TOP_BEFORE_BLUR, TOP_AFTER_BLUR} from '../events/DOMTopLevelEventTypes';

@@ -1165,9 +1160,7 @@ export function mountEventListener(listener: ReactDOMListener): void {

1160 if (enableUseEventAPI) {

1161 const {target} = listener;

1162 if (isManagedDOMElement(target)) {

1168 - attachListenerToManagedDOMElement(listener);

1169 - } else if (enableScopeAPI && isReactScope(target)) {

1170 - attachListenerToReactScope(listener);

1163 + attachListenerFromManagedDOMElement(listener);

1164 } else {

1165 attachTargetEventListener(listener);

1166 }

@@ -1179,8 +1172,6 @@ export function unmountEventListener(listener: ReactDOMListener): void {

1172 const {target} = listener;

1173 if (isManagedDOMElement(target)) {

1174 detachListenerFromManagedDOMElement(listener);

1182 - } else if (enableScopeAPI && isReactScope(target)) {

1183 - detachListenerFromReactScope(listener);

1175 } else {

1176 detachTargetEventListener(listener);

1177 }

@@ -1188,15 +1179,13 @@ export function unmountEventListener(listener: ReactDOMListener): void {

1179 }

1180

1181 export function validateEventListenerTarget(

1191 - target: EventTarget | ReactScopeMethods,

1182 + target: EventTarget,

1183 listener: ?(Event) => void,

1184 ): boolean {

1185 if (enableUseEventAPI) {

1186 if (

1187 target != null &&

1197 - (isManagedDOMElement(target) ||

1198 - isValidEventTarget(target) ||

1199 - isReactScope(target))

1188 + (isManagedDOMElement(target) || isValidEventTarget(target))

1189 ) {

1190 if (listener == null || typeof listener === 'function') {

1191 return true;

packages/react-dom/src/events/DOMModernPluginEventSystem.js

+22 -93

@@ -14,7 +14,7 @@ import type {

14 ElementListenerMapEntry,

15 } from '../events/DOMEventListenerMap';

16 import type {EventSystemFlags} from 'legacy-events/EventSystemFlags';

17 -import type {EventPriority, ReactScopeMethods} from 'shared/ReactTypes';

17 +import type {EventPriority} from 'shared/ReactTypes';

18 import type {Fiber} from 'react-reconciler/src/ReactFiber';

19 import type {PluginModule} from 'legacy-events/PluginModuleType';

20 import type {

@@ -142,11 +142,8 @@ const emptyDispatchConfigForCustomEvents: CustomDispatchConfig = {

142

143 const isArray = Array.isArray;

144

145 -// TODO: we should remove the FlowFixMes and the casting to figure out how to make

146 -// these patterns work properly.

147 -// $FlowFixMe: Flow struggles with this pattern, so we also have to cast it.

148 -const PossiblyWeakMap = ((typeof WeakMap === 'function' ? WeakMap : Map): any);

149 -

145 +// $FlowFixMe: Flow struggles with this pattern

146 +const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;

147 // $FlowFixMe: Flow cannot handle polymorphic WeakMaps

148 export const eventTargetEventListenerStore: WeakMap<

149 EventTarget,

@@ -156,15 +153,6 @@ export const eventTargetEventListenerStore: WeakMap<

153 >,

154 > = new PossiblyWeakMap();

155

159 -// $FlowFixMe: Flow cannot handle polymorphic WeakMaps

160 -export const reactScopeListenerStore: WeakMap<

161 - ReactScopeMethods,

162 - Map<

163 - DOMTopLevelEventType,

164 - {bubbled: Set<ReactDOMListener>, captured: Set<ReactDOMListener>},

165 - >,

166 -> = new PossiblyWeakMap();

167 -

156 function dispatchEventsForPlugins(

157 topLevelType: DOMTopLevelEventType,

158 eventSystemFlags: EventSystemFlags,

@@ -318,20 +306,12 @@ function isMatchingRootContainer(

306 );

307 }

308

321 -export function isManagedDOMElement(

322 - target: EventTarget | ReactScopeMethods,

323 -): boolean {

309 +export function isManagedDOMElement(target: EventTarget): boolean {

310 return getClosestInstanceFromNode(((target: any): Node)) !== null;

311 }

312

327 -export function isValidEventTarget(

328 - target: EventTarget | ReactScopeMethods,

329 -): boolean {

330 - return typeof (target: Object).addEventListener === 'function';

331 -}

332 -

333 -export function isReactScope(target: EventTarget | ReactScopeMethods): boolean {

334 - return typeof (target: Object).getChildContextValues === 'function';

313 +export function isValidEventTarget(target: EventTarget): boolean {

314 + return typeof target.addEventListener === 'function';

315 }

316

317 export function dispatchEventForPluginEventSystem(

@@ -466,16 +446,18 @@ function addEventTypeToDispatchConfig(type: DOMTopLevelEventType): void {

446 }

447 }

448

469 -export function attachListenerToManagedDOMElement(

449 +export function attachListenerFromManagedDOMElement(

450 listener: ReactDOMListener,

451 ): void {

452 const {event, target} = listener;

453 const {passive, priority, type} = event;

474 -

475 - const managedTargetElement = ((target: any): Element);

476 - const containerEventTarget = getNearestRootOrPortalContainer(

477 - managedTargetElement,

478 - );

454 + const possibleManagedTarget = ((target: any): Element);

455 + let containerEventTarget = target;

456 + if (getClosestInstanceFromNode(possibleManagedTarget)) {

457 + containerEventTarget = getNearestRootOrPortalContainer(

458 + possibleManagedTarget,

459 + );

460 + }

461 const listenerMap = getListenerMapForElement(containerEventTarget);

462 // Add the event listener to the target container (falling back to

463 // the target if we didn't find one).

@@ -487,11 +469,11 @@ export function attachListenerToManagedDOMElement(

469 priority,

470 );

471 // Get the internal listeners Set from the target instance.

490 - let listeners = getListenersFromTarget(managedTargetElement);

472 + let listeners = getListenersFromTarget(target);

473 // If we don't have any listeners, then we need to init them.

474 if (listeners === null) {

475 listeners = new Set();

494 - initListenersSet(managedTargetElement, listeners);

476 + initListenersSet(target, listeners);

477 }

478 // Add our listener to the listeners Set.

479 listeners.add(listener);

@@ -503,9 +485,8 @@ export function detachListenerFromManagedDOMElement(

485 listener: ReactDOMListener,

486 ): void {

487 const {target} = listener;

506 - const managedTargetElement = ((target: any): Element);

488 // Get the internal listeners Set from the target instance.

508 - const listeners = getListenersFromTarget(managedTargetElement);

489 + const listeners = getListenersFromTarget(target);

490 if (listeners !== null) {

491 // Remove out listener from the listeners Set.

492 listeners.delete(listener);

@@ -515,21 +496,13 @@ export function detachListenerFromManagedDOMElement(

496 export function attachTargetEventListener(listener: ReactDOMListener): void {

497 const {event, target} = listener;

498 const {capture, passive, priority, type} = event;

518 - const eventTarget = ((target: any): EventTarget);

519 - const listenerMap = getListenerMapForElement(eventTarget);

499 + const listenerMap = getListenerMapForElement(target);

500 // Add the event listener to the TargetEvent object.

521 - listenToTopLevelEvent(

522 - type,

523 - eventTarget,

524 - listenerMap,

525 - passive,

526 - priority,

527 - capture,

528 - );

529 - let eventTypeMap = eventTargetEventListenerStore.get(eventTarget);

501 + listenToTopLevelEvent(type, target, listenerMap, passive, priority, capture);

502 + let eventTypeMap = eventTargetEventListenerStore.get(target);

503 if (eventTypeMap === undefined) {

504 eventTypeMap = new Map();

532 - eventTargetEventListenerStore.set(eventTarget, eventTypeMap);

505 + eventTargetEventListenerStore.set(target, eventTypeMap);

506 }

507 // Get the listeners by the event type

508 let listeners = eventTypeMap.get(type);

@@ -550,51 +523,7 @@ export function attachTargetEventListener(listener: ReactDOMListener): void {

523 export function detachTargetEventListener(listener: ReactDOMListener): void {

524 const {event, target} = listener;

525 const {capture, type} = event;

553 - const validEventTarget = ((target: any): EventTarget);

554 - const eventTypeMap = eventTargetEventListenerStore.get(validEventTarget);

555 - if (eventTypeMap !== undefined) {

556 - const listeners = eventTypeMap.get(type);

557 - if (listeners !== undefined) {

558 - // Remove out listener from the listeners Set.

559 - if (capture) {

560 - listeners.captured.delete(listener);

561 - } else {

562 - listeners.bubbled.delete(listener);

563 - }

564 - }

565 - }

566 -}

567 -

568 -export function attachListenerToReactScope(listener: ReactDOMListener): void {

569 - const {event, target} = listener;

570 - const {capture, type} = event;

571 - const reactScope = ((target: any): ReactScopeMethods);

572 - let eventTypeMap = reactScopeListenerStore.get(reactScope);

573 - if (eventTypeMap === undefined) {

574 - eventTypeMap = new Map();

575 - reactScopeListenerStore.set(reactScope, eventTypeMap);

576 - }

577 - // Get the listeners by the event type

578 - let listeners = eventTypeMap.get(type);

579 - if (listeners === undefined) {

580 - listeners = {captured: new Set(), bubbled: new Set()};

581 - eventTypeMap.set(type, listeners);

582 - }

583 - // Add our listener to the listeners Set.

584 - if (capture) {

585 - listeners.captured.add(listener);

586 - } else {

587 - listeners.bubbled.add(listener);

588 - }

589 - // Finally, add the event to our known event types list.

590 - addEventTypeToDispatchConfig(type);

591 -}

592 -

593 -export function detachListenerFromReactScope(listener: ReactDOMListener): void {

594 - const {event, target} = listener;

595 - const {capture, type} = event;

596 - const reactScope = ((target: any): ReactScopeMethods);

597 - const eventTypeMap = reactScopeListenerStore.get(reactScope);

526 + const eventTypeMap = eventTargetEventListenerStore.get(target);

527 if (eventTypeMap !== undefined) {

528 const listeners = eventTypeMap.get(type);

529 if (listeners !== undefined) {

packages/react-dom/src/events/__tests__/DOMModernPluginEventSystem-test.internal.js

-133

@@ -2327,139 +2327,6 @@ describe('DOMModernPluginEventSystem', () => {

2327 document.body.removeChild(container2);

2328 },

2329 );

2330 -

2331 - describe('Compatibility with Scopes API', () => {

2332 - beforeEach(() => {

2333 - jest.resetModules();

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

2335 - ReactFeatureFlags.enableModernEventSystem = true;

2336 - ReactFeatureFlags.enableUseEventAPI = true;

2337 - ReactFeatureFlags.enableScopeAPI = true;

2338 -

2339 - React = require('react');

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

2341 - Scheduler = require('scheduler');

2342 - ReactDOMServer = require('react-dom/server');

2343 - });

2344 -

2345 - it('handle propagation of click events on a scope', () => {

2346 - const buttonRef = React.createRef();

2347 - const log = [];

2348 - const onClick = jest.fn(e =>

2349 - log.push(['bubble', e.currentTarget]),

2350 - );

2351 - const onClickCapture = jest.fn(e =>

2352 - log.push(['capture', e.currentTarget]),

2353 - );

2354 - const TestScope = React.unstable_createScope();

2355 -

2356 - function Test() {

2357 - const click = ReactDOM.unstable_useEvent('click');

2358 - const clickCapture = ReactDOM.unstable_useEvent('click', {

2359 - capture: true,

2360 - });

2361 - const scopeRef = React.useRef(null);

2362 -

2363 - React.useEffect(() => {

2364 - click.setListener(scopeRef.current, onClick);

2365 - clickCapture.setListener(scopeRef.current, onClickCapture);

2366 - });

2367 -

2368 - return (

2369 - <TestScope ref={scopeRef}>

2370 - <button ref={buttonRef} />

2371 - </TestScope>

2372 - );

2373 - }

2374 -

2375 - ReactDOM.render(<Test />, container);

2376 - Scheduler.unstable_flushAll();

2377 -

2378 - const buttonElement = buttonRef.current;

2379 - dispatchClickEvent(buttonElement);

2380 -

2381 - expect(onClick).toHaveBeenCalledTimes(1);

2382 - expect(onClickCapture).toHaveBeenCalledTimes(1);

2383 - expect(log).toEqual([

2384 - ['capture', buttonElement],

2385 - ['bubble', buttonElement],

2386 - ]);

2387 - });

2388 -

2389 - it('handle mixed propagation of click events on a scope', () => {

2390 - const buttonRef = React.createRef();

2391 - const divRef = React.createRef();

2392 - const log = [];

2393 - const onClick = jest.fn(e =>

2394 - log.push(['bubble', e.currentTarget]),

2395 - );

2396 - const onClickCapture = jest.fn(e =>

2397 - log.push(['capture', e.currentTarget]),

2398 - );

2399 - const TestScope = React.unstable_createScope();

2400 -

2401 - function Test() {

2402 - const click = ReactDOM.unstable_useEvent('click');

2403 - const clickCapture = ReactDOM.unstable_useEvent('click', {

2404 - capture: true,

2405 - });

2406 - const scopeRef = React.useRef(null);

2407 -

2408 - React.useEffect(() => {

2409 - click.setListener(scopeRef.current, onClick);

2410 - clickCapture.setListener(scopeRef.current, onClickCapture);

2411 - click.setListener(buttonRef.current, onClick);

2412 - clickCapture.setListener(buttonRef.current, onClickCapture);

2413 - });

2414 -

2415 - return (

2416 - <TestScope ref={scopeRef}>

2417 - <button ref={buttonRef}>

2418 - <div

2419 - ref={divRef}

2420 - onClick={onClick}

2421 - onClickCapture={onClickCapture}>

2422 - Click me!

2423 - </div>

2424 - </button>

2425 - </TestScope>

2426 - );

2427 - }

2428 -

2429 - ReactDOM.render(<Test />, container);

2430 - Scheduler.unstable_flushAll();

2431 -

2432 - const buttonElement = buttonRef.current;

2433 - dispatchClickEvent(buttonElement);

2434 -

2435 - expect(onClick).toHaveBeenCalledTimes(2);

2436 - expect(onClickCapture).toHaveBeenCalledTimes(2);

2437 - expect(log).toEqual([

2438 - ['capture', buttonElement],

2439 - ['capture', buttonElement],

2440 - ['bubble', buttonElement],

2441 - ['bubble', buttonElement],

2442 - ]);

2443 -

2444 - log.length = 0;

2445 - onClick.mockClear();

2446 - onClickCapture.mockClear();

2447 -

2448 - const divElement = divRef.current;

2449 - dispatchClickEvent(divElement);

2450 -

2451 - expect(onClick).toHaveBeenCalledTimes(3);

2452 - expect(onClickCapture).toHaveBeenCalledTimes(3);

2453 - expect(log).toEqual([

2454 - ['capture', buttonElement],

2455 - ['capture', buttonElement],

2456 - ['capture', divElement],

2457 - ['bubble', divElement],

2458 - ['bubble', buttonElement],

2459 - ['bubble', buttonElement],

2460 - ]);

2461 - });

2462 - });

2330 });

2331 },

2332 );

packages/react-dom/src/events/accumulateTwoPhaseListeners.js

+4 -36

@@ -11,19 +11,13 @@ import type {DOMTopLevelEventType} from 'legacy-events/TopLevelEventTypes';

11 import type {EventSystemFlags} from 'legacy-events/EventSystemFlags';

12 import type {ReactSyntheticEvent} from 'legacy-events/ReactSyntheticEventType';

14 -import {

15 - HostComponent,

16 - ScopeComponent,

17 -} from 'react-reconciler/src/ReactWorkTags';

18 -import {enableUseEventAPI, enableScopeAPI} from 'shared/ReactFeatureFlags';

14 +import {HostComponent} from 'react-reconciler/src/ReactWorkTags';

15 +import {enableUseEventAPI} from 'shared/ReactFeatureFlags';

17 import getListener from 'legacy-events/getListener';

18 import {getListenersFromTarget} from '../client/ReactDOMComponentTree';

19 import {IS_TARGET_EVENT_ONLY} from 'legacy-events/EventSystemFlags';

23 -import {

24 - eventTargetEventListenerStore,

25 - reactScopeListenerStore,

26 -} from './DOMModernPluginEventSystem';

20 +import {eventTargetEventListenerStore} from './DOMModernPluginEventSystem';

22 export default function accumulateTwoPhaseListeners(

23 event: ReactSyntheticEvent,

@@ -82,13 +76,11 @@ export default function accumulateTwoPhaseListeners(

76 // usual two phase accumulation using the React fiber tree to pick up

77 // all relevant useEvent and on* prop events.

78 let node = event._targetInst;

85 - let lastHostComponent;

80 // Accumulate all instances and listeners via the target -> root path.

81 while (node !== null) {

89 - // Handle listeners that are on HostComponents (i.e. <div>)

82 + // We only care for listeners that are on HostComponents (i.e. <div>)

83 if (node.tag === HostComponent) {

91 - lastHostComponent = node.stateNode;

84 // For useEvent listenrs

85 if (enableUseEventAPI && accumulateUseEventListeners) {

86 // useEvent event listeners

@@ -135,30 +127,6 @@ export default function accumulateTwoPhaseListeners(

127 dispatchInstances.push(node);

128 }

129 }

138 - } else if (enableScopeAPI && node.tag === ScopeComponent) {

139 - const reactScope = node.stateNode.methods;

140 - const eventTypeMap = reactScopeListenerStore.get(reactScope);

141 - if (eventTypeMap !== undefined) {

142 - const type = ((event.type: any): DOMTopLevelEventType);

143 - const listeners = eventTypeMap.get(type);

144 - if (listeners !== undefined) {

145 - const captureListeners = Array.from(listeners.captured);

146 - const bubbleListeners = Array.from(listeners.bubbled);

147 -

148 - for (let i = 0; i < captureListeners.length; i++) {

149 - const listener = captureListeners[i];

150 - const {callback} = listener;

151 - dispatchListeners.unshift(callback);

152 - dispatchInstances.unshift(((lastHostComponent: any): Element));

153 - }

154 - for (let i = 0; i < bubbleListeners.length; i++) {

155 - const listener = bubbleListeners[i];

156 - const {callback} = listener;

157 - dispatchListeners.push(callback);

158 - dispatchInstances.push(((lastHostComponent: any): Element));

159 - }

160 - }

161 - }

130 }

131 node = node.return;

132 }

packages/react-dom/src/shared/ReactDOMTypes.js

+2 -6

@@ -12,7 +12,6 @@ import type {

12 ReactEventResponder,

13 ReactEventResponderInstance,

14 EventPriority,

15 - ReactScopeMethods,

15 } from 'shared/ReactTypes';

16 import type {DOMTopLevelEventType} from 'legacy-events/TopLevelEventTypes';

@@ -87,15 +86,12 @@ export type ReactDOMListenerEvent = {|

87 export type ReactDOMListenerMap = {|

88 clear: () => void,

90 - setListener: (

91 - target: EventTarget | ReactScopeMethods,

92 - callback: ?(Event) => void,

93 - ) => void,

89 + setListener: (target: EventTarget, callback: ?(Event) => void) => void,

90 |};

92 export type ReactDOMListener = {|

93 callback: Event => void,

94 destroy: Node => void,

95 event: ReactDOMListenerEvent,

100 - target: EventTarget | ReactScopeMethods,

96 + target: EventTarget,

97 |};

packages/react-reconciler/src/ReactFiberHooks.js

+3 -10

@@ -14,7 +14,6 @@ import type {

14 ReactEventResponder,

15 ReactContext,

16 ReactEventResponderListener,

17 - ReactScopeMethods,

17 } from 'shared/ReactTypes';

18 import type {Fiber} from './ReactFiber';

19 import type {ExpirationTime} from './ReactFiberExpirationTime';

@@ -1652,7 +1651,7 @@ function validateNotInFunctionRender(): boolean {

1651 function createReactListener(

1652 event: ReactListenerEvent,

1653 callback: Event => void,

1655 - target: EventTarget | ReactScopeMethods,

1654 + target: EventTarget,

1655 destroy: Node => void,

1656 ): ReactListener {

1657 return {

@@ -1666,10 +1665,7 @@ function createReactListener(

1665 function mountEventListener(event: ReactListenerEvent): ReactListenerMap {

1666 if (enableUseEventAPI) {

1667 const hook = mountWorkInProgressHook();

1669 - const listenerMap: Map<

1670 - EventTarget | ReactScopeMethods,

1671 - ReactListener,

1672 - > = new Map();

1668 + const listenerMap: Map<EventTarget, ReactListener> = new Map();

1669 const rootContainerInstance = getRootHostContainer();

1670

1671 // Register the event to the current root to ensure event

@@ -1704,10 +1700,7 @@ function mountEventListener(event: ReactListenerEvent): ReactListenerMap {