react-native-reanimated 3.4.1 → 3.4.2

package/lib/typescript/Animated.d.ts

@@ -1,9 +1,74 @@
+import type { Extrapolate as _Extrapolate } from './reanimated2/interpolateColor';
+import type { SharedValue as _SharedValue } from './reanimated2/commonTypes';
+import type { DerivedValue as _DerivedValue } from './reanimated2/hook/useDerivedValue';
+import type { TransformStyleTypes as _TransformStyleTypes, Adaptable as _Adaptable, AdaptTransforms as _AdaptTransforms, AnimatedTransform as _AnimatedTransform, AnimateStyle as _AnimateStyle, StylesOrDefault as _StylesOrDefault, AnimateProps as _AnimateProps } from './reanimated2/helperTypes';
+import type { EasingFunction as _EasingFunction } from './reanimated2/Easing';
+import { addWhitelistedNativeProps as _addWhitelistedNativeProps, addWhitelistedUIProps as _addWhitelistedUIProps } from './ConfigHelper';
+import type { AnimatedScrollViewProps as _AnimatedScrollViewProps } from './reanimated2/component/ScrollView';
+import type { FlatListPropsWithLayout as _FlatListPropsWithLayout } from './reanimated2/component/FlatList';
 export { default as createAnimatedComponent } from './createAnimatedComponent';
-export { addWhitelistedNativeProps, addWhitelistedUIProps, } from './ConfigHelper';
 export { AnimatedText as Text } from './reanimated2/component/Text';
 export { AnimatedView as View } from './reanimated2/component/View';
 export { AnimatedScrollView as ScrollView } from './reanimated2/component/ScrollView';
 export { AnimatedImage as Image } from './reanimated2/component/Image';
 export { ReanimatedFlatList as FlatList } from './reanimated2/component/FlatList';
-export type { SharedValue } from './reanimated2/commonTypes';
-export type { AnimateStyle } from './reanimated2/helperTypes';
+/**
+ * @deprecated Please import `Extrapolate` directly from `react-native-reanimated` instead of `Animated` namespace.
+ */
+export type Extrapolate = typeof _Extrapolate;
+/**
+ * @deprecated Please import `SharedValue` directly from `react-native-reanimated` instead of `Animated` namespace.
+ */
+export type SharedValue<T> = _SharedValue<T>;
+/**
+ * @deprecated Please import `DerivedValue` directly from `react-native-reanimated` instead of `Animated` namespace.
+ */
+export type DerivedValue<T> = _DerivedValue<T>;
+/**
+ * @deprecated Please import `Adaptable` directly from `react-native-reanimated` instead of `Animated` namespace.
+ */
+export type Adaptable<T> = _Adaptable<T>;
+/**
+ * @deprecated Please import `TransformStyleTypes` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type TransformStyleTypes = _TransformStyleTypes;
+/**
+ * @deprecated Please import `AdaptTransforms` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type AdaptTransforms<T> = _AdaptTransforms<T>;
+/**
+ * @deprecated Please import `AnimatedTransform` directly from `react-native-reanimated` instead of `Animated` namespace.
+ */
+export type AnimatedTransform = _AnimatedTransform;
+/**
+ * @deprecated Please import `AnimateStyle` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type AnimateStyle<S> = _AnimateStyle<S>;
+/**
+ * @deprecated Please import `StylesOrDefault` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type StylesOrDefault<S> = _StylesOrDefault<S>;
+/**
+ * @deprecated Please import `AnimateProps` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type AnimateProps<P extends object> = _AnimateProps<P>;
+/**
+ * @deprecated Please import `EasingFunction` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type EasingFunction = _EasingFunction;
+/**
+ * @deprecated Please import `addWhitelistedNativeProps` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export declare const addWhitelistedNativeProps: typeof _addWhitelistedNativeProps;
+/**
+ * @deprecated Please import `addWhitelistedUIProps` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export declare const addWhitelistedUIProps: typeof _addWhitelistedUIProps;
+/**
+ * @deprecated Please import `AnimatedScrollViewProps` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type AnimatedScrollViewProps = _AnimatedScrollViewProps;
+/**
+ * @deprecated Please import `FlatListPropsWithLayout` directly from `react-native-reanimated` instead of `Animated` namespace.
+ * */
+export type FlatListPropsWithLayout<T> = _FlatListPropsWithLayout<T>;

package/lib/typescript/createAnimatedComponent.d.ts

@@ -1,27 +1,6 @@
-import type { Component, ComponentClass, FunctionComponent, Ref } from 'react';
+import type { Component, ComponentClass, FunctionComponent } from 'react';
 import './reanimated2/layoutReanimation/animationsManager';
