@tamagui/animation-helpers 2.7.7 → 3.0.0-beta.1097.1

package/src/types.ts

@@ -1,6 +1,42 @@
 /**
- * Animation configuration that can include additional properties
- * like delay, duration, stiffness, damping, etc.
+ * One entry in a driver's `animations` config, and the same type for all four
+ * drivers: a config written once resolves to the same motion on css,
+ * reanimated, motion, and react-native.
+ *
+ * The canonical spelling is `{ duration, bounce }`. `duration` is the spring's
+ * undamped period, the "how fast does this feel" number, and `bounce` is 0 for
+ * critically damped, up toward 1 for loose and oscillating, negative for
+ * sluggish. A css string is a timing; `{ type: 'timing' }` is the object
+ * spelling of one. `stiffness`/`damping`/`mass` stay available for a config
+ * that was already tuned against them.
+ */
+export type PresetConfig =
+  | string
+  | {
+      type?: 'spring'
+      duration?: number
+      bounce?: number
+      stiffness?: number
+      damping?: number
+      mass?: number
+      velocity?: number
+      overshootClamping?: boolean
+      restDisplacementThreshold?: number
+      restSpeedThreshold?: number
+    }
+  | {
+      type: 'timing'
+      duration: number
+      /** any css timing function */
+      easing?: string
+    }
+
+/** the `animations` object a driver is created with */
+export type AnimationsConfig = Record<string, PresetConfig>
+
+/**
+ * A resolved animation config in a driver's own terms. Drivers build these
+ * from a `ResolvedEntry`; nothing parses one.
  */
 export type AnimationConfig = {
   type?: string
@@ -8,50 +44,10 @@ export type AnimationConfig = {
 }
 
 /**
- * Input format for the transition prop - supports multiple syntaxes:
- *
- * 1. String: "bouncy"
- * 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }
- * 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]
- * 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }
+ * Input format for the `transition` prop: a CSS transition string, a preset
+ * name, or a config object. See `@tamagui/style-grammar/transitions`.
  *
- * Note: Uses `any` to be compatible with the TransitionProp type from @tamagui/web
- * which has more complex union types.
+ * Note: uses `any` to stay compatible with the `TransitionProp` type from
+ * `@tamagui/web`, which carries the full style-key union.
  */
 export type TransitionPropInput = any
-
-/**
- * Spring configuration parameters that can override preset defaults.
- * These are the common parameters across animation drivers.
- */
-export type SpringConfig = {
-  stiffness?: number
-  damping?: number
-  mass?: number
-  tension?: number
-  friction?: number
-  velocity?: number
-  overshootClamping?: boolean
-  duration?: number
-  bounciness?: number
-  speed?: number
-}
-
-/**
- * Normalized output format that all animation drivers consume.
- * Provides a consistent structure regardless of input format.
- */
-export type NormalizedTransition = {
-  /** Default animation key for properties not explicitly listed */
-  default: string | null
-  /** Animation key to use during enter transitions (mount) */
-  enter: string | null
-  /** Animation key to use during exit transitions (unmount) */
-  exit: string | null
-  /** Global delay in ms */
-  delay: number | undefined
-  /** Per-property animation configs: propertyName -> animationKey or config */
-  properties: Record<string, string | AnimationConfig>
-  /** Global spring config overrides that merge with the preset defaults */
-  config?: SpringConfig
-}

package/types/index.d.ts

@@ -1,4 +1,8 @@
-export { normalizeTransition, getAnimationForProperty, hasAnimation, getAnimatedProperties, getEffectiveAnimation, getAnimationConfigsForKeys } from "./normalizeTransition";
-export type { AnimationConfig, NormalizedTransition, TransitionPropInput } from "./types";
+export { animationPresets } from "./presets";
+export { canonicalTransitionProperty, isTransformProperty, styleKeysForProperty } from "./propertyNames";
+export { getTransitionResolver, setTransitionResolver, type TransitionResolver } from "./transitionResolver";
+export { easingToBezier, entryToCSS, forAnimationState, getMaxDurationMs, getSettleMs, getTransitionForKey, hasTransition, presetToTiming, resolveTransition, toCSSTransition } from "./resolveTransition";
+export type { DriverTiming, ResolvedEntry, ResolvedTransition, ResolveTransitionOptions } from "./resolveTransition";
+export type { AnimationConfig, AnimationsConfig, PresetConfig, TransitionPropInput } from "./types";
 
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1,11 +1,11 @@
 {
-  "mappings": "AAAA,SACE,qBACA,yBACA,cACA,uBACA,uBACA,kCACK;AAEP,cAAc,iBAAiB,sBAAsB,2BAA2B",
+  "mappings": "AAAA,SAAS,wBAAwB;AAEjC,SACE,6BACA,qBACA,4BACK;AAEP,SACE,uBACA,4BACK,0BACA;AAEP,SACE,gBACA,YACA,mBACA,kBACA,aACA,qBACA,eACA,gBACA,mBACA,uBACK;AAEP,cACE,cACA,eACA,oBACA,gCACK;AAEP,cACE,iBACA,kBACA,cACA,2BACK",
   "names": [],
   "sources": [
     "src/index.ts"
   ],
   "version": 3,
   "sourcesContent": [
-    "export {\n  normalizeTransition,\n  getAnimationForProperty,\n  hasAnimation,\n  getAnimatedProperties,\n  getEffectiveAnimation,\n  getAnimationConfigsForKeys,\n} from './normalizeTransition'\n\nexport type { AnimationConfig, NormalizedTransition, TransitionPropInput } from './types'\n"
+    "export { animationPresets } from './presets'\n\nexport {\n  canonicalTransitionProperty,\n  isTransformProperty,\n  styleKeysForProperty,\n} from './propertyNames'\n\nexport {\n  getTransitionResolver,\n  setTransitionResolver,\n  type TransitionResolver,\n} from './transitionResolver'\n\nexport {\n  easingToBezier,\n  entryToCSS,\n  forAnimationState,\n  getMaxDurationMs,\n  getSettleMs,\n  getTransitionForKey,\n  hasTransition,\n  presetToTiming,\n  resolveTransition,\n  toCSSTransition,\n} from './resolveTransition'\n\nexport type {\n  DriverTiming,\n  ResolvedEntry,\n  ResolvedTransition,\n  ResolveTransitionOptions,\n} from './resolveTransition'\n\nexport type {\n  AnimationConfig,\n  AnimationsConfig,\n  PresetConfig,\n  TransitionPropInput,\n} from './types'\n"
   ]
 }

package/types/presets.d.ts

@@ -0,0 +1,79 @@
+/**
+* The shipped animation presets, defined once for every driver.
+*
+* Before v3 each driver carried its own hand-tuned table, so `bouncy` was a
+* 350ms cubic-bezier on the web, a stiffness-120 spring on react-native, and a
+* stiffness-90 spring on motion. Three different motions under one name.
+*
+* They are springs in the canonical pair instead:
+*
+* - `duration` is the spring's undamped period, which is what "how fast does
+*   this feel" actually means. It is not a stopwatch: a bouncy spring keeps
+*   ringing past it, which is the point of a bouncy spring.
+* - `bounce` is 0 for critically damped (fast, no overshoot), up toward 1 for
+*   loose and oscillating, and negative for sluggish.
+*
+* On the web these compile to a `linear()` easing that traces the real spring
+* curve, overshoot included, with no javascript running.
+*
+* There are no `'200ms'`-style presets any more. A duration is CSS now, so
+* `transition="200ms"` and `transition="200ms ease-out"` work directly and
+* need nothing configured. Keep your own table small for the same reason:
+* a name is worth having only when it means something a duration cannot say.
+*/
+export declare const animationPresets: {
+	readonly quickest: {
+		readonly duration: 120;
+		readonly bounce: 0.2;
+	};
+	readonly quickestLessBouncy: {
+		readonly duration: 120;
+		readonly bounce: 0;
+	};
+	readonly quicker: {
+		readonly duration: 160;
+		readonly bounce: 0.25;
+	};
+	readonly quickerLessBouncy: {
+		readonly duration: 160;
+		readonly bounce: 0;
+	};
+	readonly quick: {
+		readonly duration: 220;
+		readonly bounce: 0.3;
+	};
+	readonly quickLessBouncy: {
+		readonly duration: 220;
+		readonly bounce: 0;
+	};
+	readonly medium: {
+		readonly duration: 300;
+		readonly bounce: 0.15;
+	};
+	readonly slow: {
+		readonly duration: 450;
+		readonly bounce: 0.1;
+	};
+	readonly slowest: {
+		readonly duration: 700;
+		readonly bounce: 0.1;
+	};
+	readonly lazy: {
+		readonly duration: 500;
+		readonly bounce: -0.2;
+	};
+	readonly superLazy: {
+		readonly duration: 800;
+		readonly bounce: -0.3;
+	};
+	readonly bouncy: {
+		readonly duration: 400;
+		readonly bounce: 0.5;
+	};
+	readonly superBouncy: {
+		readonly duration: 400;
+		readonly bounce: 0.75;
+	};
+};
+
+//# sourceMappingURL=presets.d.ts.map

package/types/presets.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,cAAM;UACX;WAAY,UAAU;WAAK,QAAQ;;UACnC;WAAsB,UAAU;WAAK,QAAQ;;UAC7C;WAAW,UAAU;WAAK,QAAQ;;UAClC;WAAqB,UAAU;WAAK,QAAQ;;UAC5C;WAAS,UAAU;WAAK,QAAQ;;UAChC;WAAmB,UAAU;WAAK,QAAQ;;UAC1C;WAAU,UAAU;WAAK,QAAQ;;UACjC;WAAQ,UAAU;WAAK,QAAQ;;UAC/B;WAAW,UAAU;WAAK,QAAQ;;UAClC;WAAQ,UAAU;WAAK,QAAQ,CAAC;;UAChC;WAAa,UAAU;WAAK,QAAQ,CAAC;;UACrC;WAAU,UAAU;WAAK,QAAQ;;UACjC;WAAe,UAAU;WAAK,QAAQ",
+  "names": [],
+  "sources": [
+    "src/presets.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { AnimationsConfig } from './types'\n\n/**\n * The shipped animation presets, defined once for every driver.\n *\n * Before v3 each driver carried its own hand-tuned table, so `bouncy` was a\n * 350ms cubic-bezier on the web, a stiffness-120 spring on react-native, and a\n * stiffness-90 spring on motion. Three different motions under one name.\n *\n * They are springs in the canonical pair instead:\n *\n * - `duration` is the spring's undamped period, which is what \"how fast does\n *   this feel\" actually means. It is not a stopwatch: a bouncy spring keeps\n *   ringing past it, which is the point of a bouncy spring.\n * - `bounce` is 0 for critically damped (fast, no overshoot), up toward 1 for\n *   loose and oscillating, and negative for sluggish.\n *\n * On the web these compile to a `linear()` easing that traces the real spring\n * curve, overshoot included, with no javascript running.\n *\n * There are no `'200ms'`-style presets any more. A duration is CSS now, so\n * `transition=\"200ms\"` and `transition=\"200ms ease-out\"` work directly and\n * need nothing configured. Keep your own table small for the same reason:\n * a name is worth having only when it means something a duration cannot say.\n */\nexport const animationPresets = {\n  quickest: { duration: 120, bounce: 0.2 },\n  quickestLessBouncy: { duration: 120, bounce: 0 },\n  quicker: { duration: 160, bounce: 0.25 },\n  quickerLessBouncy: { duration: 160, bounce: 0 },\n  quick: { duration: 220, bounce: 0.3 },\n  quickLessBouncy: { duration: 220, bounce: 0 },\n  medium: { duration: 300, bounce: 0.15 },\n  slow: { duration: 450, bounce: 0.1 },\n  slowest: { duration: 700, bounce: 0.1 },\n  lazy: { duration: 500, bounce: -0.2 },\n  superLazy: { duration: 800, bounce: -0.3 },\n  bouncy: { duration: 400, bounce: 0.5 },\n  superBouncy: { duration: 400, bounce: 0.75 },\n} as const satisfies AnimationsConfig\n"
+  ]
+}

