react-native-tvos 0.85.3-0 → 0.86.0-0

package/Libraries/ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload.js

@@ -258,11 +258,11 @@ function diffProperties(
       if (!attributeConfigHasProcess) {
         // functions are converted to booleans as markers that the associated
         // events should be sent from native.
-        nextProp = (true: any);
+        nextProp = true as any;
         // If nextProp is not a function, then don't bother changing prevProp
         // since nextProp will win and go into the updatePayload regardless.
         if (typeof prevProp === 'function') {
-          prevProp = (true: any);
+          prevProp = true as any;
         }
       }
     }
@@ -270,9 +270,9 @@ function diffProperties(
     // An explicit value of undefined is treated as a null because it overrides
     // any other preceding value.
     if (typeof nextProp === 'undefined') {
-      nextProp = (null: any);
+      nextProp = null as any;
       if (typeof prevProp === 'undefined') {
-        prevProp = (null: any);
+        prevProp = null as any;
       }
     }
 
@@ -313,7 +313,7 @@ function diffProperties(
       // case: !Object is the default case
       if (defaultDiffer(prevProp, nextProp)) {
         // a normal leaf has changed
-        (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+        (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
           propKey
         ] = nextProp;
       }
@@ -333,7 +333,7 @@ function diffProperties(
             ? // $FlowFixMe[incompatible-use] found when upgrading Flow
               attributeConfig.process(nextProp)
             : nextProp;
-        (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+        (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
           propKey
         ] = nextValue;
       }
@@ -347,13 +347,13 @@ function diffProperties(
         updatePayload,
         prevProp,
         nextProp,
-        ((attributeConfig: any): AttributeConfiguration),
+        attributeConfig as any as AttributeConfiguration,
       );
       if (removedKeyCount > 0 && updatePayload) {
         restoreDeletedValuesInNestedArray(
           updatePayload,
           nextProp,
-          ((attributeConfig: any): AttributeConfiguration),
+          attributeConfig as any as AttributeConfiguration,
         );
         removedKeys = null;
       }
@@ -389,11 +389,11 @@ function diffProperties(
     ) {
       // case: CustomAttributeConfiguration | !Object
       // Flag the leaf property for removal by sending a sentinel.
-      (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+      (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
         propKey
       ] = null;
       if (!removedKeys) {
-        removedKeys = ({}: {[string]: boolean});
+        removedKeys = {} as {[string]: boolean};
       }
       if (!removedKeys[propKey]) {
         removedKeys[propKey] = true;
@@ -406,7 +406,7 @@ function diffProperties(
       updatePayload = clearNestedProperty(
         updatePayload,
         prevProp,
-        ((attributeConfig: any): AttributeConfiguration),
+        attributeConfig as any as AttributeConfiguration,
       );
     }
   }
@@ -429,9 +429,9 @@ function addNestedProperty(
   for (const propKey in props) {
     const prop = props[propKey];
 
-    const attributeConfig = ((validAttributes[
+    const attributeConfig = validAttributes[
       propKey
-    ]: any): AttributeConfiguration);
+    ] as any as AttributeConfiguration;
 
     if (attributeConfig == null) {
       continue;
@@ -466,7 +466,7 @@ function addNestedProperty(
 
     if (newValue !== undefined) {
       if (!payload) {
-        payload = ({}: {[string]: $FlowFixMe});
+        payload = {} as {[string]: $FlowFixMe};
       }
       payload[propKey] = newValue;
       continue;

package/Libraries/ReactNative/RendererImplementation.js

@@ -8,9 +8,6 @@
  * @format
  */
 
-import type {HostInstance} from '../../src/private/types/HostInstance';
-import typeof ReactFabricType from '../Renderer/shims/ReactFabric';
-import typeof ReactNativeType from '../Renderer/shims/ReactNative';
 import type {RootTag} from './RootTag';
 
 import {
@@ -18,159 +15,45 @@ import {
   onRecoverableError,
   onUncaughtError,
 } from '../../src/private/renderer/errorhandling/ErrorHandlers';
+import ReactFabric from '../Renderer/shims/ReactFabric';
 import * as React from 'react';
 
-let cachedFabricRenderer;
-let cachedPaperRenderer;
-
-function getFabricRenderer(): ReactFabricType {
-  if (cachedFabricRenderer == null) {
-    cachedFabricRenderer = require('../Renderer/shims/ReactFabric').default;
-  }
-  return cachedFabricRenderer;
-}
-
-function getPaperRenderer(): ReactNativeType {
-  if (cachedPaperRenderer == null) {
-    cachedPaperRenderer = require('../Renderer/shims/ReactNative').default;
-  }
-  return cachedPaperRenderer;
-}
-
-const getMethod: (<MethodName: keyof ReactFabricType>(
-  () => ReactFabricType,
-  MethodName,
-) => ReactFabricType[MethodName]) &
-  (<MethodName: keyof ReactNativeType>(
-    () => ReactNativeType,
-    MethodName,
-  ) => ReactNativeType[MethodName]) = (getRenderer, methodName) => {
-  let cachedImpl;
-
-  // $FlowExpectedError[incompatible-type]
-  return function (arg1, arg2, arg3, arg4, arg5, arg6) {
-    if (cachedImpl == null) {
-      // $FlowExpectedError[prop-missing]
-      cachedImpl = getRenderer()[methodName];
-    }
-
-    // $FlowExpectedError[extra-arg]
-    return cachedImpl(arg1, arg2, arg3, arg4, arg5);
-  };
-};
-
-function getFabricMethod<MethodName: keyof ReactFabricType>(
-  methodName: MethodName,
-): ReactFabricType[MethodName] {
-  return getMethod(getFabricRenderer, methodName);
-}
-
-function getPaperMethod<MethodName: keyof ReactNativeType>(
-  methodName: MethodName,
-): ReactNativeType[MethodName] {
-  return getMethod(getPaperRenderer, methodName);
-}
-
-let cachedFabricRender;
-let cachedPaperRender;
-
 export function renderElement({
   element,
   rootTag,
-  useFabric,
-  useConcurrentRoot,
 }: {
   element: React.MixedElement,
-  rootTag: number,
-  useFabric: boolean,
-  useConcurrentRoot: boolean,
+  rootTag: RootTag,
 }): void {
-  if (useFabric) {
-    if (cachedFabricRender == null) {
-      cachedFabricRender = getFabricRenderer().render;
-    }
-
-    cachedFabricRender(element, rootTag, null, useConcurrentRoot, {
+  ReactFabric.render(
+    element,
+    Number(rootTag),
+    /* callback */ null,
+    /* useConcurrentRoot */ true,
+    {
       onCaughtError,
       onUncaughtError,
       onRecoverableError,
-    });
-  } else {
-    if (cachedPaperRender == null) {
-      cachedPaperRender = getPaperRenderer().render;
-    }
-
-    cachedPaperRender(element, rootTag, undefined, {
-      onCaughtError,
-      onUncaughtError,
-      onRecoverableError,
-    });
-  }
+    },
+  );
 }
 
-let cachedFabricDispatchCommand;
-let cachedPaperDispatchCommand;
-
-export function dispatchCommand(
-  handle: HostInstance,
-  command: string,
-  args: Array<unknown>,
-): void {
-  if (global.RN$Bridgeless === true) {
-    // Note: this function has the same implementation in the legacy and new renderer.
-    // However, evaluating the old renderer comes with some side effects.
-    if (cachedFabricDispatchCommand == null) {
-      cachedFabricDispatchCommand = getFabricRenderer().dispatchCommand;
-    }
-
-    return cachedFabricDispatchCommand(handle, command, args);
-  } else {
-    if (cachedPaperDispatchCommand == null) {
-      cachedPaperDispatchCommand = getPaperRenderer().dispatchCommand;
-    }
-
-    return cachedPaperDispatchCommand(handle, command, args);
-  }
-}
-
-export const findHostInstance_DEPRECATED: <TElementType: React.ElementType>(
-  // $FlowExpectedError[incompatible-type]
-  componentOrHandle: ?(React.ElementRef<TElementType> | number),
-) => ?HostInstance = getPaperMethod('findHostInstance_DEPRECATED');
-
-export const findNodeHandle: <TElementType: React.ElementType>(
-  // $FlowExpectedError[incompatible-type]
-  componentOrHandle: ?(React.ElementRef<TElementType> | number),
-  suppressWarning: ?boolean,
-) => ?number = getPaperMethod('findNodeHandle');
-
-export const sendAccessibilityEvent: ReactNativeType['sendAccessibilityEvent'] =
-  getPaperMethod('sendAccessibilityEvent');
-
-/**
- * This method is used by AppRegistry to unmount a root when using the old
- * React Native renderer (Paper).
- */
-export const unmountComponentAtNodeAndRemoveContainer: (
-  rootTag: RootTag,
-) => void =
-  // $FlowExpectedError[incompatible-type]
-  getPaperMethod('unmountComponentAtNodeAndRemoveContainer');
-
-export const unstable_batchedUpdates: ReactNativeType['unstable_batchedUpdates'] =
-  getPaperMethod('unstable_batchedUpdates');
-
-export const isChildPublicInstance: ReactNativeType['isChildPublicInstance'] =
-  getPaperMethod('isChildPublicInstance');
-
-export const getNodeFromInternalInstanceHandle: ReactFabricType['getNodeFromInternalInstanceHandle'] =
-  getFabricMethod('getNodeFromInternalInstanceHandle');
-
-export const getPublicInstanceFromInternalInstanceHandle: ReactFabricType['getPublicInstanceFromInternalInstanceHandle'] =
-  getFabricMethod('getPublicInstanceFromInternalInstanceHandle');
-
-export const getPublicInstanceFromRootTag: ReactFabricType['getPublicInstanceFromRootTag'] =
-  getFabricMethod('getPublicInstanceFromRootTag');
+// NOTE: these cannot be combined into a single destructuring statement because
+// `flow-api-translator` (used by `yarn build-types` to generate the
+// open-source type definitions) does not support destructuring in variable
+// declarations.
+export const dispatchCommand = ReactFabric.dispatchCommand;
+export const findHostInstance_DEPRECATED =
+  ReactFabric.findHostInstance_DEPRECATED;
+export const findNodeHandle = ReactFabric.findNodeHandle;
+export const sendAccessibilityEvent = ReactFabric.sendAccessibilityEvent;
+export const isChildPublicInstance = ReactFabric.isChildPublicInstance;
+export const getNodeFromInternalInstanceHandle =
+  ReactFabric.getNodeFromInternalInstanceHandle;
+export const getPublicInstanceFromInternalInstanceHandle =
+  ReactFabric.getPublicInstanceFromInternalInstanceHandle;
+export const getPublicInstanceFromRootTag =
+  ReactFabric.getPublicInstanceFromRootTag;
 
 export function isProfilingRenderer(): boolean {
   return Boolean(__DEV__);

package/Libraries/ReactNative/RendererProxy.js

@@ -8,19 +8,8 @@
  * @format
  */
 
-/**
- * This module exists to allow apps to select their renderer implementation
- * (e.g.: Fabric-only, Paper-only) without having to pull all the renderer
- * implementations into their app bundle, which affects app size.
- *
- * By default, the setup will be:
- *   -> RendererProxy
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *
- * But this will allow a setup like this without duplicating logic:
- *   -> RendererProxy (fork)
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *     or -> OtherImplementation (which uses Fabric only)
- */
-
+// This module allows app bundles to set up the appropriate Fabric renderer
+// variant (e.g., profiling vs production) before React Native is initialized.
+// The internal implementation (RendererProxy.fb.js) provides the indirection
+// needed to swap the renderer implementation at runtime.
 export * from './RendererImplementation';

package/Libraries/ReactNative/renderApplication.js

@@ -4,65 +4,63 @@
  * 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 {ViewStyleProp} from '../StyleSheet/StyleSheet';
-import type {IPerformanceLogger} from '../Utilities/createPerformanceLogger';
+import type {RootTag} from './RootTag';
 
-import GlobalPerformanceLogger from '../Utilities/GlobalPerformanceLogger';
-import PerformanceLoggerContext from '../Utilities/PerformanceLoggerContext';
-import warnOnce from '../Utilities/warnOnce';
 import AppContainer from './AppContainer';
 import DisplayMode, {type DisplayModeType} from './DisplayMode';
 import getCachedComponentWithDebugName from './getCachedComponentWithDebugName';
 import * as Renderer from './RendererProxy';
+import {createRootTag} from './RootTag';
 import invariant from 'invariant';
 import * as React from 'react';
 
 // require BackHandler so it sets the default handler that exits the app if no listeners respond
 import '../Utilities/BackHandler';
 
-type ActivityType = component(
-  ...{
-    mode: 'visible' | 'hidden',
-    children: React.Node,
-  }
-);
+type ActivityType = component(mode: 'visible' | 'hidden', children: React.Node);
 
-export default function renderApplication<Props: Object>(
-  RootComponent: React.ComponentType<Props>,
+export type RenderApplicationOptions<Props extends {...}> = {
+  RootComponent: component(...Props),
   initialProps: Props,
-  rootTag: any,
-  WrapperComponent?: ?React.ComponentType<any>,
+  rootTag: number | RootTag,
+  WrapperComponent?: ?component(initialProps: Props, children: React.Node),
   rootViewStyle?: ?ViewStyleProp,
-  fabric?: boolean,
-  scopedPerformanceLogger?: IPerformanceLogger,
   isLogBox?: boolean,
   debugName?: string,
   displayMode?: ?DisplayModeType,
   useOffscreen?: boolean,
-) {
-  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+};
 
-  const performanceLogger = scopedPerformanceLogger ?? GlobalPerformanceLogger;
+export default function renderApplication<Props extends {...}>({
+  RootComponent,
+  initialProps,
+  rootTag,
+  WrapperComponent,
+  rootViewStyle,
+  isLogBox,
+  debugName,
+  displayMode,
+  useOffscreen,
+}: RenderApplicationOptions<Props>) {
+  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
 
   let renderable: React.MixedElement = (
-    <PerformanceLoggerContext.Provider value={performanceLogger}>
-      <AppContainer
-        rootTag={rootTag}
-        fabric={fabric}
-        WrapperComponent={WrapperComponent}
-        rootViewStyle={rootViewStyle}
-        initialProps={initialProps ?? Object.freeze({})}
-        internal_excludeLogBox={isLogBox}>
-        <RootComponent {...initialProps} rootTag={rootTag} />
-      </AppContainer>
-    </PerformanceLoggerContext.Provider>
+    <AppContainer
+      rootTag={rootTag}
+      WrapperComponent={WrapperComponent}
+      rootViewStyle={rootViewStyle}
+      initialProps={initialProps ?? Object.freeze({})}
+      internal_excludeLogBox={isLogBox}>
+      <RootComponent {...initialProps} rootTag={rootTag} />
+    </AppContainer>
   );
 
-  if (__DEV__ && debugName) {
+  if (__DEV__ && debugName != null) {
     const RootComponentWithMeaningfulName = getCachedComponentWithDebugName(
       `${debugName}(RootComponent)`,
     );
@@ -73,10 +71,10 @@ export default function renderApplication<Props: Object>(
     );
   }
 
-  if (useOffscreen && displayMode != null) {
+  if (useOffscreen === true && displayMode != null) {
     // $FlowFixMe[incompatible-type]
-    // $FlowFixMe[prop-missing]
     // $FlowFixMe[missing-export]
+    // $FlowFixMe[prop-missing] `unstable_Activity` is not yet in the React types.
     const Activity: ActivityType = React.unstable_Activity;
 
     renderable = (
@@ -87,32 +85,8 @@ export default function renderApplication<Props: Object>(
     );
   }
 
-  // We want to have concurrentRoot always enabled when you're on Fabric.
-  const useConcurrentRoot = Boolean(fabric);
-
-  performanceLogger.startTimespan('renderApplication_React_render');
-  performanceLogger.setExtra(
-    'usedReactConcurrentRoot',
-    useConcurrentRoot ? '1' : '0',
-  );
-  performanceLogger.setExtra('usedReactFabric', fabric ? '1' : '0');
-  performanceLogger.setExtra(
-    'usedReactProfiler',
-    Renderer.isProfilingRenderer(),
-  );
   Renderer.renderElement({
     element: renderable,
-    rootTag,
-    useFabric: Boolean(fabric),
-    useConcurrentRoot,
+    rootTag: createRootTag(rootTag),
   });
-
-  const newArchitecture = !!fabric;
-  if (!newArchitecture) {
-    warnOnce(
-      '[OSS][OldArchDeprecatedWarning]',
-      'The app is running using the Legacy Architecture. The Legacy Architecture is deprecated and will be removed in a future version of React Native. Please consider migrating to the New Architecture. For more information, please see https://reactnative.dev/blog/2024/10/23/the-new-architecture-is-here',
-    );
-  }
-  performanceLogger.stopTimespan('renderApplication_React_render');
 }

package/Libraries/ReactNative/requireNativeComponent.js

@@ -26,11 +26,11 @@ const getNativeComponentAttributes =
  *
  */
 
-const requireNativeComponent = <T: {...}>(
+const requireNativeComponent = <T extends {...}>(
   uiViewClassName: string,
 ): HostComponent<T> =>
-  ((createReactNativeComponentClass(uiViewClassName, () =>
+  createReactNativeComponentClass(uiViewClassName, () =>
     getNativeComponentAttributes(uiViewClassName),
-  ): any): HostComponent<T>);
+  ) as any as HostComponent<T>;
 
 export default requireNativeComponent;

package/Libraries/ReactPrivate/ReactNativePrivateInterface.js

@@ -8,6 +8,7 @@
  * @format
  */
 
+import typeof dispatchNativeEvent from '../../src/private/renderer/events/dispatchNativeEvent';
 import typeof CustomEvent from '../../src/private/webapis/dom/events/CustomEvent';
 import typeof BatchedBridge from '../BatchedBridge/BatchedBridge';
 import typeof legacySendAccessibilityEvent from '../Components/AccessibilityInfo/legacySendAccessibilityEvent';
@@ -133,4 +134,8 @@ module.exports = {
     return require('../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance')
       .getInternalInstanceHandleFromPublicInstance;
   },
+  get dispatchNativeEvent(): dispatchNativeEvent {
+    return require('../../src/private/renderer/events/dispatchNativeEvent')
+      .default;
+  },
 };

package/Libraries/Renderer/shims/ReactNativeTypes.js

@@ -7,7 +7,7 @@
  * @noformat
  * @nolint
  * @flow strict
- * @generated SignedSource<<c0e57723772ea5f1aa8c3c897ac3c216>>
+ * @generated SignedSource<<4ab83fd2606d6a4d374ef914f231d9c1>>
  */
 
 import type {
@@ -138,37 +138,6 @@ export type RenderRootOptions = {
   onDefaultTransitionIndicator?: () => void | (() => void),
 };
 
-/**
- * Flat ReactNative renderer bundles are too big for Flow to parse efficiently.
- * Provide minimal Flow typing for the high-level RN API and call it a day.
- */
-export type ReactNativeType = {
-  findHostInstance_DEPRECATED<TElementType: React.ElementType>(
-    componentOrHandle: ?(React.ElementRef<TElementType> | number),
-  ): ?PublicInstance,
-  findNodeHandle<TElementType: React.ElementType>(
-    componentOrHandle: ?(React.ElementRef<TElementType> | number),
-    suppressWarning?: boolean,
-  ): ?number,
-  isChildPublicInstance(parent: PublicInstance, child: PublicInstance): boolean,
-  dispatchCommand(
-    handle: PublicInstance,
-    command: string,
-    args: Array<mixed>,
-  ): void,
-  sendAccessibilityEvent(handle: PublicInstance, eventType: string): void,
-  render(
-    element: React.MixedElement,
-    containerTag: number,
-    callback: ?() => void,
-    options: ?RenderRootOptions,
-  ): ?React.ElementRef<React.ElementType>,
-  unmountComponentAtNode(containerTag: number): void,
-  unmountComponentAtNodeAndRemoveContainer(containerTag: number): void,
-  +unstable_batchedUpdates: <T>(fn: (T) => void, bookkeeping: T) => void,
-  ...
-};
-
 export opaque type Node = mixed;
 export opaque type InternalInstanceHandle = mixed;
 
@@ -178,6 +147,7 @@ export type ReactFabricType = {
   ): ?PublicInstance,
   findNodeHandle<TElementType: React.ElementType>(
     componentOrHandle: ?(React.ElementRef<TElementType> | number),
+    suppressWarning?: boolean,
   ): ?number,
   dispatchCommand(
     handle: PublicInstance,

package/Libraries/Settings/Settings.ios.js

@@ -20,7 +20,7 @@ const subscriptions: Array<{
 
 const Settings = {
   _settings: (NativeSettingsManager &&
-    NativeSettingsManager.getConstants().settings: any),
+    NativeSettingsManager.getConstants().settings) as any,
 
   get(key: string): unknown {
     // $FlowFixMe[object-this-reference]

package/Libraries/StyleSheet/PlatformColorValueTypes.android.js

@@ -19,7 +19,7 @@ type LocalNativeColorValue = {
 export const PlatformColor = (...names: Array<string>): NativeColorValue => {
   /* $FlowExpectedError[incompatible-type]
    * LocalNativeColorValue is the actual type of the opaque NativeColorValue on Android platform */
-  return ({resource_paths: names}: LocalNativeColorValue);
+  return {resource_paths: names} as LocalNativeColorValue;
 };
 
 export const normalizeColorObject = (
@@ -27,7 +27,7 @@ export const normalizeColorObject = (
 ): ?ProcessedColorValue => {
   /* $FlowExpectedError[incompatible-type]
    * LocalNativeColorValue is the actual type of the opaque NativeColorValue on Android platform */
-  if ('resource_paths' in (color: LocalNativeColorValue)) {
+  if ('resource_paths' in (color as LocalNativeColorValue)) {
     return color;
   }
   return null;

package/Libraries/StyleSheet/PlatformColorValueTypes.ios.js

@@ -24,7 +24,7 @@ type LocalNativeColorValue = {
 
 export const PlatformColor = (...names: Array<string>): NativeColorValue => {
   // $FlowExpectedError[incompatible-type] LocalNativeColorValue is the iOS LocalNativeColorValue type
-  return ({semantic: names}: LocalNativeColorValue);
+  return {semantic: names} as LocalNativeColorValue;
 };
 
 export type DynamicColorIOSTuplePrivate = {
@@ -37,7 +37,7 @@ export type DynamicColorIOSTuplePrivate = {
 export const DynamicColorIOSPrivate = (
   tuple: DynamicColorIOSTuplePrivate,
 ): ColorValue => {
-  return ({
+  return {
     dynamic: {
       light: tuple.light,
       dark: tuple.dark,
@@ -46,7 +46,7 @@ export const DynamicColorIOSPrivate = (
     },
     /* $FlowExpectedError[incompatible-type]
      * LocalNativeColorValue is the actual type of the opaque NativeColorValue on iOS platform */
-  }: LocalNativeColorValue);
+  } as LocalNativeColorValue;
 };
 
 const _normalizeColorObject = (

package/Libraries/StyleSheet/StyleSheet.js

@@ -118,7 +118,7 @@ export type DangerouslyImpreciseStyleProp =
  * This will correctly give you the type 'absolute' | 'relative'
  */
 export type TypeForStyleKey<
-  +key: keyof ____DangerouslyImpreciseStyle_Internal,
+  +key extends keyof ____DangerouslyImpreciseStyle_Internal,
 > = ____DangerouslyImpreciseStyle_Internal[key];
 
 /**

package/Libraries/StyleSheet/StyleSheet.js.flow

@@ -34,7 +34,7 @@ export type {
 
 export type StyleSheetProperties = {
   hairlineWidth: number,
-  flatten<T: string>(style: T): T,
+  flatten<T extends string>(style: T): T,
 };
 
 /**
@@ -119,7 +119,7 @@ export type DangerouslyImpreciseStyleProp =
  * This will correctly give you the type 'absolute' | 'relative'
  */
 export type TypeForStyleKey<
-  +key: keyof ____DangerouslyImpreciseStyle_Internal,
+  +key extends keyof ____DangerouslyImpreciseStyle_Internal,
 > = ____DangerouslyImpreciseStyle_Internal[key];
 
 /**

package/Libraries/StyleSheet/StyleSheetExports.js

@@ -179,7 +179,7 @@ export default {
    * An identity function for creating style sheets.
    */
   // $FlowFixMe[unsupported-variance-annotation]
-  create<+S: ____Styles_Internal>(obj: S): Readonly<S> {
+  create<+S extends ____Styles_Internal>(obj: S): Readonly<S> {
     // TODO: This should return S as the return type. But first,
     // we need to codemod all the callsites that are typing this
     // return value as a number (even though it was opaque).

package/Libraries/StyleSheet/StyleSheetExports.js.flow

@@ -95,6 +95,6 @@ declare export const setStyleAttributePreprocessor: (
  * An identity function for creating style sheets.
  */
 // $FlowFixMe[unsupported-variance-annotation]
-declare export const create: <+S: ____Styles_Internal>(
+declare export const create: <+S extends ____Styles_Internal>(
   obj: S & ____Styles_Internal,
 ) => Readonly<S>;