framer-motion 11.3.2 → 11.3.4

package/dist/framer-motion.dev.js

@@ -91,38 +91,13 @@
         useManualTiming: false,
     };
 
-    class Queue {
-        constructor() {
-            this.order = [];
-            this.scheduled = new Set();
-        }
-        add(process) {
-            if (!this.scheduled.has(process)) {
-                this.scheduled.add(process);
-                this.order.push(process);
-                return true;
-            }
-        }
-        remove(process) {
-            const index = this.order.indexOf(process);
-            if (index !== -1) {
-                this.order.splice(index, 1);
-                this.scheduled.delete(process);
-            }
-        }
-        clear() {
-            this.order.length = 0;
-            this.scheduled.clear();
-        }
-    }
     function createRenderStep(runNextFrame) {
         /**
          * We create and reuse two queues, one to queue jobs for the current frame
          * and one for the next. We reuse to avoid triggering GC after x frames.
          */
-        let thisFrame = new Queue();
-        let nextFrame = new Queue();
-        let numToRun = 0;
+        let thisFrame = new Set();
+        let nextFrame = new Set();
         /**
          * Track whether we're currently processing jobs in this step. This way
          * we can decide whether to schedule new jobs for this frame or next.
@@ -133,6 +108,18 @@
          * A set of processes which were marked keepAlive when scheduled.
          */
         const toKeepAlive = new WeakSet();
+        let latestFrameData = {
+            delta: 0,
+            timestamp: 0,
+            isProcessing: false,
+        };
+        function triggerCallback(callback) {
+            if (toKeepAlive.has(callback)) {
+                step.schedule(callback);
+                runNextFrame();
+            }
+            callback(latestFrameData);
+        }
         const step = {
             /**
              * Schedule a process to run on the next frame.
@@ -142,23 +129,22 @@
                 const queue = addToCurrentFrame ? thisFrame : nextFrame;
                 if (keepAlive)
                     toKeepAlive.add(callback);
-                if (queue.add(callback) && addToCurrentFrame && isProcessing) {
-                    // If we're adding it to the currently running queue, update its measured size
-                    numToRun = thisFrame.order.length;
-                }
+                if (!queue.has(callback))
+                    queue.add(callback);
                 return callback;
             },
             /**
              * Cancel the provided callback from running on the next frame.
              */
             cancel: (callback) => {
-                nextFrame.remove(callback);
+                nextFrame.delete(callback);
                 toKeepAlive.delete(callback);
             },
             /**
              * Execute all schedule callbacks.
              */
             process: (frameData) => {
+                latestFrameData = frameData;
                 /**
                  * If we're already processing we've probably been triggered by a flushSync
                  * inside an existing process. Instead of executing, mark flushNextFrame
@@ -173,17 +159,7 @@
                 // Clear the next frame queue
                 nextFrame.clear();
                 // Execute this frame
-                numToRun = thisFrame.order.length;
-                if (numToRun) {
-                    for (let i = 0; i < numToRun; i++) {
-                        const callback = thisFrame.order[i];
-                        if (toKeepAlive.has(callback)) {
-                            step.schedule(callback);
-                            runNextFrame();
-                        }
-                        callback(frameData);
-                    }
-                }
+                thisFrame.forEach(triggerCallback);
                 isProcessing = false;
                 if (flushNextFrame) {
                     flushNextFrame = false;
@@ -4869,7 +4845,7 @@
              * This will be replaced by the build step with the latest version number.
              * When MotionValues are provided to motion components, warn if versions are mixed.
              */
-            this.version = "11.3.2";
+            this.version = "11.3.4";
             /**
              * Tracks whether this value can output a velocity. Currently this is only true
              * if the value is numerical, but we might be able to widen the scope here and support
@@ -6236,10 +6212,10 @@
              * TODO: Prefer to remove this, but currently we have motion components with
              * display: contents in Framer.
              */
-            const instance = node.instance;
-            if (instance &&
-                instance.style &&
-                instance.style.display === "contents") {
+            const { visualElement } = node.options;
+            if (visualElement &&
+                visualElement.props.style &&
+                visualElement.props.style.display === "contents") {
                 continue;
             }
             if (isSharedTransition &&
@@ -7317,7 +7293,7 @@
                  * and warn against mismatches.
                  */
                 {
-                    warnOnce(nextValue.version === "11.3.2", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.3.2 may not work as expected.`);
+                    warnOnce(nextValue.version === "11.3.4", `Attempting to mix Framer Motion versions ${nextValue.version} with 11.3.4 may not work as expected.`);
                 }
             }
             else if (isMotionValue(prevValue)) {