react-ui-animate 2.0.0 → 3.0.0-rc.1

package/dist/animation/core/react/makeFluid.d.ts

@@ -0,0 +1,30 @@
+import type { WrappedComponentOrTag } from '../types/fluid';
+/**
+ * Higher-order component to make any component animatable.
+ *
+ * This function takes a React component or an HTML tag and returns a new component
+ * that can smoothly transition between states using fluid animations. It enhances
+ * the user experience by adding dynamic and engaging animations to the wrapped component.
+ *
+ * @param WrapperComponent - The React component or HTML tag to be wrapped with animation functionality.
+ * @returns - A new component with added animation capabilities.
+ *
+ * The returned component uses fluid animations to smoothly transition between different
+ * states. It supports both style and prop animations, handling transforms and other
+ * properties seamlessly. The component ensures that animations are efficiently applied
+ * and updated based on the current state and configuration of fluid values.
+ *
+ * @example
+ * const AnimatedDiv = makeFluid('div');
+ *
+ * const MyComponent = () => {
+ *  const opacity = useAnimatedValue(1)
+ *  return (
+ *   <AnimatedDiv style={{ opacity: opacity.value }}>
+ *     Hello, world!
+ *   </AnimatedDiv>
+ * )};
+ */
+export declare function makeFluid<C extends WrappedComponentOrTag>(WrapperComponent: C): import("react").ForwardRefExoticComponent<Omit<import("../types/fluid").FluidHTMLAttributes<C> & import("../types/fluid").FluidSVGAttributes<C>, "style"> & {
+    style?: import("../types/fluid").FluidCSSProperties;
+} & import("react").RefAttributes<unknown>>;

package/dist/animation/core/react/transforms.d.ts

@@ -0,0 +1,6 @@
+export declare const styleTrasformKeys: readonly ["translate", "translateX", "translateY", "translateZ", "scale", "scaleX", "scaleY", "scaleZ", "rotate", "rotateX", "rotateY", "rotateZ", "skew", "skewX", "skewY"];
+/**
+ * getTransform function returns transform string from style object
+ */
+export declare function getTransform(style: Record<string, any>): string;
+export declare function isTransformKey(key: string): boolean;

package/dist/animation/core/react/useFluidValue.d.ts

@@ -0,0 +1,9 @@
+import { FluidValue } from '../controllers/FluidValue';
+import type { FluidValueConfig, Length, AssignValue, OnUpdateCallback } from '../types/animation';
+/**
+ * useFluidValue
+ *
+ * @param value - initial value
+ * @param config - the config object for `FluidValue`
+ */
+export declare const useFluidValue: (value: Length, config?: FluidValueConfig) => [FluidValue, (updateValue: AssignValue, config?: FluidValueConfig, callback?: OnUpdateCallback) => void];

package/dist/animation/core/react/useMount.d.ts

@@ -0,0 +1,20 @@
+import { FluidValue } from '../controllers/FluidValue';
+import type { AssignValue, FluidValueConfig } from '../types/animation';
+export interface UseMountConfig {
+    from: number;
+    enter: number | AssignValue;
+    exit: number | AssignValue;
+    enterConfig?: FluidValueConfig;
+    exitConfig?: FluidValueConfig;
+    config?: FluidValueConfig;
+}
+/**
+ * `useMount`
+ *
+ * applies mounting and unmounting of a component according to state change
+ * applying transitions
+ *
+ * @param state - boolean indicating mount state of a component
+ * @param config - the config object `UseMountConfig`
+ */
+export declare const useMount: (state: boolean, config: UseMountConfig) => (callback: (animation: FluidValue, mounted: boolean) => React.ReactNode) => import("react").ReactNode;

package/dist/animation/lib/animationType.d.ts

@@ -0,0 +1,15 @@
+export declare const AnimationConfigUtils: {
+    ELASTIC: import("../core").FluidValueConfig;
+    BOUNCE: import("../core").FluidValueConfig;
+    EASE: import("../core").FluidValueConfig;
+    STIFF: import("../core").FluidValueConfig;
+    WOOBLE: import("../core").FluidValueConfig;
+    EASE_IN: import("../core").FluidValueConfig;
+    EASE_OUT: import("../core").FluidValueConfig;
+    EASE_IN_OUT: import("../core").FluidValueConfig;
+    POWER1: import("../core").FluidValueConfig;
+    POWER2: import("../core").FluidValueConfig;
+    POWER3: import("../core").FluidValueConfig;
+    POWER4: import("../core").FluidValueConfig;
+    LINEAR: import("../core").FluidValueConfig;
+};

