@rootnative/inertia 0.0.10 → 0.0.11

package/jest-preset.js

@@ -1,7 +1,7 @@
 // Jest preset for projects consuming `@rootnative/inertia` and its sibling
 // adapter packages (`@rootnative/inertia-gestures`, `-gradients`, `-svg`).
 //
-// Layered on top of `react-native`'s own preset. Adds:
+// Layered on top of `@react-native/jest-preset`. Adds:
 //   - the `react-native-worklets` + Reanimated mock surface Inertia exercises
 //     (worklet stubs, animation primitives, color/layout utilities)
 //   - `transformIgnorePatterns` widened so Jest transforms the published
@@ -19,7 +19,36 @@
 // If you need to allowlist additional packages for transformation, extend
 // `transformIgnorePatterns` in your own config — Jest merges over the preset.
 
-const rnPreset = require('react-native/jest-preset')
+// This package is deliberately **not** declared as a peer dependency of
+// `@rootnative/inertia`. React Native pins it to an exact version (RN 0.86.3
+// requires exactly `@react-native/jest-preset@0.86.3`), so any range we
+// declared would advertise versions that cannot install — the sdk-compat range
+// audit fails on it — and an exact pin would break on every RN patch. The
+// version relationship belongs to `react-native`, which already declares it.
+//
+// Resolve `@react-native/jest-preset` directly rather than through the
+// `react-native/jest-preset` shim. RN 0.86 moved the preset into its own
+// package and left the old path as a shim that re-exports it — but it declares
+// the new package as an **optional** peer, and no package manager installs an
+// optional peer. So on RN 0.86 the shim throws a migration error for any
+// consumer who has not installed it by hand, which is what a consumer of this
+// preset would have hit. Requiring it here means the failure names this
+// package's requirement instead.
+let rnPreset
+try {
+  rnPreset = require('@react-native/jest-preset')
+} catch (error) {
+  if (error.code === 'MODULE_NOT_FOUND') {
+    throw new Error(
+      '[inertia] `@rootnative/inertia/jest-preset` needs `@react-native/jest-preset`.\n' +
+        'React Native 0.86 moved its Jest preset into that package and declares\n' +
+        'it as an optional peer, so it is not installed for you. Add it as a\n' +
+        'devDependency at the version matching your react-native:\n\n' +
+        '  npm install --save-dev @react-native/jest-preset\n',
+    )
+  }
+  throw error
+}
 
 module.exports = {
   ...rnPreset,

package/llms.txt

@@ -88,7 +88,8 @@ import { MotionFlatList } from '@rootnative/inertia/flat-list'
 - `resolveAnimatableValue(value, base, factory?)` — one level up: resolves a full per-property `animate` value (plain target, `{ to, ...override }` step, or keyframe array → `withSequence` with sequence-level `repeat`) into one animation. Gives custom components the complete `animate` grammar.
 - `cubicBezier(x1, y1, x2, y2)` / `cubicBezier(css)` — builds a `timing.easing` value from cubic-bezier control points: four numbers, a W3C CSS `cubic-bezier(0.2, 0, 0, 1)` string (design-token form), or a CSS keyword (`'linear'` | `'ease'` | `'ease-in'` | `'ease-out'` | `'ease-in-out'`). Makes CSS-format easing tokens directly consumable — pair with named transitions to feed a theme's motion tokens into the registry. Invalid input throws (`x1`/`x2` must be within [0, 1]; `step-*` and `linear(...)` unsupported).
 - `ensureWorkletEasing(easing)` — normalizes any accepted easing input (plain function, worklet, or Reanimated 4 `EasingFunctionFactory`) into a worklet `withTiming` can consume. Only needed for manual `withTiming` calls — the resolvers and primitives apply it automatically.
-- `TRANSPARENT` — `'rgba(0, 0, 0, 0)'`, the value to seed a colour shared value with when a custom component has no other source. Not `'transparent'`: Reanimated's colour table maps that keyword to `undefined`, so it is the one CSS colour name `isColor()` rejects, and a slot resting at it cannot be animated away from — under `withTiming` the target still snaps in at the end, under `withSpring` (the default) the animation never settles. Only affects values passed to `withSpring` / `withTiming`; `interpolateColor` parses the keyword fine, so hooks that interpolate colours themselves are unaffected.
+- `TRANSPARENT` — `'rgba(0, 0, 0, 0)'`, the value to seed a colour shared value with when a custom component has no other source. It exists because Reanimated up to 4.4 mapped the CSS keyword `'transparent'` to `undefined` in its colour table, making it the one name `isColor()` rejected: a slot resting at it could not be animated away from, and under `withSpring` (the default) the animation never settled. **Reanimated 4.5 fixed that** — the keyword now maps to a real packed colour — so within the supported peer band (`>=4.5.0 <4.6.0`) either spelling animates. The constant stays exported as an explicit, unambiguous seed and as the safe choice for code that may run against an older Reanimated.
+- `TranslateStyle` / `ColorStyle` / `ShadowStyle` (types) — what `useTranslateStyle`, `useColorTransition` / `useColorCascade`, and `useShadow` return. Plain style objects, **not** Reanimated's branded `AnimatedStyleHandle`: Reanimated 4.5 brands the value `useAnimatedStyle` returns, and a branded value is rejected inside a `StyleProp` array, so stating the plain shape is what keeps a style-array call site cast-free. Same reasoning as `InterpolatedStyle<K>` above. The brand is compile-time only — the value is still the animated style Reanimated produced.
 - `SharedValue<T>` (type) — re-exported from the root entry so props/refs that carry a value-layer hook result can be typed without importing from `react-native-reanimated`.
 - `@rootnative/inertia/reanimated` — render-layer interop subpath: pure re-exports of `Animated`, `createAnimatedComponent`, `useAnimatedStyle`, `useAnimatedProps`, `useDerivedValue`, `interpolate`, `interpolateColor`, `Extrapolation`, `cancelAnimation` (plus `SharedValue` / `DerivedValue` / `AnimatedStyle` / `AnimatedProps` types) under their original Reanimated names, for components that own their own `useAnimatedStyle` worklet over Inertia-driven shared values. Names must stay original — the Reanimated Babel plugin auto-workletizes callbacks by callee name. The `with*` animation factories are deliberately not re-exported; start animations with `useAnimation` / `resolveTransition` / `buildReleaseAnimation`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rootnative/inertia",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Declarative animation primitives for React Native, built on react-native-reanimated.",
   "license": "MIT",
   "author": "RootNative",
@@ -126,10 +126,10 @@
   ],
   "peerDependencies": {
     "@testing-library/react-native": ">=13.0.0",
-    "react": ">=19.0.0",
-    "react-native": ">=0.81.0",
-    "react-native-reanimated": ">=4.0.0",
-    "react-native-worklets": ">=0.5.0"
+    "react": ">=19.2.3 <20.0.0",
+    "react-native": ">=0.83.0 <0.87.0",
+    "react-native-reanimated": ">=4.5.0 <4.6.0",
+    "react-native-worklets": ">=0.10.0 <0.11.0"
   },
   "peerDependenciesMeta": {
     "@testing-library/react-native": {
@@ -137,17 +137,18 @@
     }
   },
   "devDependencies": {
-    "@react-native/babel-preset": "^0.81.5",
+    "@react-native/babel-preset": "^0.86.3",
+    "@react-native/jest-preset": "^0.86.3",
     "@size-limit/preset-small-lib": "^11.1.0",
     "@testing-library/react-native": "^13.3.3",
     "@types/jest": "^29.5.14",
-    "@types/react": "^19.1.0",
+    "@types/react": "^19.2.0",
     "jest": "^29.7.0",
-    "react": "19.1.0",
-    "react-native": "0.81.5",
-    "react-native-reanimated": "~4.1.1",
-    "react-native-worklets": "~0.5.1",
-    "react-test-renderer": "19.1.0",
+    "react": "19.2.3",
+    "react-native": "0.86.3",
+    "react-native-reanimated": "4.5.1",
+    "react-native-worklets": "0.10.1",
+    "react-test-renderer": "19.2.3",
     "size-limit": "^11.1.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.3"

package/src/index.ts

@@ -79,12 +79,15 @@ export type {
   Animator,
   BoxShadowLayer,
   ColorCascadeLayer,
+  ColorStyle,
   ColorStyleKey,
   ExtrapolationMode,
   InterpolatedStyle,
   InterpolatedStyleMap,
+  TranslateStyle,
   NumericStyleKey,
   ShadowConfig,
+  ShadowStyle,
   TransformKey,
   UseColorCascadeOptions,
   UseColorTransitionOptions,

package/src/internal/boxShadow.ts

@@ -164,7 +164,7 @@ export function resolveBoxShadowInput(
     offsetY: coerceLength(layer.offsetY, 'offsetY'),
     blurRadius: coerceLength(layer.blurRadius, 'blurRadius'),
     spreadDistance: coerceLength(layer.spreadDistance, 'spreadDistance'),
-    color: layer.color ?? 'black',
+    color: coerceColor(layer.color),
     inset: layer.inset ?? false,
   }))
 }
