motion-v 0.13.1 → 1.0.0-alpha.1

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

@@ -1,241 +0,0 @@
-import { defineComponent, mergeDefaults, warn, useAttrs, getCurrentInstance, onBeforeMount, onMounted, onBeforeUnmount, onUnmounted, onBeforeUpdate, onUpdated, ref, openBlock, createBlock, unref, withCtx, renderSlot } from "vue";
-import { injectMotion, injectLayoutGroup, provideMotion } from "../context.mjs";
-import { convertSvgStyleToAttributes, createStyles } from "../../state/style.mjs";
-import { Primitive } from "./Primitive.mjs";
-import { MotionState } from "../../state/motion-state.mjs";
-import { injectAnimatePresence } from "../presence.mjs";
-import { checkMotionIsHidden } from "./utils.mjs";
-import { useMotionConfig } from "../motion-config/context.mjs";
-import { getMotionElement } from "../hooks/use-motion-elm.mjs";
-import { isMotionValue } from "../../utils/motion-value.mjs";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Motion",
-    inheritAttrs: false
-  },
-  __name: "Motion",
-  props: /* @__PURE__ */ mergeDefaults({
-    as: {},
-    asChild: { type: Boolean },
-    hover: {},
-    press: {},
-    inView: {},
-    focus: {},
-    whileDrag: {},
-    whileHover: {},
-    whilePress: {},
-    whileInView: {},
-    whileFocus: {},
-    forwardMotionProps: { type: Boolean },
-    custom: {},
-    initial: { type: [String, Array, Object, Boolean] },
-    animate: {},
-    exit: {},
-    variants: {},
-    inherit: { type: Boolean },
-    style: {},
-    transformTemplate: { type: Function },
-    transition: {},
-    layoutGroup: {},
-    motionConfig: {},
-    onAnimationComplete: { type: Function },
-    onUpdate: { type: Function },
-    layout: { type: [Boolean, String] },
-    layoutId: {},
-    layoutScroll: { type: Boolean },
-    layoutRoot: { type: Boolean },
-    "data-framer-portal-id": {},
-    crossfade: { type: Boolean },
-    layoutDependency: {},
-    onBeforeLayoutMeasure: { type: Function },
-    onLayoutMeasure: { type: Function },
-    onLayoutAnimationStart: { type: Function },
-    onLayoutAnimationComplete: { type: Function },
-    globalPressTarget: { type: Boolean },
-    onPressStart: { type: Function },
-    onPress: { type: Function },
-    onPressCancel: { type: Function },
-    onHoverStart: { type: Function },
-    onHoverEnd: { type: Function },
-    inViewOptions: {},
-    onViewportEnter: { type: Function },
-    onViewportLeave: { type: Function },
-    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: { type: Function },
-    onDragEnd: { type: Function },
-    onDrag: { type: Function },
-    onDirectionLock: { type: Function },
-    onDragTransitionEnd: { type: Function },
-    onMeasureDragConstraints: { type: Function },
-    onPanSessionStart: { type: Function },
-    onPanStart: { type: Function },
-    onPan: { type: Function },
-    onPanEnd: { type: Function },
-    onFocus: { type: Function },
-    onBlur: { type: Function }
-  }, {
-    as: "div",
-    asChild: false,
-    initial: void 0,
-    animate: void 0,
-    hover: void 0,
-    inView: void 0,
-    layout: false,
-    layoutId: void 0,
-    layoutScroll: false,
-    layoutRoot: false,
-    dragListener: true,
-    dragElastic: 0.5,
-    dragMomentum: true,
-    whileDrag: void 0,
-    crossfade: true,
-    whileHover: ({ hover }) => {
-      if (process.env.NODE_ENV === "development" && hover) {
-        warn("hover is deprecated. Use whileHover instead.");
-      }
-      return hover;
-    },
-    whilePress: ({ press }) => {
-      if (process.env.NODE_ENV === "development" && press) {
-        warn("press is deprecated. Use whilePress instead.");
-      }
-      return press;
-    },
-    whileInView: ({ inView }) => {
-      if (process.env.NODE_ENV === "development" && inView) {
-        warn("inView is deprecated. Use whileInView instead.");
-      }
-      return inView;
-    },
-    whileFocus: ({ focus }) => {
-      if (process.env.NODE_ENV === "development" && focus) {
-        warn("focus is deprecated. Use whileFocus instead.");
-      }
-      return focus;
-    }
-  }),
-  setup(__props) {
-    const props = __props;
-    const animatePresenceContext = injectAnimatePresence({});
-    const parentState = injectMotion(null);
-    const attrs = useAttrs();
-    const layoutGroup = injectLayoutGroup({});
-    const config = useMotionConfig();
-    function getLayoutId() {
-      if (layoutGroup.id && props.layoutId)
-        return `${layoutGroup.id}-${props.layoutId}`;
-      return props.layoutId || void 0;
-    }
-    function getProps() {
-      return {
-        ...props,
-        layoutId: getLayoutId(),
-        transition: props.transition ?? config.value.transition,
-        layoutGroup,
-        motionConfig: config.value,
-        inViewOptions: props.inViewOptions ?? config.value.inViewOptions,
-        animatePresenceContext,
-        initial: animatePresenceContext.initial === false ? animatePresenceContext.initial : props.initial === true ? void 0 : props.initial
-      };
-    }
-    function getMotionProps() {
-      return {
-        ...attrs,
-        ...getProps()
-      };
-    }
-    const state = new MotionState(
-      getMotionProps(),
-      parentState
-    );
-    provideMotion(state);
-    const instance = getCurrentInstance().proxy;
-    onBeforeMount(() => {
-      state.beforeMount();
-    });
-    onMounted(() => {
-      state.mount(getMotionElement(instance.$el), getMotionProps(), checkMotionIsHidden(instance));
-    });
-    onBeforeUnmount(() => state.beforeUnmount());
-    onUnmounted(() => {
-      const el = getMotionElement(instance.$el);
-      if (!(el == null ? void 0 : el.isConnected)) {
-        state.unmount();
-      }
-    });
-    onBeforeUpdate(() => {
-      state.beforeUpdate();
-    });
-    onUpdated(() => {
-      state.update(getMotionProps());
-    });
-    function getAttrs() {
-      const isSVG = state.visualElement.type === "svg";
-      const attrsProps = { ...attrs };
-      Object.keys(attrs).forEach((key) => {
-        if (isMotionValue(attrs[key]))
-          attrsProps[key] = attrs[key].get();
-      });
-      let styleProps = {
-        ...props.style,
-        ...isSVG ? {} : state.visualElement.latestValues
-      };
-      if (isSVG) {
-        const { attributes, style } = convertSvgStyleToAttributes({
-          ...state.isMounted() ? state.target : state.baseTarget,
-          ...styleProps
-        });
-        Object.assign(attrsProps, attributes);
-        styleProps = style;
-      }
-      if (props.drag && props.dragListener !== false) {
-        Object.assign(styleProps, {
-          userSelect: "none",
-          WebkitUserSelect: "none",
-          WebkitTouchCallout: "none",
-          touchAction: props.drag === true ? "none" : `pan-${props.drag === "x" ? "y" : "x"}`
-        });
-      }
-      attrsProps.style = createStyles(styleProps);
-      return attrsProps;
-    }
-    const PrimitiveRef = ref();
-    function onMotionComplete(e) {
-      var _a, _b;
-      if (props.asChild) {
-        (_a = PrimitiveRef.value) == null ? void 0 : _a.$forceUpdate();
-      }
-      (_b = attrs.onMotioncomplete) == null ? void 0 : _b.call(attrs, e);
-    }
-    return (_ctx, _cache) => {
-      var _a;
-      return openBlock(), createBlock(unref(Primitive), {
-        ref_key: "PrimitiveRef",
-        ref: PrimitiveRef,
-        "get-props": getProps,
-        "get-attrs": getAttrs,
-        as: _ctx.as,
-        "as-child": _ctx.asChild,
-        "data-motion-group": ((_a = unref(layoutGroup).key) == null ? void 0 : _a.value) || void 0,
-        onMotioncomplete: onMotionComplete
-      }, {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 8, ["as", "as-child", "data-motion-group"]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

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

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

package/dist/es/components/motion/NameSpace.d.ts

@@ -1,15 +0,0 @@
-import { DefineComponent, IntrinsicElementAttributes } from 'vue';
-import { MotionProps } from './Motion';
-import { ComponentProps, MotionHTMLAttributes } from '../../types';
-type MotionComponentProps = {
-    create: <T extends DefineComponent>(T: any, options?: {
-        forwardMotionProps?: boolean;
-    }) => DefineComponent<MotionProps<any, unknown> & ComponentProps<T>>;
-};
-type MotionNameSpace = {
-    [K in keyof IntrinsicElementAttributes]: DefineComponent<MotionProps<K, unknown> & MotionHTMLAttributes<K>>;
-} & {
-    create: MotionComponentProps['create'];
-};
-export declare const motion: MotionNameSpace;
-export {};

package/dist/es/components/motion/NameSpace.mjs

@@ -1,48 +0,0 @@
-import { defineComponent, h } from "vue";
-import _sfc_main from "./Motion.vue.mjs";
-const componentCache = /* @__PURE__ */ new Map();
-const motion = new Proxy(_sfc_main, {
-  get(target, prop) {
-    if (typeof prop === "symbol")
-      return target[prop];
-    let motionComponent = componentCache.get(prop);
-    if (prop === "create") {
-      return (component, { forwardMotionProps = false } = {}) => {
-        return defineComponent({
-          inheritAttrs: false,
-          name: `motion.${component.$name}`,
-          setup(_, { attrs, slots }) {
-            return () => {
-              return h(_sfc_main, {
-                ...attrs,
-                forwardMotionProps,
-                as: component,
-                asChild: false
-              }, slots);
-            };
-          }
-        });
-      };
-    }
-    if (!motionComponent) {
-      motionComponent = defineComponent({
-        inheritAttrs: false,
-        name: `motion.${prop}`,
-        setup(_, { attrs, slots }) {
-          return () => {
-            return h(_sfc_main, {
-              ...attrs,
-              as: prop,
-              asChild: false
-            }, slots);
-          };
-        }
-      });
-      componentCache.set(prop, motionComponent);
-    }
-    return motionComponent;
-  }
-});
-export {
-  motion
-};

package/dist/es/components/motion/Primitive.d.ts

@@ -1,57 +0,0 @@
-import { Component, PropType } from 'vue';
-import { AsTag } from '../../types';
-export interface PrimitiveProps {
-    /**
-     * Change the default rendered element for the one passed as a child, merging their props and behavior.
-     *
-     * Read our [Composition](https://www.radix-vue.com/guides/composition.html) guide for more details.
-     */
-    asChild?: boolean;
-    /**
-     * The element or component this component should render as. Can be overwrite by `asChild`
-     * @defaultValue "div"
-     */
-    as?: AsTag | Component;
-}
-export declare const Primitive: import('vue').DefineComponent<{
-    asChild: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    as: {
-        type: PropType<AsTag>;
-        default: string;
-    };
-    getProps: {
-        type: FunctionConstructor;
-        default: () => {};
-    };
-    getAttrs: {
-        type: FunctionConstructor;
-        default: () => {};
-    };
-}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    asChild: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    as: {
-        type: PropType<AsTag>;
-        default: string;
-    };
-    getProps: {
-        type: FunctionConstructor;
-        default: () => {};
-    };
-    getAttrs: {
-        type: FunctionConstructor;
-        default: () => {};
-    };
-}>>, {
-    as: AsTag;
-    asChild: boolean;
-    getProps: Function;
-    getAttrs: Function;
-}, {}>;

package/dist/es/components/motion/Primitive.mjs

@@ -1,45 +0,0 @@
-import { defineComponent, h } from "vue";
-import { Slot } from "./Slot.mjs";
-const Primitive = defineComponent({
-  name: "Primitive",
-  inheritAttrs: false,
-  props: {
-    asChild: {
-      type: Boolean,
-      default: false
-    },
-    as: {
-      type: [String, Object],
-      default: "div"
-    },
-    getProps: {
-      type: Function,
-      default: () => ({})
-    },
-    getAttrs: {
-      type: Function,
-      default: () => ({})
-    }
-  },
-  setup(props, { attrs, slots }) {
-    const asTag = props.asChild ? "template" : props.as;
-    const SELF_CLOSING_TAGS = ["area", "img", "input"];
-    return () => {
-      const motionProps = props.getProps();
-      const motionAttrs = props.getAttrs();
-      let allAttrs = { ...motionAttrs, ...attrs };
-      if (typeof asTag === "string" && SELF_CLOSING_TAGS.includes(asTag))
-        return h(asTag, allAttrs);
-      if (asTag !== "template") {
-        if (motionProps.forwardMotionProps) {
-          allAttrs = { ...motionProps, ...allAttrs };
-        }
-        return h(props.as, allAttrs, { default: slots.default });
-      }
-      return h(Slot, allAttrs, { default: slots.default });
-    };
-  }
-});
-export {
-  Primitive
-};

package/dist/es/components/motion/Slot.d.ts

@@ -1,5 +0,0 @@
-export declare const Slot: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;

package/dist/es/components/motion/Slot.mjs

@@ -1,36 +0,0 @@
-import { defineComponent, Comment, mergeProps, cloneVNode } from "vue";
-import { renderSlotFragments } from "./renderSlotFragments.mjs";
-const Slot = defineComponent({
-  name: "PrimitiveSlot",
-  inheritAttrs: false,
-  setup(_, { attrs, slots }) {
-    return () => {
-      var _a, _b;
-      if (!slots.default)
-        return null;
-      const childrens = renderSlotFragments(slots.default());
-      const firstNonCommentChildrenIndex = childrens.findIndex((child) => child.type !== Comment);
-      if (firstNonCommentChildrenIndex === -1)
-        return childrens;
-      const firstNonCommentChildren = childrens[firstNonCommentChildrenIndex];
-      (_a = firstNonCommentChildren.props) == null ? true : delete _a.ref;
-      const mergedProps = firstNonCommentChildren.props ? mergeProps(attrs, firstNonCommentChildren.props) : attrs;
-      if (attrs.class && ((_b = firstNonCommentChildren.props) == null ? void 0 : _b.class))
-        delete firstNonCommentChildren.props.class;
-      const cloned = cloneVNode(firstNonCommentChildren, mergedProps);
-      for (const prop in mergedProps) {
-        if (prop.startsWith("on")) {
-          cloned.props || (cloned.props = {});
-          cloned.props[prop] = mergedProps[prop];
-        }
-      }
-      if (childrens.length === 1)
-        return cloned;
-      childrens[firstNonCommentChildrenIndex] = cloned;
-      return childrens;
-    };
-  }
-});
-export {
-  Slot
-};

package/dist/es/components/motion/renderSlotFragments.mjs

@@ -1,13 +0,0 @@
-import { Fragment } from "vue";
-function renderSlotFragments(children) {
-  if (!children)
-    return [];
-  return children.flatMap((child) => {
-    if (child.type === Fragment)
-      return renderSlotFragments(child.children);
-    return [child];
-  });
-}
-export {
-  renderSlotFragments
-};

package/dist/es/features/gestures/base.d.ts

@@ -1,8 +0,0 @@
-import { Feature } from '../feature';
-export declare abstract class BaseGesture extends Feature {
-    abstract isActive(): boolean;
-    removeGestureSubscriptions?: VoidFunction;
-    subscribeEvents?: () => VoidFunction;
-    protected updateGestureSubscriptions(): void;
-    unmount(): void;
-}

package/dist/es/state/animate-updates.d.ts

@@ -1,20 +0,0 @@
-import { $Transition, Options } from '../types';
-import { MotionState } from './motion-state';
-declare const STATE_TYPES: readonly ["initial", "animate", "whileInView", "whileHover", "whilePress", "whileDrag", "whileFocus", "exit"];
-export type StateType = typeof STATE_TYPES[number];
-/**
- * 核心动画更新函数,处理所有动画状态变化和执行
- * @param controlActiveState - 需要更新的动画状态
- * @param controlDelay - 动画延迟时间
- * @param directAnimate - 直接动画目标值
- * @param directTransition - 直接动画过渡配置
- */
-export declare function animateUpdates(this: MotionState, { controlActiveState, controlDelay, directAnimate, directTransition, isFallback, isExit, }?: {
-    controlActiveState?: Partial<Record<string, boolean>>;
-    controlDelay?: number;
-    directAnimate?: Options['animate'];
-    directTransition?: $Transition;
-    isFallback?: boolean;
-    isExit?: boolean;
-}): any;
-export {};

package/dist/es/state/animate-updates.mjs

@@ -1,147 +0,0 @@
-import { resolveVariant, hasChanged } from "./utils.mjs";
-import { style } from "./style.mjs";
-import { transformResetValue } from "./transform.mjs";
-import { motionEvent } from "./event.mjs";
-import { isDef } from "@vueuse/core";
-import { isAnimationControls } from "../animation/utils.mjs";
-import { animate } from "../external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/animation/animate/index.mjs";
-import { noop } from "../external/.pnpm/motion-utils@12.5.0/external/motion-utils/dist/es/noop.mjs";
-import "../external/.pnpm/motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
-const STATE_TYPES = ["initial", "animate", "whileInView", "whileHover", "whilePress", "whileDrag", "whileFocus", "exit"];
-function animateUpdates({
-  controlActiveState = void 0,
-  controlDelay = 0,
-  directAnimate,
-  directTransition,
-  isFallback = false,
-  isExit = false
-} = {}) {
-  const prevTarget = this.target;
-  this.target = { ...this.baseTarget };
-  let animationOptions = {};
-  const transition = { ...this.options.transition };
-  if (directAnimate)
-    animationOptions = resolveDirectAnimation.call(this, directAnimate, directTransition, animationOptions);
-  else
-    animationOptions = resolveStateAnimation.call(this, controlActiveState);
-  const factories = createAnimationFactories.call(this, prevTarget, animationOptions, controlDelay);
-  const { getChildAnimations, childAnimations } = setupChildAnimations.call(this, animationOptions, this.activeStates, isFallback);
-  return executeAnimations.call(this, {
-    factories,
-    getChildAnimations,
-    childAnimations,
-    transition,
-    controlActiveState,
-    isExit
-  });
-}
-function resolveDirectAnimation(directAnimate, directTransition) {
-  var _a;
-  const variant = resolveVariant(directAnimate, this.options.variants, this.options.custom || ((_a = this.options.animatePresenceContext) == null ? void 0 : _a.custom));
-  if (!variant)
-    return {};
-  const transition = variant.transition || directTransition || this.options.transition || {};
-  Object.entries(variant).forEach(([key, value]) => {
-    if (key === "transition")
-      return;
-    this.target[key] = value;
-  });
-  return transition;
-}
-function resolveStateAnimation(controlActiveState) {
-  if (controlActiveState)
-    this.activeStates = { ...this.activeStates, ...controlActiveState };
-  let variantTransition = this.options.transition;
-  let variant = {};
-  STATE_TYPES.forEach((name) => {
-    if (!this.activeStates[name] || isAnimationControls(this.options[name]))
-      return;
-    const definition = this.options[name];
-    let resolvedVariant = isDef(definition) ? resolveVariant(definition, this.options.variants, this.options.custom) : void 0;
-    if (this.visualElement.isVariantNode) {
-      const controlVariant = resolveVariant(this.context[name], this.options.variants, this.options.custom);
-      resolvedVariant = controlVariant ? Object.assign(controlVariant || {}, resolvedVariant) : variant;
-    }
-    if (!resolvedVariant)
-      return;
-    if (name !== "initial")
-      variantTransition = resolvedVariant.transition || this.options.transition || {};
-    variant = Object.assign(variant, resolvedVariant);
-  });
-  Object.entries(variant).forEach(([key, value]) => {
-    if (key === "transition")
-      return;
-    this.target[key] = value;
-  });
-  return variantTransition;
-}
-function createAnimationFactories(prevTarget, animationOptions, controlDelay) {
-  const factories = [];
-  Object.keys(this.target).forEach((key) => {
-    var _a;
-    if (!hasChanged(prevTarget[key], this.target[key]))
-      return;
-    (_a = this.baseTarget)[key] ?? (_a[key] = style.get(this.element, key));
-    const keyValue = this.target[key] === "none" && isDef(transformResetValue[key]) ? transformResetValue[key] : this.target[key];
-    factories.push(() => {
-      var _a2;
-      return animate(
-        this.element,
-        { [key]: keyValue },
-        {
-          ...(animationOptions == null ? void 0 : animationOptions[key]) || animationOptions,
-          delay: (((_a2 = animationOptions == null ? void 0 : animationOptions[key]) == null ? void 0 : _a2.delay) || (animationOptions == null ? void 0 : animationOptions.delay) || 0) + controlDelay
-        }
-      );
-    });
-  });
-  return factories;
-}
-function setupChildAnimations(transition, controlActiveState, isFallback) {
-  var _a;
-  if (!((_a = this.visualElement.variantChildren) == null ? void 0 : _a.size) || !controlActiveState)
-    return { getChildAnimations: () => Promise.resolve(), childAnimations: [] };
-  const { staggerChildren = 0, staggerDirection = 1, delayChildren = 0 } = transition || {};
-  const maxStaggerDuration = (this.visualElement.variantChildren.size - 1) * staggerChildren;
-  const generateStaggerDuration = staggerDirection === 1 ? (i = 0) => i * staggerChildren : (i = 0) => maxStaggerDuration - i * staggerChildren;
-  const childAnimations = Array.from(this.visualElement.variantChildren).map((child, index) => {
-    const childDelay = delayChildren + generateStaggerDuration(index);
-    return child.state.animateUpdates({
-      controlActiveState,
-      controlDelay: isFallback ? 0 : childDelay
-    });
-  }).filter(Boolean);
-  return {
-    getChildAnimations: () => Promise.all(childAnimations.map((animation) => {
-      return animation == null ? void 0 : animation();
-    })),
-    childAnimations
-  };
-}
-function executeAnimations({
-  factories,
-  getChildAnimations,
-  childAnimations,
-  transition,
-  controlActiveState,
-  isExit = false
-}) {
-  const getAnimation = () => Promise.all(factories.map((factory) => factory()).filter(Boolean));
-  const animationTarget = { ...this.target };
-  const element = this.element;
-  const finishAnimation = (animationPromise) => {
-    element.dispatchEvent(motionEvent("motionstart", animationTarget));
-    animationPromise.then(() => {
-      element.dispatchEvent(motionEvent("motioncomplete", animationTarget, isExit));
-    }).catch(noop);
-  };
-  const getAnimationPromise = () => {
-    const animationPromise = (transition == null ? void 0 : transition.when) ? (transition.when === "beforeChildren" ? getAnimation() : getChildAnimations()).then(() => transition.when === "beforeChildren" ? getChildAnimations() : getAnimation()) : Promise.all([getAnimation(), getChildAnimations()]);
-    finishAnimation(animationPromise);
-    return animationPromise;
-  };
-  return controlActiveState ? getAnimationPromise : getAnimationPromise();
-}
-export {
-  animateUpdates
-};

package/dist/es/utils/noop.d.ts

@@ -1 +0,0 @@
-export declare const noop: <T>(any: T) => T;