framer-motion 7.2.0 → 7.3.1

package/dist/es/animation/use-animated-state.mjs

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { useState, useEffect } from 'react';
 import { useConstant } from '../utils/use-constant.mjs';
 import { getOrigin, checkTargetForNewValues } from '../render/utils/setters.mjs';
@@ -19,11 +18,10 @@ const stateVisualElement = visualElement({
     readValueFromInstance(_state, key, options) {
         return options.initialState[key] || 0;
     },
-    makeTargetAnimatable(element, _a) {
-        var { transition, transitionEnd } = _a, target = __rest(_a, ["transition", "transitionEnd"]);
+    makeTargetAnimatable(element, { transition, transitionEnd, ...target }) {
         const origin = getOrigin(target, transition || {}, element);
         checkTargetForNewValues(element, target, origin);
-        return Object.assign({ transition, transitionEnd }, target);
+        return { transition, transitionEnd, ...target };
     },
 });
 const useVisualState = makeUseVisualState({
@@ -45,7 +43,7 @@ function useAnimatedState(initialState) {
     useEffect(() => {
         element.setProps({
             onUpdate: (v) => {
-                setAnimationState(Object.assign({}, v));
+                setAnimationState({ ...v });
             },
         });
     }, [setAnimationState, element]);

package/dist/es/animation/utils/default-transitions.mjs

@@ -47,7 +47,7 @@ const getDefaultTransition = (valueKey, to) => {
         transitionFactory =
             defaultTransitions[valueKey] || defaultTransitions.default;
     }
-    return Object.assign({ to }, transitionFactory(to));
+    return { to, ...transitionFactory(to) };
 };
 
 export { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };

package/dist/es/animation/utils/transitions.mjs

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { inertia, animate } from 'popmotion';
 import { secondsToMilliseconds } from '../../utils/time-conversion.mjs';
 import { isEasingArray, easingDefinitionToFunction } from './easing.mjs';
@@ -14,17 +13,15 @@ import { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';
  * This filters out orchestration options and returns true
  * if any options are left.
  */
-function isTransitionDefined(_a) {
-    var transition = __rest(_a, ["when", "delay", "delayChildren", "staggerChildren", "staggerDirection", "repeat", "repeatType", "repeatDelay", "from"]);
+function isTransitionDefined({ when, delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, ...transition }) {
     return !!Object.keys(transition).length;
 }
 let legacyRepeatWarning = false;
 /**
  * Convert Framer Motion's Transition type into Popmotion-compatible options.
  */
-function convertTransitionToAnimationOptions(_a) {
-    var { ease, times, yoyo, flip, loop } = _a, transition = __rest(_a, ["ease", "times", "yoyo", "flip", "loop"]);
-    const options = Object.assign({}, transition);
+function convertTransitionToAnimationOptions({ ease, times, yoyo, flip, loop, ...transition }) {
+    const options = { ...transition };
     if (times)
         options["offset"] = times;
     /**
@@ -89,26 +86,30 @@ function hydrateKeyframes(options) {
     return options;
 }
 function getPopmotionAnimationOptions(transition, options, key) {
-    var _a;
-    if (Array.isArray(options.to)) {
-        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);
+    if (Array.isArray(options.to) && transition.duration === undefined) {
+        transition.duration = 0.8;
     }
     hydrateKeyframes(options);
     /**
      * Get a default transition if none is determined to be defined.
      */
     if (!isTransitionDefined(transition)) {
-        transition = Object.assign(Object.assign({}, transition), getDefaultTransition(key, options.to));
+        transition = {
+            ...transition,
+            ...getDefaultTransition(key, options.to),
+        };
     }
-    return Object.assign(Object.assign({}, options), convertTransitionToAnimationOptions(transition));
+    return {
+        ...options,
+        ...convertTransitionToAnimationOptions(transition),
+    };
 }
 /**
  *
  */
 function getAnimation(key, value, target, transition, onComplete) {
-    var _a;
-    const valueTransition = getValueTransition(transition, key);
-    let origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();
+    const valueTransition = getValueTransition(transition, key) || {};
+    let origin = valueTransition.from !== undefined ? valueTransition.from : value.get();
     const isTargetAnimatable = isAnimatable(key, target);
     if (origin === "none" && isTargetAnimatable && typeof target === "string") {
         /**
@@ -137,24 +138,25 @@ function getAnimation(key, value, target, transition, onComplete) {
         };
         return valueTransition.type === "inertia" ||
             valueTransition.type === "decay"
-            ? inertia(Object.assign(Object.assign({}, options), valueTransition))
-            : animate(Object.assign(Object.assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: (v) => {
-                    var _a;
+            ? inertia({ ...options, ...valueTransition })
+            : animate({
+                ...getPopmotionAnimationOptions(valueTransition, options, key),
+                onUpdate: (v) => {
                     options.onUpdate(v);
-                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);
-                }, onComplete: () => {
-                    var _a;
+                    valueTransition.onUpdate && valueTransition.onUpdate(v);
+                },
+                onComplete: () => {
                     options.onComplete();
-                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);
-                } }));
+                    valueTransition.onComplete && valueTransition.onComplete();
+                },
+            });
     }
     function set() {
-        var _a, _b;
         const finalTarget = resolveFinalValueInKeyframes(target);
         value.set(finalTarget);
         onComplete();
-        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);
-        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);
+        valueTransition.onUpdate && valueTransition.onUpdate(finalTarget);
+        valueTransition.onComplete && valueTransition.onComplete();
         return { stop: () => { } };
     }
     return !isOriginAnimatable ||
@@ -199,7 +201,7 @@ function startAnimation(key, value, target, transition = {}) {
         }
         return () => {
             clearTimeout(delayTimer);
-            controls === null || controls === void 0 ? void 0 : controls.stop();
+            controls && controls.stop();
         };
     });
 }

package/dist/es/components/AnimatePresence/PopChild.mjs

@@ -44,14 +44,14 @@ function PopChild({ children, isPresent }) {
      * styles set via the style prop.
      */
     useInsertionEffect(() => {
-        var _a;
         const { width, height, top, left } = size.current;
         if (isPresent || !ref.current || !width || !height)
             return;
         ref.current.dataset.motionPopId = id;
         const style = document.createElement("style");
         document.head.appendChild(style);
-        (_a = style.sheet) === null || _a === void 0 ? void 0 : _a.insertRule(`
+        if (style.sheet) {
+            style.sheet.insertRule(`
           [data-motion-pop-id="${id}"] {
             position: absolute !important;
             width: ${width}px !important;
@@ -60,6 +60,7 @@ function PopChild({ children, isPresent }) {
             left: ${left}px !important;
           }
         `);
+        }
         return () => {
             document.head.removeChild(style);
         };

package/dist/es/components/AnimatePresence/PresenceChild.mjs

@@ -18,7 +18,7 @@ const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, p
                 if (!isComplete)
                     return; // can stop searching when any is incomplete
             }
-            onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete();
+            onExitComplete && onExitComplete();
         },
         register: (childId) => {
             presenceChildren.set(childId, false);
@@ -39,7 +39,10 @@ const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, p
      * component immediately.
      */
     React.useEffect(() => {
-        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());
+        !isPresent &&
+            !presenceChildren.size &&
+            onExitComplete &&
+            onExitComplete();
     }, [isPresent]);
     if (mode === "popLayout") {
         children = React.createElement(PopChild, { isPresent: isPresent }, children);

package/dist/es/components/AnimatePresence/use-presence.mjs

@@ -34,7 +34,7 @@ function usePresence() {
     // Replace with useId when released in React
     const id = useId();
     useEffect(() => register(id), []);
-    const safeToRemove = () => onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id);
+    const safeToRemove = () => onExitComplete && onExitComplete(id);
     return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
 }
 /**

package/dist/es/components/LayoutGroup/index.mjs

@@ -7,8 +7,7 @@ import { nodeGroup } from '../../projection/node/group.mjs';
 
 const shouldInheritGroup = (inherit) => inherit === true;
 const shouldInheritId = (inherit) => shouldInheritGroup(inherit === true) || inherit === "id";
-const LayoutGroup = ({ children, id, inheritId, inherit = true, }) => {
-    var _a, _b;
+const LayoutGroup = ({ children, id, inheritId, inherit = true }) => {
     // Maintain backwards-compatibility with inheritId until 7.0
     if (inheritId !== undefined)
         inherit = inheritId;
@@ -16,7 +15,7 @@ const LayoutGroup = ({ children, id, inheritId, inherit = true, }) => {
     const deprecatedLayoutGroupContext = useContext(DeprecatedLayoutGroupContext);
     const [forceRender, key] = useForceUpdate();
     const context = useRef(null);
-    const upstreamId = (_a = layoutGroupContext.id) !== null && _a !== void 0 ? _a : deprecatedLayoutGroupContext;
+    const upstreamId = layoutGroupContext.id || deprecatedLayoutGroupContext;
     if (context.current === null) {
         if (shouldInheritId(inherit) && upstreamId) {
             id = id ? upstreamId + "-" + id : upstreamId;
@@ -24,11 +23,11 @@ const LayoutGroup = ({ children, id, inheritId, inherit = true, }) => {
         context.current = {
             id,
             group: shouldInheritGroup(inherit)
-                ? (_b = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _b !== void 0 ? _b : nodeGroup()
+                ? layoutGroupContext.group || nodeGroup()
                 : nodeGroup(),
         };
     }
-    const memoizedContext = useMemo(() => (Object.assign(Object.assign({}, context.current), { forceRender })), [key]);
+    const memoizedContext = useMemo(() => ({ ...context.current, forceRender }), [key]);
     return (React.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));
 };
 

package/dist/es/components/LazyMotion/index.mjs

@@ -1,8 +1,7 @@
-import { __rest } from 'tslib';
 import * as React from 'react';
 import { useState, useRef, useEffect } from 'react';
 import { LazyContext } from '../../context/LazyContext.mjs';
-import { loadFeatures } from '../../motion/features/definitions.mjs';
+import { loadFeatures } from '../../motion/features/load-features.mjs';
 
 /**
  * Used in conjunction with the `m` component to reduce bundle size.
@@ -46,14 +45,13 @@ function LazyMotion({ children, features, strict = false }) {
      * If this is a synchronous load, load features immediately
      */
     if (!isLazyBundle(features)) {
-        const { renderer } = features, loadedFeatures = __rest(features, ["renderer"]);
+        const { renderer, ...loadedFeatures } = features;
         loadedRenderer.current = renderer;
         loadFeatures(loadedFeatures);
     }
     useEffect(() => {
         if (isLazyBundle(features)) {
-            features().then((_a) => {
-                var { renderer } = _a, loadedFeatures = __rest(_a, ["renderer"]);
+            features().then(({ renderer, ...loadedFeatures }) => {
                 loadFeatures(loadedFeatures);
                 loadedRenderer.current = renderer;
                 setIsLoaded(true);

package/dist/es/components/MotionConfig/index.mjs

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import * as React from 'react';
 import { useContext, useMemo } from 'react';
 import { MotionConfigContext } from '../../context/MotionConfigContext.mjs';
@@ -22,13 +21,12 @@ import { useConstant } from '../../utils/use-constant.mjs';
  *
  * @public
  */
-function MotionConfig(_a) {
-    var { children, isValidProp } = _a, config = __rest(_a, ["children", "isValidProp"]);
+function MotionConfig({ children, isValidProp, ...config }) {
     isValidProp && loadExternalIsValidProp(isValidProp);
     /**
      * Inherit props from any parent MotionConfig components
      */
-    config = Object.assign(Object.assign({}, useContext(MotionConfigContext)), config);
+    config = { ...useContext(MotionConfigContext), ...config };
     /**
      * Don't allow isStatic to change between renders as it affects how many hooks
      * motion components fire.

package/dist/es/components/Reorder/Group.mjs

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { invariant } from 'hey-listen';
 import * as React from 'react';
 import { forwardRef, useRef, useEffect } from 'react';
@@ -7,8 +6,7 @@ import { motion } from '../../render/dom/motion.mjs';
 import { useConstant } from '../../utils/use-constant.mjs';
 import { checkReorder } from './utils/check-reorder.mjs';
 
-function ReorderGroup(_a, externalRef) {
-    var { children, as = "ul", axis = "y", onReorder, values } = _a, props = __rest(_a, ["children", "as", "axis", "onReorder", "values"]);
+function ReorderGroup({ children, as = "ul", axis = "y", onReorder, values, ...props }, externalRef) {
     const Component = useConstant(() => motion(as));
     const order = [];
     const isReordering = useRef(false);
@@ -40,7 +38,7 @@ function ReorderGroup(_a, externalRef) {
     useEffect(() => {
         isReordering.current = false;
     });
-    return (React.createElement(Component, Object.assign({}, props, { ref: externalRef }),
+    return (React.createElement(Component, { ...props, ref: externalRef },
         React.createElement(ReorderContext.Provider, { value: context }, children)));
 }
 const Group = forwardRef(ReorderGroup);

package/dist/es/components/Reorder/Item.mjs

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { invariant } from 'hey-listen';
 import * as React from 'react';
 import { forwardRef, useContext, useRef, useEffect } from 'react';
@@ -12,13 +11,12 @@ import { isMotionValue } from '../../value/utils/is-motion-value.mjs';
 function useDefaultMotionValue(value, defaultValue = 0) {
     return isMotionValue(value) ? value : useMotionValue(defaultValue);
 }
-function ReorderItem(_a, externalRef) {
-    var { children, style, value, as = "li", onDrag, layout = true } = _a, props = __rest(_a, ["children", "style", "value", "as", "onDrag", "layout"]);
+function ReorderItem({ children, style = {}, value, as = "li", onDrag, layout = true, ...props }, externalRef) {
     const Component = useConstant(() => motion(as));
     const context = useContext(ReorderContext);
     const point = {
-        x: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.x),
-        y: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.y),
+        x: useDefaultMotionValue(style.x),
+        y: useDefaultMotionValue(style.y),
     };
     const zIndex = useTransform([point.x, point.y], ([latestX, latestY]) => latestX || latestY ? 1 : "unset");
     const measuredLayout = useRef(null);
@@ -27,14 +25,14 @@ function ReorderItem(_a, externalRef) {
     useEffect(() => {
         registerItem(value, measuredLayout.current);
     }, [context]);
-    return (React.createElement(Component, Object.assign({ drag: axis }, props, { dragSnapToOrigin: true, style: Object.assign(Object.assign({}, style), { x: point.x, y: point.y, zIndex }), layout: layout, onDrag: (event, gesturePoint) => {
+    return (React.createElement(Component, { drag: axis, ...props, dragSnapToOrigin: true, style: { ...style, x: point.x, y: point.y, zIndex }, layout: layout, onDrag: (event, gesturePoint) => {
             const { velocity } = gesturePoint;
             velocity[axis] &&
                 updateOrder(value, point[axis].get(), velocity[axis]);
-            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, gesturePoint);
+            onDrag && onDrag(event, gesturePoint);
         }, onLayoutMeasure: (measured) => {
             measuredLayout.current = measured;
-        }, ref: externalRef }), children));
+        }, ref: externalRef }, children));
 }
 const Item = forwardRef(ReorderItem);
 

package/dist/es/context/MotionContext/utils.mjs

@@ -1,7 +1,8 @@
-import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.mjs';
+import { isVariantLabel } from '../../render/utils/is-variant-label.mjs';
+import { isControllingVariants } from '../../render/utils/is-controlling-variants.mjs';
 
 function getCurrentTreeVariants(props, context) {
-    if (checkIfControllingVariants(props)) {
+    if (isControllingVariants(props)) {
         const { initial, animate } = props;
         return {
             initial: initial === false || isVariantLabel(initial)

package/dist/es/gestures/PanSession.mjs

@@ -39,7 +39,7 @@ class PanSession {
                 return;
             const { point } = info;
             const { timestamp } = getFrameData();
-            this.history.push(Object.assign(Object.assign({}, point), { timestamp }));
+            this.history.push({ ...point, timestamp });
             const { onStart, onMove } = this.handlers;
             if (!isPanStarted) {
                 onStart && onStart(this.lastMoveEvent, info);
@@ -76,7 +76,7 @@ class PanSession {
         const initialInfo = transformPoint(info, this.transformPagePoint);
         const { point } = initialInfo;
         const { timestamp } = getFrameData();
-        this.history = [Object.assign(Object.assign({}, point), { timestamp })];
+        this.history = [{ ...point, timestamp }];
         const { onSessionStart } = handlers;
         onSessionStart &&
             onSessionStart(event, getPanInfo(initialInfo, this.history));

package/dist/es/gestures/drag/VisualElementDragControls.mjs

@@ -251,8 +251,17 @@ class VisualElementDragControls {
              */
             const bounceStiffness = dragElastic ? 200 : 1000000;
             const bounceDamping = dragElastic ? 40 : 10000000;
-            const inertia = Object.assign(Object.assign({ type: "inertia", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness,
-                bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);
+            const inertia = {
+                type: "inertia",
+                velocity: dragMomentum ? velocity[axis] : 0,
+                bounceStiffness,
+                bounceDamping,
+                timeConstant: 750,
+                restDelta: 1,
+                restSpeed: 10,
+                ...dragTransition,
+                ...transition,
+            };
             // If we're not animating on an externally-provided `MotionValue` we can use the
             // component's animation controls which will handle interactions with whileHover (etc),
             // otherwise we just have to animate the `MotionValue` itself.
@@ -404,12 +413,15 @@ class VisualElementDragControls {
     getProps() {
         const props = this.visualElement.getProps();
         const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;
-        return Object.assign(Object.assign({}, props), { drag,
+        return {
+            ...props,
+            drag,
             dragDirectionLock,
             dragPropagation,
             dragConstraints,
             dragElastic,
-            dragMomentum });
+            dragMomentum,
+        };
     }
 }
 function shouldDrag(direction, drag, currentDirection) {

package/dist/es/gestures/use-focus-gesture.mjs

@@ -8,13 +8,12 @@ import { useDomEvent } from '../events/use-dom-event.mjs';
  * @internal
  */
 function useFocusGesture({ whileFocus, visualElement }) {
+    const { animationState } = visualElement;
     const onFocus = () => {
-        var _a;
-        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, true);
+        animationState && animationState.setActive(AnimationType.Focus, true);
     };
     const onBlur = () => {
-        var _a;
-        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Focus, false);
+        animationState && animationState.setActive(AnimationType.Focus, false);
     };
     useDomEvent(visualElement, "focus", whileFocus ? onFocus : undefined);
     useDomEvent(visualElement, "blur", whileFocus ? onBlur : undefined);

package/dist/es/gestures/use-hover-gesture.mjs

@@ -5,14 +5,15 @@ import { isDragActive } from './drag/utils/lock.mjs';
 
 function createHoverEvent(visualElement, isActive, callback) {
     return (event, info) => {
-        var _a;
         if (!isMouseEvent(event) || isDragActive())
             return;
         /**
          * Ensure we trigger animations before firing event callback
          */
-        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Hover, isActive);
-        callback === null || callback === void 0 ? void 0 : callback(event, info);
+        if (visualElement.animationState) {
+            visualElement.animationState.setActive(AnimationType.Hover, isActive);
+        }
+        callback && callback(event, info);
     };
 }
 function useHoverGesture({ onHoverStart, onHoverEnd, whileHover, visualElement, }) {

package/dist/es/gestures/use-tap-gesture.mjs

@@ -21,15 +21,14 @@ function useTapGesture({ onTap, onTapStart, onTapCancel, whileTap, visualElement
         passive: !(onTapStart || onTap || onTapCancel || onPointerDown),
     };
     function removePointerEndListener() {
-        var _a;
-        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);
+        cancelPointerEndListeners.current && cancelPointerEndListeners.current();
         cancelPointerEndListeners.current = null;
     }
     function checkPointerEnd() {
-        var _a;
         removePointerEndListener();
         isPressing.current = false;
-        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, false);
+        visualElement.animationState &&
+            visualElement.animationState.setActive(AnimationType.Tap, false);
         return !isDragActive();
     }
     function onPointerUp(event, info) {
@@ -40,16 +39,15 @@ function useTapGesture({ onTap, onTapStart, onTapCancel, whileTap, visualElement
          * as, or a child of, this component's element
          */
         !isNodeOrChild(visualElement.getInstance(), event.target)
-            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)
-            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);
+            ? onTapCancel && onTapCancel(event, info)
+            : onTap && onTap(event, info);
     }
     function onPointerCancel(event, info) {
         if (!checkPointerEnd())
             return;
-        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);
+        onTapCancel && onTapCancel(event, info);
     }
     function onPointerDown(event, info) {
-        var _a;
         removePointerEndListener();
         if (isPressing.current)
             return;
@@ -58,8 +56,9 @@ function useTapGesture({ onTap, onTapStart, onTapCancel, whileTap, visualElement
         /**
          * Ensure we trigger animations before firing event callback
          */
-        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Tap, true);
-        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);
+        visualElement.animationState &&
+            visualElement.animationState.setActive(AnimationType.Tap, true);
+        onTapStart && onTapStart(event, info);
     }
     usePointerEvent(visualElement, "pointerdown", hasPressListeners ? onPointerDown : undefined, eventOptions);
     useUnmountEffect(removePointerEndListener);

package/dist/es/index.mjs

@@ -20,7 +20,8 @@ export { useElementScroll } from './value/scroll/use-element-scroll.mjs';
 export { useViewportScroll } from './value/scroll/use-viewport-scroll.mjs';
 export { useTime } from './value/use-time.mjs';
 export { useWillChange } from './value/use-will-change/index.mjs';
-export { useReducedMotion, useReducedMotionConfig } from './utils/use-reduced-motion.mjs';
+export { useReducedMotion } from './utils/reduced-motion/use-reduced-motion.mjs';
+export { useReducedMotionConfig } from './utils/reduced-motion/use-reduced-motion-config.mjs';
 export { animationControls } from './animation/animation-controls.mjs';
 export { useAnimation, useAnimationControls } from './animation/use-animation.mjs';
 export { useAnimationFrame } from './utils/use-animation-frame.mjs';

package/dist/es/motion/features/animations.mjs

@@ -26,10 +26,15 @@ const animations = {
         const [isPresent, safeToRemove] = usePresence();
         const presenceContext = useContext(PresenceContext);
         useEffect(() => {
-            var _a, _b;
             visualElement.isPresent = isPresent;
-            const animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });
-            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));
+            const animation = visualElement.animationState &&
+                visualElement.animationState.setActive(AnimationType.Exit, !isPresent, {
+                    custom: (presenceContext && presenceContext.custom) ||
+                        custom,
+                });
+            if (animation && !isPresent) {
+                animation.then(safeToRemove);
+            }
         }, [isPresent]);
     }),
 };

package/dist/es/motion/features/definitions.mjs

@@ -30,17 +30,5 @@ const featureDefinitions = {
         "onViewportLeave",
     ]),
 };
-function loadFeatures(features) {
-    for (const key in features) {
-        if (features[key] === null)
-            continue;
-        if (key === "projectionNodeConstructor") {
-            featureDefinitions.projectionNodeConstructor = features[key];
-        }
-        else {
-            featureDefinitions[key].Component = features[key];
-        }
-    }
-}
 
-export { featureDefinitions, loadFeatures };
+export { featureDefinitions };

package/dist/es/motion/features/layout/MeasureLayout.mjs

@@ -19,16 +19,19 @@ class MeasureLayoutWithContext extends React__default.Component {
         const { projection } = visualElement;
         addScaleCorrector(defaultScaleCorrectors);
         if (projection) {
-            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)
+            if (layoutGroup.group)
                 layoutGroup.group.add(projection);
-            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {
+            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
                 switchLayoutGroup.register(projection);
             }
             projection.root.didUpdate();
             projection.addEventListener("animationComplete", () => {
                 this.safeToRemove();
             });
-            projection.setOptions(Object.assign(Object.assign({}, projection.options), { onExitComplete: () => this.safeToRemove() }));
+            projection.setOptions({
+                ...projection.options,
+                onExitComplete: () => this.safeToRemove(),
+            });
         }
         globalProjectionState.hasEverUpdated = true;
     }
@@ -104,15 +107,18 @@ class MeasureLayoutWithContext extends React__default.Component {
 function MeasureLayout(props) {
     const [isPresent, safeToRemove] = usePresence();
     const layoutGroup = useContext(LayoutGroupContext);
-    return (React__default.createElement(MeasureLayoutWithContext, Object.assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));
+    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));
 }
 const defaultScaleCorrectors = {
-    borderRadius: Object.assign(Object.assign({}, correctBorderRadius), { applyTo: [
+    borderRadius: {
+        ...correctBorderRadius,
+        applyTo: [
             "borderTopLeftRadius",
             "borderTopRightRadius",
             "borderBottomLeftRadius",
             "borderBottomRightRadius",
-        ] }),
+        ],
+    },
     borderTopLeftRadius: correctBorderRadius,
     borderTopRightRadius: correctBorderRadius,
     borderBottomLeftRadius: correctBorderRadius,

package/dist/es/motion/features/load-features.mjs

@@ -0,0 +1,14 @@
+import { featureDefinitions } from './definitions.mjs';
+
+function loadFeatures(features) {
+    for (const key in features) {
+        if (key === "projectionNodeConstructor") {
+            featureDefinitions.projectionNodeConstructor = features[key];
+        }
+        else {
+            featureDefinitions[key].Component = features[key];
+        }
+    }
+}
+
+export { loadFeatures };