react-ui-animate 1.2.2 → 1.4.2

package/dist/Interpolation.d.ts

@@ -0,0 +1,20 @@
+import { ExtrapolateConfig } from "@raidipesh78/re-motion";
+/**
+ * interpolate function maps input range to output range
+ * @param value - number | TransitionValue
+ * @param inputRange - Array<number>
+ * @param outputRange - Array<string | number>
+ * @param extrapolateConfig - "clamp" | "identity" | "extend"
+ * @returns - number | TransitionValue
+ */
+export declare function interpolate(value: any, 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: any, minOutput: number | string, maxOutput: number | string, extrapolateConfig?: ExtrapolateConfig): any;

package/dist/Math.d.ts

@@ -0,0 +1,34 @@
+/**
+ * bin(booleanValue)
+ * returns 1 if booleanValue == true and 0 if booleanValue == false
+ */
+export declare function bin(bool: boolean): 1 | 0;
+/**
+ * mix(progress, a, b)
+ * linear interpolation between a and b
+ */
+export declare function mix(perc: number, val1: number, val2: number): number;
+/**
+ * clamp(value, min, max)
+ * clamps value for min and max bounds
+ */
+export declare function clamp(value: number, lowerbound: number, upperbound: number): number;
+/**
+ * rubberClamp(value, min, max, constant?)
+ * constant is optional : default 0.15
+ * clamps the value for min and max value and
+ * extends beyond min and max values with constant
+ * factor to create elastic rubber band effect
+ */
+export declare function rubberClamp(value: number, lowerbound: number, upperbound: number, constant?: number): number;
+/**
+ * snapTo(value, velocity, snapPoints[])
+ * Calculates the final snapPoint according to given current value,
+ * velocity and snapPoints array
+ */
+export declare function snapTo(value: number, velocity: number, snapPoints: Array<number>): number;
+/**
+ * move(array, moveIndex, toIndex)
+ * move array item from moveIndex to toIndex without array modification
+ */
+export declare function move(array: Array<any>, moveIndex: number, toIndex: number): any[];

package/dist/Modules.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { UseAnimatedValueConfig } from "./useAnimatedValue";
+/**
+ * Make any component animatable
+ */
+export declare function makeAnimatedComponent(WrappedComponent: React.ElementType<any>): React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedBlock : Animated Div
+ */
+export declare const AnimatedBlock: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedInline : Animated Span
+ */
+export declare const AnimatedInline: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedImage : Animated Image
+ */
+export declare const AnimatedImage: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+interface ScrollableBlockProps {
+    children?: (animation: any) => React.ReactNode;
+    direction?: "single" | "both";
+    threshold?: number;
+    animationConfig?: UseAnimatedValueConfig;
+}
+/**
+ * ScrollableBlock
+ * Used to animate element when enter into viewport
+ * Render props pattern with children accepts animation node
+ * animated value goes from 0 to 1 when appear on viewport & vice versa.
+ */
+export declare const ScrollableBlock: React.FC<ScrollableBlockProps>;
+export {};

package/dist/Types.d.ts

