react-native-reanimated 3.4.0 → 3.4.2

package/lib/module/reanimated2/platform-specific/checkCppVersion.js.map

@@ -1 +1 @@
-{"version":3,"names":["jsVersion","checkCppVersion","cppVersion","global","_REANIMATED_VERSION_CPP","undefined","Error","ok","matchVersion","version1","version2","match","major1","minor1","split","major2","minor2"],"sources":["checkCppVersion.ts"],"sourcesContent":["import { jsVersion } from './jsVersion';\n\nexport function checkCppVersion() {\n  const cppVersion = global._REANIMATED_VERSION_CPP;\n  if (cppVersion === undefined) {\n    throw new Error(\n      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`\n    );\n  }\n  const ok = matchVersion(jsVersion, cppVersion);\n  if (!ok) {\n    throw new Error(\n      `[Reanimated] Mismatch between JavaScript part (${jsVersion}) and native part of Reanimated (${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`\n    );\n  }\n}\n\nexport function matchVersion(version1: string, version2: string) {\n  if (version1.match(/^\\d+\\.\\d+\\.\\d+$/) && version2.match(/^\\d+\\.\\d+\\.\\d+$/)) {\n    // x.y.z, compare only major and minor, skip patch\n    const [major1, minor1] = version1.split('.');\n    const [major2, minor2] = version2.split('.');\n    return major1 === major2 && minor1 === minor2;\n  } else {\n    // alpha, beta or rc, compare everything\n    return version1 === version2;\n  }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,aAAa;AAEvC,OAAO,SAASC,eAAeA,CAAA,EAAG;EAChC,MAAMC,UAAU,GAAGC,MAAM,CAACC,uBAAuB;EACjD,IAAIF,UAAU,KAAKG,SAAS,EAAE;IAC5B,MAAM,IAAIC,KAAK,CACZ,8OAA6O,CAC/O;EACH;EACA,MAAMC,EAAE,GAAGC,YAAY,CAACR,SAAS,EAAEE,UAAU,CAAC;EAC9C,IAAI,CAACK,EAAE,EAAE;IACP,MAAM,IAAID,KAAK,CACZ,kDAAiDN,SAAU,oCAAmCE,UAAW,4HAA2HA,UAAW,kCAAiC,CAClR;EACH;AACF;AAEA,OAAO,SAASM,YAAYA,CAACC,QAAgB,EAAEC,QAAgB,EAAE;EAC/D,IAAID,QAAQ,CAACE,KAAK,CAAC,iBAAiB,CAAC,IAAID,QAAQ,CAACC,KAAK,CAAC,iBAAiB,CAAC,EAAE;IAC1E;IACA,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGJ,QAAQ,CAACK,KAAK,CAAC,GAAG,CAAC;IAC5C,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGN,QAAQ,CAACI,KAAK,CAAC,GAAG,CAAC;IAC5C,OAAOF,MAAM,KAAKG,MAAM,IAAIF,MAAM,KAAKG,MAAM;EAC/C,CAAC,MAAM;IACL;IACA,OAAOP,QAAQ,KAAKC,QAAQ;EAC9B;AACF"}
+{"version":3,"names":["jsVersion","checkCppVersion","cppVersion","global","_REANIMATED_VERSION_CPP","undefined","Error","ok","matchVersion","version1","version2","match","major1","minor1","split","major2","minor2"],"sources":["checkCppVersion.ts"],"sourcesContent":["import { jsVersion } from './jsVersion';\n\nexport function checkCppVersion() {\n  const cppVersion = global._REANIMATED_VERSION_CPP;\n  if (cppVersion === undefined) {\n    throw new Error(\n      `[Reanimated] Couldn't determine the version of the native part of Reanimated. Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must use the exact version which is bundled into Expo SDK.`\n    );\n  }\n  const ok = matchVersion(jsVersion, cppVersion);\n  if (!ok) {\n    throw new Error(\n      `[Reanimated] Mismatch between JavaScript part (${jsVersion}) and native part of Reanimated (${cppVersion}). Did you forget to re-build the app after upgrading react-native-reanimated? If you use Expo Go, you must downgrade to ${cppVersion} which is bundled into Expo SDK.`\n    );\n  }\n}\n\n// This is used only in test files, therefore it is reported by ts-prune (which is desired)\n// ts-prune-ignore-next\nexport function matchVersion(version1: string, version2: string) {\n  if (version1.match(/^\\d+\\.\\d+\\.\\d+$/) && version2.match(/^\\d+\\.\\d+\\.\\d+$/)) {\n    // x.y.z, compare only major and minor, skip patch\n    const [major1, minor1] = version1.split('.');\n    const [major2, minor2] = version2.split('.');\n    return major1 === major2 && minor1 === minor2;\n  } else {\n    // alpha, beta or rc, compare everything\n    return version1 === version2;\n  }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,aAAa;AAEvC,OAAO,SAASC,eAAeA,CAAA,EAAG;EAChC,MAAMC,UAAU,GAAGC,MAAM,CAACC,uBAAuB;EACjD,IAAIF,UAAU,KAAKG,SAAS,EAAE;IAC5B,MAAM,IAAIC,KAAK,CACZ,8OAA6O,CAC/O;EACH;EACA,MAAMC,EAAE,GAAGC,YAAY,CAACR,SAAS,EAAEE,UAAU,CAAC;EAC9C,IAAI,CAACK,EAAE,EAAE;IACP,MAAM,IAAID,KAAK,CACZ,kDAAiDN,SAAU,oCAAmCE,UAAW,4HAA2HA,UAAW,kCAAiC,CAClR;EACH;AACF;;AAEA;AACA;AACA,OAAO,SAASM,YAAYA,CAACC,QAAgB,EAAEC,QAAgB,EAAE;EAC/D,IAAID,QAAQ,CAACE,KAAK,CAAC,iBAAiB,CAAC,IAAID,QAAQ,CAACC,KAAK,CAAC,iBAAiB,CAAC,EAAE;IAC1E;IACA,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGJ,QAAQ,CAACK,KAAK,CAAC,GAAG,CAAC;IAC5C,MAAM,CAACC,MAAM,EAAEC,MAAM,CAAC,GAAGN,QAAQ,CAACI,KAAK,CAAC,GAAG,CAAC;IAC5C,OAAOF,MAAM,KAAKG,MAAM,IAAIF,MAAM,KAAKG,MAAM;EAC/C,CAAC,MAAM;IACL;IACA,OAAOP,QAAQ,KAAKC,QAAQ;EAC9B;AACF"}

package/lib/module/reanimated2/platform-specific/jsVersion.js

@@ -3,5 +3,5 @@
  * with the version used to build the native part of the library in runtime.
  * Remember to keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '3.4.0';
+export const jsVersion = '3.4.2';
 //# sourceMappingURL=jsVersion.js.map

package/lib/module/reanimated2/platform-specific/jsVersion.js.map

@@ -1 +1 @@
-{"version":3,"names":["jsVersion"],"sources":["jsVersion.ts"],"sourcesContent":["/**\n * We hardcode the version of Reanimated here in order to compare it\n * with the version used to build the native part of the library in runtime.\n * Remember to keep this in sync with the version declared in `package.json`\n */\nexport const jsVersion = '3.4.0';\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,SAAS,GAAG,OAAO"}
+{"version":3,"names":["jsVersion"],"sources":["jsVersion.ts"],"sourcesContent":["/**\n * We hardcode the version of Reanimated here in order to compare it\n * with the version used to build the native part of the library in runtime.\n * Remember to keep this in sync with the version declared in `package.json`\n */\nexport const jsVersion = '3.4.2';\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,SAAS,GAAG,OAAO"}

package/lib/module/reanimated2/valueSetter.js

@@ -1,4 +1,3 @@
-export { stopMapper } from './mappers';
 export function valueSetter(sv, value) {
   'worklet';
 

package/lib/module/reanimated2/valueSetter.js.map

@@ -1 +1 @@
-{"version":3,"names":["stopMapper","valueSetter","sv","value","previousAnimation","_animation","cancelled","onFrame","undefined","animation","_value","current","isHigherOrder","callback","initializeAnimation","timestamp","onStart","currentTimestamp","global","__frameTimestamp","performance","now","step","finished","requestAnimationFrame"],"sources":["valueSetter.ts"],"sourcesContent":["import type { AnimationObject, AnimatableValue } from './commonTypes';\nimport type { Descriptor } from './hook/commonTypes';\nexport { stopMapper } from './mappers';\n\nexport function valueSetter(sv: any, value: any): void {\n  'worklet';\n  const previousAnimation = sv._animation;\n  if (previousAnimation) {\n    previousAnimation.cancelled = true;\n    sv._animation = null;\n  }\n  if (\n    typeof value === 'function' ||\n    (value !== null &&\n      typeof value === 'object' &&\n      (value as AnimationObject).onFrame !== undefined)\n  ) {\n    const animation: AnimationObject =\n      typeof value === 'function'\n        ? (value as () => AnimationObject)()\n        : (value as AnimationObject);\n    // prevent setting again to the same value\n    // and triggering the mappers that treat this value as an input\n    // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)\n    // built in animations that are not higher order(withTiming, withSpring) hold target value in .current\n    if (sv._value === animation.current && !animation.isHigherOrder) {\n      animation.callback && animation.callback(true);\n      return;\n    }\n    // animated set\n    const initializeAnimation = (timestamp: number) => {\n      animation.onStart(animation, sv.value, timestamp, previousAnimation);\n    };\n    const currentTimestamp = global.__frameTimestamp || performance.now();\n    initializeAnimation(currentTimestamp);\n    const step = (timestamp: number) => {\n      if (animation.cancelled) {\n        animation.callback && animation.callback(false /* finished */);\n        return;\n      }\n      const finished = animation.onFrame(animation, timestamp);\n      animation.finished = true;\n      animation.timestamp = timestamp;\n      sv._value = animation.current;\n      if (finished) {\n        animation.callback && animation.callback(true /* finished */);\n      } else {\n        requestAnimationFrame(step);\n      }\n    };\n\n    sv._animation = animation;\n\n    step(currentTimestamp);\n  } else {\n    // prevent setting again to the same value\n    // and triggering the mappers that treat this value as an input\n    if (sv._value === value) {\n      return;\n    }\n    sv._value = value as Descriptor | AnimatableValue;\n  }\n}\n"],"mappings":"AAEA,SAASA,UAAU,QAAQ,WAAW;AAEtC,OAAO,SAASC,WAAWA,CAACC,EAAO,EAAEC,KAAU,EAAQ;EACrD,SAAS;;EACT,MAAMC,iBAAiB,GAAGF,EAAE,CAACG,UAAU;EACvC,IAAID,iBAAiB,EAAE;IACrBA,iBAAiB,CAACE,SAAS,GAAG,IAAI;IAClCJ,EAAE,CAACG,UAAU,GAAG,IAAI;EACtB;EACA,IACE,OAAOF,KAAK,KAAK,UAAU,IAC1BA,KAAK,KAAK,IAAI,IACb,OAAOA,KAAK,KAAK,QAAQ,IACxBA,KAAK,CAAqBI,OAAO,KAAKC,SAAU,EACnD;IACA,MAAMC,SAA0B,GAC9B,OAAON,KAAK,KAAK,UAAU,GACtBA,KAAK,EAA4B,GACjCA,KAAyB;IAChC;IACA;IACA;IACA;IACA,IAAID,EAAE,CAACQ,MAAM,KAAKD,SAAS,CAACE,OAAO,IAAI,CAACF,SAAS,CAACG,aAAa,EAAE;MAC/DH,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,IAAI,CAAC;MAC9C;IACF;IACA;IACA,MAAMC,mBAAmB,GAAIC,SAAiB,IAAK;MACjDN,SAAS,CAACO,OAAO,CAACP,SAAS,EAAEP,EAAE,CAACC,KAAK,EAAEY,SAAS,EAAEX,iBAAiB,CAAC;IACtE,CAAC;IACD,MAAMa,gBAAgB,GAAGC,MAAM,CAACC,gBAAgB,IAAIC,WAAW,CAACC,GAAG,EAAE;IACrEP,mBAAmB,CAACG,gBAAgB,CAAC;IACrC,MAAMK,IAAI,GAAIP,SAAiB,IAAK;MAClC,IAAIN,SAAS,CAACH,SAAS,EAAE;QACvBG,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,KAAK,CAAC,eAAe;QAC9D;MACF;MACA,MAAMU,QAAQ,GAAGd,SAAS,CAACF,OAAO,CAACE,SAAS,EAAEM,SAAS,CAAC;MACxDN,SAAS,CAACc,QAAQ,GAAG,IAAI;MACzBd,SAAS,CAACM,SAAS,GAAGA,SAAS;MAC/Bb,EAAE,CAACQ,MAAM,GAAGD,SAAS,CAACE,OAAO;MAC7B,IAAIY,QAAQ,EAAE;QACZd,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,IAAI,CAAC,eAAe;MAC/D,CAAC,MAAM;QACLW,qBAAqB,CAACF,IAAI,CAAC;MAC7B;IACF,CAAC;IAEDpB,EAAE,CAACG,UAAU,GAAGI,SAAS;IAEzBa,IAAI,CAACL,gBAAgB,CAAC;EACxB,CAAC,MAAM;IACL;IACA;IACA,IAAIf,EAAE,CAACQ,MAAM,KAAKP,KAAK,EAAE;MACvB;IACF;IACAD,EAAE,CAACQ,MAAM,GAAGP,KAAqC;EACnD;AACF"}
+{"version":3,"names":["valueSetter","sv","value","previousAnimation","_animation","cancelled","onFrame","undefined","animation","_value","current","isHigherOrder","callback","initializeAnimation","timestamp","onStart","currentTimestamp","global","__frameTimestamp","performance","now","step","finished","requestAnimationFrame"],"sources":["valueSetter.ts"],"sourcesContent":["import type { AnimationObject, AnimatableValue } from './commonTypes';\nimport type { Descriptor } from './hook/commonTypes';\n\nexport function valueSetter(sv: any, value: any): void {\n  'worklet';\n  const previousAnimation = sv._animation;\n  if (previousAnimation) {\n    previousAnimation.cancelled = true;\n    sv._animation = null;\n  }\n  if (\n    typeof value === 'function' ||\n    (value !== null &&\n      typeof value === 'object' &&\n      (value as AnimationObject).onFrame !== undefined)\n  ) {\n    const animation: AnimationObject =\n      typeof value === 'function'\n        ? (value as () => AnimationObject)()\n        : (value as AnimationObject);\n    // prevent setting again to the same value\n    // and triggering the mappers that treat this value as an input\n    // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)\n    // built in animations that are not higher order(withTiming, withSpring) hold target value in .current\n    if (sv._value === animation.current && !animation.isHigherOrder) {\n      animation.callback && animation.callback(true);\n      return;\n    }\n    // animated set\n    const initializeAnimation = (timestamp: number) => {\n      animation.onStart(animation, sv.value, timestamp, previousAnimation);\n    };\n    const currentTimestamp = global.__frameTimestamp || performance.now();\n    initializeAnimation(currentTimestamp);\n    const step = (timestamp: number) => {\n      if (animation.cancelled) {\n        animation.callback && animation.callback(false /* finished */);\n        return;\n      }\n      const finished = animation.onFrame(animation, timestamp);\n      animation.finished = true;\n      animation.timestamp = timestamp;\n      sv._value = animation.current;\n      if (finished) {\n        animation.callback && animation.callback(true /* finished */);\n      } else {\n        requestAnimationFrame(step);\n      }\n    };\n\n    sv._animation = animation;\n\n    step(currentTimestamp);\n  } else {\n    // prevent setting again to the same value\n    // and triggering the mappers that treat this value as an input\n    if (sv._value === value) {\n      return;\n    }\n    sv._value = value as Descriptor | AnimatableValue;\n  }\n}\n"],"mappings":"AAGA,OAAO,SAASA,WAAWA,CAACC,EAAO,EAAEC,KAAU,EAAQ;EACrD,SAAS;;EACT,MAAMC,iBAAiB,GAAGF,EAAE,CAACG,UAAU;EACvC,IAAID,iBAAiB,EAAE;IACrBA,iBAAiB,CAACE,SAAS,GAAG,IAAI;IAClCJ,EAAE,CAACG,UAAU,GAAG,IAAI;EACtB;EACA,IACE,OAAOF,KAAK,KAAK,UAAU,IAC1BA,KAAK,KAAK,IAAI,IACb,OAAOA,KAAK,KAAK,QAAQ,IACxBA,KAAK,CAAqBI,OAAO,KAAKC,SAAU,EACnD;IACA,MAAMC,SAA0B,GAC9B,OAAON,KAAK,KAAK,UAAU,GACtBA,KAAK,EAA4B,GACjCA,KAAyB;IAChC;IACA;IACA;IACA;IACA,IAAID,EAAE,CAACQ,MAAM,KAAKD,SAAS,CAACE,OAAO,IAAI,CAACF,SAAS,CAACG,aAAa,EAAE;MAC/DH,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,IAAI,CAAC;MAC9C;IACF;IACA;IACA,MAAMC,mBAAmB,GAAIC,SAAiB,IAAK;MACjDN,SAAS,CAACO,OAAO,CAACP,SAAS,EAAEP,EAAE,CAACC,KAAK,EAAEY,SAAS,EAAEX,iBAAiB,CAAC;IACtE,CAAC;IACD,MAAMa,gBAAgB,GAAGC,MAAM,CAACC,gBAAgB,IAAIC,WAAW,CAACC,GAAG,EAAE;IACrEP,mBAAmB,CAACG,gBAAgB,CAAC;IACrC,MAAMK,IAAI,GAAIP,SAAiB,IAAK;MAClC,IAAIN,SAAS,CAACH,SAAS,EAAE;QACvBG,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,KAAK,CAAC,eAAe;QAC9D;MACF;MACA,MAAMU,QAAQ,GAAGd,SAAS,CAACF,OAAO,CAACE,SAAS,EAAEM,SAAS,CAAC;MACxDN,SAAS,CAACc,QAAQ,GAAG,IAAI;MACzBd,SAAS,CAACM,SAAS,GAAGA,SAAS;MAC/Bb,EAAE,CAACQ,MAAM,GAAGD,SAAS,CAACE,OAAO;MAC7B,IAAIY,QAAQ,EAAE;QACZd,SAAS,CAACI,QAAQ,IAAIJ,SAAS,CAACI,QAAQ,CAAC,IAAI,CAAC,eAAe;MAC/D,CAAC,MAAM;QACLW,qBAAqB,CAACF,IAAI,CAAC;MAC7B;IACF,CAAC;IAEDpB,EAAE,CAACG,UAAU,GAAGI,SAAS;IAEzBa,IAAI,CAACL,gBAAgB,CAAC;EACxB,CAAC,MAAM;IACL;IACA;IACA,IAAIf,EAAE,CAACQ,MAAM,KAAKP,KAAK,EAAE;MACvB;IACF;IACAD,EAAE,CAACQ,MAAM,GAAGP,KAAqC;EACnD;AACF"}

package/lib/module/setAndForwardRef.js.map

@@ -1 +1 @@
-{"version":3,"names":["setAndForwardRef","_ref","getForwardedRef","setLocalRef","forwardRef","ref","forwardedRef","current"],"sources":["setAndForwardRef.ts"],"sourcesContent":["/**\n * imported from react-native\n */\n\nimport type { MutableRefObject } from 'react';\n\n/**\n * This is a helper function for when a component needs to be able to forward a ref\n * to a child component, but still needs to have access to that component as part of\n * its implementation.\n *\n * Its main use case is in wrappers for native components.\n *\n * Usage:\n *\n *   class MyView extends React.Component {\n *     _nativeRef = null;\n *\n *     _setNativeRef = setAndForwardRef({\n *       getForwardedRef: () => this.props.forwardedRef,\n *       setLocalRef: ref => {\n *         this._nativeRef = ref;\n *       },\n *     });\n *\n *     render() {\n *       return <View ref={this._setNativeRef} />;\n *     }\n *   }\n *\n *   const MyViewWithRef = React.forwardRef((props, ref) => (\n *     <MyView {...props} forwardedRef={ref} />\n *   ));\n *\n *   module.exports = MyViewWithRef;\n */\n\nexport type ForwardedRef<T> = () => MutableRefObject<T> | ((ref: T) => void);\n\nfunction setAndForwardRef<T>({\n  getForwardedRef,\n  setLocalRef,\n}: {\n  getForwardedRef: ForwardedRef<T>;\n  setLocalRef: (ref: T) => void;\n}): (ref: T) => void {\n  return function forwardRef(ref: T) {\n    const forwardedRef = getForwardedRef();\n\n    setLocalRef(ref);\n\n    // Forward to user ref prop (if one has been specified)\n    if (typeof forwardedRef === 'function') {\n      // Handle function-based refs. String-based refs are handled as functions.\n      forwardedRef(ref);\n    } else if (typeof forwardedRef === 'object' && forwardedRef != null) {\n      // Handle createRef-based refs\n      forwardedRef.current = ref;\n    }\n  };\n}\n\nexport default setAndForwardRef;\n"],"mappings":"AAAA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAASA,gBAAgBA,CAAAC,IAAA,EAMJ;EAAA,IANQ;IAC3BC,eAAe;IACfC;EAIF,CAAC,GAAAF,IAAA;EACC,OAAO,SAASG,UAAUA,CAACC,GAAM,EAAE;IACjC,MAAMC,YAAY,GAAGJ,eAAe,EAAE;IAEtCC,WAAW,CAACE,GAAG,CAAC;;IAEhB;IACA,IAAI,OAAOC,YAAY,KAAK,UAAU,EAAE;MACtC;MACAA,YAAY,CAACD,GAAG,CAAC;IACnB,CAAC,MAAM,IAAI,OAAOC,YAAY,KAAK,QAAQ,IAAIA,YAAY,IAAI,IAAI,EAAE;MACnE;MACAA,YAAY,CAACC,OAAO,GAAGF,GAAG;IAC5B;EACF,CAAC;AACH;AAEA,eAAeL,gBAAgB"}
+{"version":3,"names":["setAndForwardRef","_ref","getForwardedRef","setLocalRef","forwardRef","ref","forwardedRef","current"],"sources":["setAndForwardRef.ts"],"sourcesContent":["/**\n * imported from react-native\n */\n\nimport type { MutableRefObject } from 'react';\n\n/**\n * This is a helper function for when a component needs to be able to forward a ref\n * to a child component, but still needs to have access to that component as part of\n * its implementation.\n *\n * Its main use case is in wrappers for native components.\n *\n * Usage:\n *\n *   class MyView extends React.Component {\n *     _nativeRef = null;\n *\n *     _setNativeRef = setAndForwardRef({\n *       getForwardedRef: () => this.props.forwardedRef,\n *       setLocalRef: ref => {\n *         this._nativeRef = ref;\n *       },\n *     });\n *\n *     render() {\n *       return <View ref={this._setNativeRef} />;\n *     }\n *   }\n *\n *   const MyViewWithRef = React.forwardRef((props, ref) => (\n *     <MyView {...props} forwardedRef={ref} />\n *   ));\n *\n *   module.exports = MyViewWithRef;\n */\n\ntype ForwardedRef<T> = () => MutableRefObject<T> | ((ref: T) => void);\n\nfunction setAndForwardRef<T>({\n  getForwardedRef,\n  setLocalRef,\n}: {\n  getForwardedRef: ForwardedRef<T>;\n  setLocalRef: (ref: T) => void;\n}): (ref: T) => void {\n  return function forwardRef(ref: T) {\n    const forwardedRef = getForwardedRef();\n\n    setLocalRef(ref);\n\n    // Forward to user ref prop (if one has been specified)\n    if (typeof forwardedRef === 'function') {\n      // Handle function-based refs. String-based refs are handled as functions.\n      forwardedRef(ref);\n    } else if (typeof forwardedRef === 'object' && forwardedRef != null) {\n      // Handle createRef-based refs\n      forwardedRef.current = ref;\n    }\n  };\n}\n\nexport default setAndForwardRef;\n"],"mappings":"AAAA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAASA,gBAAgBA,CAAAC,IAAA,EAMJ;EAAA,IANQ;IAC3BC,eAAe;IACfC;EAIF,CAAC,GAAAF,IAAA;EACC,OAAO,SAASG,UAAUA,CAACC,GAAM,EAAE;IACjC,MAAMC,YAAY,GAAGJ,eAAe,EAAE;IAEtCC,WAAW,CAACE,GAAG,CAAC;;IAEhB;IACA,IAAI,OAAOC,YAAY,KAAK,UAAU,EAAE;MACtC;MACAA,YAAY,CAACD,GAAG,CAAC;IACnB,CAAC,MAAM,IAAI,OAAOC,YAAY,KAAK,QAAQ,IAAIA,YAAY,IAAI,IAAI,EAAE;MACnE;MACAA,YAAY,CAACC,OAAO,GAAGF,GAAG;IAC5B;EACF,CAAC;AACH;AAEA,eAAeL,gBAAgB"}

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/core.d.ts

@@ -7,6 +7,18 @@ export { runOnJS, runOnUI } from './threads';
 export { makeShareable } from './shareables';
 export { makeMutable, makeRemote } from './mutables';
 export type ReanimatedConsole = Pick<Console, 'debug' | 'log' | 'warn' | 'info' | 'error'>;
+/**
+ * @returns `true` in Reanimated 3, doesn't exist in Reanimated 2 or 1
+ */
+export declare const isReanimated3: () => boolean;
+/**
+ * @deprecated This function was superseded by other checks.
+ * We keep it here for backward compatibility reasons.
+ * If you need to check if you are using Reanimated 3 or Reanimated 2
+ * please use `isReanimated3` function instead.
+ * @returns `true` in Reanimated 3, doesn't exist in Reanimated 2
+ */
+export declare const isConfigured: () => boolean;
 export declare function getViewProp<T>(viewTag: string, propName: string): Promise<T>;
 export declare function getSensorContainer(): SensorContainer;
 export declare function registerEventHandler<T>(eventHash: string, eventHandler: (event: T) => void): number;

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 {};