@react-native-ama/animations 1.2.0 → 2.0.0-beta.0

package/dist/hooks/useAnimation.js

@@ -35,12 +35,12 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useAnimation = void 0;
-const core_1 = require("@react-native-ama/core");
-const internal_1 = require("@react-native-ama/internal");
+const useAMAContextSafe_1 = require("../internals/useAMAContextSafe");
+const animationStates_1 = require("../internals/animationStates");
 const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
 const useAnimation = ({ duration, useNativeDriver, from, to, skipIfReduceMotionEnabled = false, }) => {
-    const { isReduceMotionEnabled } = (0, core_1.useAMAContext)();
+    const { isReduceMotionEnabled } = (0, useAMAContextSafe_1.useAMAContextSafe)();
     const progress = React.useRef(new react_native_1.Animated.Value(0)).current;
     const reduceMotionProgress = React.useRef(new react_native_1.Animated.Value(0)).current;
     const hasOnlyMotionAnimation = React.useRef(false);
@@ -62,7 +62,7 @@ const useAnimation = ({ duration, useNativeDriver, from, to, skipIfReduceMotionE
             useNativeDriver,
         });
     };
-    const _a = (0, internal_1.interpolateAnimationStates)(from, to, isReduceMotionEnabled, progress, reduceMotionProgress), { __hasOnlyMotionAnimation } = _a, style = __rest(_a, ["__hasOnlyMotionAnimation"]);
+    const _a = (0, animationStates_1.interpolateAnimationStates)(from, to, isReduceMotionEnabled, progress, reduceMotionProgress), { __hasOnlyMotionAnimation } = _a, style = __rest(_a, ["__hasOnlyMotionAnimation"]);
     hasOnlyMotionAnimation.current = __hasOnlyMotionAnimation;
     return {
         animatedStyle: style,

package/dist/hooks/useAnimationDuration.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useAnimationDuration = void 0;
-const core_1 = require("@react-native-ama/core");
+const useAMAContextSafe_1 = require("../internals/useAMAContextSafe");
 const react_1 = __importDefault(require("react"));
 const isMotionAnimation_1 = require("../utils/isMotionAnimation");
 const useAnimationDuration = () => {
-    const { isReduceMotionEnabled } = (0, core_1.useAMAContext)();
+    const { isReduceMotionEnabled } = (0, useAMAContextSafe_1.useAMAContextSafe)();
     const getAnimationDuration = react_1.default.useCallback((propertyToAnimate, duration) => {
         return isReduceMotionEnabled && (0, isMotionAnimation_1.isMotionAnimation)(propertyToAnimate)
             ? 0

package/dist/hooks/useReanimatedAnimationBuilder.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReanimatedAnimationBuilder = void 0;
-const core_1 = require("@react-native-ama/core");
-const internal_1 = require("@react-native-ama/internal");
+const useAMAContextSafe_1 = require("../internals/useAMAContextSafe");
+const animationConstants_1 = require("../internals/animationConstants");
 const react_native_reanimated_1 = require("react-native-reanimated");
 const useReanimatedAnimationBuilder = ({ from, to, exitFrom, exitTo, duration, }) => {
-    const { isReduceMotionEnabled } = (0, core_1.useAMAContext)();
+    const { isReduceMotionEnabled } = (0, useAMAContextSafe_1.useAMAContextSafe)();
     const animationBuilder = (initial, final) => {
         return (values) => {
             'worklet';
@@ -18,7 +18,7 @@ const useReanimatedAnimationBuilder = ({ from, to, exitFrom, exitTo, duration, }
                     // @ts-ignore
                     typeof toValue === 'string' ? values[toValue] || 0 : toValue;
                     const realDuration = isReduceMotionEnabled &&
-                        internal_1.MOTION_ANIMATIONS.includes(key)
+                        animationConstants_1.MOTION_ANIMATIONS.includes(key)
                         ? 0
                         : duration;
                     const newValue = Array.isArray(value)

package/dist/hooks/useReanimatedTiming.d.ts

@@ -1,4 +1,4 @@
-import type { MotionAnimationKey } from '@react-native-ama/internal';
+import type { MotionAnimationKey } from '../internals/animationConstants';
 import { AnimationCallback, WithSpringConfig, WithTimingConfig } from 'react-native-reanimated';
 export declare const useReanimatedTiming: () => {
     withTiming: (propertyKey: MotionAnimationKey, toValue: number, config?: WithTimingConfig, callback?: AnimationCallback) => number;

package/dist/hooks/useReanimatedTiming.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReanimatedTiming = void 0;
-const core_1 = require("@react-native-ama/core");
+const useAMAContextSafe_1 = require("../internals/useAMAContextSafe");
 const react_1 = __importDefault(require("react"));
 const react_native_reanimated_1 = require("react-native-reanimated");
 const isMotionAnimation_1 = require("../utils/isMotionAnimation");
 const useReanimatedTiming = () => {
-    const { isReduceMotionEnabled } = (0, core_1.useAMAContext)();
+    const { isReduceMotionEnabled } = (0, useAMAContextSafe_1.useAMAContextSafe)();
     const withTiming = react_1.default.useCallback((propertyKey, toValue, config = {}, callback) => {
         if (isReduceMotionEnabled && (0, isMotionAnimation_1.isMotionAnimation)(propertyKey)) {
             config.duration = 0;

package/dist/internals/animationConstants.d.ts

@@ -0,0 +1,3 @@
+import type { ViewStyle } from 'react-native';
+export type MotionAnimationKey = Partial<keyof ViewStyle> | 'scale';
+export declare const MOTION_ANIMATIONS: MotionAnimationKey[];

package/dist/internals/animationConstants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTION_ANIMATIONS = void 0;
+exports.MOTION_ANIMATIONS = [
+    'left',
+    'bottom',
+    'top',
+    'right',
+    'transform',
+    'translateX',
+    'translateY',
+    'scaleX',
+    'scaleY',
+    'scale',
+    'width',
+    'height',
+    'padding',
+    'paddingBottom',
+    'paddingLeft',
+    'paddingRight',
+    'paddingTop',
+    'paddingVertical',
+    'paddingHorizontal',
+    'margin',
+    'marginBottom',
+    'marginLeft',
+    'marginRight',
+    'marginTop',
+    'marginHorizontal',
+    'marginVertical',
+    'rotation',
+];

package/dist/internals/animationStates.d.ts

@@ -0,0 +1,2 @@
+import type { Animated } from 'react-native';
+export declare const interpolateAnimationStates: (from: Record<string, any>, to: Record<string, any>, isReduceMotionEnabled: boolean, progressValue: Animated.Value, reduceMotionProgressValue: Animated.Value) => Record<string, any>;

package/dist/internals/animationStates.js

@@ -0,0 +1,43 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateAnimationStates = void 0;
+const animationConstants_1 = require("./animationConstants");
+const interpolateAnimationStates = (from, to, isReduceMotionEnabled, progressValue, reduceMotionProgressValue) => {
+    return Object.keys(from).reduce((outputAnimation, key) => {
+        const isMotionAnimation = animationConstants_1.MOTION_ANIMATIONS.includes(key);
+        const progressKey = isReduceMotionEnabled && isMotionAnimation
+            ? reduceMotionProgressValue
+            : progressValue;
+        if (Array.isArray(from[key])) {
+            outputAnimation[key] = from[key].map((animationObject, index) => {
+                const _a = (0, exports.interpolateAnimationStates)(animationObject, to[key][index], isReduceMotionEnabled, progressValue, reduceMotionProgressValue), { __hasOnlyMotionAnimation } = _a, style = __rest(_a, ["__hasOnlyMotionAnimation"]);
+                outputAnimation.__hasOnlyMotionAnimation =
+                    outputAnimation.__hasOnlyMotionAnimation &&
+                        __hasOnlyMotionAnimation;
+                return style;
+            });
+        }
+        else {
+            outputAnimation[key] = progressKey.interpolate({
+                inputRange: [0, 1],
+                // @ts-ignore
+                outputRange: [from[key], to[key]],
+            });
+            outputAnimation.__hasOnlyMotionAnimation =
+                outputAnimation.__hasOnlyMotionAnimation && isMotionAnimation;
+        }
+        return outputAnimation;
+    }, { __hasOnlyMotionAnimation: true });
+};
+exports.interpolateAnimationStates = interpolateAnimationStates;

package/dist/internals/useAMAContextSafe.d.ts

@@ -0,0 +1,3 @@
+export declare const useAMAContextSafe: () => {
+    isReduceMotionEnabled: boolean;
+};

package/dist/internals/useAMAContextSafe.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAMAContextSafe = void 0;
+const AMACore = require('@react-native-ama/core');
+const SAFE_DEFAULTS = {
+    isReduceMotionEnabled: false,
+};
+const useAMAContextSafe = () => {
+    var _a, _b;
+    try {
+        return (_b = (_a = AMACore === null || AMACore === void 0 ? void 0 : AMACore.useAMAContext) === null || _a === void 0 ? void 0 : _a.call(AMACore)) !== null && _b !== void 0 ? _b : SAFE_DEFAULTS;
+    }
+    catch (_c) {
+        return SAFE_DEFAULTS;
+    }
+};
+exports.useAMAContextSafe = useAMAContextSafe;

package/dist/utils/isMotionAnimation.d.ts

@@ -1,2 +1,2 @@
-import { type MotionAnimationKey } from '@react-native-ama/internal';
+import { type MotionAnimationKey } from '../internals/animationConstants';
 export declare const isMotionAnimation: (key: MotionAnimationKey) => boolean;

package/dist/utils/isMotionAnimation.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMotionAnimation = void 0;
-const internal_1 = require("@react-native-ama/internal");
+const animationConstants_1 = require("../internals/animationConstants");
 const isMotionAnimation = (key) => {
-    return internal_1.MOTION_ANIMATIONS.includes(key);
+    return animationConstants_1.MOTION_ANIMATIONS.includes(key);
 };
 exports.isMotionAnimation = isMotionAnimation;

package/package.json

@@ -1,33 +1,53 @@
 {
   "name": "@react-native-ama/animations",
-  "version": "1.2.0",
-  "react-native": "src/index",
-  "types": "dist/index.d.ts",
-  "main": "dist/index.js",
+  "version": "2.0.0-beta.0",
+  "sideEffects": false,
   "exports": {
-    ".": [
-      {
-        "imports": "./dist/index.js",
-        "types": "./dist/index.d.ts"
-      },
-      "./dist/index.js"
-    ]
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./AnimatedContainer": {
+      "types": "./dist/components/AnimatedContainer.d.ts",
+      "default": "./dist/components/AnimatedContainer.js"
+    },
+    "./useAnimation": {
+      "types": "./dist/hooks/useAnimation.d.ts",
+      "default": "./dist/hooks/useAnimation.js"
+    },
+    "./useAnimationDuration": {
+      "types": "./dist/hooks/useAnimationDuration.d.ts",
+      "default": "./dist/hooks/useAnimationDuration.js"
+    },
+    "./useReanimatedAnimationBuilder": {
+      "types": "./dist/hooks/useReanimatedAnimationBuilder.d.ts",
+      "default": "./dist/hooks/useReanimatedAnimationBuilder.js"
+    },
+    "./useReanimatedTiming": {
+      "types": "./dist/hooks/useReanimatedTiming.d.ts",
+      "default": "./dist/hooks/useReanimatedTiming.js"
+    }
   },
   "files": [
     "src",
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p ./tsconfig.build.json",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@react-native-ama/core": "~1.2.0",
-    "@react-native-ama/internal": "~1.2.0"
+    "build": "rm -rf dist && ../../node_modules/.bin/tsc -p ./tsconfig.build.json",
+    "typecheck": "../../node_modules/.bin/tsc --noEmit",
+    "test": "jest"
   },
   "peerDependencies": {
+    "@react-native-ama/core": "~2.0.0-beta.0",
     "react": "*",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-reanimated": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-ama/core": {
+      "optional": true
+    }
   },
   "keywords": [
     "react-native",
@@ -47,5 +67,45 @@
     "provenance": true
   },
   "author": "",
-  "license": "MIT"
+  "license": "MIT",
+  "jest": {
+    "preset": "react-native",
+    "setupFilesAfterEnv": [
+      "<rootDir>/jest.setup.js"
+    ],
+    "modulePathIgnorePatterns": [
+      "<rootDir>/node_modules",
+      "<rootDir>/dist/"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{ts,tsx}",
+      "!src/index.ts"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "statements": 100,
+        "branches": 95,
+        "functions": 100,
+        "lines": 100
+      }
+    },
+    "transformIgnorePatterns": [
+      "node_modules/(?!(react-native-reanimated|expo|@expo)/)"
+    ],
+    "transform": {
+      "\\.[jt]sx?$": "babel-jest"
+    },
+    "moduleDirectories": [
+      "node_modules",
+      "../../playground/node_modules"
+    ],
+    "moduleNameMapper": {
+      "@react-native/js-polyfills/error-guard": "<rootDir>/../../jest-mocks/error-guard.js",
+      "^(\\.{1,2}/)*ama\\.config\\.json$": "<rootDir>/../../jest-mocks/ama-config.js",
+      "^(\\.{1,2}/)*ReactNativeAmaModule$": "<rootDir>/../../jest-mocks/ReactNativeAmaModule.js",
+      "^(\\.{1,2}/)*ReactNativeAmaView(\\.web)?$": "<rootDir>/../../jest-mocks/ReactNativeAmaModule.js",
+      "^@react-native-ama/core$": "<rootDir>/../../jest-mocks/ama-core.js"
+    },
+    "verbose": true
+  }
 }

package/src/components/AnimatedContainer.test.tsx

@@ -1,7 +1,6 @@
 import { AutofocusContainer } from '@react-native-ama/core';
 import { render } from '@testing-library/react-native';
 import * as React from 'react';
-
 import * as UseReanimatedAnimationBuilder from '../hooks/useReanimatedAnimationBuilder';
 import { AnimatedContainer } from './AnimatedContainer';
 
@@ -27,14 +26,16 @@ describe('AnimatedContainer', () => {
     expect(useReanimatedAnimationBuilder).toHaveBeenCalledWith({
       from,
       to,
+      exitFrom: undefined,
+      exitTo: undefined,
       duration: 300,
-      exit: undefined,
     });
 
     expect(getByTestId('test-id').props).toEqual({
       children: undefined,
       entering: 'entering',
       exiting: 'exiting',
+      ref: null,
       style: undefined,
       testID: 'test-id',
     });
@@ -52,14 +53,16 @@ describe('AnimatedContainer', () => {
     expect(useReanimatedAnimationBuilder).toHaveBeenCalledWith({
       from,
       to,
+      exitFrom: undefined,
+      exitTo: undefined,
       duration: 600,
-      exit: undefined,
     });
 
     expect(getByTestId('test-id').props).toEqual({
       children: undefined,
       entering: 'entering',
       exiting: 'exiting',
+      ref: null,
       style: undefined,
       testID: 'test-id',
     });
@@ -81,15 +84,6 @@ describe('AnimatedContainer', () => {
 });
 
 jest.mock('../hooks/useReanimatedAnimationBuilder');
-jest.mock('../hooks/useFocus', () => {
-  return {
-    useFocus: () => {
-      return {
-        setFocus: jest.fn(),
-      };
-    },
-  };
-});
 
 jest.mock('react-native-reanimated', () => {
   const { View } = require('react-native');

package/src/components/AnimatedContainer.tsx

@@ -3,7 +3,6 @@ import * as React from 'react';
 import type { PropsWithChildren } from 'react';
 import type { ViewProps } from 'react-native';
 import Animated, { AnimateProps } from 'react-native-reanimated';
-
 import {
   AnimatedEntryViewStyle,
   AnimatedExitViewStyle,
@@ -55,7 +54,8 @@ export const AnimatedContainer = React.forwardRef<
           entering={entering}
           exiting={exiting}
           ref={forwardRef}
-          {...rest}>
+          {...rest}
+        >
           {children}
         </Animated.View>
       </Wrapper>

package/src/hooks/useAnimation.test.ts

@@ -1,7 +1,6 @@
 import * as AMAProvider from '@react-native-ama/core';
 import { renderHook } from '@testing-library/react-native';
 import { Animated } from 'react-native';
-
 import { useAnimation } from './useAnimation';
 
 beforeEach(() => {

package/src/hooks/useAnimation.ts

@@ -1,5 +1,5 @@
-import { useAMAContext } from '@react-native-ama/core';
-import { interpolateAnimationStates } from '@react-native-ama/internal';
+import { useAMAContextSafe } from '../internals/useAMAContextSafe';
+import { interpolateAnimationStates } from '../internals/animationStates';
 import * as React from 'react';
 import type { ViewStyle } from 'react-native';
 import { Animated } from 'react-native';
@@ -19,7 +19,7 @@ export const useAnimation = ({
   to,
   skipIfReduceMotionEnabled = false,
 }: UseAnimation) => {
-  const { isReduceMotionEnabled } = useAMAContext();
+  const { isReduceMotionEnabled } = useAMAContextSafe();
   const progress = React.useRef(new Animated.Value(0)).current;
   const reduceMotionProgress = React.useRef(new Animated.Value(0)).current;
   const hasOnlyMotionAnimation = React.useRef(false);

package/src/hooks/useAnimationDuration.test.ts

@@ -1,6 +1,5 @@
 import * as AMAProvider from '@react-native-ama/core';
 import { renderHook } from '@testing-library/react-native';
-
 import { useAnimationDuration } from './useAnimationDuration';
 
 describe('useAnimationDuration', () => {

package/src/hooks/useAnimationDuration.ts

@@ -1,11 +1,10 @@
-import { useAMAContext } from '@react-native-ama/core';
+import { useAMAContextSafe } from '../internals/useAMAContextSafe';
 import React from 'react';
 import type { ViewStyle } from 'react-native';
-
 import { isMotionAnimation } from '../utils/isMotionAnimation';
 
 export const useAnimationDuration = () => {
-  const { isReduceMotionEnabled } = useAMAContext();
+  const { isReduceMotionEnabled } = useAMAContextSafe();
 
   const getAnimationDuration = React.useCallback(
     (propertyToAnimate: keyof ViewStyle, duration: number) => {

package/src/hooks/useReanimatedAnimationBuilder.test.ts

@@ -1,13 +1,12 @@
 import * as AMAProvider from '@react-native-ama/core';
 import { renderHook } from '@testing-library/react-native';
-
 import { useReanimatedAnimationBuilder } from './useReanimatedAnimationBuilder';
 
 beforeEach(() => {
   jest.clearAllMocks();
 });
 
-let withTiming: jest.Mock;
+var withTiming: jest.Mock;
 
 describe('useReanimatedAnimationBuilder', () => {
   describe('entering animation', () => {

package/src/hooks/useReanimatedAnimationBuilder.ts

@@ -1,5 +1,5 @@
-import { useAMAContext } from '@react-native-ama/core';
-import { MOTION_ANIMATIONS } from '@react-native-ama/internal';
+import { useAMAContextSafe } from '../internals/useAMAContextSafe';
+import { MOTION_ANIMATIONS } from '../internals/animationConstants';
 import type { ViewProps, ViewStyle } from 'react-native';
 import {
   EntryAnimationsValues,
@@ -26,7 +26,7 @@ export const useReanimatedAnimationBuilder = ({
   exitTo,
   duration,
 }: UseReanimatedAnimationBuilder) => {
-  const { isReduceMotionEnabled } = useAMAContext();
+  const { isReduceMotionEnabled } = useAMAContextSafe();
 
   const animationBuilder = <InitialValues, FinalValues>(
     initial: InitialValues,

package/src/hooks/useReanimatedTiming.test.ts

@@ -1,7 +1,6 @@
 import * as AMAProvider from '@react-native-ama/core';
-import { MOTION_ANIMATIONS } from '@react-native-ama/internal';
+import { MOTION_ANIMATIONS } from '../internals/animationConstants';
 import { renderHook } from '@testing-library/react-native';
-
 import { useReanimatedTiming } from './useReanimatedTiming';
 
 beforeEach(() => {
@@ -79,8 +78,8 @@ const amaContextValues = {
   isScreenReaderEnabled: false,
 };
 
-let withSpring: jest.Mock;
-let withTiming: jest.Mock;
+var withSpring: jest.Mock;
+var withTiming: jest.Mock;
 
 function mockReanimated() {
   withSpring = jest.fn();

package/src/hooks/useReanimatedTiming.ts

@@ -1,5 +1,5 @@
-import { useAMAContext } from '@react-native-ama/core';
-import type { MotionAnimationKey } from '@react-native-ama/internal';
+import type { MotionAnimationKey } from '../internals/animationConstants';
+import { useAMAContextSafe } from '../internals/useAMAContextSafe';
 import React from 'react';
 import {
   AnimationCallback,
@@ -8,11 +8,10 @@ import {
   WithSpringConfig,
   WithTimingConfig,
 } from 'react-native-reanimated';
-
 import { isMotionAnimation } from '../utils/isMotionAnimation';
 
 export const useReanimatedTiming = () => {
-  const { isReduceMotionEnabled } = useAMAContext();
+  const { isReduceMotionEnabled } = useAMAContextSafe();
 
   const withTiming = React.useCallback(
     (

package/src/internals/animationConstants.ts

@@ -0,0 +1,33 @@
+import type { ViewStyle } from 'react-native';
+
+export type MotionAnimationKey = Partial<keyof ViewStyle> | 'scale';
+
+export const MOTION_ANIMATIONS: MotionAnimationKey[] = [
+  'left',
+  'bottom',
+  'top',
+  'right',
+  'transform',
+  'translateX',
+  'translateY',
+  'scaleX',
+  'scaleY',
+  'scale',
+  'width',
+  'height',
+  'padding',
+  'paddingBottom',
+  'paddingLeft',
+  'paddingRight',
+  'paddingTop',
+  'paddingVertical',
+  'paddingHorizontal',
+  'margin',
+  'marginBottom',
+  'marginLeft',
+  'marginRight',
+  'marginTop',
+  'marginHorizontal',
+  'marginVertical',
+  'rotation',
+];

package/src/internals/animationStates.test.ts

@@ -0,0 +1,71 @@
+import { Animated } from 'react-native';
+import { interpolateAnimationStates } from './animationStates';
+
+const makeValue = () => {
+  const value = new Animated.Value(0);
+  // react-native mock exposes .interpolate; ensure it returns something
+  return value;
+};
+
+describe('interpolateAnimationStates', () => {
+  it('interpolates scalar properties using the progress value', () => {
+    const progress = makeValue();
+    const reduceMotionProgress = makeValue();
+    const result = interpolateAnimationStates(
+      { opacity: 0 },
+      { opacity: 1 },
+      false,
+      progress,
+      reduceMotionProgress,
+    );
+
+    expect(result).toHaveProperty('opacity');
+    expect(result.__hasOnlyMotionAnimation).toBe(false);
+  });
+
+  it('uses reduceMotionProgressValue for motion properties when reduce motion is enabled', () => {
+    const progress = makeValue();
+    const reduceMotionProgress = makeValue();
+    const result = interpolateAnimationStates(
+      { translateX: 0 },
+      { translateX: 100 },
+      true,
+      progress,
+      reduceMotionProgress,
+    );
+
+    expect(result).toHaveProperty('translateX');
+    expect(result.__hasOnlyMotionAnimation).toBe(true);
+  });
+
+  it('handles array values (transform arrays) recursively', () => {
+    const progress = makeValue();
+    const reduceMotionProgress = makeValue();
+    const result = interpolateAnimationStates(
+      { transform: [{ translateX: 0 }, { scale: 1 }] },
+      { transform: [{ translateX: 100 }, { scale: 2 }] },
+      false,
+      progress,
+      reduceMotionProgress,
+    );
+
+    expect(Array.isArray(result.transform)).toBe(true);
+    expect(result.transform).toHaveLength(2);
+    expect(result.transform[0]).toHaveProperty('translateX');
+    expect(result.transform[1]).toHaveProperty('scale');
+  });
+
+  it('sets __hasOnlyMotionAnimation false when mixing motion and non-motion props', () => {
+    const progress = makeValue();
+    const reduceMotionProgress = makeValue();
+    const result = interpolateAnimationStates(
+      { opacity: 0, translateX: 0 },
+      { opacity: 1, translateX: 100 },
+      false,
+      progress,
+      reduceMotionProgress,
+    );
+
+    expect(result.__hasOnlyMotionAnimation).toBe(false);
+  });
+});

package/src/internals/animationStates.ts

@@ -0,0 +1,55 @@
+import type { Animated, ViewStyle } from 'react-native';
+import { MOTION_ANIMATIONS } from './animationConstants';
+
+export const interpolateAnimationStates = (
+  from: Record<string, any>,
+  to: Record<string, any>,
+  isReduceMotionEnabled: boolean,
+  progressValue: Animated.Value,
+  reduceMotionProgressValue: Animated.Value,
+): Record<string, any> => {
+  return Object.keys(from).reduce(
+    (outputAnimation, key) => {
+      const isMotionAnimation = MOTION_ANIMATIONS.includes(
+        key as keyof ViewStyle,
+      );
+      const progressKey =
+        isReduceMotionEnabled && isMotionAnimation
+          ? reduceMotionProgressValue
+          : progressValue;
+
+      if (Array.isArray(from[key])) {
+        outputAnimation[key] = from[key].map(
+          (animationObject: Record<string, any>, index: number) => {
+            const { __hasOnlyMotionAnimation, ...style } =
+              interpolateAnimationStates(
+                animationObject,
+                to[key][index],
+                isReduceMotionEnabled,
+                progressValue,
+                reduceMotionProgressValue,
+              );
+
+            outputAnimation.__hasOnlyMotionAnimation =
+              outputAnimation.__hasOnlyMotionAnimation &&
+              __hasOnlyMotionAnimation;
+
+            return style;
+          },
+        );
+      } else {
+        outputAnimation[key] = progressKey.interpolate({
+          inputRange: [0, 1],
+          // @ts-ignore
+          outputRange: [from[key], to[key]],
+        });
+
+        outputAnimation.__hasOnlyMotionAnimation =
+          outputAnimation.__hasOnlyMotionAnimation && isMotionAnimation;
+      }
+
+      return outputAnimation;
+    },
+    { __hasOnlyMotionAnimation: true } as Record<string, any>,
+  );
+};

package/src/internals/useAMAContextSafe.test.ts

@@ -0,0 +1,44 @@
+import { renderHook } from '@testing-library/react-native';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  jest.resetModules();
+});
+
+describe('useAMAContextSafe', () => {
+  it('returns isReduceMotionEnabled from core when core is present', () => {
+    jest.doMock('@react-native-ama/core', () => ({
+      useAMAContext: () => ({ isReduceMotionEnabled: true }),
+    }));
+
+    const { useAMAContextSafe: safe } =
+      require('./useAMAContextSafe') as typeof import('./useAMAContextSafe');
+    const { result } = renderHook(() => safe());
+
+    expect(result.current.isReduceMotionEnabled).toBe(true);
+  });
+
+  it('returns isReduceMotionEnabled: false when core is absent', () => {
+    jest.doMock('@react-native-ama/core', () => null);
+
+    const { useAMAContextSafe: safe } =
+      require('./useAMAContextSafe') as typeof import('./useAMAContextSafe');
+    const { result } = renderHook(() => safe());
+
+    expect(result.current.isReduceMotionEnabled).toBe(false);
+  });
+
+  it('returns isReduceMotionEnabled: false when useAMAContext throws', () => {
+    jest.doMock('@react-native-ama/core', () => ({
+      useAMAContext: () => {
+        throw new Error('Please wrap your app with <AMAProvider />');
+      },
+    }));
+
+    const { useAMAContextSafe: safe } =
+      require('./useAMAContextSafe') as typeof import('./useAMAContextSafe');
+    const { result } = renderHook(() => safe());
+
+    expect(result.current.isReduceMotionEnabled).toBe(false);
+  });
+});

package/src/internals/useAMAContextSafe.ts

@@ -0,0 +1,13 @@
+const AMACore = require('@react-native-ama/core');
+
+const SAFE_DEFAULTS = {
+  isReduceMotionEnabled: false,
+};
+
+export const useAMAContextSafe = (): { isReduceMotionEnabled: boolean } => {
+  try {
+    return AMACore?.useAMAContext?.() ?? SAFE_DEFAULTS;
+  } catch {
+    return SAFE_DEFAULTS;
+  }
+};

package/src/utils/isMotionAnimation.ts

@@ -1,7 +1,7 @@
 import {
   MOTION_ANIMATIONS,
   type MotionAnimationKey,
-} from '@react-native-ama/internal';
+} from '../internals/animationConstants';
 
 export const isMotionAnimation = (key: MotionAnimationKey) => {
   return MOTION_ANIMATIONS.includes(key);