framer-motion 12.4.13 → 12.6.0

package/dist/{types.d-6pKw1mTI.d.ts → types.d-B50aGbjN.d.ts}

@@ -1,13 +1,9 @@
 /// <reference types="react" />
-import { Easing, TransformProperties, SVGPathProperties, VariableKeyframesDefinition, AnimationPlaybackControls, ValueAnimationOptions, Transition as Transition$1, EasingFunction, ProgressTimeline } from 'motion-dom';
+import { Easing, TransformProperties, SVGPathProperties, VariableKeyframesDefinition, MotionValue, AnimationPlaybackControls, ValueAnimationOptions, Transition as Transition$1, EasingFunction, ProgressTimeline, Batcher } from 'motion-dom';
 import * as React$1 from 'react';
 import { SVGAttributes, CSSProperties, PropsWithoutRef, RefAttributes, JSX } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-type RefObject<T> = {
-    current: T | null;
-};
-
 interface Point {
     x: number;
     y: number;
@@ -38,81 +34,6 @@ interface Delta {
 }
 type TransformPoint = (point: Point) => Point;
 
-/**
- * Passed in to pan event handlers like `onPan` the `PanInfo` object contains
- * information about the current state of the tap gesture such as its
- * `point`, `delta`, `offset` and `velocity`.
- *
- * ```jsx
- * <motion.div onPan={(event, info) => {
- *   console.log(info.point.x, info.point.y)
- * }} />
- * ```
- *
- * @public
- */
-interface PanInfo {
-    /**
-     * Contains `x` and `y` values for the current pan position relative
-     * to the device or page.
-     *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.point.x, info.point.y)
-     * }
-     *
-     * <motion.div onPan={onPan} />
-     * ```
-     *
-     * @public
-     */
-    point: Point;
-    /**
-     * Contains `x` and `y` values for the distance moved since
-     * the last event.
-     *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.delta.x, info.delta.y)
-     * }
-     *
-     * <motion.div onPan={onPan} />
-     * ```
-     *
-     * @public
-     */
-    delta: Point;
-    /**
-     * Contains `x` and `y` values for the distance moved from
-     * the first pan event.
-     *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.offset.x, info.offset.y)
-     * }
-     *
-     * <motion.div onPan={onPan} />
-     * ```
-     *
-     * @public
-     */
-    offset: Point;
-    /**
-     * Contains `x` and `y` values for the current velocity of the pointer, in px/ms.
-     *
-     * ```jsx
-     * function onPan(event, info) {
-     *   console.log(info.velocity.x, info.velocity.y)
-     * }
-     *
-     * <motion.div onPan={onPan} />
-     * ```
-     *
-     * @public
-     */
-    velocity: Point;
-}
-
 type GenericKeyframesTarget<V> = V[] | Array<null | V>;
 /**
  * @public
@@ -989,6 +910,85 @@ interface CustomValueType {
     toValue: () => number | string;
 }
 
+type RefObject<T> = {
+    current: T | null;
+};
+
+/**
+ * Passed in to pan event handlers like `onPan` the `PanInfo` object contains
+ * information about the current state of the tap gesture such as its
+ * `point`, `delta`, `offset` and `velocity`.
+ *
+ * ```jsx
+ * <motion.div onPan={(event, info) => {
+ *   console.log(info.point.x, info.point.y)
+ * }} />
+ * ```
+ *
+ * @public
+ */
+interface PanInfo {
+    /**
+     * Contains `x` and `y` values for the current pan position relative
+     * to the device or page.
+     *
+     * ```jsx
+     * function onPan(event, info) {
+     *   console.log(info.point.x, info.point.y)
+     * }
+     *
+     * <motion.div onPan={onPan} />
+     * ```
+     *
+     * @public
+     */
+    point: Point;
+    /**
+     * Contains `x` and `y` values for the distance moved since
+     * the last event.
+     *
+     * ```jsx
+     * function onPan(event, info) {
+     *   console.log(info.delta.x, info.delta.y)
+     * }
+     *
+     * <motion.div onPan={onPan} />
+     * ```
+     *
+     * @public
+     */
+    delta: Point;
+    /**
+     * Contains `x` and `y` values for the distance moved from
+     * the first pan event.
+     *
+     * ```jsx
+     * function onPan(event, info) {
+     *   console.log(info.offset.x, info.offset.y)
+     * }
+     *
+     * <motion.div onPan={onPan} />
+     * ```
+     *
+     * @public
+     */
+    offset: Point;
+    /**
+     * Contains `x` and `y` values for the current velocity of the pointer, in px/ms.
+     *
+     * ```jsx
+     * function onPan(event, info) {
+     *   console.log(info.velocity.x, info.velocity.y)
+     * }
+     *
+     * <motion.div onPan={onPan} />
+     * ```
+     *
+     * @public
+     */
+    velocity: Point;
+}
+
 type ReducedMotionConfig = "always" | "never" | "user";
 /**
  * @public
@@ -1088,194 +1088,6 @@ interface UseVisualStateConfig<Instance, RenderState> {
 }
 declare const makeUseVisualState: <I, RS>(config: UseVisualStateConfig<I, RS>) => UseVisualState<I, RS>;
 
-/**
- * @public
- */
-type Subscriber<T> = (v: T) => void;
-/**
- * @public
- */
-type PassiveEffect<T> = (v: T, safeSetter: (v: T) => void) => void;
-interface MotionValueEventCallbacks<V> {
-    animationStart: () => void;
-    animationComplete: () => void;
-    animationCancel: () => void;
-    change: (latestValue: V) => void;
-    renderRequest: () => void;
-}
-interface ResolvedValues$1 {
-    [key: string]: string | number;
-}
-interface Owner {
-    current: HTMLElement | unknown;
-    getProps: () => {
-        onUpdate?: (latest: ResolvedValues$1) => void;
-        transformTemplate?: (transform: TransformProperties, generatedTransform: string) => string;
-    };
-}
-interface MotionValueOptions {
-    owner?: Owner;
-}
-/**
- * `MotionValue` is used to track the state and velocity of motion values.
- *
- * @public
- */
-declare class MotionValue<V = any> {
-    /**
-     * 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.
-     */
-    version: string;
-    /**
-     * If a MotionValue has an owner, it was created internally within Motion
-     * and therefore has no external listeners. It is therefore safe to animate via WAAPI.
-     */
-    owner?: Owner;
-    /**
-     * The current state of the `MotionValue`.
-     */
-    private current;
-    /**
-     * The previous state of the `MotionValue`.
-     */
-    private prev;
-    /**
-     * The previous state of the `MotionValue` at the end of the previous frame.
-     */
-    private prevFrameValue;
-    /**
-     * The last time the `MotionValue` was updated.
-     */
-    updatedAt: number;
-    /**
-     * The time `prevFrameValue` was updated.
-     */
-    prevUpdatedAt: number | undefined;
-    private stopPassiveEffect?;
-    /**
-     * A reference to the currently-controlling animation.
-     */
-    animation?: AnimationPlaybackControls;
-    setCurrent(current: V): void;
-    setPrevFrameValue(prevFrameValue?: V | undefined): void;
-    /**
-     * Adds a function that will be notified when the `MotionValue` is updated.
-     *
-     * It returns a function that, when called, will cancel the subscription.
-     *
-     * When calling `onChange` inside a React component, it should be wrapped with the
-     * `useEffect` hook. As it returns an unsubscribe function, this should be returned
-     * from the `useEffect` function to ensure you don't add duplicate subscribers..
-     *
-     * ```jsx
-     * export const MyComponent = () => {
-     *   const x = useMotionValue(0)
-     *   const y = useMotionValue(0)
-     *   const opacity = useMotionValue(1)
-     *
-     *   useEffect(() => {
-     *     function updateOpacity() {
-     *       const maxXY = Math.max(x.get(), y.get())
-     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
-     *       opacity.set(newOpacity)
-     *     }
-     *
-     *     const unsubscribeX = x.on("change", updateOpacity)
-     *     const unsubscribeY = y.on("change", updateOpacity)
-     *
-     *     return () => {
-     *       unsubscribeX()
-     *       unsubscribeY()
-     *     }
-     *   }, [])
-     *
-     *   return <motion.div style={{ x }} />
-     * }
-     * ```
-     *
-     * @param subscriber - A function that receives the latest value.
-     * @returns A function that, when called, will cancel this subscription.
-     *
-     * @deprecated
-     */
-    onChange(subscription: Subscriber<V>): () => void;
-    /**
-     * An object containing a SubscriptionManager for each active event.
-     */
-    private events;
-    on<EventName extends keyof MotionValueEventCallbacks<V>>(eventName: EventName, callback: MotionValueEventCallbacks<V>[EventName]): VoidFunction;
-    clearListeners(): void;
-    /**
-     * Sets the state of the `MotionValue`.
-     *
-     * @remarks
-     *
-     * ```jsx
-     * const x = useMotionValue(0)
-     * x.set(10)
-     * ```
-     *
-     * @param latest - Latest value to set.
-     * @param render - Whether to notify render subscribers. Defaults to `true`
-     *
-     * @public
-     */
-    set(v: V, render?: boolean): void;
-    setWithVelocity(prev: V, current: V, delta: number): void;
-    /**
-     * Set the state of the `MotionValue`, stopping any active animations,
-     * effects, and resets velocity to `0`.
-     */
-    jump(v: V, endAnimation?: boolean): void;
-    updateAndNotify: (v: V, render?: boolean) => void;
-    /**
-     * Returns the latest state of `MotionValue`
-     *
-     * @returns - The latest state of `MotionValue`
-     *
-     * @public
-     */
-    get(): NonNullable<V>;
-    /**
-     * @public
-     */
-    getPrevious(): V | undefined;
-    /**
-     * Returns the latest velocity of `MotionValue`
-     *
-     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
-     *
-     * @public
-     */
-    getVelocity(): number;
-    hasAnimated: boolean;
-    /**
-     * Stop the currently active animation.
-     *
-     * @public
-     */
-    stop(): void;
-    /**
-     * Returns `true` if this value is currently animating.
-     *
-     * @public
-     */
-    isAnimating(): boolean;
-    private clearAnimation;
-    /**
-     * Destroy and clean up subscribers to this `MotionValue`.
-     *
-     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
-     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
-     * created a `MotionValue` via the `motionValue` function.
-     *
-     * @public
-     */
-    destroy(): void;
-}
-declare function motionValue<V>(init: V, options?: MotionValueOptions): MotionValue<V>;
-
 type ScrapeMotionValuesFromProps = (props: MotionProps, prevProps: MotionProps, visualElement?: VisualElement) => {
     [key: string]: MotionValue | string | number;
 };
@@ -3122,26 +2934,6 @@ declare class ScrollTimeline implements ProgressTimeline {
 }
 declare function scroll(onScroll: OnScroll | AnimationPlaybackControls, { axis, ...options }?: ScrollOptions): VoidFunction;
 
-type Process = (data: FrameData) => void;
-type Schedule = (process: Process, keepAlive?: boolean, immediate?: boolean) => Process;
-interface Step {
-    schedule: Schedule;
-    cancel: (process: Process) => void;
-    process: (data: FrameData) => void;
-}
-type StepId = "read" | "resolveKeyframes" | "update" | "preRender" | "render" | "postRender";
-type Batcher = {
-    [key in StepId]: Schedule;
-};
-type Steps = {
-    [key in StepId]: Step;
-};
-interface FrameData {
-    delta: number;
-    timestamp: number;
-    isProcessing: boolean;
-}
-
 type UnionStringArray<T extends Readonly<string[]>> = T[number];
 declare const svgElements: readonly ["animate", "circle", "defs", "desc", "ellipse", "g", "image", "line", "filter", "marker", "mask", "metadata", "path", "pattern", "polygon", "polyline", "rect", "stop", "svg", "switch", "symbol", "text", "tspan", "use", "view", "clipPath", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "foreignObject", "linearGradient", "radialGradient", "textPath"];
 type SVGElements = UnionStringArray<typeof svgElements>;
@@ -3222,4 +3014,4 @@ declare global {
 
 type DOMMotionComponents = HTMLMotionComponents & SVGMotionComponents;
 
-export { type MotionTransform as $, type Axis as A, type Batcher as B, type CustomValueType as C, type DOMMotionComponents as D, type EventInfo as E, type FeatureBundle as F, type GenericKeyframesTarget as G, type HTMLMotionProps as H, type IProjectionNode as I, optimizedAppearDataAttribute as J, KeyframeResolver as K, PresenceContext as L, type MotionProps as M, SwitchLayoutGroupContext as N, type OnScrollInfo as O, type Process as P, type DragElastic as Q, type ResolvedKeyframes as R, type ScrollInfoOptions as S, type TapHandlers as T, type DragHandlers as U, VisualElement as V, type DraggableProps as W, type LayoutProps as X, type AnimationProps as Y, type MotionAdvancedProps as Z, type MotionStyle as _, MotionConfigContext as a, type VariantLabels as a0, type ForwardRefComponent as a1, type SVGAttributesAsMotionValues as a2, type SVGMotionProps as a3, type AnimationLifecycles as a4, type CreateVisualElement as a5, FlatTree as a6, type Inertia as a7, type Keyframes as a8, type KeyframesTarget as a9, type FeatureDefinition as aA, type FeatureDefinitions as aB, type FeaturePackage as aC, type LazyFeatureBundle as aD, type RenderComponent as aE, type BoundingBox as aF, type AxisDelta as aG, type Delta as aH, type TransformPoint as aI, type None as aa, type Orchestration as ab, type Repeat as ac, type ResolvedKeyframesTarget as ad, type ResolvedSingleTarget as ae, type ResolvedValueTarget as af, type SingleTarget as ag, type Spring as ah, type Target as ai, type TargetAndTransition as aj, type Transition as ak, type Tween as al, type ValueTarget as am, type Variant as an, type Variants as ao, type ResolveKeyframes as ap, scroll as aq, motionValue as ar, type PassiveEffect as as, type Subscriber as at, type ScrapeMotionValuesFromProps as au, type AnimationType as av, makeUseVisualState as aw, type VisualState as ax, type HydratedFeatureDefinition as ay, type HydratedFeatureDefinitions as az, type HTMLElements as b, MotionValue as c, type FrameData as d, type Steps as e, type Point as f, type MotionComponentProps as g, type HTMLMotionComponents as h, type SVGMotionComponents as i, type FeaturePackages as j, type Box as k, type MotionValueEventCallbacks as l, type ValueAnimationOptionsWithRenderContext as m, type AnimationControls as n, type AnimationDefinition as o, type VisualElementAnimationOptions as p, type ResolvedValues as q, type HTMLRenderState as r, DragControls as s, type PanInfo as t, useDragControls as u, type FocusHandlers as v, type HoverHandlers as w, type PanHandlers as x, type TapInfo as y, createRendererMotionComponent as z };
+export { type ForwardRefComponent as $, type Axis as A, type Box as B, type CustomValueType as C, type DOMMotionComponents as D, type EventInfo as E, type FeatureBundle as F, type GenericKeyframesTarget as G, type HTMLMotionProps as H, type IProjectionNode as I, SwitchLayoutGroupContext as J, KeyframeResolver as K, type DragElastic as L, type MotionProps as M, type DraggableProps as N, type OnScrollInfo as O, type Point as P, type DragHandlers as Q, type ResolvedKeyframes as R, type ScrollInfoOptions as S, type TapHandlers as T, type LayoutProps as U, type ValueAnimationOptionsWithRenderContext as V, type AnimationProps as W, type MotionAdvancedProps as X, type MotionStyle as Y, type MotionTransform as Z, type VariantLabels as _, MotionConfigContext as a, type SVGAttributesAsMotionValues as a0, type SVGMotionProps as a1, type AnimationLifecycles as a2, type CreateVisualElement as a3, FlatTree as a4, type Inertia as a5, type Keyframes as a6, type KeyframesTarget as a7, type None as a8, type Orchestration as a9, type Repeat as aa, type ResolvedKeyframesTarget as ab, type ResolvedSingleTarget as ac, type ResolvedValueTarget as ad, type SingleTarget as ae, type Spring as af, type Target as ag, type TargetAndTransition as ah, type Transition as ai, type Tween as aj, type ValueTarget as ak, type Variant as al, type Variants as am, type ResolveKeyframes as an, scroll as ao, type HydratedFeatureDefinition as ap, type HydratedFeatureDefinitions as aq, type FeatureDefinition as ar, type FeatureDefinitions as as, type FeaturePackage as at, type LazyFeatureBundle as au, type RenderComponent as av, type BoundingBox as aw, type AxisDelta as ax, type Delta as ay, type TransformPoint as az, type HTMLElements as b, type MotionComponentProps as c, type HTMLMotionComponents as d, type SVGMotionComponents as e, type FeaturePackages as f, type AnimationControls as g, VisualElement as h, type AnimationDefinition as i, type VisualElementAnimationOptions as j, type ResolvedValues as k, type HTMLRenderState as l, type ScrapeMotionValuesFromProps as m, makeUseVisualState as n, type VisualState as o, type AnimationType as p, DragControls as q, type PanInfo as r, type FocusHandlers as s, type HoverHandlers as t, useDragControls as u, type PanHandlers as v, type TapInfo as w, createRendererMotionComponent as x, optimizedAppearDataAttribute as y, PresenceContext as z };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "framer-motion",
-    "version": "12.4.13",
+    "version": "12.6.0",
     "description": "A simple and powerful JavaScript animation library",
     "main": "dist/cjs/index.js",
     "module": "dist/es/index.mjs",
@@ -61,8 +61,6 @@
     "keywords": [
         "react animation",
         "react",
-        "three",
-        "3d",
         "pose",
         "react pose",
         "animation",
@@ -89,8 +87,8 @@
         "measure": "rollup -c ./rollup.size.config.mjs"
     },
     "dependencies": {
-        "motion-dom": "^12.4.11",
-        "motion-utils": "^12.4.10",
+        "motion-dom": "^12.6.0",
+        "motion-utils": "^12.5.0",
         "tslib": "^2.4.0"
     },
     "devDependencies": {
@@ -144,5 +142,5 @@
             "maxSize": "2.7 kB"
         }
     ],
-    "gitHead": "ac0bc2f6003a20face739983390102b033d291df"
+    "gitHead": "1c1f25b8fb696e07eb5807ba7ac5b03a832d0a00"
 }

