@office-iss/react-native-win32 0.71.0 → 0.71.2

package/Libraries/Components/View/ViewPropTypes.win32.d.ts

@@ -0,0 +1,372 @@
+/**
+ * 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 * as React from 'react';
+import {Insets} from 'react-native/types/public/Insets';
+import {GestureResponderHandlers} from 'react-native/types/public/ReactNativeRenderer';
+import {StyleProp} from 'react-native/Libraries/StyleSheet/StyleSheet';
+import {ViewStyle} from 'react-native/Libraries/StyleSheet/StyleSheetTypes';
+import {
+  LayoutChangeEvent,
+  MouseEvent, // Win32
+  NativeSyntheticEvent, // Win32
+  PointerEvents,
+} from 'react-native/Libraries/Types/CoreEventTypes';
+import {Touchable} from 'react-native/Libraries/Components/Touchable/Touchable';
+import {AccessibilityProps} from './ViewAccessibility';
+
+export type TVParallaxProperties = {
+  /**
+   * If true, parallax effects are enabled.  Defaults to true.
+   */
+  enabled?: boolean | undefined;
+
+  /**
+   * Defaults to 2.0.
+   */
+  shiftDistanceX?: number | undefined;
+
+  /**
+   * Defaults to 2.0.
+   */
+  shiftDistanceY?: number | undefined;
+
+  /**
+   * Defaults to 0.05.
+   */
+  tiltAngle?: number | undefined;
+
+  /**
+   * Defaults to 1.0
+   */
+  magnification?: number | undefined;
+
+  /**
+   * Defaults to 1.0
+   */
+  pressMagnification?: number | undefined;
+
+  /**
+   * Defaults to 0.3
+   */
+  pressDuration?: number | undefined;
+
+  /**
+   * Defaults to 0.3
+   */
+  pressDelay?: number | undefined;
+};
+
+export interface TVViewPropsIOS {
+  /**
+   * *(Apple TV only)* When set to true, this view will be focusable
+   * and navigable using the Apple TV remote.
+   *
+   * @platform ios
+   */
+  isTVSelectable?: boolean | undefined;
+
+  /**
+   * *(Apple TV only)* May be set to true to force the Apple TV focus engine to move focus to this view.
+   *
+   * @platform ios
+   */
+  hasTVPreferredFocus?: boolean | undefined;
+
+  /**
+   * *(Apple TV only)* Object with properties to control Apple TV parallax effects.
+   *
+   * @platform ios
+   */
+  tvParallaxProperties?: TVParallaxProperties | undefined;
+
+  /**
+   * *(Apple TV only)* May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus.  Defaults to 2.0.
+   *
+   * @platform ios
+   */
+  tvParallaxShiftDistanceX?: number | undefined;
+
+  /**
+   * *(Apple TV only)* May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus.  Defaults to 2.0.
+   *
+   * @platform ios
+   */
+  tvParallaxShiftDistanceY?: number | undefined;
+
+  /**
+   * *(Apple TV only)* May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus.  Defaults to 0.05.
+   *
+   * @platform ios
+   */
+  tvParallaxTiltAngle?: number | undefined;
+
+  /**
+   * *(Apple TV only)* May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus.  Defaults to 1.0.
+   *
+   * @platform ios
+   */
+  tvParallaxMagnification?: number | undefined;
+}
+
+export interface ViewPropsIOS extends TVViewPropsIOS {
+  /**
+   * Whether this view should be rendered as a bitmap before compositing.
+   *
+   * On iOS, this is useful for animations and interactions that do not modify this component's dimensions nor its children;
+   * for example, when translating the position of a static view, rasterization allows the renderer to reuse a cached bitmap of a static view
+   * and quickly composite it during each frame.
+   *
+   * Rasterization incurs an off-screen drawing pass and the bitmap consumes memory.
+   * Test and measure when using this property.
+   */
+  shouldRasterizeIOS?: boolean | undefined;
+}
+
+export interface ViewPropsAndroid {
+  /**
+   * Views that are only used to layout their children or otherwise don't draw anything
+   * may be automatically removed from the native hierarchy as an optimization.
+   * Set this property to false to disable this optimization and ensure that this View exists in the native view hierarchy.
+   */
+  collapsable?: boolean | undefined;
+
+  /**
+   * Whether this view needs to rendered offscreen and composited with an alpha in order to preserve 100% correct colors and blending behavior.
+   * The default (false) falls back to drawing the component and its children
+   * with an alpha applied to the paint used to draw each element instead of rendering the full component offscreen and compositing it back with an alpha value.
+   * This default may be noticeable and undesired in the case where the View you are setting an opacity on
+   * has multiple overlapping elements (e.g. multiple overlapping Views, or text and a background).
+   *
+   * Rendering offscreen to preserve correct alpha behavior is extremely expensive
+   * and hard to debug for non-native developers, which is why it is not turned on by default.
+   * If you do need to enable this property for an animation,
+   * consider combining it with renderToHardwareTextureAndroid if the view contents are static (i.e. it doesn't need to be redrawn each frame).
+   * If that property is enabled, this View will be rendered off-screen once,
+   * saved in a hardware texture, and then composited onto the screen with an alpha each frame without having to switch rendering targets on the GPU.
+   */
+  needsOffscreenAlphaCompositing?: boolean | undefined;
+
+  /**
+   * Whether this view should render itself (and all of its children) into a single hardware texture on the GPU.
+   *
+   * On Android, this is useful for animations and interactions that only modify opacity, rotation, translation, and/or scale:
+   * in those cases, the view doesn't have to be redrawn and display lists don't need to be re-executed. The texture can just be
+   * re-used and re-composited with different parameters. The downside is that this can use up limited video memory, so this prop should be set back to false at the end of the interaction/animation.
+   */
+  renderToHardwareTextureAndroid?: boolean | undefined;
+
+  /**
+   * Whether this `View` should be focusable with a non-touch input device, eg. receive focus with a hardware keyboard.
+   */
+  focusable?: boolean | undefined;
+}
+
+// [Win32
+
+export type Cursor =
+  | 'auto'
+  | 'default'
+  | 'pointer'
+  | 'help'
+  | 'not-allowed'
+  | 'wait'
+  | 'move'
+  | 'nesw-resize'
+  | 'ns-resize'
+  | 'nwse-resize'
+  | 'we-resize'
+  | 'text';
+
+export interface INativeKeyboardEvent {
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+  key: string;
+}
+export type IKeyboardEvent = NativeSyntheticEvent<INativeKeyboardEvent>;
+
+// All of T becomes optional except for Keys
+type PartiallyRequired<T, Keys extends keyof T = keyof T> = Pick<
+  Partial<T>,
+  Exclude<keyof T, Keys>
+> &
+  Pick<T, Keys>;
+
+export type IHandledKeyboardEvent = PartiallyRequired<
+  INativeKeyboardEvent,
+  'key'
+>;
+// Win32]
+
+export interface ViewPropsWin32 {
+  onKeyDown?: (args: IKeyboardEvent) => void;
+  onKeyDownCapture?: (args: IKeyboardEvent) => void;
+  onKeyUp?: (args: IKeyboardEvent) => void;
+  onKeyUpCapture?: (args: IKeyboardEvent) => void;
+
+  keyDownEvents?: IHandledKeyboardEvent[];
+  keyUpEvents?: IHandledKeyboardEvent[];
+
+  onMouseLeave?: ?((event: MouseEvent) => void);
+  onMouseEnter?: ?((event: MouseEvent) => void);
+
+  /**
+   * Specifies the Tooltip for the view
+   * @platform windows
+   */
+  tooltip?: ?string;
+
+  /**
+   * Tab Index
+   * @platform windows
+   */
+  tabIndex?: ?number;
+
+  /**
+   * Specifies if the control should show System focus visuals
+   */
+  enableFocusRing?: ?boolean;
+
+  /**
+   * The onBlur event occurs when an element loses focus.  The opposite of onBlur is onFocus.  Note that in React
+   * Native, unlike in the web, the onBlur event bubbles (similar to onFocusOut in the web).
+   *
+   * `ev.target === ev.currentTarget` when the focus is being lost from this component.
+   * `ev.target !== ev.currentTarget` when the focus is being lost from a descendant.
+   */
+  onBlur?: (ev: NativeSyntheticEvent<{}>) => void;
+  /**
+   * The onBlur event occurs when an element loses focus.  The opposite of onBlur is onFocus.  Note that in React
+   * Native, unlike in the web, the onBlur event bubbles (similar to onFocusOut in the web).
+   *
+   * `ev.target === ev.currentTarget` when the focus is being lost from this component.
+   * `ev.target !== ev.currentTarget` when the focus is being lost from a descendant.
+   */
+  onBlurCapture?: (ev: NativeSyntheticEvent<{}>) => void;
+  /**
+   * The onFocus event occurs when an element gets focus. The opposite of onFocus is onBlur.  Note that in React
+   * Native, unlike in the web, the onFocus event bubbles (similar to onFocusIn in the web).
+   *
+   * `ev.target === ev.currentTarget` when the focus is being lost from this component.
+   * `ev.target !== ev.currentTarget` when the focus is being lost from a descendant.
+   */
+  onFocus?: (ev: NativeSyntheticEvent<{}>) => void;
+  /**
+   * The onFocus event occurs when an element gets focus. The opposite of onFocus is onBlur.  Note that in React
+   * Native, unlike in the web, the onFocus event bubbles (similar to onFocusIn in the web).
+   *
+   * `ev.target === ev.currentTarget` when the focus is being lost from this component.
+   * `ev.target !== ev.currentTarget` when the focus is being lost from a descendant.
+   */
+  onFocusCapture?: (ev: NativeSyntheticEvent<{}>) => void;
+
+  cursor?: Cursor;
+
+  /**
+   * Whether this `View` should be focusable with a non-touch input device, eg. receive focus with a hardware keyboard.
+   */
+  focusable?: boolean | undefined;
+
+  /**
+   * Specified an AirSpace animation class to apply to this view
+   */
+  animationClass?: string;
+}
+
+/**
+ * @see https://reactnative.dev/docs/view#props
+ */
+export interface ViewProps
+  extends ViewPropsAndroid,
+    ViewPropsIOS,
+    ViewPropsWin32,
+    GestureResponderHandlers,
+    Touchable,
+    PointerEvents,
+    AccessibilityProps {
+  children?: React.ReactNode;
+  /**
+   * This defines how far a touch event can start away from the view.
+   * Typical interface guidelines recommend touch targets that are at least
+   * 30 - 40 points/density-independent pixels. If a Touchable view has
+   * a height of 20 the touchable height can be extended to 40 with
+   * hitSlop={{top: 10, bottom: 10, left: 0, right: 0}}
+   * NOTE The touch area never extends past the parent view bounds and
+   * the Z-index of sibling views always takes precedence if a touch
+   * hits two overlapping views.
+   */
+  hitSlop?: Insets | undefined;
+
+  /**
+   * Used to reference react managed views from native code.
+   */
+  id?: string | undefined;
+
+  /**
+   * Invoked on mount and layout changes with
+   *
+   * {nativeEvent: { layout: {x, y, width, height}}}.
+   */
+  onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
+
+  /**
+   *
+   * In the absence of auto property, none is much like CSS's none value. box-none is as if you had applied the CSS class:
+   *
+   * .box-none {
+   *   pointer-events: none;
+   * }
+   * .box-none * {
+   *   pointer-events: all;
+   * }
+   *
+   * box-only is the equivalent of
+   *
+   * .box-only {
+   *   pointer-events: all;
+   * }
+   * .box-only * {
+   *   pointer-events: none;
+   * }
+   *
+   * But since pointerEvents does not affect layout/appearance, and we are already deviating from the spec by adding additional modes,
+   * we opt to not include pointerEvents on style. On some platforms, we would need to implement it as a className anyways. Using style or not is an implementation detail of the platform.
+   */
+  pointerEvents?: 'box-none' | 'none' | 'box-only' | 'auto' | undefined;
+
+  /**
+   *
+   * This is a special performance property exposed by RCTView and is useful for scrolling content when there are many subviews,
+   * most of which are offscreen. For this property to be effective, it must be applied to a view that contains many subviews that extend outside its bound.
+   * The subviews must also have overflow: hidden, as should the containing view (or one of its superviews).
+   */
+  removeClippedSubviews?: boolean | undefined;
+
+  style?: StyleProp<ViewStyle> | undefined;
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: string | undefined;
+
+  /**
+   * Used to reference react managed views from native code.
+   */
+  nativeID?: string | undefined;
+}
+
+// For backwards compat.... // Win32
+export interface IViewWin32 {
+  focus: () => void;
+}
+
+// For backwards compat.... // Win32
+export type IViewWin32Props = ViewProps;

