motion 11.11.12 → 11.11.14

package/dist/es/framer-motion/dist/es/value/use-combine-values.mjs

@@ -0,0 +1,37 @@
+import { useMotionValue } from './use-motion-value.mjs';
+import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.mjs';
+import { cancelFrame, frame } from '../frameloop/frame.mjs';
+
+function useCombineMotionValues(values, combineValues) {
+    /**
+     * Initialise the returned motion value. This remains the same between renders.
+     */
+    const value = useMotionValue(combineValues());
+    /**
+     * Create a function that will update the template motion value with the latest values.
+     * This is pre-bound so whenever a motion value updates it can schedule its
+     * execution in Framesync. If it's already been scheduled it won't be fired twice
+     * in a single frame.
+     */
+    const updateValue = () => value.set(combineValues());
+    /**
+     * Synchronously update the motion value with the latest values during the render.
+     * This ensures that within a React render, the styles applied to the DOM are up-to-date.
+     */
+    updateValue();
+    /**
+     * Subscribe to all motion values found within the template. Whenever any of them change,
+     * schedule an update.
+     */
+    useIsomorphicLayoutEffect(() => {
+        const scheduleUpdate = () => frame.preRender(updateValue, false, true);
+        const subscriptions = values.map((v) => v.on("change", scheduleUpdate));
+        return () => {
+            subscriptions.forEach((unsubscribe) => unsubscribe());
+            cancelFrame(updateValue);
+        };
+    });
+    return value;
+}
+
+export { useCombineMotionValues };

package/dist/es/framer-motion/dist/es/value/use-computed.mjs

@@ -0,0 +1,19 @@
+import { collectMotionValues } from './index.mjs';
+import { useCombineMotionValues } from './use-combine-values.mjs';
+
+function useComputed(compute) {
+    /**
+     * Open session of collectMotionValues. Any MotionValue that calls get()
+     * will be saved into this array.
+     */
+    collectMotionValues.current = [];
+    compute();
+    const value = useCombineMotionValues(collectMotionValues.current, compute);
+    /**
+     * Synchronously close session of collectMotionValues.
+     */
+    collectMotionValues.current = undefined;
+    return value;
+}
+
+export { useComputed };

package/dist/es/framer-motion/dist/es/value/use-inverted-scale.mjs

@@ -0,0 +1,52 @@
+import { useTransform } from './use-transform.mjs';
+import { invariant, warning } from '../utils/errors.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+import { MotionContext } from '../context/MotionContext/index.mjs';
+import { useContext } from 'react';
+
+// Keep things reasonable and avoid scale: Infinity. In practise we might need
+// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]
+// to simply hide content at unreasonable scales.
+const maxScale = 100000;
+const invertScale = (scale) => scale > 0.001 ? 1 / scale : maxScale;
+let hasWarned = false;
+/**
+ * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse
+ * of their respective parent scales.
+ *
+ * This is useful for undoing the distortion of content when scaling a parent component.
+ *
+ * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.
+ * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output
+ * of those instead.
+ *
+ * ```jsx
+ * const MyComponent = () => {
+ *   const { scaleX, scaleY } = useInvertedScale()
+ *   return <motion.div style={{ scaleX, scaleY }} />
+ * }
+ * ```
+ *
+ * @deprecated
+ */
+function useInvertedScale(scale) {
+    let parentScaleX = useMotionValue(1);
+    let parentScaleY = useMotionValue(1);
+    const { visualElement } = useContext(MotionContext);
+    invariant(!!(scale || visualElement), "If no scale values are provided, useInvertedScale must be used within a child of another motion component.");
+    warning(hasWarned, "useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.");
+    hasWarned = true;
+    if (scale) {
+        parentScaleX = scale.scaleX || parentScaleX;
+        parentScaleY = scale.scaleY || parentScaleY;
+    }
+    else if (visualElement) {
+        parentScaleX = visualElement.getValue("scaleX", 1);
+        parentScaleY = visualElement.getValue("scaleY", 1);
+    }
+    const scaleX = useTransform(parentScaleX, invertScale);
+    const scaleY = useTransform(parentScaleY, invertScale);
+    return { scaleX, scaleY };
+}
+
+export { invertScale, useInvertedScale };

