@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/exports/TouchableHighlight/index.js

@@ -0,0 +1,148 @@
+/**
+ * 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
+ */
+
+'use client';
+
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+var _excluded = ["activeOpacity", "children", "delayPressIn", "delayPressOut", "delayLongPress", "disabled", "focusable", "isTVSelectable", "onHideUnderlay", "onLongPress", "onPress", "onPressIn", "onPressOut", "onShowUnderlay", "rejectResponderTermination", "style", "testOnly_pressed", "underlayColor"];
+import * as React from 'react';
+import { useCallback, useMemo, useState, useRef } from 'react';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+//import { warnOnce } from '../../modules/warnOnce';
+
+function createExtraStyles(activeOpacity, underlayColor) {
+  return {
+    child: {
+      opacity: activeOpacity !== null && activeOpacity !== void 0 ? activeOpacity : 0.85
+    },
+    underlay: {
+      backgroundColor: underlayColor === undefined ? 'black' : underlayColor
+    }
+  };
+}
+function hasPressHandler(props) {
+  return props.onPress != null || props.onPressIn != null || props.onPressOut != null || props.onLongPress != null;
+}
+
+/**
+ * A wrapper for making views respond properly to touches.
+ * On press down, the opacity of the wrapped view is decreased, which allows
+ * the underlay color to show through, darkening or tinting the view.
+ *
+ * The underlay comes from wrapping the child in a new View, which can affect
+ * layout, and sometimes cause unwanted visual artifacts if not used correctly,
+ * for example if the backgroundColor of the wrapped view isn't explicitly set
+ * to an opaque color.
+ *
+ * TouchableHighlight must have one child (not zero or more than one).
+ * If you wish to have several child components, wrap them in a View.
+ */
+function TouchableHighlight(props, forwardedRef) {
+  /*
+  warnOnce(
+    'TouchableHighlight',
+    'TouchableHighlight is deprecated. Please use Pressable.'
+  );
+  */
+
+  var activeOpacity = props.activeOpacity,
+    children = props.children,
+    delayPressIn = props.delayPressIn,
+    delayPressOut = props.delayPressOut,
+    delayLongPress = props.delayLongPress,
+    disabled = props.disabled,
+    focusable = props.focusable,
+    isTVSelectable = props.isTVSelectable,
+    onHideUnderlay = props.onHideUnderlay,
+    onLongPress = props.onLongPress,
+    onPress = props.onPress,
+    onPressIn = props.onPressIn,
+    onPressOut = props.onPressOut,
+    onShowUnderlay = props.onShowUnderlay,
+    rejectResponderTermination = props.rejectResponderTermination,
+    style = props.style,
+    testOnly_pressed = props.testOnly_pressed,
+    underlayColor = props.underlayColor,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var hostRef = useRef(null);
+  var setRef = useMergeRefs(forwardedRef, hostRef);
+  var _useState = useState(testOnly_pressed === true ? createExtraStyles(activeOpacity, underlayColor) : null),
+    extraStyles = _useState[0],
+    setExtraStyles = _useState[1];
+  var showUnderlay = useCallback(() => {
+    if (!hasPressHandler(props)) {
+      return;
+    }
+    setExtraStyles(createExtraStyles(activeOpacity, underlayColor));
+    if (onShowUnderlay != null) {
+      onShowUnderlay();
+    }
+  }, [activeOpacity, onShowUnderlay, props, underlayColor]);
+  var hideUnderlay = useCallback(() => {
+    if (testOnly_pressed === true) {
+      return;
+    }
+    if (hasPressHandler(props)) {
+      setExtraStyles(null);
+      if (onHideUnderlay != null) {
+        onHideUnderlay();
+      }
+    }
+  }, [onHideUnderlay, props, testOnly_pressed]);
+  var pressConfig = useMemo(() => ({
+    cancelable: !rejectResponderTermination,
+    disabled,
+    delayLongPress,
+    delayPressStart: delayPressIn,
+    delayPressEnd: delayPressOut,
+    onLongPress,
+    onPress,
+    onPressStart(event) {
+      showUnderlay();
+      if (onPressIn != null) {
+        onPressIn(event);
+      }
+    },
+    onPressEnd(event) {
+      hideUnderlay();
+      if (onPressOut != null) {
+        onPressOut(event);
+      }
+    }
+  }), [delayLongPress, delayPressIn, delayPressOut, disabled, onLongPress, onPress, onPressIn, onPressOut, rejectResponderTermination, showUnderlay, hideUnderlay]);
+  var pressEventHandlers = usePressEvents(hostRef, pressConfig);
+  var child = React.Children.only(children);
+  return /*#__PURE__*/React.createElement(View, _extends({}, rest, pressEventHandlers, {
+    accessibilityDisabled: disabled,
+    focusable: !disabled && focusable !== false,
+    pointerEvents: disabled ? 'box-none' : undefined,
+    ref: setRef,
+    style: [styles.root, style, !disabled && styles.actionable, extraStyles && extraStyles.underlay],
+    tabIndex: focusable !== false && isTVSelectable !== false ? 0 : -1
+  }), /*#__PURE__*/React.cloneElement(child, {
+    style: [child.props.style, extraStyles && extraStyles.child]
+  }));
+}
+var styles = StyleSheet.create({
+  root: {
+    userSelect: 'none'
+  },
+  actionable: {
+    cursor: 'pointer',
+    touchAction: 'manipulation'
+  }
+});
+var MemoedTouchableHighlight = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef(TouchableHighlight));
+MemoedTouchableHighlight.displayName = 'TouchableHighlight';
+export default MemoedTouchableHighlight;