package/dist/animation/lib/getInitialConfig.d.ts

@@ -0,0 +1,3 @@
+import { FluidValueConfig } from '../core';
+export type InitialConfigType = 'linear' | 'easein' | 'easeout' | 'easeinout' | 'ease' | 'power1' | 'power2' | 'power3' | 'power4' | 'elastic' | 'stiff' | 'wooble' | 'bounce';
+export declare const getInitialConfig: (animationType?: InitialConfigType) => FluidValueConfig;

package/dist/animation/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { interpolate, bInterpolate } from './interpolation';
+export { AnimatedBlock, AnimatedImage, AnimatedInline, MountedBlock, ScrollableBlock, TransitionBlock, } from './modules';
+export { useAnimatedValue, UseAnimatedValueConfig } from './useAnimatedValue';
+export { useMountedValue } from './useMountedValue';
+export { AnimationConfigUtils } from './animationType';

package/dist/animation/{interpolation.d.ts → lib/interpolation.d.ts}

@@ -1,21 +1,20 @@
-import { ExtrapolateConfig, FluidValue } from '@raidipesh78/re-motion';
-import { ValueType } from './useAnimatedValue';
-/**
- * interpolate functions maps input range to given output range
- * @param value - number | TransitionValue
- * @param inputRange - Array<number>
- * @param outputRange - Array<number | string>
- * @param extrapolateConfig - "clamp" | "identity" | "extend"
- * @returns - number | TransitionValue
- */
-export declare function interpolate(value: number | FluidValue | ValueType, inputRange: Array<number>, outputRange: Array<number | string>, extrapolateConfig?: ExtrapolateConfig): any;
-/**
- * bInterpolate functions maps input range [0, 1] to given [minOutput, maxOutput]
- * sorthand function to interpolate input range [0, 1]
- * @param value - number | TransitionValue
- * @param minOutput - number | string
- * @param maxOutput - number | string
- * @param extrapolateConfig - "clamp" | "identity" | "extend"
- * @returns - number | TransitionValue
- */
-export declare function bInterpolate(value: number | FluidValue | ValueType, minOutput: number | string, maxOutput: number | string, extrapolateConfig?: ExtrapolateConfig): any;
+import { ExtrapolateConfig, FluidValue } from '../core';
+/**
+ * interpolate functions maps input range to given output range
+ * @param value - number | TransitionValue
+ * @param inputRange - Array<number>
+ * @param outputRange - Array<number | string>
+ * @param extrapolateConfig - "clamp" | "identity" | "extend"
+ * @returns - number | TransitionValue
+ */
+export declare function interpolate(value: number | FluidValue, inputRange: Array<number>, outputRange: Array<number | string>, extrapolateConfig?: ExtrapolateConfig): any;
+/**
+ * bInterpolate functions maps input range [0, 1] to given [minOutput, maxOutput]
+ * sorthand function to interpolate input range [0, 1]
+ * @param value - number | TransitionValue
+ * @param minOutput - number | string
+ * @param maxOutput - number | string
+ * @param extrapolateConfig - "clamp" | "identity" | "extend"
+ * @returns - number | TransitionValue
+ */
+export declare function bInterpolate(value: number | FluidValue, minOutput: number | string, maxOutput: number | string, extrapolateConfig?: ExtrapolateConfig): any;

package/dist/animation/lib/modules/AnimatedBlock.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AnimatedBlock - A higher order component built upon `div` element
+ * which can accept `AnimatedValue`. It also exposes some extra style properties like
+ * translateX, translateY, rotateX, rotateY, scaleX, etc.
+ */
+export declare const AnimatedBlock: import("react").ForwardRefExoticComponent<Omit<import("../../core/types/fluid").FluidHTMLAttributes<"div"> & import("../../core/types/fluid").FluidSVGAttributes<"div">, "style"> & {
+    style?: import("../../core/types/fluid").FluidCSSProperties;
+} & import("react").RefAttributes<unknown>>;