package/dist/es/frameloop/batcher.mjs

@@ -1,69 +0,0 @@
-import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';
-import { stepsOrder } from './order.mjs';
-import { createRenderStep } from './render-step.mjs';
-
-const maxElapsed = 40;
-function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
-    let runNextFrame = false;
-    let useDefaultElapsed = true;
-    const state = {
-        delta: 0.0,
-        timestamp: 0.0,
-        isProcessing: false,
-    };
-    const flagRunNextFrame = () => (runNextFrame = true);
-    const steps = stepsOrder.reduce((acc, key) => {
-        acc[key] = createRenderStep(flagRunNextFrame, allowKeepAlive ? key : undefined);
-        return acc;
-    }, {});
-    const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
-    const processBatch = () => {
-        const timestamp = MotionGlobalConfig.useManualTiming
-            ? state.timestamp
-            : performance.now();
-        runNextFrame = false;
-        if (!MotionGlobalConfig.useManualTiming) {
-            state.delta = useDefaultElapsed
-                ? 1000 / 60
-                : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
-        }
-        state.timestamp = timestamp;
-        state.isProcessing = true;
-        // Unrolled render loop for better per-frame performance
-        read.process(state);
-        resolveKeyframes.process(state);
-        update.process(state);
-        preRender.process(state);
-        render.process(state);
-        postRender.process(state);
-        state.isProcessing = false;
-        if (runNextFrame && allowKeepAlive) {
-            useDefaultElapsed = false;
-            scheduleNextBatch(processBatch);
-        }
-    };
-    const wake = () => {
-        runNextFrame = true;
-        useDefaultElapsed = true;
-        if (!state.isProcessing) {
-            scheduleNextBatch(processBatch);
-        }
-    };
-    const schedule = stepsOrder.reduce((acc, key) => {
-        const step = steps[key];
-        acc[key] = (process, keepAlive = false, immediate = false) => {
-            if (!runNextFrame)
-                wake();
-            return step.schedule(process, keepAlive, immediate);
-        };
-        return acc;
-    }, {});
-    const cancel = (process) => {
-        for (let i = 0; i < stepsOrder.length; i++) {
-            steps[stepsOrder[i]].cancel(process);
-        }
-    };
-    return { schedule, cancel, state, steps };
-}
-
-export { createRenderBatcher };