package/dist/exports/TouchableHighlight/index.js.flow

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use client';
+
+import type { ColorValue } from '../../types';
+import type { Props as TouchableWithoutFeedbackProps } from '../TouchableWithoutFeedback';
+import type { ViewProps } from '../View';
+import type { TVViewProps } from '../TV/types';
+import * as React from 'react';
+import { useCallback, useMemo, useState, useRef } from 'react';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+//import { warnOnce } from '../../modules/warnOnce';
+
+type ViewStyle = $PropertyType<ViewProps, 'style'>;
+type Props = $ReadOnly<{|
+  ...TouchableWithoutFeedbackProps,
+  ...TVViewProps,
+  activeOpacity?: ?number,
+  onHideUnderlay?: ?() => void,
+  onShowUnderlay?: ?() => void,
+  style?: ViewStyle,
+  testOnly_pressed?: ?boolean,
+  underlayColor?: ?ColorValue,
+|}>;
+type ExtraStyles = $ReadOnly<{|
+  child: ViewStyle,
+  underlay: ViewStyle,
+|}>;
+declare function createExtraStyles(activeOpacity: any, underlayColor: any): ExtraStyles;
+declare function hasPressHandler(props: any): boolean;
+/**
+ * A wrapper for making views respond properly to touches.
+ * On press down, the opacity of the wrapped view is decreased, which allows
+ * the underlay color to show through, darkening or tinting the view.
+ *
+ * The underlay comes from wrapping the child in a new View, which can affect
+ * layout, and sometimes cause unwanted visual artifacts if not used correctly,
+ * for example if the backgroundColor of the wrapped view isn't explicitly set
+ * to an opaque color.
+ *
+ * TouchableHighlight must have one child (not zero or more than one).
+ * If you wish to have several child components, wrap them in a View.
+ */
+declare function TouchableHighlight(props: Props, forwardedRef: any): React.Node;
+const styles = StyleSheet.create({
+  root: {
+    userSelect: 'none'
+  },
+  actionable: {
+    cursor: 'pointer',
+    touchAction: 'manipulation'
+  }
+});
+const MemoedTouchableHighlight = React.memo(React.forwardRef(TouchableHighlight));
+MemoedTouchableHighlight.displayName = 'TouchableHighlight';
+export default (MemoedTouchableHighlight: React.AbstractComponent<Props, React.ElementRef<typeof View>>);