@@ -0,0 +1,64 @@
+export declare type MeasurementValue = number | Array<number>;
+export declare type MeasurementType = {
+    left: MeasurementValue;
+    top: MeasurementValue;
+    width: MeasurementValue;
+    height: MeasurementValue;
+    vLeft: MeasurementValue;
+    vTop: MeasurementValue;
+};
+export declare type WindowDimensionType = {
+    width: number;
+    height: number;
+    innerWidth: number;
+    innerHeight: number;
+};
+declare type GenericEventType = {
+    velocityX: number;
+    velocityY: number;
+    directionX: number;
+    directionY: number;
+};
+export declare type ScrollEventType = {
+    isScrolling: boolean;
+    scrollX: number;
+    scrollY: number;
+} & GenericEventType;
+export declare type WheelEventType = {
+    target: HTMLElement | undefined | null;
+    isWheeling: boolean;
+    movementX: number;
+    movementY: number;
+    offsetX: number;
+    offsetY: number;
+    deltaX: number;
+    deltaY: number;
+} & GenericEventType;
+export declare type DragEventType = {
+    args: Array<number | undefined>;
+    down: boolean;
+    movementX: number;
+    movementY: number;
+    offsetX: number;
+    offsetY: number;
+    distanceX: number;
+    distanceY: number;
+    cancel: () => void;
+} & GenericEventType;
+export declare type MouseMoveEventType = {
+    target: EventTarget | undefined | null;
+    isMoving: boolean;
+    mouseX: number;
+    mouseY: number;
+} & GenericEventType;
+export declare type UseDragConfig = {
+    initial?: () => {
+        movementX: number;
+        movementY: number;
+    };
+};
+export declare type Vector2 = {
+    x: number;
+    y: number;
+};
+export {};

package/dist/animation/getInitialConfig.d.ts

@@ -0,0 +1,3 @@
+import { GenericAnimationConfig } from "./useAnimatedValue";
+export declare type InitialConfigType = "ease" | "elastic" | "stiff" | "wooble" | "bounce" | undefined;
+export declare const getInitialConfig: (animationType: InitialConfigType) => GenericAnimationConfig;

package/dist/animation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./interpolation";
+export * from "./modules";
+export { useAnimatedValue } from "./useAnimatedValue";
+export { useMountedValue } from "./useMountedValue";

package/dist/animation/interpolation.d.ts

@@ -0,0 +1,20 @@
+import { ExtrapolateConfig } from "@raidipesh78/re-motion";
+/**
+ * interpolate function maps input range to output range
+ * @param value - number | TransitionValue
+ * @param inputRange - Array<number>
+ * @param outputRange - Array<string | number>
+ * @param extrapolateConfig - "clamp" | "identity" | "extend"
+ * @returns - number | TransitionValue
+ */
+export declare function interpolate(value: any, 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: any, minOutput: number | string, maxOutput: number | string, extrapolateConfig?: ExtrapolateConfig): any;

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

@@ -0,0 +1,5 @@
+/**
+ * AnimatedBlock
+ * <div /> element which can accept animation values
+ */
+export declare const AnimatedBlock: any;

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

@@ -0,0 +1,5 @@
+/**
+ * AnimatedImage
+ * <img /> element which can accept animation values
+ */
+export declare const AnimatedImage: any;

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

@@ -0,0 +1,5 @@
+/**
+ * AnimatedInline
+ * <span /> element which can accept animation values
+ */
+export declare const AnimatedInline: any;

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

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { TransitionValue } from "@raidipesh78/re-motion";
+import { InnerUseMountedValueConfig } from "../useMountedValue";
+interface MountedBlockProps {
+    state: boolean;
+    children: (animation: {
+        value: TransitionValue;
+    }) => React.ReactNode;
+    config?: InnerUseMountedValueConfig;
+}
+/**
+ * MountedBlock handles mounting and unmounting of a component
+ * @props - state: boolean, config: InnerUseMountedValueConfig
+ * @children -  (animation: { value: TransitionValue }) => React.ReactNode
+ */
+export declare const MountedBlock: ({ state, children, config, }: MountedBlockProps) => JSX.Element;
+export {};

package/dist/animation/modules/ScrollableBlock.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { UseAnimatedValueConfig } from "../useAnimatedValue";
+interface ScrollableBlockProps {
+    children?: (animation: any) => React.ReactNode;
+    direction?: "single" | "both";
+    threshold?: number;
+    animationConfig?: UseAnimatedValueConfig;
+}
+/**
+ * ScrollableBlock
+ * Used to animate element when enter into viewport
+ * Render props pattern with children accepts animation node
+ * animated value goes from 0 to 1 when appear on viewport & vice versa.
+ */
+export declare const ScrollableBlock: React.FC<ScrollableBlockProps>;
+export {};

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