package/types/propertyNames.d.ts

@@ -0,0 +1,13 @@
+/**
+* the css property name an entry is filed under, so `backgroundColor` and
+* `background-color` are one key and cannot both silently apply.
+*/
+export declare function canonicalTransitionProperty(key: string): string;
+export declare function isTransformProperty(key: string): boolean;
+/**
+* the style keys a css property covers, for drivers that key their per-property
+* options by style key rather than css property (motion, react-native).
+*/
+export declare function styleKeysForProperty(property: string): readonly string[];
+
+//# sourceMappingURL=propertyNames.d.ts.map

package/types/propertyNames.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;;AA0CA,OAAO,iBAAS,4BAA4B;AAO5C,OAAO,iBAAS,oBAAoB;;;;;AAwBpC,OAAO,iBAAS,qBAAqB",
+  "names": [],
+  "sources": [
+    "src/propertyNames.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// which css property a tamagui style key animates under.\n//\n// this is a module of its own, with no imports, because `@tamagui/web` needs\n// it on every styled component while the parser and the spring solver in\n// `resolveTransition` are only needed when a driver is in the bundle.\n\n/**\n * transform parts map onto the css property that actually animates them.\n * `translate`, `scale`, and `rotate` are real individual transform properties;\n * everything else can only be reached through `transform` as a whole.\n *\n * collapsing here is deliberate. css cannot animate `rotateX` separately from\n * `skewY` (both live in `transform`), so letting a js driver do it would be a\n * capability that silently disappears the moment you build for the web.\n */\nconst transformProperties: Record<string, string> = {\n  x: 'translate',\n  y: 'translate',\n  z: 'translate',\n  translate: 'translate',\n  translateX: 'translate',\n  translateY: 'translate',\n  translateZ: 'translate',\n  scale: 'scale',\n  scaleX: 'scale',\n  scaleY: 'scale',\n  scaleZ: 'scale',\n  rotate: 'rotate',\n  rotateX: 'transform',\n  rotateY: 'transform',\n  rotateZ: 'transform',\n  skewX: 'transform',\n  skewY: 'transform',\n  perspective: 'transform',\n  matrix: 'transform',\n  transform: 'transform',\n}\n\n/**\n * the css property name an entry is filed under, so `backgroundColor` and\n * `background-color` are one key and cannot both silently apply.\n */\nexport function canonicalTransitionProperty(key: string): string {\n  if (key === 'all' || key === 'none') return key\n  const transform = transformProperties[key]\n  if (transform) return transform\n  return key.includes('-') ? key : key.replace(/[A-Z]/g, '-$&').toLowerCase()\n}\n\nexport function isTransformProperty(key: string): boolean {\n  return key in transformProperties\n}\n\nconst styleKeysByProperty: Record<string, readonly string[]> = {\n  translate: ['translate', 'translateX', 'translateY', 'translateZ', 'x', 'y', 'z'],\n  scale: ['scale', 'scaleX', 'scaleY', 'scaleZ'],\n  rotate: ['rotate'],\n  transform: [\n    'transform',\n    'rotateX',\n    'rotateY',\n    'rotateZ',\n    'skewX',\n    'skewY',\n    'perspective',\n    'matrix',\n  ],\n}\n\n/**\n * the style keys a css property covers, for drivers that key their per-property\n * options by style key rather than css property (motion, react-native).\n */\nexport function styleKeysForProperty(property: string): readonly string[] {\n  const transform = styleKeysByProperty[property]\n  if (transform) return transform\n  return [property.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase())]\n}\n"
+  ]
+}

