@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

package/dist/cjs/TextInput/index.cjs

@@ -0,0 +1,396 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TextInput_exports = {};
+__export(TextInput_exports, {
+  TextInput: () => TextInput,
+  default: () => TextInput_default
+});
+module.exports = __toCommonJS(TextInput_exports);
+var React = __toESM(require("react"), 1);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_react_native_web_internals2 = require("@hanzogui/react-native-web-internals");
+var import_createElement = require("../createElement/index.cjs");
+const isSelectionStale = (node, selection) => {
+  const {
+    selectionEnd,
+    selectionStart
+  } = node;
+  const {
+    start,
+    end
+  } = selection;
+  return start !== selectionStart || end !== selectionEnd;
+};
+const setSelection = (node, selection) => {
+  if (isSelectionStale(node, selection)) {
+    const {
+      start,
+      end
+    } = selection;
+    try {
+      node.setSelectionRange(start, end || start);
+    } catch (e) {}
+  }
+};
+const forwardPropsList = Object.assign({}, import_react_native_web_internals2.forwardedProps.defaultProps, import_react_native_web_internals2.forwardedProps.accessibilityProps, import_react_native_web_internals2.forwardedProps.clickProps, import_react_native_web_internals2.forwardedProps.focusProps, import_react_native_web_internals2.forwardedProps.keyboardProps, import_react_native_web_internals2.forwardedProps.mouseProps, import_react_native_web_internals2.forwardedProps.touchProps, import_react_native_web_internals2.forwardedProps.styleProps, {
+  autoCapitalize: true,
+  className: true,
+  autoComplete: true,
+  autoCorrect: true,
+  autoFocus: true,
+  defaultValue: true,
+  disabled: true,
+  lang: true,
+  maxLength: true,
+  onChange: true,
+  onScroll: true,
+  placeholder: true,
+  pointerEvents: true,
+  readOnly: true,
+  rows: true,
+  spellCheck: true,
+  value: true,
+  type: true
+});
+const pickProps = props => (0, import_react_native_web_internals2.pick)(props, forwardPropsList);
+const useIsomorphicLayoutEffect = typeof window === "undefined" ? React.useEffect : React.useLayoutEffect;
+function isEventComposing(nativeEvent) {
+  return nativeEvent.isComposing || nativeEvent.keyCode === 229;
+}
+let focusTimeout = null;
+const TextInput = React.forwardRef((props, forwardedRef) => {
+  const {
+    autoCapitalize = "sentences",
+    autoComplete,
+    autoCompleteType,
+    autoCorrect = true,
+    blurOnSubmit,
+    clearTextOnFocus,
+    dir,
+    editable,
+    enterKeyHint,
+    inputMode = "text",
+    keyboardType,
+    multiline = false,
+    numberOfLines,
+    onBlur,
+    onChange,
+    onChangeText,
+    onContentSizeChange,
+    onFocus,
+    onKeyPress,
+    onLayout,
+    onMoveShouldSetResponder,
+    onMoveShouldSetResponderCapture,
+    onResponderEnd,
+    onResponderGrant,
+    onResponderMove,
+    onResponderReject,
+    onResponderRelease,
+    onResponderStart,
+    onResponderTerminate,
+    onResponderTerminationRequest,
+    onScrollShouldSetResponder,
+    onScrollShouldSetResponderCapture,
+    onSelectionChange,
+    onSelectionChangeShouldSetResponder,
+    onSelectionChangeShouldSetResponderCapture,
+    onStartShouldSetResponder,
+    onStartShouldSetResponderCapture,
+    onSubmitEditing,
+    placeholderTextColor,
+    readOnly = false,
+    returnKeyType,
+    rows = 1,
+    secureTextEntry = false,
+    selection,
+    selectTextOnFocus,
+    showSoftInputOnFocus,
+    caretHidden,
+    spellCheck
+  } = props;
+  let type;
+  let _inputMode;
+  if (inputMode != null) {
+    _inputMode = inputMode;
+    if (inputMode === "email") {
+      type = "email";
+    } else if (inputMode === "tel") {
+      type = "tel";
+    } else if (inputMode === "search") {
+      type = "search";
+    } else if (inputMode === "url") {
+      type = "url";
+    } else {
+      type = "text";
+    }
+  } else if (keyboardType != null) {
+    warn("keyboardType", "keyboardType is deprecated. Use inputMode.");
+    switch (keyboardType) {
+      case "email-address":
+        type = "email";
+        break;
+      case "number-pad":
+      case "numeric":
+        _inputMode = "numeric";
+        break;
+      case "decimal-pad":
+        _inputMode = "decimal";
+        break;
+      case "phone-pad":
+        type = "tel";
+        break;
+      case "search":
+      case "web-search":
+        type = "search";
+        break;
+      case "url":
+        type = "url";
+        break;
+      default:
+        type = "text";
+    }
+  }
+  if (secureTextEntry) {
+    type = "password";
+  }
+  const dimensions = React.useRef({
+    height: null,
+    width: null
+  });
+  const hostRef = React.useRef(null);
+  const handleContentSizeChange = React.useCallback(hostNode => {
+    if (multiline && onContentSizeChange && hostNode != null) {
+      const newHeight = hostNode.scrollHeight;
+      const newWidth = hostNode.scrollWidth;
+      if (newHeight !== dimensions.current.height || newWidth !== dimensions.current.width) {
+        dimensions.current.height = newHeight;
+        dimensions.current.width = newWidth;
+        onContentSizeChange({
+          nativeEvent: {
+            contentSize: {
+              height: dimensions.current.height,
+              width: dimensions.current.width
+            }
+          }
+        });
+      }
+    }
+  }, [multiline, onContentSizeChange]);
+  const imperativeRef = React.useMemo(() => hostNode => {
+    if (hostNode != null) {
+      hostNode.clear = () => {
+        if (hostNode != null) {
+          hostNode.value = "";
+        }
+      };
+      hostNode.isFocused = () => hostNode != null && import_react_native_web_internals2.TextInputState.currentlyFocusedField() === hostNode;
+      handleContentSizeChange(hostNode);
+    }
+  }, [handleContentSizeChange]);
+  function handleBlur(e) {
+    import_react_native_web_internals2.TextInputState._currentlyFocusedNode = null;
+    if (onBlur) {
+      e.nativeEvent.text = e.target.value;
+      onBlur(e);
+    }
+  }
+  function handleChange(e) {
+    const hostNode = e.target;
+    const text = hostNode.value;
+    e.nativeEvent.text = text;
+    handleContentSizeChange(hostNode);
+    if (onChange) {
+      onChange(e);
+    }
+    if (onChangeText) {
+      onChangeText(text);
+    }
+  }
+  function handleFocus(e) {
+    const hostNode = e.target;
+    if (onFocus) {
+      e.nativeEvent.text = hostNode.value;
+      onFocus(e);
+    }
+    if (hostNode != null) {
+      import_react_native_web_internals2.TextInputState._currentlyFocusedNode = hostNode;
+      if (clearTextOnFocus) {
+        hostNode.value = "";
+      }
+      if (selectTextOnFocus) {
+        if (focusTimeout != null) {
+          clearTimeout(focusTimeout);
+        }
+        focusTimeout = setTimeout(() => {
+          if (hostNode != null) {
+            hostNode.select();
+          }
+        }, 0);
+      }
+    }
+  }
+  function handleKeyDown(e) {
+    const hostNode = e.target;
+    e.stopPropagation();
+    const blurOnSubmitDefault = !multiline;
+    const shouldBlurOnSubmit = blurOnSubmit == null ? blurOnSubmitDefault : blurOnSubmit;
+    const nativeEvent = e.nativeEvent;
+    const isComposing = isEventComposing(nativeEvent);
+    if (onKeyPress) {
+      onKeyPress(e);
+    }
+    if (e.key === "Enter" && !e.shiftKey &&
+    // Do not call submit if composition is occuring.
+    !isComposing && !e.isDefaultPrevented()) {
+      if ((blurOnSubmit || !multiline) && onSubmitEditing) {
+        e.preventDefault();
+        nativeEvent.text = e.target.value;
+        onSubmitEditing(e);
+      }
+      if (shouldBlurOnSubmit && hostNode != null) {
+        setTimeout(() => hostNode.blur(), 0);
+      }
+    }
+  }
+  function handleSelectionChange(e) {
+    if (onSelectionChange) {
+      try {
+        const node = e.target;
+        const {
+          selectionStart,
+          selectionEnd
+        } = node;
+        e.nativeEvent.selection = {
+          start: selectionStart,
+          end: selectionEnd
+        };
+        e.nativeEvent.text = e.target.value;
+        onSelectionChange(e);
+      } catch (e2) {}
+    }
+  }
+  useIsomorphicLayoutEffect(() => {
+    const node = hostRef.current;
+    if (node != null && selection != null) {
+      setSelection(node, selection);
+    }
+    if (document.activeElement === node) {
+      import_react_native_web_internals2.TextInputState._currentlyFocusedNode = node;
+    }
+  }, [hostRef, selection]);
+  const component = multiline ? "textarea" : "input";
+  (0, import_react_native_web_internals2.useElementLayout)(hostRef, onLayout);
+  (0, import_react_native_web_internals2.useResponderEvents)(hostRef, {
+    onMoveShouldSetResponder,
+    onMoveShouldSetResponderCapture,
+    onResponderEnd,
+    onResponderGrant,
+    onResponderMove,
+    onResponderReject,
+    onResponderRelease,
+    onResponderStart,
+    onResponderTerminate,
+    onResponderTerminationRequest,
+    onScrollShouldSetResponder,
+    onScrollShouldSetResponderCapture,
+    onSelectionChangeShouldSetResponder,
+    onSelectionChangeShouldSetResponderCapture,
+    onStartShouldSetResponder,
+    onStartShouldSetResponderCapture
+  });
+  const {
+    direction: contextDirection
+  } = (0, import_react_native_web_internals2.useLocaleContext)();
+  const supportedProps = pickProps(props);
+  supportedProps.autoCapitalize = autoCapitalize;
+  supportedProps.autoComplete = autoComplete || autoCompleteType || "on";
+  supportedProps.autoCorrect = autoCorrect ? "on" : "off";
+  supportedProps.dir = dir !== void 0 ? dir : "auto";
+  if (returnKeyType != null) {
+    warn("returnKeyType", "returnKeyType is deprecated. Use enterKeyHint.");
+  }
+  supportedProps.enterKeyHint = enterKeyHint || returnKeyType;
+  supportedProps.inputMode = _inputMode;
+  supportedProps.onBlur = handleBlur;
+  supportedProps.onChange = handleChange;
+  supportedProps.onFocus = handleFocus;
+  supportedProps.onKeyDown = handleKeyDown;
+  supportedProps.onSelect = handleSelectionChange;
+  if (editable != null) {
+    warn("editable", "editable is deprecated. Use readOnly.");
+  }
+  supportedProps.readOnly = readOnly === true || editable === false;
+  if (numberOfLines != null) {
+    warn("numberOfLines", "TextInput numberOfLines is deprecated. Use rows.");
+  }
+  supportedProps.rows = multiline ? rows != null ? rows : numberOfLines : 1;
+  supportedProps.spellCheck = spellCheck != null ? spellCheck : autoCorrect;
+  supportedProps.style = [{
+    "--placeholderTextColor": placeholderTextColor
+  }, styles.textinput$raw, styles.placeholder, props.style, caretHidden && styles.caretHidden];
+  supportedProps.type = multiline ? void 0 : type;
+  supportedProps.virtualkeyboardpolicy = showSoftInputOnFocus === false ? "manual" : "auto";
+  const platformMethodsRef = (0, import_react_native_web_internals2.usePlatformMethods)(supportedProps);
+  const setRef = (0, import_react_native_web_internals2.useMergeRefs)(hostRef, platformMethodsRef, imperativeRef, forwardedRef);
+  supportedProps.ref = setRef;
+  const langDirection = props.lang != null ? (0, import_react_native_web_internals2.getLocaleDirection)(props.lang) : null;
+  const componentDirection = props.dir || langDirection;
+  const writingDirection = componentDirection || contextDirection;
+  const element = (0, import_createElement.useCreateElement)(component, supportedProps, {
+    writingDirection
+  });
+  return element;
+});
+function warn(...args) {
+  if (process.env.NODE_ENV !== "production") {
+    console.warn(...args);
+  }
+}
+TextInput.displayName = "TextInput";
+TextInput.State = import_react_native_web_internals2.TextInputState;
+const styles = import_react_native_web_internals.StyleSheet.create({
+  textinput$raw: {
+    MozAppearance: "textfield",
+    WebkitAppearance: "none",
+    appearance: "none"
+  },
+  placeholder: {
+    placeholderTextColor: "var(--placeholderTextColor)"
+  },
+  caretHidden: {
+    caretColor: "transparent"
+  }
+});
+var TextInput_default = TextInput;