package/dist/exports/TouchableNativeFeedback/index.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import UnimplementedView from '../../modules/UnimplementedView';
+export default UnimplementedView;

package/dist/exports/TouchableNativeFeedback/index.js.flow

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import UnimplementedView from '../../modules/UnimplementedView';
+export default UnimplementedView;

package/dist/exports/TouchableOpacity/index.js

@@ -0,0 +1,117 @@
+/**
+ * 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
+ */
+
+'use client';
+
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+var _excluded = ["activeOpacity", "delayPressIn", "delayPressOut", "delayLongPress", "disabled", "focusable", "isTVSelectable", "onLongPress", "onPress", "onPressIn", "onPressOut", "rejectResponderTermination", "style"];
+import * as React from 'react';
+import { useCallback, useMemo, useState, useRef } from 'react';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+//import { warnOnce } from '../../modules/warnOnce';
+
+/**
+ * A wrapper for making views respond properly to touches.
+ * On press down, the opacity of the wrapped view is decreased, dimming it.
+ */
+function TouchableOpacity(props, forwardedRef) {
+  /*
+  warnOnce(
+    'TouchableOpacity',
+    'TouchableOpacity is deprecated. Please use Pressable.'
+  );
+  */
+
+  var activeOpacity = props.activeOpacity,
+    delayPressIn = props.delayPressIn,
+    delayPressOut = props.delayPressOut,
+    delayLongPress = props.delayLongPress,
+    disabled = props.disabled,
+    focusable = props.focusable,
+    isTVSelectable = props.isTVSelectable,
+    onLongPress = props.onLongPress,
+    onPress = props.onPress,
+    onPressIn = props.onPressIn,
+    onPressOut = props.onPressOut,
+    rejectResponderTermination = props.rejectResponderTermination,
+    style = props.style,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var hostRef = useRef(null);
+  var setRef = useMergeRefs(forwardedRef, hostRef);
+  var _useState = useState('0s'),
+    duration = _useState[0],
+    setDuration = _useState[1];
+  var _useState2 = useState(null),
+    opacityOverride = _useState2[0],
+    setOpacityOverride = _useState2[1];
+  var setOpacityTo = useCallback((value, duration) => {
+    setOpacityOverride(value);
+    setDuration(duration ? duration / 1000 + "s" : '0s');
+  }, [setOpacityOverride, setDuration]);
+  var setOpacityActive = useCallback(duration => {
+    setOpacityTo(activeOpacity !== null && activeOpacity !== void 0 ? activeOpacity : 0.2, duration);
+  }, [activeOpacity, setOpacityTo]);
+  var setOpacityInactive = useCallback(duration => {
+    setOpacityTo(null, duration);
+  }, [setOpacityTo]);
+  var pressConfig = useMemo(() => ({
+    cancelable: !rejectResponderTermination,
+    disabled,
+    delayLongPress,
+    delayPressStart: delayPressIn,
+    delayPressEnd: delayPressOut,
+    onLongPress,
+    onPress,
+    onPressStart(event) {
+      var isGrant = event.dispatchConfig != null ? event.dispatchConfig.registrationName === 'onResponderGrant' : event.type === 'keydown';
+      setOpacityActive(isGrant ? 0 : 150);
+      if (onPressIn != null) {
+        onPressIn(event);
+      }
+    },
+    onPressEnd(event) {
+      setOpacityInactive(250);
+      if (onPressOut != null) {
+        onPressOut(event);
+      }
+    }
+  }), [delayLongPress, delayPressIn, delayPressOut, disabled, onLongPress, onPress, onPressIn, onPressOut, rejectResponderTermination, setOpacityActive, setOpacityInactive]);
+  var pressEventHandlers = usePressEvents(hostRef, pressConfig);
+  return /*#__PURE__*/React.createElement(View, _extends({}, rest, pressEventHandlers, {
+    accessibilityDisabled: disabled,
+    focusable: !disabled && focusable !== false,
+    pointerEvents: disabled ? 'box-none' : undefined,
+    ref: setRef,
+    style: [styles.root, !disabled && styles.actionable, style, opacityOverride != null && {
+      opacity: opacityOverride
+    }, {
+      transitionDuration: duration
+    }],
+    tabIndex: focusable !== false && isTVSelectable !== false ? 0 : -1
+  }));
+}
+var styles = StyleSheet.create({
+  root: {
+    transitionProperty: 'opacity',
+    transitionDuration: '0.15s',
+    userSelect: 'none'
+  },
+  actionable: {
+    cursor: 'pointer',
+    touchAction: 'manipulation'
+  }
+});
+var MemoedTouchableOpacity = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef(TouchableOpacity));
+MemoedTouchableOpacity.displayName = 'TouchableOpacity';
+export default MemoedTouchableOpacity;

