Package-level declarations

Imperative wrapper around AnimatedValue.

A container that animates between content for different targetState values. The target content enters while previously-keyed content exits; both are kept in the container's own subtree (an overlapping StackLayout) until each exit settles — the same container-owned retention model as AnimatedVisibility. No DisappearingHost / rendercore machinery is involved.

Scope for AnimatedContent.transitionSpec. Exposes the initialState and targetState of the current transition (so the spec can vary by direction, e.g. via isTransitioningTo or slideIntoContainer) and collects the enter/exit specs that make up the ContentTransform.

A mutable, animation-aware value holder that implements Value for direct use in Litho Style APIs.

A container that animates its content entering and exiting the render tree.

Coalesces active FrameDrivenAnimations onto a shared AnimationFrameDriver.

A stable descriptor of an animated value's invalidation, recorded each frame the value changes.

The per-render handle returned by useAnimationGroup and the public surface for declaring a group's animations (animateFloat, animateDimen, …).

A handle that controls when an animation begins receiving frame callbacks.

An immutable configuration that defines how an animation should behave.

Strategy interface that controls when an animation begins receiving frame callbacks.

A small, mutable, fixed-size holder for the float components an animated value decomposes into — the currency the spring/tween machinery computes on. A scalar animates as one component, a size as two, a color as four.

A stateless, time-driven computation engine that produces animation values.

TypeConverter for Color values: 4 components (alpha, red, green, blue) blended independently, so two colors that would collide under a single-float projection still animate correctly.

Describes how an AnimatedContent transitions between two states: how the target content enters and how the outgoing content exits, plus an optional size animation.

An Easing defined by a cubic bezier curve.

Represents the damping ratio of a spring animation.

TypeConverter for Dimen values, animating in resolved pixels.

A FiniteAnimationSpec whose forward cycle has a known, fixed duration. Repeating a cycle is only possible when its length is known up front, so repeatable / infiniteRepeatable accept only duration-based specs (springs, which have no fixed cycle, are excluded).

Defines an easing curve that controls the rate of change of an animation over time.

The visibility lifecycle states for enter/exit transitions, shared by the animated container APIs.

Describes how content enters the render tree. Compose multiple effects with plus:

Describes how content exits the render tree. Compose multiple effects with plus:

An AnimationSpec that completes in finite time: it eventually reaches its target and settles.

Identity TypeConverter for Float values.

The per-render handle returned by useInfiniteAnimationGroup and the public surface for declaring a container's loops (animateFloat, animateDimen, …).

An AnimationSpec that never settles — it loops for the lifetime of its owner. Produced by infiniteRepeatable and consumed by useInfiniteAnimation. Deliberately NOT a FiniteAnimationSpec, so the type system keeps it out of target-settling APIs that depend on completion.

TypeConverter for Int values. Rounds the component back to the nearest integer.

Handle returned by KeyframesBuilder.at to allow chaining using for per-segment easing.

Builder for defining keyframes in a KeyframesSpec.

Defines how an animation repeats when it reaches the end of an iteration.

Represents a directional transition segment from initialState to targetState.

Produces the AnimationSpec for an AnimatedContent container size animation between two content sizes. (Reserved for the opt-in, layout-affecting size-morph path.)

The direction content moves during a container-relative slide.

A one-time shift of a repeating animation's start time, used to stagger or delay loops (see repeatable / infiniteRepeatable).

How a StartOffset is applied relative to a repeating animation's first cycle.

Represents the stiffness of a spring animation.

Defines the host properties animated by Style.transition.

Represents timing functions (easing curves) for animations.

Describes the origin point for scale and clip transforms as fractional coordinates within the component's bounds.

Converts a value of type T to and from the AnimationVector the animation system runs on. Each animated type decomposes into a fixed set of float components — 1 for a scalar like Float, 2 for a size, 4 for a color — and the spring/tween machinery drives each component on its own, so a multi-component value carries a real per-component value and per-component velocity rather than being collapsed to one lossy scalar.

Sets the alpha of the View using a Value.

Wraps an Android Interpolator as an Easing.

Converts this Easing to an Android Interpolator.

Sets the background color of the View using a Value.

Equivalent of Transition.SPRING_WITH_OVERSHOOT, the default Transition animator. Keeps the existing motion of code moving off Transition; prefer spring for new code.

Equivalent of Transition.springWithConfig(tension, friction). Keeps the existing motion of code moving off Transition; prefer spring for new code.

Equivalent of Transition.SPRING_WITHOUT_OVERSHOOT.

Equivalent of Transition.timing(durationMs), which eases with accelerate-decelerate. Keeps the existing motion of code moving off Transition; prefer tween for new code.

Equivalent of Transition.timing(durationMs, interpolator). A null interpolator is linear, as it is for Transition.

Sets the elevation of the View using a Value.

Evaluates an intermediate Color between two colors, per channel. Kept as a standalone helper for call sites that blend colors directly.

