@office-iss/react-native-win32 0.73.2 → 0.74.0-preview.1

package/Libraries/Animated/NativeAnimatedTurboModule.js

@@ -4,75 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 
-import type {TurboModule} from '../TurboModule/RCTExport';
-
-import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
-import shouldUseTurboAnimatedModule from './shouldUseTurboAnimatedModule';
-
-type EndResult = {finished: boolean, value?: number, ...};
-type EndCallback = (result: EndResult) => void;
-type SaveValueCallback = (value: number) => void;
-
-export type EventMapping = {|
-  nativeEventPath: Array<string>,
-  animatedValueTag: ?number,
-|};
-
-// The config has different keys depending on the type of the Node
-// TODO(T54896888): Make these types strict
-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: (
-    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;
-  +disconnectAnimatedNodeFromView: (nodeTag: number, viewTag: number) => void;
-  +restoreDefaultValues: (nodeTag: number) => void;
-  +dropAnimatedNode: (tag: number) => void;
-  +addAnimatedEventToView: (
-    viewTag: number,
-    eventName: string,
-    eventMapping: EventMapping,
-  ) => void;
-  +removeAnimatedEventFromView: (
-    viewTag: number,
-    eventName: string,
-    animatedNodeTag: number,
-  ) => void;
-
-  // Events
-  +addListener: (eventName: string) => void;
-  +removeListeners: (count: number) => void;
-
-  // All of the above in a batched mode
-  +queueAndExecuteBatchedOperations?: (operationsAndArgs: Array<any>) => void;
-}
-
-const NativeModule: ?Spec = shouldUseTurboAnimatedModule()
-  ? TurboModuleRegistry.get<Spec>('NativeAnimatedTurboModule')
-  : null;
-
-export default NativeModule;
+export * from '../../src/private/specs/modules/NativeAnimatedTurboModule';
+import NativeAnimatedTurboModule from '../../src/private/specs/modules/NativeAnimatedTurboModule';
+export default NativeAnimatedTurboModule;

package/Libraries/Animated/animations/Animation.js

@@ -14,11 +14,8 @@ import type {PlatformConfig} from '../AnimatedPlatformConfig';
 import type AnimatedNode from '../nodes/AnimatedNode';
 import type AnimatedValue from '../nodes/AnimatedValue';
 
-import Platform from '../../Utilities/Platform';
 import NativeAnimatedHelper from '../NativeAnimatedHelper';
-import AnimatedColor from '../nodes/AnimatedColor';
 import AnimatedProps from '../nodes/AnimatedProps';
-import AnimatedValueXY from '../nodes/AnimatedValueXY';
 
 export type EndResult = {finished: boolean, value?: number, ...};
 export type EndCallback = (result: EndResult) => void;