@@ -0,0 +1,6 @@
+export * from "./makeAnimatedComponent";
+export * from "./AnimatedBlock";
+export * from "./AnimatedInline";
+export * from "./AnimatedImage";
+export * from "./ScrollableBlock";
+export * from "./MountedBlock";

package/dist/animation/modules/makeAnimatedComponent.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Make any component animatable
+ */
+export declare function makeAnimatedComponent(WrappedComponent: React.ElementType<any>): import("react").ForwardRefExoticComponent<Pick<any, string | number | symbol> & import("react").RefAttributes<unknown>>;

package/dist/animation/modules.d.ts

@@ -0,0 +1,47 @@
+import * as React from "react";
+import { TransitionValue } from "@raidipesh78/re-motion";
+import { UseAnimatedValueConfig } from "./useAnimatedValue";
+import { InnerUseMountedValueConfig } from "./useMountedValue";
+/**
+ * Make any component animatable
+ */
+export declare function makeAnimatedComponent(WrappedComponent: React.ElementType<any>): React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedBlock : Animated Div
+ */
+export declare const AnimatedBlock: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedInline : Animated Span
+ */
+export declare const AnimatedInline: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/**
+ * AnimatedImage : Animated Image
+ */
+export declare const AnimatedImage: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+interface ScrollableBlockProps {
+    children?: (animation: any) => React.ReactNode;
+    direction?: "single" | "both";
+    threshold?: number;
+    animationConfig?: UseAnimatedValueConfig;
+}
+/**
+ * ScrollableBlock
+ * Used to animate element when enter into viewport
+ * Render props pattern with children accepts animation node
+ * animated value goes from 0 to 1 when appear on viewport & vice versa.
+ */
+export declare const ScrollableBlock: React.FC<ScrollableBlockProps>;
+interface MountedBlockProps {
+    state: boolean;
+    children: (animation: {
+        value: TransitionValue;
+    }) => React.ReactNode;
+    config?: InnerUseMountedValueConfig;
+}
+/**
+ * MountedBlock handles mounting and unmounting of a component
+ * @props - state: boolean, config: InnerUseMountedValueConfig
+ * @children -  (animation: { value: TransitionValue }) => React.ReactNode
+ */
+export declare const MountedBlock: ({ state, children, config, }: MountedBlockProps) => JSX.Element;
+export {};

package/dist/animation/useAnimatedValue.d.ts

@@ -0,0 +1,30 @@
+import { TransitionValue, ResultType } from "@raidipesh78/re-motion";
+import { InitialConfigType } from "./getInitialConfig";
+declare type AnimatedValueType = number | string;
+export interface GenericAnimationConfig {
+    duration?: number;
+    mass?: number;
+    friction?: number;
+    tension?: number;
+    easing?: (t: number) => number;
+    delay?: number;
+}
+export interface UseAnimatedValueConfig extends GenericAnimationConfig {
+    animationType?: InitialConfigType;
+    onAnimationEnd?: (value: ResultType) => void;
+    listener?: (value: number) => void;
+    immediate?: boolean;
+}
+export declare type ValueReturnType = TransitionValue | number | string | {
+    toValue: number | string;
+    immediate?: boolean;
+};
+interface UseAnimatedValueReturn {
+    value: ValueReturnType;
+    currentValue: number | string;
+}
+/**
+ * useAnimatedValue for animated transitions
+ */
+export declare function useAnimatedValue(initialValue: AnimatedValueType, config?: UseAnimatedValueConfig): UseAnimatedValueReturn;
+export {};