package/dist/es/framer-motion/dist/es/value/use-motion-template.mjs

@@ -0,0 +1,45 @@
+import { useCombineMotionValues } from './use-combine-values.mjs';
+import { isMotionValue } from './utils/is-motion-value.mjs';
+
+/**
+ * Combine multiple motion values into a new one using a string template literal.
+ *
+ * ```jsx
+ * import {
+ *   motion,
+ *   useSpring,
+ *   useMotionValue,
+ *   useMotionTemplate
+ * } from "framer-motion"
+ *
+ * function Component() {
+ *   const shadowX = useSpring(0)
+ *   const shadowY = useMotionValue(0)
+ *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`
+ *
+ *   return <motion.div style={{ filter: shadow }} />
+ * }
+ * ```
+ *
+ * @public
+ */
+function useMotionTemplate(fragments, ...values) {
+    /**
+     * Create a function that will build a string from the latest motion values.
+     */
+    const numFragments = fragments.length;
+    function buildValue() {
+        let output = ``;
+        for (let i = 0; i < numFragments; i++) {
+            output += fragments[i];
+            const value = values[i];
+            if (value) {
+                output += isMotionValue(value) ? value.get() : value;
+            }
+        }
+        return output;
+    }
+    return useCombineMotionValues(values.filter(isMotionValue), buildValue);
+}
+
+export { useMotionTemplate };

package/dist/es/framer-motion/dist/es/value/use-motion-value.mjs

@@ -0,0 +1,38 @@
+import { useContext, useState, useEffect } from 'react';
+import { motionValue } from './index.mjs';
+import { MotionConfigContext } from '../context/MotionConfigContext.mjs';
+import { useConstant } from '../utils/use-constant.mjs';
+
+/**
+ * Creates a `MotionValue` to track the state and velocity of a value.
+ *
+ * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.
+ *
+ * ```jsx
+ * export const MyComponent = () => {
+ *   const scale = useMotionValue(1)
+ *
+ *   return <motion.div style={{ scale }} />
+ * }
+ * ```
+ *
+ * @param initial - The initial state.
+ *
+ * @public
+ */
+function useMotionValue(initial) {
+    const value = useConstant(() => motionValue(initial));
+    /**
+     * If this motion value is being used in static mode, like on
+     * the Framer canvas, force components to rerender when the motion
+     * value is updated.
+     */
+    const { isStatic } = useContext(MotionConfigContext);
+    if (isStatic) {
+        const [, setLatest] = useState(initial);
+        useEffect(() => value.on("change", setLatest), []);
+    }
+    return value;
+}
+
+export { useMotionValue };

package/dist/es/framer-motion/dist/es/value/use-scroll.mjs

@@ -0,0 +1,39 @@
+import { motionValue } from './index.mjs';
+import { useConstant } from '../utils/use-constant.mjs';
+import { useEffect } from 'react';
+import { warning } from '../utils/errors.mjs';
+import { scroll } from '../render/dom/scroll/index.mjs';
+import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.mjs';
+
+function refWarning(name, ref) {
+    warning(Boolean(!ref || ref.current), `You have defined a ${name} options but the provided ref is not yet hydrated, probably because it's defined higher up the tree. Try calling useScroll() in the same component as the ref, or setting its \`layoutEffect: false\` option.`);
+}
+const createScrollMotionValues = () => ({
+    scrollX: motionValue(0),
+    scrollY: motionValue(0),
+    scrollXProgress: motionValue(0),
+    scrollYProgress: motionValue(0),
+});
+function useScroll({ container, target, layoutEffect = true, ...options } = {}) {
+    const values = useConstant(createScrollMotionValues);
+    const useLifecycleEffect = layoutEffect
+        ? useIsomorphicLayoutEffect
+        : useEffect;
+    useLifecycleEffect(() => {
+        refWarning("target", target);
+        refWarning("container", container);
+        return scroll((_progress, { x, y }) => {
+            values.scrollX.set(x.current);
+            values.scrollXProgress.set(x.progress);
+            values.scrollY.set(y.current);
+            values.scrollYProgress.set(y.progress);
+        }, {
+            ...options,
+            container: (container === null || container === void 0 ? void 0 : container.current) || undefined,
+            target: (target === null || target === void 0 ? void 0 : target.current) || undefined,
+        });
+    }, [container, target, JSON.stringify(options.offset)]);
+    return values;
+}
+
+export { useScroll };