package/dist/exports/TouchableOpacity/index.js.flow

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use client';
+
+import type { Props as TouchableWithoutFeedbackProps } from '../TouchableWithoutFeedback';
+import type { TVViewProps } from '../TV/types';
+import type { ViewProps } from '../View';
+import * as React from 'react';
+import { useCallback, useMemo, useState, useRef } from 'react';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+//import { warnOnce } from '../../modules/warnOnce';
+
+type ViewStyle = $PropertyType<ViewProps, 'style'>;
+type Props = $ReadOnly<{|
+  ...TouchableWithoutFeedbackProps,
+  ...TVViewProps,
+  activeOpacity?: ?number,
+  style?: ?ViewStyle,
+|}>;
+
+/**
+ * A wrapper for making views respond properly to touches.
+ * On press down, the opacity of the wrapped view is decreased, dimming it.
+ */
+declare function TouchableOpacity(props: Props, forwardedRef: any): React.Node;
+const styles = StyleSheet.create({
+  root: {
+    transitionProperty: 'opacity',
+    transitionDuration: '0.15s',
+    userSelect: 'none'
+  },
+  actionable: {
+    cursor: 'pointer',
+    touchAction: 'manipulation'
+  }
+});
+const MemoedTouchableOpacity = React.memo(React.forwardRef(TouchableOpacity));
+MemoedTouchableOpacity.displayName = 'TouchableOpacity';
+export default (MemoedTouchableOpacity: React.AbstractComponent<Props, React.ElementRef<typeof View>>);

package/dist/exports/TouchableWithoutFeedback/index.js

@@ -0,0 +1,72 @@
+/**
+ * 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
+ */
+
+'use client';
+
+import * as React from 'react';
+import { useMemo, useRef } from 'react';
+import pick from '../../modules/pick';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import { warnOnce } from '../../modules/warnOnce';
+var forwardPropsList = {
+  accessibilityDisabled: true,
+  accessibilityLabel: true,
+  accessibilityLiveRegion: true,
+  accessibilityRole: true,
+  accessibilityState: true,
+  accessibilityValue: true,
+  children: true,
+  disabled: true,
+  focusable: true,
+  nativeID: true,
+  onBlur: true,
+  onFocus: true,
+  onLayout: true,
+  testID: true
+};
+var pickProps = props => pick(props, forwardPropsList);
+function TouchableWithoutFeedback(props, forwardedRef) {
+  warnOnce('TouchableWithoutFeedback', 'TouchableWithoutFeedback is deprecated. Please use Pressable.');
+  var delayPressIn = props.delayPressIn,
+    delayPressOut = props.delayPressOut,
+    delayLongPress = props.delayLongPress,
+    disabled = props.disabled,
+    focusable = props.focusable,
+    onLongPress = props.onLongPress,
+    onPress = props.onPress,
+    onPressIn = props.onPressIn,
+    onPressOut = props.onPressOut,
+    rejectResponderTermination = props.rejectResponderTermination;
+  var hostRef = useRef(null);
+  var pressConfig = useMemo(() => ({
+    cancelable: !rejectResponderTermination,
+    disabled,
+    delayLongPress,
+    delayPressStart: delayPressIn,
+    delayPressEnd: delayPressOut,
+    onLongPress,
+    onPress,
+    onPressStart: onPressIn,
+    onPressEnd: onPressOut
+  }), [disabled, delayPressIn, delayPressOut, delayLongPress, onLongPress, onPress, onPressIn, onPressOut, rejectResponderTermination]);
+  var pressEventHandlers = usePressEvents(hostRef, pressConfig);
+  var element = React.Children.only(props.children);
+  var children = [element.props.children];
+  var supportedProps = pickProps(props);
+  supportedProps.accessibilityDisabled = disabled;
+  supportedProps.focusable = !disabled && focusable !== false;
+  supportedProps.ref = useMergeRefs(forwardedRef, hostRef, element.ref);
+  var elementProps = Object.assign(supportedProps, pressEventHandlers);
+  return /*#__PURE__*/React.cloneElement(element, elementProps, ...children);
+}
+var MemoedTouchableWithoutFeedback = /*#__PURE__*/React.memo(/*#__PURE__*/React.forwardRef(TouchableWithoutFeedback));
+MemoedTouchableWithoutFeedback.displayName = 'TouchableWithoutFeedback';
+export default MemoedTouchableWithoutFeedback;

