motion-v 0.8.0 → 0.9.0

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@11.16.6/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/features/layout/layout.d.ts

@@ -4,6 +4,7 @@ export declare class LayoutFeature extends Feature {
     constructor(state: MotionState);
     beforeUpdate(): void;
     update(): void;
+    didUpdate(): void;
     beforeMount(): void;
     mount(): void;
     beforeUnmount(): void;

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

@@ -11,8 +11,12 @@ class LayoutFeature extends Feature {
     this.state.willUpdate("beforeUpdate");
   }
   update() {
-    var _a;
-    (_a = this.state.visualElement.projection) == null ? void 0 : _a.root.didUpdate();
+    this.didUpdate();
+  }
+  didUpdate() {
+    var _a, _b;
+    if (this.state.options.layout || this.state.options.layoutId)
+      (_b = (_a = this.state.visualElement.projection) == null ? void 0 : _a.root) == null ? void 0 : _b.didUpdate();
   }
   beforeMount() {
   }
@@ -26,7 +30,7 @@ class LayoutFeature extends Feature {
         (_a = layoutGroup == null ? void 0 : layoutGroup.group) == null ? void 0 : _a.add(projection);
       }
       globalProjectionState.hasEverUpdated = true;
-      projection == null ? void 0 : projection.root.didUpdate();
+      this.didUpdate();
     }
   }
   beforeUnmount() {
@@ -42,14 +46,11 @@ class LayoutFeature extends Feature {
     }
   }
   unmount() {
-    var _a, _b;
     const layoutGroup = this.state.options.layoutGroup;
     const projection = this.state.visualElement.projection;
     if ((layoutGroup == null ? void 0 : layoutGroup.group) && projection)
       layoutGroup.group.remove(projection);
-    if (this.state.options.layoutId || this.state.options.layout) {
-      (_b = (_a = this.state.visualElement.projection) == null ? void 0 : _a.root) == null ? void 0 : _b.didUpdate();
-    }
+    this.didUpdate();
   }
 }
 export {

package/dist/es/features/layout/projection.mjs

@@ -4,6 +4,7 @@ import { getClosestProjectingNode } from "./utils.mjs";
 import { addScaleCorrector } from "../../external/.pnpm/framer-motion@11.16.6/external/framer-motion/dist/es/projection/styles/scale-correction.mjs";
 import { defaultScaleCorrector } from "./config.mjs";
 import { isHTMLElement } from "../gestures/drag/utils/is.mjs";
+import { doneCallbacks } from "../../components/presence.mjs";
 class ProjectionFeature extends Feature {
   constructor(state) {
     super(state);
@@ -32,7 +33,21 @@ class ProjectionFeature extends Feature {
       // initialPromotionConfig
       layoutRoot: options.layoutRoot,
       layoutScroll: options.layoutScroll,
-      crossfade: options.crossfade
+      crossfade: options.crossfade,
+      onExitComplete: () => {
+        var _a;
+        if (!((_a = this.state.visualElement.projection) == null ? void 0 : _a.isPresent)) {
+          const done = doneCallbacks.get(this.state.element);
+          this.state.isSafeToRemove = true;
+          if (done) {
+            done({
+              detail: {
+                isExit: true
+              }
+            }, true);
+          }
+        }
+      }
     });
   }
   update() {

package/dist/es/features/layout/types.d.ts

@@ -1,4 +1,17 @@
-export interface LayoutOptions {
+import { Box } from 'framer-motion';
+export interface LayoutLifecycles {
+    onBeforeLayoutMeasure?: (box: Box) => void;
+    onLayoutMeasure?: (box: Box, prevBox: Box) => void;
+    /**
+     * @internal
+     */
+    onLayoutAnimationStart?: () => void;
+    /**
+     * @internal
+     */
+    onLayoutAnimationComplete?: () => void;
+}
+export interface LayoutOptions extends LayoutLifecycles {
     'layout'?: boolean | 'position' | 'size' | 'preserve-aspect';
     'layoutId'?: string;
     'layoutScroll'?: boolean;

package/dist/es/index.mjs

@@ -41,6 +41,7 @@ import { cancelSync, sync } from "./external/.pnpm/framer-motion@11.16.6/externa
 import { cancelFrame, frame, frameData, frameSteps } from "./external/.pnpm/framer-motion@11.16.6/external/framer-motion/dist/es/frameloop/frame.mjs";
 import { motion } from "./components/motion/NameSpace.mjs";
 import { provideMotionConfig, useMotionConfig } from "./components/motion-config/context.mjs";
+import { Reorder, ReorderGroup, ReorderItem } from "./components/reorder/index.mjs";
 import { useComputed } from "./value/use-computed.mjs";
 import { useCombineMotionValues } from "./value/use-combine-values.mjs";
 import { useTransform } from "./value/use-transform.mjs";
@@ -64,6 +65,9 @@ export {
   default3 as Motion,
   default5 as MotionConfig,
   MotionValue,
+  Reorder,
+  ReorderGroup,
+  ReorderItem,
   animate,
   animateMini,
   anticipate,