package/dist/animation/useMountedValue.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import { TransitionValue, UseTransitionConfig } from "@raidipesh78/re-motion";
+export interface InnerUseMountedValueConfig extends UseTransitionConfig {
+    enterDuration?: number;
+    exitDuration?: number;
+}
+interface UseMountedValueConfig {
+    from: number;
+    enter: number;
+    exit: number;
+    config?: InnerUseMountedValueConfig;
+}
+/**
+ * useMountedValue handles mounting and unmounting of a component
+ * @param state - boolean
+ * @param config - useTransitionConfig
+ * @returns mountedValueFunction with a callback with argument ( animationNode, mounted )
+ */
+export declare function useMountedValue(state: boolean, config: UseMountedValueConfig): (callback: ({ value }: {
+    value: TransitionValue;
+}, mounted: boolean) => React.ReactNode) => React.ReactNode;
+export {};

package/dist/controllers/EventAttacher.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Attach single document / window event / HTMLElement
+ */
+export declare function attachEvent(domTarget: Window | Document | HTMLElement, event: string, callback: (e: any) => void, capture?: any): () => void;
+/**
+ * Attach multiple document / window event / HTMLElement
+ */
+export declare function attachEvents(domTarget: Window | Document | HTMLElement, events: Array<[event: string, callback: (e: any) => void, capture?: any]>): () => void;

package/dist/controllers/index.d.ts

@@ -0,0 +1 @@
+export * from "./EventAttacher";

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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;
+}

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

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

package/dist/gestures/eventAttacher.d.ts

@@ -0,0 +1,11 @@
+declare type MouseEventType = "click" | "dblclick" | "mousedown" | "mousemove" | "mouseup" | "touchstart" | "touchmove" | "touchend" | "mouseenter" | "mouseleave" | "mouseout" | "mouseover" | "scroll" | "wheel" | "contextmenu";
+declare 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?: string[] | undefined) => void;
+export {};

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

@@ -0,0 +1,5 @@
+export * from "./useDrag";
+export * from "./useMouseMove";
+export * from "./useScroll";
+export * from "./useWheel";
+export * from "./useGesture";

package/dist/gestures/hooks/useDrag.d.ts

@@ -0,0 +1,4 @@
+import { DragEventType, UseDragConfig } from "../types";
+export declare function useDrag(callback: (event: DragEventType) => void, config?: UseDragConfig): (index?: number | undefined) => {
+    ref: any;
+};

package/dist/gestures/hooks/useGesture.d.ts

@@ -0,0 +1,9 @@
+import { DragEventType, WheelEventType, ScrollEventType, MouseMoveEventType } from "../types";
+export declare function useGesture({ onDrag, onWheel, onScroll, onMouseMove, }: {
+    onDrag?: (event: DragEventType) => void;
+    onWheel?: (event: WheelEventType) => void;
+    onScroll?: (event: ScrollEventType) => void;
+    onMouseMove?: (event: MouseMoveEventType) => void;
+}): (index?: number | undefined) => {
+    ref: any;
+};

package/dist/gestures/hooks/useMouseMove.d.ts

@@ -0,0 +1,4 @@
+import { MouseMoveEventType } from "../types";
+export declare function useMouseMove(callback: (event: MouseMoveEventType) => void): (index?: number | undefined) => {
+    ref: any;
+};

package/dist/gestures/hooks/useRecognizer.d.ts

@@ -0,0 +1,10 @@
+declare type UseRecognizerHandlerType = Array<[
+    key: "drag" | "wheel" | "move" | "scroll",
+    gesture: any,
+    callback: any,
+    config?: any
+]>;
+export declare const useRecognizer: (handlers: UseRecognizerHandlerType) => (index?: number | undefined) => {
+    ref: any;
+};
+export {};

package/dist/gestures/hooks/useScroll.d.ts

@@ -0,0 +1,4 @@
+import { ScrollEventType } from "../types";
+export declare function useScroll(callback: (event: ScrollEventType) => void): (index?: number | undefined) => {
+    ref: any;
+};

package/dist/gestures/hooks/useWheel.d.ts

@@ -0,0 +1,4 @@
+import { WheelEventType } from "../types";
+export declare function useWheel(callback: (event: WheelEventType) => void): (index?: number | undefined) => {
+    ref: any;
+};

