motion-v 0.8.1 → 0.10.0-beta.1

package/dist/es/animation/hooks/animation-controls.mjs

@@ -1,6 +1,6 @@
 import { mountedStates } from "../../state/motion-state.mjs";
 import { invariant } from "hey-listen";
-import { setTarget } from "../../external/.pnpm/framer-motion@11.16.6/external/framer-motion/dist/es/render/utils/setters.mjs";
+import { setTarget } from "../../external/.pnpm/framer-motion@12.4.0/external/framer-motion/dist/es/render/utils/setters.mjs";
 import { resolveVariant } from "../../state/utils.mjs";
 function stopAnimation(visualElement) {
   visualElement.values.forEach((value) => value.stop());

package/dist/es/animation/hooks/use-animate.mjs

@@ -1,5 +1,5 @@
 import { ref, onUnmounted } from "vue";
-import { createScopedAnimate } from "../../external/.pnpm/framer-motion@11.16.6/external/framer-motion/dist/es/animation/animate/index.mjs";
+import { createScopedAnimate } from "../../external/.pnpm/framer-motion@12.4.0/external/framer-motion/dist/es/animation/animate/index.mjs";
 function useAnimate() {
   const dom = ref(null);
   const domProxy = new Proxy(dom, {

package/dist/es/components/animate-presence/AnimatePresence.vue.mjs

@@ -2,7 +2,7 @@ import { defineComponent, onMounted, onUnmounted, computed, openBlock, createBlo
 import { mountedStates } from "../../state/motion-state.mjs";
 import { provideAnimatePresence, removeDoneCallback, doneCallbacks } from "../presence.mjs";
 import { usePopLayout } from "./use-pop-layout.mjs";
-import { frame } from "../../external/.pnpm/framer-motion@11.16.6/external/framer-motion/dist/es/frameloop/frame.mjs";
+import { frame } from "../../external/.pnpm/framer-motion@12.4.0/external/framer-motion/dist/es/frameloop/frame.mjs";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
     name: "AnimatePresence",

package/dist/es/components/context.d.ts

@@ -6,7 +6,6 @@ export interface NodeGroup {
     add: (node: IProjectionNode) => void;
     remove: (node: IProjectionNode) => void;
     dirty: VoidFunction;
-    didUpdate: VoidFunction;
 }
 export interface LayoutGroupState {
     id?: string;

package/dist/es/components/index.d.ts

@@ -1,3 +1,4 @@
 export { Motion, motion, type MotionProps } from './motion';
 export * from './animate-presence';
 export * from './motion-config';
+export * from './reorder';

package/dist/es/components/motion/Motion.vue.mjs

@@ -35,6 +35,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     layoutRoot: { type: Boolean },
     "data-framer-portal-id": {},
     crossfade: { type: Boolean },
+    onBeforeLayoutMeasure: { type: Function },
+    onLayoutMeasure: { type: Function },
+    onLayoutAnimationStart: { type: Function },
+    onLayoutAnimationComplete: { type: Function },
     globalPressTarget: { type: Boolean },
     press: {},
     onPressStart: { type: Function },
@@ -136,7 +140,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       state.update(getMotionProps());
     });
     function getProps() {
-      const isSVG = state.visualElement.type === "svg";
+      var _a, _b;
+      const isSVG = ((_a = state.visualElement) == null ? void 0 : _a.type) === "svg";
       const attrsProps = { ...attrs };
       Object.keys(attrs).forEach((key) => {
         if (isMotionValue(attrs[key]))
@@ -144,7 +149,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       });
       let styleProps = {
         ...props.style,
-        ...isSVG ? {} : state.visualElement.latestValues
+        ...isSVG ? {} : (_b = state.visualElement) == null ? void 0 : _b.latestValues
       };
       if (isSVG) {
         const { attributes, style } = convertSvgStyleToAttributes(state.target);

package/dist/es/components/reorder/Group.d.ts

@@ -0,0 +1,71 @@
+import { MotionProps } from '../motion';
+import { ElementType } from '../../types';
+export interface GroupProps<T extends ElementType, K = unknown, V = unknown> extends MotionProps<T, K> {
+    /**
+     * The axis to reorder along. By default, items will be draggable on this axis.
+     * To make draggable on both axes, set `<Reorder.Item drag />`
+     *
+     * @public
+     */
+    'axis'?: 'x' | 'y';
+    /**
+     * A callback to fire with the new value order. For instance, if the values
+     * are provided as a state from `useState`, this could be the set state function.
+     *
+     * @public
+     */
+    'onUpdate:values'?: (newOrder: V[]) => void;
+    /**
+     * The latest values state.
+     *
+     * ```jsx
+     * function Component() {
+     *   const [items, setItems] = useState([0, 1, 2])
+     *
+     *   return (
+     *     <Reorder.Group values={items} onReorder={setItems}>
+     *         {items.map((item) => <Reorder.Item key={item} value={item} />)}
+     *     </Reorder.Group>
+     *   )
+     * }
+     * ```
+     *
+     * @public
+     */
+    'values': V[];
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<GroupProps<keyof import('vue').IntrinsicElementAttributes, unknown, unknown>>, {
+    as: string;
+    axis: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<GroupProps<keyof import('vue').IntrinsicElementAttributes, unknown, unknown>>, {
+    as: string;
+    axis: string;
+}>>>, {
+    as: keyof import('vue').IntrinsicElementAttributes;
+    axis: "x" | "y";
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/es/components/reorder/Group.vue.mjs

@@ -0,0 +1,131 @@
+import { defineComponent, toRefs, onUpdated, useAttrs, openBlock, createBlock, unref, normalizeProps, guardReactiveProps, withCtx, renderSlot, createTextVNode, toDisplayString } from "vue";
+import { invariant } from "hey-listen";
+import { reorderContextProvider } from "./context.mjs";
+import { compareMin, checkReorder, getValue } from "./utils.mjs";
+import _sfc_main$1 from "../motion/Motion.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "ReorderGroup",
+    inheritAttrs: false
+  },
+  __name: "Group",
+  props: {
+    axis: { default: "y" },
+    "onUpdate:values": {},
+    values: {},
+    as: { default: "ul" },
+    asChild: { type: Boolean },
+    whileDrag: {},
+    custom: {},
+    initial: { type: [String, Object, Boolean] },
+    animate: {},
+    exit: {},
+    variants: {},
+    style: {},
+    transformTemplate: {},
+    transition: {},
+    layoutGroup: {},
+    motionConfig: {},
+    onAnimationComplete: {},
+    onUpdate: {},
+    layout: { type: [Boolean, String] },
+    layoutId: {},
+    layoutScroll: { type: Boolean },
+    layoutRoot: { type: Boolean },
+    "data-framer-portal-id": {},
+    crossfade: { type: Boolean },
+    onBeforeLayoutMeasure: {},
+    onLayoutMeasure: {},
+    onLayoutAnimationStart: {},
+    onLayoutAnimationComplete: {},
+    globalPressTarget: { type: Boolean },
+    press: {},
+    onPressStart: {},
+    onPress: {},
+    onPressCancel: {},
+    hover: {},
+    onHoverStart: {},
+    onHoverEnd: {},
+    inViewOptions: {},
+    inView: {},
+    onViewportEnter: {},
+    onViewportLeave: {},
+    drag: { type: [Boolean, String] },
+    dragSnapToOrigin: { type: Boolean },
+    dragDirectionLock: { type: Boolean },
+    dragPropagation: { type: Boolean },
+    dragConstraints: { type: [Boolean, Object] },
+    dragElastic: { type: [Boolean, Number, Object] },
+    dragMomentum: { type: Boolean },
+    dragTransition: {},
+    dragListener: { type: Boolean },
+    dragControls: {},
+    onDragStart: {},
+    onDragEnd: {},
+    onDrag: {},
+    onDirectionLock: {},
+    onDragTransitionEnd: {},
+    onMeasureDragConstraints: {},
+    onPanSessionStart: {},
+    onPanStart: {},
+    onPan: {},
+    onPanEnd: {},
+    focus: {},
+    onFocus: {},
+    onBlur: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { axis } = toRefs(props);
+    const order = [];
+    let isReordering = false;
+    function warning() {
+      invariant(Boolean(props.values), "Reorder.Group must be provided a values prop");
+    }
+    onUpdated(() => {
+      isReordering = false;
+    });
+    reorderContextProvider({
+      axis,
+      registerItem: (value, layout) => {
+        const idx = order.findIndex((entry) => value === entry.value);
+        if (idx !== -1) {
+          order[idx].layout = layout[axis.value];
+        } else {
+          order.push({ value, layout: layout[axis.value] });
+        }
+        order.sort(compareMin);
+      },
+      updateOrder: (item, offset, velocity) => {
+        if (isReordering)
+          return;
+        const newOrder = checkReorder(order, item, offset, velocity);
+        if (order !== newOrder) {
+          isReordering = true;
+          props["onUpdate:values"](
+            newOrder.map(getValue).filter((value) => props.values.includes(value))
+          );
+        }
+      }
+    });
+    const attrs = useAttrs();
+    function bindProps() {
+      return {
+        ...attrs,
+        ...props
+      };
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), normalizeProps(guardReactiveProps(bindProps())), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default"),
+          createTextVNode(" " + toDisplayString(warning()), 1)
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/components/reorder/Group.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./Group.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/es/components/reorder/Item.d.ts

@@ -0,0 +1,88 @@
+import { MotionProps } from '../motion';
+import { ElementType } from '../../types';
+export interface GroupItemProps<T extends ElementType, K = unknown, V = unknown> extends MotionProps<T, K> {
+    /**
+     * The value in the list that this component represents.
+     *
+     * @public
+     */
+    value: V;
+    /**
+     * A subset of layout options primarily used to disable layout="size"
+     *
+     * @public
+     * @default true
+     */
+    layout?: true | 'position';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<GroupItemProps<keyof import('vue').IntrinsicElementAttributes, unknown, unknown>>, {
+    layout: boolean;
+    as: ElementType;
+    initial: any;
+    animate: any;
+    hover: any;
+    inView: any;
+    layoutId: any;
+    layoutScroll: boolean;
+    layoutRoot: boolean;
+    dragListener: boolean;
+    dragElastic: number;
+    dragMomentum: boolean;
+    whileDrag: any;
+    crossfade: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<GroupItemProps<keyof import('vue').IntrinsicElementAttributes, unknown, unknown>>, {
+    layout: boolean;
+    as: ElementType;
+    initial: any;
+    animate: any;
+    hover: any;
+    inView: any;
+    layoutId: any;
+    layoutScroll: boolean;
+    layoutRoot: boolean;
+    dragListener: boolean;
+    dragElastic: number;
+    dragMomentum: boolean;
+    whileDrag: any;
+    crossfade: boolean;
+}>>>, {
+    layout: true | "position";
+    layoutId: string;
+    layoutScroll: boolean;
+    layoutRoot: boolean;
+    crossfade: boolean;
+    initial: string | import('../../types').Variant | boolean;
+    animate: string | import('../../types').Variant | import('../../animation/types').AnimationControls;
+    inView: string | import('../../types').Variant;
+    hover: string | import('../../types').Variant;
+    whileDrag: import('../../types').Options["whileDrag"];
+    dragElastic: number;
+    dragMomentum: boolean;
+    dragListener: boolean;
+    as: keyof import('vue').IntrinsicElementAttributes;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/es/components/reorder/Item.vue.mjs

@@ -0,0 +1,131 @@
+import { defineComponent, toRefs, useAttrs, computed, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot, createTextVNode, toDisplayString } from "vue";
+import { useReorderContext } from "./context.mjs";
+import { useDefaultMotionValue } from "./utils.mjs";
+import { invariant } from "hey-listen";
+import { useTransform } from "../../value/use-transform.mjs";
+import _sfc_main$1 from "../motion/Motion.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "ReorderItem",
+    inheritAttrs: false
+  },
+  __name: "Item",
+  props: {
+    value: {},
+    layout: { type: [Boolean, String], default: true },
+    as: { default: "li" },
+    asChild: { type: Boolean },
+    whileDrag: { default: void 0 },
+    custom: {},
+    initial: { type: [String, Object, Boolean], default: void 0 },
+    animate: { default: void 0 },
+    exit: {},
+    variants: {},
+    style: {},
+    transformTemplate: {},
+    transition: {},
+    layoutGroup: {},
+    motionConfig: {},
+    onAnimationComplete: {},
+    onUpdate: {},
+    layoutId: { default: void 0 },
+    layoutScroll: { type: Boolean, default: false },
+    layoutRoot: { type: Boolean, default: false },
+    "data-framer-portal-id": {},
+    crossfade: { type: Boolean, default: true },
+    onBeforeLayoutMeasure: {},
+    onLayoutMeasure: {},
+    onLayoutAnimationStart: {},
+    onLayoutAnimationComplete: {},
+    globalPressTarget: { type: Boolean },
+    press: {},
+    onPressStart: {},
+    onPress: {},
+    onPressCancel: {},
+    hover: { default: void 0 },
+    onHoverStart: {},
+    onHoverEnd: {},
+    inViewOptions: {},
+    inView: { default: void 0 },
+    onViewportEnter: {},
+    onViewportLeave: {},
+    drag: { type: [Boolean, String] },
+    dragSnapToOrigin: { type: Boolean },
+    dragDirectionLock: { type: Boolean },
+    dragPropagation: { type: Boolean },
+    dragConstraints: { type: [Boolean, Object] },
+    dragElastic: { type: [Boolean, Number, Object], default: 0.5 },
+    dragMomentum: { type: Boolean, default: true },
+    dragTransition: {},
+    dragListener: { type: Boolean, default: true },
+    dragControls: {},
+    onDragStart: {},
+    onDragEnd: {},
+    onDrag: {},
+    onDirectionLock: {},
+    onDragTransitionEnd: {},
+    onMeasureDragConstraints: {},
+    onPanSessionStart: {},
+    onPanStart: {},
+    onPan: {},
+    onPanEnd: {},
+    focus: {},
+    onFocus: {},
+    onBlur: {}
+  },
+  setup(__props) {
+    var _a, _b;
+    const props = __props;
+    const { style } = toRefs(props);
+    const context = useReorderContext(null);
+    const point = {
+      x: useDefaultMotionValue((_a = style.value) == null ? void 0 : _a.x),
+      y: useDefaultMotionValue((_b = style.value) == null ? void 0 : _b.y)
+    };
+    const zIndex = useTransform([point.x, point.y], ([latestX, latestY]) => latestX || latestY ? 1 : "unset");
+    function warning() {
+      invariant(Boolean(context), "Reorder.Item must be a child of Reorder.Group");
+    }
+    const { axis, registerItem, updateOrder } = context || {};
+    const attrs = useAttrs();
+    function bindProps() {
+      return {
+        ...attrs,
+        ...props,
+        style: {
+          ...style.value,
+          x: point.x,
+          y: point.y,
+          zIndex
+        }
+      };
+    }
+    const drag = computed(() => {
+      if (props.drag) {
+        return props.drag;
+      }
+      return axis.value;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), mergeProps(bindProps(), {
+        drag: drag.value,
+        "drag-snap-to-origin": true,
+        onDrag: _cache[0] || (_cache[0] = (event, gesturePoint) => {
+          const { velocity } = gesturePoint;
+          velocity[unref(axis)] && unref(updateOrder)(_ctx.value, point[unref(axis)].get(), velocity[unref(axis)]);
+          _ctx.onDrag && _ctx.onDrag(event, gesturePoint);
+        }),
+        onLayoutMeasure: _cache[1] || (_cache[1] = (measured) => unref(registerItem)(_ctx.value, measured))
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default"),
+          createTextVNode(" " + toDisplayString(warning()), 1)
+        ]),
+        _: 3
+      }, 16, ["drag"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/components/reorder/Item.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./Item.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/es/components/reorder/context.d.ts

@@ -0,0 +1,8 @@
+import { Box } from 'framer-motion';
+import { Ref } from 'vue';
+export interface ReorderContextProps<T> {
+    axis?: Ref<'x' | 'y'>;
+    registerItem?: (item: T, layout: Box) => void;
+    updateOrder?: (item: T, offset: number, velocity: number) => void;
+}
+export declare const useReorderContext: <T extends ReorderContextProps<any> = ReorderContextProps<any>>(fallback?: T) => T extends null ? ReorderContextProps<any> : ReorderContextProps<any>, reorderContextProvider: (contextValue: ReorderContextProps<any>) => ReorderContextProps<any>;

package/dist/es/components/reorder/context.mjs

@@ -0,0 +1,6 @@
+import { createContext } from "../../utils/createContext.mjs";
+const [useReorderContext, reorderContextProvider] = createContext("ReorderContext");
+export {
+  reorderContextProvider,
+  useReorderContext
+};

package/dist/es/components/reorder/index.d.ts

@@ -0,0 +1,13 @@
+import { DefineSetupFnComponent, IntrinsicElementAttributes } from 'vue';
+import { GroupProps } from './Group';
+import { GroupItemProps } from './Item';
+import { ElementType, SVGAttributesWithMotionValues, SetMotionValueType } from '../../types';
+type IntrinsicElementAttributesAsMotionValues = SetMotionValueType<IntrinsicElementAttributes, keyof SVGAttributesWithMotionValues>;
+type ItemProps<T extends ElementType = 'li'> = GroupItemProps<T, unknown, unknown> & IntrinsicElementAttributesAsMotionValues[T];
+export declare const ReorderGroup: DefineSetupFnComponent<GroupProps<ElementType, any, any>>;
+export declare const ReorderItem: DefineSetupFnComponent<ItemProps<ElementType>>;
+export declare const Reorder: {
+    Group: DefineSetupFnComponent<GroupProps<keyof IntrinsicElementAttributes, any, any>>;
+    Item: DefineSetupFnComponent<ItemProps<keyof IntrinsicElementAttributes>>;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import _sfc_main from "./Group.vue.mjs";
+import _sfc_main$1 from "./Item.vue.mjs";
+const ReorderGroup = _sfc_main;
+const ReorderItem = _sfc_main$1;
+const Reorder = {
+  Group: ReorderGroup,
+  Item: ReorderItem
+};
+export {
+  Reorder,
+  ReorderGroup,
+  ReorderItem
+};

package/dist/es/components/reorder/types.d.ts

@@ -0,0 +1,5 @@
+import { Axis } from 'framer-motion';
+export interface ItemData<T> {
+    value: T;
+    layout: Axis;
+}

package/dist/es/components/reorder/utils.d.ts

@@ -0,0 +1,6 @@
+import { ItemData } from './types';
+export declare function compareMin<V>(a: ItemData<V>, b: ItemData<V>): number;
+export declare function getValue<V>(item: ItemData<V>): V;
+export declare function checkReorder<T>(order: ItemData<T>[], value: T, offset: number, velocity: number): ItemData<T>[];
+export declare function moveItem<T>([...arr]: T[], fromIndex: number, toIndex: number): T[];
+export declare function useDefaultMotionValue(value: any, defaultValue?: number): import('framer-motion/dom').MotionValue<any>;

package/dist/es/components/reorder/utils.mjs

@@ -0,0 +1,46 @@
+import { mixNumber } from "../../utils/mix/number.mjs";
+import { motionValue } from "../../external/.pnpm/framer-motion@12.4.0/external/framer-motion/dist/es/value/index.mjs";
+import { isMotionValue } from "../../utils/motion-value.mjs";
+function compareMin(a, b) {
+  return a.layout.min - b.layout.min;
+}
+function getValue(item) {
+  return item.value;
+}
+function checkReorder(order, value, offset, velocity) {
+  if (!velocity)
+    return order;
+  const index = order.findIndex((item2) => item2.value === value);
+  if (index === -1)
+    return order;
+  const nextOffset = velocity > 0 ? 1 : -1;
+  const nextItem = order[index + nextOffset];
+  if (!nextItem)
+    return order;
+  const item = order[index];
+  const nextLayout = nextItem.layout;
+  const nextItemCenter = mixNumber(nextLayout.min, nextLayout.max, 0.5);
+  if (nextOffset === 1 && item.layout.max + offset > nextItemCenter || nextOffset === -1 && item.layout.min + offset < nextItemCenter) {
+    return moveItem(order, index, index + nextOffset);
+  }
+  return order;
+}
+function moveItem([...arr], fromIndex, toIndex) {
+  const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;
+  if (startIndex >= 0 && startIndex < arr.length) {
+    const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;
+    const [item] = arr.splice(fromIndex, 1);
+    arr.splice(endIndex, 0, item);
+  }
+  return arr;
+}
+function useDefaultMotionValue(value, defaultValue = 0) {
+  return isMotionValue(value) ? value : motionValue(defaultValue);
+}
+export {
+  checkReorder,
+  compareMin,
+  getValue,
+  moveItem,
+  useDefaultMotionValue
+};

package/dist/es/constants/index.mjs

@@ -3,7 +3,9 @@ const components = {
     "Motion",
     "AnimatePresence",
     "LayoutGroup",
-    "MotionConfig"
+    "MotionConfig",
+    "ReorderGroup",
+    "ReorderItem"
   ]
 };
 const utilities = {

package/dist/es/external/.pnpm/{framer-motion@11.16.6 → framer-motion@12.4.0}/external/framer-motion/dist/es/animation/animate/index.mjs

@@ -1,9 +1,9 @@
-import { GroupPlaybackControls } from "../../../../../../../motion-dom@11.16.4/external/motion-dom/dist/es/animation/controls/Group.mjs";
-import "../../../../../../../motion-utils@11.16.0/external/motion-utils/dist/es/errors.mjs";
+import { GroupPlaybackControls } from "../../../../../../../motion-dom@12.0.0/external/motion-dom/dist/es/animation/controls/Group.mjs";
+import "../../../../../../../motion-utils@12.0.0/external/motion-utils/dist/es/errors.mjs";
 import { animateSequence } from "./sequence.mjs";
 import { animateSubject } from "./subject.mjs";
 function isSequence(value) {
-  return Array.isArray(value) && Array.isArray(value[0]);
+  return Array.isArray(value) && value.some(Array.isArray);
 }
 function createScopedAnimate(scope) {
   function scopedAnimate(subjectOrSequence, optionsOrKeyframes, options) {

package/dist/es/external/.pnpm/{framer-motion@11.16.6 → framer-motion@12.4.0}/external/framer-motion/dist/es/animation/animate/resolve-subjects.mjs

@@ -1,5 +1,5 @@
-import "../../../../../../../motion-utils@11.16.0/external/motion-utils/dist/es/errors.mjs";
-import { resolveElements } from "../../../../../../../motion-dom@11.16.4/external/motion-dom/dist/es/utils/resolve-elements.mjs";
+import "../../../../../../../motion-utils@12.0.0/external/motion-utils/dist/es/errors.mjs";
+import { resolveElements } from "../../../../../../../motion-dom@12.0.0/external/motion-dom/dist/es/utils/resolve-elements.mjs";
 import { isDOMKeyframes } from "../utils/is-dom-keyframes.mjs";
 function resolveSubjects(subject, keyframes, scope, selectorCache) {
   if (typeof subject === "string" && isDOMKeyframes(keyframes)) {

package/dist/es/external/.pnpm/{framer-motion@11.16.6 → framer-motion@12.4.0}/external/framer-motion/dist/es/animation/animate/subject.mjs

@@ -1,4 +1,4 @@
-import { invariant } from "../../../../../../../motion-utils@11.16.0/external/motion-utils/dist/es/errors.mjs";
+import { invariant } from "../../../../../../../motion-utils@12.0.0/external/motion-utils/dist/es/errors.mjs";
 import { visualElementStore } from "../../render/store.mjs";
 import { isMotionValue } from "../../value/utils/is-motion-value.mjs";
 import { animateTarget } from "../interfaces/visual-element-target.mjs";