package/types/resolveTransition.d.ts

@@ -0,0 +1,108 @@
+import { type TransitionBehavior, type TransitionDiagnostic, type TransitionObjectValue } from "@tamagui/style-grammar/transitions";
+export type DriverTiming = {
+	kind: "timing";
+	durationMs: number;
+	easing: string;
+} | {
+	kind: "spring";
+	/** the undamped period, the portable "how fast does this feel" number */
+	durationMs: number;
+	bounce: number;
+	stiffness: number;
+	damping: number;
+	mass: number;
+	/** authored low-level overrides, for drivers that take them raw */
+	extra?: Record<string, unknown>;
+};
+export interface ResolvedEntry {
+	/** canonical property name, kebab-case, or `all` / `none` */
+	property: string;
+	timing: DriverTiming;
+	delayMs: number;
+	behavior: TransitionBehavior;
+}
+export interface ResolvedTransition {
+	/** in authored order; later entries win under the css last-wins rule */
+	entries: readonly ResolvedEntry[];
+	/** the winning `all` entry, or null when only specific properties were named */
+	all: ResolvedEntry | null;
+	/** winning entry per canonical property name, excluding `all` */
+	byProperty: Readonly<Record<string, ResolvedEntry>>;
+	/** true when the author disabled transitions entirely (`transition="none"`) */
+	none: boolean;
+	/**
+	* true when any entry was authored as a preset name or a `spring()`, the two
+	* things that have no css spelling of their own. a resolution without one is
+	* already plain css and needs no driver at all.
+	*/
+	fused: boolean;
+	/** replaces this whole resolution while mounting, when the author set one */
+	enter: ResolvedTransition | null;
+	/** replaces this whole resolution while unmounting */
+	exit: ResolvedTransition | null;
+	diagnostics: readonly TransitionDiagnostic[];
+}
+/** the resolution that applies in a given animation state */
+export declare function forAnimationState(resolved: ResolvedTransition, state: "enter" | "exit" | "default"): ResolvedTransition;
+/**
+* turns one entry in a driver's `animations` config into a timing.
+*
+* accepts every shape `PresetConfig` allows: a css string (`'350ms ease-out'`),
+* spring physics (`{ type: 'spring', damping, stiffness, mass }`), a timing
+* (`{ type: 'timing', duration, easing }`), and the canonical pair
+* (`{ duration, bounce }`). configs written for any driver therefore resolve
+* to the same motion on all four.
+*/
+export declare function presetToTiming(preset: unknown): DriverTiming | null;
+/**
+* a css easing as cubic-bezier control points, which is the only easing shape
+* reanimated, motion, and react-native all accept.
+*
+* returns null for `steps()` and `linear()`, which have no bezier equivalent.
+* a driver that gets null should fall back to its own default rather than
+* pretending it applied something.
+*/
+export declare function easingToBezier(easing: string): readonly [number, number, number, number] | null;
+export interface ResolveTransitionOptions {
+	/** the driver's animations config; its keys are the valid preset names */
+	animations?: Record<string, unknown> | null;
+	/** config shorthands, so `transition="bg 200ms"` names backgroundColor */
+	shorthands?: Record<string, string> | null;
+}
+/**
+* parses and resolves a `transition` prop into driver-ready entries.
+*
+* memoized per (animations config, authored value), because this runs on every
+* render of every component carrying a transition.
+*/
+export declare function resolveTransition(transition: TransitionObjectValue | null | undefined, options?: ResolveTransitionOptions): ResolvedTransition;
+/**
+* the transition that applies to one style key, under css last-wins.
+*
+* an authored `transform` already expanded into the whole family in
+* `fromEntries`, so `x`, `scale` and `rotate` find a direct entry here.
+*/
+export declare function getTransitionForKey(resolved: ResolvedTransition, key: string): ResolvedEntry | null;
+/** true when anything at all will animate */
+export declare function hasTransition(resolved: ResolvedTransition): boolean;
+/**
+* how long a timing actually runs, which for a spring is its settle time and
+* not its nominal duration. this is the number a completion deadline needs.
+*/
+export declare function getSettleMs(timing: DriverTiming): number;
+/** the longest anything will take, for the driver's completion bookkeeping */
+export declare function getMaxDurationMs(resolved: ResolvedTransition): number;
+/**
+* one entry as css. a spring becomes a `linear()` easing sampled across its
+* settle time, which is how a real spring curve, overshoot included, survives
+* with no javascript running.
+*/
+export declare function entryToCSS(entry: ResolvedEntry): string;
+/**
+* the whole resolution as a css `transition` value, or `undefined` when
+* nothing animates. entry order is preserved, so css last-wins does the
+* per-property resolution for us in the browser.
+*/
+export declare function toCSSTransition(resolved: ResolvedTransition): string | undefined;
+
+//# sourceMappingURL=resolveTransition.d.ts.map