package/dist/cjs/TextInput/types.cjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/TouchableNativeFeedback.cjs

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TouchableNativeFeedback_exports = {};
+__export(TouchableNativeFeedback_exports, {
+  TouchableNativeFeedback: () => import_UnimplementedView.UnimplementedView
+});
+module.exports = __toCommonJS(TouchableNativeFeedback_exports);
+var import_UnimplementedView = require("./UnimplementedView.cjs");

package/dist/cjs/TouchableOpacity.cjs

@@ -0,0 +1,125 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TouchableOpacity_exports = {};
+__export(TouchableOpacity_exports, {
+  TouchableOpacity: () => TouchableOpacity
+});
+module.exports = __toCommonJS(TouchableOpacity_exports);
+var React = __toESM(require("react"), 1);
+var import_react = require("react");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_View = require("./View/index.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+function TouchableOpacityImpl(props, forwardedRef) {
+  const {
+    activeOpacity,
+    delayPressIn,
+    delayPressOut,
+    delayLongPress,
+    disabled,
+    focusable,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    rejectResponderTermination,
+    style,
+    ...rest
+  } = props;
+  const hostRef = (0, import_react.useRef)(null);
+  const setRef = (0, import_react_native_web_internals.useMergeRefs)(forwardedRef, hostRef);
+  const [duration, setDuration] = (0, import_react.useState)("0s");
+  const [opacityOverride, setOpacityOverride] = (0, import_react.useState)(null);
+  const setOpacityTo = (0, import_react.useCallback)((value, duration2) => {
+    setOpacityOverride(value);
+    setDuration(duration2 ? `${duration2 / 1e3}s` : "0s");
+  }, [setOpacityOverride, setDuration]);
+  const setOpacityActive = (0, import_react.useCallback)(duration2 => {
+    setOpacityTo(activeOpacity ?? 0.2, duration2);
+  }, [activeOpacity, setOpacityTo]);
+  const setOpacityInactive = (0, import_react.useCallback)(duration2 => {
+    setOpacityTo(null, duration2);
+  }, [setOpacityTo]);
+  const pressConfig = (0, import_react.useMemo)(() => ({
+    cancelable: !rejectResponderTermination,
+    disabled,
+    delayLongPress,
+    delayPressStart: delayPressIn,
+    delayPressEnd: delayPressOut,
+    onLongPress,
+    onPress,
+    onPressStart(event) {
+      const 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]);
+  const pressEventHandlers = (0, import_react_native_web_internals.usePressEvents)(hostRef, pressConfig);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_View.View, {
+    ...rest,
+    ...pressEventHandlers,
+    accessibilityDisabled: disabled,
+    focusable: !disabled && focusable !== false,
+    ref: setRef,
+    style: [styles.root, !disabled && styles.actionable, style, opacityOverride != null && {
+      opacity: opacityOverride
+    }, {
+      transitionDuration: duration
+    }]
+  });
+}
+const styles = import_react_native_web_internals.StyleSheet.create({
+  root: {
+    transitionProperty: "opacity",
+    transitionDuration: "0.15s",
+    userSelect: "none"
+  },
+  actionable: {
+    cursor: "pointer",
+    touchAction: "manipulation"
+  }
+});
+const TouchableOpacity = React.memo(React.forwardRef(TouchableOpacityImpl));
+TouchableOpacity.displayName = "TouchableOpacity";
+TouchableOpacity.Mixin = {};

package/dist/cjs/TouchableWithoutFeedback.cjs

@@ -0,0 +1,95 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TouchableWithoutFeedback_exports = {};
+__export(TouchableWithoutFeedback_exports, {
+  TouchableWithoutFeedback: () => TouchableWithoutFeedback
+});
+module.exports = __toCommonJS(TouchableWithoutFeedback_exports);
+var React = __toESM(require("react"), 1);
+var import_react = require("react");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+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
+};
+const pickProps = props => (0, import_react_native_web_internals.pick)(props, forwardPropsList);
+function TouchableWithoutFeedbackImpl(props, forwardedRef) {
+  const {
+    delayPressIn,
+    delayPressOut,
+    delayLongPress,
+    disabled,
+    focusable,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    rejectResponderTermination
+  } = props;
+  const hostRef = (0, import_react.useRef)(null);
+  const pressConfig = (0, import_react.useMemo)(() => ({
+    cancelable: !rejectResponderTermination,
+    disabled,
+    delayLongPress,
+    delayPressStart: delayPressIn,
+    delayPressEnd: delayPressOut,
+    onLongPress,
+    onPress,
+    onPressStart: onPressIn,
+    onPressEnd: onPressOut
+  }), [disabled, delayPressIn, delayPressOut, delayLongPress, onLongPress, onPress, onPressIn, onPressOut, rejectResponderTermination]);
+  const pressEventHandlers = (0, import_react_native_web_internals.usePressEvents)(hostRef, pressConfig);
+  const element = React.Children.only(props.children);
+  const children = [element.props.children];
+  const supportedProps = pickProps(props);
+  supportedProps.accessibilityDisabled = disabled;
+  supportedProps.focusable = !disabled && focusable !== false;
+  supportedProps.ref = (0, import_react_native_web_internals.useMergeRefs)(forwardedRef, hostRef, element.ref);
+  const elementProps = Object.assign(supportedProps, pressEventHandlers);
+  return React.cloneElement(element, elementProps, ...children);
+}
+const TouchableWithoutFeedback = React.memo(React.forwardRef(TouchableWithoutFeedbackImpl));
+TouchableWithoutFeedback.displayName = "TouchableWithoutFeedback";