package/dist/animation/lib/modules/AnimatedImage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AnimatedImage - A higher order component built upon `img` element
+ * which can accept `AnimatedValue`. It also exposes some extra style properties like
+ * translateX, translateY, rotateX, rotateY, scaleX, etc.
+ */
+export declare const AnimatedImage: import("react").ForwardRefExoticComponent<Omit<import("../../core/types/fluid").FluidHTMLAttributes<"img"> & import("../../core/types/fluid").FluidSVGAttributes<"img">, "style"> & {
+    style?: import("../../core/types/fluid").FluidCSSProperties;
+} & import("react").RefAttributes<unknown>>;

package/dist/animation/lib/modules/AnimatedInline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AnimatedInline - A higher order component built upon `span` element
+ * which can accept `AnimatedValue`. It also exposes some extra style properties like
+ * translateX, translateY, rotateX, rotateY, scaleX, etc.
+ */
+export declare const AnimatedInline: import("react").ForwardRefExoticComponent<Omit<import("../../core/types/fluid").FluidHTMLAttributes<"span"> & import("../../core/types/fluid").FluidSVGAttributes<"span">, "style"> & {
+    style?: import("../../core/types/fluid").FluidCSSProperties;
+} & import("react").RefAttributes<unknown>>;

package/dist/animation/lib/modules/MountedBlock.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { FluidValue, FluidValueConfig } from '../../core';
+interface MountedValueConfig extends FluidValueConfig {
+}
+interface MountedBlockProps {
+    state: boolean;
+    children: (animation: {
+        value: FluidValue;
+    }) => React.ReactNode;
+    from?: number;
+    enter?: number;
+    exit?: number;
+    config?: MountedValueConfig;
+    enterConfig?: MountedValueConfig;
+    exitConfig?: MountedValueConfig;
+}
+/**
+ * MountedBlock - Higher order component which handles mounting and unmounting of a component.
+ * @prop { boolean } state - Boolean indicating the component should mount or unmount.
+ * @prop { function } children - Child as a function with `AnimatedValue` on `.value` property.
+ * @prop { number } from - Number that dictates the beginning state for animation.
+ * @prop { number } enter - Number that dictates the entry state for animation.
+ * @prop { number } exit - Number that dictates the exit state for animation.
+ * @prop { MountedValueConfig } config - Animation configuration for overall animation.
+ * @prop { MountedValueConfig } enterConfig - Animation configuration for the entering state of animation.
+ * @prop { MountedValueConfig } exitConfig - Animation configuration for the entering state of animation.
+ */
+export declare const MountedBlock: ({ state, children, from, enter, exit, config, enterConfig, exitConfig, }: MountedBlockProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/animation/{modules → lib/modules}/ScrollableBlock.d.ts

@@ -1,21 +1,22 @@
-import * as React from 'react';
-import { UseAnimatedValueConfig, ValueType } from '../useAnimatedValue';
-interface ScrollableBlockProps {
-    children?: (animation: {
-        value: ValueType;
-    }) => React.ReactNode;
-    direction?: 'single' | 'both';
-    threshold?: number;
-    animationConfig?: UseAnimatedValueConfig;
-}
-/**
- * ScrollableBlock - Higher order component to handle the entrance or exit animation
- * of a component when it enters or exit the viewport. Accepts child as a function with
- * `AnimatedValue` as its first argument which can be interpolated on input range [0, 1]
- * @prop { function } children - child as a function with `AnimatedValue` as its first argument.
- * @prop { 'single' | 'both' } direction - single applies animation on enter once, both applies on enter and exit.
- * @prop { number } threshold - should be in range 0 to 1 which equivalent to `IntersectionObserver` threshold.
- * @prop { UseAnimatedValueConfig } animationConfig - Animation config
- */
-export declare const ScrollableBlock: (props: ScrollableBlockProps) => JSX.Element;
-export {};
+import * as React from 'react';
+import { UseAnimatedValueConfig } from '../useAnimatedValue';
+import { FluidValue } from '../../core';
+interface ScrollableBlockProps {
+    children?: (animation: {
+        value?: FluidValue | string | number;
+    }) => React.ReactNode;
+    direction?: 'single' | 'both';
+    threshold?: number;
+    animationConfig?: UseAnimatedValueConfig;
+}
+/**
+ * ScrollableBlock - Higher order component to handle the entrance or exit animation
+ * of a component when it enters or exit the viewport. Accepts child as a function with
+ * `AnimatedValue` as its first argument which can be interpolated on input range [0, 1]
+ * @prop { function } children - child as a function with `AnimatedValue` as its first argument.
+ * @prop { 'single' | 'both' } direction - single applies animation on enter once, both applies on enter and exit.
+ * @prop { number } threshold - should be in range 0 to 1 which equivalent to `IntersectionObserver` threshold.
+ * @prop { UseAnimatedValueConfig } animationConfig - Animation config
+ */
+export declare const ScrollableBlock: (props: ScrollableBlockProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/animation/{modules → lib/modules}/TransitionBlock.d.ts

@@ -1,17 +1,18 @@
-import * as React from 'react';
-import { UseAnimatedValueConfig, ValueType } from '../useAnimatedValue';
-interface TransitionBlockProps {
-    state: boolean;
-    children: (animation: {
-        value: ValueType;
-    }) => React.ReactNode;
-    config?: UseAnimatedValueConfig;
-}
-/**
- * TransitionBlock - Higher order component which animates on state change.
- * @prop { boolean } state - Boolean indicating the current state of animation, usually `false = 0 and true = 1`.
- * @prop { function } children - Child as a function with `AnimatedValue` on `.value` property.
- * @prop { UseAnimatedValueConfig } config - Animation configuration.
- */
-export declare const TransitionBlock: ({ state, children, config, }: TransitionBlockProps) => JSX.Element;
-export {};
+import * as React from 'react';
+import { UseAnimatedValueConfig } from '../useAnimatedValue';
+import { FluidValue } from '../../core';
+interface TransitionBlockProps {
+    state: boolean;
+    children: (animation: {
+        value?: FluidValue | string | number;
+    }) => React.ReactNode;
+    config?: UseAnimatedValueConfig;
+}
+/**
+ * TransitionBlock - Higher order component which animates on state change.
+ * @prop { boolean } state - Boolean indicating the current state of animation, usually `false = 0 and true = 1`.
+ * @prop { function } children - Child as a function with `AnimatedValue` on `.value` property.
+ * @prop { UseAnimatedValueConfig } config - Animation configuration.
+ */
+export declare const TransitionBlock: ({ state, children, config, }: TransitionBlockProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/animation/{modules → lib/modules}/index.d.ts

@@ -1,6 +1,6 @@
-export * from './AnimatedBlock';
-export * from './AnimatedInline';
-export * from './AnimatedImage';
-export * from './MountedBlock';
-export * from './ScrollableBlock';
-export * from './TransitionBlock';
+export * from './AnimatedBlock';
+export * from './AnimatedInline';
+export * from './AnimatedImage';
+export * from './MountedBlock';
+export * from './ScrollableBlock';
+export * from './TransitionBlock';

package/dist/animation/{useAnimatedValue.d.ts → lib/useAnimatedValue.d.ts}

@@ -1,22 +1,17 @@
-import { TransitionValueConfig } from '@raidipesh78/re-motion';
-declare type Length = number | string;
-export interface UseAnimatedValueConfig extends TransitionValueConfig {
-}
-declare type AssignValue = {
-    toValue: Length;
-    config?: UseAnimatedValueConfig;
-};
-export declare type ValueType = Length | AssignValue | ((update: (next: AssignValue) => Promise<any>) => void);
-/**
- * `useAnimatedValue` returns an animation value with `.value` and `.currentValue` property which is
- * initialized when passed to argument (`initialValue`). The retured value persist until the lifetime of
- * a component. It doesnot cast any re-renders which can is very good for performance optimization.
- *
- * @param { string | number } initialValue - Initial value
- * @param { UseAnimatedValueConfig } config - Animation configuration object.
- */
-export declare function useAnimatedValue(initialValue: Length, config?: UseAnimatedValueConfig): {
-    value: ValueType;
-    currentValue: number | string;
-};
-export {};
+import { FluidValueConfig, FluidValue } from '../core';
+type Length = number | string;
+export interface UseAnimatedValueConfig extends FluidValueConfig {
+}
+/**
+ * `useAnimatedValue` returns an animation value with `.value` and `.currentValue` property which is
+ * initialized when passed to argument (`initialValue`). The retured value persist until the lifetime of
+ * a component. It doesnot cast any re-renders which can is very good for performance optimization.
+ *
+ * @param { string | number } initialValue - Initial value
+ * @param { UseAnimatedValueConfig } config - Animation configuration object.
+ */
+export declare function useAnimatedValue(initialValue: Length, config?: UseAnimatedValueConfig): {
+    value: FluidValue | string | number | undefined;
+    currentValue: number | string;
+};
+export {};

package/dist/animation/{useMountedValue.d.ts → lib/useMountedValue.d.ts}

@@ -1,15 +1,14 @@
-import * as React from 'react';
-import { UseMountConfig, FluidValue } from '@raidipesh78/re-motion';
-export interface UseMountedValueConfig extends UseMountConfig {
-}
-/**
- * `useMountedValue` handles mounting and unmounting of a component which captures current state
- * passed as an arugment (`state`) and exposes the shadow state which handles the mount and unmount
- * of a component.
- *
- * @param { boolean } state - Boolean indicating the component should mount or unmount.
- * @param { UseMountedValueConfig } config - Animation configuration.
- */
-export declare function useMountedValue(state: boolean, config: UseMountedValueConfig): (cb: (value: {
-    value: FluidValue;
-}, mounted: boolean) => React.ReactNode) => any;
+import { UseMountConfig, FluidValue } from '../core';
+export interface UseMountedValueConfig extends UseMountConfig {
+}
+/**
+ * `useMountedValue` handles mounting and unmounting of a component which captures current state
+ * passed as an arugment (`state`) and exposes the shadow state which handles the mount and unmount
+ * of a component.
+ *
+ * @param { boolean } state - Boolean indicating the component should mount or unmount.
+ * @param { UseMountedValueConfig } config - Animation configuration.
+ */
+export declare function useMountedValue(state: boolean, config: UseMountedValueConfig): (cb: (value: {
+    value: FluidValue;
+}, mounted: boolean) => React.ReactNode) => import("react").ReactNode;

package/dist/gestures/controllers/DragGesture.d.ts

@@ -1,17 +1,17 @@
-import { Vector2 } from '../types';
-import { Gesture } from './Gesture';
-export declare class DragGesture extends Gesture {
-    movementStart: Vector2;
-    initialMovement: Vector2;
-    movement: Vector2;
-    previousMovement: Vector2;
-    translation: Vector2;
-    offset: Vector2;
-    velocity: Vector2;
-    _initEvents(): void;
-    _cancelEvents(): void;
-    _handleCallback(): void;
-    pointerDown(e: any): void;
-    pointerMove(e: any): void;
-    pointerUp(): void;
-}
+import { Gesture } from './Gesture';
+import type { Vector2 } from '../types';
+export declare class DragGesture extends Gesture {
+    movementStart: Vector2;
+    initialMovement: Vector2;
+    movement: Vector2;
+    previousMovement: Vector2;
+    translation: Vector2;
+    offset: Vector2;
+    velocity: Vector2;
+    _initEvents(): void;
+    _cancelEvents(): void;
+    _handleCallback(): void;
+    pointerDown(e: any): void;
+    pointerMove(e: any): void;
+    pointerUp(): void;
+}

package/dist/gestures/controllers/Gesture.d.ts

@@ -1,20 +1,20 @@
-export declare class Gesture {
-    currentIndex?: number;
-    lastTimeStamp: number;
-    isActive: boolean;
-    targetElement?: HTMLElement;
-    targetElements: Array<HTMLElement>;
-    config?: any;
-    callback?: <T>(event: T) => void;
-    _subscribe?: (eventKeys?: Array<string>) => void;
-    static _VELOCITY_LIMIT: number;
-    _initEvents(): void;
-    _cancelEvents(): void;
-    applyCallback(callback: <T>(event: T) => void): void;
-    applyGesture({ targetElement, targetElements, callback, config, }: {
-        targetElement?: any;
-        targetElements?: any;
-        callback: <T>(event: T) => void;
-        config?: any;
-    }): () => void | undefined;
-}
+export declare class Gesture {
+    currentIndex?: number;
+    lastTimeStamp: number;
+    isActive: boolean;
+    targetElement?: HTMLElement;
+    targetElements: Array<HTMLElement>;
+    config?: any;
+    callback?: <T>(event: T) => void;
+    _subscribe?: (eventKeys?: Array<string>) => void;
+    static _VELOCITY_LIMIT: number;
+    _initEvents(): void;
+    _cancelEvents(): void;
+    applyCallback(callback: <T>(event: T) => void): void;
+    applyGesture({ targetElement, targetElements, callback, config, }: {
+        targetElement?: any;
+        targetElements?: any;
+        callback: <T>(event: T) => void;
+        config?: any;
+    }): () => void | undefined;
+}

package/dist/gestures/controllers/MouseMoveGesture.d.ts

@@ -1,13 +1,13 @@
-import { Vector2 } from '../types';
-import { Gesture } from './Gesture';
-export declare class MouseMoveGesture extends Gesture {
-    event?: MouseEvent;
-    isActiveID?: any;
-    movement: Vector2;
-    previousMovement: Vector2;
-    velocity: Vector2;
-    direction: Vector2;
-    _initEvents(): void;
-    _handleCallback(): void;
-    onMouseMove(e: MouseEvent): void;
-}
+import { Vector2 } from '../types';
+import { Gesture } from './Gesture';
+export declare class MouseMoveGesture extends Gesture {
+    event?: MouseEvent;
+    isActiveID?: any;
+    movement: Vector2;
+    previousMovement: Vector2;
+    velocity: Vector2;
+    direction: Vector2;
+    _initEvents(): void;
+    _handleCallback(): void;
+    onMouseMove(e: MouseEvent): void;
+}

package/dist/gestures/controllers/ScrollGesture.d.ts

@@ -1,14 +1,14 @@
-import { Vector2 } from '../types';
-import { Gesture } from './Gesture';
-export declare class ScrollGesture extends Gesture {
-    isActiveID?: any;
-    movement: Vector2;
-    previousMovement: Vector2;
-    direction: Vector2;
-    velocity: Vector2;
-    _initEvents(): void;
-    _handleCallback(): void;
-    onScroll({ x, y }: Vector2): void;
-    scrollListener(): void;
-    scrollElementListener(): void;
-}
+import { Vector2 } from '../types';
+import { Gesture } from './Gesture';
+export declare class ScrollGesture extends Gesture {
+    isActiveID?: any;
+    movement: Vector2;
+    previousMovement: Vector2;
+    direction: Vector2;
+    velocity: Vector2;
+    _initEvents(): void;
+    _handleCallback(): void;
+    onScroll({ x, y }: Vector2): void;
+    scrollListener(): void;
+    scrollElementListener(): void;
+}

package/dist/gestures/controllers/WheelGesture.d.ts

@@ -1,15 +1,15 @@
-import { Vector2 } from '../types';
-import { Gesture } from './Gesture';
-export declare class WheelGesture extends Gesture {
-    isActiveID?: any;
-    movement: Vector2;
-    previousMovement: Vector2;
-    direction: Vector2;
-    velocity: Vector2;
-    delta: Vector2;
-    offset: Vector2;
-    translation: Vector2;
-    _initEvents(): void;
-    _handleCallback(): void;
-    onWheel(event: WheelEvent): void;
-}
+import { Vector2 } from '../types';
+import { Gesture } from './Gesture';
+export declare class WheelGesture extends Gesture {
+    isActiveID?: any;
+    movement: Vector2;
+    previousMovement: Vector2;
+    direction: Vector2;
+    velocity: Vector2;
+    delta: Vector2;
+    offset: Vector2;
+    translation: Vector2;
+    _initEvents(): void;
+    _handleCallback(): void;
+    onWheel(event: WheelEvent): void;
+}

package/dist/gestures/controllers/index.d.ts

@@ -1,4 +1,4 @@
-export * from './DragGesture';
-export * from './MouseMoveGesture';
-export * from './ScrollGesture';
-export * from './WheelGesture';
+export * from './DragGesture';
+export * from './MouseMoveGesture';
+export * from './ScrollGesture';
+export * from './WheelGesture';

package/dist/gestures/helpers/eventAttacher.d.ts

@@ -0,0 +1,11 @@
+type MouseEventType = 'click' | 'dblclick' | 'mousedown' | 'mousemove' | 'mouseup' | 'touchstart' | 'touchmove' | 'touchend' | 'mouseenter' | 'mouseleave' | 'mouseout' | 'mouseover' | 'scroll' | 'wheel' | 'contextmenu';
+type DomTargetTypes = Array<Window | Document | HTMLElement>;
+/**
+ * Attach multiple document / window event / HTMLElement
+ */
+export declare function attachEvents(domTargets: DomTargetTypes, events: Array<[
+    event: MouseEventType,
+    callback: (e: any) => void,
+    capture?: any
+]>): (eventKeys?: Array<string>) => void;
+export {};

package/dist/gestures/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './math';