@office-iss/react-native-win32 0.64.6 → 0.64.10

package/.flowconfig

@@ -12,6 +12,7 @@
 <PROJECT_ROOT>/Libraries/Alert/Alert.js
 <PROJECT_ROOT>/Libraries/Components/AccessibilityInfo/NativeAccessibilityInfo.js
 <PROJECT_ROOT>/Libraries/Components/Picker/Picker.js
+<PROJECT_ROOT>/Libraries/Components/Pressable/Pressable.js
 <PROJECT_ROOT>/Libraries/Components/SafeAreaView/SafeAreaView.js
 <PROJECT_ROOT>/Libraries/Components/TextInput/TextInput.js
 <PROJECT_ROOT>/Libraries/Components/TextInput/TextInputState.js
@@ -19,11 +20,15 @@
 <PROJECT_ROOT>/Libraries/Components/View/ReactNativeViewAttributes.js
 <PROJECT_ROOT>/Libraries/Components/View/ReactNativeViewViewConfig.js
 <PROJECT_ROOT>/Libraries/Components/View/View.js
+<PROJECT_ROOT>/Libraries/Components/View/ViewPropTypes.js
 <PROJECT_ROOT>/Libraries/Image/Image.js
 <PROJECT_ROOT>/Libraries/Inspector/Inspector.js
 <PROJECT_ROOT>/Libraries/Inspector/InspectorOverlay.js
 <PROJECT_ROOT>/Libraries/Network/RCTNetworking.js
+<PROJECT_ROOT>/Libraries/Pressability/Pressability.js
+<PROJECT_ROOT>/Libraries/Pressability/HoverState.js
 <PROJECT_ROOT>/Libraries/StyleSheet/StyleSheet.js
+<PROJECT_ROOT>/Libraries/Types/CoreEventTypes.js
 <PROJECT_ROOT>/Libraries/Utilities/DeviceInfo.js
 <PROJECT_ROOT>/Libraries/Utilities/Dimensions.js
 

package/CHANGELOG.json