Expands content horizontally by animating a clip rect from zero width to full width.

Expands content horizontally over duration — a shortcut for expandHorizontally(tween(duration), expandFrom).

Expands content in both directions by animating a clip rect from zero size to full size.

Expands content in both directions over duration — a shortcut for expandIn(tween(duration), expandFrom).

Expands content vertically by animating a clip rect from zero height to full height.

Expands content vertically over duration — a shortcut for expandVertically(tween(duration), expandFrom).

Fades content in from initialAlpha to fully opaque.

Fades content in over duration — a shortcut for fadeIn(tween(duration), initialAlpha).

Fades content out from fully opaque to targetAlpha.

Fades content out over duration — a shortcut for fadeOut(tween(duration), targetAlpha).

Sets a specific preferred height for this component using a Value.

Creates an InfiniteAnimationSpec that repeats animation for the lifetime of its owner. Because it never settles, it can only be consumed by useInfiniteAnimation, not by target-settling APIs.

Creates a KeyframesSpec with the given duration and keyframe definitions.

This Style adds a mount callback for state value.

Creates a FiniteAnimationSpec that repeats animation for a fixed number of iterations.

Sets the rotation of the View using a Value.

Sets the X-axis rotation of the View using a Value.

Sets the Y-axis rotation of the View using a Value.

Sets the scale (scaleX and scaleY) of the View using a Value.

Scales content in from initialScale to full size.

Scales content in over duration — a shortcut for scaleIn(tween(duration), initialScale, transformOrigin).

Scales content out from full size to targetScale.

Scales content out over duration — a shortcut for scaleOut(tween(duration), targetScale, transformOrigin).

Shrinks content horizontally by animating a clip rect from full width to zero width.

Shrinks content horizontally over duration — a shortcut for shrinkHorizontally(tween(duration), shrinkTowards).

Shrinks content out in both directions by animating a clip rect from full size to zero size.

Shrinks content out in both directions over duration — a shortcut for shrinkOut(tween(duration), shrinkTowards).

Shrinks content vertically by animating a clip rect from full height to zero height.

Shrinks content vertically over duration — a shortcut for shrinkVertically(tween(duration), shrinkTowards).

Slides content in horizontally. The initialOffsetX lambda receives the full width of the component and returns the pixel offset to start from.

Slides content in horizontally over duration — a shortcut for slideInHorizontally(tween(duration), initialOffsetX).

Slides the target content into the container, entering from the edge opposite towards and moving in the towards direction to its resting position. Unlike slideInHorizontally / slideInVertically (which offset by the content's own size), the slide is measured across the container's bounds. Only meaningful inside AnimatedContent's transitionSpec.

Slides the target content into the container over duration — a shortcut for slideIntoContainer(towards, tween(duration), initialOffset).

Slides content in vertically. The initialOffsetY lambda receives the full height of the component and returns the pixel offset to start from.

Slides content in vertically over duration — a shortcut for slideInVertically(tween(duration), initialOffsetY).

Slides content out horizontally. The targetOffsetX lambda receives the full width of the component and returns the pixel offset to end at.

Slides content out horizontally over duration — a shortcut for slideOutHorizontally(tween(duration), targetOffsetX).

Slides the outgoing content out of the container in the towards direction. The slide is measured across the container's bounds (see slideIntoContainer). Only meaningful inside AnimatedContent's transitionSpec.

Slides the outgoing content out of the container over duration — a shortcut for slideOutOfContainer(towards, tween(duration), targetOffset).

Slides content out vertically. The targetOffsetY lambda receives the full height of the component and returns the pixel offset to end at.

Slides content out vertically over duration — a shortcut for slideOutVertically(tween(duration), targetOffsetY).

Creates a SnapSpec that instantly jumps to the target value.

Creates a SpringSpec for physics-based spring animations.

Creates an Interpolator from this Timing.

Adds a diff-based transition to the host represented by this Style.

Sets the X-axis translation of the View using a Value.

Sets the Y-axis translation of the View using a Value.

Creates a TweenSpec for time-based animations with an easing curve.

Creates an Animatable for imperative animation control.

Animates a Color value with per-channel interpolation, automatically starting a new animation whenever targetValue changes.

Animates a Dimen value, automatically starting a new animation whenever targetValue changes.

Animates a Float value, automatically starting a new animation whenever targetValue changes.

Animates an Int value, automatically starting a new animation whenever targetValue changes.

Animates a value of type T, automatically starting a new animation whenever targetValue changes.

Coordinates multiple animated properties that respond to a shared targetState.

Creates an InfiniteAnimationGroup container for continuous, lifecycle-owned looping animations — shimmer, pulse, spinners, breathing effects, loading dots. Each child loops between an explicit from and to, starts with the component, and stops when it unmounts.

Returns a stable AnimationTrigger.Lazy instance for explicit manual triggering.

Sets a specific preferred width for this component using a Value.