package/dist/es/framer-motion/dist/es/value/use-spring.mjs

@@ -0,0 +1,85 @@
+import { useContext, useRef, useInsertionEffect } from 'react';
+import { isMotionValue } from './utils/is-motion-value.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+import { MotionConfigContext } from '../context/MotionConfigContext.mjs';
+import { useIsomorphicLayoutEffect } from '../utils/use-isomorphic-effect.mjs';
+import { animateValue } from '../animation/animators/MainThreadAnimation.mjs';
+import { frame, frameData } from '../frameloop/frame.mjs';
+
+function toNumber(v) {
+    if (typeof v === "number")
+        return v;
+    return parseFloat(v);
+}
+/**
+ * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.
+ *
+ * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber
+ * to another `MotionValue`.
+ *
+ * @remarks
+ *
+ * ```jsx
+ * const x = useSpring(0, { stiffness: 300 })
+ * const y = useSpring(x, { damping: 10 })
+ * ```
+ *
+ * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.
+ * @param springConfig - Configuration options for the spring.
+ * @returns `MotionValue`
+ *
+ * @public
+ */
+function useSpring(source, config = {}) {
+    const { isStatic } = useContext(MotionConfigContext);
+    const activeSpringAnimation = useRef(null);
+    const value = useMotionValue(isMotionValue(source) ? toNumber(source.get()) : source);
+    const latestValue = useRef(value.get());
+    const latestSetter = useRef(() => { });
+    const startAnimation = () => {
+        /**
+         * If the previous animation hasn't had the chance to even render a frame, render it now.
+         */
+        const animation = activeSpringAnimation.current;
+        if (animation && animation.time === 0) {
+            animation.sample(frameData.delta);
+        }
+        stopAnimation();
+        activeSpringAnimation.current = animateValue({
+            keyframes: [value.get(), latestValue.current],
+            velocity: value.getVelocity(),
+            type: "spring",
+            restDelta: 0.001,
+            restSpeed: 0.01,
+            ...config,
+            onUpdate: latestSetter.current,
+        });
+    };
+    const stopAnimation = () => {
+        if (activeSpringAnimation.current) {
+            activeSpringAnimation.current.stop();
+        }
+    };
+    useInsertionEffect(() => {
+        return value.attach((v, set) => {
+            /**
+             * A more hollistic approach to this might be to use isStatic to fix VisualElement animations
+             * at that level, but this will work for now
+             */
+            if (isStatic)
+                return set(v);
+            latestValue.current = v;
+            latestSetter.current = set;
+            frame.update(startAnimation);
+            return value.get();
+        }, stopAnimation);
+    }, [JSON.stringify(config)]);
+    useIsomorphicLayoutEffect(() => {
+        if (isMotionValue(source)) {
+            return source.on("change", (v) => value.set(toNumber(v)));
+        }
+    }, [value]);
+    return value;
+}
+
+export { useSpring };

package/dist/es/framer-motion/dist/es/value/use-time.mjs

@@ -0,0 +1,10 @@
+import { useAnimationFrame } from '../utils/use-animation-frame.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+
+function useTime() {
+    const time = useMotionValue(0);
+    useAnimationFrame((t) => time.set(t));
+    return time;
+}
+
+export { useTime };

