@hanzogui/animations-reanimated 8.3.1 → 8.3.2

package/dist/cjs/createAnimations.cjs

@@ -1,959 +0,0 @@
-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 createAnimations_exports = {};
-__export(createAnimations_exports, {
-  createAnimations: () => createAnimations
-});
-module.exports = __toCommonJS(createAnimations_exports);
-var import_animation_helpers = require("@hanzogui/animation-helpers");
-var import_core = require("@hanzogui/core");
-var import_use_presence = require("@hanzogui/use-presence");
-var import_normalize_colors = __toESM(require("@react-native/normalize-colors"), 1);
-var import_react = __toESM(require("react"), 1);
-var import_react_native_reanimated = __toESM(require("react-native-reanimated"), 1);
-var import_jsx_runtime = require("react/jsx-runtime");
-const getDefaultExport = module2 => {
-  const mod = module2;
-  if (mod.__esModule || mod[Symbol.toStringTag] === "Module") {
-    return mod.default || mod;
-  }
-  return mod;
-};
-const Animated = getDefaultExport(import_react_native_reanimated.default);
-const silenceAnimatedComponentDevCheck = style => {
-  if (process.env.NODE_ENV !== "development" || import_core.isWeb || !style || typeof style !== "object") {
-    return;
-  }
-  Object.defineProperty(style, "_requiresAnimatedComponent", {
-    configurable: true,
-    enumerable: false,
-    value: true
-  });
-};
-const resolveDynamicValue = (value, isDark) => {
-  if (value !== null && typeof value === "object" && "dynamic" in value && typeof value.dynamic === "object") {
-    const dynamic = value.dynamic;
-    return isDark ? dynamic.dark : dynamic.light;
-  }
-  return value;
-};
-const updateMapperState = import_core.isWeb ? (state, emitted) => {
-  state.value.emitted = emitted;
-} : (state, emitted) => {
-  "worklet";
-
-  if (!globalThis._WORKLET) return;
-  state.modify(current => {
-    current.emitted = emitted;
-    return current;
-  }, false);
-};
-const cloneAnimationValue = value => {
-  if (Array.isArray(value)) {
-    return value.map(cloneAnimationValue);
-  }
-  if (value && typeof value === "object") {
-    const next = {};
-    for (const key in value) {
-      next[key] = cloneAnimationValue(value[key]);
-    }
-    return next;
-  }
-  return value;
-};
-const cloneStyleRecord = style => {
-  const next = {};
-  for (const key in style) {
-    next[key] = cloneAnimationValue(style[key]);
-  }
-  return next;
-};
-const cloneTransitionConfig = config => {
-  return cloneAnimationValue(config);
-};
-const getAnimatedTransforms = value => {
-  if (!Array.isArray(value)) return [];
-  return value.filter(item => item !== null && typeof item === "object" && !Array.isArray(item));
-};
-const getRemovedAnimatedKeys = (current, previous) => {
-  const removedKeys = {};
-  for (const key of previous) {
-    if (!current.has(key)) removedKeys[key] = true;
-  }
-  return removedKeys;
-};
-const getImplicitDefault = (key, targetValue) => {
-  "worklet";
-
-  const value = key === "opacity" || key === "scale" || key === "scaleX" || key === "scaleY" ? 1 : 0;
-  if (typeof targetValue !== "string") return value;
-  let suffixIndex = 0;
-  while (suffixIndex < targetValue.length) {
-    const character = targetValue[suffixIndex];
-    const code = character.charCodeAt(0);
-    if (code >= 48 && code <= 57 || character === "." || character === "-" || character === "+") {
-      suffixIndex++;
-    } else {
-      break;
-    }
-  }
-  return suffixIndex > 0 ? `${value}${targetValue.slice(suffixIndex)}` : value;
-};
-const COLOR_STYLE_KEYS = {
-  backgroundColor: true,
-  borderColor: true,
-  borderLeftColor: true,
-  borderRightColor: true,
-  borderTopColor: true,
-  borderBottomColor: true,
-  color: true
-};
-const toReanimatedColor = value => {
-  "worklet";
-
-  if (typeof value === "number") {
-    const color = value >>> 0;
-    const alpha = (color >>> 24 & 255) / 255;
-    const red = color >>> 16 & 255;
-    const green = color >>> 8 & 255;
-    const blue = color & 255;
-    return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
-  }
-  if (typeof value !== "string") return value;
-  const trimmed = value.trim();
-  if (trimmed === "transparent") return "rgba(0, 0, 0, 0)";
-  return trimmed;
-};
-const isReanimatedColorHistory = value => {
-  "worklet";
-
-  const normalized = toReanimatedColor(value);
-  return typeof normalized === "string" && normalized.startsWith("rgba(");
-};
-const normalizeAnimationColor = value => {
-  if (typeof value === "number") {
-    return toReanimatedColor(value);
-  }
-  if (typeof value !== "string") return;
-  const color = (0, import_normalize_colors.default)(value);
-  if (color == null) return;
-  const red = Math.round((color & 4278190080) >>> 24);
-  const green = Math.round((color & 16711680) >>> 16);
-  const blue = Math.round((color & 65280) >>> 8);
-  const alpha = (color & 255) / 255;
-  return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
-};
-const buildSnapshot = (animated, statics, transforms, previousKeys, lastPainted) => {
-  const snapshotAnimated = {};
-  const snapshotStatics = cloneStyleRecord(statics);
-  for (const key in snapshotStatics) {
-    if (!COLOR_STYLE_KEYS[key]) continue;
-    const normalized = normalizeAnimationColor(snapshotStatics[key]);
-    if (normalized !== void 0) snapshotStatics[key] = normalized;
-  }
-  for (const key in animated) {
-    if (key === "transform") continue;
-    const value = animated[key];
-    if (COLOR_STYLE_KEYS[key]) {
-      const normalized = normalizeAnimationColor(value);
-      if (normalized === void 0) {
-        snapshotStatics[key] = cloneAnimationValue(value);
-        continue;
-      }
-      snapshotAnimated[key] = normalized;
-    } else {
-      snapshotAnimated[key] = cloneAnimationValue(value);
-    }
-  }
-  const snapshotTransforms = transforms.map(cloneStyleRecord);
-  const keys = new Set(Object.keys(snapshotAnimated));
-  for (const transform of snapshotTransforms) {
-    const key = Object.keys(transform)[0];
-    const value = key ? transform[key] : void 0;
-    if (key && (typeof value === "number" || typeof value === "string")) {
-      keys.add(`transform:${key}`);
-    }
-  }
-  const seeds = {};
-  for (const key of keys) {
-    let value = lastPainted[key];
-    if (typeof value !== "number" && typeof value !== "string") continue;
-    if (value === "auto" || typeof value === "string" && value.startsWith("calc")) {
-      continue;
-    }
-    if (COLOR_STYLE_KEYS[key]) value = normalizeAnimationColor(value);
-    if (value !== void 0) seeds[key] = value;
-  }
-  const gatedKeys = {};
-  for (const key of keys) gatedKeys[key] = true;
-  const removedKeys = getRemovedAnimatedKeys(keys, previousKeys);
-  const painted = {
-    ...snapshotStatics,
-    ...snapshotAnimated
-  };
-  const staticTransforms = getAnimatedTransforms(snapshotStatics.transform);
-  delete painted.transform;
-  for (const transform of staticTransforms) {
-    const key = Object.keys(transform)[0];
-    if (key) painted[`transform:${key}`] = transform[key];
-  }
-  for (const transform of snapshotTransforms) {
-    const key = Object.keys(transform)[0];
-    if (key) painted[`transform:${key}`] = transform[key];
-  }
-  return {
-    value: {
-      animated: snapshotAnimated,
-      statics: snapshotStatics,
-      transforms: snapshotTransforms,
-      gatedKeys,
-      seeds,
-      removedKeys,
-      removeTransform: Object.keys(removedKeys).some(key => key.startsWith("transform:")),
-      clearValue: import_core.isWeb ? "" : null
-    },
-    painted,
-    keys
-  };
-};
-const getGatedKeys = snapshot => Object.keys(snapshot.gatedKeys);
-const createReanimatedConfig = config => {
-  "worklet";
-
-  const next = {};
-  const source = config;
-  for (const key in source) {
-    if (key === "type" || key === "delay") continue;
-    const value = source[key];
-    if (value !== void 0) {
-      next[key] = value;
-    }
-  }
-  return next;
-};
-const applyAnimation = (targetValue, config, callback, seedValue, validateStartAsColor = false) => {
-  "worklet";
-
-  const delay = config.delay;
-  const reanimatedConfig = createReanimatedConfig(config);
-  let animatedValue;
-  if (config.type === "timing") {
-    animatedValue = (0, import_react_native_reanimated.withTiming)(targetValue, reanimatedConfig, callback);
-  } else {
-    animatedValue = (0, import_react_native_reanimated.withSpring)(targetValue, reanimatedConfig, callback);
-  }
-  if (seedValue !== void 0 || validateStartAsColor) {
-    const innerOnStart = animatedValue.onStart;
-    animatedValue.onStart = (animation, value, timestamp, previousAnimation) => {
-      "worklet";
-
-      const startValue = validateStartAsColor ? isReanimatedColorHistory(value) ? toReanimatedColor(value) : seedValue ?? targetValue : seedValue;
-      innerOnStart(animation, startValue, timestamp, previousAnimation);
-    };
-  }
-  if (delay && delay > 0) {
-    animatedValue = (0, import_react_native_reanimated.withDelay)(delay, animatedValue);
-  }
-  return animatedValue;
-};
-const animateSnapshotValue = (key, implicitKey, targetValue, config, previouslyEmitted, seedValue, gated, currentlyExiting, exitCycleId, currentlyCompletingAnimation, didAnimateCycleId, markExitKeyDone, markDidAnimateKeyDone, validateStartAsColor = false) => {
-  "worklet";
-
-  const cycleGated = gated && (currentlyExiting || currentlyCompletingAnimation);
-  if (!previouslyEmitted && seedValue === void 0 && !cycleGated) {
-    return targetValue;
-  }
-  let callback;
-  if (gated && currentlyExiting) {
-    callback = finished => {
-      "worklet";
-
-      (0, import_react_native_reanimated.runOnJS)(markExitKeyDone)(key, exitCycleId, finished ?? false);
-    };
-  } else if (gated && currentlyCompletingAnimation) {
-    callback = finished => {
-      "worklet";
-
-      (0, import_react_native_reanimated.runOnJS)(markDidAnimateKeyDone)(key, didAnimateCycleId, finished ?? false);
-    };
-  }
-  return applyAnimation(targetValue, config, callback, previouslyEmitted ? void 0 : seedValue ?? getImplicitDefault(implicitKey, targetValue), validateStartAsColor);
-};
-const ANIMATABLE_PROPERTIES = {
-  // Transform
-  transform: true,
-  // Opacity
-  opacity: true,
-  // Dimensions
-  height: true,
-  width: true,
-  minWidth: true,
-  minHeight: true,
-  maxWidth: true,
-  maxHeight: true,
-  // Background
-  backgroundColor: true,
-  // Border colors
-  borderColor: true,
-  borderLeftColor: true,
-  borderRightColor: true,
-  borderTopColor: true,
-  borderBottomColor: true,
-  // Border radius
-  borderRadius: true,
-  borderTopLeftRadius: true,
-  borderTopRightRadius: true,
-  borderBottomLeftRadius: true,
-  borderBottomRightRadius: true,
-  // Border width
-  borderWidth: true,
-  borderLeftWidth: true,
-  borderRightWidth: true,
-  borderTopWidth: true,
-  borderBottomWidth: true,
-  // Text
-  color: true,
-  fontSize: true,
-  fontWeight: true,
-  lineHeight: true,
-  letterSpacing: true,
-  // Position
-  left: true,
-  right: true,
-  top: true,
-  bottom: true,
-  // Margin
-  margin: true,
-  marginTop: true,
-  marginBottom: true,
-  marginLeft: true,
-  marginRight: true,
-  marginHorizontal: true,
-  marginVertical: true,
-  // Padding
-  padding: true,
-  paddingTop: true,
-  paddingBottom: true,
-  paddingLeft: true,
-  paddingRight: true,
-  paddingHorizontal: true,
-  paddingVertical: true,
-  // Flex/Gap
-  gap: true,
-  rowGap: true,
-  columnGap: true,
-  flex: true,
-  flexGrow: true,
-  flexShrink: true
-};
-const canAnimateProperty = (key, value, animateOnly) => {
-  if (!ANIMATABLE_PROPERTIES[key]) return false;
-  if (value === "auto") return false;
-  if (typeof value === "string" && value.startsWith("calc")) return false;
-  if (animateOnly && !animateOnly.includes(key)) return false;
-  return true;
-};
-const splitAnimationStyles = (style, isDark, disableAnimation, animateOnly) => {
-  const animated = {};
-  const statics = {};
-  for (const key in style) {
-    const value = resolveDynamicValue(style[key], isDark);
-    if (value === void 0) continue;
-    if (!disableAnimation && canAnimateProperty(key, value, animateOnly)) {
-      animated[key] = cloneAnimationValue(value);
-    } else {
-      statics[key] = cloneAnimationValue(value);
-    }
-  }
-  return {
-    animated,
-    statics
-  };
-};
-function createWebAnimatedComponent(defaultTag) {
-  const isText = defaultTag === "span";
-  const Component = Animated.createAnimatedComponent((0, import_react.forwardRef)((propsIn, ref) => {
-    const {
-      forwardedRef,
-      render = defaultTag,
-      ...rest
-    } = propsIn;
-    const hostRef = (0, import_react.useRef)(null);
-    const composedRefs = (0, import_core.useComposedRefs)(forwardedRef, ref, hostRef);
-    const stateRef = (0, import_react.useRef)({
-      get host() {
-        return hostRef.current;
-      }
-    });
-    const [, themeState] = (0, import_core.useThemeWithState)({});
-    const result = (0, import_core.getSplitStyles)(rest, isText ? import_core.Text.staticConfig : import_core.View.staticConfig, themeState?.theme ?? {}, themeState?.name ?? "", {
-      unmounted: false
-    }, {
-      isAnimated: false,
-      noClass: true
-    });
-    const viewProps = result?.viewProps ?? {};
-    const Element = render;
-    const transformedProps = import_core.hooks.usePropsTransform?.(render, viewProps, stateRef, false);
-    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(Element, {
-      ...transformedProps,
-      ref: composedRefs
-    });
-  }));
-  Component.acceptRenderProp = true;
-  return Component;
-}
-const AnimatedView = createWebAnimatedComponent("div");
-const AnimatedText = createWebAnimatedComponent("span");
-function buildTransitionConfig(transition, animations, animationState, styleKeys) {
-  const normalized = (0, import_animation_helpers.normalizeTransition)(transition);
-  const effectiveKey = (0, import_animation_helpers.getEffectiveAnimation)(normalized, animationState);
-  let base = cloneTransitionConfig(effectiveKey ? animations[effectiveKey] ?? {
-    type: "spring"
-  } : {
-    type: "spring"
-  });
-  if (normalized.delay) {
-    base = cloneTransitionConfig({
-      ...base,
-      delay: normalized.delay
-    });
-  }
-  if (normalized.config) {
-    base = cloneTransitionConfig({
-      ...base,
-      ...normalized.config
-    });
-    if (base.type !== "timing" && normalized.config.duration !== void 0 && normalized.config.damping === void 0 && normalized.config.stiffness === void 0 && normalized.config.mass === void 0) {
-      base = cloneTransitionConfig({
-        ...base,
-        type: "timing"
-      });
-    }
-  }
-  const propertyConfigs = {};
-  for (const key of styleKeys) {
-    const propAnimation = normalized.properties[key];
-    if (typeof propAnimation === "string") {
-      propertyConfigs[key] = cloneTransitionConfig(animations[propAnimation] ?? base);
-    } else if (propAnimation && typeof propAnimation === "object") {
-      const configType = propAnimation.type;
-      const baseForProp = configType ? animations[configType] ?? base : base;
-      propertyConfigs[key] = cloneTransitionConfig({
-        ...baseForProp,
-        ...propAnimation
-      });
-    } else {
-      propertyConfigs[key] = cloneTransitionConfig(base);
-    }
-  }
-  return {
-    baseConfig: base,
-    propertyConfigs
-  };
-}
-function getStyleKeys(style) {
-  const keys = new Set(Object.keys(style));
-  if (style.transform && Array.isArray(style.transform)) {
-    for (const t of style.transform) {
-      if (t && typeof t === "object") {
-        keys.add(Object.keys(t)[0]);
-      }
-    }
-  }
-  return keys;
-}
-function createAnimations(animationsConfig) {
-  const animations = {};
-  for (const key in animationsConfig) {
-    animations[key] = cloneTransitionConfig({
-      type: "spring",
-      ...animationsConfig[key]
-    });
-  }
-  return {
-    needsCustomComponent: true,
-    View: import_core.isWeb ? AnimatedView : Animated.View,
-    Text: import_core.isWeb ? AnimatedText : Animated.Text,
-    isReactNative: true,
-    inputStyle: "value",
-    outputStyle: "inline",
-    avoidReRenders: true,
-    animations,
-    usePresence: import_use_presence.usePresence,
-    ResetPresence: import_use_presence.ResetPresence,
-    // =========================================================================
-    // useAnimatedNumber - For imperative animated values
-    // =========================================================================
-    useAnimatedNumber(initial) {
-      const sharedValue = (0, import_react_native_reanimated.useSharedValue)(initial);
-      return (0, import_react.useMemo)(() => ({
-        getInstance() {
-          "worklet";
-
-          return sharedValue;
-        },
-        getValue() {
-          "worklet";
-
-          return sharedValue.value;
-        },
-        setValue(next, config = {
-          type: "spring"
-        }, onFinish) {
-          if (config.type === "direct") {
-            sharedValue.value = next;
-            onFinish?.();
-          } else {
-            const cb = onFinish ? finished => {
-              "worklet";
-
-              if (finished !== false) {
-                (0, import_react_native_reanimated.runOnJS)(onFinish)();
-              }
-            } : void 0;
-            const animationConfig = cloneTransitionConfig(config);
-            if (import_core.isWeb) {
-              sharedValue.value = applyAnimation(next, animationConfig, cb);
-            } else {
-              (0, import_react_native_reanimated.runOnUI)((targetValue, animationConfig2) => {
-                "worklet";
-
-                sharedValue.value = applyAnimation(targetValue, animationConfig2, cb);
-              })(next, animationConfig);
-            }
-          }
-        },
-        stop() {
-          (0, import_react_native_reanimated.cancelAnimation)(sharedValue);
-        }
-      }), [sharedValue]);
-    },
-    // =========================================================================
-    // useAnimatedNumberReaction - React to animated value changes
-    // =========================================================================
-    useAnimatedNumberReaction({
-      value
-    }, onValue) {
-      const instance = value.getInstance();
-      return (0, import_react_native_reanimated.useAnimatedReaction)(() => instance.value, (next, prev) => {
-        if (prev !== next) {
-          (0, import_react_native_reanimated.runOnJS)(onValue)(next);
-        }
-      }, [onValue, instance]);
-    },
-    // =========================================================================
-    // useAnimatedNumberStyle - Create animated styles from values
-    // =========================================================================
-    useAnimatedNumberStyle(val, getStyle) {
-      const instance = val.getInstance();
-      if (import_core.isWeb) {
-        return (0, import_react_native_reanimated.useAnimatedStyle)(() => {
-          "worklet";
-
-          return getStyle(instance.value);
-        }, [instance, getStyle]);
-      }
-      const styleVal = (0, import_react_native_reanimated.useDerivedValue)(() => {
-        "worklet";
-
-        return getStyle(instance.value);
-      });
-      const animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(() => {
-        "worklet";
-
-        return styleVal.value;
-      });
-      silenceAnimatedComponentDevCheck(animatedStyle);
-      return animatedStyle;
-    },
-    useAnimatedNumbersStyle(vals, getStyle) {
-      const instances = vals.map(v => v.getInstance());
-      const animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(() => {
-        "worklet";
-
-        const currentValues = instances.map(inst => inst.value);
-        return getStyle(...currentValues);
-      }, import_core.isWeb ? [getStyle, ...instances] : void 0);
-      silenceAnimatedComponentDevCheck(animatedStyle);
-      return animatedStyle;
-    },
-    // =========================================================================
-    // useAnimations - Main animation hook for components
-    // =========================================================================
-    useAnimations(animationProps) {
-      const {
-        props,
-        presence,
-        style,
-        componentState,
-        useStyleEmitter,
-        themeName,
-        stateRef,
-        styleState,
-        onDidAnimate
-      } = animationProps;
-      const isHydrating = componentState.unmounted === true;
-      const isMounting = componentState.unmounted === "should-enter";
-      const isEntering = !!componentState.unmounted;
-      const isExiting = presence?.[0] === false;
-      const wasEnteringRef = (0, import_react.useRef)(isEntering);
-      const justFinishedEntering = wasEnteringRef.current && !isEntering;
-      import_react.default.useEffect(() => {
-        wasEnteringRef.current = isEntering;
-      });
-      const effectiveTransition = styleState?.effectiveTransition ?? props.transition;
-      const normalized = (0, import_animation_helpers.normalizeTransition)(effectiveTransition);
-      const animationState = isExiting ? "exit" : isMounting || justFinishedEntering ? "enter" : "default";
-      const animationKey = (0, import_animation_helpers.getEffectiveAnimation)(normalized, animationState);
-      const disableAnimation = isHydrating || !animationKey;
-      const isDark = themeName?.startsWith("dark") || false;
-      const sendExitComplete = presence?.[1];
-      const onDidAnimateRef = (0, import_react.useRef)(onDidAnimate);
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        onDidAnimateRef.current = onDidAnimate;
-      }, [onDidAnimate]);
-      const didAnimateCycleIdRef = (0, import_react.useRef)(0);
-      const pendingDidAnimateKeysRef = (0, import_react.useRef)(/* @__PURE__ */new Set());
-      const didAnimateCompletedRef = (0, import_react.useRef)(false);
-      const isCompletingAnimationRef = (0, import_react_native_reanimated.useSharedValue)(false);
-      const didAnimateCycleIdShared = (0, import_react_native_reanimated.useSharedValue)(0);
-      const markDidAnimateKeyDone = (0, import_core.useEvent)((key, cycleId, finished) => {
-        if (!finished || cycleId !== didAnimateCycleIdRef.current) return;
-        if (didAnimateCompletedRef.current) return;
-        pendingDidAnimateKeysRef.current.delete(key);
-        if (pendingDidAnimateKeysRef.current.size === 0) {
-          didAnimateCompletedRef.current = true;
-          isCompletingAnimationRef.value = false;
-          onDidAnimateRef.current?.();
-        }
-      });
-      const exitCycleIdRef = (0, import_react.useRef)(0);
-      const pendingExitKeysRef = (0, import_react.useRef)(/* @__PURE__ */new Set());
-      const exitCompletedRef = (0, import_react.useRef)(false);
-      const wasExitingRef = (0, import_react.useRef)(false);
-      const justStartedExiting = isExiting && !wasExitingRef.current;
-      const justStoppedExiting = !isExiting && wasExitingRef.current;
-      const markExitKeyDone = (0, import_core.useEvent)((key, cycleId, finished) => {
-        if (cycleId !== exitCycleIdRef.current) return;
-        if (exitCompletedRef.current) return;
-        pendingExitKeysRef.current.delete(key);
-        if (pendingExitKeysRef.current.size === 0) {
-          exitCompletedRef.current = true;
-          sendExitComplete?.();
-        }
-      });
-      const isExitingRef = (0, import_react_native_reanimated.useSharedValue)(isExiting);
-      const exitCycleIdShared = (0, import_react_native_reanimated.useSharedValue)(exitCycleIdRef.current);
-      if (justStartedExiting) {
-        exitCycleIdRef.current++;
-        exitCompletedRef.current = false;
-        pendingExitKeysRef.current.clear();
-        didAnimateCycleIdRef.current++;
-        pendingDidAnimateKeysRef.current.clear();
-        didAnimateCompletedRef.current = true;
-      }
-      if (justStoppedExiting) {
-        exitCycleIdRef.current++;
-        pendingExitKeysRef.current.clear();
-      }
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        isExitingRef.value = isExiting;
-        exitCycleIdShared.value = exitCycleIdRef.current;
-        if (justStartedExiting) {
-          isCompletingAnimationRef.value = false;
-          didAnimateCycleIdShared.value = didAnimateCycleIdRef.current;
-        }
-      }, [isExiting, exitCycleIdRef.current, justStartedExiting]);
-      import_react.default.useEffect(() => {
-        wasExitingRef.current = isExiting;
-      });
-      const committedRenderKeysRef = (0, import_react.useRef)(/* @__PURE__ */new Set());
-      const lastPaintedRef = (0, import_react.useRef)({});
-      const carryRef = (0, import_react.useRef)({});
-      const {
-        animatedStyles,
-        staticStyles,
-        nextCarry
-      } = (0, import_react.useMemo)(() => {
-        const animateOnly = props.animateOnly;
-        const {
-          animated,
-          statics
-        } = splitAnimationStyles(style, isDark, disableAnimation, animateOnly);
-        const nextCarry2 = cloneStyleRecord(carryRef.current);
-        for (const key in nextCarry2) {
-          if (!(key in animated)) delete nextCarry2[key];
-        }
-        for (const key in animated) {
-          if (!(key in nextCarry2)) {
-            nextCarry2[key] = cloneAnimationValue(animated[key]);
-          }
-          statics[key] = nextCarry2[key];
-        }
-        return {
-          animatedStyles: animated,
-          staticStyles: statics,
-          nextCarry: nextCarry2
-        };
-      }, [disableAnimation, style, isDark, props.animateOnly]);
-      const renderSnapshot = (0, import_react.useMemo)(() => buildSnapshot(animatedStyles, staticStyles, getAnimatedTransforms(animatedStyles.transform), committedRenderKeysRef.current, lastPaintedRef.current), [animatedStyles, staticStyles]);
-      const renderSnapshotRef = (0, import_react_native_reanimated.useSharedValue)({
-        animated: {},
-        statics: {},
-        transforms: [],
-        gatedKeys: {},
-        seeds: {},
-        removedKeys: {},
-        removeTransform: false,
-        clearValue: import_core.isWeb ? "" : null
-      });
-      const emitterSnapshotRef = (0, import_react_native_reanimated.useSharedValue)(null);
-      const emitterKeysRef = (0, import_react.useRef)(null);
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        carryRef.current = nextCarry;
-        committedRenderKeysRef.current = renderSnapshot.keys;
-        lastPaintedRef.current = renderSnapshot.painted;
-      }, [nextCarry, renderSnapshot]);
-      const pseudoActiveRef = (0, import_react.useRef)(false);
-      const isExitingJSRef = (0, import_react.useRef)(false);
-      isExitingJSRef.current = isExiting;
-      const publishedSnapshotRef = (0, import_react.useRef)(null);
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        const droppingLatch = (isExiting || !pseudoActiveRef.current) && emitterSnapshotRef.value !== null;
-        const emitterKeys = droppingLatch ? emitterKeysRef.current : null;
-        if (droppingLatch || publishedSnapshotRef.current !== renderSnapshot.value) {
-          const removedKeys = emitterKeys ? {
-            ...renderSnapshot.value.removedKeys,
-            ...getRemovedAnimatedKeys(renderSnapshot.keys, emitterKeys)
-          } : renderSnapshot.value.removedKeys;
-          renderSnapshotRef.value = {
-            ...renderSnapshot.value,
-            removedKeys,
-            removeTransform: Object.keys(removedKeys).some(key => key.startsWith("transform:"))
-          };
-          publishedSnapshotRef.current = renderSnapshot.value;
-        }
-        if (droppingLatch) {
-          emitterSnapshotRef.value = null;
-          emitterKeysRef.current = null;
-        }
-      });
-      const {
-        baseConfig,
-        propertyConfigs
-      } = (0, import_react.useMemo)(() => {
-        if (isHydrating) {
-          return {
-            baseConfig: {
-              type: "timing",
-              duration: 0
-            },
-            propertyConfigs: {}
-          };
-        }
-        return buildTransitionConfig(effectiveTransition, animations, animationState, getStyleKeys(animatedStyles));
-      }, [isHydrating, effectiveTransition, animatedStyles, animationState]);
-      const configRef = (0, import_react_native_reanimated.useSharedValue)({
-        baseConfig,
-        propertyConfigs,
-        disableAnimation,
-        isHydrating
-      });
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        configRef.value = {
-          baseConfig,
-          propertyConfigs,
-          disableAnimation,
-          isHydrating
-        };
-      }, [baseConfig, propertyConfigs, disableAnimation, isHydrating]);
-      useStyleEmitter?.((nextStyle, effectiveTransition2, pseudoActive) => {
-        if (isExitingJSRef.current) return;
-        pseudoActiveRef.current = pseudoActive === true;
-        const animateOnly = props.animateOnly;
-        const transitionToUse = effectiveTransition2 ?? props.transition;
-        const {
-          baseConfig: newBase,
-          propertyConfigs: newPropertyConfigs
-        } = buildTransitionConfig(transitionToUse, animations, animationState, getStyleKeys(nextStyle));
-        configRef.value = {
-          baseConfig: newBase,
-          propertyConfigs: newPropertyConfigs,
-          disableAnimation: configRef.value.disableAnimation,
-          isHydrating: configRef.value.isHydrating
-        };
-        const previousKeys = emitterKeysRef.current ?? committedRenderKeysRef.current;
-        const {
-          animated,
-          statics
-        } = splitAnimationStyles(nextStyle, isDark, configRef.value.disableAnimation, animateOnly);
-        const snapshot = buildSnapshot(animated, statics, getAnimatedTransforms(animated.transform), previousKeys, lastPaintedRef.current);
-        emitterSnapshotRef.value = snapshot.value;
-        emitterKeysRef.current = snapshot.keys;
-        lastPaintedRef.current = snapshot.painted;
-        if (process.env.NODE_ENV === "development" && props.debug && props.debug !== "profile") {
-          console.info("[animations-reanimated] useStyleEmitter update", {
-            animated,
-            statics,
-            transforms: snapshot.value.transforms
-          });
-        }
-      });
-      const exitKeysRegistered = (0, import_react.useRef)(false);
-      if (justStartedExiting && sendExitComplete) {
-        const exitKeys = getGatedKeys(renderSnapshot.value);
-        pendingExitKeysRef.current = new Set(exitKeys);
-        exitKeysRegistered.current = exitKeys.length > 0;
-      }
-      const previousDidAnimateStyleRef = (0, import_react.useRef)(null);
-      const didAnimateStyle = onDidAnimate ? JSON.stringify(style) : null;
-      const previousDidAnimateStyle = previousDidAnimateStyleRef.current;
-      const shouldRegisterDidAnimate = didAnimateStyle !== null && previousDidAnimateStyle !== null && previousDidAnimateStyle !== didAnimateStyle && !isExiting && !isEntering && !justFinishedEntering;
-      const didAnimateKeys = shouldRegisterDidAnimate ? getGatedKeys(renderSnapshot.value) : [];
-      (0, import_core.useIsomorphicLayoutEffect)(() => {
-        if (didAnimateStyle === null) {
-          previousDidAnimateStyleRef.current = null;
-          isCompletingAnimationRef.value = false;
-          return;
-        }
-        const previousStyleStillCurrent = previousDidAnimateStyleRef.current === previousDidAnimateStyle;
-        previousDidAnimateStyleRef.current = didAnimateStyle;
-        if (!shouldRegisterDidAnimate || !previousStyleStillCurrent) return;
-        const cycleId = ++didAnimateCycleIdRef.current;
-        pendingDidAnimateKeysRef.current = new Set(didAnimateKeys);
-        didAnimateCompletedRef.current = didAnimateKeys.length === 0;
-        isCompletingAnimationRef.value = didAnimateKeys.length > 0;
-        didAnimateCycleIdShared.value = cycleId;
-        if (didAnimateKeys.length === 0) {
-          onDidAnimateRef.current?.();
-        }
-      }, [didAnimateStyle, shouldRegisterDidAnimate]);
-      import_react.default.useEffect(() => {
-        if (!justStartedExiting || !sendExitComplete) return;
-        if (!exitKeysRegistered.current && pendingExitKeysRef.current.size === 0) {
-          if (!exitCompletedRef.current) {
-            exitCompletedRef.current = true;
-            sendExitComplete();
-          }
-        }
-      }, [justStartedExiting, sendExitComplete]);
-      const mapperStateRef = (0, import_react_native_reanimated.useSharedValue)({
-        emitted: {}
-      });
-      const animatedStyle = (0, import_react_native_reanimated.useAnimatedStyle)(() => {
-        "worklet";
-
-        const mapperState = mapperStateRef.value;
-        const config = configRef.value;
-        if (config.disableAnimation || config.isHydrating) {
-          updateMapperState(mapperStateRef, {});
-          return {};
-        }
-        const previouslyEmitted = mapperState.emitted;
-        const emitted = {};
-        const result = {};
-        const emitterSnapshot = emitterSnapshotRef.value;
-        const snapshot = emitterSnapshot ?? renderSnapshotRef.value;
-        const animatedValues = snapshot.animated;
-        const staticValues = snapshot.statics;
-        const currentlyExiting = isExitingRef.value;
-        const currentCycleId = exitCycleIdShared.value;
-        const currentlyCompletingAnimation = isCompletingAnimationRef.value;
-        const currentDidAnimateCycleId = didAnimateCycleIdShared.value;
-        for (const key in staticValues) {
-          result[key] = staticValues[key];
-        }
-        for (const key in snapshot.removedKeys) {
-          if (!key.startsWith("transform:") && !(key in staticValues)) {
-            result[key] = snapshot.clearValue;
-          }
-        }
-        for (const key in animatedValues) {
-          if (key === "transform") continue;
-          const targetValue = animatedValues[key];
-          emitted[key] = true;
-          if (typeof targetValue !== "number" && typeof targetValue !== "string") {
-            result[key] = targetValue;
-            continue;
-          }
-          result[key] = animateSnapshotValue(key, key, targetValue, config.propertyConfigs[key] ?? config.baseConfig, !!previouslyEmitted[key], snapshot.seeds[key], !!snapshot.gatedKeys[key], currentlyExiting, currentCycleId, currentlyCompletingAnimation, currentDidAnimateCycleId, markExitKeyDone, markDidAnimateKeyDone, !!COLOR_STYLE_KEYS[key]);
-        }
-        const transforms = snapshot.transforms;
-        if (transforms.length > 0 || snapshot.removeTransform) {
-          const validTransforms = [];
-          for (const t of transforms) {
-            if (!t) continue;
-            const keys = Object.keys(t);
-            if (keys.length === 0) continue;
-            const transformKey = keys[0];
-            const value = t[transformKey];
-            if (typeof value === "number" || typeof value === "string") {
-              const propConfig = config.propertyConfigs[transformKey] ?? config.baseConfig;
-              const subKey = `transform:${transformKey}`;
-              emitted[subKey] = true;
-              validTransforms.push({
-                [transformKey]: animateSnapshotValue(subKey, transformKey, value, propConfig, !!previouslyEmitted[subKey], snapshot.seeds[subKey], !!snapshot.gatedKeys[subKey], currentlyExiting, currentCycleId, currentlyCompletingAnimation, currentDidAnimateCycleId, markExitKeyDone, markDidAnimateKeyDone)
-              });
-            } else {
-              validTransforms.push(t);
-            }
-          }
-          if (validTransforms.length > 0 || !("transform" in staticValues)) {
-            result.transform = validTransforms;
-          }
-        }
-        updateMapperState(mapperStateRef, emitted);
-        return result;
-      }, import_core.isWeb ? [
-      // pass SharedValues so the stable mapper watches them on web (no babel plugin)
-      renderSnapshotRef, emitterSnapshotRef, configRef, isExitingRef, exitCycleIdShared, markExitKeyDone, isCompletingAnimationRef, didAnimateCycleIdShared, markDidAnimateKeyDone] : void 0);
-      silenceAnimatedComponentDevCheck(animatedStyle);
-      if (process.env.NODE_ENV === "development" && props.debug && props.debug !== "profile") {
-        console.info("[animations-reanimated] useAnimations", {
-          animationKey,
-          componentState,
-          isExiting,
-          animatedStyles,
-          staticStyles,
-          baseConfig,
-          propertyConfigs
-        });
-      }
-      return {
-        style: [staticStyles, animatedStyle]
-      };
-    }
-  };
-}