package/dist/gestures/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hooks";
+export * from "./math";

package/dist/gestures/math.d.ts

@@ -0,0 +1,34 @@
+/**
+ * bin(booleanValue)
+ * returns 1 if booleanValue == true and 0 if booleanValue == false
+ */
+export declare function bin(bool: boolean): 1 | 0;
+/**
+ * mix(progress, a, b)
+ * linear interpolation between a and b
+ */
+export declare function mix(perc: number, val1: number, val2: number): number;
+/**
+ * clamp(value, min, max)
+ * clamps value for min and max bounds
+ */
+export declare function clamp(value: number, lowerbound: number, upperbound: number): number;
+/**
+ * rubberClamp(value, min, max, constant?)
+ * constant is optional : default 0.15
+ * clamps the value for min and max value and
+ * extends beyond min and max values with constant
+ * factor to create elastic rubber band effect
+ */
+export declare function rubberClamp(value: number, lowerbound: number, upperbound: number, constant?: number): number;
+/**
+ * snapTo(value, velocity, snapPoints[])
+ * Calculates the final snapPoint according to given current value,
+ * velocity and snapPoints array
+ */
+export declare function snapTo(value: number, velocity: number, snapPoints: Array<number>): number;
+/**
+ * move(array, moveIndex, toIndex)
+ * move array item from moveIndex to toIndex without array modification
+ */
+export declare function move(array: Array<any>, moveIndex: number, toIndex: number): any[];

package/dist/gestures/types.d.ts

@@ -0,0 +1,51 @@
+declare type GenericEventType = {
+    velocityX: number;
+    velocityY: number;
+    directionX: number;
+    directionY: number;
+};
+export declare type DragEventType = {
+    args: Array<number | undefined>;
+    down: boolean;
+    movementX: number;
+    movementY: number;
+    offsetX: number;
+    offsetY: number;
+    distanceX: number;
+    distanceY: number;
+    cancel: () => void;
+} & GenericEventType;
+export declare type MouseMoveEventType = {
+    args: Array<number | undefined>;
+    event: MouseEvent;
+    target: EventTarget | undefined | null;
+    isMoving: boolean;
+    mouseX: number;
+    mouseY: number;
+} & GenericEventType;
+export declare type ScrollEventType = {
+    isScrolling: boolean;
+    scrollX: number;
+    scrollY: number;
+} & GenericEventType;
+export declare type WheelEventType = {
+    target: HTMLElement | undefined | null;
+    isWheeling: boolean;
+    movementX: number;
+    movementY: number;
+    offsetX: number;
+    offsetY: number;
+    deltaX: number;
+    deltaY: number;
+} & GenericEventType;
+export declare type UseDragConfig = {
+    initial?: () => {
+        movementX: number;
+        movementY: number;
+    };
+};
+export declare type Vector2 = {
+    x: number;
+    y: number;
+};
+export {};

package/dist/gestures/withDefault.d.ts

@@ -0,0 +1,4 @@
+export declare const withDefault: (x: number, y: number) => {
+    x: number;
+    y: number;
+};

package/dist/getInitialConfig.d.ts

@@ -0,0 +1,3 @@
+import { GenericAnimationConfig } from "./useAnimatedValue";
+export declare type InitialConfigType = "ease" | "elastic" | "stiff" | "wooble" | "bounce" | undefined;
+export declare const getInitialConfig: (animationType: InitialConfigType) => GenericAnimationConfig;

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./useOutsideClick";
+export * from "./useMeasure";
+export * from "./useWindowDimension";

package/dist/hooks/useDrag.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import { DragEventType, UseDragConfig } from "../Types";
+export declare function useDrag(callback: (event: DragEventType) => void, config?: UseDragConfig, deps?: React.DependencyList): (index?: number | undefined) => {
+    ref: any;
+};