@@ -39,10 +36,11 @@ let startNativeAnimationNextId = 1;
 export default class Animation {
   __active: boolean;
   __isInteraction: boolean;
-  __nativeId: number;
   __onEnd: ?EndCallback;
   __iterations: number;
 
+  _nativeId: number;
+
   start(
     fromValue: number,
     onUpdate: (value: number) => void,
@@ -52,8 +50,8 @@ export default class Animation {
   ): void {}
 
   stop(): void {
-    if (this.__nativeId) {
-      NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+    if (this._nativeId) {
+      NativeAnimatedHelper.API.stopAnimation(this._nativeId);
     }
   }
 
@@ -78,20 +76,6 @@ export default class Animation {
       return result;
     }
 
-    // Vectorized animations (animations on AnimatedValueXY, AnimatedColor nodes)
-    // are split into multiple animations for each component that execute in parallel.
-    // Calling update() on AnimatedProps when each animation completes results in
-    // potential flickering as all animations that are part of the vectorized animation
-    // may not have completed yet. For example, only the animation for the red channel of
-    // an animating color may have been completed, resulting in a temporary red color
-    // being rendered. So, for now, ignore AnimatedProps that use a vectorized animation.
-    if (
-      Platform.OS === 'ios' &&
-      (node instanceof AnimatedValueXY || node instanceof AnimatedColor)
-    ) {
-      return result;
-    }
-
     for (const child of node.__getChildren()) {
       result.push(...this.__findAnimatedPropsNodes(child));
     }
@@ -108,9 +92,9 @@ export default class Animation {
     try {
       const config = this.__getNativeAnimationConfig();
       animatedValue.__makeNative(config.platformConfig);
-      this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
+      this._nativeId = NativeAnimatedHelper.generateNewAnimationId();
       NativeAnimatedHelper.API.startAnimatingNode(
-        this.__nativeId,
+        this._nativeId,
         animatedValue.__getNativeTag(),
         config,
         result => {

package/Libraries/Animated/components/AnimatedFlatList.js

@@ -14,22 +14,7 @@ import FlatList from '../../Lists/FlatList';
 import createAnimatedComponent from '../createAnimatedComponent';
 import * as React from 'react';
 
-/**
- * @see https://github.com/facebook/react-native/commit/b8c8562
- */
-const FlatListWithEventThrottle = React.forwardRef(
-  // $FlowFixMe[incompatible-call]
-  (
-    props: React.ElementConfig<typeof FlatList>,
-    ref:
-      | ((null | FlatList<mixed>) => mixed)
-      | {current: null | FlatList<mixed>, ...},
-  ) => <FlatList {...props} ref={ref} />,
-);
-
-export default (createAnimatedComponent(
-  FlatListWithEventThrottle,
-): AnimatedComponentType<
+export default (createAnimatedComponent(FlatList): AnimatedComponentType<
   React.ElementConfig<typeof FlatList>,
   React.ElementRef<typeof FlatList>,
 >);

package/Libraries/Animated/components/AnimatedScrollView.js

@@ -30,39 +30,44 @@ type Instance = React.ElementRef<typeof ScrollView>;
  * @see https://github.com/facebook/react-native/commit/b8c8562
  */
 const AnimatedScrollView: AnimatedComponentType<Props, Instance> =
-  React.forwardRef((props, forwardedRef) => {
-    // (Android only) When a ScrollView has a RefreshControl and
-    // any `style` property set with an Animated.Value, the CSS
-    // gets incorrectly applied twice. This is because ScrollView
-    // swaps the parent/child relationship of itself and the
-    // RefreshControl component (see ScrollView.js for more details).
-    if (
-      Platform.OS === 'android' &&
-      props.refreshControl != null &&
-      props.style != null
+  React.forwardRef(
+    function AnimatedScrollViewWithOrWithoutInvertedRefreshControl(
+      props,
+      forwardedRef,
     ) {
-      return (
-        <AnimatedScrollViewWithInvertedRefreshControl
-          scrollEventThrottle={0.0001}
-          {...props}
-          ref={forwardedRef}
-          refreshControl={props.refreshControl}
-        />
-      );
-    } else {
-      return (
-        <AnimatedScrollViewWithoutInvertedRefreshControl
-          scrollEventThrottle={0.0001}
-          {...props}
-          ref={forwardedRef}
-        />
-      );
-    }
-  });
+      // (Android only) When a ScrollView has a RefreshControl and
+      // any `style` property set with an Animated.Value, the CSS
+      // gets incorrectly applied twice. This is because ScrollView
+      // swaps the parent/child relationship of itself and the
+      // RefreshControl component (see ScrollView.js for more details).
+      if (
+        Platform.OS === 'android' &&
+        props.refreshControl != null &&
+        props.style != null
+      ) {
+        return (
+          <AnimatedScrollViewWithInvertedRefreshControl
+            scrollEventThrottle={0.0001}
+            {...props}
+            ref={forwardedRef}
+            refreshControl={props.refreshControl}
+          />
+        );
+      } else {
+        return (
+          <AnimatedScrollViewWithoutInvertedRefreshControl
+            scrollEventThrottle={0.0001}
+            {...props}
+            ref={forwardedRef}
+          />
+        );
+      }
+    },
+  );
 
 const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
   // $FlowFixMe[incompatible-call]
-  (
+  function AnimatedScrollViewWithInvertedRefreshControl(
     props: {
       ...React.ElementConfig<typeof ScrollView>,
       // $FlowFixMe[unclear-type] Same Flow type as `refreshControl` in ScrollView
@@ -71,7 +76,7 @@ const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
     forwardedRef:
       | {current: Instance | null, ...}
       | ((Instance | null) => mixed),
-  ) => {
+  ) {
     // Split `props` into the animate-able props for the parent (RefreshControl)
     // and child (ScrollView).
     const {intermediatePropsForRefreshControl, intermediatePropsForScrollView} =
@@ -103,7 +108,7 @@ const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
       Props,
       Instance,
     >(intermediatePropsForScrollView);
-    const ref = useMergeRefs<Instance | null>(scrollViewRef, forwardedRef);
+    const ref = useMergeRefs<Instance>(scrollViewRef, forwardedRef);
 
     return (
       // $FlowFixMe[incompatible-use] Investigate useAnimatedProps return value

package/Libraries/Animated/components/AnimatedSectionList.js

@@ -8,32 +8,13 @@
  * @format
  */
 
-import type {SectionBase} from '../../Lists/SectionList';
 import type {AnimatedComponentType} from '../createAnimatedComponent';
 
 import SectionList from '../../Lists/SectionList';
 import createAnimatedComponent from '../createAnimatedComponent';
 import * as React from 'react';
 
-/**
- * @see https://github.com/facebook/react-native/commit/b8c8562
- */
-const SectionListWithEventThrottle = React.forwardRef(
-  // $FlowFixMe[incompatible-call]
-  (
-    props: React.ElementConfig<typeof SectionList>,
-    ref:
-      | ((null | SectionList<SectionBase<$FlowFixMe>>) => mixed)
-      | {
-          current: null | SectionList<SectionBase<$FlowFixMe>>,
-          ...
-        },
-  ) => <SectionList {...props} ref={ref} />,
-);
-
-export default (createAnimatedComponent(
-  SectionListWithEventThrottle,
-): AnimatedComponentType<
+export default (createAnimatedComponent(SectionList): AnimatedComponentType<
   React.ElementConfig<typeof SectionList>,
   React.ElementRef<typeof SectionList>,
 >);

package/Libraries/Animated/createAnimatedComponent.js

@@ -13,50 +13,55 @@ import useMergeRefs from '../Utilities/useMergeRefs';
 import useAnimatedProps from './useAnimatedProps';
 import * as React from 'react';
 
+// $FlowFixMe[deprecated-type]
+export type AnimatedProps<Props: {...}> = $ObjMap<
+  Props &
+    $ReadOnly<{
+      passthroughAnimatedPropExplicitValues?: React.ElementConfig<typeof View>,
+    }>,
+  () => any,
+>;
+
 export type AnimatedComponentType<
-  -Props: {+[string]: mixed, ...},
+  Props: {...},
   +Instance = mixed,
-> = React.AbstractComponent<
-  $ObjMap<
-    Props &
-      $ReadOnly<{
-        passthroughAnimatedPropExplicitValues?: React.ElementConfig<
-          typeof View,
-        >,
-      }>,
-    () => any,
-  >,
-  Instance,
->;
+> = React.AbstractComponent<AnimatedProps<Props>, Instance>;
 
 export default function createAnimatedComponent<TProps: {...}, TInstance>(
   Component: React.AbstractComponent<TProps, TInstance>,
 ): AnimatedComponentType<TProps, TInstance> {
-  return React.forwardRef((props, forwardedRef) => {
-    const [reducedProps, callbackRef] = useAnimatedProps<TProps, TInstance>(
-      // $FlowFixMe[incompatible-call]
-      props,
-    );
-    // $FlowFixMe[incompatible-call]
-    const ref = useMergeRefs<TInstance | null>(callbackRef, forwardedRef);
-
-    // Some components require explicit passthrough values for animation
-    // to work properly. For example, if an animated component is
-    // transformed and Pressable, onPress will not work after transform
-    // without these passthrough values.
-    // $FlowFixMe[prop-missing]
-    const {passthroughAnimatedPropExplicitValues, style} = reducedProps;
-    const {style: passthroughStyle, ...passthroughProps} =
-      passthroughAnimatedPropExplicitValues ?? {};
-    const mergedStyle = {...style, ...passthroughStyle};
-
-    return (
-      <Component
-        {...reducedProps}
-        {...passthroughProps}
-        style={mergedStyle}
-        ref={ref}
-      />
-    );
-  });
+  const AnimatedComponent = React.forwardRef<AnimatedProps<TProps>, TInstance>(
+    (props, forwardedRef) => {
+      const [reducedProps, callbackRef] = useAnimatedProps<TProps, TInstance>(
+        // $FlowFixMe[incompatible-call]
+        props,
+      );
+      const ref = useMergeRefs<TInstance>(callbackRef, forwardedRef);
+
+      // Some components require explicit passthrough values for animation
+      // to work properly. For example, if an animated component is
+      // transformed and Pressable, onPress will not work after transform
+      // without these passthrough values.
+      // $FlowFixMe[prop-missing]
+      const {passthroughAnimatedPropExplicitValues, style} = reducedProps;
+      const {style: passthroughStyle, ...passthroughProps} =
+        passthroughAnimatedPropExplicitValues ?? {};
+      const mergedStyle = {...style, ...passthroughStyle};
+
+      return (
+        <Component
+          {...reducedProps}
+          {...passthroughProps}
+          style={mergedStyle}
+          ref={ref}
+        />
+      );
+    },
+  );
+
+  AnimatedComponent.displayName = `Animated(${
+    Component.displayName || 'Anonymous'
+  })`;
+
+  return AnimatedComponent;
 }

package/Libraries/Animated/nodes/AnimatedStyle.js

@@ -12,7 +12,7 @@
 
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
 
-import ReactNativeFeatureFlags from '../../ReactNative/ReactNativeFeatureFlags';
+import * as ReactNativeFeatureFlags from '../../../src/private/featureflags/ReactNativeFeatureFlags';
 import flattenStyle from '../../StyleSheet/flattenStyle';
 import Platform from '../../Utilities/Platform';
 import NativeAnimatedHelper from '../NativeAnimatedHelper';

package/Libraries/Animated/shouldUseTurboAnimatedModule.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 

package/Libraries/Animated/useAnimatedProps.js

@@ -10,8 +10,8 @@
 
 'use strict';
 
+import * as ReactNativeFeatureFlags from '../../src/private/featureflags/ReactNativeFeatureFlags';
 import {isPublicInstance as isFabricPublicInstance} from '../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils';
-import ReactNativeFeatureFlags from '../ReactNative/ReactNativeFeatureFlags';
 import useRefEffect from '../Utilities/useRefEffect';
 import {AnimatedEvent} from './AnimatedEvent';
 import NativeAnimatedHelper from './NativeAnimatedHelper';
@@ -37,6 +37,7 @@ export default function useAnimatedProps<TProps: {...}, TInstance>(
 ): [ReducedProps<TProps>, CallbackRef<TInstance | null>] {
   const [, scheduleUpdate] = useReducer<number, void>(count => count + 1, 0);
   const onUpdateRef = useRef<?() => void>(null);
+  const timerRef = useRef<TimeoutID | null>(null);
 
   // TODO: Only invalidate `node` if animated props or `style` change. In the
   // previous implementation, we permitted `style` to override props with the
@@ -87,6 +88,25 @@ export default function useAnimatedProps<TProps: {...}, TInstance>(
           // $FlowIgnore[not-a-function] - Assume it's still a function.
           // $FlowFixMe[incompatible-use]
           instance.setNativeProps(node.__getAnimatedValue());
+          if (isFabricInstance(instance)) {
+            // Keeping state of Fiber tree and Shadow tree in sync.
+            //
+            // This is done by calling `scheduleUpdate` which will trigger a commit.
+            // However, React commit is not fast enough to drive animations.
+            // This is where setNativeProps comes in handy but the state between
+            // Fiber tree and Shadow tree needs to be kept in sync.
+            // The goal is to call `scheduleUpdate` as little as possible to maintain
+            // performance but frequently enough to keep state in sync.
+            // Debounce is set to 48ms, which is 3 * the duration of a frame.
+            // 3 frames was the highest value where flickering state was not observed.
+            if (timerRef.current != null) {
+              clearTimeout(timerRef.current);
+            }
+            timerRef.current = setTimeout(() => {
+              timerRef.current = null;
+              scheduleUpdate();
+            }, 48);
+          }
         }
       };
 

package/Libraries/AppState/NativeAppState.js

@@ -4,30 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 
-import type {TurboModule} from '../TurboModule/RCTExport';
-
-import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
-
-export type AppStateConstants = {|
-  initialAppState: string,
-|};
-
-export type AppState = {|app_state: string|};
-
-export interface Spec extends TurboModule {
-  +getConstants: () => AppStateConstants;
-  +getCurrentAppState: (
-    success: (appState: AppState) => void,
-    error: (error: Object) => void,
-  ) => void;
-
-  // Events
-  +addListener: (eventName: string) => void;
-  +removeListeners: (count: number) => void;
-}
-
-export default (TurboModuleRegistry.getEnforcing<Spec>('AppState'): Spec);
+export * from '../../src/private/specs/modules/NativeAppState';
+import NativeAppState from '../../src/private/specs/modules/NativeAppState';
+export default NativeAppState;

package/Libraries/BatchedBridge/NativeModules.js

@@ -177,7 +177,7 @@ function updateErrorWithErrorData(
 let NativeModules: {[moduleName: string]: $FlowFixMe, ...} = {};
 if (global.nativeModuleProxy) {
   NativeModules = global.nativeModuleProxy;
-} else if (!global.nativeExtensions) {
+} else {
   const bridgeConfig = global.__fbBatchedBridgeConfig;
   invariant(
     bridgeConfig,

package/Libraries/Blob/Blob.js

@@ -57,10 +57,7 @@ class Blob {
    * Currently we only support creating Blobs from other Blobs.
    * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob
    */
-  constructor(
-    parts: Array<$ArrayBufferView | ArrayBuffer | Blob | string> = [],
-    options?: BlobOptions,
-  ) {
+  constructor(parts: Array<Blob | string> = [], options?: BlobOptions) {
     const BlobManager = require('./BlobManager');
     this.data = BlobManager.createFromParts(parts, options).data;
   }

package/Libraries/Blob/BlobManager.js

@@ -11,7 +11,6 @@
 import type {BlobCollector, BlobData, BlobOptions} from './BlobTypes';
 
 import NativeBlobModule from './NativeBlobModule';
-import {fromByteArray} from 'base64-js';
 import invariant from 'invariant';
 
 const Blob = require('./Blob');
@@ -60,7 +59,7 @@ class BlobManager {
    * Create blob from existing array of blobs.
    */
   static createFromParts(
-    parts: Array<$ArrayBufferView | ArrayBuffer | Blob | string>,
+    parts: Array<Blob | string>,
     options?: BlobOptions,
   ): Blob {
     invariant(NativeBlobModule, 'NativeBlobModule is available.');
@@ -68,12 +67,11 @@ class BlobManager {
     const blobId = uuidv4();
     const items = parts.map(part => {
       if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
-        return {
-          // $FlowFixMe[incompatible-cast]
-          data: fromByteArray(new Uint8Array((part: ArrayBuffer))),
-          type: 'string',
-        };
-      } else if (part instanceof Blob) {
+        throw new Error(
+          "Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported",
+        );
+      }
+      if (part instanceof Blob) {
         return {
           data: part.data,
           type: 'blob',

package/Libraries/Blob/File.js

@@ -23,7 +23,7 @@ class File extends Blob {
    * Constructor for JS consumers.
    */
   constructor(
-    parts: Array<$ArrayBufferView | ArrayBuffer | Blob | string>,
+    parts: Array<Blob | string>,
     name: string,
     options?: BlobOptions,
   ) {

package/Libraries/Blob/NativeBlobModule.js

@@ -4,56 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 
-import type {TurboModule} from '../TurboModule/RCTExport';
-
-import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
-
-export interface Spec extends TurboModule {
-  +getConstants: () => {|BLOB_URI_SCHEME: ?string, BLOB_URI_HOST: ?string|};
-  +addNetworkingHandler: () => void;
-  +addWebSocketHandler: (id: number) => void;
-  +removeWebSocketHandler: (id: number) => void;
-  +sendOverSocket: (blob: Object, socketID: number) => void;
-  +createFromParts: (parts: Array<Object>, withId: string) => void;
-  +release: (blobId: string) => void;
-}
-
-const NativeModule = TurboModuleRegistry.get<Spec>('BlobModule');
-
-let constants = null;
-let NativeBlobModule = null;
-
-if (NativeModule != null) {
-  NativeBlobModule = {
-    getConstants(): {|BLOB_URI_SCHEME: ?string, BLOB_URI_HOST: ?string|} {
-      if (constants == null) {
-        constants = NativeModule.getConstants();
-      }
-      return constants;
-    },
-    addNetworkingHandler(): void {
-      NativeModule.addNetworkingHandler();
-    },
-    addWebSocketHandler(id: number): void {
-      NativeModule.addWebSocketHandler(id);
-    },
-    removeWebSocketHandler(id: number): void {
-      NativeModule.removeWebSocketHandler(id);
-    },
-    sendOverSocket(blob: Object, socketID: number): void {
-      NativeModule.sendOverSocket(blob, socketID);
-    },
-    createFromParts(parts: Array<Object>, withId: string): void {
-      NativeModule.createFromParts(parts, withId);
-    },
-    release(blobId: string): void {
-      NativeModule.release(blobId);
-    },
-  };
-}
-
-export default (NativeBlobModule: ?Spec);
+export * from '../../src/private/specs/modules/NativeBlobModule';
+import NativeBlobModule from '../../src/private/specs/modules/NativeBlobModule';
+export default NativeBlobModule;

package/Libraries/Blob/NativeFileReaderModule.js

@@ -4,19 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 
-import type {TurboModule} from '../TurboModule/RCTExport';
-
-import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
-
-export interface Spec extends TurboModule {
-  +readAsDataURL: (data: Object) => Promise<string>;
-  +readAsText: (data: Object, encoding: string) => Promise<string>;
-}
-
-export default (TurboModuleRegistry.getEnforcing<Spec>(
-  'FileReaderModule',
-): Spec);
+export * from '../../src/private/specs/modules/NativeFileReaderModule';
+import NativeFileReaderModule from '../../src/private/specs/modules/NativeFileReaderModule';
+export default NativeFileReaderModule;