@tamagui/web 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/hooks/useComponentState.cjs

@@ -3,219 +3,197 @@ 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
-  });
+	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;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var useComponentState_exports = {};
-__export(useComponentState_exports, {
-  useComponentState: () => useComponentState
-});
+__export(useComponentState_exports, { useComponentState: () => useComponentState });
 module.exports = __toCommonJS(useComponentState_exports);
 var import_constants = require("@tamagui/constants");
 var import_is_equal_shallow = require("@tamagui/is-equal-shallow");
 var import_use_did_finish_ssr = require("@tamagui/use-did-finish-ssr");
 var import_react = require("react");
 var import_config = require("../config.cjs");
+var import_isOptimizedForFirstRender = require("./isOptimizedForFirstRender.cjs");
 var import_defaultComponentState = require("../defaultComponentState.cjs");
 var import_isObj = require("../helpers/isObj.cjs");
-var import_log = require("../helpers/log.cjs");
 const useComponentState = (props, animationDriver, staticConfig, config) => {
-  "use no memo";
-
-  const isHydrated = (0, import_use_did_finish_ssr.useDidFinishSSR)();
-  const needsHydration = !(0, import_use_did_finish_ssr.useIsClientOnly)();
-  const useAnimations = animationDriver?.isStub ? void 0 : animationDriver?.useAnimations;
-  const {
-    isHOC
-  } = staticConfig;
-  const stateRef = (0, import_react.useRef)(
-  // performance: avoid creating object every render
-  void 0);
-  if (!stateRef.current) {
-    stateRef.current = {
-      startedUnhydrated: needsHydration && !isHydrated
-    };
-  }
-  const hasAnimationProp = Boolean(!isHOC && "transition" in props || props.style && hasAnimatedStyleValue(props.style));
-  const inputStyle = animationDriver?.inputStyle ?? "css";
-  const outputStyle = animationDriver?.outputStyle ?? "css";
-  const curStateRef = stateRef.current;
-  if (!needsHydration && hasAnimationProp) {
-    curStateRef.hasAnimated = true;
-  }
-  const platformPseudo = Boolean(!isHOC && useAnimations && animationDriver?.avoidReRenders && (0, import_constants.getPlatformDriver)()?.pseudo && ("hoverStyle" in props || "pressStyle" in props || "focusStyle" in props));
-  const willBeAnimatedClient = (() => {
-    const next = !!((hasAnimationProp || platformPseudo) && !isHOC && useAnimations);
-    return Boolean(next || curStateRef.hasAnimated);
-  })();
-  const willBeAnimated = !import_constants.isServer && willBeAnimatedClient;
-  if (willBeAnimated && !curStateRef.hasAnimated) {
-    curStateRef.hasAnimated = true;
-  }
-  const {
-    disableClassName
-  } = props;
-  const presence = !isHOC && willBeAnimated && props["animatePresence"] !== false && animationDriver?.usePresence?.() || null;
-  const presenceState = presence?.[2];
-  const isExiting = presenceState?.isPresent === false;
-  const isEntering = presenceState?.isPresent === true && presenceState.initial !== false;
-  const hasEnterStyle = !!props.enterStyle;
-  const hasAnimationThatNeedsHydrate = hasAnimationProp && !isHydrated && (animationDriver?.isReactNative || inputStyle !== "css");
-  const canImmediatelyEnter = hasEnterStyle || isEntering;
-  const shouldEnter = !isHOC && (hasEnterStyle || isEntering || hasAnimationThatNeedsHydrate ||
-  // disableClassName doesnt work server side, only client, so needs hydrate
-  // this is just for a better ux, supports css variables for light/dark, media queries, etc
-  disableClassName);
-  const initialState = shouldEnter ?
-  // on the very first render we switch all spring animation drivers to css rendering
-  // this is because we need to use css variables, which they don't support to do proper SSR
-  // without flickers of the wrong colors.
-  // but once we do that initial hydration and we are in client side rendering mode,
-  // we can avoid the extra re-render on mount
-  canImmediatelyEnter ? import_defaultComponentState.defaultComponentStateShouldEnter : import_defaultComponentState.defaultComponentState : import_defaultComponentState.defaultComponentStateMounted;
-  const disabled = isDisabled(props);
-  if (disabled != null) {
-    initialState.disabled = disabled;
-  }
-  const states = (0, import_react.useState)(initialState);
-  const state = props.forceStyle ? {
-    ...states[0],
-    [props.forceStyle]: true
-  } : states[0];
-  const setState = states[1];
-  let isAnimated = willBeAnimated;
-  if (import_constants.isWeb && hasAnimationThatNeedsHydrate && !staticConfig.isHOC && !isHydrated) {
-    isAnimated = false;
-    curStateRef.willHydrate = true;
-  }
-  if (disabled !== state.disabled) {
-    if (disabled) {
-      Object.assign(state, import_defaultComponentState.defaultComponentStateMounted);
-    }
-    state.disabled = disabled;
-    setState(_ => ({
-      ...state
-    }));
-  }
-  const groupName = props.group;
-  if (!stateRef.current.baseSetStateShallow) {
-    const r = stateRef.current;
-    r.baseSetStateShallow = stateOrGetState => {
-      setState(prev => {
-        const next = typeof stateOrGetState === "function" ? stateOrGetState(prev) : stateOrGetState;
-        const update = (0, import_is_equal_shallow.mergeIfNotShallowEqual)(prev, next);
-        if (process.env.NODE_ENV === "development") {
-          const dbg = r.__debug;
-          if (dbg && update !== prev) {
-            console.groupCollapsed(`setStateShallow CHANGE`, "=>", update);
-            console.info(`previously`, prev);
-            console.trace();
-            console.groupEnd();
-          }
-        }
-        return update;
-      });
-    };
-  }
-  if (process.env.NODE_ENV === "development") {
-    ;
-    stateRef.current.__debug = props.debug;
-  }
-  const setStateShallow = stateRef.current.baseSetStateShallow;
-  if (process.env.NODE_ENV === "development" && globalThis.time) globalThis.time`state-useCreateShallowSetState`;
-  if (presenceState && isAnimated && isHydrated && staticConfig.variants) {
-    if (process.env.NODE_ENV === "development" && props.debug === "verbose") {
-      console.warn(`has presenceState ${JSON.stringify(presenceState)}`);
-    }
-    const {
-      enterVariant,
-      exitVariant,
-      enterExitVariant,
-      custom
-    } = presenceState;
-    if ((0, import_isObj.isObj)(custom)) {
-      Object.assign(props, custom);
-    }
-    const exv = exitVariant ?? enterExitVariant;
-    const env = enterVariant ?? enterExitVariant;
-    if (state.unmounted && env && staticConfig.variants[env]) {
-      if (process.env.NODE_ENV === "development" && props.debug === "verbose") {
-        console.warn(`Animating presence ENTER "${env}"`);
-      }
-      props[env] = true;
-    } else if (isExiting && exv) {
-      if (process.env.NODE_ENV === "development" && props.debug === "verbose") {
-        console.warn(`Animating presence EXIT "${exv}"`);
-      }
-      props[exv] = exitVariant !== enterExitVariant;
-    }
-  }
-  let noClass = !import_constants.isWeb || !!props.forceStyle;
-  if (!isHydrated) {
-    noClass = false;
-  } else {
-    if (import_constants.isWeb && isHydrated) {
-      const isAnimatedAndHydrated = isAnimated && isHydrated;
-      const isClassNameDisabled = !staticConfig.acceptsClassName && ((0, import_config.getSetting)("disableSSR") || !state.unmounted);
-      const isDisabledManually = disableClassName && !state.unmounted;
-      if (
-      // Only disable className for animation drivers that output inline styles (not css)
-      isAnimatedAndHydrated && outputStyle !== "css" || isDisabledManually || isClassNameDisabled) {
-        noClass = true;
-        if (process.env.NODE_ENV === "development" && props.debug === "verbose") {
-          (0, import_log.log)(`avoiding className`, {
-            isAnimatedAndHydrated,
-            isDisabledManually,
-            isClassNameDisabled
-          });
-        }
-      }
-    }
-  }
-  return {
-    startedUnhydrated: curStateRef.startedUnhydrated,
-    curStateRef,
-    disabled,
-    groupName,
-    hasAnimationProp,
-    hasEnterStyle,
-    isAnimated,
-    isExiting,
-    isHydrated,
-    presence,
-    presenceState,
-    setState,
-    setStateShallow,
-    noClass,
-    state,
-    stateRef,
-    inputStyle,
-    outputStyle,
-    willBeAnimated,
-    willBeAnimatedClient,
-    platformPseudo
-  };
+	"use no memo";
+	const isHydrated = (0, import_use_did_finish_ssr.useDidFinishSSR)();
+	const needsHydration = !(0, import_use_did_finish_ssr.useIsClientOnly)();
+	const useAnimations = animationDriver?.isStub ? void 0 : animationDriver?.useAnimations;
+	const { isHOC } = staticConfig;
+	const stateRef = (0, import_react.useRef)(void 0);
+	const curStateRef = stateRef.current ||= {
+		startedUnhydrated: needsHydration && !isHydrated,
+		optimizeForFirstRender: (0, import_isOptimizedForFirstRender.isOptimizedForFirstRender)()
+	};
+	const hasAnimationProp = Boolean(!isHOC && "transition" in props || props.style && hasAnimatedStyleValue(props.style));
+	const inputStyle = animationDriver?.inputStyle ?? "css";
+	const outputStyle = animationDriver?.outputStyle ?? "css";
+	if (!needsHydration && hasAnimationProp) {
+		curStateRef.hasAnimated = true;
+	}
+	const platformPseudoPossible = Boolean(!isHOC && useAnimations && animationDriver?.avoidReRenders && (0, import_constants.getPlatformDriver)()?.pseudo);
+	const willBeAnimatedClient = Boolean((hasAnimationProp || platformPseudoPossible) && !isHOC && useAnimations || curStateRef.hasAnimated);
+	const willBeAnimated = !import_constants.isServer && willBeAnimatedClient;
+	if (willBeAnimated && hasAnimationProp && !curStateRef.hasAnimated) {
+		curStateRef.hasAnimated = true;
+	}
+	const { disableClassName } = props;
+	const animatePresenceOptIn = willBeAnimated && !isHOC && props["animatePresence"] !== false;
+	if (animatePresenceOptIn) {
+		curStateRef.shouldRegisterPresence = true;
+	} else {
+		curStateRef.shouldRegisterPresence ??= false;
+	}
+	const presenceResult = animationDriver?.usePresence?.(curStateRef) || null;
+	const presence = animatePresenceOptIn ? presenceResult : null;
+	const presenceState = presence?.[2];
+	const isExiting = presenceState?.isPresent === false;
+	const isEntering = presenceState?.isPresent === true && presenceState.initial !== false;
+	const hasAnimationThatNeedsHydrate = hasAnimationProp && !isHydrated && inputStyle !== "css";
+	const disabled = isDisabled(props);
+	const [componentState, reactSetState] = (0, import_react.useState)(() => disabled != null ? {
+		...import_defaultComponentState.defaultComponentStateMounted,
+		disabled
+	} : import_defaultComponentState.defaultComponentStateMounted);
+	const initialStyleFrameUnmounted = curStateRef.initialStyleFrameUnmounted;
+	let state = !curStateRef.didFinalizeInitialStyleFrame && !isHOC || initialStyleFrameUnmounted !== void 0 ? { ...componentState } : componentState;
+	if (!curStateRef.didFinalizeInitialStyleFrame && !isHOC) {
+		state.unmounted = true;
+	}
+	if (initialStyleFrameUnmounted !== void 0) {
+		state.unmounted = initialStyleFrameUnmounted;
+	}
+	if (props.forceStyle) {
+		if (state === componentState) state = { ...state };
+		state[props.forceStyle] = true;
+	}
+	const setState = curStateRef.setState ||= (stateOrGetState) => {
+		const pendingUnmounted = curStateRef.initialStyleFrameUnmounted;
+		curStateRef.initialStyleFrameUnmounted = void 0;
+		reactSetState((previous) => {
+			const current = pendingUnmounted !== void 0 && previous.unmounted !== pendingUnmounted ? {
+				...previous,
+				unmounted: pendingUnmounted
+			} : previous;
+			return typeof stateOrGetState === "function" ? stateOrGetState(current) : stateOrGetState;
+		});
+	};
+	let isAnimated = willBeAnimated;
+	if (import_constants.isWeb && hasAnimationThatNeedsHydrate && !isHOC && !isHydrated) {
+		isAnimated = false;
+		curStateRef.willHydrate = true;
+	}
+	if (disabled !== state.disabled) {
+		if (disabled) {
+			Object.assign(state, import_defaultComponentState.defaultComponentStateMounted);
+		}
+		state.disabled = disabled;
+		setState((_) => ({ ...state }));
+	}
+	const groupName = props.group;
+	const setStateShallow = curStateRef.baseSetStateShallow ||= (stateOrGetState) => {
+		setState((prev) => {
+			const next = typeof stateOrGetState === "function" ? stateOrGetState(prev) : stateOrGetState;
+			return (0, import_is_equal_shallow.mergeIfNotShallowEqual)(prev, next);
+		});
+	};
+	let outProps = props;
+	if (presenceState && isAnimated && isHydrated && staticConfig.variants) {
+		const { custom } = presenceState;
+		if ((0, import_isObj.isObj)(custom)) {
+			outProps = {
+				...props,
+				...custom
+			};
+		}
+	}
+	let noClass = !import_constants.isWeb || Boolean(props.forceStyle);
+	if (import_constants.isWeb) {
+		if (!isHydrated) {
+			noClass = false;
+		} else {
+			const isAnimatedAndHydrated = Boolean((hasAnimationProp || curStateRef.hasAnimated) && useAnimations && !isHOC);
+			const isClassNameDisabled = !staticConfig.acceptsClassName && ((0, import_config.getSetting)("disableSSR") || !state.unmounted);
+			const isDisabledManually = Boolean(disableClassName && !state.unmounted);
+			if (isAnimatedAndHydrated && outputStyle !== "css" || isDisabledManually || isClassNameDisabled) {
+				noClass = true;
+			}
+		}
+	}
+	const result = {
+		props: outProps,
+		startedUnhydrated: curStateRef.startedUnhydrated,
+		curStateRef,
+		disabled,
+		groupName,
+		hasAnimationProp,
+		hasEnterStyle: false,
+		isAnimated,
+		isExiting,
+		isHydrated,
+		presence,
+		presenceState,
+		setState,
+		setStateShallow,
+		noClass,
+		state,
+		stateRef,
+		inputStyle,
+		outputStyle,
+		willBeAnimated,
+		willBeAnimatedClient,
+		platformPseudo: platformPseudoPossible,
+		finalizeStyleFlags(hasEnterStyle, hasPlatformPseudo) {
+			const platformPseudo = platformPseudoPossible && hasPlatformPseudo;
+			const nextWillBeAnimatedClient = Boolean((hasAnimationProp || platformPseudo) && !isHOC && useAnimations || curStateRef.hasAnimated);
+			const nextWillBeAnimated = !import_constants.isServer && nextWillBeAnimatedClient;
+			if (nextWillBeAnimated && !curStateRef.hasAnimated) {
+				curStateRef.hasAnimated = true;
+			}
+			if (!curStateRef.didFinalizeInitialStyleFrame) {
+				curStateRef.didFinalizeInitialStyleFrame = true;
+				const shouldEnter = !isHOC && (hasEnterStyle || isEntering || hasAnimationThatNeedsHydrate || disableClassName);
+				const unmounted = shouldEnter ? hasEnterStyle || isEntering ? "should-enter" : true : false;
+				state.unmounted = unmounted;
+				curStateRef.initialStyleFrameUnmounted = unmounted || void 0;
+			}
+			result.hasEnterStyle = hasEnterStyle;
+			result.platformPseudo = platformPseudo;
+			result.willBeAnimatedClient = nextWillBeAnimatedClient;
+			result.willBeAnimated = nextWillBeAnimated;
+			result.isAnimated = import_constants.isWeb && hasAnimationThatNeedsHydrate && !isHOC && !isHydrated ? false : nextWillBeAnimated;
+			if (nextWillBeAnimated && !isHOC && props["animatePresence"] !== false) {
+				curStateRef.shouldRegisterPresence = true;
+			}
+			return result;
+		}
+	};
+	return result;
 };
 function hasAnimatedStyleValue(style) {
-  return Object.keys(style).some(k => {
-    const val = style[k];
-    return val && typeof val === "object" && "_animation" in val;
-  });
+	for (const k in style) {
+		const val = style[k];
+		if (val && typeof val === "object" && "_animation" in val) {
+			return true;
+		}
+	}
+	return false;
 }