package/types/resolveTransition.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAaA,cAOO,yBACA,2BAEA,6BAEA;AAKP,YAAY,eACR;CACE,MAAM;CACN;CACA;IAEF;CACE,MAAM;;CAEN;CACA;CACA;CACA;CACA;;CAEA,QAAQ;;AAGd,iBAAiB,cAAc;;CAE7B;CACA,QAAQ;CACR;CACA,UAAU;;AAGZ,iBAAiB,mBAAmB;;CAElC,kBAAkB;;CAElB,KAAK;;CAEL,YAAY,SAAS,eAAe;;CAEpC;;;;;;CAMA;;CAEA,OAAO;;CAEP,MAAM;CACN,sBAAsB;;;AAexB,OAAO,iBAAS,kBACd,UAAU,oBACV,OAAO,UAAU,SAAS,YACzB;;;;;;;;;;AAuCH,OAAO,iBAAS,eAAe,kBAAkB;;;;;;;;;AAwIjD,OAAO,iBAAS,eACd;AAYF,iBAAiB,yBAAyB;;CAExC,aAAa;;CAEb,aAAa;;;;;;;;AAaf,OAAO,iBAAS,kBACd,YAAY,0CACZ,UAAS,2BACR;;;;;;;AAyHH,OAAO,iBAAS,oBACd,UAAU,oBACV,cACC;;AAQH,OAAO,iBAAS,cAAc,UAAU;;;;;AAQxC,OAAO,iBAAS,YAAY,QAAQ;;AAMpC,OAAO,iBAAS,iBAAiB,UAAU;;;;;;AAgB3C,OAAO,iBAAS,WAAW,OAAO;;;;;;AA0BlC,OAAO,iBAAS,gBAAgB,UAAU",
+  "names": [],
+  "sources": [
+    "src/resolveTransition.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// the one place a `transition` prop becomes driver-ready values.\n//\n// every driver and `getSplitStyles` call `resolveTransition`, so there is a\n// single grammar, a single preset lookup, and a single spring solver behind\n// css, reanimated, motion, and react-native. a transition that means one thing\n// on one driver cannot mean something else on another, because none of them\n// decide anything on their own any more.\n//\n// the shape is CSS's: an ordered entry list where the LAST entry naming a\n// property wins for that property, and entries do not inherit from each other.\n// `transition=\"all 200ms, opacity 150ms ease-out\"` reads exactly as it does in\n// a stylesheet.\n\nimport {\n  parseTransition,\n  parseTransitionObject,\n  springFromDurationBounce,\n  springSettleTime,\n  springToDurationBounce,\n  springToLinearEasing,\n  type TransitionBehavior,\n  type TransitionDiagnostic,\n  type TransitionEntry,\n  type TransitionObjectValue,\n  type TransitionTiming,\n} from '@tamagui/style-grammar/transitions'\n\nimport { canonicalTransitionProperty } from './propertyNames'\nimport { setTransitionResolver } from './transitionResolver'\n\nexport type DriverTiming =\n  | {\n      kind: 'timing'\n      durationMs: number\n      easing: string\n    }\n  | {\n      kind: 'spring'\n      /** the undamped period, the portable \"how fast does this feel\" number */\n      durationMs: number\n      bounce: number\n      stiffness: number\n      damping: number\n      mass: number\n      /** authored low-level overrides, for drivers that take them raw */\n      extra?: Record<string, unknown>\n    }\n\nexport interface ResolvedEntry {\n  /** canonical property name, kebab-case, or `all` / `none` */\n  property: string\n  timing: DriverTiming\n  delayMs: number\n  behavior: TransitionBehavior\n}\n\nexport interface ResolvedTransition {\n  /** in authored order; later entries win under the css last-wins rule */\n  entries: readonly ResolvedEntry[]\n  /** the winning `all` entry, or null when only specific properties were named */\n  all: ResolvedEntry | null\n  /** winning entry per canonical property name, excluding `all` */\n  byProperty: Readonly<Record<string, ResolvedEntry>>\n  /** true when the author disabled transitions entirely (`transition=\"none\"`) */\n  none: boolean\n  /**\n   * true when any entry was authored as a preset name or a `spring()`, the two\n   * things that have no css spelling of their own. a resolution without one is\n   * already plain css and needs no driver at all.\n   */\n  fused: boolean\n  /** replaces this whole resolution while mounting, when the author set one */\n  enter: ResolvedTransition | null\n  /** replaces this whole resolution while unmounting */\n  exit: ResolvedTransition | null\n  diagnostics: readonly TransitionDiagnostic[]\n}\n\nconst emptyResolved: ResolvedTransition = {\n  entries: [],\n  all: null,\n  byProperty: {},\n  none: false,\n  fused: false,\n  enter: null,\n  exit: null,\n  diagnostics: [],\n}\n\n/** the resolution that applies in a given animation state */\nexport function forAnimationState(\n  resolved: ResolvedTransition,\n  state: 'enter' | 'exit' | 'default'\n): ResolvedTransition {\n  if (state === 'enter' && resolved.enter) return resolved.enter\n  if (state === 'exit' && resolved.exit) return resolved.exit\n  return resolved\n}\n\nfunction timeToMs(value: string): number {\n  // the grammar guarantees a `<number>ms` or `<number>s` token here\n  return value.endsWith('ms') ? Number.parseFloat(value) : Number.parseFloat(value) * 1000\n}\n\nfunction springTiming(\n  durationMs: number,\n  bounce: number,\n  extra?: Record<string, unknown>\n): DriverTiming {\n  const mass = typeof extra?.mass === 'number' ? extra.mass : 1\n  const physics = springFromDurationBounce({ duration: durationMs, bounce }, mass)\n  return {\n    kind: 'spring',\n    durationMs,\n    bounce,\n    // authored physics win over the derived pair, so the escape hatch is exact\n    stiffness: typeof extra?.stiffness === 'number' ? extra.stiffness : physics.stiffness,\n    damping: typeof extra?.damping === 'number' ? extra.damping : physics.damping,\n    mass,\n    extra,\n  }\n}\n\n/**\n * turns one entry in a driver's `animations` config into a timing.\n *\n * accepts every shape `PresetConfig` allows: a css string (`'350ms ease-out'`),\n * spring physics (`{ type: 'spring', damping, stiffness, mass }`), a timing\n * (`{ type: 'timing', duration, easing }`), and the canonical pair\n * (`{ duration, bounce }`). configs written for any driver therefore resolve\n * to the same motion on all four.\n */\nexport function presetToTiming(preset: unknown): DriverTiming | null {\n  if (typeof preset === 'string') {\n    const parsed = parseTransition(preset)\n    if (!parsed.ok || parsed.value.kind !== 'transition') return null\n    const entry = parsed.value.entries[0]\n    if (!entry) return null\n    return timingToDriver(entry.timing, null)\n  }\n\n  if (!preset || typeof preset !== 'object') return null\n  const config = preset as Record<string, unknown>\n  const duration = typeof config.duration === 'number' ? config.duration : undefined\n  const hasPhysics =\n    typeof config.stiffness === 'number' || typeof config.damping === 'number'\n\n  const stiffness = typeof config.stiffness === 'number' ? config.stiffness : undefined\n  const damping = typeof config.damping === 'number' ? config.damping : undefined\n\n  const isSpring =\n    config.type === 'spring' || typeof config.bounce === 'number' || hasPhysics\n\n  if (isSpring) {\n    const mass = typeof config.mass === 'number' ? config.mass : 1\n    if (stiffness !== undefined) {\n      const canonical = springToDurationBounce({\n        stiffness,\n        damping: damping ?? 2 * Math.sqrt(stiffness * mass),\n        mass,\n      })\n      return {\n        kind: 'spring',\n        durationMs: duration ?? canonical.duration,\n        bounce: typeof config.bounce === 'number' ? config.bounce : canonical.bounce,\n        stiffness,\n        damping: damping ?? 2 * Math.sqrt(stiffness * mass),\n        mass,\n        extra: config,\n      }\n    }\n    if (duration !== undefined) {\n      return springTiming(\n        duration,\n        typeof config.bounce === 'number' ? config.bounce : 0,\n        config\n      )\n    }\n    return null\n  }\n\n  if (duration === undefined) return null\n  const easing = typeof config.easing === 'string' ? config.easing : 'ease'\n  return { kind: 'timing', durationMs: duration, easing }\n}\n\n/**\n * lowers a grammar timing atom into driver values, resolving a preset name\n * against the driver's configured animations.\n */\nfunction timingToDriver(\n  timing: TransitionTiming,\n  animations: Record<string, unknown> | null\n): DriverTiming | null {\n  if (timing.type === 'css') {\n    return {\n      kind: 'timing',\n      durationMs: timeToMs(timing.duration),\n      easing: timing.timingFunction,\n    }\n  }\n\n  if (timing.type === 'spring') {\n    return springTiming(\n      timeToMs(timing.duration),\n      timing.bounce,\n      timing.config as Record<string, unknown> | undefined\n    )\n  }\n\n  const preset = animations?.[timing.name]\n  if (preset === undefined) return null\n  const base = presetToTiming(preset)\n  if (!base || !timing.config) return base\n\n  // authored overrides land on top of the preset, in the preset's own terms\n  const overrides = timing.config as Record<string, unknown>\n  if (base.kind === 'spring' || typeof overrides.bounce === 'number') {\n    const overrideDuration =\n      typeof overrides.duration === 'number'\n        ? overrides.duration\n        : typeof overrides.duration === 'string'\n          ? timeToMs(overrides.duration)\n          : undefined\n    const overrideBounce =\n      typeof overrides.bounce === 'number' ? overrides.bounce : undefined\n    const durationMs = overrideDuration ?? base.durationMs\n    const bounce = overrideBounce ?? (base.kind === 'spring' ? base.bounce : 0)\n    let carried = base.kind === 'spring' ? base.extra : undefined\n    // a duration or bounce override re-solves the spring, so a preset written as\n    // stiffness/damping cannot pass those two through: they ARE what the\n    // override replaces. mass belongs to the object rather than the curve, so it\n    // carries. physics written in the override still win, exactly as elsewhere.\n    if (carried && (overrideDuration !== undefined || overrideBounce !== undefined)) {\n      const { stiffness, damping, ...rest } = carried\n      carried = rest\n    }\n    return springTiming(durationMs, bounce, { ...carried, ...overrides })\n  }\n\n  return {\n    kind: 'timing',\n    durationMs:\n      typeof overrides.duration === 'number'\n        ? overrides.duration\n        : typeof overrides.duration === 'string'\n          ? timeToMs(overrides.duration)\n          : base.durationMs,\n    easing: typeof overrides.easing === 'string' ? overrides.easing : base.easing,\n  }\n}\n\nconst namedEasings: Record<string, readonly [number, number, number, number]> = {\n  linear: [0, 0, 1, 1],\n  ease: [0.25, 0.1, 0.25, 1],\n  'ease-in': [0.42, 0, 1, 1],\n  'ease-out': [0, 0, 0.58, 1],\n  'ease-in-out': [0.42, 0, 0.58, 1],\n}\n\n/**\n * a css easing as cubic-bezier control points, which is the only easing shape\n * reanimated, motion, and react-native all accept.\n *\n * returns null for `steps()` and `linear()`, which have no bezier equivalent.\n * a driver that gets null should fall back to its own default rather than\n * pretending it applied something.\n */\nexport function easingToBezier(\n  easing: string\n): readonly [number, number, number, number] | null {\n  const named = namedEasings[easing]\n  if (named) return named\n  if (!easing.startsWith('cubic-bezier(')) return null\n  const parts = easing.slice('cubic-bezier('.length, -1).split(',')\n  if (parts.length !== 4) return null\n  const points = parts.map((part) => Number.parseFloat(part))\n  if (points.some((point) => !Number.isFinite(point))) return null\n  return points as unknown as [number, number, number, number]\n}\n\nexport interface ResolveTransitionOptions {\n  /** the driver's animations config; its keys are the valid preset names */\n  animations?: Record<string, unknown> | null\n  /** config shorthands, so `transition=\"bg 200ms\"` names backgroundColor */\n  shorthands?: Record<string, string> | null\n}\n\nconst cacheByAnimations = new WeakMap<object, Map<string, ResolvedTransition>>()\nconst objectCache = new WeakMap<object, ResolvedTransition>()\nconst noAnimations: Record<string, unknown> = {}\n\n/**\n * parses and resolves a `transition` prop into driver-ready entries.\n *\n * memoized per (animations config, authored value), because this runs on every\n * render of every component carrying a transition.\n */\nexport function resolveTransition(\n  transition: TransitionObjectValue | null | undefined,\n  options: ResolveTransitionOptions = {}\n): ResolvedTransition {\n  if (transition == null || transition === '') return emptyResolved\n\n  const animations = options.animations ?? null\n  const cacheKey = (animations ?? noAnimations) as object\n\n  if (typeof transition === 'string') {\n    let byValue = cacheByAnimations.get(cacheKey)\n    if (!byValue) {\n      byValue = new Map()\n      cacheByAnimations.set(cacheKey, byValue)\n    }\n    const hit = byValue.get(transition)\n    if (hit) return hit\n    const built = buildResolved(transition, animations, options.shorthands ?? null)\n    // an authored value set is bounded in practice, but a codegen loop is not\n    if (byValue.size > 2048) byValue.clear()\n    byValue.set(transition, built)\n    return built\n  }\n\n  if (typeof transition !== 'object') return emptyResolved\n  const hit = objectCache.get(transition)\n  if (hit) return hit\n  const built = buildResolved(transition, animations, options.shorthands ?? null)\n  objectCache.set(transition, built)\n  return built\n}\n\nfunction buildResolved(\n  transition: TransitionObjectValue,\n  animations: Record<string, unknown> | null,\n  shorthands: Record<string, string> | null\n): ResolvedTransition {\n  const presetNames = animations ? new Set(Object.keys(animations)) : undefined\n  const parsed = parseTransitionObject(transition, presetNames)\n\n  if (!parsed.ok) {\n    return { ...emptyResolved, diagnostics: parsed.diagnostics }\n  }\n  if (parsed.value.kind !== 'transition') return emptyResolved\n\n  return fromEntries(\n    parsed.value.entries,\n    animations,\n    shorthands,\n    parsed.value.enter\n      ? fromEntries(parsed.value.enter, animations, shorthands, null, null)\n      : null,\n    parsed.value.exit\n      ? fromEntries(parsed.value.exit, animations, shorthands, null, null)\n      : null\n  )\n}\n\nconst transformFamily = ['transform', 'translate', 'scale', 'rotate'] as const\n\nfunction fromEntries(\n  source: readonly TransitionEntry[],\n  animations: Record<string, unknown> | null,\n  shorthands: Record<string, string> | null,\n  enter: ResolvedTransition | null,\n  exit: ResolvedTransition | null\n): ResolvedTransition {\n  const entries: ResolvedEntry[] = []\n  const byProperty: Record<string, ResolvedEntry> = {}\n  const diagnostics: TransitionDiagnostic[] = []\n  let all: ResolvedEntry | null = null\n  let none = false\n  let fused = false\n\n  for (const entry of source) {\n    if (entry.property === 'none') {\n      none = true\n      continue\n    }\n\n    if (entry.timing.type !== 'css') fused = true\n\n    const timing = timingToDriver(entry.timing, animations)\n    if (!timing) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: entry.timing.type === 'preset' ? entry.timing.name : undefined,\n        message:\n          entry.timing.type === 'preset'\n            ? `\"${entry.timing.name}\" is not a configured animation`\n            : 'transition timing could not be resolved',\n      })\n      continue\n    }\n\n    const expanded = shorthands?.[entry.property] ?? entry.property\n    const property = canonicalTransitionProperty(expanded)\n    const delayMs = timeToMs(entry.delay)\n    // tamagui writes x/y into the css `translate` longhand, scale into\n    // `scale` and rotate into `rotate`, so an authored `transform` covers the\n    // whole family or it transitions nothing the author can see.\n    for (const name of expanded === 'transform' ? transformFamily : [property]) {\n      const resolved: ResolvedEntry = {\n        property: name,\n        timing,\n        delayMs,\n        behavior: entry.behavior,\n      }\n      entries.push(resolved)\n      // last wins, exactly as a stylesheet resolves a repeated property\n      if (name === 'all') all = resolved\n      else byProperty[name] = resolved\n    }\n  }\n\n  return { entries, all, byProperty, none, fused, enter, exit, diagnostics }\n}\n\n/**\n * the transition that applies to one style key, under css last-wins.\n *\n * an authored `transform` already expanded into the whole family in\n * `fromEntries`, so `x`, `scale` and `rotate` find a direct entry here.\n */\nexport function getTransitionForKey(\n  resolved: ResolvedTransition,\n  key: string\n): ResolvedEntry | null {\n  if (resolved.none) return null\n  const direct = resolved.byProperty[canonicalTransitionProperty(key)]\n  if (direct) return direct\n  return resolved.all\n}\n\n/** true when anything at all will animate */\nexport function hasTransition(resolved: ResolvedTransition): boolean {\n  return !resolved.none && resolved.entries.length > 0\n}\n\n/**\n * how long a timing actually runs, which for a spring is its settle time and\n * not its nominal duration. this is the number a completion deadline needs.\n */\nexport function getSettleMs(timing: DriverTiming): number {\n  if (timing.kind === 'timing') return timing.durationMs\n  return springSettleTime({ duration: timing.durationMs, bounce: timing.bounce })\n}\n\n/** the longest anything will take, for the driver's completion bookkeeping */\nexport function getMaxDurationMs(resolved: ResolvedTransition): number {\n  let max = 0\n  for (const entry of resolved.entries) {\n    const total = getSettleMs(entry.timing) + entry.delayMs\n    if (total > max) max = total\n  }\n  return max\n}\n\nconst linearEasingCache = new Map<string, { easing: string; durationMs: number }>()\n\n/**\n * one entry as css. a spring becomes a `linear()` easing sampled across its\n * settle time, which is how a real spring curve, overshoot included, survives\n * with no javascript running.\n */\nexport function entryToCSS(entry: ResolvedEntry): string {\n  const delay = entry.delayMs ? ` ${entry.delayMs}ms` : ''\n  const behavior = entry.behavior === 'allow-discrete' ? ' allow-discrete' : ''\n\n  if (entry.timing.kind === 'timing') {\n    return `${entry.property} ${entry.timing.durationMs}ms ${entry.timing.easing}${delay}${behavior}`\n  }\n\n  const key = `${entry.timing.durationMs}/${entry.timing.bounce}`\n  let spring = linearEasingCache.get(key)\n  if (!spring) {\n    spring = springToLinearEasing({\n      duration: entry.timing.durationMs,\n      bounce: entry.timing.bounce,\n    })\n    if (linearEasingCache.size > 256) linearEasingCache.clear()\n    linearEasingCache.set(key, spring)\n  }\n  return `${entry.property} ${Math.round(spring.durationMs)}ms ${spring.easing}${delay}${behavior}`\n}\n\n/**\n * the whole resolution as a css `transition` value, or `undefined` when\n * nothing animates. entry order is preserved, so css last-wins does the\n * per-property resolution for us in the browser.\n */\nexport function toCSSTransition(resolved: ResolvedTransition): string | undefined {\n  if (resolved.none) return 'none'\n  if (!resolved.entries.length) return undefined\n\n  let out = ''\n  for (const entry of resolved.entries) {\n    out += `${out ? ', ' : ''}${entryToCSS(entry)}`\n  }\n  return out || undefined\n}\n\n// see `transitionResolver.ts`: this is what keeps the grammar out of a bundle\n// that has no animation driver in it.\nsetTransitionResolver({ resolve: resolveTransition, toCSS: toCSSTransition })\n"
+  ]
+}