package/Libraries/Components/View/ViewPropTypes.win32.js

@@ -669,4 +669,27 @@ export type ViewProps = $ReadOnly<{|
    * See https://reactnative.dev/docs/view#removeclippedsubviews
    */
   removeClippedSubviews?: ?boolean,
+
+  /**
+   * Specifies the nativeID of the associated label text. When the assistive technology focuses on the component with this props, the text is read aloud.
+   *
+   * @platform win32
+   */
+  accessibilityDescribedBy?: ?string,
+
+  /**
+   * Legacy property replaced by accessibilityLabelledBy - here for backwards compat
+   *
+   * @platform win32
+   * @deprecated
+   */
+  // $FlowFixMe[unclear-type]
+  accessibilityLabeledBy?: any,
+
+  /**
+   * Specifies the nativeID of the control that controls this one.
+   *
+   * @platform win32
+   */
+  accessibilityControls?: ?string,
 |}>;

package/Libraries/Components/View/ViewWin32.d.ts

@@ -1,12 +1,30 @@
-/**
- * Copyright: Microsoft 2015
- *
- * RN-specific implementation of the cross-platform View abstraction.
- */
-import React from 'react';
-import { View } from 'react-native';
-import { IViewWin32Props } from './ViewWin32.Props';
-declare type ViewWin32Type = React.ForwardRefExoticComponent<IViewWin32Props & React.RefAttributes<View>> & View;
-export declare const ViewWin32: React.ForwardRefExoticComponent<IViewWin32Props & React.RefAttributes<any>>;
-export declare type ViewWin32 = ViewWin32Type;
-export {};
+/**
+ * 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 * as React from 'react';
+import {Constructor} from 'react-native/types/private/Utilities';
+import {ViewProps} from './ViewPropTypes';
+import {NativeMethods} from 'react-native/types/public/ReactNativeTypes';
+
+/**
+ * The most fundamental component for building UI, View is a container that supports layout with flexbox, style, some touch handling,
+ * and accessibility controls, and is designed to be nested inside other views and to have 0 to many children of any type.
+ * View maps directly to the native view equivalent on whatever platform React is running on,
+ * whether that is a UIView, <div>, android.view, etc.
+ */
+declare class ViewWin32Component extends React.Component<ViewProps> {}
+declare const ViewWin32Base: Constructor<NativeMethods> &
+  typeof ViewWin32Component;
+export class ViewWin32 extends ViewWin32Base {
+  /**
+   * Is 3D Touch / Force Touch available (i.e. will touch events include `force`)
+   * @platform ios
+   */
+  static forceTouchAvailable: boolean;
+}