package/dist/es/frameloop/frame.mjs

@@ -1,6 +0,0 @@
-import { noop } from 'motion-utils';
-import { createRenderBatcher } from './batcher.mjs';
-
-const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
-
-export { cancelFrame, frame, frameData, frameSteps };

package/dist/es/frameloop/index-legacy.mjs

@@ -1,20 +0,0 @@
-import { stepsOrder } from './order.mjs';
-import { frame, cancelFrame } from './frame.mjs';
-
-/**
- * @deprecated
- *
- * Import as `frame` instead.
- */
-const sync = frame;
-/**
- * @deprecated
- *
- * Use cancelFrame(callback) instead.
- */
-const cancelSync = stepsOrder.reduce((acc, key) => {
-    acc[key] = (process) => cancelFrame(process);
-    return acc;
-}, {});
-
-export { cancelSync, sync };

package/dist/es/frameloop/microtask.mjs

@@ -1,5 +0,0 @@
-import { createRenderBatcher } from './batcher.mjs';
-
-const { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);
-
-export { cancelMicrotask, microtask };

package/dist/es/frameloop/order.mjs

@@ -1,10 +0,0 @@
-const stepsOrder = [
-    "read", // Read
-    "resolveKeyframes", // Write/Read/Write/Read
-    "update", // Compute
-    "preRender", // Compute
-    "render", // Write
-    "postRender", // Compute
-];
-
-export { stepsOrder };