package/dist/exports/TouchableWithoutFeedback/index.js.flow

@@ -0,0 +1,65 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use client';
+
+import type { PressResponderConfig } from '../../modules/usePressEvents/PressResponder';
+import type { TVParallaxPropertiesType } from '../TV/types';
+import type { ViewProps } from '../View';
+import * as React from 'react';
+import { useMemo, useRef } from 'react';
+import pick from '../../modules/pick';
+import useMergeRefs from '../../modules/useMergeRefs';
+import usePressEvents from '../../modules/usePressEvents';
+import { warnOnce } from '../../modules/warnOnce';
+export type Props = $ReadOnly<{|
+  accessibilityLabel?: $PropertyType<ViewProps, 'accessibilityLabel'>,
+  accessibilityLiveRegion?: $PropertyType<ViewProps, 'accessibilityLiveRegion'>,
+  accessibilityRole?: $PropertyType<ViewProps, 'accessibilityRole'>,
+  children?: ?React.Node,
+  delayLongPress?: ?number,
+  delayPressIn?: ?number,
+  delayPressOut?: ?number,
+  disabled?: ?boolean,
+  focusable?: ?boolean,
+  nativeID?: $PropertyType<ViewProps, 'nativeID'>,
+  onBlur?: $PropertyType<ViewProps, 'onBlur'>,
+  onFocus?: $PropertyType<ViewProps, 'onFocus'>,
+  onLayout?: $PropertyType<ViewProps, 'onLayout'>,
+  onLongPress?: $PropertyType<PressResponderConfig, 'onLongPress'>,
+  onPress?: $PropertyType<PressResponderConfig, 'onPress'>,
+  onPressIn?: $PropertyType<PressResponderConfig, 'onPressStart'>,
+  onPressOut?: $PropertyType<PressResponderConfig, 'onPressEnd'>,
+  rejectResponderTermination?: ?boolean,
+  testID?: $PropertyType<ViewProps, 'testID'>,
+  // Not used yet, probably never will be is is for iOS only
+  tvParallaxProperties?: TVParallaxPropertiesType,
+|}>;
+const forwardPropsList = {
+  accessibilityDisabled: true,
+  accessibilityLabel: true,
+  accessibilityLiveRegion: true,
+  accessibilityRole: true,
+  accessibilityState: true,
+  accessibilityValue: true,
+  children: true,
+  disabled: true,
+  focusable: true,
+  nativeID: true,
+  onBlur: true,
+  onFocus: true,
+  onLayout: true,
+  testID: true
+};
+declare var pickProps: (props: any) => any;
+declare function TouchableWithoutFeedback(props: Props, forwardedRef: any): React.Node;
+const MemoedTouchableWithoutFeedback = React.memo(React.forwardRef(TouchableWithoutFeedback));
+MemoedTouchableWithoutFeedback.displayName = 'TouchableWithoutFeedback';
+export default (MemoedTouchableWithoutFeedback: React.AbstractComponent<Props, React.ElementRef<any>>);

