@tamagui/animations-react-native 2.7.7 → 3.0.0-0.canary.1791057742817

package/dist/cjs/createAnimations.native.cjs

@@ -0,0 +1,863 @@
+"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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createAnimations_native_exports = {};
+__export(createAnimations_native_exports, {
+	AnimatedText: () => AnimatedText,
+	AnimatedView: () => AnimatedView,
+	createAnimations: () => createAnimations,
+	useAnimatedNumber: () => useAnimatedNumber,
+	useAnimatedNumberReaction: () => useAnimatedNumberReaction,
+	useAnimatedNumberStyle: () => useAnimatedNumberStyle,
+	useAnimatedNumbersStyle: () => useAnimatedNumbersStyle
+});
+module.exports = __toCommonJS(createAnimations_native_exports);
+var import_animation_helpers = require("@tamagui/animation-helpers");
+var import_constants = require("@tamagui/constants");
+var import_use_presence = require("@tamagui/use-presence");
+var import_web = require("@tamagui/web");
+var import_internal_runtime = require("@tamagui/web/internal-runtime");
+var import_react = __toESM(require("react"), 1);
+var import_react_native = require("react-native");
+var isFabric = !import_constants.isWeb && typeof global !== "undefined" && !!global.__nativeFabricUIManager;
+var resolveDynamicValue = function(value, isDark) {
+	if (value && typeof value === "object" && "dynamic" in value) {
+		var dynamicValue = isDark ? value.dynamic.dark : value.dynamic.light;
+		return dynamicValue;
+	}
+	return value;
+};
+var animatedStyleKey = {
+	transform: true,
+	opacity: true
+};
+var colorStyleKey = {
+	backgroundColor: true,
+	color: true,
+	borderColor: true,
+	borderLeftColor: true,
+	borderRightColor: true,
+	borderTopColor: true,
+	borderBottomColor: true
+};
+var layoutStyleKey = {
+	height: true,
+	width: true,
+	minHeight: true,
+	maxHeight: true,
+	minWidth: true,
+	maxWidth: true
+};
+var textMetricStyleKey = {
+	fontSize: true,
+	lineHeight: true
+};
+var jsDriverStyleKey = {
+	...layoutStyleKey,
+	...textMetricStyleKey
+};
+function hasAnimatedLayoutKey(style, isDark, resolved) {
+	for (var key in layoutStyleKey) {
+		if (!(0, import_animation_helpers.getTransitionForKey)(resolved, key)) continue;
+		if (typeof resolveDynamicValue(style[key], isDark) === "number") return true;
+	}
+	return false;
+}
+var getLeadingRatio = function(metrics) {
+	var ratio = metrics === null || metrics === void 0 ? void 0 : metrics.lineHeight;
+	return typeof ratio === "number" && Number.isFinite(ratio) && ratio >= 0 ? ratio : void 0;
+};
+var paintsLeadingProduct = function(style, ratio) {
+	return ratio !== void 0 && typeof style.fontSize === "number" && typeof style.lineHeight === "number";
+};
+var inheritedFontSizeNode = function(style, ratio, inheritedText) {
+	return ratio !== void 0 && typeof style.fontSize !== "number" && (inheritedText === null || inheritedText === void 0 ? void 0 : inheritedText.driver) === "react-native" ? inheritedText.fontSize : void 0;
+};
+function isAnimatableColor(value) {
+	return typeof value === "string" && (0, import_react_native.processColor)(value) != null;
+}
+var costlyToAnimateStyleKey = {
+	borderRadius: true,
+	borderTopLeftRadius: true,
+	borderTopRightRadius: true,
+	borderBottomLeftRadius: true,
+	borderBottomRightRadius: true,
+	borderWidth: true,
+	borderLeftWidth: true,
+	borderRightWidth: true,
+	borderTopWidth: true,
+	borderBottomWidth: true,
+	...colorStyleKey
+};
+var AnimatedView = import_react_native.Animated.View;
+var AnimatedText = import_react_native.Animated.Text;
+var animatedTextInput;
+function useAnimatedNumber(initial) {
+	var state = import_react.default.useRef(null);
+	if (!state.current) {
+		state.current = {
+			composite: null,
+			val: new import_react_native.Animated.Value(initial),
+			strategy: { type: "spring" }
+		};
+	}
+	return {
+		getInstance() {
+			return state.current.val;
+		},
+		getValue() {
+			return state.current.val["_value"];
+		},
+		stop() {
+			var _state_current_composite;
+			(_state_current_composite = state.current.composite) === null || _state_current_composite === void 0 ? void 0 : _state_current_composite.stop();
+			state.current.composite = null;
+		},
+		setValue(next) {
+			var { type, ...config } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { type: "spring" }, onFinish = arguments.length > 2 ? arguments[2] : void 0;
+			var val = state.current.val;
+			var handleFinish = onFinish ? function(param) {
+				var { finished } = param;
+				return finished ? onFinish() : null;
+			} : void 0;
+			if (type === "direct") {
+				var _state_current_composite;
+				(_state_current_composite = state.current.composite) === null || _state_current_composite === void 0 ? void 0 : _state_current_composite.stop();
+				state.current.composite = null;
+				val.setValue(next);
+				onFinish === null || onFinish === void 0 ? void 0 : onFinish();
+			} else if (type === "spring") {
+				var _state_current_composite1;
+				(_state_current_composite1 = state.current.composite) === null || _state_current_composite1 === void 0 ? void 0 : _state_current_composite1.stop();
+				var composite = import_react_native.Animated.spring(val, {
+					...config,
+					toValue: next,
+					useNativeDriver: isFabric
+				});
+				composite.start(handleFinish);
+				state.current.composite = composite;
+			} else {
+				var _state_current_composite2;
+				(_state_current_composite2 = state.current.composite) === null || _state_current_composite2 === void 0 ? void 0 : _state_current_composite2.stop();
+				var composite1 = import_react_native.Animated.timing(val, {
+					...config,
+					toValue: next,
+					useNativeDriver: isFabric
+				});
+				composite1.start(handleFinish);
+				state.current.composite = composite1;
+			}
+		}
+	};
+}
+var useAnimatedNumberReaction = function(param, onValue) {
+	var { value } = param;
+	var onChange = (0, import_web.useEvent)(function(current) {
+		onValue(current.value);
+	});
+	import_react.default.useEffect(function() {
+		var id = value.getInstance().addListener(onChange);
+		return function() {
+			value.getInstance().removeListener(id);
+		};
+	}, [value, onChange]);
+};
+var useAnimatedNumberStyle = function(value, getStyle) {
+	var instance = value.getInstance();
+	var animatedStyle = getStyle(instance);
+	var usesAnimatedNode = hasAnimatedNode(animatedStyle);
+	var [current, setCurrent] = import_react.default.useState(value.getValue());
+	import_react.default.useEffect(function() {
+		if (usesAnimatedNode) return;
+		var id = instance.addListener(function(param) {
+			var { value: next } = param;
+			setCurrent(next);
+		});
+		return function() {
+			instance.removeListener(id);
+		};
+	}, [instance, usesAnimatedNode]);
+	return usesAnimatedNode ? animatedStyle : getStyle(current);
+};
+function hasAnimatedNode(value) {
+	if (!value || typeof value !== "object") return false;
+	if (typeof value.__getValue === "function") return true;
+	if (Array.isArray(value)) return value.some(hasAnimatedNode);
+	return Object.values(value).some(hasAnimatedNode);
+}
+var useAnimatedNumbersStyle = function(vals, getStyle) {
+	return getStyle(...vals.map(function(v) {
+		return v.getInstance();
+	}));
+};
+function createAnimations(animations, options) {
+	var _options_useNativeDriver;
+	var nativeDriver = (_options_useNativeDriver = options === null || options === void 0 ? void 0 : options.useNativeDriver) !== null && _options_useNativeDriver !== void 0 ? _options_useNativeDriver : isFabric;
+	return {
+		inputStyle: "value",
+		outputStyle: "inline",
+		avoidReRenders: true,
+		animations,
+		needsCustomComponent: true,
+		View: AnimatedView,
+		Text: AnimatedText,
+		useAnimatedNumber,
+		useAnimatedNumberReaction,
+		useAnimatedNumberStyle,
+		useAnimatedNumbersStyle,
+		usePresence: import_use_presence.usePresence,
+		ResetPresence: import_use_presence.ResetPresence,
+		useTextMetrics: function(param) {
+			var { inheritedText, lineHeight } = param;
+			var node = (inheritedText === null || inheritedText === void 0 ? void 0 : inheritedText.driver) === "react-native" ? inheritedText.fontSize : null;
+			var ratio = typeof lineHeight === "number" ? lineHeight : null;
+			var style = import_react.default.useMemo(function() {
+				return node ? ratio === null ? { fontSize: node } : {
+					fontSize: node,
+					lineHeight: import_react_native.Animated.multiply(node, ratio)
+				} : null;
+			}, [node, ratio]);
+			var textChannel = inheritedText !== null && inheritedText !== void 0 ? inheritedText : null;
+			if (!style) return {
+				style: null,
+				textChannel
+			};
+			animatedTextInput || (animatedTextInput = import_react_native.Animated.createAnimatedComponent(import_react_native.TextInput));
+			return {
+				style,
+				textChannel,
+				Text: AnimatedText,
+				TextInput: animatedTextInput
+			};
+		},
+		useAnimations: function(param) {
+			var { props, onTransition, style, componentState, presence, stateRef, styleState, useStyleEmitter, inheritedText } = param;
+			var _themeState_name;
+			var isDisabled = import_constants.isWeb && componentState.unmounted === true;
+			var isExiting = (presence === null || presence === void 0 ? void 0 : presence[0]) === false;
+			var sendExitComplete = presence === null || presence === void 0 ? void 0 : presence[1];
+			var onTransitionRef = import_react.default.useRef(onTransition);
+			onTransitionRef.current = onTransition;
+			var emit = function(phase, cause, finished) {
+				var _onTransitionRef_current;
+				(_onTransitionRef_current = onTransitionRef.current) === null || _onTransitionRef_current === void 0 ? void 0 : _onTransitionRef_current.call(onTransitionRef, phase === "end" ? {
+					phase,
+					cause,
+					finished
+				} : {
+					phase,
+					cause
+				});
+			};
+			var _styleState_effectiveTransition;
+			var effectiveTransition = (_styleState_effectiveTransition = styleState === null || styleState === void 0 ? void 0 : styleState.effectiveTransition) !== null && _styleState_effectiveTransition !== void 0 ? _styleState_effectiveTransition : props.transition;
+			var [, themeState] = (0, import_internal_runtime.useThemeWithState)({});
+			var isDark = (themeState === null || themeState === void 0 ? void 0 : themeState.scheme) === "dark" || (themeState === null || themeState === void 0 ? void 0 : (_themeState_name = themeState.name) === null || _themeState_name === void 0 ? void 0 : _themeState_name.startsWith("dark"));
+			var animateStyles = import_react.default.useRef({});
+			var leadingRatioValue = import_react.default.useRef(null);
+			var leadingRatioRef = import_react.default.useRef(void 0);
+			var paintsDerivedLeading = import_react.default.useRef(false);
+			var textChannelRef = import_react.default.useRef(null);
+			leadingRatioRef.current = getLeadingRatio(styleState === null || styleState === void 0 ? void 0 : styleState.nativeTextMetrics);
+			var paintedTextRef = import_react.default.useRef({});
+			var movesTextValue = function(key, target) {
+				if (typeof target !== "number") return false;
+				var node = animateStyles.current[key];
+				var last = node ? node["_value"] : paintedTextRef.current[key];
+				return last !== void 0 && last !== target;
+			};
+			var movesLeadingRatio = function(ratio) {
+				if (ratio === void 0) return false;
+				var node = leadingRatioValue.current;
+				var last = node ? node["_value"] : paintedTextRef.current.ratio;
+				return last !== void 0 && last !== ratio;
+			};
+			var fontSizeNode = import_react.default.useRef(null);
+			var animatedValueFor = function(key) {
+				var painted = animateStyles.current[key];
+				if (painted) return painted;
+				if (key === "fontSize" && fontSizeNode.current) return fontSizeNode.current;
+				if (textMetricStyleKey[key]) return new import_react_native.Animated.Value(paintedTextRef.current[key]);
+				return void 0;
+			};
+			var leadingRatioValueFrom = function() {
+				var _leadingRatioValue_current;
+				return (_leadingRatioValue_current = leadingRatioValue.current) !== null && _leadingRatioValue_current !== void 0 ? _leadingRatioValue_current : new import_react_native.Animated.Value(paintedTextRef.current.ratio);
+			};
+			var animatedTranforms = import_react.default.useRef([]);
+			var animationsState = import_react.default.useRef(/* @__PURE__ */ new WeakMap());
+			var pseudoActiveRef = import_react.default.useRef(false);
+			var exitCycleIdRef = import_react.default.useRef(0);
+			var exitCompletedRef = import_react.default.useRef(false);
+			var wasExitingRef = import_react.default.useRef(false);
+			var enterStartedRef = import_react.default.useRef(false);
+			var exitStartedRef = import_react.default.useRef(false);
+			var updateInFlightRef = import_react.default.useRef(false);
+			var updateCycleIdRef = import_react.default.useRef(0);
+			var prevStyleSigRef = import_react.default.useRef(null);
+			var justStartedExiting = isExiting && !wasExitingRef.current;
+			var justStoppedExiting = !isExiting && wasExitingRef.current;
+			if (justStartedExiting) {
+				exitCycleIdRef.current++;
+				exitCompletedRef.current = false;
+			}
+			if (justStoppedExiting) {
+				exitCycleIdRef.current++;
+			}
+			var isEntering = !!componentState.unmounted;
+			var wasEnteringRef = import_react.default.useRef(isEntering);
+			var justFinishedEntering = wasEnteringRef.current && !isEntering;
+			import_react.default.useEffect(function() {
+				wasEnteringRef.current = isEntering;
+			});
+			var args = [
+				JSON.stringify(style),
+				JSON.stringify(effectiveTransition),
+				componentState,
+				isExiting,
+				!!onTransition,
+				isDark,
+				justFinishedEntering,
+				leadingRatioRef.current,
+				inheritedText
+			];
+			var res = import_react.default.useMemo(function() {
+				var _textChannelRef_current;
+				var runners = [];
+				var completions = [];
+				var animationState = isExiting ? "exit" : isEntering || justFinishedEntering ? "enter" : "default";
+				var resolved = (0, import_animation_helpers.forAnimationState)((0, import_animation_helpers.resolveTransition)(effectiveTransition, { animations }), animationState);
+				var nonAnimatedStyle = {};
+				var paintedRatio = leadingRatioRef.current;
+				var paintsProduct = paintsLeadingProduct(style, paintedRatio);
+				var movesFontSize = movesTextValue("fontSize", style.fontSize);
+				var movesLeading = paintsProduct ? movesLeadingRatio(paintedRatio) : movesTextValue("lineHeight", style.lineHeight);
+				if (!isExiting && !isDisabled && !pseudoActiveRef.current) {
+					if (!movesFontSize) delete animateStyles.current.fontSize;
+					if (!movesLeading) delete animateStyles.current.lineHeight;
+				}
+				if (isDisabled || typeof style.fontSize !== "number" || !(0, import_animation_helpers.getTransitionForKey)(resolved, "fontSize")) {
+					fontSizeNode.current = null;
+				} else if (!fontSizeNode.current) {
+					fontSizeNode.current = new import_react_native.Animated.Value(style.fontSize);
+				}
+				var seenAnimateKeys = /* @__PURE__ */ new Set();
+				var sawTransform = false;
+				var transformCount = 0;
+				var derivesLeading = !isDisabled && paintsProduct && (movesFontSize || movesLeading) && (!!(0, import_animation_helpers.getTransitionForKey)(resolved, "fontSize") || !!(0, import_animation_helpers.getTransitionForKey)(resolved, "lineHeight"));
+				var inheritedFontSize = isDisabled ? void 0 : inheritedFontSizeNode(style, paintedRatio, inheritedText);
+				var useNativeDriverForNode = nativeDriver && !hasAnimatedLayoutKey(style, isDark, resolved) && !movesFontSize && !movesLeading && !inheritedFontSize && !Object.keys(animateStyles.current).some(function(key2) {
+					return jsDriverStyleKey[key2];
+				});
+				for (var key in style) {
+					var rawVal = style[key];
+					var val = resolveDynamicValue(rawVal, isDark);
+					if (val === void 0) continue;
+					if (isDisabled) {
+						continue;
+					}
+					if ((derivesLeading || inheritedFontSize) && (key === "fontSize" || key === "lineHeight")) {
+						if (key === "fontSize" && derivesLeading && !movesFontSize) {
+							nonAnimatedStyle[key] = val;
+						}
+						continue;
+					}
+					if (textMetricStyleKey[key] && !(key === "fontSize" ? movesFontSize : movesLeading)) {
+						nonAnimatedStyle[key] = val;
+						continue;
+					}
+					if (animatedStyleKey[key] == null && !costlyToAnimateStyleKey[key] && !jsDriverStyleKey[key]) {
+						nonAnimatedStyle[key] = val;
+						continue;
+					}
+					if (key !== "transform" && !(0, import_animation_helpers.getTransitionForKey)(resolved, key)) {
+						nonAnimatedStyle[key] = val;
+						continue;
+					}
+					if (jsDriverStyleKey[key] && typeof val !== "number") {
+						nonAnimatedStyle[key] = val;
+						continue;
+					}
+					if (colorStyleKey[key] && !isAnimatableColor(val)) {
+						nonAnimatedStyle[key] = val;
+						continue;
+					}
+					if (key !== "transform") {
+						animateStyles.current[key] = update(key, animatedValueFor(key), val);
+						seenAnimateKeys.add(key);
+						continue;
+					}
+					if (!val) continue;
+					if (typeof val === "string") {
+						console.warn(`Warning: Tamagui can't animate string transforms yet!`);
+						continue;
+					}
+					sawTransform = true;
+					var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+					try {
+						for (var _iterator = val[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+							var transform = _step.value;
+							var _animatedTranforms_current_index;
+							if (!transform) continue;
+							var index = transformCount++;
+							var tkey = Object.keys(transform)[0];
+							var currentTransform = (_animatedTranforms_current_index = animatedTranforms.current[index]) === null || _animatedTranforms_current_index === void 0 ? void 0 : _animatedTranforms_current_index[tkey];
+							animatedTranforms.current[index] = { [tkey]: update(tkey, currentTransform, transform[tkey]) };
+							animatedTranforms.current = [...animatedTranforms.current];
+						}
+					} catch (err) {
+						_didIteratorError = true;
+						_iteratorError = err;
+					} finally {
+						try {
+							if (!_iteratorNormalCompletion && _iterator.return != null) {
+								_iterator.return();
+							}
+						} finally {
+							if (_didIteratorError) {
+								throw _iteratorError;
+							}
+						}
+					}
+				}
+				var ratioFactor = function() {
+					if (!movesLeading) {
+						leadingRatioValue.current = null;
+						return paintedRatio;
+					}
+					leadingRatioValue.current = update("lineHeight", leadingRatioValueFrom(), paintedRatio);
+					return leadingRatioValue.current;
+				};
+				var derivedLeading;
+				if (derivesLeading) {
+					var fontSizeFactor = style.fontSize;
+					if (movesFontSize) {
+						fontSizeFactor = update("fontSize", animatedValueFor("fontSize"), style.fontSize);
+						animateStyles.current.fontSize = fontSizeFactor;
+						seenAnimateKeys.add("fontSize");
+					}
+					derivedLeading = import_react_native.Animated.multiply(fontSizeFactor, ratioFactor());
+				} else if (inheritedFontSize) {
+					derivedLeading = import_react_native.Animated.multiply(inheritedFontSize, ratioFactor());
+				} else if (!isDisabled) {
+					leadingRatioValue.current = null;
+				}
+				paintsDerivedLeading.current = !!derivedLeading;
+				var ownFontSizeNode = fontSizeNode.current;
+				var textChannel = ownFontSizeNode ? ((_textChannelRef_current = textChannelRef.current) === null || _textChannelRef_current === void 0 ? void 0 : _textChannelRef_current.fontSize) === ownFontSizeNode ? textChannelRef.current : {
+					fontSize: ownFontSizeNode,
+					driver: "react-native"
+				} : typeof style.fontSize === "number" ? null : inheritedText !== null && inheritedText !== void 0 ? inheritedText : null;
+				textChannelRef.current = textChannel;
+				if (!isExiting && !isDisabled && !pseudoActiveRef.current) {
+					for (var k in animateStyles.current) {
+						if (!seenAnimateKeys.has(k)) delete animateStyles.current[k];
+					}
+					if (!sawTransform) {
+						if (animatedTranforms.current.length) animatedTranforms.current = [];
+					} else if (animatedTranforms.current.length > transformCount) {
+						animatedTranforms.current = animatedTranforms.current.slice(0, transformCount);
+					}
+				}
+				var animatedTransformStyle = animatedTranforms.current.length > 0 ? { transform: animatedTranforms.current.map(function(r) {
+					var _animationsState_current_get;
+					var key2 = Object.keys(r)[0];
+					var val2 = ((_animationsState_current_get = animationsState.current.get(r[key2])) === null || _animationsState_current_get === void 0 ? void 0 : _animationsState_current_get.interpolation) || r[key2];
+					return { [key2]: val2 };
+				}) } : {};
+				var animatedStyle = {
+					...Object.fromEntries(Object.entries(animateStyles.current).map(function(param2) {
+						var [k2, v] = param2;
+						var _animationsState_current_get;
+						return [k2, ((_animationsState_current_get = animationsState.current.get(v)) === null || _animationsState_current_get === void 0 ? void 0 : _animationsState_current_get.interpolation) || v];
+					})),
+					...derivedLeading ? { lineHeight: derivedLeading } : null,
+					...animatedTransformStyle
+				};
+				if (!isDisabled) {
+					paintedTextRef.current = {
+						fontSize: style.fontSize,
+						lineHeight: style.lineHeight,
+						ratio: paintedRatio
+					};
+				}
+				return {
+					runners,
+					completions,
+					textChannel,
+					style: [nonAnimatedStyle, animatedStyle]
+				};
+				function update(key2, animated, valIn) {
+					var isColorStyleKey = colorStyleKey[key2];
+					var [val2, type] = isColorStyleKey ? [0, void 0] : getValue(valIn);
+					var animateToValue = val2;
+					var value = animated || new import_react_native.Animated.Value(val2);
+					var curInterpolation = animationsState.current.get(value);
+					var interpolateArgs;
+					if (type) {
+						var _curInterpolation_current;
+						interpolateArgs = getInterpolated((_curInterpolation_current = curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.current) !== null && _curInterpolation_current !== void 0 ? _curInterpolation_current : value["_value"], val2, type);
+						animationsState.current.set(value, {
+							interpolation: value.interpolate(interpolateArgs),
+							current: val2
+						});
+					}
+					if (isColorStyleKey) {
+						animateToValue = (curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.animateToValue) ? 0 : 1;
+						interpolateArgs = getColorInterpolated(curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.current, valIn, animateToValue);
+						animationsState.current.set(value, {
+							current: valIn,
+							interpolation: value.interpolate(interpolateArgs),
+							animateToValue: (curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.animateToValue) ? 0 : 1
+						});
+					}
+					if (value) {
+						var animationConfig = getAnimationConfig(key2, animations, effectiveTransition, animationState);
+						var resolve;
+						var promise = new Promise(function(res2) {
+							resolve = res2;
+						});
+						completions.push(promise);
+						runners.push(function() {
+							value.stopAnimation();
+							var { type: type2, delay, ...config } = animationConfig;
+							var animation = import_react_native.Animated[type2 || "spring"](value, {
+								toValue: animateToValue,
+								...config,
+								useNativeDriver: useNativeDriverForNode
+							});
+							var animation2 = delay ? import_react_native.Animated.sequence([import_react_native.Animated.delay(delay), animation]) : animation;
+							animation2.start(function(param2) {
+								var { finished } = param2;
+								if (finished || isExiting) {
+									resolve();
+								}
+							});
+						});
+					}
+					if (process.env.NODE_ENV === "development") {
+						if (props["debug"] === "verbose") {
+							console.info(" 💠 animate", key2, `from (${value["_value"]}) to`, valIn, `(${val2})`, "type", type, "interpolate", interpolateArgs);
+						}
+					}
+					return value;
+				}
+			}, args);
+			import_react.default.useEffect(function() {
+				wasExitingRef.current = isExiting;
+			});
+			(0, import_constants.useIsomorphicLayoutEffect)(function() {
+				if (justStoppedExiting && exitStartedRef.current && !exitCompletedRef.current) {
+					exitStartedRef.current = false;
+					emit("end", "exit", false);
+				}
+			}, [justStoppedExiting]);
+			(0, import_constants.useIsomorphicLayoutEffect)(function() {
+				res.runners.forEach(function(r) {
+					return r();
+				});
+				var cycleId = exitCycleIdRef.current;
+				var cause = isExiting ? "exit" : isEntering || justFinishedEntering ? "enter" : "update";
+				if (cause === "exit") {
+					if (enterStartedRef.current) {
+						enterStartedRef.current = false;
+						emit("end", "enter", false);
+					}
+					if (updateInFlightRef.current) {
+						updateInFlightRef.current = false;
+						updateCycleIdRef.current++;
+						emit("end", "update", false);
+					}
+				}
+				if (cause === "update") {
+					var sig = args[0];
+					if (prevStyleSigRef.current === null || prevStyleSigRef.current === sig) {
+						prevStyleSigRef.current = sig;
+						return;
+					}
+					prevStyleSigRef.current = sig;
+					if (res.completions.length === 0) return;
+					if (updateInFlightRef.current) {
+						emit("end", "update", false);
+					}
+					updateInFlightRef.current = true;
+					var uid = ++updateCycleIdRef.current;
+					emit("start", "update");
+					Promise.all(res.completions).then(function() {
+						if (uid !== updateCycleIdRef.current) return;
+						updateInFlightRef.current = false;
+						emit("end", "update", true);
+					});
+					return;
+				}
+				prevStyleSigRef.current = args[0];
+				if (res.completions.length === 0) {
+					emit("start", cause);
+					emit("end", cause, true);
+					if (isExiting && !exitCompletedRef.current) {
+						exitCompletedRef.current = true;
+						sendExitComplete === null || sendExitComplete === void 0 ? void 0 : sendExitComplete();
+					}
+					return;
+				}
+				if (cause === "enter" && !enterStartedRef.current) {
+					enterStartedRef.current = true;
+					emit("start", "enter");
+				}
+				if (cause === "exit" && !exitStartedRef.current) {
+					exitStartedRef.current = true;
+					emit("start", "exit");
+				}
+				Promise.all(res.completions).then(function() {
+					if (isExiting && cycleId !== exitCycleIdRef.current) return;
+					if (isExiting && exitCompletedRef.current) return;
+					if (isExiting) {
+						if (exitStartedRef.current) {
+							exitStartedRef.current = false;
+							emit("end", "exit", true);
+						}
+						exitCompletedRef.current = true;
+						sendExitComplete === null || sendExitComplete === void 0 ? void 0 : sendExitComplete();
+					} else if (enterStartedRef.current) {
+						enterStartedRef.current = false;
+						emit("end", "enter", true);
+					}
+				});
+			}, args);
+			var onEmittedStyle = function(nextStyle, emittedTransition, pseudoActive, nextMetrics) {
+				pseudoActiveRef.current = pseudoActive === true;
+				var runners = [];
+				var seenAnimateKeys = /* @__PURE__ */ new Set();
+				var transformCount = 0;
+				var animatedShapeChanged = false;
+				var emittedResolved = (0, import_animation_helpers.forAnimationState)((0, import_animation_helpers.resolveTransition)(emittedTransition !== null && emittedTransition !== void 0 ? emittedTransition : effectiveTransition, { animations }), "default");
+				var emittedRatio = getLeadingRatio(nextMetrics);
+				var emitterPaintsProduct = paintsLeadingProduct(nextStyle, emittedRatio);
+				var emitterMovesFontSize = movesTextValue("fontSize", nextStyle.fontSize);
+				var emitterMovesLeading = emitterPaintsProduct ? movesLeadingRatio(emittedRatio) : movesTextValue("lineHeight", nextStyle.lineHeight);
+				var useNativeDriverForNode = nativeDriver && !hasAnimatedLayoutKey(nextStyle, isDark, emittedResolved) && !emitterMovesFontSize && !emitterMovesLeading && !inheritedFontSizeNode(nextStyle, emittedRatio, inheritedText) && !Object.keys(animateStyles.current).some(function(key2) {
+					return jsDriverStyleKey[key2];
+				});
+				var emitterDerivesLeading = emitterPaintsProduct && (emitterMovesFontSize || emitterMovesLeading) && (!!(0, import_animation_helpers.getTransitionForKey)(emittedResolved, "fontSize") || !!(0, import_animation_helpers.getTransitionForKey)(emittedResolved, "lineHeight"));
+				for (var key in nextStyle) {
+					var rawVal = nextStyle[key];
+					var val = resolveDynamicValue(rawVal, isDark);
+					if (val === void 0) continue;
+					if (emitterDerivesLeading && (key === "fontSize" || key === "lineHeight")) {
+						continue;
+					}
+					if (textMetricStyleKey[key] && !(key === "fontSize" ? emitterMovesFontSize : emitterMovesLeading)) {
+						continue;
+					}
+					if (key === "transform" && Array.isArray(val)) {
+						var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+						try {
+							for (var _iterator = val[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+								var transform = _step.value;
+								var _animatedTranforms_current_index;
+								if (!transform) continue;
+								var index = transformCount++;
+								var tkey = Object.keys(transform)[0];
+								var currentTransform = (_animatedTranforms_current_index = animatedTranforms.current[index]) === null || _animatedTranforms_current_index === void 0 ? void 0 : _animatedTranforms_current_index[tkey];
+								if (!currentTransform) animatedShapeChanged = true;
+								animatedTranforms.current[index] = { [tkey]: update(tkey, currentTransform, transform[tkey]) };
+							}
+						} catch (err) {
+							_didIteratorError = true;
+							_iteratorError = err;
+						} finally {
+							try {
+								if (!_iteratorNormalCompletion && _iterator.return != null) {
+									_iterator.return();
+								}
+							} finally {
+								if (_didIteratorError) {
+									throw _iteratorError;
+								}
+							}
+						}
+					} else if (animatedStyleKey[key] != null || costlyToAnimateStyleKey[key] || jsDriverStyleKey[key]) {
+						if (jsDriverStyleKey[key] && typeof val !== "number") continue;
+						if (colorStyleKey[key] && !isAnimatableColor(val)) continue;
+						if (!animateStyles.current[key]) animatedShapeChanged = true;
+						animateStyles.current[key] = update(key, animatedValueFor(key), val);
+						seenAnimateKeys.add(key);
+					}
+				}
+				if (emitterDerivesLeading) {
+					if (emitterMovesFontSize) {
+						if (!animateStyles.current.fontSize) animatedShapeChanged = true;
+						animateStyles.current.fontSize = update("fontSize", animatedValueFor("fontSize"), nextStyle.fontSize);
+						seenAnimateKeys.add("fontSize");
+					}
+					if (emitterMovesLeading) {
+						if (!leadingRatioValue.current) animatedShapeChanged = true;
+						leadingRatioValue.current = update("lineHeight", leadingRatioValueFrom(), emittedRatio);
+					}
+				}
+				if (emitterDerivesLeading !== paintsDerivedLeading.current) {
+					animatedShapeChanged = true;
+				}
+				for (var key1 in animateStyles.current) {
+					if (!seenAnimateKeys.has(key1)) {
+						delete animateStyles.current[key1];
+						animatedShapeChanged = true;
+					}
+				}
+				if (animatedTranforms.current.length > transformCount) {
+					animatedTranforms.current = animatedTranforms.current.slice(0, transformCount);
+					animatedShapeChanged = true;
+				}
+				paintedTextRef.current = {
+					fontSize: nextStyle.fontSize,
+					lineHeight: nextStyle.lineHeight,
+					ratio: emittedRatio
+				};
+				runners.forEach(function(r) {
+					return r();
+				});
+				if (animatedShapeChanged && stateRef.current.nextState) {
+					var _stateRef_current_baseSetStateShallow, _stateRef_current;
+					(_stateRef_current_baseSetStateShallow = (_stateRef_current = stateRef.current).baseSetStateShallow) === null || _stateRef_current_baseSetStateShallow === void 0 ? void 0 : _stateRef_current_baseSetStateShallow.call(_stateRef_current, stateRef.current.nextState);
+				}
+				function update(key2, animated, valIn) {
+					var isColor = colorStyleKey[key2];
+					var [numVal, type] = isColor ? [0, void 0] : getValue(valIn);
+					var animateToValue = numVal;
+					var value = animated || new import_react_native.Animated.Value(numVal);
+					var curInterpolation = animationsState.current.get(value);
+					if (type) {
+						var _curInterpolation_current;
+						animationsState.current.set(value, {
+							interpolation: value.interpolate(getInterpolated((_curInterpolation_current = curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.current) !== null && _curInterpolation_current !== void 0 ? _curInterpolation_current : value["_value"], numVal, type)),
+							current: numVal
+						});
+					}
+					if (isColor) {
+						animateToValue = (curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.animateToValue) ? 0 : 1;
+						animationsState.current.set(value, {
+							current: valIn,
+							interpolation: value.interpolate(getColorInterpolated(curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.current, valIn, animateToValue)),
+							animateToValue: (curInterpolation === null || curInterpolation === void 0 ? void 0 : curInterpolation.animateToValue) ? 0 : 1
+						});
+					}
+					var animationConfig = getAnimationConfig(key2, animations, emittedTransition !== null && emittedTransition !== void 0 ? emittedTransition : effectiveTransition, "default");
+					runners.push(function() {
+						value.stopAnimation();
+						var { type: type2, delay, ...config } = animationConfig;
+						var anim = import_react_native.Animated[type2 || "spring"](value, {
+							toValue: animateToValue,
+							...config,
+							useNativeDriver: useNativeDriverForNode
+						});
+						(delay ? import_react_native.Animated.sequence([import_react_native.Animated.delay(delay), anim]) : anim).start();
+					});
+					return value;
+				}
+			};
+			useStyleEmitter === null || useStyleEmitter === void 0 ? void 0 : useStyleEmitter(onEmittedStyle);
+			if (process.env.NODE_ENV === "development") {
+				if (props["debug"] === "verbose") {
+					console.info(`Animated`, {
+						response: res,
+						inputStyle: style,
+						isExiting
+					});
+				}
+			}
+			return res;
+		}
+	};
+}
+function getColorInterpolated(currentColor, nextColor, animateToValue) {
+	var inputRange = [0, 1];
+	var outputRange = [currentColor ? currentColor : nextColor, nextColor];
+	if (animateToValue === 0) {
+		outputRange.reverse();
+	}
+	return {
+		inputRange,
+		outputRange
+	};
+}
+function getInterpolated(current, next) {
+	var postfix = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "deg";
+	if (next === current) {
+		current = next - 1e-9;
+	}
+	var inputRange = [current, next];
+	var outputRange = [`${current}${postfix}`, `${next}${postfix}`];
+	if (next < current) {
+		inputRange.reverse();
+		outputRange.reverse();
+	}
+	return {
+		inputRange,
+		outputRange
+	};
+}
+function entryToRN(entry) {
+	var extra = entry.timing.kind === "spring" ? entry.timing.extra : void 0;
+	if (entry.timing.kind === "spring") {
+		return {
+			type: "spring",
+			stiffness: entry.timing.stiffness,
+			damping: entry.timing.damping,
+			mass: entry.timing.mass,
+			...typeof (extra === null || extra === void 0 ? void 0 : extra.velocity) === "number" ? { velocity: extra.velocity } : null,
+			...typeof (extra === null || extra === void 0 ? void 0 : extra.overshootClamping) === "boolean" ? { overshootClamping: extra.overshootClamping } : null,
+			...entry.delayMs ? { delay: entry.delayMs } : null
+		};
+	}
+	var bezier = (0, import_animation_helpers.easingToBezier)(entry.timing.easing);
+	return {
+		type: "timing",
+		duration: entry.timing.durationMs,
+		...bezier ? { easing: import_react_native.Easing.bezier(bezier[0], bezier[1], bezier[2], bezier[3]) } : null,
+		...entry.delayMs ? { delay: entry.delayMs } : null
+	};
+}
+var snapConfig = {
+	type: "timing",
+	duration: 0
+};
+function getAnimationConfig(key, animations, transition) {
+	var animationState = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "default";
+	var resolved = (0, import_animation_helpers.forAnimationState)((0, import_animation_helpers.resolveTransition)(transition, { animations }), animationState);
+	var entry = (0, import_animation_helpers.getTransitionForKey)(resolved, key);
+	return entry ? entryToRN(entry) : snapConfig;
+}
+function getValue(input) {
+	var isColor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+	if (typeof input !== "string") {
+		return [input];
+	}
+	var _input_match;
+	var [_, number, after] = (_input_match = input.match(/(-?(?:\d+\.?\d*|\.\d+))(deg|%|px)?/)) !== null && _input_match !== void 0 ? _input_match : [];
+	return [+number, after];
+}