package/Libraries/Components/View/ViewWin32.js

@@ -1,71 +1,161 @@
-"use strict";
-/**
- * Copyright: Microsoft 2015
- *
- * RN-specific implementation of the cross-platform View abstraction.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewWin32 = void 0;
-const react_1 = __importDefault(require("react"));
-const react_native_1 = require("react-native");
-const setAndForwardRef = require('../../Utilities/setAndForwardRef');
-exports.ViewWin32 = react_1.default.forwardRef((props, ref) => {
-    /**
-     * Check for raw text in the DOM.
-     */
-    if (__DEV__) {
-        if (props) {
-            react_1.default.Children.toArray(props.children).forEach(item => {
-                if (typeof item === 'string') {
-                    console.error(`Unexpected text node: ${item}. A text node cannot be a child of a <View>.`);
-                }
-            });
-        }
-    }
-    /**
-     * Process accessibility refs into node handles after initial DOM render, before sent across the bridge.
-     * useLayoutEffect will invalidate the render to assess the ref-based accessibility properties.
-     */
-    const [labeledByTarget, setLabeledByTarget] = react_1.default.useState(null);
-    const [describedByTarget, setDescribedByTarget] = react_1.default.useState(null);
-    const [controlsTarget, setControlsTarget] = react_1.default.useState(null);
-    const { accessibilityLabeledBy, accessibilityDescribedBy, accessibilityControls, ...rest } = props;
-    react_1.default.useLayoutEffect(() => {
-        if (accessibilityLabeledBy !== undefined && accessibilityLabeledBy.current !== null) {
-            setLabeledByTarget((0, react_native_1.findNodeHandle)(accessibilityLabeledBy.current));
-        }
-    }, [accessibilityLabeledBy]);
-    react_1.default.useLayoutEffect(() => {
-        if (accessibilityDescribedBy !== undefined && accessibilityDescribedBy.current !== null) {
-            setDescribedByTarget((0, react_native_1.findNodeHandle)(accessibilityDescribedBy.current));
-        }
-    }, [accessibilityDescribedBy]);
-    react_1.default.useLayoutEffect(() => {
-        if (accessibilityControls !== undefined && accessibilityControls.current !== null) {
-            setControlsTarget((0, react_native_1.findNodeHandle)(accessibilityControls.current));
-        }
-    }, [accessibilityControls]);
-    /**
-     * Set up the forwarding ref to enable adding the focus method.
-     */
-    const focusRef = react_1.default.useRef();
-    const setNativeRef = setAndForwardRef({
-        getForwardedRef: () => ref,
-        setLocalRef: localRef => {
-            focusRef.current = localRef;
-            /**
-             * Add focus() as a callable function to the forwarded reference.
-             */
-            if (localRef) {
-                localRef.focus = () => {
-                    react_native_1.UIManager.dispatchViewManagerCommand((0, react_native_1.findNodeHandle)(localRef), react_native_1.UIManager.getViewManagerConfig('RCTView').Commands.focus, null);
-                };
-            }
-        },
-    });
-    return react_1.default.createElement(react_native_1.View, { ref: setNativeRef, ...rest, ...((controlsTarget !== null) ? { accessibilityControls: controlsTarget } : {}), ...((labeledByTarget !== null) ? { accessibilityLabeledBy: labeledByTarget } : {}), ...((describedByTarget !== null) ? { accessibilityDescribedBy: describedByTarget } : {}) });
-});
-//# sourceMappingURL=ViewWin32.js.map
+/**
+ * Copyright: Microsoft 2015
+ *
+ * RN-specific implementation of the cross-platform View abstraction.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import * as React from 'react';
+import {useCallback, useRef, useLayoutEffect} from 'react';
+import type {ViewProps} from './ViewPropTypes';
+
+import View from './View';
+import {findNodeHandle} from '../../ReactNative/RendererProxy';
+import UIManager from '../../ReactNative/UIManager';
+import useMergeRefs from '../../Utilities/useMergeRefs';
+import warnOnce from '../../Utilities/warnOnce';
+
+/**
+ * Basic View component with additional Win32 specific functionality
+ */
+
+const ViewWin32: React.AbstractComponent<
+  ViewProps,
+  React.ElementRef<typeof View>,
+> = React.forwardRef(
+  (
+    {
+      accessibilityLabeledBy,
+      accessibilityDescribedBy,
+      accessibilityControls,
+      ...rest
+    }: ViewProps,
+    forwardedRef,
+  ) => {
+    /**
+     * Process accessibility refs into node handles after initial DOM render, before sent across the bridge.
+     * useLayoutEffect will invalidate the render to assess the ref-based accessibility properties.
+     *
+     * RN core moved these properties to use NativeID instead of Refs, so this is only kept for back compat
+     */
+
+    const [labeledByTarget, setLabeledByTarget] = React.useState<
+      number | null | void,
+    >(null);
+    const [describedByTarget, setDescribedByTarget] = React.useState<
+      number | null | void,
+    >(null);
+    const [controlsTarget, setControlsTarget] = React.useState<
+      number | null | void,
+    >(null);
+
+    useLayoutEffect(() => {
+      if (
+        accessibilityLabeledBy !== undefined &&
+        accessibilityLabeledBy.current !== null
+      ) {
+        warnOnce(
+          'accessibilityLabeledByAsRef',
+          'accessibilityLabeledBy has been deprecated.  Instead use accessibilityLabelledBy (double L), and specify it as a string matching the nativeID of the target component.  Support of specifying accessibilityLabeledBy will be removed in a future release',
+        );
+        setLabeledByTarget(findNodeHandle(accessibilityLabeledBy.current));
+      }
+    }, [accessibilityLabeledBy]);
+
+    useLayoutEffect(() => {
+      if (
+        typeof accessibilityDescribedBy !== 'string' &&
+        accessibilityDescribedBy !== undefined &&
+        // $FlowFixMe[incompatible-use] - Using accessibilityDescribedBy as Ref for backcompat, not typed
+        // $FlowFixMe[prop-missing]
+        accessibilityDescribedBy.current !== null
+      ) {
+        warnOnce(
+          'accessibilityDescribedByRef',
+          'accessibilityDescribedBy should be specfied as a string matching the nativeID of the target component.  Support of specifying accessibilityDescribedBy using a ref is deprecated and will be removed in a future release',
+        );
+        // $FlowFixMe[incompatible-use] - Using accessibilityDescribedBy as Ref for backcompat, not typed
+        // $FlowFixMe[prop-missing]
+        setDescribedByTarget(findNodeHandle(accessibilityDescribedBy.current));
+      }
+    }, [accessibilityDescribedBy]);
+
+    useLayoutEffect(() => {
+      if (
+        typeof accessibilityControls !== 'string' &&
+        accessibilityControls !== undefined &&
+        // $FlowFixMe[incompatible-use] - Using accessibilityControls as Ref for backcompat, not typed
+        // $FlowFixMe[prop-missing]
+        accessibilityControls.current !== null
+      ) {
+        warnOnce(
+          'accessibilityControlsRef',
+          'accessibilityControls should be specfied as a string matching the nativeID of the target component.  Support of specifying accessibilityControls using a ref is deprecated and will be removed in a future release',
+        );
+        // $FlowFixMe[incompatible-use] - Using accessibilityControls as Ref for backcompat, not typed
+        // $FlowFixMe[prop-missing]
+        setControlsTarget(findNodeHandle(accessibilityControls.current));
+      }
+    }, [accessibilityControls]);
+
+    /**
+     * Set up the forwarding ref to enable adding the focus method.
+     */
+    const focusRef = useRef<typeof View | null>(null);
+
+    const setLocalRef = useCallback(
+      (instance: typeof View | null) => {
+        focusRef.current = instance;
+        /**
+         * Add focus() as a callable function to the forwarded reference.
+         */
+        if (instance) {
+          // $FlowFixMe[prop-missing] - TODO - focus on a component should already call into TextInputState.focus.. once we remove the refs required for legacy accessibility*By ref support
+          instance.focus = () => {
+            UIManager.dispatchViewManagerCommand(
+              findNodeHandle(instance),
+              UIManager.getViewManagerConfig('RCTView').Commands.focus,
+              null,
+            );
+          };
+        }
+      },
+      [focusRef],
+    );
+
+    // $FlowFixMe
+    const setNativeRef = useMergeRefs<typeof View | null>({
+      setLocalRef,
+      forwardedRef,
+    });
+
+    return (
+      <View
+        ref={setNativeRef}
+        {...rest}
+        {...(controlsTarget !== null
+          ? {accessibilityControls: controlsTarget}
+          : {})}
+        {...(labeledByTarget !== null
+          ? {accessibilityLabeledBy: labeledByTarget}
+          : {})}
+        {...(describedByTarget !== null
+          ? // $FlowFixMe[exponential-spread]
+            {accessibilityDescribedBy: describedByTarget}
+          : // $FlowFixMe[exponential-spread]
+          typeof accessibilityDescribedBy === 'string'
+          ? {accessibilityDescribedBy}
+          : {})}
+        {...(typeof accessibilityControls === 'string'
+          ? {accessibilityControls}
+          : {})}
+      />
+    );
+  },
+);
+
+ViewWin32.displayName = 'ViewWin32';
+
+module.exports = ViewWin32;

package/Libraries/Image/Image.win32.js

@@ -25,7 +25,6 @@ import ImageInjection from './ImageInjection';
 import {getImageSourcesFromImageProps} from './ImageSourceUtils';
 import {convertObjectFitToResizeMode} from './ImageUtils';
 import ImageViewNativeComponent from './ImageViewNativeComponent';
-import NativeImageLoaderIOS from './NativeImageLoaderIOS';
 import resolveAssetSource from './resolveAssetSource';
 import * as React from 'react';