@office-iss/react-native-win32 0.70.2 → 0.71.0-preview.1

package/Libraries/Animated/nodes/AnimatedStyle.js

@@ -12,13 +12,13 @@
 
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
 
-const flattenStyle = require('../../StyleSheet/flattenStyle');
-const NativeAnimatedHelper = require('../NativeAnimatedHelper');
-const AnimatedNode = require('./AnimatedNode');
-const AnimatedTransform = require('./AnimatedTransform');
-const AnimatedWithChildren = require('./AnimatedWithChildren');
+import flattenStyle from '../../StyleSheet/flattenStyle';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import AnimatedNode from './AnimatedNode';
+import AnimatedTransform from './AnimatedTransform';
+import AnimatedWithChildren from './AnimatedWithChildren';
 
-class AnimatedStyle extends AnimatedWithChildren {
+export default class AnimatedStyle extends AnimatedWithChildren {
   _style: Object;
 
   constructor(style: any) {
@@ -34,23 +34,15 @@ class AnimatedStyle extends AnimatedWithChildren {
   }
 
   // Recursively get values for nested styles (like iOS's shadowOffset)
-  _walkStyleAndGetValues(style: any, initialStyle: ?Object) {
+  _walkStyleAndGetValues(style: any): {[string]: any | {...}} {
     const updatedStyle: {[string]: any | {...}} = {};
     for (const key in style) {
       const value = style[key];
       if (value instanceof AnimatedNode) {
-        // During initial render we want to use the initial value of both natively and non-natively
-        // driven nodes. On subsequent renders, we cannot use the value of natively driven nodes
-        // as they may not be up to date, so we use the initial value to ensure that values of
-        // native animated nodes do not impact rerenders.
-        if (!initialStyle || !value.__isNative) {
-          updatedStyle[key] = value.__getValue();
-        } else if (initialStyle.hasOwnProperty(key)) {
-          updatedStyle[key] = initialStyle[key];
-        }
+        updatedStyle[key] = value.__getValue();
       } else if (value && !Array.isArray(value) && typeof value === 'object') {
         // Support animating nested values (for example: shadowOffset.height)
-        updatedStyle[key] = this._walkStyleAndGetValues(value, initialStyle);
+        updatedStyle[key] = this._walkStyleAndGetValues(value);
       } else {
         updatedStyle[key] = value;
       }
@@ -58,12 +50,12 @@ class AnimatedStyle extends AnimatedWithChildren {
     return updatedStyle;
   }
 
-  __getValue(initialStyle: ?Object): Object {
-    return this._walkStyleAndGetValues(this._style, initialStyle);
+  __getValue(): Object {
+    return this._walkStyleAndGetValues(this._style);
   }
 
   // Recursively get animated values for nested styles (like iOS's shadowOffset)
-  _walkStyleAndGetAnimatedValues(style: any) {
+  _walkStyleAndGetAnimatedValues(style: any): {[string]: any | {...}} {
     const updatedStyle: {[string]: any | {...}} = {};
     for (const key in style) {
       const value = style[key];
@@ -128,5 +120,3 @@ class AnimatedStyle extends AnimatedWithChildren {
     };
   }
 }
-
-module.exports = AnimatedStyle;

package/Libraries/Animated/nodes/AnimatedSubtraction.js

@@ -10,15 +10,15 @@
 
 'use strict';
 
-const AnimatedInterpolation = require('./AnimatedInterpolation');
-const AnimatedNode = require('./AnimatedNode');
-const AnimatedValue = require('./AnimatedValue');
-const AnimatedWithChildren = require('./AnimatedWithChildren');
-
-import type {InterpolationConfigType} from './AnimatedInterpolation';
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
+import type {InterpolationConfigType} from './AnimatedInterpolation';
+import type AnimatedNode from './AnimatedNode';
 
-class AnimatedSubtraction extends AnimatedWithChildren {
+import AnimatedInterpolation from './AnimatedInterpolation';
+import AnimatedValue from './AnimatedValue';
+import AnimatedWithChildren from './AnimatedWithChildren';
+
+export default class AnimatedSubtraction extends AnimatedWithChildren {
   _a: AnimatedNode;
   _b: AnimatedNode;
 
@@ -62,5 +62,3 @@ class AnimatedSubtraction extends AnimatedWithChildren {
     };
   }
 }
-
-module.exports = AnimatedSubtraction;

package/Libraries/Animated/nodes/AnimatedTracking.js

@@ -10,17 +10,14 @@
 
 'use strict';
 
-const AnimatedValue = require('./AnimatedValue');
-const AnimatedNode = require('./AnimatedNode');
-const {
-  generateNewAnimationId,
-  shouldUseNativeDriver,
-} = require('../NativeAnimatedHelper');
-
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
 import type {EndCallback} from '../animations/Animation';
+import type AnimatedValue from './AnimatedValue';
+
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import AnimatedNode from './AnimatedNode';
 
-class AnimatedTracking extends AnimatedNode {
+export default class AnimatedTracking extends AnimatedNode {
   _value: AnimatedValue;
   _parent: AnimatedNode;
   _callback: ?EndCallback;
@@ -40,7 +37,8 @@ class AnimatedTracking extends AnimatedNode {
     this._parent = parent;
     this._animationClass = animationClass;
     this._animationConfig = animationConfig;
-    this._useNativeDriver = shouldUseNativeDriver(animationConfig);
+    this._useNativeDriver =
+      NativeAnimatedHelper.shouldUseNativeDriver(animationConfig);
     this._callback = callback;
     this.__attach();
   }
@@ -93,12 +91,10 @@ class AnimatedTracking extends AnimatedNode {
     const animationConfig = animation.__getNativeAnimationConfig();
     return {
       type: 'tracking',
-      animationId: generateNewAnimationId(),
+      animationId: NativeAnimatedHelper.generateNewAnimationId(),
       animationConfig,
       toValue: this._parent.__getNativeTag(),
       value: this._value.__getNativeTag(),
     };
   }
 }
-
-module.exports = AnimatedTracking;

package/Libraries/Animated/nodes/AnimatedTransform.js

@@ -12,11 +12,11 @@
 
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
 
-const NativeAnimatedHelper = require('../NativeAnimatedHelper');
-const AnimatedNode = require('./AnimatedNode');
-const AnimatedWithChildren = require('./AnimatedWithChildren');
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import AnimatedNode from './AnimatedNode';
+import AnimatedWithChildren from './AnimatedWithChildren';
 
-class AnimatedTransform extends AnimatedWithChildren {
+export default class AnimatedTransform extends AnimatedWithChildren {
   _transforms: $ReadOnlyArray<Object>;
 
   constructor(transforms: $ReadOnlyArray<Object>) {
@@ -37,34 +37,11 @@ class AnimatedTransform extends AnimatedWithChildren {
   }
 
   __getValue(): $ReadOnlyArray<Object> {
-    return this._transforms.map(transform => {
-      const result: {[string]: any} = {};
-      for (const key in transform) {
-        const value = transform[key];
-        if (value instanceof AnimatedNode) {
-          result[key] = value.__getValue();
-        } else {
-          result[key] = value;
-        }
-      }
-      return result;
-    });
+    return this._get(animatedNode => animatedNode.__getValue());
   }
 
   __getAnimatedValue(): $ReadOnlyArray<Object> {
-    return this._transforms.map(transform => {
-      const result: {[string]: any} = {};
-      for (const key in transform) {
-        const value = transform[key];
-        if (value instanceof AnimatedNode) {
-          result[key] = value.__getAnimatedValue();
-        } else {
-          // All transform components needed to recompose matrix
-          result[key] = value;
-        }
-      }
-      return result;
-    });
+    return this._get(animatedNode => animatedNode.__getAnimatedValue());
   }
 
   __attach(): void {
@@ -118,6 +95,36 @@ class AnimatedTransform extends AnimatedWithChildren {
       transforms: transConfigs,
     };
   }
-}
 
-module.exports = AnimatedTransform;
+  _get(getter: AnimatedNode => any): $ReadOnlyArray<Object> {
+    return this._transforms.map(transform => {
+      const result: {[string]: any} = {};
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof AnimatedNode) {
+          result[key] = getter(value);
+        } else if (Array.isArray(value)) {
+          result[key] = value.map(element => {
+            if (element instanceof AnimatedNode) {
+              return getter(element);
+            } else {
+              return element;
+            }
+          });
+        } else if (typeof value === 'object') {
+          result[key] = {};
+          for (const [nestedKey, nestedValue] of Object.entries(value)) {
+            if (nestedValue instanceof AnimatedNode) {
+              result[key][nestedKey] = getter(nestedValue);
+            } else {
+              result[key][nestedKey] = nestedValue;
+            }
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+}

package/Libraries/Animated/nodes/AnimatedValue.js

@@ -10,16 +10,16 @@
 
 'use strict';
 
-const AnimatedInterpolation = require('./AnimatedInterpolation');
-const AnimatedWithChildren = require('./AnimatedWithChildren');
-const InteractionManager = require('../../Interaction/InteractionManager');
-const NativeAnimatedHelper = require('../NativeAnimatedHelper');
-
-import type AnimatedNode from './AnimatedNode';
 import type Animation, {EndCallback} from '../animations/Animation';
 import type {InterpolationConfigType} from './AnimatedInterpolation';
+import type AnimatedNode from './AnimatedNode';
 import type AnimatedTracking from './AnimatedTracking';
 
+import InteractionManager from '../../Interaction/InteractionManager';
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import AnimatedInterpolation from './AnimatedInterpolation';
+import AnimatedWithChildren from './AnimatedWithChildren';
+
 export type AnimatedValueConfig = $ReadOnly<{
   useNativeDriver: boolean,
 }>;
@@ -49,7 +49,7 @@ const NativeAnimatedAPI = NativeAnimatedHelper.API;
  * transform which can receive values from multiple parents.
  */
 function _flush(rootNode: AnimatedValue): void {
-  const animatedStyles = new Set();
+  const animatedStyles = new Set<AnimatedValue | AnimatedNode>();
   function findAnimatedStyles(node: AnimatedValue | AnimatedNode) {
     /* $FlowFixMe[prop-missing] (>=0.68.0 site=react_native_fb) This comment
      * suppresses an error found when Flow v0.68 was deployed. To see the error
@@ -84,13 +84,14 @@ function _executeAsAnimatedBatch(id: string, operation: () => void) {
  *
  * See https://reactnative.dev/docs/animatedvalue
  */
-class AnimatedValue extends AnimatedWithChildren {
+export default class AnimatedValue extends AnimatedWithChildren {
   _value: number;
   _startingValue: number;
   _offset: number;
   _animation: ?Animation;
   _tracking: ?AnimatedTracking;
 
+  // $FlowFixMe[missing-local-annot]
   constructor(value: number, config?: ?AnimatedValueConfig) {
     super();
     if (typeof value !== 'number') {
@@ -303,5 +304,3 @@ class AnimatedValue extends AnimatedWithChildren {
     };
   }
 }
-
-module.exports = AnimatedValue;

package/Libraries/Animated/nodes/AnimatedValueXY.js

@@ -12,10 +12,9 @@
 
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
 
-const AnimatedValue = require('./AnimatedValue');
-const AnimatedWithChildren = require('./AnimatedWithChildren');
-
-const invariant = require('invariant');
+import AnimatedValue from './AnimatedValue';
+import AnimatedWithChildren from './AnimatedWithChildren';
+import invariant from 'invariant';
 
 export type AnimatedValueXYConfig = $ReadOnly<{
   useNativeDriver: boolean,
@@ -34,7 +33,7 @@ let _uniqueId = 1;
  *
  * See https://reactnative.dev/docs/animatedvaluexy
  */
-class AnimatedValueXY extends AnimatedWithChildren {
+export default class AnimatedValueXY extends AnimatedWithChildren {
   x: AnimatedValue;
   y: AnimatedValue;
   _listeners: {
@@ -249,5 +248,3 @@ class AnimatedValueXY extends AnimatedWithChildren {
     super.__makeNative(platformConfig);
   }
 }
-
-module.exports = AnimatedValueXY;

package/Libraries/Animated/nodes/AnimatedWithChildren.js

@@ -11,10 +11,11 @@
 'use strict';
 
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
-const AnimatedNode = require('./AnimatedNode');
-const NativeAnimatedHelper = require('../NativeAnimatedHelper');
 
-class AnimatedWithChildren extends AnimatedNode {
+import NativeAnimatedHelper from '../NativeAnimatedHelper';
+import AnimatedNode from './AnimatedNode';
+
+export default class AnimatedWithChildren extends AnimatedNode {
   _children: Array<AnimatedNode>;
 
   constructor() {
@@ -85,5 +86,3 @@ class AnimatedWithChildren extends AnimatedNode {
     }
   }
 }
-
-module.exports = AnimatedWithChildren;

package/Libraries/Animated/useAnimatedProps.js

@@ -10,10 +10,10 @@
 
 'use strict';
 
-import AnimatedProps from './nodes/AnimatedProps';
-import {AnimatedEvent} from './AnimatedEvent';
 import useRefEffect from '../Utilities/useRefEffect';
+import {AnimatedEvent} from './AnimatedEvent';
 import NativeAnimatedHelper from './NativeAnimatedHelper';
+import AnimatedProps from './nodes/AnimatedProps';
 import {
   useCallback,
   useEffect,
@@ -21,7 +21,6 @@ import {
   useMemo,
   useReducer,
   useRef,
-  useState,
 } from 'react';
 
 type ReducedProps<TProps> = {
@@ -31,12 +30,10 @@ type ReducedProps<TProps> = {
 };
 type CallbackRef<T> = T => mixed;
 
-let animatedComponentNextId = 1;
-
 export default function useAnimatedProps<TProps: {...}, TInstance>(
   props: TProps,
 ): [ReducedProps<TProps>, CallbackRef<TInstance | null>] {
-  const [, scheduleUpdate] = useReducer(count => count + 1, 0);
+  const [, scheduleUpdate] = useReducer<number, void>(count => count + 1, 0);
   const onUpdateRef = useRef<?() => void>(null);
 
   // TODO: Only invalidate `node` if animated props or `style` change. In the
@@ -63,7 +60,7 @@ export default function useAnimatedProps<TProps: {...}, TInstance>(
   // But there is no way to transparently compose three separate callback refs,
   // so we just combine them all into one for now.
   const refEffect = useCallback(
-    instance => {
+    (instance: TInstance) => {
       // NOTE: This may be called more often than necessary (e.g. when `props`
       // changes), but `setNativeView` already optimizes for that.
       node.setNativeView(instance);
@@ -141,16 +138,11 @@ function useAnimatedPropsLifecycle(node: AnimatedProps): void {
   const prevNodeRef = useRef<?AnimatedProps>(null);
   const isUnmountingRef = useRef<boolean>(false);
 
-  const [animatedComponentId] = useState(
-    () => `${animatedComponentNextId++}:animatedComponent`,
-  );
-
-  useLayoutEffect(() => {
-    NativeAnimatedHelper.API.setWaitingForIdentifier(animatedComponentId);
-  });
-
   useEffect(() => {
-    NativeAnimatedHelper.API.unsetWaitingForIdentifier(animatedComponentId);
+    // It is ok for multiple components to call `flushQueue` because it noops
+    // if the queue is empty. When multiple animated components are mounted at
+    // the same time. Only first component flushes the queue and the others will noop.
+    NativeAnimatedHelper.API.flushQueue();
   });
 
   useLayoutEffect(() => {

package/Libraries/Animated/useAnimatedValue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import type {Animated} from './Animated';
+
+export function useAnimatedValue(
+  initialValue: number,
+  config?: Animated.AnimatedConfig,
+): Animated.Value;

package/Libraries/Animated/useAnimatedValue.js

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and 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
+ */
+
+import type {AnimatedValueConfig} from './nodes/AnimatedValue';
+
+import Animated from './Animated';
+import {useRef} from 'react';
+
+export default function useAnimatedValue(
+  initialValue: number,
+  config?: ?AnimatedValueConfig,
+): Animated.Value {
+  const ref = useRef<null | Animated.Value>(null);
+  if (ref.current == null) {
+    ref.current = new Animated.Value(initialValue, config);
+  }
+  return ref.current;
+}

package/Libraries/AppState/AppState.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import {NativeEventSubscription} from '../EventEmitter/RCTNativeAppEventEmitter';
+
+/**
+ * AppState can tell you if the app is in the foreground or background,
+ * and notify you when the state changes.
+ *
+ * AppState is frequently used to determine the intent and proper behavior
+ * when handling push notifications.
+ *
+ * App State Events
+ *      change - This even is received when the app state has changed.
+ *      focus [Android] - Received when the app gains focus (the user is interacting with the app).
+ *      blur [Android] - Received when the user is not actively interacting with the app.
+ *
+ * App States
+ *      active - The app is running in the foreground
+ *      background - The app is running in the background. The user is either in another app or on the home screen
+ *      inactive [iOS] - This is a transition state that currently never happens for typical React Native apps.
+ *      unknown [iOS] - Initial value until the current app state is determined
+ *      extension [iOS] - The app is running as an app extension
+ *
+ * For more information, see Apple's documentation: https://developer.apple.com/library/ios/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/TheAppLifeCycle/TheAppLifeCycle.html
+ *
+ * @see https://reactnative.dev/docs/appstate#app-states
+ */
+export type AppStateEvent = 'change' | 'memoryWarning' | 'blur' | 'focus';
+export type AppStateStatus =
+  | 'active'
+  | 'background'
+  | 'inactive'
+  | 'unknown'
+  | 'extension';
+
+export interface AppStateStatic {
+  currentState: AppStateStatus;
+  isAvailable: boolean;
+
+  /**
+   * Add a handler to AppState changes by listening to the change event
+   * type and providing the handler
+   */
+  addEventListener(
+    type: AppStateEvent,
+    listener: (state: AppStateStatus) => void,
+  ): NativeEventSubscription;
+}
+
+export const AppState: AppStateStatic;
+export type AppState = AppStateStatic;

package/Libraries/AppState/AppState.js

@@ -8,11 +8,11 @@
  * @format
  */
 
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import logError from '../Utilities/logError';
-import NativeAppState from './NativeAppState';
 import Platform from '../Utilities/Platform';
+import {type EventSubscription} from '../vendor/emitter/EventEmitter';
+import NativeAppState from './NativeAppState';
 
 export type AppStateValues = 'inactive' | 'background' | 'active';
 
@@ -76,17 +76,13 @@ class AppState {
         // It's possible that the state will have changed here & listeners need to be notified
         if (!eventUpdated && this.currentState !== appStateData.app_state) {
           this.currentState = appStateData.app_state;
+          // $FlowFixMe[incompatible-call]
           emitter.emit('appStateDidChange', appStateData);
         }
       }, logError);
     }
   }
 
-  // TODO: now that AppState is a subclass of NativeEventEmitter, we could
-  // deprecate `addEventListener` and `removeEventListener` and just use
-  // addListener` and `listener.remove()` directly. That will be a breaking
-  // change though, as both the method and event names are different
-  // (addListener events are currently required to be globally unique).
   /**
    * Add a handler to AppState changes by listening to the `change` event type
    * and providing the handler.

package/Libraries/AppState/NativeAppState.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {

package/Libraries/BatchedBridge/MessageQueue.js

@@ -241,7 +241,7 @@ class MessageQueue {
     params: mixed[],
     onFail: ?(...mixed[]) => void,
     onSucc: ?(...mixed[]) => void,
-  ) {
+  ): void {
     this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
 
     this._queue[MODULE_IDS].push(moduleID);
@@ -252,7 +252,7 @@ class MessageQueue {
       // folly-convertible.  As a special case, if a prop value is a
       // function it is permitted here, and special-cased in the
       // conversion.
-      const isValidArgument = (val: mixed) => {
+      const isValidArgument = (val: mixed): boolean => {
         switch (typeof val) {
           case 'undefined':
           case 'boolean':
@@ -321,6 +321,7 @@ class MessageQueue {
     }
     Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);
     if (__DEV__ && this.__spy && isFinite(moduleID)) {
+      // $FlowFixMe[not-a-function]
       this.__spy({
         type: TO_NATIVE,
         module: this._remoteModuleTable[moduleID],
@@ -380,7 +381,7 @@ class MessageQueue {
     return (
       // $FlowFixMe[cannot-resolve-name]
       typeof DebuggerInternal !== 'undefined' &&
-      DebuggerInternal.shouldPauseOnThrow === true // eslint-disable-line no-undef
+      DebuggerInternal.shouldPauseOnThrow === true
     );
   }
 
@@ -408,9 +409,12 @@ class MessageQueue {
       const callableModuleNames = Object.keys(this._lazyCallableModules);
       const n = callableModuleNames.length;
       const callableModuleNameList = callableModuleNames.join(', ');
+
+      // TODO(T122225939): Remove after investigation: Why are we getting to this line in bridgeless mode?
+      const isBridgelessMode = global.RN$Bridgeless === true ? 'true' : 'false';
       invariant(
         false,
-        `Failed to call into JavaScript module method ${module}.${method}(). Module has not been registered as callable. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
+        `Failed to call into JavaScript module method ${module}.${method}(). Module has not been registered as callable. Bridgeless Mode: ${isBridgelessMode}. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
         A frequent cause of the error is that the application entry file path is incorrect. This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.`,
       );
     }
@@ -424,7 +428,7 @@ class MessageQueue {
     Systrace.endEvent();
   }
 
-  __invokeCallback(cbID: number, args: mixed[]) {
+  __invokeCallback(cbID: number, args: mixed[]): void {
     this._lastFlush = Date.now();
     this._eventLoopStartTime = this._lastFlush;
 

package/Libraries/BatchedBridge/NativeModules.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+/**
+ * Interface for NativeModules which allows to augment NativeModules with type informations.
+ * See react-native-sensor-manager for example.
+ */
+interface NativeModulesStatic {
+  [name: string]: any;
+}
+
+/**
+ * Native Modules written in ObjectiveC/Swift/Java exposed via the RCTBridge
+ * Define lazy getters for each module. These will return the module if already loaded, or load it if not.
+ * See https://reactnative.dev/docs/native-modules-ios
+ * @example
+ * const MyModule = NativeModules.ModuleName
+ */
+export const NativeModules: NativeModulesStatic;

package/Libraries/BatchedBridge/NativeModules.js

@@ -155,6 +155,7 @@ function genMethod(moduleID: number, methodID: number, type: MethodType) {
       }
     };
   }
+  // $FlowFixMe[prop-missing]
   fn.type = type;
   return fn;
 }

package/Libraries/Blob/BlobManager.js

@@ -8,13 +8,14 @@
  * @format
  */
 
-const Blob = require('./Blob');
-const BlobRegistry = require('./BlobRegistry');
+import type {BlobCollector, BlobData, BlobOptions} from './BlobTypes';
 
-import type {BlobData, BlobOptions, BlobCollector} from './BlobTypes';
 import NativeBlobModule from './NativeBlobModule';
 import invariant from 'invariant';
 
+const Blob = require('./Blob');
+const BlobRegistry = require('./BlobRegistry');
+
 /*eslint-disable no-bitwise */
 /*eslint-disable eqeqeq */
 
@@ -110,6 +111,7 @@ class BlobManager {
    */
   static createFromOptions(options: BlobData): Blob {
     BlobRegistry.register(options.blobId);
+    // $FlowFixMe[prop-missing]
     return Object.assign(Object.create(Blob.prototype), {
       data:
         // Reuse the collector instance when creating from an existing blob.