package/types/transitionResolver.d.ts

@@ -0,0 +1,30 @@
+import type { ResolvedTransition } from "./resolveTransition";
+/**
+* `getSplitStyles` needs to know whether a `transition` string is plain css or
+* needs a driver, and that answer has to come from the same grammar the
+* compiler uses. Importing the grammar into `@tamagui/web` would put the
+* parser and the spring solver in every bundle, including one with no
+* animations in it at all, which is about 3.6kb gzip of runtime nobody asked
+* for.
+*
+* So `resolveTransition` registers itself here on import. Loading any driver
+* loads it, and a bundle with no driver in it has no presets to resolve, so
+* the absent resolver is the correct answer rather than a missing one.
+*
+* The slot lives on `globalThis` because a bundler routinely gives one process
+* two copies of this module: Vite's SSR graph and its optimized-deps graph each
+* carry their own, and a module-local `let` then leaves the reader looking at
+* the copy nobody registered into. The server rendered a transition as a static
+* class while the client resolved it to a driver animation, which React reports
+* as a hydration mismatch.
+*/
+export type TransitionResolver = {
+	resolve: (value: any, options: {
+		animations?: any;
+	}) => ResolvedTransition;
+	toCSS: (resolved: ResolvedTransition) => string | undefined;
+};
+export declare function setTransitionResolver(next: TransitionResolver): void;
+export declare function getTransitionResolver(): TransitionResolver | null;
+
+//# sourceMappingURL=transitionResolver.d.ts.map