@@ -2,7 +2,67 @@
   "name": "@office-iss/react-native-win32",
   "entries": [
     {
-      "date": "Mon, 13 Sep 2021 15:06:02 GMT",
+      "date": "Mon, 17 Jan 2022 16:09:50 GMT",
+      "tag": "@office-iss/react-native-win32_v0.64.10",
+      "version": "0.64.10",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Port windows pressable with extra desktop support to win32",
+            "author": "saadnajmi2@gmail.com",
+            "commit": "acfb47a7924f4d4e34e020838423bbbab026d670",
+            "package": "@office-iss/react-native-win32"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 15 Nov 2021 16:09:20 GMT",
+      "tag": "@office-iss/react-native-win32_v0.64.9",
+      "version": "0.64.9",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Add enableFocusRing prop for View and test",
+            "author": "ruaraki@microsoft.com",
+            "commit": "ecbd53d9cd10b88691fc79eeaaf3be1b035f162f",
+            "package": "@office-iss/react-native-win32"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 25 Oct 2021 15:07:12 GMT",
+      "tag": "@office-iss/react-native-win32_v0.64.8",
+      "version": "0.64.8",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Revert back to a warning for acceptsKeyboardFocus deprecation",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e615b1c46b7396fe617dc3019091cc367bd145a8",
+            "package": "@office-iss/react-native-win32"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 20 Sep 2021 15:06:37 GMT",
+      "tag": "@office-iss/react-native-win32_v0.64.7",
+      "version": "0.64.7",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Adding accessibilityItemType to ViewWin32",
+            "author": "safreibe@microsoft.com",
+            "commit": "47ceaac64f88816796d67d08affb9beea67d6344",
+            "package": "@office-iss/react-native-win32"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 13 Sep 2021 15:06:21 GMT",
       "tag": "@office-iss/react-native-win32_v0.64.6",
       "version": "0.64.6",
       "comments": {

package/CHANGELOG.md

@@ -1,17 +1,49 @@
 # Change Log - @office-iss/react-native-win32
 
-This log was last generated on Mon, 13 Sep 2021 15:06:02 GMT and should not be manually modified.
+This log was last generated on Mon, 17 Jan 2022 16:09:50 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.64.6
+## 0.64.10
 
-Mon, 13 Sep 2021 15:06:02 GMT
+Mon, 17 Jan 2022 16:09:50 GMT
 
 ### Patches
 
-- Fix exception in View when props are undefined (30809111+acoates-ms@users.noreply.github.com)
+- Port windows pressable with extra desktop support to win32 (saadnajmi2@gmail.com)
 
+## 0.64.9
+
+Mon, 15 Nov 2021 16:09:20 GMT
+
+### Patches
+
+- Add enableFocusRing prop for View and test (ruaraki@microsoft.com)
+
+## 0.64.8
+
+Mon, 25 Oct 2021 15:07:12 GMT
+
+### Patches
+
+- Revert back to a warning for acceptsKeyboardFocus deprecation (30809111+acoates-ms@users.noreply.github.com)
+
+## 0.64.7
+
+Mon, 20 Sep 2021 15:06:37 GMT
+
+### Patches
+
+- Adding accessibilityItemType to ViewWin32 (safreibe@microsoft.com)
+
+## 0.64.6
+
+Mon, 13 Sep 2021 15:06:21 GMT
+
+### Patches
+
+- Fix exception in View when props are undefined (30809111+acoates-ms@users.noreply.github.com)
+
 ## 0.64.5
 
 Mon, 23 Aug 2021 15:10:07 GMT

package/Libraries/Components/Pressable/Pressable.win32.js

@@ -0,0 +1,333 @@
+/**
+ * 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 * as React from 'react';
+import {useMemo, useState, useRef, useImperativeHandle} from 'react';
+import useAndroidRippleForView, {
+  type RippleConfig,
+} from './useAndroidRippleForView';
+import type {
+  AccessibilityActionEvent,
+  AccessibilityActionInfo,
+  AccessibilityRole,
+  AccessibilityState,
+  AccessibilityValue,
+} from '../View/ViewAccessibility';
+import {PressabilityDebugView} from '../../Pressability/PressabilityDebug';
+import usePressability from '../../Pressability/usePressability';
+import {normalizeRect, type RectOrSize} from '../../StyleSheet/Rect';
+import type {
+  LayoutEvent,
+  PressEvent,
+  // [Windows
+  MouseEvent,
+  BlurEvent,
+  FocusEvent, // Windows]
+} from '../../Types/CoreEventTypes';
+import View from '../View/View';
+import TextInputState from '../TextInput/TextInputState';
+
+type ViewStyleProp = $ElementType<React.ElementConfig<typeof View>, 'style'>;
+
+export type StateCallbackType = $ReadOnly<{|
+  pressed: boolean,
+|}>;
+
+type Props = $ReadOnly<{|
+  /**
+   * Accessibility.
+   */
+  accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+  accessibilityElementsHidden?: ?boolean,
+  accessibilityHint?: ?Stringish,
+  accessibilityIgnoresInvertColors?: ?boolean,
+  accessibilityLabel?: ?Stringish,
+  accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+  accessibilityRole?: ?AccessibilityRole,
+  accessibilityState?: ?AccessibilityState,
+  accessibilityValue?: ?AccessibilityValue,
+  accessibilityViewIsModal?: ?boolean,
+  accessible?: ?boolean,
+  focusable?: ?boolean,
+  importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+  onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+
+  /**
+   * Either children or a render prop that receives a boolean reflecting whether
+   * the component is currently pressed.
+   */
+  children: React.Node | ((state: StateCallbackType) => React.Node),
+
+  /**
+   * Duration to wait after hover in before calling `onHoverIn`.
+   */
+  delayHoverIn?: ?number,
+
+  /**
+   * Duration to wait after hover out before calling `onHoverOut`.
+   */
+  delayHoverOut?: ?number,
+
+  /**
+   * Duration (in milliseconds) from `onPressIn` before `onLongPress` is called.
+   */
+  delayLongPress?: ?number,
+
+  /**
+   * Whether the press behavior is disabled.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Additional distance outside of this view in which a press is detected.
+   */
+  hitSlop?: ?RectOrSize,
+
+  /**
+   * Additional distance outside of this view in which a touch is considered a
+   * press before `onPressOut` is triggered.
+   */
+  pressRetentionOffset?: ?RectOrSize,
+
+  /**
+   * Called when this view's layout changes.
+   */
+  onLayout?: ?(event: LayoutEvent) => void,
+
+  /**
+   * Called when the hover is activated to provide visual feedback.
+   */
+  onHoverIn?: ?(event: MouseEvent) => mixed,
+
+  /**
+   * Called when the hover is deactivated to undo visual feedback.
+   */
+  onHoverOut?: ?(event: MouseEvent) => mixed,
+
+  /**
+   * Called when a long-tap gesture is detected.
+   */
+  onLongPress?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a touch is engaged before `onPress`.
+   */
+  onPressIn?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a touch is released before `onPress`.
+   */
+  onPressOut?: ?(event: PressEvent) => void,
+
+  /**
+   * Called after the element loses focus.
+   */
+  onBlur?: ?(event: BlurEvent) => mixed,
+
+  /**
+   * Called after the element is focused.
+   */
+  onFocus?: ?(event: FocusEvent) => mixed,
+
+  /**
+   * Either view styles or a function that receives a boolean reflecting whether
+   * the component is currently pressed and returns view styles.
+   */
+  style?: ViewStyleProp | ((state: StateCallbackType) => ViewStyleProp),
+
+  /**
+   * Identifier used to find this view in tests.
+   */
+  testID?: ?string,
+
+  /**
+   * If true, doesn't play system sound on touch.
+   */
+  android_disableSound?: ?boolean,
+
+  /**
+   * Enables the Android ripple effect and configures its color.
+   */
+  android_ripple?: ?RippleConfig,
+
+  /**
+   * Used only for documentation or testing (e.g. snapshot testing).
+   */
+  testOnly_pressed?: ?boolean,
+
+  /**
+   * Duration to wait after press down before calling `onPressIn`.
+   */
+  unstable_pressDelay?: ?number,
+|}>;
+
+/**
+ * Component used to build display components that should respond to whether the
+ * component is currently pressed or not.
+ */
+function Pressable(props: Props, forwardedRef): React.Node {
+  const {
+    accessible,
+    android_disableSound,
+    android_ripple,
+    children,
+    delayHoverIn,
+    delayHoverOut,
+    delayLongPress,
+    disabled,
+    focusable,
+    onHoverIn,
+    onHoverOut,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    // [Windows
+    onBlur,
+    onFocus,
+    // Windows]
+    pressRetentionOffset,
+    style,
+    testOnly_pressed,
+    unstable_pressDelay,
+    ...restProps
+  } = props;
+
+  const viewRef = useRef<React.ElementRef<typeof View> | null>(null);
+  useImperativeHandle(forwardedRef, () => viewRef.current);
+
+  // [Windows
+  const _onBlur = (event: BlurEvent) => {
+    TextInputState.blurInput(viewRef.current);
+    if (props.onBlur) {
+      props.onBlur(event);
+    }
+  };
+
+  const _onFocus = (event: FocusEvent) => {
+    TextInputState.focusInput(viewRef.current);
+    if (props.onFocus) {
+      props.onFocus(event);
+    }
+  };
+  // Windows]
+
+  const android_rippleConfig = useAndroidRippleForView(android_ripple, viewRef);
+
+  const [pressed, setPressed] = usePressState(testOnly_pressed === true);
+
+  const hitSlop = normalizeRect(props.hitSlop);
+
+  const restPropsWithDefaults: React.ElementConfig<typeof View> = {
+    ...restProps,
+    ...android_rippleConfig?.viewProps,
+    accessible: accessible !== false,
+    focusable: focusable !== false,
+    hitSlop,
+  };
+
+  const config = useMemo(
+    () => ({
+      disabled,
+      hitSlop,
+      pressRectOffset: pressRetentionOffset,
+      android_disableSound,
+      delayHoverIn,
+      delayHoverOut,
+      delayLongPress,
+      delayPressIn: unstable_pressDelay,
+      onHoverIn,
+      onHoverOut,
+      onLongPress,
+      onPress,
+      onPressIn(event: PressEvent): void {
+        if (android_rippleConfig != null) {
+          android_rippleConfig.onPressIn(event);
+        }
+        setPressed(true);
+        if (onPressIn != null) {
+          onPressIn(event);
+        }
+      },
+      onPressMove: android_rippleConfig?.onPressMove,
+      onPressOut(event: PressEvent): void {
+        if (android_rippleConfig != null) {
+          android_rippleConfig.onPressOut(event);
+        }
+        setPressed(false);
+        if (onPressOut != null) {
+          onPressOut(event);
+        }
+      },
+      // [Windows
+      onBlur,
+      onFocus,
+      // Windows]
+    }),
+    [
+      android_disableSound,
+      android_rippleConfig,
+      delayHoverIn,
+      delayHoverOut,
+      delayLongPress,
+      disabled,
+      hitSlop,
+      onHoverIn,
+      onHoverOut,
+      onLongPress,
+      onPress,
+      onPressIn,
+      onPressOut,
+      // [Windows
+      onBlur,
+      onFocus,
+      // Windows]
+      pressRetentionOffset,
+      setPressed,
+      unstable_pressDelay,
+    ],
+  );
+  const eventHandlers = usePressability(config);
+
+  return (
+    <View
+      {...restPropsWithDefaults}
+      {...eventHandlers}
+      // [Windows
+      onBlur={_onBlur}
+      onFocus={_onFocus}
+      // Windows]
+      ref={viewRef}
+      style={typeof style === 'function' ? style({pressed}) : style}>
+      {typeof children === 'function' ? children({pressed}) : children}
+      {__DEV__ ? <PressabilityDebugView color="red" hitSlop={hitSlop} /> : null}
+    </View>
+  );
+}
+
+function usePressState(forcePressed: boolean): [boolean, (boolean) => void] {
+  const [pressed, setPressed] = useState(false);
+  return [pressed || forcePressed, setPressed];
+}
+
+const MemoedPressable = React.memo(React.forwardRef(Pressable));
+MemoedPressable.displayName = 'Pressable';
+
+export default (MemoedPressable: React.AbstractComponent<
+  Props,
+  React.ElementRef<typeof View>,
+>);

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

@@ -379,6 +379,8 @@ const ReactNativeViewConfig = {
     accessibilityLabeledBy: true,
     accessibilityDescription: true,
     accessibilityControls: true,
+    accessibilityItemType: true,
+    enableFocusRing: true,
     // Windows]
   },
 };

package/Libraries/Components/View/Tests/ViewWin32Test.js

@@ -68,11 +68,11 @@ var FocusMoverTestComponent = /** @class */ (function (_super) {
     }
     FocusMoverTestComponent.prototype.render = function () {
         return (React.createElement(ViewWin32_1.ViewWin32, null,
-            React.createElement(ViewWin32_1.ViewWin32, { ref: this._labeledBy, accessibilityLabel: "separate label for test" }),
+            React.createElement(ViewWin32_1.ViewWin32, { ref: this._labeledBy, accessibilityLabel: "separate label for test", accessibilityItemType: "Comment" }),
             React.createElement(ViewWin32_1.ViewWin32, { style: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-around', marginVertical: 5 } },
                 React.createElement(react_native_1.TouchableHighlight, { onPress: this._onPress },
                     React.createElement(ViewWin32_1.ViewWin32, { accessibilityLabeledBy: this._labeledBy, style: styles.blackbox })),
-                React.createElement(ViewWin32_1.ViewWin32, { ref: this._setRef, focusable: true, style: this.state.hasFocus ? { backgroundColor: '#aee8fcff' } : { backgroundColor: '#00000000' }, onFocus: this._onFocus, onBlur: this._onBlur },
+                React.createElement(ViewWin32_1.ViewWin32, { ref: this._setRef, focusable: true, style: this.state.hasFocus ? { backgroundColor: '#aee8fcff' } : { backgroundColor: '#00000000' }, onFocus: this._onFocus, onBlur: this._onBlur, enableFocusRing: false },
                     React.createElement(react_native_1.Text, null, this.state.hasFocus ? 'Focus: Yes' : 'Focus: No')))));
     };
     return FocusMoverTestComponent;
@@ -113,7 +113,7 @@ var KeyboardTestComponent = /** @class */ (function (_super) {
     }
     KeyboardTestComponent.prototype.render = function () {
         return (React.createElement(ViewWin32_1.ViewWin32, { keyDownEvents: handledNativeKeyboardEvents, keyUpEvents: handledNativeKeyboardEvents },
-            React.createElement(ViewWin32_1.ViewWin32, { style: this.state.hasFocus ? [styles.keyComponentRoot, styles.border] : styles.keyComponentRoot, focusable: true, onKeyUp: this._onKeyUp, onKeyDown: this._onKeyDown, onFocus: this._onFocus, onBlur: this._onBlur },
+            React.createElement(ViewWin32_1.ViewWin32, { style: this.state.hasFocus ? [styles.keyComponentRoot, styles.border] : styles.keyComponentRoot, focusable: true, onKeyUp: this._onKeyUp, onKeyDown: this._onKeyDown, onFocus: this._onFocus, onBlur: this._onBlur, enableFocusRing: false },
                 React.createElement(ViewWin32_1.ViewWin32, { style: styles.keyEnterVisualizer },
                     React.createElement(react_native_1.Text, null, "OnKeyDown"),
                     React.createElement(react_native_1.Text, null, "----"),
@@ -189,6 +189,44 @@ var CursorExample = function () {
         React.createElement(CursorTestComponent, { cursor: 'text' }),
         React.createElement(CursorTestComponent, { cursor: 'we-resize' })));
 };
+var EnableFocusRingExample = /** @class */ (function (_super) {
+    __extends(EnableFocusRingExample, _super);
+    function EnableFocusRingExample(props) {
+        var _this = _super.call(this, props) || this;
+        _this._onFocus = function () {
+            _this.setState({
+                hasFocus: true,
+            });
+        };
+        _this._onBlur = function () {
+            _this.setState({
+                hasFocus: false,
+            });
+        };
+        _this.state = {
+            hasFocus: false,
+        };
+        return _this;
+    }
+    EnableFocusRingExample.prototype.render = function () {
+        return (React.createElement(ViewWin32_1.ViewWin32, { style: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-around', marginVertical: 5 } },
+            React.createElement(ViewWin32_1.ViewWin32, { style: {
+                    backgroundColor: 'pink',
+                    height: 100,
+                    width: 100,
+                }, enableFocusRing: true, focusable: true },
+                React.createElement(react_native_1.Text, null, "enableFocusRing set to true")),
+            React.createElement(ViewWin32_1.ViewWin32, { style: {
+                    backgroundColor: 'pink',
+                    height: 100,
+                    width: 100,
+                }, enableFocusRing: false, focusable: true, onFocus: this._onFocus, onBlur: this._onBlur },
+                React.createElement(React.Fragment, null,
+                    React.createElement(react_native_1.Text, null, "enableFocusRing set to false"),
+                    React.createElement(react_native_1.Text, null, this.state.hasFocus ? 'Focus: Yes' : 'Focus: No')))));
+    };
+    return EnableFocusRingExample;
+}(React.Component));
 exports.title = 'ViewWin32';
 exports.displayName = 'ViewWin32 Example';
 exports.description = 'All the stock View props plus Win32 specific ones';
@@ -231,5 +269,12 @@ exports.examples = [
             return React.createElement(CursorExample, null);
         },
     },
+    {
+        title: 'EnableFocusRing example',
+        description: 'Displays focus visuals that are driven by native',
+        render: function () {
+            return React.createElement(EnableFocusRingExample, null);
+        },
+    },
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViewWin32Test.js","sourceRoot":"","sources":["../../../../src/Libraries/Components/View/Tests/ViewWin32Test.tsx"],"names":[],"mappings":"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","sourcesContent":["'use strict';\nimport * as React from 'react';\nimport { StyleSheet, Text, TouchableHighlight } from 'react-native';\nimport { ViewWin32 } from '../ViewWin32';\nimport { Cursor, IKeyboardEvent, IHandledKeyboardEvent } from '../ViewWin32.Props';\n\nconst styles = StyleSheet.create({\n  border: {\n    borderStyle: 'dotted',\n    borderColor: 'black',\n  },\n  keyComponentRoot: {\n    borderWidth: 2,\n    flexDirection: 'row',\n    marginVertical: 5,\n    backgroundColor: 'whitesmoke',\n    justifyContent: 'space-around',\n  },\n  keyEnterVisualizer: {\n    margin: 5,\n    alignItems: 'center',\n    minWidth: 100,\n    minHeight: 30,\n  },\n  blackbox: { height: 30, width: 30, borderColor: 'black', borderWidth: 3 },\n});\n\ninterface IFocusableComponentState {\n  hasFocus: boolean;\n}\n\nclass FocusMoverTestComponent extends React.Component<{}, IFocusableComponentState> {\n  private _focusTarget: ViewWin32 = null;\n  private readonly _labeledBy: React.RefObject<ViewWin32>;\n\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n    };\n    this._labeledBy = React.createRef<ViewWin32>();\n  }\n  public render() {\n    return (\n      <ViewWin32>\n        <ViewWin32 ref={this._labeledBy} accessibilityLabel=\"separate label for test\" />\n      <ViewWin32 style={{ flexDirection: 'row', alignItems: 'center', justifyContent: 'space-around', marginVertical: 5 }}>\n        <TouchableHighlight onPress={this._onPress}>\n          <ViewWin32 accessibilityLabeledBy={this._labeledBy} style={styles.blackbox} />\n        </TouchableHighlight>\n        <ViewWin32\n          ref={this._setRef}\n          focusable\n          style={this.state.hasFocus ? { backgroundColor: '#aee8fcff' } : { backgroundColor: '#00000000' }}\n          onFocus={this._onFocus}\n          onBlur={this._onBlur}\n        >\n          <Text>{this.state.hasFocus ? 'Focus: Yes' : 'Focus: No'}</Text>\n        </ViewWin32>\n      </ViewWin32>\n      </ViewWin32>\n    );\n  }\n\n  private readonly _setRef = (ref: ViewWin32) => {\n    this._focusTarget = ref;\n  };\n\n  private readonly _onPress = () => {\n    if (this._focusTarget !== undefined) {\n      this._focusTarget.focus();\n    }\n  };\n\n  private readonly _onFocus = () => {\n    this.setState({\n      hasFocus: true,\n    });\n  };\n\n  private readonly _onBlur = () => {\n    this.setState({\n      hasFocus: false,\n    });\n  };\n}\n\ninterface IKeyboardableComponentState {\n  lastKeyDown: string;\n  lastKeyUp: string;\n}\n\nconst handledNativeKeyboardEvents: IHandledKeyboardEvent[] = [\n  { key: 'ArrowDown' },\n  { key: 'ArrowUp' },\n  { key: 'ArrowLeft' },\n  { key: 'ArrowRight' },\n  { key: 'Tab' },\n];\n\nclass KeyboardTestComponent extends React.Component<{}, IFocusableComponentState & IKeyboardableComponentState> {\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n      lastKeyDown: null,\n      lastKeyUp: null,\n    };\n  }\n\n  public render() {\n    return (\n      <ViewWin32 keyDownEvents={handledNativeKeyboardEvents} keyUpEvents={handledNativeKeyboardEvents}>\n        <ViewWin32\n          style={this.state.hasFocus ? [styles.keyComponentRoot, styles.border] : styles.keyComponentRoot}\n          focusable\n          onKeyUp={this._onKeyUp}\n          onKeyDown={this._onKeyDown}\n          onFocus={this._onFocus}\n          onBlur={this._onBlur}\n        >\n          <ViewWin32 style={styles.keyEnterVisualizer}>\n            <Text>OnKeyDown</Text>\n            <Text>----</Text>\n            <Text>{this.state.lastKeyDown !== null ? this.state.lastKeyDown : ' '}</Text>\n          </ViewWin32>\n          <ViewWin32 style={styles.keyEnterVisualizer}>\n            <Text>OnKeyUp</Text>\n            <Text>----</Text>\n            <Text>{this.state.lastKeyUp !== null ? this.state.lastKeyUp : ' '}</Text>\n          </ViewWin32>\n        </ViewWin32>\n      </ViewWin32>\n    );\n  }\n\n  private readonly _onFocus = () => {\n    this.setState({\n      hasFocus: true,\n    });\n  };\n\n  private readonly _onBlur = () => {\n    this.setState({\n      hasFocus: false,\n    });\n  };\n\n  private readonly _onKeyUp = (ev: IKeyboardEvent) => {\n    this.setState({ lastKeyUp: ev.nativeEvent.key, lastKeyDown: null });\n  };\n\n  private readonly _onKeyDown = (ev: IKeyboardEvent) => {\n    this.setState({ lastKeyDown: ev.nativeEvent.key, lastKeyUp: null });\n  };\n}\n\ninterface IHoverComponentProps {\n  color: string;\n}\nclass HoverTestComponent extends React.Component<IHoverComponentProps, IFocusableComponentState> {\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n    };\n  }\n\n  public render() {\n    return (\n      <ViewWin32\n        onMouseEnter={this._onMouseEnter}\n        onMouseLeave={this._onMouseLeave}\n        style={this.state.hasFocus ? [styles.blackbox, { backgroundColor: this.props.color }] : styles.blackbox}\n      />\n    );\n  }\n  private readonly _onMouseLeave = () => {\n    this.setState({ hasFocus: false });\n  };\n  private readonly _onMouseEnter = () => {\n    this.setState({ hasFocus: true });\n  };\n}\n\nclass HoverExample extends React.Component {\n  public render() {\n    return (\n      <ViewWin32 style={{ flexDirection: 'row', marginHorizontal: 75, justifyContent: 'space-around' }}>\n        <HoverTestComponent color=\"red\" />\n        <HoverTestComponent color=\"orange\" />\n        <HoverTestComponent color=\"yellow\" />\n        <HoverTestComponent color=\"green\" />\n        <HoverTestComponent color=\"blue\" />\n        <HoverTestComponent color=\"indigo\" />\n        <HoverTestComponent color=\"violet\" />\n      </ViewWin32>\n    );\n  }\n}\n\nconst ToolTipExample: React.FunctionComponent<{}> = () => {\n  return (\n    <ViewWin32\n      style={{\n        backgroundColor: 'red',\n        height: 100,\n        width: 100,\n      }}\n      tooltip=\"Example tooltip\"\n      cursor=\"pointer\"\n    />\n  );\n};\n\ninterface ICursorTestComponentProps {\n  cursor: Cursor\n}\n\nconst CursorTestComponent: React.FunctionComponent<ICursorTestComponentProps> = (props) => {\n  return (\n    <ViewWin32 style={{flexDirection: 'column'}}>\n      <Text>{props.cursor}</Text>\n      <ViewWin32 cursor={props.cursor} style={styles.blackbox} />\n    </ViewWin32>\n  )\n}\n\nconst CursorExample: React.FunctionComponent = () => {\n  return (\n    <ViewWin32 style={{ flexDirection: 'row', justifyContent: 'space-around' }}>\n      <CursorTestComponent cursor='auto' />\n      <CursorTestComponent cursor='default' />\n      <CursorTestComponent cursor='help' />\n      <CursorTestComponent cursor='nesw-resize' />\n      <CursorTestComponent cursor='not-allowed' />\n      <CursorTestComponent cursor='ns-resize' />\n      <CursorTestComponent cursor='nwse-resize' />\n      <CursorTestComponent cursor='pointer' />\n      <CursorTestComponent cursor='wait' />\n      <CursorTestComponent cursor='move' />\n      <CursorTestComponent cursor='text' />\n      <CursorTestComponent cursor='we-resize' />\n    </ViewWin32>\n  );\n}\n\nexport const title = 'ViewWin32';\nexport const displayName = 'ViewWin32 Example';\nexport const description = 'All the stock View props plus Win32 specific ones';\nexport const examples = [\n  {\n    title: 'focus() method example',\n    description: 'Each of these black boxes moves focus to the ViewWin32 on the right',\n    render(): JSX.Element {\n      return (\n        <ViewWin32>\n          <FocusMoverTestComponent />\n          <FocusMoverTestComponent />\n          <FocusMoverTestComponent />\n        </ViewWin32>\n      );\n    },\n  },\n  {\n    title: 'KeyboardEvents example',\n    description: 'Native keyboarding has been prevented',\n    render(): JSX.Element {\n      return <KeyboardTestComponent />;\n    },\n  },\n  {\n    title: 'Hover example',\n    description: 'Hover a rainbow',\n    render(): JSX.Element {\n      return <HoverExample />;\n    },\n  },\n  {\n    title: 'Tooltip example',\n    description: 'Displays a tooltip on hover',\n    render(): JSX.Element {\n      return <ToolTipExample />;\n    },\n  },\n  {\n    title: 'Cursor example',\n    description: 'Each of these boxes should display a different cursor',\n    render(): JSX.Element {\n      return <CursorExample />;\n    },\n  },\n];\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViewWin32Test.js","sourceRoot":"","sources":["../../../../src/Libraries/Components/View/Tests/ViewWin32Test.tsx"],"names":[],"mappings":"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","sourcesContent":["'use strict';\nimport * as React from 'react';\nimport { StyleSheet, Text, TouchableHighlight } from 'react-native';\nimport { ViewWin32 } from '../ViewWin32';\nimport { Cursor, IKeyboardEvent, IHandledKeyboardEvent } from '../ViewWin32.Props';\n\nconst styles = StyleSheet.create({\n  border: {\n    borderStyle: 'dotted',\n    borderColor: 'black',\n  },\n  keyComponentRoot: {\n    borderWidth: 2,\n    flexDirection: 'row',\n    marginVertical: 5,\n    backgroundColor: 'whitesmoke',\n    justifyContent: 'space-around',\n  },\n  keyEnterVisualizer: {\n    margin: 5,\n    alignItems: 'center',\n    minWidth: 100,\n    minHeight: 30,\n  },\n  blackbox: { height: 30, width: 30, borderColor: 'black', borderWidth: 3 },\n});\n\ninterface IFocusableComponentState {\n  hasFocus: boolean;\n}\n\nclass FocusMoverTestComponent extends React.Component<{}, IFocusableComponentState> {\n  private _focusTarget: ViewWin32 = null;\n  private readonly _labeledBy: React.RefObject<ViewWin32>;\n\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n    };\n    this._labeledBy = React.createRef<ViewWin32>();\n  }\n  public render() {\n    return (\n      <ViewWin32>\n        <ViewWin32 ref={this._labeledBy} accessibilityLabel=\"separate label for test\" accessibilityItemType=\"Comment\" />\n      <ViewWin32 style={{ flexDirection: 'row', alignItems: 'center', justifyContent: 'space-around', marginVertical: 5 }}>\n        <TouchableHighlight onPress={this._onPress}>\n          <ViewWin32 accessibilityLabeledBy={this._labeledBy} style={styles.blackbox} />\n        </TouchableHighlight>\n        <ViewWin32\n          ref={this._setRef}\n          focusable\n          style={this.state.hasFocus ? { backgroundColor: '#aee8fcff' } : { backgroundColor: '#00000000' }}\n          onFocus={this._onFocus}\n          onBlur={this._onBlur}\n          enableFocusRing={false}\n        >\n          <Text>{this.state.hasFocus ? 'Focus: Yes' : 'Focus: No'}</Text>\n        </ViewWin32>\n      </ViewWin32>\n      </ViewWin32>\n    );\n  }\n\n  private readonly _setRef = (ref: ViewWin32) => {\n    this._focusTarget = ref;\n  };\n\n  private readonly _onPress = () => {\n    if (this._focusTarget !== undefined) {\n      this._focusTarget.focus();\n    }\n  };\n\n  private readonly _onFocus = () => {\n    this.setState({\n      hasFocus: true,\n    });\n  };\n\n  private readonly _onBlur = () => {\n    this.setState({\n      hasFocus: false,\n    });\n  };\n}\n\ninterface IKeyboardableComponentState {\n  lastKeyDown: string;\n  lastKeyUp: string;\n}\n\nconst handledNativeKeyboardEvents: IHandledKeyboardEvent[] = [\n  { key: 'ArrowDown' },\n  { key: 'ArrowUp' },\n  { key: 'ArrowLeft' },\n  { key: 'ArrowRight' },\n  { key: 'Tab' },\n];\n\nclass KeyboardTestComponent extends React.Component<{}, IFocusableComponentState & IKeyboardableComponentState> {\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n      lastKeyDown: null,\n      lastKeyUp: null,\n    };\n  }\n\n  public render() {\n    return (\n      <ViewWin32 keyDownEvents={handledNativeKeyboardEvents} keyUpEvents={handledNativeKeyboardEvents}>\n        <ViewWin32\n          style={this.state.hasFocus ? [styles.keyComponentRoot, styles.border] : styles.keyComponentRoot}\n          focusable\n          onKeyUp={this._onKeyUp}\n          onKeyDown={this._onKeyDown}\n          onFocus={this._onFocus}\n          onBlur={this._onBlur}\n          enableFocusRing={false}\n        >\n          <ViewWin32 style={styles.keyEnterVisualizer}>\n            <Text>OnKeyDown</Text>\n            <Text>----</Text>\n            <Text>{this.state.lastKeyDown !== null ? this.state.lastKeyDown : ' '}</Text>\n          </ViewWin32>\n          <ViewWin32 style={styles.keyEnterVisualizer}>\n            <Text>OnKeyUp</Text>\n            <Text>----</Text>\n            <Text>{this.state.lastKeyUp !== null ? this.state.lastKeyUp : ' '}</Text>\n          </ViewWin32>\n        </ViewWin32>\n      </ViewWin32>\n    );\n  }\n\n  private readonly _onFocus = () => {\n    this.setState({\n      hasFocus: true,\n    });\n  };\n\n  private readonly _onBlur = () => {\n    this.setState({\n      hasFocus: false,\n    });\n  };\n\n  private readonly _onKeyUp = (ev: IKeyboardEvent) => {\n    this.setState({ lastKeyUp: ev.nativeEvent.key, lastKeyDown: null });\n  };\n\n  private readonly _onKeyDown = (ev: IKeyboardEvent) => {\n    this.setState({ lastKeyDown: ev.nativeEvent.key, lastKeyUp: null });\n  };\n}\n\ninterface IHoverComponentProps {\n  color: string;\n}\nclass HoverTestComponent extends React.Component<IHoverComponentProps, IFocusableComponentState> {\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n    };\n  }\n\n  public render() {\n    return (\n      <ViewWin32\n        onMouseEnter={this._onMouseEnter}\n        onMouseLeave={this._onMouseLeave}\n        style={this.state.hasFocus ? [styles.blackbox, { backgroundColor: this.props.color }] : styles.blackbox}\n      />\n    );\n  }\n  private readonly _onMouseLeave = () => {\n    this.setState({ hasFocus: false });\n  };\n  private readonly _onMouseEnter = () => {\n    this.setState({ hasFocus: true });\n  };\n}\n\nclass HoverExample extends React.Component {\n  public render() {\n    return (\n      <ViewWin32 style={{ flexDirection: 'row', marginHorizontal: 75, justifyContent: 'space-around' }}>\n        <HoverTestComponent color=\"red\" />\n        <HoverTestComponent color=\"orange\" />\n        <HoverTestComponent color=\"yellow\" />\n        <HoverTestComponent color=\"green\" />\n        <HoverTestComponent color=\"blue\" />\n        <HoverTestComponent color=\"indigo\" />\n        <HoverTestComponent color=\"violet\" />\n      </ViewWin32>\n    );\n  }\n}\n\nconst ToolTipExample: React.FunctionComponent<{}> = () => {\n  return (\n    <ViewWin32\n      style={{\n        backgroundColor: 'red',\n        height: 100,\n        width: 100,\n      }}\n      tooltip=\"Example tooltip\"\n      cursor=\"pointer\"\n    />\n  );\n};\n\ninterface ICursorTestComponentProps {\n  cursor: Cursor\n}\n\nconst CursorTestComponent: React.FunctionComponent<ICursorTestComponentProps> = (props) => {\n  return (\n    <ViewWin32 style={{flexDirection: 'column'}}>\n      <Text>{props.cursor}</Text>\n      <ViewWin32 cursor={props.cursor} style={styles.blackbox} />\n    </ViewWin32>\n  )\n}\n\nconst CursorExample: React.FunctionComponent = () => {\n  return (\n    <ViewWin32 style={{ flexDirection: 'row', justifyContent: 'space-around' }}>\n      <CursorTestComponent cursor='auto' />\n      <CursorTestComponent cursor='default' />\n      <CursorTestComponent cursor='help' />\n      <CursorTestComponent cursor='nesw-resize' />\n      <CursorTestComponent cursor='not-allowed' />\n      <CursorTestComponent cursor='ns-resize' />\n      <CursorTestComponent cursor='nwse-resize' />\n      <CursorTestComponent cursor='pointer' />\n      <CursorTestComponent cursor='wait' />\n      <CursorTestComponent cursor='move' />\n      <CursorTestComponent cursor='text' />\n      <CursorTestComponent cursor='we-resize' />\n    </ViewWin32>\n  );\n}\nclass EnableFocusRingExample extends React.Component<{}, IFocusableComponentState> {\n  public constructor(props) {\n    super(props);\n    this.state = {\n      hasFocus: false,\n    };\n  }\n  \n  public render() {\n    return (\n      <ViewWin32 style={{ flexDirection: 'row', alignItems: 'center', justifyContent: 'space-around', marginVertical: 5 }}>\n        <ViewWin32\n          style={{\n            backgroundColor: 'pink',\n            height: 100,\n            width: 100,\n          }}\n          enableFocusRing={true}\n          focusable\n        >\n          <Text>enableFocusRing set to true</Text>\n        </ViewWin32>\n        <ViewWin32\n          style={{\n            backgroundColor: 'pink',\n            height: 100,\n            width: 100,\n          }}\n          enableFocusRing={false}\n          focusable\n          onFocus={this._onFocus}\n          onBlur={this._onBlur}\n        >\n          <>\n            <Text>enableFocusRing set to false</Text>\n            <Text>{this.state.hasFocus ? 'Focus: Yes' : 'Focus: No'}</Text>\n          </>\n        </ViewWin32>\n      </ViewWin32>\n    );\n  }\n\n  private readonly _onFocus = () => {\n    this.setState({\n      hasFocus: true,\n    });\n  };\n\n  private readonly _onBlur = () => {\n    this.setState({\n      hasFocus: false,\n    });\n  };\n}\n\n\nexport const title = 'ViewWin32';\nexport const displayName = 'ViewWin32 Example';\nexport const description = 'All the stock View props plus Win32 specific ones';\nexport const examples = [\n  {\n    title: 'focus() method example',\n    description: 'Each of these black boxes moves focus to the ViewWin32 on the right',\n    render(): JSX.Element {\n      return (\n        <ViewWin32>\n          <FocusMoverTestComponent />\n          <FocusMoverTestComponent />\n          <FocusMoverTestComponent />\n        </ViewWin32>\n      );\n    },\n  },\n  {\n    title: 'KeyboardEvents example',\n    description: 'Native keyboarding has been prevented',\n    render(): JSX.Element {\n      return <KeyboardTestComponent />;\n    },\n  },\n  {\n    title: 'Hover example',\n    description: 'Hover a rainbow',\n    render(): JSX.Element {\n      return <HoverExample />;\n    },\n  },\n  {\n    title: 'Tooltip example',\n    description: 'Displays a tooltip on hover',\n    render(): JSX.Element {\n      return <ToolTipExample />;\n    },\n  },\n  {\n    title: 'Cursor example',\n    description: 'Each of these boxes should display a different cursor',\n    render(): JSX.Element {\n      return <CursorExample />;\n    },\n  },\n  {\n    title: 'EnableFocusRing example',\n    description: 'Displays focus visuals that are driven by native',\n    render(): JSX.Element {\n      return <EnableFocusRingExample />;\n    },\n  },\n];\n"]}