package/dist/exports/UIManager/index.js

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import getBoundingClientRect from '../../modules/getBoundingClientRect';
+import setValueForStyles from '../../modules/setValueForStyles';
+var getRect = node => {
+  var height = node.offsetHeight;
+  var width = node.offsetWidth;
+  var left = node.offsetLeft;
+  var top = node.offsetTop;
+  node = node.offsetParent;
+  while (node && node.nodeType === 1 /* Node.ELEMENT_NODE */) {
+    left += node.offsetLeft + node.clientLeft - node.scrollLeft;
+    top += node.offsetTop + node.clientTop - node.scrollTop;
+    node = node.offsetParent;
+  }
+  top -= window.scrollY;
+  left -= window.scrollX;
+  return {
+    width,
+    height,
+    top,
+    left
+  };
+};
+var measureLayout = (node, relativeToNativeNode, callback) => {
+  var relativeNode = relativeToNativeNode || node && node.parentNode;
+  if (node && relativeNode) {
+    setTimeout(() => {
+      if (node.isConnected && relativeNode.isConnected) {
+        var relativeRect = getRect(relativeNode);
+        var _getRect = getRect(node),
+          height = _getRect.height,
+          left = _getRect.left,
+          top = _getRect.top,
+          width = _getRect.width;
+        var x = left - relativeRect.left;
+        var y = top - relativeRect.top;
+        callback(x, y, width, height, left, top);
+      }
+    }, 0);
+  }
+};
+var elementsToIgnore = {
+  A: true,
+  BODY: true,
+  INPUT: true,
+  SELECT: true,
+  TEXTAREA: true
+};
+var UIManager = {
+  blur(node) {
+    try {
+      node.blur();
+    } catch (err) {}
+  },
+  focus(node) {
+    try {
+      var name = node.nodeName;
+      // A tabIndex of -1 allows element to be programmatically focused but
+      // prevents keyboard focus. We don't want to set the tabindex value on
+      // elements that should not prevent keyboard focus.
+      if (node.getAttribute('tabIndex') == null && node.isContentEditable !== true && elementsToIgnore[name] == null) {
+        node.setAttribute('tabIndex', '-1');
+      }
+      node.focus();
+    } catch (err) {}
+  },
+  measure(node, callback) {
+    measureLayout(node, null, callback);
+  },
+  measureInWindow(node, callback) {
+    if (node) {
+      setTimeout(() => {
+        var _getBoundingClientRec = getBoundingClientRect(node),
+          height = _getBoundingClientRec.height,
+          left = _getBoundingClientRec.left,
+          top = _getBoundingClientRec.top,
+          width = _getBoundingClientRec.width;
+        callback(left, top, width, height);
+      }, 0);
+    }
+  },
+  measureLayout(node, relativeToNativeNode, onFail, onSuccess) {
+    measureLayout(node, relativeToNativeNode, onSuccess);
+  },
+  updateView(node, props) {
+    for (var prop in props) {
+      if (!Object.prototype.hasOwnProperty.call(props, prop)) {
+        continue;
+      }
+      var value = props[prop];
+      switch (prop) {
+        case 'style':
+          {
+            setValueForStyles(node, value);
+            break;
+          }
+        case 'class':
+        case 'className':
+          {
+            node.setAttribute('class', value);
+            break;
+          }
+        case 'text':
+        case 'value':
+          // native platforms use `text` prop to replace text input value
+          node.value = value;
+          break;
+        default:
+          node.setAttribute(prop, value);
+      }
+    }
+  },
+  configureNextLayoutAnimation(config, onAnimationDidEnd) {
+    onAnimationDidEnd();
+  },
+  // mocks
+  setLayoutAnimationEnabledExperimental() {}
+};
+export default UIManager;