{"version":3,"file":"AnimatePresence-CwW_7dvJ.cjs","names":["React","React","isHTMLElement","MotionConfigContext","useConstant","PresenceContext","usePresence","useConstant","LayoutGroupContext","Fragment"],"sources":["../node_modules/framer-motion/dist/es/utils/use-composed-ref.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/utils.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs"],"sourcesContent":["import * as React from 'react';\n\n/**\n * Taken from https://github.com/radix-ui/primitives/blob/main/packages/react/compose-refs/src/compose-refs.tsx\n */\n/**\n * Set a given ref to a given value\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nfunction setRef(ref, value) {\n    if (typeof ref === \"function\") {\n        return ref(value);\n    }\n    else if (ref !== null && ref !== undefined) {\n        ref.current = value;\n    }\n}\n/**\n * A utility to compose multiple refs together\n * Accepts callback refs and RefObject(s)\n */\nfunction composeRefs(...refs) {\n    return (node) => {\n        let hasCleanup = false;\n        const cleanups = refs.map((ref) => {\n            const cleanup = setRef(ref, node);\n            if (!hasCleanup && typeof cleanup === \"function\") {\n                hasCleanup = true;\n            }\n            return cleanup;\n        });\n        // React <19 will log an error to the console if a callback ref returns a\n        // value. We don't use ref cleanups internally so this will only happen if a\n        // user's ref callback returns a value, which we only expect if they are\n        // using the cleanup functionality added in React 19.\n        if (hasCleanup) {\n            return () => {\n                for (let i = 0; i < cleanups.length; i++) {\n                    const cleanup = cleanups[i];\n                    if (typeof cleanup === \"function\") {\n                        cleanup();\n                    }\n                    else {\n                        setRef(refs[i], null);\n                    }\n                }\n            };\n        }\n    };\n}\n/**\n * A custom hook that composes multiple refs\n * Accepts callback refs and RefObject(s)\n */\nfunction useComposedRefs(...refs) {\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    return React.useCallback(composeRefs(...refs), refs);\n}\n\nexport { useComposedRefs };\n//# sourceMappingURL=use-composed-ref.mjs.map\n","\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport { isHTMLElement } from 'motion-dom';\nimport * as React from 'react';\nimport { useId, useRef, useContext, useInsertionEffect } from 'react';\nimport { MotionConfigContext } from '../../context/MotionConfigContext.mjs';\nimport { useComposedRefs } from '../../utils/use-composed-ref.mjs';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const parent = element.offsetParent;\n            const parentWidth = isHTMLElement(parent)\n                ? parent.offsetWidth || 0\n                : 0;\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n            size.right = parentWidth - size.width - size.left;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent, anchorX, root }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n        right: 0,\n    });\n    const { nonce } = useContext(MotionConfigContext);\n    /**\n     * In React 19, refs are passed via props.ref instead of element.ref.\n     * We check props.ref first (React 19) and fall back to element.ref (React 18).\n     */\n    const childRef = children.props?.ref ??\n        children?.ref;\n    const composedRef = useComposedRefs(ref, childRef);\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left, right } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        const x = anchorX === \"left\" ? `left: ${left}` : `right: ${right}`;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        if (nonce)\n            style.nonce = nonce;\n        const parent = root ?? document.head;\n        parent.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            ${x}px !important;\n            top: ${top}px !important;\n          }\n        `);\n        }\n        return () => {\n            if (parent.contains(style)) {\n                parent.removeChild(style);\n            }\n        };\n    }, [isPresent]);\n    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref: composedRef }) }));\n}\n\nexport { PopChild };\n//# sourceMappingURL=PopChild.mjs.map\n","\"use client\";\nimport { jsx } from 'react/jsx-runtime';\nimport * as React from 'react';\nimport { useId, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, anchorX, root }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    let isReusedContext = true;\n    let context = useMemo(() => {\n        isReusedContext = false;\n        return {\n            id,\n            initial,\n            isPresent,\n            custom,\n            onExitComplete: (childId) => {\n                presenceChildren.set(childId, true);\n                for (const isComplete of presenceChildren.values()) {\n                    if (!isComplete)\n                        return; // can stop searching when any is incomplete\n                }\n                onExitComplete && onExitComplete();\n            },\n            register: (childId) => {\n                presenceChildren.set(childId, false);\n                return () => presenceChildren.delete(childId);\n            },\n        };\n    }, [isPresent, presenceChildren, onExitComplete]);\n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    if (presenceAffectsLayout && isReusedContext) {\n        context = { ...context };\n    }\n    useMemo(() => {\n        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = (jsx(PopChild, { isPresent: isPresent, anchorX: anchorX, root: root, children: children }));\n    }\n    return (jsx(PresenceContext.Provider, { value: context, children: children }));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n//# sourceMappingURL=PresenceChild.mjs.map\n","import { Children, isValidElement } from 'react';\n\nconst getChildKey = (child) => child.key || \"\";\nfunction onlyElements(children) {\n    const filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    Children.forEach(children, (child) => {\n        if (isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n\nexport { getChildKey, onlyElements };\n//# sourceMappingURL=utils.mjs.map\n","\"use client\";\nimport { jsx, Fragment } from 'react/jsx-runtime';\nimport { useMemo, useRef, useState, useContext } from 'react';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { usePresence } from './use-presence.mjs';\nimport { onlyElements, getChildKey } from './utils.mjs';\n\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = \"sync\", propagate = false, anchorX = \"left\", root }) => {\n    const [isParentPresent, safeToRemove] = usePresence(propagate);\n    /**\n     * Filter any children that aren't ReactElements. We can only track components\n     * between renders with a props.key.\n     */\n    const presentChildren = useMemo(() => onlyElements(children), [children]);\n    /**\n     * Track the keys of the currently rendered children. This is used to\n     * determine which children are exiting.\n     */\n    const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);\n    /**\n     * If `initial={false}` we only want to pass this to components in the first render.\n     */\n    const isInitialRender = useRef(true);\n    /**\n     * A ref containing the currently present children. When all exit animations\n     * are complete, we use this to re-render the component with the latest children\n     * *committed* rather than the latest children *rendered*.\n     */\n    const pendingPresentChildren = useRef(presentChildren);\n    /**\n     * Track which exiting children have finished animating out.\n     */\n    const exitComplete = useConstant(() => new Map());\n    /**\n     * Track which components are currently processing exit to prevent duplicate processing.\n     */\n    const exitingComponents = useRef(new Set());\n    /**\n     * Save children to render as React state. To ensure this component is concurrent-safe,\n     * we check for exiting children via an effect.\n     */\n    const [diffedChildren, setDiffedChildren] = useState(presentChildren);\n    const [renderedChildren, setRenderedChildren] = useState(presentChildren);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        pendingPresentChildren.current = presentChildren;\n        /**\n         * Update complete status of exiting children.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const key = getChildKey(renderedChildren[i]);\n            if (!presentKeys.includes(key)) {\n                if (exitComplete.get(key) !== true) {\n                    exitComplete.set(key, false);\n                }\n            }\n            else {\n                exitComplete.delete(key);\n                exitingComponents.current.delete(key);\n            }\n        }\n    }, [renderedChildren, presentKeys.length, presentKeys.join(\"-\")]);\n    const exitingChildren = [];\n    if (presentChildren !== diffedChildren) {\n        let nextChildren = [...presentChildren];\n        /**\n         * Loop through all the currently rendered components and decide which\n         * are exiting.\n         */\n        for (let i = 0; i < renderedChildren.length; i++) {\n            const child = renderedChildren[i];\n            const key = getChildKey(child);\n            if (!presentKeys.includes(key)) {\n                nextChildren.splice(i, 0, child);\n                exitingChildren.push(child);\n            }\n        }\n        /**\n         * If we're in \"wait\" mode, and we have exiting children, we want to\n         * only render these until they've all exited.\n         */\n        if (mode === \"wait\" && exitingChildren.length) {\n            nextChildren = exitingChildren;\n        }\n        setRenderedChildren(onlyElements(nextChildren));\n        setDiffedChildren(presentChildren);\n        /**\n         * Early return to ensure once we've set state with the latest diffed\n         * children, we can immediately re-render.\n         */\n        return null;\n    }\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        renderedChildren.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    /**\n     * If we've been provided a forceRender function by the LayoutGroupContext,\n     * we can use it to force a re-render amongst all surrounding components once\n     * all components have finished animating out.\n     */\n    const { forceRender } = useContext(LayoutGroupContext);\n    return (jsx(Fragment, { children: renderedChildren.map((child) => {\n            const key = getChildKey(child);\n            const isPresent = propagate && !isParentPresent\n                ? false\n                : presentChildren === renderedChildren ||\n                    presentKeys.includes(key);\n            const onExit = () => {\n                if (exitingComponents.current.has(key)) {\n                    return;\n                }\n                exitingComponents.current.add(key);\n                if (exitComplete.has(key)) {\n                    exitComplete.set(key, true);\n                }\n                else {\n                    return;\n                }\n                let isEveryExitComplete = true;\n                exitComplete.forEach((isExitComplete) => {\n                    if (!isExitComplete)\n                        isEveryExitComplete = false;\n                });\n                if (isEveryExitComplete) {\n                    forceRender?.();\n                    setRenderedChildren(pendingPresentChildren.current);\n                    propagate && safeToRemove?.();\n                    onExitComplete && onExitComplete();\n                }\n            };\n            return (jsx(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial\n                    ? undefined\n                    : false, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, root: root, onExitComplete: isPresent ? undefined : onExit, anchorX: anchorX, children: child }, key));\n        }) }));\n};\n\nexport { AnimatePresence };\n//# sourceMappingURL=index.mjs.map\n"],"x_google_ignoreList":[0,1,2,3,4],"mappings":"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"}