package/dist/es/framer-motion/dist/es/value/use-transform.mjs

@@ -0,0 +1,29 @@
+import { transform } from '../utils/transform.mjs';
+import { useCombineMotionValues } from './use-combine-values.mjs';
+import { useConstant } from '../utils/use-constant.mjs';
+import { useComputed } from './use-computed.mjs';
+
+function useTransform(input, inputRangeOrTransformer, outputRange, options) {
+    if (typeof input === "function") {
+        return useComputed(input);
+    }
+    const transformer = typeof inputRangeOrTransformer === "function"
+        ? inputRangeOrTransformer
+        : transform(inputRangeOrTransformer, outputRange, options);
+    return Array.isArray(input)
+        ? useListTransform(input, transformer)
+        : useListTransform([input], ([latest]) => transformer(latest));
+}
+function useListTransform(values, transformer) {
+    const latest = useConstant(() => []);
+    return useCombineMotionValues(values, () => {
+        latest.length = 0;
+        const numValues = values.length;
+        for (let i = 0; i < numValues; i++) {
+            latest[i] = values[i].get();
+        }
+        return transformer(latest);
+    });
+}
+
+export { useTransform };

package/dist/es/framer-motion/dist/es/value/use-velocity.mjs

@@ -0,0 +1,35 @@
+import { useMotionValueEvent } from '../utils/use-motion-value-event.mjs';
+import { useMotionValue } from './use-motion-value.mjs';
+import { frame } from '../frameloop/frame.mjs';
+
+/**
+ * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.
+ *
+ * ```javascript
+ * const x = useMotionValue(0)
+ * const xVelocity = useVelocity(x)
+ * const xAcceleration = useVelocity(xVelocity)
+ * ```
+ *
+ * @public
+ */
+function useVelocity(value) {
+    const velocity = useMotionValue(value.getVelocity());
+    const updateVelocity = () => {
+        const latest = value.getVelocity();
+        velocity.set(latest);
+        /**
+         * If we still have velocity, schedule an update for the next frame
+         * to keep checking until it is zero.
+         */
+        if (latest)
+            frame.update(updateVelocity);
+    };
+    useMotionValueEvent(value, "change", () => {
+        // Schedule an update to this value at the end of the current frame.
+        frame.update(updateVelocity, false, true);
+    });
+    return velocity;
+}
+
+export { useVelocity };

package/dist/es/framer-motion/dist/es/value/use-will-change/WillChangeMotionValue.mjs

@@ -0,0 +1,22 @@
+import { MotionValue } from '../index.mjs';
+import { getWillChangeName } from './get-will-change-name.mjs';
+import { addUniqueItem } from '../../utils/array.mjs';
+
+class WillChangeMotionValue extends MotionValue {
+    constructor() {
+        super(...arguments);
+        this.values = [];
+    }
+    add(name) {
+        const styleName = getWillChangeName(name);
+        if (styleName) {
+            addUniqueItem(this.values, styleName);
+            this.update();
+        }
+    }
+    update() {
+        this.set(this.values.length ? this.values.join(", ") : "auto");
+    }
+}
+
+export { WillChangeMotionValue };

package/dist/es/framer-motion/dist/es/value/use-will-change/get-will-change-name.mjs

@@ -0,0 +1,14 @@
+import { acceleratedValues } from '../../animation/animators/utils/accelerated-values.mjs';
+import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';
+import { transformProps } from '../../render/html/utils/transform.mjs';
+
+function getWillChangeName(name) {
+    if (transformProps.has(name)) {
+        return "transform";
+    }
+    else if (acceleratedValues.has(name)) {
+        return camelToDash(name);
+    }
+}
+
+export { getWillChangeName };

package/dist/es/framer-motion/dist/es/value/use-will-change/index.mjs

@@ -0,0 +1,8 @@
+import { useConstant } from '../../utils/use-constant.mjs';
+import { WillChangeMotionValue } from './WillChangeMotionValue.mjs';
+
+function useWillChange() {
+    return useConstant(() => new WillChangeMotionValue("auto"));
+}
+
+export { useWillChange };