@@ -273,7 +273,10 @@ export type BoxShadowInput =
       // rejected) by `coerceLength` like every other length.
       blurRadius?: unknown
       spreadDistance?: number | string | undefined
-      color?: string | undefined
+      // `unknown` because RN 0.86 widened this from `string` to `ColorValue`,
+      // which includes the opaque handle `PlatformColor()` returns. Coerced
+      // (and rejected) by `coerceColor`.
+      color?: unknown
       inset?: boolean | undefined
     }>
 
@@ -284,6 +287,25 @@ export type BoxShadowInput =
  * `parseBoxShadow` — px and unitless only, and anything else throws rather
  * than silently animating from a `NaN`.
  */
+/**
+ * Coerce one RN colour field to a string.
+ *
+ * RN 0.86 widened `BoxShadowValue.color` from `string` to `ColorValue`, which
+ * admits the opaque handle `PlatformColor()` and `DynamicColorIOS()` return.
+ * That handle is a platform reference, not a colour this code can read, so it
+ * cannot be interpolated. Reject it here with a message that names the cause,
+ * rather than letting it reach the worklet and animate to `NaN`.
+ */
+function coerceColor(value: unknown): string {
+  if (value === undefined) return 'black'
+  if (typeof value === 'string') return value
+  throw new Error(
+    '[inertia] boxShadow: color must be a colour string, got ' +
+      `${typeof value}. PlatformColor and DynamicColorIOS values cannot be ` +
+      'interpolated — pass a string colour on an animated shadow.',
+  )
+}
+
 function coerceLength(value: unknown, field: string): number {
   if (value === undefined) return 0
   if (typeof value === 'number') return value

package/src/touch/useTouchDrag.ts

@@ -5,9 +5,11 @@ import {
   type PanResponderInstance,
 } from 'react-native'
 import { useSharedValue, type SharedValue } from 'react-native-reanimated'
-import type { useAnimatedStyle } from 'react-native-reanimated'
 import { buildReleaseAnimation } from '../transitions'
-import { useTranslateStyle } from '../values/useTranslateStyle'
+import {
+  useTranslateStyle,
+  type TranslateStyle,
+} from '../values/useTranslateStyle'
 import { applyBounds } from './applyBounds'
 import type { TransitionConfig } from '../types'
 
@@ -22,7 +24,7 @@ export interface UseTouchDragResult {
   /** Spread onto a `View` / `Pressable` to install the pan responder. */
   panHandlers: PanResponderInstance['panHandlers']
   /** Stable animated `transform` style. */
-  animatedStyle: ReturnType<typeof useAnimatedStyle>
+  animatedStyle: TranslateStyle
   /** Live x translation, persistent across gestures. */
   dragX: SharedValue<number>
   /** Live y translation, persistent across gestures. */

package/src/transitions/resolveSequence.ts

@@ -1,4 +1,4 @@
-import { withSequence } from 'react-native-reanimated'
+import { withSequence, withTiming } from 'react-native-reanimated'
 import {
   applyRepeat,
   repeatOf,
@@ -13,6 +13,18 @@ import {
   type TransitionConfig,
 } from '../types'
 
+/** A zero-length timing, for a snapped step inside an animated sequence. */
+const INSTANT = { duration: 0 } as const
+
+/**
+ * True when a resolved step is a bare target rather than a Reanimated
+ * animation object. `buildOne` returns the target itself for `no-animation`,
+ * which is what the reduced-motion gate collapses every step to.
+ */
+function isSnapped(step: unknown): step is number | string {
+  return typeof step === 'number' || typeof step === 'string'
+}
+
 /**
  * True when the value is a `{ to, ...transitionOverride }` sequence step.
  * Plain numbers and plain transition objects fail this check.
@@ -37,6 +49,12 @@ function isStepObject<V>(
  *   3. array of either   → `withSequence` of resolved steps, with the
  *      top-level `repeat` applied at the **sequence level** (not per step).
  *      Per-step `repeat` overrides remain step-local.
+ *
+ * `withSequence` writes a `finished` flag onto each argument it is handed, so
+ * a bare target throws `Cannot create property 'finished' on number` and takes
+ * the whole render down with it. Two paths produce bare targets, and both are
+ * handled below rather than at the call site: reduced motion (every step) and
+ * a per-step `{ type: 'no-animation' }` override (some steps).
  */
 export function resolveAnimatableValue<V extends number | string>(
   value: AnimatableValue<V>,
@@ -49,7 +67,29 @@ export function resolveAnimatableValue<V extends number | string>(
     const animations = steps.map((step, i) =>
       resolveStep(step, stepBase, factory?.('step', i)),
     )
-    const seq = withSequence(...(animations as never[]))
+    // The reduced-motion gate. `mergeTransition` hands a `no-animation` base
+    // back untouched for every step, so the whole sequence is a snap and there
+    // is nothing to sequence. Settle on the last step — where the sequence
+    // would have ended. `repeat` and `delay` are already dropped for
+    // `no-animation` (`repeatOf` and `delayOf` both return `undefined`), so
+    // nothing needs to wrap this.
+    //
+    // Read off the config rather than sniffing the resolved values: under the
+    // Jest mock `withSpring` and `withTiming` also return bare targets, so a
+    // shape test reports every sequence as snapped and the gate stops being
+    // observable in either direction.
+    if (stepBase?.type === 'no-animation' && animations.length > 0) {
+      return animations[animations.length - 1]
+    }
+    // A step that declares `{ type: 'no-animation' }` inside a sequence that
+    // otherwise animates resolves to a bare target of its own. The step still
+    // owns its slot in the order, so it becomes an instant timing rather than
+    // being dropped.
+    const seq = withSequence(
+      ...(animations.map((a) =>
+        isSnapped(a) ? withTiming(a as number, INSTANT) : a,
+      ) as never[]),
+    )
     return applyRepeat(seq, base ? repeatOf(base) : undefined, {
       sequence: true,
     })

package/src/types.ts

@@ -5,6 +5,7 @@ import {
   type Ref,
 } from 'react'
 import { type BoxShadowValue, type StyleProp } from 'react-native'
+import { type AnimatedProps } from 'react-native-reanimated'
 
 /**
  * A single animation step's destination, optionally overriding the transition
@@ -555,6 +556,14 @@ export interface MotionProps<C, V extends VariantsMap<C> = VariantsMap<C>> {
  * Props of a Motion primitive for a given underlying component `C` and a
  * concrete variants map `V`: the component's own props (minus `style`, which
  * we replace with an animated style) intersected with the Motion props.
+ *
+ * `style` is taken from `AnimatedProps<…>`, not from `C` directly, because a
+ * Motion primitive renders `Animated.createAnimatedComponent(C)` — so the
+ * styles it accepts are the ones that animated component accepts. Reanimated
+ * 4.5 brands what `useAnimatedStyle` returns, and `ComponentProps<C>['style']`
+ * rejects a branded value, which would have made the sanctioned escape hatch
+ * (Principle 2: own your `useAnimatedStyle` over Inertia-driven shared values,
+ * then pass it to a `Motion.*` primitive) require a cast at every call site.
  */
 export type MotionComponentProps<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -562,7 +571,11 @@ export type MotionComponentProps<
   V extends VariantsMap<ComponentProps<C>> = VariantsMap<ComponentProps<C>>,
 > = Omit<ComponentProps<C>, 'style'> &
   MotionProps<ComponentProps<C>, V> & {
-    style?: ComponentProps<C>['style']
+    style?: AnimatedProps<ComponentProps<C>> extends {
+      style?: infer S
+    }
+      ? S
+      : ComponentProps<C>['style']
     ref?: Ref<unknown>
   }
 

package/src/values/index.ts

@@ -8,6 +8,7 @@ export {
 } from './useColorCascade'
 export {
   useColorTransition,
+  type ColorStyle,
   type ColorStyleKey,
   type UseColorTransitionOptions,
 } from './useColorTransition'
@@ -36,7 +37,8 @@ export {
   useShadow,
   type BoxShadowLayer,
   type ShadowConfig,
+  type ShadowStyle,
   type UseShadowOptions,
 } from './useShadow'
-export { useTranslateStyle } from './useTranslateStyle'
+export { useTranslateStyle, type TranslateStyle } from './useTranslateStyle'
 export { useVariants } from './useVariants'

package/src/values/useColorCascade.ts

@@ -4,7 +4,7 @@ import {
   useAnimatedStyle,
   type SharedValue,
 } from 'react-native-reanimated'
-import type { ColorStyleKey } from './useColorTransition'
+import type { ColorStyle, ColorStyleKey } from './useColorTransition'
 
 /**
  * One layer in a color cascade: its own `progress` shared value (0→1) and the
@@ -70,7 +70,7 @@ export function useColorCascade(
   rest: string,
   layers: readonly ColorCascadeLayer[],
   options?: UseColorCascadeOptions,
-): ReturnType<typeof useAnimatedStyle> {
+): ColorStyle {
   const key = options?.key ?? 'backgroundColor'
 
   // Resolve the layer chain into two flat arrays the worklet closes over — the
@@ -121,5 +121,5 @@ export function useColorCascade(
       )
     }
     return { [key]: acc }
-  })
+  }) as unknown as ColorStyle
 }

package/src/values/useColorTransition.ts

@@ -20,6 +20,21 @@ export type ColorStyleKey =
   | 'tintColor'
   | 'shadowColor'
 
+/**
+ * A one-key colour style fragment, as returned by {@link useColorTransition}
+ * and {@link useColorCascade}.
+ *
+ * Deliberately **not** `ReturnType<typeof useAnimatedStyle>`. Reanimated 4.5
+ * brands that value (`AnimatedStyleHandle`), and a branded type is rejected
+ * inside a `StyleProp` array — so every call site would need a cast, which is
+ * the defect `InterpolatedStyle` was introduced to remove in `0.0.9`. The brand
+ * is compile-time only, so the runtime value is unchanged.
+ *
+ * Optional per key because which slot is filled is chosen at run time from
+ * `options.key`; exactly one is ever present.
+ */
+export type ColorStyle = { [K in ColorStyleKey]?: string }
+
 export interface UseColorTransitionOptions {
   /**
    * Which style slot the interpolated color is emitted under. Defaults to
@@ -56,7 +71,7 @@ export function useColorTransition(
   progress: SharedValue<number>,
   range: readonly [string, string],
   options?: UseColorTransitionOptions,
-): ReturnType<typeof useAnimatedStyle> {
+): ColorStyle {
   // Resolve the slot key once on the JS thread so the worklet body
   // consumes a single string literal — consistent with the JS-thread
   // resolver principle that keeps `Object.keys`-style walks off the UI
@@ -68,5 +83,5 @@ export function useColorTransition(
   return useAnimatedStyle(() => {
     'worklet'
     return { [key]: interpolateColor(progress.value, [0, 1], [from, to]) }
-  })
+  }) as unknown as ColorStyle
 }

package/src/values/useInterpolatedStyle.ts

@@ -308,6 +308,13 @@ export function useInterpolatedStyle<K extends keyof InterpolatedStyleMap>(
   // The worklet builds a `Record<string, unknown>` by design — the emitted keys
   // are only known from `entries` at run time. `InterpolatedStyle<K>` is the
   // static statement of that same shape, so the cast is where the two meet.
+  //
+  // Through `unknown` because Reanimated 4.5 brands what `useAnimatedStyle`
+  // returns (`AnimatedStyleHandle`), and a branded type no longer overlaps a
+  // plain style object. Erasing the brand is the point of this hook: the
+  // returned value has to drop into a `StyleProp<ViewStyle>` array without the
+  // consumer casting. The brand is compile-time only, so the runtime value is
+  // unchanged — it is still the animated style Reanimated produced.
   return useAnimatedStyle(() => {
     'worklet'
     const out: Record<string, unknown> = {}
@@ -338,5 +345,5 @@ export function useInterpolatedStyle<K extends keyof InterpolatedStyleMap>(
     }
     if (transform.length > 0) out.transform = transform
     return out
-  }) as InterpolatedStyle<K>
+  }) as unknown as InterpolatedStyle<K>
 }

package/src/values/useShadow.ts

@@ -43,6 +43,22 @@ export interface ShadowConfig {
   boxShadow?: string | readonly BoxShadowLayer[]
 }
 
+/**
+ * The style fragment {@link useShadow} returns: the native shadow keys plus the
+ * CSS `boxShadow`, each present only when the paired configs drive it.
+ *
+ * Deliberately **not** `ReturnType<typeof useAnimatedStyle>` — see
+ * {@link ColorStyle} for why the brand is erased here.
+ */
+export type ShadowStyle = {
+  shadowColor?: string
+  shadowOffset?: { width: number; height: number }
+  shadowOpacity?: number
+  shadowRadius?: number
+  elevation?: number
+  boxShadow?: string
+}
+
 export interface UseShadowOptions {
   /** Shadow state at `progress === 0`. */
   from: ShadowConfig
@@ -97,7 +113,7 @@ export function useShadow({
   from,
   to,
   progress,
-}: UseShadowOptions): ReturnType<typeof useAnimatedStyle> {
+}: UseShadowOptions): ShadowStyle {
   // Resolve presence + endpoints once on the JS thread so the worklet body
   // consumes flat literals — consistent with the JS-thread resolver
   // principle that keeps `Object.keys`-style walks off the UI thread.
@@ -198,5 +214,5 @@ export function useShadow({
       out.boxShadow = css
     }
     return out
-  })
+  }) as unknown as ShadowStyle
 }

package/src/values/useTranslateStyle.ts

@@ -1,5 +1,21 @@
+import type { ViewStyle } from 'react-native'
 import { useAnimatedStyle, type SharedValue } from 'react-native-reanimated'
 
+/**
+ * What {@link useTranslateStyle} returns: a plain style object that owns
+ * `transform`.
+ *
+ * Deliberately **not** `ReturnType<typeof useAnimatedStyle>`. Reanimated 4.5
+ * brands that value (`AnimatedStyleHandle`), and a branded type is rejected
+ * inside a `StyleProp<ViewStyle>` array — so every call site would need a cast,
+ * which is the exact defect `InterpolatedStyle` was introduced to remove in
+ * `0.0.9`. The brand is compile-time only, so the runtime value is unchanged:
+ * it is still the animated style Reanimated produced.
+ */
+export type TranslateStyle = {
+  transform: NonNullable<ViewStyle['transform']>
+}
+
 /**
  * Animated style that translates by two shared values:
  * `transform: [{ translateX: x }, { translateY: y }]`.
@@ -24,8 +40,8 @@ import { useAnimatedStyle, type SharedValue } from 'react-native-reanimated'
 export function useTranslateStyle(
   x: SharedValue<number>,
   y: SharedValue<number>,
-): ReturnType<typeof useAnimatedStyle> {
+): TranslateStyle {
   return useAnimatedStyle(() => ({
     transform: [{ translateX: x.value }, { translateY: y.value }],
-  }))
+  })) as unknown as TranslateStyle
 }

package/dist/applyBounds-BYGiHrYO.d.mts

@@ -1,18 +0,0 @@
-/**
- * Clamp `value` to `[min, max]`. When `elastic > 0` the overshoot past a
- * bound is scaled by `elastic` instead of hard-clamped, giving a rubber-band
- * feel. `min` / `max` may be `undefined` to leave that side unbounded.
- *
- * Worklet, so it runs both inside a gesture-handler pan handler on the UI
- * thread (`useDrag`) and from a JS-thread `PanResponder` callback
- * (`useTouchDrag`).
- *
- * ```ts
- * applyBounds(120, -100, 100, 0)    // 100
- * applyBounds(120, -100, 100, 0.5)  // 110
- * applyBounds(50, undefined, 100, 0) // 50
- * ```
- */
-declare function applyBounds(value: number, min: number | undefined, max: number | undefined, elastic: number): number;
-
-export { applyBounds as a };

package/dist/applyBounds-BYGiHrYO.d.ts

@@ -1,18 +0,0 @@
-/**
- * Clamp `value` to `[min, max]`. When `elastic > 0` the overshoot past a
- * bound is scaled by `elastic` instead of hard-clamped, giving a rubber-band
- * feel. `min` / `max` may be `undefined` to leave that side unbounded.
- *
- * Worklet, so it runs both inside a gesture-handler pan handler on the UI
- * thread (`useDrag`) and from a JS-thread `PanResponder` callback
- * (`useTouchDrag`).
- *
- * ```ts
- * applyBounds(120, -100, 100, 0)    // 100
- * applyBounds(120, -100, 100, 0.5)  // 110
- * applyBounds(50, undefined, 100, 0) // 50
- * ```
- */
-declare function applyBounds(value: number, min: number | undefined, max: number | undefined, elastic: number): number;
-
-export { applyBounds as a };

package/dist/chunk-PLKXCJIB.js

@@ -1,8 +0,0 @@
-'use strict';
-
-var chunk2UGWAB6N_js = require('./chunk-2UGWAB6N.js');
-var reactNative = require('react-native');
-
-var MotionView = chunk2UGWAB6N_js.createMotionComponent(reactNative.View);
-
-exports.MotionView = MotionView;

package/dist/chunk-UBHQJFUW.js

@@ -1,8 +0,0 @@
-'use strict';
-
-var chunk2UGWAB6N_js = require('./chunk-2UGWAB6N.js');
-var reactNative = require('react-native');
-
-var MotionText = chunk2UGWAB6N_js.createMotionComponent(reactNative.Text);
-
-exports.MotionText = MotionText;

package/dist/chunk-XKNEQDAT.js

@@ -1,8 +0,0 @@
-'use strict';
-
-var chunk2UGWAB6N_js = require('./chunk-2UGWAB6N.js');
-var reactNative = require('react-native');
-
-var MotionImage = chunk2UGWAB6N_js.createMotionComponent(reactNative.Image);
-
-exports.MotionImage = MotionImage;