-import type { BaseAnimationBuilder, EntryExitAnimationFunction, ILayoutAnimationBuilder } from './reanimated2/layoutReanimation';
-import { SharedTransition } from './reanimated2/layoutReanimation';
-import type { SharedValue, StyleProps } from './reanimated2/commonTypes';
-import type { ViewDescriptorsSet, ViewRefSet } from './reanimated2/ViewDescriptorsSet';
 import type { AnimateProps } from './reanimated2/helperTypes';
-type NestedArray<T> = T | NestedArray<T>[];
-interface AnimatedProps extends Record<string, unknown> {
-    viewDescriptors?: ViewDescriptorsSet;
-    viewsRef?: ViewRefSet<unknown>;
-    initial?: SharedValue<StyleProps>;
-}
-export type AnimatedComponentProps<P extends Record<string, unknown>> = P & {
-    forwardedRef?: Ref<Component>;
-    style?: NestedArray<StyleProps>;
-    animatedProps?: Partial<AnimatedComponentProps<AnimatedProps>>;
-    animatedStyle?: StyleProps;
-    layout?: BaseAnimationBuilder | ILayoutAnimationBuilder | typeof BaseAnimationBuilder;
-    entering?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
-    exiting?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
-    sharedTransitionTag?: string;
-    sharedTransitionStyle?: SharedTransition;
-};
 type Options<P> = {
     setNativeProps: (ref: ComponentRef, props: P) => void;
 };
@@ -30,10 +9,6 @@ interface ComponentRef extends Component {
     getScrollableNode?: () => ComponentRef;
     getAnimatableRef?: () => ComponentRef;
 }
-export interface InitialComponentProps extends Record<string, unknown> {
-    ref?: Ref<Component>;
-    collapsable?: boolean;
-}
 export default function createAnimatedComponent<P extends object>(component: FunctionComponent<P>, options?: Options<P>): FunctionComponent<AnimateProps<P>>;
 export default function createAnimatedComponent<P extends object>(component: ComponentClass<P>, options?: Options<P>): ComponentClass<AnimateProps<P>>;
 export {};

package/lib/typescript/reanimated2/Easing.d.ts