package/dist/es/motion/lib/react.mjs

@@ -0,0 +1,110 @@
+"use client";
+export { motion } from '../../framer-motion/dist/es/render/components/motion/proxy.mjs';
+export { m } from '../../framer-motion/dist/es/render/components/m/proxy.mjs';
+export { AnimatePresence } from '../../framer-motion/dist/es/components/AnimatePresence/index.mjs';
+export { MotionConfig } from '../../framer-motion/dist/es/components/MotionConfig/index.mjs';
+export { LazyMotion } from '../../framer-motion/dist/es/components/LazyMotion/index.mjs';
+export { LayoutGroup } from '../../framer-motion/dist/es/components/LayoutGroup/index.mjs';
+export { domMin } from '../../framer-motion/dist/es/render/dom/features-min.mjs';
+export { domAnimation } from '../../framer-motion/dist/es/render/dom/features-animation.mjs';
+export { domMax } from '../../framer-motion/dist/es/render/dom/features-max.mjs';
+export { useMotionValue } from '../../framer-motion/dist/es/value/use-motion-value.mjs';
+export { useMotionTemplate } from '../../framer-motion/dist/es/value/use-motion-template.mjs';
+export { resolveMotionValue } from '../../framer-motion/dist/es/value/utils/resolve-motion-value.mjs';
+export { useTransform } from '../../framer-motion/dist/es/value/use-transform.mjs';
+export { useSpring } from '../../framer-motion/dist/es/value/use-spring.mjs';
+export { useVelocity } from '../../framer-motion/dist/es/value/use-velocity.mjs';
+export { useScroll } from '../../framer-motion/dist/es/value/use-scroll.mjs';
+export { useElementScroll } from '../../framer-motion/dist/es/value/scroll/use-element-scroll.mjs';
+export { useViewportScroll } from '../../framer-motion/dist/es/value/scroll/use-viewport-scroll.mjs';
+export { useTime } from '../../framer-motion/dist/es/value/use-time.mjs';
+export { useWillChange } from '../../framer-motion/dist/es/value/use-will-change/index.mjs';
+export { useMotionValueEvent } from '../../framer-motion/dist/es/utils/use-motion-value-event.mjs';
+export { useReducedMotion } from '../../framer-motion/dist/es/utils/reduced-motion/use-reduced-motion.mjs';
+export { useReducedMotionConfig } from '../../framer-motion/dist/es/utils/reduced-motion/use-reduced-motion-config.mjs';
+export { animationControls } from '../../framer-motion/dist/es/animation/hooks/animation-controls.mjs';
+export { useAnimate } from '../../framer-motion/dist/es/animation/hooks/use-animate.mjs';
+export { useAnimateMini } from '../../framer-motion/dist/es/animation/hooks/use-animate-style.mjs';
+export { useAnimation, useAnimationControls } from '../../framer-motion/dist/es/animation/hooks/use-animation.mjs';
+export { useAnimationFrame } from '../../framer-motion/dist/es/utils/use-animation-frame.mjs';
+export { animateVisualElement } from '../../framer-motion/dist/es/animation/interfaces/visual-element.mjs';
+export { useCycle } from '../../framer-motion/dist/es/utils/use-cycle.mjs';
+export { isValidMotionProp } from '../../framer-motion/dist/es/motion/utils/valid-prop.mjs';
+export { useIsPresent, usePresence } from '../../framer-motion/dist/es/components/AnimatePresence/use-presence.mjs';
+export { useInView } from '../../framer-motion/dist/es/utils/use-in-view.mjs';
+export { DragControls, useDragControls } from '../../framer-motion/dist/es/gestures/drag/use-drag-controls.mjs';
+export { useDomEvent } from '../../framer-motion/dist/es/events/use-dom-event.mjs';
+export { createRendererMotionComponent } from '../../framer-motion/dist/es/motion/index.mjs';
+export { isMotionComponent } from '../../framer-motion/dist/es/motion/utils/is-motion-component.mjs';
+export { unwrapMotionComponent } from '../../framer-motion/dist/es/motion/utils/unwrap-motion-component.mjs';
+export { VisualElement } from '../../framer-motion/dist/es/render/VisualElement.mjs';
+export { addScaleCorrector } from '../../framer-motion/dist/es/projection/styles/scale-correction.mjs';
+export { disableInstantTransitions, useInstantTransition } from '../../framer-motion/dist/es/utils/use-instant-transition.mjs';
+export { useInstantLayoutTransition } from '../../framer-motion/dist/es/projection/use-instant-layout-transition.mjs';
+export { useResetProjection } from '../../framer-motion/dist/es/projection/use-reset-projection.mjs';
+export { buildTransform } from '../../framer-motion/dist/es/render/html/utils/build-transform.mjs';
+export { visualElementStore } from '../../framer-motion/dist/es/render/store.mjs';
+export { animateValue } from '../../framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs';
+export { color } from '../../framer-motion/dist/es/value/types/color/index.mjs';
+export { complex } from '../../framer-motion/dist/es/value/types/complex/index.mjs';
+export { px } from '../../framer-motion/dist/es/value/types/numbers/units.mjs';
+export { MotionGlobalConfig } from '../../framer-motion/dist/es/utils/GlobalConfig.mjs';
+export { AcceleratedAnimation } from '../../framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs';
+export { startOptimizedAppearAnimation } from '../../framer-motion/dist/es/animation/optimized-appear/start.mjs';
+export { optimizedAppearDataAttribute } from '../../framer-motion/dist/es/animation/optimized-appear/data-id.mjs';
+export { spring } from '../../framer-motion/dist/es/animation/generators/spring/index.mjs';
+export { findSpring } from '../../framer-motion/dist/es/animation/generators/spring/find.mjs';
+export { MotionContext } from '../../framer-motion/dist/es/context/MotionContext/index.mjs';
+export { MotionConfigContext } from '../../framer-motion/dist/es/context/MotionConfigContext.mjs';
+export { PresenceContext } from '../../framer-motion/dist/es/context/PresenceContext.mjs';
+export { LayoutGroupContext } from '../../framer-motion/dist/es/context/LayoutGroupContext.mjs';
+export { SwitchLayoutGroupContext } from '../../framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs';
+export { FlatTree } from '../../framer-motion/dist/es/render/utils/flat-tree.mjs';
+export { DeprecatedLayoutGroupContext } from '../../framer-motion/dist/es/context/DeprecatedLayoutGroupContext.mjs';
+export { useAnimatedState as useDeprecatedAnimatedState } from '../../framer-motion/dist/es/animation/hooks/use-animated-state.mjs';
+export { useInvertedScale as useDeprecatedInvertedScale } from '../../framer-motion/dist/es/value/use-inverted-scale.mjs';
+export { AnimateSharedLayout } from '../../framer-motion/dist/es/components/AnimateSharedLayout.mjs';
+export { delay } from '../../framer-motion/dist/es/utils/delay.mjs';
+export { MotionValue, motionValue } from '../../framer-motion/dist/es/value/index.mjs';
+export { animate, createScopedAnimate } from '../../framer-motion/dist/es/animation/animate/index.mjs';
+export { animateMini } from '../../framer-motion/dist/es/animation/animators/waapi/animate-style.mjs';
+export { scroll } from '../../framer-motion/dist/es/render/dom/scroll/index.mjs';
+export { scrollInfo } from '../../framer-motion/dist/es/render/dom/scroll/track.mjs';
+export { inView } from '../../framer-motion/dist/es/render/dom/viewport/index.mjs';
+export { inertia } from '../../framer-motion/dist/es/animation/generators/inertia.mjs';
+export { keyframes } from '../../framer-motion/dist/es/animation/generators/keyframes.mjs';
+export { stagger } from '../../framer-motion/dist/es/animation/utils/stagger.mjs';
+export { transform } from '../../framer-motion/dist/es/utils/transform.mjs';
+export { clamp } from '../../framer-motion/dist/es/utils/clamp.mjs';
+export { mix } from '../../framer-motion/dist/es/utils/mix/index.mjs';
+export { pipe } from '../../framer-motion/dist/es/utils/pipe.mjs';
+export { progress } from '../../framer-motion/dist/es/utils/progress.mjs';
+export { wrap } from '../../framer-motion/dist/es/utils/wrap.mjs';
+export { cancelSync, sync } from '../../framer-motion/dist/es/frameloop/index-legacy.mjs';
+export { anticipate } from '../../framer-motion/dist/es/easing/anticipate.mjs';
+export { backIn, backInOut, backOut } from '../../framer-motion/dist/es/easing/back.mjs';
+export { circIn, circInOut, circOut } from '../../framer-motion/dist/es/easing/circ.mjs';
+export { easeIn, easeInOut, easeOut } from '../../framer-motion/dist/es/easing/ease.mjs';
+export { cubicBezier } from '../../framer-motion/dist/es/easing/cubic-bezier.mjs';
+export { steps } from '../../framer-motion/dist/es/easing/steps.mjs';
+export { mirrorEasing } from '../../framer-motion/dist/es/easing/modifiers/mirror.mjs';
+export { reverseEasing } from '../../framer-motion/dist/es/easing/modifiers/reverse.mjs';
+export { distance, distance2D } from '../../framer-motion/dist/es/utils/distance.mjs';
+export { invariant, warning } from '../../framer-motion/dist/es/utils/errors.mjs';
+export { interpolate } from '../../framer-motion/dist/es/utils/interpolate.mjs';
+export { cancelFrame, frame, frameData, frameSteps } from '../../framer-motion/dist/es/frameloop/frame.mjs';
+export { animations } from '../../framer-motion/dist/es/motion/features/animations.mjs';
+export { createBox } from '../../framer-motion/dist/es/projection/geometry/models.mjs';
+export { calcLength } from '../../framer-motion/dist/es/projection/geometry/delta-calc.mjs';
+export { filterProps } from '../../framer-motion/dist/es/render/dom/utils/filter-props.mjs';
+export { makeUseVisualState } from '../../framer-motion/dist/es/motion/utils/use-visual-state.mjs';
+export { isDragActive } from '../../framer-motion/dist/es/gestures/drag/utils/lock.mjs';
+export { addPointerEvent } from '../../framer-motion/dist/es/events/add-pointer-event.mjs';
+export { addPointerInfo } from '../../framer-motion/dist/es/events/event-info.mjs';
+export { isMotionValue } from '../../framer-motion/dist/es/value/utils/is-motion-value.mjs';
+export { isBrowser } from '../../framer-motion/dist/es/utils/is-browser.mjs';
+export { useUnmountEffect } from '../../framer-motion/dist/es/utils/use-unmount-effect.mjs';
+export { useIsomorphicLayoutEffect } from '../../framer-motion/dist/es/utils/use-isomorphic-effect.mjs';
+export { useForceUpdate } from '../../framer-motion/dist/es/utils/use-force-update.mjs';
+import * as namespace from '../../framer-motion/dist/es/components/Reorder/namespace.mjs';
+export { namespace as Reorder };

package/dist/motion.dev.js

@@ -281,7 +281,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.11.12";
+            this.version = "11.11.13";
             /**
              * 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
@@ -4091,7 +4091,7 @@
                  * and warn against mismatches.
                  */
                 {
-                    warnOnce(nextValue.version === "11.11.12", `Attempting to mix Motion versions ${nextValue.version} with 11.11.12 may not work as expected.`);
+                    warnOnce(nextValue.version === "11.11.13", `Attempting to mix Motion versions ${nextValue.version} with 11.11.13 may not work as expected.`);
                 }
             }
             else if (isMotionValue(prevValue)) {