package/types/transitionResolver.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc,0BAA0B;;;;;;;;;;;;;;;;;;;;AAqBxC,YAAY,qBAAqB;CAC/B,UAAU,YAAY,SAAS;EAAE;OAAuB;CACxD,QAAQ,UAAU;;AAKpB,OAAO,iBAAS,sBAAsB,MAAM;AAI5C,OAAO,iBAAS,yBAAyB",
+  "names": [],
+  "sources": [
+    "src/transitionResolver.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { ResolvedTransition } from './resolveTransition'\n\n/**\n * `getSplitStyles` needs to know whether a `transition` string is plain css or\n * needs a driver, and that answer has to come from the same grammar the\n * compiler uses. Importing the grammar into `@tamagui/web` would put the\n * parser and the spring solver in every bundle, including one with no\n * animations in it at all, which is about 3.6kb gzip of runtime nobody asked\n * for.\n *\n * So `resolveTransition` registers itself here on import. Loading any driver\n * loads it, and a bundle with no driver in it has no presets to resolve, so\n * the absent resolver is the correct answer rather than a missing one.\n *\n * The slot lives on `globalThis` because a bundler routinely gives one process\n * two copies of this module: Vite's SSR graph and its optimized-deps graph each\n * carry their own, and a module-local `let` then leaves the reader looking at\n * the copy nobody registered into. The server rendered a transition as a static\n * class while the client resolved it to a driver animation, which React reports\n * as a hydration mismatch.\n */\nexport type TransitionResolver = {\n  resolve: (value: any, options: { animations?: any }) => ResolvedTransition\n  toCSS: (resolved: ResolvedTransition) => string | undefined\n}\n\nconst slot = Symbol.for('tamagui.transitionResolver')\n\nexport function setTransitionResolver(next: TransitionResolver): void {\n  ;(globalThis as any)[slot] = next\n}\n\nexport function getTransitionResolver(): TransitionResolver | null {\n  return (globalThis as any)[slot] ?? null\n}\n"
+  ]
+}