-const isDisabled = props => {
-  return props.disabled || props.passThrough || props.accessibilityState?.disabled || props["aria-disabled"] || props.accessibilityDisabled || false;
-};
+const isDisabled = (props) => {
+	return props.disabled || props.passThrough || props.accessibilityState?.disabled || props["aria-disabled"] || props.accessibilityDisabled || false;
+};

package/dist/cjs/hooks/useComponentState.native.cjs

@@ -0,0 +1,212 @@
+"use strict";
+
+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 useComponentState_exports = {};
+__export(useComponentState_exports, { useComponentState: () => useComponentState });
+module.exports = __toCommonJS(useComponentState_exports);
+var import_constants = require("@tamagui/constants");
+var import_is_equal_shallow = require("@tamagui/is-equal-shallow");
+var import_use_did_finish_ssr = require("@tamagui/use-did-finish-ssr");
+var import_react = require("react");
+var import_config = require("../config.native.js");
+var import_isOptimizedForFirstRender = require("./isOptimizedForFirstRender.native.js");
+var import_defaultComponentState = require("../defaultComponentState.native.js");
+var import_isObj = require("../helpers/isObj.native.js");
+var useComponentState = function(props, animationDriver, staticConfig, config) {
+	"use no memo";
+	var _getPlatformDriver, _animationDriver_usePresence;
+	var _stateRef, _curStateRef, _curStateRef1;
+	var isHydrated = (0, import_use_did_finish_ssr.useDidFinishSSR)();
+	var needsHydration = !(0, import_use_did_finish_ssr.useIsClientOnly)();
+	var useAnimations = (animationDriver === null || animationDriver === void 0 ? void 0 : animationDriver.isStub) ? void 0 : animationDriver === null || animationDriver === void 0 ? void 0 : animationDriver.useAnimations;
+	var { isHOC } = staticConfig;
+	var stateRef = (0, import_react.useRef)(void 0);
+	var curStateRef = (_stateRef = stateRef).current || (_stateRef.current = {
+		startedUnhydrated: needsHydration && !isHydrated,
+		optimizeForFirstRender: (0, import_isOptimizedForFirstRender.isOptimizedForFirstRender)()
+	});
+	var hasAnimationProp = Boolean(!isHOC && "transition" in props || props.style && hasAnimatedStyleValue(props.style));
+	var _animationDriver_inputStyle;
+	var inputStyle = (_animationDriver_inputStyle = animationDriver === null || animationDriver === void 0 ? void 0 : animationDriver.inputStyle) !== null && _animationDriver_inputStyle !== void 0 ? _animationDriver_inputStyle : "css";
+	var _animationDriver_outputStyle;
+	var outputStyle = (_animationDriver_outputStyle = animationDriver === null || animationDriver === void 0 ? void 0 : animationDriver.outputStyle) !== null && _animationDriver_outputStyle !== void 0 ? _animationDriver_outputStyle : "css";
+	if (!needsHydration && hasAnimationProp) {
+		curStateRef.hasAnimated = true;
+	}
+	var platformPseudoPossible = Boolean(!isHOC && useAnimations && (animationDriver === null || animationDriver === void 0 ? void 0 : animationDriver.avoidReRenders) && ((_getPlatformDriver = (0, import_constants.getPlatformDriver)()) === null || _getPlatformDriver === void 0 ? void 0 : _getPlatformDriver.pseudo));
+	var willBeAnimatedClient = Boolean((hasAnimationProp || platformPseudoPossible) && !isHOC && useAnimations || curStateRef.hasAnimated);
+	var willBeAnimated = !import_constants.isServer && willBeAnimatedClient;
+	if (willBeAnimated && hasAnimationProp && !curStateRef.hasAnimated) {
+		curStateRef.hasAnimated = true;
+	}
+	var { disableClassName } = props;
+	var animatePresenceOptIn = willBeAnimated && !isHOC && props["animatePresence"] !== false;
+	if (animatePresenceOptIn) {
+		curStateRef.shouldRegisterPresence = true;
+	} else {
+		var _curStateRef2;
+		var _shouldRegisterPresence;
+		(_shouldRegisterPresence = (_curStateRef2 = curStateRef).shouldRegisterPresence) !== null && _shouldRegisterPresence !== void 0 ? _shouldRegisterPresence : _curStateRef2.shouldRegisterPresence = false;
+	}
+	var presenceResult = (animationDriver === null || animationDriver === void 0 ? void 0 : (_animationDriver_usePresence = animationDriver.usePresence) === null || _animationDriver_usePresence === void 0 ? void 0 : _animationDriver_usePresence.call(animationDriver, curStateRef)) || null;
+	var presence = animatePresenceOptIn ? presenceResult : null;
+	var presenceState = presence === null || presence === void 0 ? void 0 : presence[2];
+	var isExiting = (presenceState === null || presenceState === void 0 ? void 0 : presenceState.isPresent) === false;
+	var isEntering = (presenceState === null || presenceState === void 0 ? void 0 : presenceState.isPresent) === true && presenceState.initial !== false;
+	var hasAnimationThatNeedsHydrate = hasAnimationProp && !isHydrated && inputStyle !== "css";
+	var disabled = isDisabled(props);
+	var [componentState, reactSetState] = (0, import_react.useState)(function() {
+		return disabled != null ? {
+			...import_defaultComponentState.defaultComponentStateMounted,
+			disabled
+		} : import_defaultComponentState.defaultComponentStateMounted;
+	});
+	var initialStyleFrameUnmounted = curStateRef.initialStyleFrameUnmounted;
+	var state = !curStateRef.didFinalizeInitialStyleFrame && !isHOC || initialStyleFrameUnmounted !== void 0 ? { ...componentState } : componentState;
+	if (!curStateRef.didFinalizeInitialStyleFrame && !isHOC) {
+		state.unmounted = true;
+	}
+	if (initialStyleFrameUnmounted !== void 0) {
+		state.unmounted = initialStyleFrameUnmounted;
+	}
+	if (props.forceStyle) {
+		if (state === componentState) state = { ...state };
+		state[props.forceStyle] = true;
+	}
+	var setState = (_curStateRef = curStateRef).setState || (_curStateRef.setState = function(stateOrGetState) {
+		var pendingUnmounted = curStateRef.initialStyleFrameUnmounted;
+		curStateRef.initialStyleFrameUnmounted = void 0;
+		reactSetState(function(previous) {
+			var current = pendingUnmounted !== void 0 && previous.unmounted !== pendingUnmounted ? {
+				...previous,
+				unmounted: pendingUnmounted
+			} : previous;
+			return typeof stateOrGetState === "function" ? stateOrGetState(current) : stateOrGetState;
+		});
+	});
+	var isAnimated = willBeAnimated;
+	if (import_constants.isWeb && hasAnimationThatNeedsHydrate && !isHOC && !isHydrated) {
+		isAnimated = false;
+		curStateRef.willHydrate = true;
+	}
+	if (disabled !== state.disabled) {
+		if (disabled) {
+			Object.assign(state, import_defaultComponentState.defaultComponentStateMounted);
+		}
+		state.disabled = disabled;
+		setState(function(_) {
+			return { ...state };
+		});
+	}
+	var groupName = props.group;
+	var setStateShallow = (_curStateRef1 = curStateRef).baseSetStateShallow || (_curStateRef1.baseSetStateShallow = function(stateOrGetState) {
+		setState(function(prev) {
+			var next = typeof stateOrGetState === "function" ? stateOrGetState(prev) : stateOrGetState;
+			return (0, import_is_equal_shallow.mergeIfNotShallowEqual)(prev, next);
+		});
+	});
+	var outProps = props;
+	if (presenceState && isAnimated && isHydrated && staticConfig.variants) {
+		var { custom } = presenceState;
+		if ((0, import_isObj.isObj)(custom)) {
+			outProps = {
+				...props,
+				...custom
+			};
+		}
+	}
+	var noClass = !import_constants.isWeb || Boolean(props.forceStyle);
+	if (import_constants.isWeb) {
+		if (!isHydrated) {
+			noClass = false;
+		} else {
+			var isAnimatedAndHydrated = Boolean((hasAnimationProp || curStateRef.hasAnimated) && useAnimations && !isHOC);
+			var isClassNameDisabled = !staticConfig.acceptsClassName && ((0, import_config.getSetting)("disableSSR") || !state.unmounted);
+			var isDisabledManually = Boolean(disableClassName && !state.unmounted);
+			if (isAnimatedAndHydrated && outputStyle !== "css" || isDisabledManually || isClassNameDisabled) {
+				noClass = true;
+			}
+		}
+	}
+	var result = {
+		props: outProps,
+		startedUnhydrated: curStateRef.startedUnhydrated,
+		curStateRef,
+		disabled,
+		groupName,
+		hasAnimationProp,
+		hasEnterStyle: false,
+		isAnimated,
+		isExiting,
+		isHydrated,
+		presence,
+		presenceState,
+		setState,
+		setStateShallow,
+		noClass,
+		state,
+		stateRef,
+		inputStyle,
+		outputStyle,
+		willBeAnimated,
+		willBeAnimatedClient,
+		platformPseudo: platformPseudoPossible,
+		finalizeStyleFlags(hasEnterStyle, hasPlatformPseudo) {
+			var platformPseudo = platformPseudoPossible && hasPlatformPseudo;
+			var nextWillBeAnimatedClient = Boolean((hasAnimationProp || platformPseudo) && !isHOC && useAnimations || curStateRef.hasAnimated);
+			var nextWillBeAnimated = !import_constants.isServer && nextWillBeAnimatedClient;
+			if (nextWillBeAnimated && !curStateRef.hasAnimated) {
+				curStateRef.hasAnimated = true;
+			}
+			if (!curStateRef.didFinalizeInitialStyleFrame) {
+				curStateRef.didFinalizeInitialStyleFrame = true;
+				var shouldEnter = !isHOC && (hasEnterStyle || isEntering || hasAnimationThatNeedsHydrate || disableClassName);
+				var unmounted = shouldEnter ? hasEnterStyle || isEntering ? "should-enter" : true : false;
+				state.unmounted = unmounted;
+				curStateRef.initialStyleFrameUnmounted = unmounted || void 0;
+			}
+			result.hasEnterStyle = hasEnterStyle;
+			result.platformPseudo = platformPseudo;
+			result.willBeAnimatedClient = nextWillBeAnimatedClient;
+			result.willBeAnimated = nextWillBeAnimated;
+			result.isAnimated = import_constants.isWeb && hasAnimationThatNeedsHydrate && !isHOC && !isHydrated ? false : nextWillBeAnimated;
+			if (nextWillBeAnimated && !isHOC && props["animatePresence"] !== false) {
+				curStateRef.shouldRegisterPresence = true;
+			}
+			return result;
+		}
+	};
+	return result;
+};
+function hasAnimatedStyleValue(style) {
+	for (var k in style) {
+		var val = style[k];
+		if (val && typeof val === "object" && "_animation" in val) {
+			return true;
+		}
+	}
+	return false;
+}
+var isDisabled = function(props) {
+	var _props_accessibilityState;
+	return props.disabled || props.passThrough || ((_props_accessibilityState = props.accessibilityState) === null || _props_accessibilityState === void 0 ? void 0 : _props_accessibilityState.disabled) || props["aria-disabled"] || props.accessibilityDisabled || false;
+};