@@ -43,10 +43,18 @@
  * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
  * - [`out`](docs/easing.html#out) runs an easing function backwards
  */
-export type EasingFn = (t: number) => number;
-export type EasingFactoryFn = {
-    factory: () => EasingFn;
+export type EasingFunction = (t: number) => number;
+/**
+ * @deprecated Please use `EasingFunction` type instead.
+ */
+export type EasingFn = EasingFunction;
+export type EasingFunctionFactory = {
+    factory: () => EasingFunction;
 };
+/**
+ * @deprecated Please use `EasingFunctionFactory` type instead.
+ */
+export type EasingFactoryFn = EasingFunctionFactory;
 /**
  * A linear function, `f(t) = t`. Position correlates to elapsed time one to
  * one.
@@ -81,7 +89,7 @@ declare function cubic(t: number): number;
  * n = 4: http://easings.net/#easeInQuart
  * n = 5: http://easings.net/#easeInQuint
  */
-declare function poly(n: number): EasingFn;
+declare function poly(n: number): EasingFunction;
 /**
  * A sinusoidal function.
  *
@@ -110,7 +118,7 @@ declare function exp(t: number): number;
  *
  * http://easings.net/#easeInElastic
  */
-declare function elastic(bounciness?: number): EasingFn;
+declare function elastic(bounciness?: number): EasingFunction;
 /**
  * Use with `Animated.parallel()` to create a simple effect where the object
  * animates back slightly as the animation starts.
@@ -140,24 +148,24 @@ declare function bezierFn(x1: number, y1: number, x2: number, y2: number): (x: n
 /**
  * Runs an easing function forwards.
  */
-declare function in_(easing: EasingFn): EasingFn;
+declare function in_(easing: EasingFunction): EasingFunction;
 /**
  * Runs an easing function backwards.
  */
-declare function out(easing: EasingFn): EasingFn;
+declare function out(easing: EasingFunction): EasingFunction;
 /**
  * Makes any easing function symmetrical. The easing function will run
  * forwards for half of the duration, then backwards for the rest of the
  * duration.
  */
-declare function inOut(easing: EasingFn): EasingFn;
+declare function inOut(easing: EasingFunction): EasingFunction;
 /**
  * The `steps` easing function jumps between discrete values at regular intervals,
  * creating a stepped animation effect. The `n` parameter determines the number of
  * steps in the animation, and the `roundToNextStep` parameter determines whether the animation
  * should start at the beginning or end of each step.
  */
-declare function steps(n?: number, roundToNextStep?: boolean): EasingFn;
+declare function steps(n?: number, roundToNextStep?: boolean): EasingFunction;
 export declare const Easing: {
     linear: typeof linear;
     ease: typeof ease;

package/lib/typescript/reanimated2/UpdateProps.d.ts

@@ -1,13 +1,13 @@
 import type { MutableRefObject } from 'react';
-import type { AnimatedStyle, SharedValue, StyleProps } from './commonTypes';
+import type { SharedValue, StyleProps } from './commonTypes';
+import type { AnimatedStyle } from './helperTypes';
 import type { Descriptor } from './hook/commonTypes';
 import type { ViewRefSet } from './ViewDescriptorsSet';
-export declare const colorProps: string[];
 export declare const ColorProperties: string[];
-export declare let updateProps: (viewDescriptor: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined) => void;
-export declare const updatePropsJestWrapper: (viewDescriptors: SharedValue<Descriptor[]>, updates: AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined, animatedStyle: MutableRefObject<AnimatedStyle>, adapters: ((updates: AnimatedStyle) => void)[]) => void;
+declare let updateProps: (viewDescriptor: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle<any>, maybeViewRef: ViewRefSet<any> | undefined) => void;
+export declare const updatePropsJestWrapper: (viewDescriptors: SharedValue<Descriptor[]>, updates: AnimatedStyle<any>, maybeViewRef: ViewRefSet<any> | undefined, animatedStyle: MutableRefObject<AnimatedStyle<any>>, adapters: ((updates: AnimatedStyle<any>) => void)[]) => void;
 export default updateProps;
 export interface UpdatePropsManager {
-    update(viewDescriptors: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle): void;
+    update(viewDescriptors: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle<any>): void;
     flush(): void;
 }

package/lib/typescript/reanimated2/animation/commonTypes.d.ts

@@ -1,4 +1,5 @@
-import type { AnimatedStyle, StyleProps, AnimatableValue, AnimationObject, Animation, Timestamp, AnimationCallback } from '../commonTypes';
+import type { StyleProps, AnimatableValue, AnimationObject, Animation, Timestamp, AnimationCallback } from '../commonTypes';
+import type { AnimatedStyle } from '../helperTypes';
 export interface HigherOrderAnimation {
     isHigherOrder?: boolean;
 }
@@ -20,8 +21,8 @@ export interface SequenceAnimation extends Animation<SequenceAnimation>, HigherO
 }
 export interface StyleLayoutAnimation extends HigherOrderAnimation {
     current: StyleProps;
-    styleAnimations: AnimatedStyle;
+    styleAnimations: AnimatedStyle<any>;
     onFrame: (animation: StyleLayoutAnimation, timestamp: Timestamp) => boolean;
-    onStart: (nextAnimation: StyleLayoutAnimation, current: AnimatedStyle, timestamp: Timestamp, previousAnimation: StyleLayoutAnimation) => void;
+    onStart: (nextAnimation: StyleLayoutAnimation, current: AnimatedStyle<any>, timestamp: Timestamp, previousAnimation: StyleLayoutAnimation) => void;
     callback?: AnimationCallback;
 }

package/lib/typescript/reanimated2/animation/decay.d.ts

@@ -1,10 +1,11 @@
-import type { Animation, AnimationCallback, AnimationObject, AnimatableValue, Timestamp } from '../commonTypes';
+import type { Animation, AnimationCallback, AnimatableValue, Timestamp } from '../commonTypes';
 interface DecayConfig {
     deceleration?: number;
     velocityFactor?: number;
     clamp?: number[];
     velocity?: number;
 }
+export type WithDecayConfig = DecayConfig;
 export interface DecayAnimation extends Animation<DecayAnimation> {
     lastTimestamp: Timestamp;
     startTimestamp: Timestamp;
@@ -12,9 +13,6 @@ export interface DecayAnimation extends Animation<DecayAnimation> {
     velocity: number;
     current: AnimatableValue;
 }
-export interface InnerDecayAnimation extends Omit<DecayAnimation, 'current'>, AnimationObject {
-    current: number;
-}
 type withDecayType = (userConfig: DecayConfig, callback?: AnimationCallback) => number;
 export declare const withDecay: withDecayType;
 export {};

package/lib/typescript/reanimated2/animation/index.d.ts

@@ -1,10 +1,10 @@
 export type { HigherOrderAnimation, NextAnimation, DelayAnimation, RepeatAnimation, SequenceAnimation, StyleLayoutAnimation, } from './commonTypes';
 export { cancelAnimation, defineAnimation, initialUpdaterRun } from './util';
 export { withTiming } from './timing';
-export type { TimingAnimation } from './timing';
+export type { TimingAnimation, WithTimingConfig } from './timing';
 export { withSpring } from './spring';
-export type { SpringAnimation } from './springUtils';
-export { withDecay } from './decay';
+export type { SpringAnimation, WithSpringConfig } from './springUtils';
+export { withDecay, WithDecayConfig } from './decay';
 export type { DecayAnimation } from './decay';
 export { withDelay } from './delay';
 export { withRepeat } from './repeat';

package/lib/typescript/reanimated2/animation/springUtils.d.ts

@@ -16,6 +16,7 @@ export type SpringConfig = {
     duration?: number;
     dampingRatio?: number;
 });
+export type WithSpringConfig = SpringConfig;
 export interface SpringConfigInner {
     useDuration: boolean;
     configIsInvalid: boolean;

package/lib/typescript/reanimated2/animation/styleAnimation.d.ts

@@ -1,7 +1,3 @@
-import type { AnimatableValue, AnimatedStyle, NestedObject, NestedObjectValues } from '../commonTypes';
+import type { AnimatedStyle } from '../helperTypes';
 import type { StyleLayoutAnimation } from './commonTypes';
-export declare function resolvePath<T>(obj: NestedObject<T>, path: AnimatableValue[] | AnimatableValue): NestedObjectValues<T> | undefined;
-type Path = Array<string | number> | string | number;
-export declare function setPath<T>(obj: NestedObject<T>, path: Path, value: NestedObjectValues<T>): void;
-export declare function withStyleAnimation(styleAnimations: AnimatedStyle): StyleLayoutAnimation;
-export {};
+export declare function withStyleAnimation(styleAnimations: AnimatedStyle<any>): StyleLayoutAnimation;

package/lib/typescript/reanimated2/animation/timing.d.ts

@@ -1,22 +1,19 @@
-import type { EasingFn, EasingFactoryFn } from '../Easing';
+import type { EasingFunction, EasingFunctionFactory } from '../Easing';
 import type { Animation, AnimationCallback, Timestamp, AnimatableValue } from '../commonTypes';
 interface TimingConfig {
     duration?: number;
-    easing?: EasingFn | EasingFactoryFn;
+    easing?: EasingFunction | EasingFunctionFactory;
 }
+export type WithTimingConfig = TimingConfig;
 export interface TimingAnimation extends Animation<TimingAnimation> {
     type: string;
-    easing: EasingFn;
+    easing: EasingFunction;
     startValue: AnimatableValue;
     startTime: Timestamp;
     progress: number;
     toValue: AnimatableValue;
     current: AnimatableValue;
 }
-export interface InnerTimingAnimation extends Omit<TimingAnimation, 'toValue' | 'current'> {
-    toValue: number;
-    current: number;
-}
 type withTimingType = <T extends AnimatableValue>(toValue: T, userConfig?: TimingConfig, callback?: AnimationCallback) => T;
 export declare const withTiming: withTimingType;
 export {};

package/lib/typescript/reanimated2/animation/transformationMatrix/matrixUtils.d.ts

@@ -4,7 +4,7 @@ type FixedLengthArray<T, L extends number, PassedObject = [T, ...Array<T>]> = Pa
 };
 export type AffineMatrix = FixedLengthArray<FixedLengthArray<number, 4>, 4>;
 export type AffineMatrixFlat = FixedLengthArray<number, 16>;
-export type TransformMatrixDecomposition = Record<'translationMatrix' | 'scaleMatrix' | 'rotationMatrix' | 'skewMatrix', AffineMatrix>;
+type TransformMatrixDecomposition = Record<'translationMatrix' | 'scaleMatrix' | 'rotationMatrix' | 'skewMatrix', AffineMatrix>;
 type Axis = 'x' | 'y' | 'z';
 interface TansformMatrixDecompositionWithAngles extends TransformMatrixDecomposition {
     rx: number;

package/lib/typescript/reanimated2/animation/util.d.ts

@@ -1,10 +1,8 @@
-import type { NextAnimation, StyleLayoutAnimation } from './commonTypes';
-import type { AnimatedStyle, SharedValue, AnimatableValue, Animation, AnimationObject } from '../commonTypes';
-export type UserUpdater = () => AnimatedStyle;
+import type { StyleLayoutAnimation } from './commonTypes';
+import type { SharedValue, AnimatableValue, AnimationObject } from '../commonTypes';
 export declare function initialUpdaterRun<T>(updater: () => T): T;
 type AnimationToDecoration<T extends AnimationObject | StyleLayoutAnimation, U extends AnimationObject | StyleLayoutAnimation> = T extends StyleLayoutAnimation ? Record<string, unknown> : U | (() => U) | AnimatableValue;
 export declare function defineAnimation<T extends AnimationObject | StyleLayoutAnimation, // type that's supposed to be returned
 U extends AnimationObject | StyleLayoutAnimation = T>(starting: AnimationToDecoration<T, U>, factory: () => T): T;
 export declare function cancelAnimation<T>(sharedValue: SharedValue<T>): void;
-export declare function withStartValue(startValue: AnimatableValue, animation: NextAnimation<AnimationObject>): Animation<AnimationObject>;
 export {};

package/lib/typescript/reanimated2/commonTypes.d.ts

@@ -5,10 +5,6 @@ export interface StyleProps extends ViewStyle, TextStyle {
     originY?: number;
     [key: string]: any;
 }
-export interface AnimatedStyle extends Record<string, AnimationObject> {
-    [key: string]: any;
-    transform?: Array<Record<'matrix', number[] | AnimationObject> | Partial<Record<'perspective' | 'scale' | 'scaleX' | 'scaleY' | 'translateX' | 'translateY', number | AnimationObject>> | Partial<Record<'rotate' | 'rotateX' | 'rotateY' | 'rotateZ' | 'skewX' | 'skewY', string | AnimationObject>> | Record<string, AnimationObject>>;
-}
 export interface SharedValue<T> {
     value: T;
     addListener: (listenerID: number, listener: (value: T) => void) => void;

package/lib/typescript/reanimated2/component/FlatList.d.ts

@@ -6,10 +6,11 @@ import type { AnimateProps } from '../helperTypes';
 interface ReanimatedFlatListPropsWithLayout<T> extends FlatListProps<T> {
     itemLayoutAnimation?: ILayoutAnimationBuilder;
 }
+export type FlatListPropsWithLayout<T> = ReanimatedFlatListPropsWithLayout<T>;
 declare class ReanimatedFlatListClass<T> extends Component<AnimateProps<ReanimatedFlatListPropsWithLayout<T>>> {
     getNode(): FlatList;
 }
-export interface ReanimatedFlatListProps<ItemT> extends FlatListProps<ItemT> {
+interface ReanimatedFlatListProps<ItemT> extends FlatListProps<ItemT> {
     itemLayoutAnimation?: ILayoutAnimationBuilder;
 }
 export declare const ReanimatedFlatList: React.ForwardRefExoticComponent<ReanimatedFlatListProps<any> & React.RefAttributes<FlatList<any>>>;

package/lib/typescript/reanimated2/component/ScrollView.d.ts

@@ -3,7 +3,7 @@ import type { ScrollViewProps } from 'react-native';
 import { ScrollView } from 'react-native';
 import type { SharedValue } from '../commonTypes';
 import type { AnimateProps } from '../helperTypes';
-interface AnimatedScrollViewProps extends ScrollViewProps {
+export interface AnimatedScrollViewProps extends ScrollViewProps {
     scrollViewOffset?: SharedValue<number>;
 }
 declare class AnimatedScrollViewClass extends Component<AnimateProps<AnimatedScrollViewProps>> {

package/lib/typescript/reanimated2/helperTypes.d.ts

@@ -3,29 +3,33 @@ import type { AnimatableValue, BaseAnimationBuilder, EntryExitAnimationFunction,
 import type { ReanimatedKeyframe } from './layoutReanimation/animationBuilder/Keyframe';
 import type { SharedTransition } from './layoutReanimation/sharedTransitions';
 import type { DependencyList } from './hook/commonTypes';
-type Adaptable<T> = T | ReadonlyArray<T | ReadonlyArray<T>> | SharedValue<T>;
-type AdaptTransforms<T> = {
+export type Adaptable<T> = T | ReadonlyArray<T | ReadonlyArray<T>> | SharedValue<T>;
+export type AdaptTransforms<T> = {
     [P in keyof T]: Adaptable<T[P]>;
 };
 type TransformsStyle = Pick<RNTransformsStyle, 'transform'>;
-type TransformStyleTypes = TransformsStyle['transform'] extends readonly (infer T)[] | undefined ? T : never;
-type AnimatedTransform = AdaptTransforms<TransformStyleTypes>[];
+export type TransformStyleTypes = TransformsStyle['transform'] extends readonly (infer T)[] | string | undefined ? T : never;
+export type AnimatedTransform = AdaptTransforms<TransformStyleTypes>[];
+/**
+ * @deprecated Please use `AnimatedStyle` type instead.
+ */
 export type AnimateStyle<S> = {
     [K in keyof S]: K extends 'transform' ? AnimatedTransform : S[K] extends ReadonlyArray<any> ? ReadonlyArray<AnimateStyle<S[K][0]>> : S[K] extends object ? AnimateStyle<S[K]> : S[K] extends ColorValue | undefined ? S[K] | number : S[K] | SharedValue<AnimatableValue>;
 };
+export type AnimatedStyle<S> = AnimateStyle<S>;
 type MaybeSharedValue<S> = {
     [K in keyof S]: S[K] | Readonly<SharedValue<Extract<S[K], AnimatableValue>>>;
 };
-type StylesOrDefault<T> = 'style' extends keyof T ? MaybeSharedValue<T['style']> : Record<string, unknown>;
+export type StylesOrDefault<T> = 'style' extends keyof T ? MaybeSharedValue<T['style']> : Record<string, unknown>;
 type EntryOrExitLayoutType = BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | ReanimatedKeyframe;
 type PickStyleProps<T> = Pick<T, {
     [Key in keyof T]-?: Key extends `${string}Style` ? Key : never;
 }[keyof T]>;
 type StyleAnimatedProps<P extends object> = {
-    [K in keyof PickStyleProps<P>]: StyleProp<AnimateStyle<P[K] | MaybeSharedValue<P[K]>>>;
+    [K in keyof PickStyleProps<P>]: StyleProp<AnimatedStyle<P[K] | MaybeSharedValue<P[K]>>>;
 };
 type JustStyleAnimatedProp<P extends object> = {
-    style?: StyleProp<AnimateStyle<StylesOrDefault<P>>>;
+    style?: StyleProp<AnimatedStyle<StylesOrDefault<P>>>;
 };
 type NonStyleAnimatedProps<P extends object> = {
     [K in keyof Omit<P, keyof PickStyleProps<P> | 'style'>]: P[K] | SharedValue<P[K]>;

package/lib/typescript/reanimated2/hook/commonTypes.d.ts

@@ -1,3 +1,4 @@
+import type { Component } from 'react';
 import type { Context, ShadowNodeWrapper } from '../commonTypes';
 export type DependencyList = Array<unknown> | undefined;
 export interface ContextWithDependencies<TContext extends Context> {
@@ -9,8 +10,7 @@ export interface Descriptor {
     name: string;
     shadowNodeWrapper: ShadowNodeWrapper;
 }
-export interface RefObjectFunction<T> {
+export interface AnimatedRef<T extends Component> {
     current: T | null;
     (component?: T): number | ShadowNodeWrapper | HTMLElement;
 }
-export type AnimatedRef<T> = RefObjectFunction<T>;

package/lib/typescript/reanimated2/hook/index.d.ts

@@ -3,7 +3,7 @@ export { useAnimatedProps, useEvent, useHandler, useWorkletCallback, } from './H
 export { useSharedValue } from './useSharedValue';
 export { useReducedMotion } from './useReducedMotion';
 export { useAnimatedStyle } from './useAnimatedStyle';
-export type { AnimatedStyleResult } from './useAnimatedStyle';
+export type { AnimatedStyleResult, AnimatedStyleProp, } from './useAnimatedStyle';
 export { useAnimatedGestureHandler } from './useAnimatedGestureHandler';
 export type { GestureHandlerEvent, GestureHandlers, } from './useAnimatedGestureHandler';
 export { useAnimatedReaction } from './useAnimatedReaction';

package/lib/typescript/reanimated2/hook/useAnimatedGestureHandler.d.ts

@@ -12,7 +12,7 @@ export interface GestureHandlers<T, TContext extends Context> {
     onCancel?: Handler<T, TContext>;
     onFinish?: Handler<T, TContext>;
 }
-export declare const EventType: {
+declare const EventType: {
     UNDETERMINED: number;
     FAILED: number;
     BEGAN: number;
@@ -20,7 +20,7 @@ export declare const EventType: {
     ACTIVE: number;
     END: number;
 };
-export interface GestureHandlerNativeEvent {
+interface GestureHandlerNativeEvent {
     handlerTag: number;
     numberOfPointers: number;
     state: (typeof EventType)[keyof typeof EventType];

package/lib/typescript/reanimated2/hook/useAnimatedRef.d.ts

@@ -1,8 +1,8 @@
 import type { Component } from 'react';
 import type { AnimatedRef } from './commonTypes';
-interface ComponentRef extends Component {
-    getNativeScrollRef?: () => ComponentRef;
-    getScrollableNode?: () => ComponentRef;
+interface MaybeScrollableComponent extends Component {
+    getNativeScrollRef?: any;
+    getScrollableNode?: any;
 }
-export declare function useAnimatedRef<T extends ComponentRef>(): AnimatedRef<T>;
+export declare function useAnimatedRef<T extends MaybeScrollableComponent>(): AnimatedRef<T>;
 export {};

package/lib/typescript/reanimated2/hook/useAnimatedStyle.d.ts

@@ -1,16 +1,15 @@
 import type { MutableRefObject } from 'react';
 import type { DependencyList } from './commonTypes';
 import type { ViewDescriptorsSet, ViewRefSet } from '../ViewDescriptorsSet';
-import type { AnimatedStyle } from '../commonTypes';
 import type { ImageStyle, RegisteredStyle, TextStyle, ViewStyle } from 'react-native';
-import type { AnimateStyle } from '../helperTypes';
+import type { AnimatedStyle } from '../helperTypes';
 export interface AnimatedStyleResult {
     viewDescriptors: ViewDescriptorsSet;
-    initial: AnimatedStyle;
+    initial: AnimatedStyle<any>;
     viewsRef: ViewRefSet<any>;
-    animatedStyle?: MutableRefObject<AnimatedStyle>;
+    animatedStyle?: MutableRefObject<AnimatedStyle<any>>;
 }
-type AnimatedStyleProp<T> = AnimateStyle<T> | RegisteredStyle<AnimateStyle<T>>;
+export type AnimatedStyleProp<T> = AnimatedStyle<T> | RegisteredStyle<AnimatedStyle<T>>;
 type useAnimatedStyleType = <T extends AnimatedStyleProp<ViewStyle | ImageStyle | TextStyle>>(updater: () => T, deps?: DependencyList | null) => T;
 export declare const useAnimatedStyle: useAnimatedStyleType;
 export {};

package/lib/typescript/reanimated2/hook/utils.d.ts

@@ -1,4 +1,5 @@
-import type { AnimatedStyle, Context, NestedObjectValues, WorkletFunction, AnimationObject } from '../commonTypes';
+import type { Context, NestedObjectValues, WorkletFunction, AnimationObject } from '../commonTypes';
+import type { AnimatedStyle } from '../helperTypes';
 import type { DependencyList } from './commonTypes';
 import type { NativeSyntheticEvent } from 'react-native';
 interface Handler<T, TContext extends Context> extends WorkletFunction {
@@ -7,11 +8,6 @@ interface Handler<T, TContext extends Context> extends WorkletFunction {
 interface Handlers<T, TContext extends Context> {
     [key: string]: Handler<T, TContext> | undefined;
 }
-export interface UseHandlerContext<TContext extends Context> {
-    context: TContext;
-    doDependenciesDiffer: boolean;
-    useWeb: boolean;
-}
 type useEventType = <T extends object>(handler: (e: T) => void, eventNames?: string[], rebuild?: boolean) => (e: NativeSyntheticEvent<T>) => void;
 export declare const useEvent: useEventType;
 type useHandlerType = <T, TContext extends Context = Record<string, never>>(handlers: Handlers<T, TContext>, deps?: DependencyList) => {
@@ -21,11 +17,7 @@ type useHandlerType = <T, TContext extends Context = Record<string, never>>(hand
 };
 export declare const useHandler: useHandlerType;
 export declare function buildWorkletsHash(handlers: Record<string, WorkletFunction> | Array<WorkletFunction>): string;
-export declare function buildDependencies(dependencies: DependencyList, handlers: Record<string, WorkletFunction | undefined>): Array<unknown>;
-export declare function areDependenciesEqual(nextDeps: DependencyList, prevDeps: DependencyList): boolean;
-export declare function hasColorProps(updates: AnimatedStyle): boolean;
-export declare function parseColors(updates: AnimatedStyle): void;
 export declare function isAnimated(prop: NestedObjectValues<AnimationObject>): boolean;
 export declare function shallowEqual(a: any, b: any): boolean;
-export declare const validateAnimatedStyles: (styles: AnimatedStyle) => void;
+export declare const validateAnimatedStyles: (styles: AnimatedStyle<any>) => void;
 export {};

package/lib/typescript/reanimated2/index.d.ts

@@ -14,4 +14,6 @@ export * from './commonTypes';
 export * from './frameCallback';
 export * from './pluginUtils';
 export * from './jestUtils';
-export type { AnimateProps } from './helperTypes';
+export type { Adaptable, AdaptTransforms, AnimateProps, AnimatedProps, AnimatedTransform, TransformStyleTypes, AnimateStyle, AnimatedStyle, StylesOrDefault, } from './helperTypes';
+export type { AnimatedScrollViewProps } from './component/ScrollView';
+export type { FlatListPropsWithLayout } from './component/FlatList';

package/lib/typescript/reanimated2/interpolateColor.d.ts

@@ -8,13 +8,13 @@ export type InterpolationOptions = {
     gamma?: number;
     useCorrectedHSVInterpolation?: boolean;
 };
-interface InterpolateRGB {
+export interface InterpolateRGB {
     r: number[];
     g: number[];
     b: number[];
     a: number[];
 }
-interface InterpolateHSV {
+export interface InterpolateHSV {
     h: number[];
     s: number[];
     v: number[];
@@ -35,4 +35,3 @@ export interface InterpolateConfig {
 }
 export declare function useInterpolateConfig(inputRange: readonly number[], outputRange: readonly (string | number)[], colorSpace?: ColorSpace, options?: InterpolationOptions): SharedValue<InterpolateConfig>;
 export declare const interpolateSharableColor: (value: number, interpolateConfig: SharedValue<InterpolateConfig>) => string | number;
-export {};

package/lib/typescript/reanimated2/js-reanimated/commonTypes.d.ts

@@ -1,43 +1 @@
-import type { Timestamp, NestedObjectValues } from '../commonTypes';
-import type MutableValue from './MutableValue';
-export interface Mapper<T> {
-    MAPPER_ID?: number;
-    id: number;
-    inputs: MutableValue<T>[];
-    outputs: MutableValue<T>[];
-    mapper: () => void;
-    dirty: boolean;
-    execute(): void;
-    extractMutablesFromArray<T>(array: NestedObjectValues<MutableValue<T>>): MutableValue<T>[];
-}
-export interface MapperRegistry<T> {
-    sortedMappers: Mapper<T>[];
-    mappers: Map<number, Mapper<T>>;
-    _module: JSReanimated;
-    updatedSinceLastExecute: boolean;
-    startMapper(mapper: Mapper<T>): number;
-    stopMapper(id: number): void;
-    execute(): void;
-    updateOrder(): void;
-}
-export interface JSReanimated {
-    _valueSetter?: <T>(value: T) => void;
-    _renderRequested: boolean;
-    _mapperRegistry: MapperRegistry<any>;
-    _frames: ((timestamp: Timestamp) => void)[];
-    timeProvider: {
-        now: () => number;
-    };
-    pushFrame(frame: (timestamp: Timestamp) => void): void;
-    maybeRequestRender(): void;
-    _onRender(timestampMs: number): void;
-    installCoreFunctions(valueSetter: <T>(value: T) => void): void;
-    makeShareable<T>(value: T): T;
-    makeMutable<T>(value: T): MutableValue<T>;
-    makeRemote<T>(object: Record<string, any>): T;
-    startMapper(mapper: () => void, inputs: NestedObjectValues<MutableValue<unknown>>[], outputs: NestedObjectValues<MutableValue<unknown>>[]): number;
-    stopMapper(mapperId: number): void;
-    registerEventHandler<T>(_: string, __: (event: T) => void): string;
-    unregisterEventHandler(_: string): void;
-    enableLayoutAnimations(): void;
-}
+export {};

package/lib/typescript/reanimated2/js-reanimated/index.d.ts

@@ -1,5 +1,6 @@
 import JSReanimated from './JSReanimated';
-import type { AnimatedStyle, StyleProps } from '../commonTypes';
+import type { StyleProps } from '../commonTypes';
+import type { AnimatedStyle } from '../helperTypes';
 declare const reanimatedJS: JSReanimated;
 interface JSReanimatedComponent {
     previousStyle: StyleProps;
@@ -10,7 +11,7 @@ interface JSReanimatedComponent {
         setAttribute: (key: string, props: unknown) => void;
     };
 }
-export declare const _updatePropsJS: (updates: StyleProps | AnimatedStyle, viewRef: {
+export declare const _updatePropsJS: (updates: StyleProps | AnimatedStyle<any>, viewRef: {
     _component?: JSReanimatedComponent;
 }) => void;
 export default reanimatedJS;