react-native-tvos 0.64.2-5 → 0.66.3-2

package/Libraries/Animated/nodes/AnimatedInterpolation.js

@@ -205,14 +205,12 @@ function createInterpolationFromStringOutputRange(
   //   [200, 250],
   //   [0, 0.5],
   // ]
-  /* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need to
-   * guard against this possibility.
-   */
+  /* $FlowFixMe[incompatible-use] (>=0.18.0): `outputRange[0].match()` can
+   * return `null`. Need to guard against this possibility. */
   const outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
   outputRange.forEach(value => {
-    /* $FlowFixMe(>=0.18.0): `value.match()` can return `null`. Need to guard
-     * against this possibility.
-     */
+    /* $FlowFixMe[incompatible-use] (>=0.18.0): `value.match()` can return
+     * `null`. Need to guard against this possibility. */
     value.match(stringShapeRegex).forEach((number, i) => {
       outputRanges[i].push(+number);
     });
@@ -220,8 +218,10 @@ function createInterpolationFromStringOutputRange(
 
   const interpolations = outputRange[0]
     .match(stringShapeRegex)
-    /* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need
-     * to guard against this possibility. */
+    /* $FlowFixMe[incompatible-use] (>=0.18.0): `outputRange[0].match()` can
+     * return `null`. Need to guard against this possibility. */
+    /* $FlowFixMe[incompatible-call] (>=0.18.0): `outputRange[0].match()` can
+     * return `null`. Need to guard against this possibility. */
     .map((value, i) => {
       return createInterpolation({
         ...config,
@@ -277,12 +277,11 @@ function checkValidInputRange(arr: $ReadOnlyArray<number>) {
   for (let i = 1; i < arr.length; ++i) {
     invariant(
       arr[i] >= arr[i - 1],
-      /* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
-       * one or both of the operands may be something that doesn't cleanly
-       * convert to a string, like undefined, null, and object, etc. If you really
-       * mean this implicit string conversion, you can do something like
-       * String(myThing)
-       */
+      /* $FlowFixMe[incompatible-type] (>=0.13.0) - In the addition expression
+       * below this comment, one or both of the operands may be something that
+       * doesn't cleanly convert to a string, like undefined, null, and object,
+       * etc. If you really mean this implicit string conversion, you can do
+       * something like String(myThing) */
       'inputRange must be monotonically non-decreasing ' + arr,
     );
   }
@@ -292,12 +291,11 @@ function checkInfiniteRange(name: string, arr: $ReadOnlyArray<number>) {
   invariant(arr.length >= 2, name + ' must have at least 2 elements');
   invariant(
     arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity,
-    /* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
-     * one or both of the operands may be something that doesn't cleanly convert
-     * to a string, like undefined, null, and object, etc. If you really mean
-     * this implicit string conversion, you can do something like
-     * String(myThing)
-     */
+    /* $FlowFixMe[incompatible-type] (>=0.13.0) - In the addition expression
+     * below this comment, one or both of the operands may be something that
+     * doesn't cleanly convert to a string, like undefined, null, and object,
+     * etc. If you really mean this implicit string conversion, you can do
+     * something like String(myThing) */
     name + 'cannot be ]-infinity;+infinity[ ' + arr,
   );
 }
@@ -358,8 +356,9 @@ class AnimatedInterpolation extends AnimatedWithChildren {
     return {
       inputRange: this._config.inputRange,
       // Only the `outputRange` can contain strings so we don't need to transform `inputRange` here
-      /* $FlowFixMe(>=0.38.0) - Flow error detected during the deployment of
-       * v0.38.0. To see the error, remove this comment and run flow */
+      /* $FlowFixMe[incompatible-call] (>=0.38.0) - Flow error detected during
+       * the deployment of v0.38.0. To see the error, remove this comment and
+       * run flow */
       outputRange: this.__transformDataType(this._config.outputRange),
       extrapolateLeft:
         this._config.extrapolateLeft || this._config.extrapolate || 'extend',

package/Libraries/Animated/nodes/AnimatedProps.js

@@ -33,7 +33,6 @@ class AnimatedProps extends AnimatedNode {
     }
     this._props = props;
     this._callback = callback;
-    this.__attach();
   }
 
   __getValue(): Object {

package/Libraries/Animated/nodes/AnimatedValue.js

@@ -46,9 +46,9 @@ const NativeAnimatedAPI = NativeAnimatedHelper.API;
 function _flush(rootNode: AnimatedValue): void {
   const animatedStyles = new Set();
   function findAnimatedStyles(node) {
-    /* $FlowFixMe(>=0.68.0 site=react_native_fb) This comment suppresses an
-     * error found when Flow v0.68 was deployed. To see the error delete this
-     * comment and run Flow. */
+    /* $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
+     * delete this comment and run Flow. */
     if (typeof node.update === 'function') {
       animatedStyles.add(node);
     } else {
@@ -56,10 +56,21 @@ function _flush(rootNode: AnimatedValue): void {
     }
   }
   findAnimatedStyles(rootNode);
-  /* $FlowFixMe */
+  // $FlowFixMe[prop-missing]
   animatedStyles.forEach(animatedStyle => animatedStyle.update());
 }
 
+/**
+ * Some operations are executed only on batch end, which is _mostly_ scheduled when
+ * Animated component props change. For some of the changes which require immediate execution
+ * (e.g. setValue), we create a separate batch in case none is scheduled.
+ */
+function _executeAsAnimatedBatch(id: string, operation: () => void) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id);
+  operation();
+  NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+
 /**
  * Standard value for driving animations.  One `Animated.Value` can drive
  * multiple properties in a synchronized fashion, but can only be driven by one
@@ -115,7 +126,9 @@ class AnimatedValue extends AnimatedWithChildren {
       !this.__isNative /* don't perform a flush for natively driven values */,
     );
     if (this.__isNative) {
-      NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value);
+      _executeAsAnimatedBatch(this.__getNativeTag().toString(), () => {
+        NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value);
+      });
     }
   }
 
@@ -183,6 +196,12 @@ class AnimatedValue extends AnimatedWithChildren {
   resetAnimation(callback?: ?(value: number) => void): void {
     this.stopAnimation(callback);
     this._value = this._startingValue;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeValue(
+        this.__getNativeTag(),
+        this._startingValue,
+      );
+    }
   }
 
   _onAnimatedValueUpdateReceived(value: number): void {

package/Libraries/Animated/nodes/AnimatedWithChildren.js

@@ -76,6 +76,7 @@ class AnimatedWithChildren extends AnimatedNode {
     super.__callListeners(value);
     if (!this.__isNative) {
       for (const child of this._children) {
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
         if (child.__getValue) {
           child.__callListeners(child.__getValue());
         }

package/Libraries/Animated/useAnimatedProps.js

@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import AnimatedProps from './nodes/AnimatedProps';
+import {AnimatedEvent} from './AnimatedEvent';
+import useRefEffect from '../Utilities/useRefEffect';
+import NativeAnimatedHelper from './NativeAnimatedHelper';
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+} from 'react';
+
+type ReducedProps<TProps> = {
+  ...TProps,
+  collapsable: boolean,
+  ...
+};
+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 onUpdateRef = useRef<?() => void>(null);
+
+  // TODO: Only invalidate `node` if animated props or `style` change. In the
+  // previous implementation, we permitted `style` to override props with the
+  // same name property name as styles, so we can probably continue doing that.
+  // The ordering of other props *should* not matter.
+  const node = useMemo(
+    () => new AnimatedProps(props, () => onUpdateRef.current?.()),
+    [props],
+  );
+  useAnimatedPropsLifecycle(node);
+
+  // TODO: This "effect" does three things:
+  //
+  //   1) Call `setNativeView`.
+  //   2) Update `onUpdateRef`.
+  //   3) Update listeners for `AnimatedEvent` props.
+  //
+  // Ideally, each of these would be separat "effects" so that they are not
+  // unnecessarily re-run when irrelevant dependencies change. For example, we
+  // should be able to hoist all `AnimatedEvent` props and only do #3 if either
+  // the `AnimatedEvent` props change or `instance` changes.
+  //
+  // 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 => {
+      // NOTE: This may be called more often than necessary (e.g. when `props`
+      // changes), but `setNativeView` already optimizes for that.
+      node.setNativeView(instance);
+
+      // NOTE: This callback is only used by the JavaScript animation driver.
+      onUpdateRef.current = () => {
+        if (
+          process.env.NODE_ENV === 'test' ||
+          typeof instance !== 'object' ||
+          typeof instance?.setNativeProps !== 'function' ||
+          isFabricInstance(instance)
+        ) {
+          // Schedule an update for this component to update `reducedProps`,
+          // but do not compute it immediately. If a parent also updated, we
+          // need to merge those new props in before updating.
+          scheduleUpdate();
+        } else if (!node.__isNative) {
+          // $FlowIgnore[not-a-function] - Assume it's still a function.
+          instance.setNativeProps(node.__getAnimatedValue());
+        } else {
+          throw new Error(
+            'Attempting to run JS driven animation on animated node ' +
+              'that has been moved to "native" earlier by starting an ' +
+              'animation with `useNativeDriver: true`',
+          );
+        }
+      };
+
+      const target = getEventTarget(instance);
+      const events = [];
+
+      for (const propName in props) {
+        const propValue = props[propName];
+        if (propValue instanceof AnimatedEvent && propValue.__isNative) {
+          propValue.__attach(target, propName);
+          events.push([propName, propValue]);
+        }
+      }
+
+      return () => {
+        onUpdateRef.current = null;
+
+        for (const [propName, propValue] of events) {
+          propValue.__detach(target, propName);
+        }
+      };
+    },
+    [props, node],
+  );
+  const callbackRef = useRefEffect<TInstance>(refEffect);
+
+  return [reduceAnimatedProps<TProps>(node), callbackRef];
+}
+
+function reduceAnimatedProps<TProps>(
+  node: AnimatedProps,
+): ReducedProps<TProps> {
+  // Force `collapsable` to be false so that the native view is not flattened.
+  // Flattened views cannot be accurately referenced by the native driver.
+  return {
+    ...node.__getValue(),
+    collapsable: false,
+  };
+}
+
+/**
+ * Manages the lifecycle of the supplied `AnimatedProps` by invoking `__attach`
+ * and `__detach`. However, this is more complicated because `AnimatedProps`
+ * uses reference counting to determine when to recursively detach its children
+ * nodes. So in order to optimize this, we avoid detaching until the next attach
+ * unless we are unmounting.
+ */
+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);
+  });
+
+  useLayoutEffect(() => {
+    isUnmountingRef.current = false;
+    return () => {
+      isUnmountingRef.current = true;
+    };
+  }, []);
+
+  useLayoutEffect(() => {
+    node.__attach();
+    if (prevNodeRef.current != null) {
+      const prevNode = prevNodeRef.current;
+      // TODO: Stop restoring default values (unless `reset` is called).
+      prevNode.__restoreDefaultValues();
+      prevNode.__detach();
+      prevNodeRef.current = null;
+    }
+    return () => {
+      if (isUnmountingRef.current) {
+        // NOTE: Do not restore default values on unmount, see D18197735.
+        node.__detach();
+      } else {
+        prevNodeRef.current = node;
+      }
+    };
+  }, [node]);
+}
+
+function getEventTarget<TInstance>(instance: TInstance): TInstance {
+  return typeof instance === 'object' &&
+    typeof instance?.getScrollableNode === 'function'
+    ? // $FlowFixMe[incompatible-use] - Legacy instance assumptions.
+      instance.getScrollableNode()
+    : instance;
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function isFabricInstance(instance: any): boolean {
+  return (
+    hasFabricHandle(instance) ||
+    // Some components have a setNativeProps function but aren't a host component
+    // such as lists like FlatList and SectionList. These should also use
+    // forceUpdate in Fabric since setNativeProps doesn't exist on the underlying
+    // host component. This crazy hack is essentially special casing those lists and
+    // ScrollView itself to use forceUpdate in Fabric.
+    // If these components end up using forwardRef then these hacks can go away
+    // as instance would actually be the underlying host component and the above check
+    // would be sufficient.
+    hasFabricHandle(instance?.getNativeScrollRef?.()) ||
+    hasFabricHandle(instance?.getScrollResponder?.()?.getNativeScrollRef?.())
+  );
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function hasFabricHandle(instance: any): boolean {
+  // eslint-disable-next-line dot-notation
+  return instance?.['_internalInstanceHandle']?.stateNode?.canonical != null;
+}

package/Libraries/AppState/AppState.js

@@ -4,17 +4,30 @@
  * 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
- * @flow
  */
 
-'use strict';
-
+import {type EventSubscription} from '../vendor/emitter/EventEmitter';
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import logError from '../Utilities/logError';
-import EventEmitter from '../vendor/emitter/EventEmitter';
 import NativeAppState from './NativeAppState';
-import invariant from 'invariant';
+import Platform from '../Utilities/Platform';
+
+export type AppStateValues = 'inactive' | 'background' | 'active';
+
+type AppStateEventDefinitions = {
+  change: [AppStateValues],
+  memoryWarning: [],
+  blur: [],
+  focus: [],
+};
+
+type NativeAppStateEventDefinitions = {
+  appStateDidChange: [{app_state: AppStateValues}],
+  appStateFocusChange: [boolean],
+  memoryWarning: [],
+};
 
 /**
  * `AppState` can tell you if the app is in the foreground or background,
@@ -22,44 +35,50 @@ import invariant from 'invariant';
  *
  * See https://reactnative.dev/docs/appstate.html
  */
-class AppState extends NativeEventEmitter {
-  _eventHandlers: Object;
-  _supportedEvents = ['change', 'memoryWarning', 'blur', 'focus'];
-  currentState: ?string;
+class AppState {
+  currentState: ?string = null;
   isAvailable: boolean;
 
-  constructor() {
-    super(NativeAppState);
-
-    this.isAvailable = true;
-    this._eventHandlers = this._supportedEvents.reduce((handlers, key) => {
-      handlers[key] = new Map();
-      return handlers;
-    }, {});
-
-    this.currentState = NativeAppState.getConstants().initialAppState;
-
-    let eventUpdated = false;
+  _emitter: ?NativeEventEmitter<NativeAppStateEventDefinitions>;
 
-    // TODO: this is a terrible solution - in order to ensure `currentState`
-    // prop is up to date, we have to register an observer that updates it
-    // whenever the state changes, even if nobody cares. We should just
-    // deprecate the `currentState` property and get rid of this.
-    this.addListener('appStateDidChange', appStateData => {
-      eventUpdated = true;
-      this.currentState = appStateData.app_state;
-    });
-
-    // TODO: see above - this request just populates the value of `currentState`
-    // when the module is first initialized. Would be better to get rid of the
-    // prop and expose `getCurrentAppState` method directly.
-    NativeAppState.getCurrentAppState(appStateData => {
-      // It's possible that the state will have changed here & listeners need to be notified
-      if (!eventUpdated && this.currentState !== appStateData.app_state) {
+  constructor() {
+    if (NativeAppState == null) {
+      this.isAvailable = false;
+    } else {
+      this.isAvailable = true;
+
+      const emitter: NativeEventEmitter<NativeAppStateEventDefinitions> = new NativeEventEmitter(
+        // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+        // If you want to use the native module on other platforms, please remove this condition and test its behavior
+        Platform.OS !== 'ios' ? null : NativeAppState,
+      );
+      this._emitter = emitter;
+
+      this.currentState = NativeAppState.getConstants().initialAppState;
+
+      let eventUpdated = false;
+
+      // TODO: this is a terrible solution - in order to ensure `currentState`
+      // prop is up to date, we have to register an observer that updates it
+      // whenever the state changes, even if nobody cares. We should just
+      // deprecate the `currentState` property and get rid of this.
+      emitter.addListener('appStateDidChange', appStateData => {
+        eventUpdated = true;
         this.currentState = appStateData.app_state;
-        this.emit('appStateDidChange', appStateData);
-      }
-    }, logError);
+      });
+
+      // TODO: see above - this request just populates the value of `currentState`
+      // when the module is first initialized. Would be better to get rid of the
+      // prop and expose `getCurrentAppState` method directly.
+      // $FlowExpectedError[incompatible-call]
+      NativeAppState.getCurrentAppState(appStateData => {
+        // 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;
+          emitter.emit('appStateDidChange', appStateData);
+        }
+      }, logError);
+    }
   }
 
   // TODO: now that AppState is a subclass of NativeEventEmitter, we could
@@ -73,107 +92,72 @@ class AppState extends NativeEventEmitter {
    *
    * See https://reactnative.dev/docs/appstate.html#addeventlistener
    */
-  addEventListener(type: string, handler: Function) {
-    invariant(
-      this._supportedEvents.indexOf(type) !== -1,
-      'Trying to subscribe to unknown event: "%s"',
-      type,
-    );
-
+  addEventListener<K: $Keys<AppStateEventDefinitions>>(
+    type: K,
+    handler: (...$ElementType<AppStateEventDefinitions, K>) => void,
+  ): EventSubscription {
+    const emitter = this._emitter;
+    if (emitter == null) {
+      throw new Error('Cannot use AppState when `isAvailable` is false.');
+    }
     switch (type) {
-      case 'change': {
-        this._eventHandlers[type].set(
-          handler,
-          this.addListener('appStateDidChange', appStateData => {
-            handler(appStateData.app_state);
-          }),
-        );
-        break;
-      }
-      case 'memoryWarning': {
-        this._eventHandlers[type].set(
-          handler,
-          this.addListener('memoryWarning', handler),
-        );
-        break;
-      }
-
+      case 'change':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        const changeHandler: AppStateValues => void = handler;
+        return emitter.addListener('appStateDidChange', appStateData => {
+          changeHandler(appStateData.app_state);
+        });
+      case 'memoryWarning':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        const memoryWarningHandler: () => void = handler;
+        return emitter.addListener('memoryWarning', memoryWarningHandler);
       case 'blur':
-      case 'focus': {
-        this._eventHandlers[type].set(
-          handler,
-          this.addListener('appStateFocusChange', hasFocus => {
-            if (type === 'blur' && !hasFocus) {
-              handler();
-            }
-            if (type === 'focus' && hasFocus) {
-              handler();
-            }
-          }),
-        );
-      }
+      case 'focus':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        const focusOrBlurHandler: () => void = handler;
+        return emitter.addListener('appStateFocusChange', hasFocus => {
+          if (type === 'blur' && !hasFocus) {
+            focusOrBlurHandler();
+          }
+          if (type === 'focus' && hasFocus) {
+            focusOrBlurHandler();
+          }
+        });
     }
+    throw new Error('Trying to subscribe to unknown event: ' + type);
   }
 
   /**
-   * Remove a handler by passing the `change` event type and the handler.
-   *
-   * See https://reactnative.dev/docs/appstate.html#removeeventlistener
+   * @deprecated Use `remove` on the EventSubscription from `addEventListener`.
    */
-  removeEventListener(type: string, handler: Function) {
-    invariant(
-      this._supportedEvents.indexOf(type) !== -1,
-      'Trying to remove listener for unknown event: "%s"',
-      type,
-    );
-    if (!this._eventHandlers[type].has(handler)) {
-      return;
+  removeEventListener<K: $Keys<AppStateEventDefinitions>>(
+    type: K,
+    listener: (...$ElementType<AppStateEventDefinitions, K>) => mixed,
+  ): void {
+    const emitter = this._emitter;
+    if (emitter == null) {
+      throw new Error('Cannot use AppState when `isAvailable` is false.');
     }
-    this._eventHandlers[type].get(handler).remove();
-    this._eventHandlers[type].delete(handler);
-  }
-}
-
-function throwMissingNativeModule() {
-  invariant(
-    false,
-    'Cannot use AppState module when native RCTAppState is not included in the build.\n' +
-      'Either include it, or check AppState.isAvailable before calling any methods.',
-  );
-}
-
-class MissingNativeAppStateShim extends EventEmitter {
-  // AppState
-  isAvailable: boolean = false;
-  currentState: ?string = null;
-
-  addEventListener(type: string, handler: Function) {
-    throwMissingNativeModule();
-  }
-
-  removeEventListener(type: string, handler: Function) {
-    throwMissingNativeModule();
-  }
-
-  // EventEmitter
-  addListener() {
-    throwMissingNativeModule();
-  }
-
-  removeAllListeners() {
-    throwMissingNativeModule();
-  }
-
-  removeSubscription() {
-    throwMissingNativeModule();
+    // NOTE: This will report a deprecation notice via `console.error`.
+    switch (type) {
+      case 'change':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        // $FlowIssue[incompatible-call]
+        emitter.removeListener('appStateDidChange', listener);
+        return;
+      case 'memoryWarning':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        emitter.removeListener('memoryWarning', listener);
+        return;
+      case 'blur':
+      case 'focus':
+        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
+        // $FlowIssue[incompatible-call]
+        emitter.addListener('appStateFocusChange', listener);
+        return;
+    }
+    throw new Error('Trying to unsubscribe from unknown event: ' + type);
   }
 }
 
-// This module depends on the native `RCTAppState` module. If you don't include it,
-// `AppState.isAvailable` will return `false`, and any method calls will throw.
-// We reassign the class variable to keep the autodoc generator happy.
-const AppStateInstance: AppState | MissingNativeAppStateShim = NativeAppState
-  ? new AppState()
-  : new MissingNativeAppStateShim();
-
-module.exports = AppStateInstance;
+module.exports = (new AppState(): AppState);

package/Libraries/AppState/NativeAppState.js

@@ -8,8 +8,6 @@
  * @format
  */
 
-'use strict';
-
 import type {TurboModule} from '../TurboModule/RCTExport';
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';