package/types/types.d.ts

@@ -1,56 +1,49 @@
 /**
-* Animation configuration that can include additional properties
-* like delay, duration, stiffness, damping, etc.
-*/
-export type AnimationConfig = {
-	type?: string;
-	[key: string]: any;
-};
-/**
-* Input format for the transition prop - supports multiple syntaxes:
-*
-* 1. String: "bouncy"
-* 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }
-* 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]
-* 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }
+* One entry in a driver's `animations` config, and the same type for all four
+* drivers: a config written once resolves to the same motion on css,
+* reanimated, motion, and react-native.
 *
-* Note: Uses `any` to be compatible with the TransitionProp type from @tamagui/web
-* which has more complex union types.
-*/
-export type TransitionPropInput = any;
-/**
-* Spring configuration parameters that can override preset defaults.
-* These are the common parameters across animation drivers.
+* The canonical spelling is `{ duration, bounce }`. `duration` is the spring's
+* undamped period, the "how fast does this feel" number, and `bounce` is 0 for
+* critically damped, up toward 1 for loose and oscillating, negative for
+* sluggish. A css string is a timing; `{ type: 'timing' }` is the object
+* spelling of one. `stiffness`/`damping`/`mass` stay available for a config
+* that was already tuned against them.
 */
-export type SpringConfig = {
+export type PresetConfig = string | {
+	type?: "spring";
+	duration?: number;
+	bounce?: number;
 	stiffness?: number;
 	damping?: number;
 	mass?: number;
-	tension?: number;
-	friction?: number;
 	velocity?: number;
 	overshootClamping?: boolean;
-	duration?: number;
-	bounciness?: number;
-	speed?: number;
+	restDisplacementThreshold?: number;
+	restSpeedThreshold?: number;
+} | {
+	type: "timing";
+	duration: number;
+	/** any css timing function */
+	easing?: string;
 };
+/** the `animations` object a driver is created with */
+export type AnimationsConfig = Record<string, PresetConfig>;
 /**
-* Normalized output format that all animation drivers consume.
-* Provides a consistent structure regardless of input format.
+* A resolved animation config in a driver's own terms. Drivers build these
+* from a `ResolvedEntry`; nothing parses one.
 */
-export type NormalizedTransition = {
-	/** Default animation key for properties not explicitly listed */
-	default: string | null;
-	/** Animation key to use during enter transitions (mount) */
-	enter: string | null;
-	/** Animation key to use during exit transitions (unmount) */
-	exit: string | null;
-	/** Global delay in ms */
-	delay: number | undefined;
-	/** Per-property animation configs: propertyName -> animationKey or config */
-	properties: Record<string, string | AnimationConfig>;
-	/** Global spring config overrides that merge with the preset defaults */
-	config?: SpringConfig;
+export type AnimationConfig = {
+	type?: string;
+	[key: string]: any;
 };
+/**
+* Input format for the `transition` prop: a CSS transition string, a preset
+* name, or a config object. See `@tamagui/style-grammar/transitions`.
+*
+* Note: uses `any` to stay compatible with the `TransitionProp` type from
+* `@tamagui/web`, which carries the full style-key union.
+*/
+export type TransitionPropInput = any;
 
 //# sourceMappingURL=types.d.ts.map

package/types/types.d.ts.map

@@ -1,11 +1,11 @@
 {
-  "mappings": ";;;;AAIA,YAAY,kBAAkB;CAC5B;;;;;;;;;;;;;;AAeF,YAAY;;;;;AAMZ,YAAY,eAAe;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;AAOF,YAAY,uBAAuB;;CAEjC;;CAEA;;CAEA;;CAEA;;CAEA,YAAY,wBAAwB;;CAEpC,SAAS",
+  "mappings": ";;;;;;;;;;;;AAYA,YAAY,wBAER;CACE,OAAO;CACP;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;IAEF;CACE,MAAM;CACN;;CAEA;;;AAIN,YAAY,mBAAmB,eAAe;;;;;AAM9C,YAAY,kBAAkB;CAC5B;;;;;;;;;;AAWF,YAAY",
   "names": [],
   "sources": [
     "src/types.ts"
   ],
   "version": 3,
   "sourcesContent": [
-    "/**\n * Animation configuration that can include additional properties\n * like delay, duration, stiffness, damping, etc.\n */\nexport type AnimationConfig = {\n  type?: string\n  [key: string]: any\n}\n\n/**\n * Input format for the transition prop - supports multiple syntaxes:\n *\n * 1. String: \"bouncy\"\n * 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }\n * 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]\n * 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }\n *\n * Note: Uses `any` to be compatible with the TransitionProp type from @tamagui/web\n * which has more complex union types.\n */\nexport type TransitionPropInput = any\n\n/**\n * Spring configuration parameters that can override preset defaults.\n * These are the common parameters across animation drivers.\n */\nexport type SpringConfig = {\n  stiffness?: number\n  damping?: number\n  mass?: number\n  tension?: number\n  friction?: number\n  velocity?: number\n  overshootClamping?: boolean\n  duration?: number\n  bounciness?: number\n  speed?: number\n}\n\n/**\n * Normalized output format that all animation drivers consume.\n * Provides a consistent structure regardless of input format.\n */\nexport type NormalizedTransition = {\n  /** Default animation key for properties not explicitly listed */\n  default: string | null\n  /** Animation key to use during enter transitions (mount) */\n  enter: string | null\n  /** Animation key to use during exit transitions (unmount) */\n  exit: string | null\n  /** Global delay in ms */\n  delay: number | undefined\n  /** Per-property animation configs: propertyName -> animationKey or config */\n  properties: Record<string, string | AnimationConfig>\n  /** Global spring config overrides that merge with the preset defaults */\n  config?: SpringConfig\n}\n"
+    "/**\n * One entry in a driver's `animations` config, and the same type for all four\n * drivers: a config written once resolves to the same motion on css,\n * reanimated, motion, and react-native.\n *\n * The canonical spelling is `{ duration, bounce }`. `duration` is the spring's\n * undamped period, the \"how fast does this feel\" number, and `bounce` is 0 for\n * critically damped, up toward 1 for loose and oscillating, negative for\n * sluggish. A css string is a timing; `{ type: 'timing' }` is the object\n * spelling of one. `stiffness`/`damping`/`mass` stay available for a config\n * that was already tuned against them.\n */\nexport type PresetConfig =\n  | string\n  | {\n      type?: 'spring'\n      duration?: number\n      bounce?: number\n      stiffness?: number\n      damping?: number\n      mass?: number\n      velocity?: number\n      overshootClamping?: boolean\n      restDisplacementThreshold?: number\n      restSpeedThreshold?: number\n    }\n  | {\n      type: 'timing'\n      duration: number\n      /** any css timing function */\n      easing?: string\n    }\n\n/** the `animations` object a driver is created with */\nexport type AnimationsConfig = Record<string, PresetConfig>\n\n/**\n * A resolved animation config in a driver's own terms. Drivers build these\n * from a `ResolvedEntry`; nothing parses one.\n */\nexport type AnimationConfig = {\n  type?: string\n  [key: string]: any\n}\n\n/**\n * Input format for the `transition` prop: a CSS transition string, a preset\n * name, or a config object. See `@tamagui/style-grammar/transitions`.\n *\n * Note: uses `any` to stay compatible with the `TransitionProp` type from\n * `@tamagui/web`, which carries the full style-key union.\n */\nexport type TransitionPropInput = any\n"
   ]
 }