framer-motion 12.24.2 → 12.24.4

package/dist/framer-motion.dev.js

@@ -4731,7 +4731,13 @@
         value.attach((v, set) => {
             latestValue = v;
             latestSetter = (latest) => set(parseValue(latest, unit));
-            frame.postRender(startAnimation);
+            frame.postRender(() => {
+                startAnimation();
+                value['events'].animationStart?.notify();
+                activeAnimation?.then(() => {
+                    value['events'].animationComplete?.notify();
+                });
+            });
         }, stopAnimation);
         if (isMotionValue(source)) {
             const removeSourceOnChange = source.on("change", (v) => value.set(parseValue(v, unit)));
@@ -5102,7 +5108,7 @@
      * Set a given ref to a given value
      * This utility takes care of different types of refs: callback refs and RefObject(s)
      */
-    function setRef(ref, value) {
+    function setRef$1(ref, value) {
         if (typeof ref === "function") {
             return ref(value);
         }
@@ -5118,7 +5124,7 @@
         return (node) => {
             let hasCleanup = false;
             const cleanups = refs.map((ref) => {
-                const cleanup = setRef(ref, node);
+                const cleanup = setRef$1(ref, node);
                 if (!hasCleanup && typeof cleanup === "function") {
                     hasCleanup = true;
                 }
@@ -5136,7 +5142,7 @@
                             cleanup();
                         }
                         else {
-                            setRef(refs[i], null);
+                            setRef$1(refs[i], null);
                         }
                     }
                 };
@@ -9696,11 +9702,26 @@
             Object.prototype.hasOwnProperty.call(ref, "current"));
     }
 
+    /**
+     * Set a given ref to a given value
+     * This utility takes care of different types of refs: callback refs and RefObject(s)
+     * Returns a cleanup function if the ref callback returns one (React 19 feature)
+     */
+    function setRef(ref, value) {
+        if (typeof ref === "function") {
+            return ref(value);
+        }
+        else if (isRefObject(ref)) {
+            ref.current = value;
+        }
+    }
     /**
      * Creates a ref function that, when called, hydrates the provided
      * external ref and VisualElement.
      */
     function useMotionRef(visualState, visualElement, externalRef) {
+        // Store the cleanup function from external ref if it returns one
+        const externalRefCleanupRef = React$1.useRef(null);
         return React$1.useCallback((instance) => {
             if (instance) {
                 visualState.onMount && visualState.onMount(instance);
@@ -9714,19 +9735,30 @@
                 }
             }
             if (externalRef) {
-                if (typeof externalRef === "function") {
-                    externalRef(instance);
+                if (instance) {
+                    // Mount: call the external ref and store any cleanup function
+                    const cleanup = setRef(externalRef, instance);
+                    if (typeof cleanup === "function") {
+                        externalRefCleanupRef.current = cleanup;
+                    }
                 }
-                else if (isRefObject(externalRef)) {
-                    externalRef.current = instance;
+                else {
+                    // Unmount: call stored cleanup function if available, otherwise call ref with null
+                    if (externalRefCleanupRef.current) {
+                        externalRefCleanupRef.current();
+                        externalRefCleanupRef.current = null;
+                    }
+                    else {
+                        // Fallback to React <19 behavior for refs that don't return cleanup
+                        setRef(externalRef, instance);
+                    }
                 }
             }
         }, 
         /**
-         * Include externalRef in dependencies to ensure the callback updates
-         * when the ref changes, allowing proper ref forwarding.
+         * Include all dependencies to ensure the callback updates correctly
          */
-        [visualElement]);
+        [visualElement, visualState, externalRef]);
     }
 
     /**