@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/src/private/renderer/events/ReactNativeResponder.js

@@ -18,6 +18,7 @@ import {
   setCurrentTarget,
   setTarget,
 } from '../../webapis/dom/events/internals/EventInternals';
+import {getEventTargetParent} from '../../webapis/dom/events/internals/EventTargetInternals';
 import {
   getCurrentProps,
   getNativeElementReference,
@@ -78,6 +79,23 @@ function isEndish(topLevelType: string): boolean {
   return topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
 }
 
+// Routes through the event-dispatch parent cache (shared with
+// `EventTarget.getEventPath`) and stops the walk when the parent is not
+// an element (e.g., when reaching the document at the top of the tree).
+function getResponderParentElement(
+  node: ReadOnlyElement,
+): ReadOnlyElement | null {
+  // `ReadOnlyElement` extends `EventTarget` at runtime when the new
+  // event-dispatching pipeline is enabled (the only case this module runs in).
+  // $FlowFixMe[incompatible-type]
+  const eventTarget: EventTarget = node;
+  const parent = getEventTargetParent(eventTarget);
+  if (parent instanceof ReadOnlyElement) {
+    return parent;
+  }
+  return null;
+}
+
 /**
  * Return the lowest common ancestor of A and B, or null if they are in
  * different trees.
@@ -95,12 +113,12 @@ function getLowestCommonAncestor(
   }
 
   // Walk up from A until we find an ancestor that contains B
-  let current: ?ReadOnlyElement = instA.parentElement;
+  let current: ?ReadOnlyElement = getResponderParentElement(instA);
   while (current != null) {
     if (current.contains(instB)) {
       return current;
     }
-    current = current.parentElement;
+    current = getResponderParentElement(current);
   }
 
   return null;
@@ -265,7 +283,7 @@ function negotiateResponder(
   }
 
   const dispatchNode: ReadOnlyElement | null = skipSelf
-    ? negotiationNode.parentElement
+    ? getResponderParentElement(negotiationNode)
     : negotiationNode;
   if (dispatchNode == null) {
     return null;
@@ -276,7 +294,7 @@ function negotiateResponder(
   let node: ?ReadOnlyElement = dispatchNode;
   while (node != null) {
     path.unshift(node);
-    node = node.parentElement;
+    node = getResponderParentElement(node);
   }
 
   const dispatchConfig = responderEventTypes[shouldSetEventName];
@@ -550,6 +568,24 @@ to return true:wantsResponderID|                            |
                                |                            |
                                +                            + */
 
+/**
+ * Returns whether a top-level event is one that the responder system needs to
+ * observe. Used as a fast-path in `processResponderEvent`: most events
+ * (`pointerup`, `pointermove`, `layout`, etc.) are not responder-relevant and
+ * — when no responder is currently set — produce no work.
+ */
+function isResponderRelevantTopLevelType(topLevelType: string): boolean {
+  return match (topLevelType) {
+    | 'topTouchStart'
+    | 'topTouchMove'
+    | 'topTouchEnd'
+    | 'topTouchCancel'
+    | 'topScroll'
+    | 'topSelectionChange' => true,
+    _ => false,
+  };
+}
+
 /**
  * Process a native event through the responder system.
  */
@@ -558,6 +594,15 @@ export function processResponderEvent(
   eventTarget: EventTarget | null,
   nativeEvent: {[string]: unknown},
 ): void {
+  // Fast path: if this event isn't one the responder system cares about and
+  // there is no active responder, exit immediately. This is the dominant case
+  // for non-touch events (pointer*, layout, etc.) on apps without an active
+  // gesture, and saves the touch counting + ResponderTouchHistoryStore +
+  // canTriggerTransfer work.
+  if (responderNode == null && !isResponderRelevantTopLevelType(topLevelType)) {
+    return;
+  }
+
   // Track touch count
   if (isStartish(topLevelType)) {
     trackedTouchCount += 1;

package/src/private/renderer/events/ResponderTouchHistoryStore.js

@@ -221,11 +221,20 @@ const ResponderTouchHistoryStore = {
       instrumentationCallback(topLevelType, nativeEvent);
     }
 
+    if (nativeEvent.changedTouches == null) {
+      console.error(
+        'Touch event "%s" received with no changedTouches. This is likely ' +
+          'a bug in the native touch handling system.',
+        topLevelType,
+      );
+      return;
+    }
+
     if (isMoveish(topLevelType)) {
       nativeEvent.changedTouches.forEach(recordTouchMove);
     } else if (isStartish(topLevelType)) {
       nativeEvent.changedTouches.forEach(recordTouchStart);
-      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      touchHistory.numberActiveTouches = nativeEvent.touches?.length ?? 0;
       if (touchHistory.numberActiveTouches === 1) {
         touchHistory.indexOfSingleActiveTouch =
           // $FlowFixMe[incompatible-type] might be null according to type
@@ -233,7 +242,7 @@ const ResponderTouchHistoryStore = {
       }
     } else if (isEndish(topLevelType)) {
       nativeEvent.changedTouches.forEach(recordTouchEnd);
-      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      touchHistory.numberActiveTouches = nativeEvent.touches?.length ?? 0;
       if (touchHistory.numberActiveTouches === 1) {
         for (let i = 0; i < touchBank.length; i++) {
           const touchTrackToCheck = touchBank[i];

package/src/private/renderer/events/dispatchNativeEvent.js

@@ -14,7 +14,11 @@ import {
   customBubblingEventTypes,
   customDirectEventTypes,
 } from '../../../../Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
-import {setEventInitTimeStamp} from '../../webapis/dom/events/internals/EventInternals';
+import {
+  setBubbledPropName,
+  setCapturedPropName,
+  setEventInitTimeStamp,
+} from '../../webapis/dom/events/internals/EventInternals';
 import {dispatchTrustedEvent} from '../../webapis/dom/events/internals/EventTargetInternals';
 import LegacySyntheticEvent from './LegacySyntheticEvent';
 import {topLevelTypeToEventType} from './ReactNativeEventTypeMapping';
@@ -40,44 +44,75 @@ export default function dispatchNativeEvent(
   // Process responder events before normal event dispatch.
   processResponderEvent(type, target, payload);
 
-  // Normal EventTarget dispatch
-  const bubbleConfig = customBubblingEventTypes[type];
-  const directConfig = customDirectEventTypes[type];
+  try {
+    // Normal EventTarget dispatch
+    const bubbleConfig = customBubblingEventTypes[type];
+    const directConfig = customDirectEventTypes[type];
 
-  // Skip events that are not registered in the view config
-  if (bubbleConfig != null || directConfig != null) {
-    // Honor `skipBubbling` declared in the view config: when set, the bubble
-    // phase only fires on the target itself (matching the legacy renderer's
-    // behavior). The synthesized event reports `bubbles: false`, which causes
-    // the EventTarget bubble loop to short-circuit after dispatching to the
-    // target. Capture-phase listeners are unaffected.
-    const bubbles =
-      bubbleConfig != null &&
-      bubbleConfig.phasedRegistrationNames.skipBubbling !== true;
+    // Skip events that are not registered in the view config
+    if (bubbleConfig != null || directConfig != null) {
+      // Honor `skipBubbling` declared in the view config: when set, the bubble
+      // phase only fires on the target itself (matching the legacy renderer's
+      // behavior). The synthesized event reports `bubbles: false`, which causes
+      // the EventTarget bubble loop to short-circuit after dispatching to the
+      // target. Capture-phase listeners are unaffected.
+      const bubbles =
+        bubbleConfig != null &&
+        bubbleConfig.phasedRegistrationNames.skipBubbling !== true;
 
-    const eventType = topLevelTypeToEventType(type);
-    const options: {bubbles: boolean, cancelable: boolean} = {
-      bubbles,
-      cancelable: true,
-    };
+      const eventType = topLevelTypeToEventType(type);
+      const options: {bubbles: boolean, cancelable: boolean} = {
+        bubbles,
+        cancelable: true,
+      };
 
-    // Preserve the native event timestamp for backwards compatibility.
-    const nativeTimestamp = payload.timeStamp ?? payload.timestamp;
-    if (typeof nativeTimestamp === 'number') {
-      setEventInitTimeStamp(options, nativeTimestamp);
-    }
+      // Preserve the native event timestamp for backwards compatibility.
+      const nativeTimestamp = payload.timeStamp ?? payload.timestamp;
+      if (typeof nativeTimestamp === 'number') {
+        setEventInitTimeStamp(options, nativeTimestamp);
+      }
 
-    const syntheticEvent = new LegacySyntheticEvent(
-      eventType,
-      options,
-      payload,
-      bubbleConfig ?? directConfig,
-    );
-    dispatchTrustedEvent(target, syntheticEvent);
-  }
+      const syntheticEvent = new LegacySyntheticEvent(
+        eventType,
+        options,
+        payload,
+        bubbleConfig ?? directConfig,
+      );
 
-  // Rethrow the first error caught during responder lifecycle dispatch,
-  // after all dispatching is complete. This matches the old system's
-  // runEventsInBatch → rethrowCaughtError pattern.
-  rethrowCaughtError();
+      // Pre-resolve the React prop names ("onFoo" / "onFooCapture") once per
+      // dispatch and stash them on the event so per-ancestor
+      // `EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY` lookups can read them
+      // directly, avoiding the per-call `getEventTypePropName` hash lookup.
+      if (bubbleConfig != null) {
+        const phasedRegistrationNames = bubbleConfig.phasedRegistrationNames;
+        setBubbledPropName(
+          syntheticEvent,
+          phasedRegistrationNames.bubbled ?? null,
+        );
+        setCapturedPropName(
+          syntheticEvent,
+          phasedRegistrationNames.captured ?? null,
+        );
+      } else if (directConfig != null) {
+        setBubbledPropName(
+          syntheticEvent,
+          directConfig.registrationName ?? null,
+        );
+        setCapturedPropName(syntheticEvent, null);
+      }
+
+      // Pass `rethrowListenerErrors: true` so the first listener error is
+      // rethrown synchronously (matching the legacy plugin path) rather than
+      // deferred to a new task, keeping it catchable by React error boundaries
+      // and the native event call.
+      dispatchTrustedEvent(target, syntheticEvent, true);
+    }
+  } finally {
+    // Rethrow the first error caught during responder lifecycle dispatch,
+    // after all dispatching is complete. This matches the old system's
+    // runEventsInBatch → rethrowCaughtError pattern. Running it in a `finally`
+    // ensures a pending responder error is never left to leak into a later
+    // dispatch even if the normal dispatch above threw synchronously.
+    rethrowCaughtError();
+  }
 }

package/src/private/setup/setUpDOM.js

@@ -31,47 +31,57 @@ export default function setUpDOM() {
 
   polyfillGlobal(
     'DOMRectList',
-    () => require('../webapis/geometry/DOMRectList').default,
+    () => require('../webapis/geometry/DOMRectList').DOMRectList_public,
   );
 
   polyfillGlobal(
     'HTMLCollection',
-    () => require('../webapis/dom/oldstylecollections/HTMLCollection').default,
+    () =>
+      require('../webapis/dom/oldstylecollections/HTMLCollection')
+        .HTMLCollection_public,
   );
 
   polyfillGlobal(
     'NodeList',
-    () => require('../webapis/dom/oldstylecollections/NodeList').default,
+    () =>
+      require('../webapis/dom/oldstylecollections/NodeList').NodeList_public,
   );
 
   polyfillGlobal(
     'Node',
-    () => require('../webapis/dom/nodes/ReadOnlyNode').default,
+    () => require('../webapis/dom/nodes/ReadOnlyNode').ReadOnlyNode_public,
   );
 
   polyfillGlobal(
     'Document',
-    () => require('../webapis/dom/nodes/ReactNativeDocument').default,
+    () =>
+      require('../webapis/dom/nodes/ReactNativeDocument')
+        .ReactNativeDocument_public,
   );
 
   polyfillGlobal(
     'CharacterData',
-    () => require('../webapis/dom/nodes/ReadOnlyCharacterData').default,
+    () =>
+      require('../webapis/dom/nodes/ReadOnlyCharacterData')
+        .ReadOnlyCharacterData_public,
   );
 
   polyfillGlobal(
     'Text',
-    () => require('../webapis/dom/nodes/ReadOnlyText').default,
+    () => require('../webapis/dom/nodes/ReadOnlyText').ReadOnlyText_public,
   );
 
   polyfillGlobal(
     'Element',
-    () => require('../webapis/dom/nodes/ReadOnlyElement').default,
+    () =>
+      require('../webapis/dom/nodes/ReadOnlyElement').ReadOnlyElement_public,
   );
 
   polyfillGlobal(
     'HTMLElement',
-    () => require('../webapis/dom/nodes/ReactNativeElement').default,
+    () =>
+      require('../webapis/dom/nodes/ReactNativeElement')
+        .ReactNativeElement_public,
   );
 
   polyfillGlobal('Event', () => require('../webapis/dom/events/Event').default);

package/src/private/setup/setUpIntersectionObserver.js

@@ -24,4 +24,11 @@ export default function setUpIntersectionObserver() {
     () =>
       require('../webapis/intersectionobserver/IntersectionObserver').default,
   );
+
+  polyfillGlobal(
+    'IntersectionObserverEntry',
+    () =>
+      require('../webapis/intersectionobserver/IntersectionObserverEntry')
+        .IntersectionObserverEntry_public,
+  );
 }

package/src/private/setup/setUpMutationObserver.js

@@ -26,6 +26,8 @@ export default function setUpMutationObserver() {
 
   polyfillGlobal(
     'MutationRecord',
-    () => require('../webapis/mutationobserver/MutationRecord').default,
+    () =>
+      require('../webapis/mutationobserver/MutationRecord')
+        .MutationRecord_public,
   );
 }

package/src/private/specs_DEPRECATED/modules/NativeAccessibilityInfo.js

@@ -13,28 +13,28 @@ import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {
-  +isReduceMotionEnabled: (
+  readonly isReduceMotionEnabled: (
     onSuccess: (isReduceMotionEnabled: boolean) => void,
   ) => void;
-  +isInvertColorsEnabled?: (
+  readonly isInvertColorsEnabled?: (
     onSuccess: (isInvertColorsEnabled: boolean) => void,
   ) => void;
-  +isHighTextContrastEnabled?: (
+  readonly isHighTextContrastEnabled?: (
     onSuccess: (isHighTextContrastEnabled: boolean) => void,
   ) => void;
-  +isTouchExplorationEnabled: (
+  readonly isTouchExplorationEnabled: (
     onSuccess: (isScreenReaderEnabled: boolean) => void,
   ) => void;
-  +isAccessibilityServiceEnabled?: ?(
+  readonly isAccessibilityServiceEnabled?: ?(
     onSuccess: (isAccessibilityServiceEnabled: boolean) => void,
   ) => void;
-  +setAccessibilityFocus: (reactTag: number) => void;
-  +announceForAccessibility: (announcement: string) => void;
-  +getRecommendedTimeoutMillis?: (
+  readonly setAccessibilityFocus: (reactTag: number) => void;
+  readonly announceForAccessibility: (announcement: string) => void;
+  readonly getRecommendedTimeoutMillis?: (
     mSec: number,
     onSuccess: (recommendedTimeoutMillis: number) => void,
   ) => void;
-  +isGrayscaleEnabled?: (
+  readonly isGrayscaleEnabled?: (
     onSuccess: (isGrayscaleEnabled: boolean) => void,
   ) => void;
 }

package/src/private/specs_DEPRECATED/modules/NativeAccessibilityManager.js

@@ -13,55 +13,55 @@ import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {
-  +getCurrentBoldTextState: (
+  readonly getCurrentBoldTextState: (
     onSuccess: (isBoldTextEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentGrayscaleState: (
+  readonly getCurrentGrayscaleState: (
     onSuccess: (isGrayscaleEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentInvertColorsState: (
+  readonly getCurrentInvertColorsState: (
     onSuccess: (isInvertColorsEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentReduceMotionState: (
+  readonly getCurrentReduceMotionState: (
     onSuccess: (isReduceMotionEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentDarkerSystemColorsState?: (
+  readonly getCurrentDarkerSystemColorsState?: (
     onSuccess: (isDarkerSystemColorsEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentPrefersCrossFadeTransitionsState?: (
+  readonly getCurrentPrefersCrossFadeTransitionsState?: (
     onSuccess: (prefersCrossFadeTransitions: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentReduceTransparencyState: (
+  readonly getCurrentReduceTransparencyState: (
     onSuccess: (isReduceTransparencyEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +getCurrentVoiceOverState: (
+  readonly getCurrentVoiceOverState: (
     onSuccess: (isScreenReaderEnabled: boolean) => void,
     onError: (error: Object) => void,
   ) => void;
-  +setAccessibilityContentSizeMultipliers: (JSMultipliers: {
-    +extraSmall?: ?number,
-    +small?: ?number,
-    +medium?: ?number,
-    +large?: ?number,
-    +extraLarge?: ?number,
-    +extraExtraLarge?: ?number,
-    +extraExtraExtraLarge?: ?number,
-    +accessibilityMedium?: ?number,
-    +accessibilityLarge?: ?number,
-    +accessibilityExtraLarge?: ?number,
-    +accessibilityExtraExtraLarge?: ?number,
-    +accessibilityExtraExtraExtraLarge?: ?number,
+  readonly setAccessibilityContentSizeMultipliers: (JSMultipliers: {
+    readonly extraSmall?: ?number,
+    readonly small?: ?number,
+    readonly medium?: ?number,
+    readonly large?: ?number,
+    readonly extraLarge?: ?number,
+    readonly extraExtraLarge?: ?number,
+    readonly extraExtraExtraLarge?: ?number,
+    readonly accessibilityMedium?: ?number,
+    readonly accessibilityLarge?: ?number,
+    readonly accessibilityExtraLarge?: ?number,
+    readonly accessibilityExtraExtraLarge?: ?number,
+    readonly accessibilityExtraExtraExtraLarge?: ?number,
   }) => void;
-  +setAccessibilityFocus: (reactTag: number) => void;
-  +announceForAccessibility: (announcement: string) => void;
-  +announceForAccessibilityWithOptions?: (
+  readonly setAccessibilityFocus: (reactTag: number) => void;
+  readonly announceForAccessibility: (announcement: string) => void;
+  readonly announceForAccessibilityWithOptions?: (
     announcement: string,
     options: {queue?: boolean, priority?: 'low' | 'default' | 'high'},
   ) => void;

package/src/private/specs_DEPRECATED/modules/NativeActionSheetManager.js

@@ -13,44 +13,44 @@ import type {TurboModule} from '../../../../Libraries/TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../../../../Libraries/TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {
-  +getConstants: () => {};
-  +showActionSheetWithOptions: (
+  readonly getConstants: () => {};
+  readonly showActionSheetWithOptions: (
     options: {
-      +title?: ?string,
-      +message?: ?string,
-      +options: ?Array<string>,
-      +destructiveButtonIndices?: ?Array<number>,
-      +cancelButtonIndex?: ?number,
-      +anchor?: ?number,
-      +tintColor?: ?number,
-      +cancelButtonTintColor?: ?number,
-      +disabledButtonTintColor?: ?number,
-      +userInterfaceStyle?: ?string,
-      +disabledButtonIndices?: Array<number>,
+      readonly title?: ?string,
+      readonly message?: ?string,
+      readonly options: ?Array<string>,
+      readonly destructiveButtonIndices?: ?Array<number>,
+      readonly cancelButtonIndex?: ?number,
+      readonly anchor?: ?number,
+      readonly tintColor?: ?number,
+      readonly cancelButtonTintColor?: ?number,
+      readonly disabledButtonTintColor?: ?number,
+      readonly userInterfaceStyle?: ?string,
+      readonly disabledButtonIndices?: Array<number>,
     },
     callback: (buttonIndex: number) => void,
   ) => void;
-  +showShareActionSheetWithOptions: (
+  readonly showShareActionSheetWithOptions: (
     options: {
-      +message?: ?string,
-      +url?: ?string,
-      +subject?: ?string,
-      +anchor?: ?number,
-      +tintColor?: ?number,
-      +cancelButtonTintColor?: ?number,
-      +disabledButtonTintColor?: ?number,
-      +excludedActivityTypes?: ?Array<string>,
-      +userInterfaceStyle?: ?string,
+      readonly message?: ?string,
+      readonly url?: ?string,
+      readonly subject?: ?string,
+      readonly anchor?: ?number,
+      readonly tintColor?: ?number,
+      readonly cancelButtonTintColor?: ?number,
+      readonly disabledButtonTintColor?: ?number,
+      readonly excludedActivityTypes?: ?Array<string>,
+      readonly userInterfaceStyle?: ?string,
     },
     failureCallback: (error: {
-      +domain: string,
-      +code: string,
-      +userInfo?: ?Object,
-      +message: string,
+      readonly domain: string,
+      readonly code: string,
+      readonly userInfo?: ?Object,
+      readonly message: string,
     }) => void,
     successCallback: (completed: boolean, activityType: ?string) => void,
   ) => void;
-  +dismissActionSheet?: () => void;
+  readonly dismissActionSheet?: () => void;
 }
 
 export default TurboModuleRegistry.get<Spec>('ActionSheetManager') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeAlertManager.js

@@ -26,7 +26,7 @@ export type Args = {
 };
 
 export interface Spec extends TurboModule {
-  +alertWithArgs: (
+  readonly alertWithArgs: (
     args: Args,
     callback: (id: number, value: string) => void,
   ) => void;

package/src/private/specs_DEPRECATED/modules/NativeAnimatedModule.js

@@ -28,51 +28,71 @@ export type AnimatedNodeConfig = Object;
 export type AnimatingNodeConfig = Object;
 
 export interface Spec extends TurboModule {
-  +startOperationBatch: () => void;
-  +finishOperationBatch: () => void;
-  +createAnimatedNode: (tag: number, config: AnimatedNodeConfig) => void;
-  +updateAnimatedNodeConfig?: (tag: number, config: AnimatedNodeConfig) => void;
-  +getValue: (tag: number, saveValueCallback: SaveValueCallback) => void;
-  +startListeningToAnimatedNodeValue: (tag: number) => void;
-  +stopListeningToAnimatedNodeValue: (tag: number) => void;
-  +connectAnimatedNodes: (parentTag: number, childTag: number) => void;
-  +disconnectAnimatedNodes: (parentTag: number, childTag: number) => void;
-  +startAnimatingNode: (
+  readonly startOperationBatch: () => void;
+  readonly finishOperationBatch: () => void;
+  readonly createAnimatedNode: (
+    tag: number,
+    config: AnimatedNodeConfig,
+  ) => void;
+  readonly updateAnimatedNodeConfig?: (
+    tag: number,
+    config: AnimatedNodeConfig,
+  ) => void;
+  readonly getValue: (
+    tag: number,
+    saveValueCallback: SaveValueCallback,
+  ) => void;
+  readonly startListeningToAnimatedNodeValue: (tag: number) => void;
+  readonly stopListeningToAnimatedNodeValue: (tag: number) => void;
+  readonly connectAnimatedNodes: (parentTag: number, childTag: number) => void;
+  readonly disconnectAnimatedNodes: (
+    parentTag: number,
+    childTag: number,
+  ) => void;
+  readonly startAnimatingNode: (
     animationId: number,
     nodeTag: number,
     config: AnimatingNodeConfig,
     endCallback: EndCallback,
   ) => void;
-  +stopAnimation: (animationId: number) => void;
-  +setAnimatedNodeValue: (nodeTag: number, value: number) => void;
-  +setAnimatedNodeOffset: (nodeTag: number, offset: number) => void;
-  +flattenAnimatedNodeOffset: (nodeTag: number) => void;
-  +extractAnimatedNodeOffset: (nodeTag: number) => void;
-  +connectAnimatedNodeToView: (nodeTag: number, viewTag: number) => void;
-  +connectAnimatedNodeToShadowNodeFamily?: (
+  readonly stopAnimation: (animationId: number) => void;
+  readonly setAnimatedNodeValue: (nodeTag: number, value: number) => void;
+  readonly setAnimatedNodeOffset: (nodeTag: number, offset: number) => void;
+  readonly flattenAnimatedNodeOffset: (nodeTag: number) => void;
+  readonly extractAnimatedNodeOffset: (nodeTag: number) => void;
+  readonly connectAnimatedNodeToView: (
+    nodeTag: number,
+    viewTag: number,
+  ) => void;
+  readonly connectAnimatedNodeToShadowNodeFamily?: (
     nodeTag: number,
     shadowNode: Object,
   ) => void;
-  +disconnectAnimatedNodeFromView: (nodeTag: number, viewTag: number) => void;
-  +restoreDefaultValues: (nodeTag: number) => void;
-  +dropAnimatedNode: (tag: number) => void;
-  +addAnimatedEventToView: (
+  readonly disconnectAnimatedNodeFromView: (
+    nodeTag: number,
+    viewTag: number,
+  ) => void;
+  readonly restoreDefaultValues: (nodeTag: number) => void;
+  readonly dropAnimatedNode: (tag: number) => void;
+  readonly addAnimatedEventToView: (
     viewTag: number,
     eventName: string,
     eventMapping: EventMapping,
   ) => void;
-  +removeAnimatedEventFromView: (
+  readonly removeAnimatedEventFromView: (
     viewTag: number,
     eventName: string,
     animatedNodeTag: number,
   ) => void;
 
   // Events
-  +addListener: (eventName: string) => void;
-  +removeListeners: (count: number) => void;
+  readonly addListener: (eventName: string) => void;
+  readonly removeListeners: (count: number) => void;
 
   // All of the above in a batched mode
-  +queueAndExecuteBatchedOperations?: (operationsAndArgs: Array<any>) => void;
+  readonly queueAndExecuteBatchedOperations?: (
+    operationsAndArgs: Array<any>,
+  ) => void;
 }
 
 const NativeModule: ?Spec = !shouldUseTurboAnimatedModule()