package/dist/es/frameloop/render-step.mjs

@@ -1,92 +0,0 @@
-import { statsBuffer } from '../stats/buffer.mjs';
-
-function createRenderStep(runNextFrame, stepName) {
-    /**
-     * 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 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.
-     */
-    let isProcessing = false;
-    let flushNextFrame = false;
-    /**
-     * A set of processes which were marked keepAlive when scheduled.
-     */
-    const toKeepAlive = new WeakSet();
-    let latestFrameData = {
-        delta: 0.0,
-        timestamp: 0.0,
-        isProcessing: false,
-    };
-    let numCalls = 0;
-    function triggerCallback(callback) {
-        if (toKeepAlive.has(callback)) {
-            step.schedule(callback);
-            runNextFrame();
-        }
-        numCalls++;
-        callback(latestFrameData);
-    }
-    const step = {
-        /**
-         * Schedule a process to run on the next frame.
-         */
-        schedule: (callback, keepAlive = false, immediate = false) => {
-            const addToCurrentFrame = immediate && isProcessing;
-            const queue = addToCurrentFrame ? thisFrame : nextFrame;
-            if (keepAlive)
-                toKeepAlive.add(callback);
-            if (!queue.has(callback))
-                queue.add(callback);
-            return callback;
-        },
-        /**
-         * Cancel the provided callback from running on the next frame.
-         */
-        cancel: (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
-             * as true and ensure we flush the following frame at the end of this one.
-             */
-            if (isProcessing) {
-                flushNextFrame = true;
-                return;
-            }
-            isProcessing = true;
-            [thisFrame, nextFrame] = [nextFrame, thisFrame];
-            // Execute this frame
-            thisFrame.forEach(triggerCallback);
-            /**
-             * If we're recording stats then
-             */
-            if (stepName && statsBuffer.value) {
-                statsBuffer.value.frameloop[stepName].push(numCalls);
-            }
-            numCalls = 0;
-            // Clear the frame so no callbacks remain. This is to avoid
-            // memory leaks should this render step not run for a while.
-            thisFrame.clear();
-            isProcessing = false;
-            if (flushNextFrame) {
-                flushNextFrame = false;
-                step.process(frameData);
-            }
-        },
-    };
-    return step;
-}
-
-export { createRenderStep };

package/dist/es/frameloop/sync-time.mjs

@@ -1,31 +0,0 @@
-import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';
-import { frameData } from './frame.mjs';
-
-let now;
-function clearTime() {
-    now = undefined;
-}
-/**
- * An eventloop-synchronous alternative to performance.now().
- *
- * Ensures that time measurements remain consistent within a synchronous context.
- * Usually calling performance.now() twice within the same synchronous context
- * will return different values which isn't useful for animations when we're usually
- * trying to sync animations to the same frame.
- */
-const time = {
-    now: () => {
-        if (now === undefined) {
-            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming
-                ? frameData.timestamp
-                : performance.now());
-        }
-        return now;
-    },
-    set: (newTime) => {
-        now = newTime;
-        queueMicrotask(clearTime);
-    },
-};
-
-export { time };