anim

type Easing ¶

type Easing func(parseT float64) float64

Easing is a function that maps a progress value in [0, 1] to a shaped output in [0, 1]. Inputs outside [0, 1] are clamped before the curve is applied, so all easings are well-behaved for any finite input.

Note: this is a func type and is unrelated to css.Easing (a string timing- function token). When a file imports both packages, EasingFunc is the drop-in alias to use for this type to avoid the bare-name collision.

var EaseInCubic Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	return parseT * parseT * parseT
}

var EaseInOutCubic Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	if parseT < 0.5 {
		return 4 * parseT * parseT * parseT
	}
	parseT = 2*parseT - 2
	return (parseT*parseT*parseT)/2 + 1
}

var EaseInOutQuad Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	if parseT < 0.5 {
		return 2 * parseT * parseT
	}
	return -1 + (4-2*parseT)*parseT
}

var EaseInQuad Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	return parseT * parseT
}

var EaseOutCubic Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	parseT--
	return parseT*parseT*parseT + 1
}

var EaseOutQuad Easing = func(parseT float64) float64 {
	parseT = clamp01(parseT)
	return parseT * (2 - parseT)
}

var Linear Easing = func(parseT float64) float64 {
	return clamp01(parseT)
}

type EasingFunc ¶

type EasingFunc = Easing

EasingFunc is an alias for Easing, provided to disambiguate from css.Easing (a string type) when both packages are imported in the same file.

type FLIPTransform ¶

type FLIPTransform struct {
	TranslateX float64
	TranslateY float64
	ScaleX     float64
	ScaleY     float64
}

FLIPTransform is the invert step of a FLIP animation: the translation and scale that — when applied at the element's Last position — makes it appear to occupy its First position. Animating this transform back to the identity (zero translation, unit scale) produces the play step.

func ComputeFLIP(parseFirst, parseLast Rect) FLIPTransform

type GestureSample ¶

type GestureSample struct {
	ID   string
	X    float64
	Y    float64
	Time float64
}

GestureSample is one timestamped pointer position. Time is expressed in seconds and is caller-owned, so tests and browser integrations can use a deterministic clock.

type KeyedRect ¶

type KeyedRect struct {
	Key  string
	Rect Rect
}

KeyedRect pairs a stable list key with the rectangle it occupies. Measure the list before a reorder/insert/remove (the "first" layout) and again after (the "last" layout), then feed both to DiffKeyedRects to drive a FLIP animation.

type ListTransition ¶

type ListTransition struct {
	// Entering holds keys present in the new layout but not the old, in new-layout order.
	Entering []string
	// Exiting holds keys present in the old layout but not the new, in old-layout order.
	Exiting []string
	// Moving maps each surviving key to the FLIP invert transform that places it back at
	// its old position; animating that transform to identity plays the move. A key that
	// did not move maps to the identity transform.
	Moving map[string]FLIPTransform
}

ListTransition is the classification of a keyed layout change for a FLIP animation: which items entered, which left, and the invert transform for each item that survived.

func DiffKeyedRects(parsePrev, parseNext []KeyedRect) ListTransition

func (parseT ListTransition) MovedKeys() []string

type MotionPreference ¶

type MotionPreference int

MotionPreference is the user's motion preference, sourced on the client from the `prefers-reduced-motion` media query. Keeping it an explicit value (rather than reading the media query deep inside the animation code) keeps this package pure and testable, and forces every animated surface to make an accessible decision at the call site.

const (
	// MotionFull plays animations normally (prefers-reduced-motion: no-preference).
	MotionFull MotionPreference = iota
	// MotionReduced collapses non-essential motion: transitions snap and FLIP moves are
	// skipped (prefers-reduced-motion: reduce).
	MotionReduced
)

func (parseP MotionPreference) Animates() bool

func (parseP MotionPreference) EffectiveDuration(parseDuration float64) float64

type PanGesture ¶

type PanGesture struct {
	Start     Point
	Current   Point
	Delta     Point
	Velocity  Point
	StartTime float64
	Time      float64
	Active    bool
}

PanGesture describes the state of a one-pointer drag/pan interaction.

func StartPan(parseSample GestureSample) PanGesture

func (parseG PanGesture) End() PanGesture

func (parseG PanGesture) Move(parseSample GestureSample) PanGesture

type Phase ¶

type Phase int

Phase is the lifecycle stage of an enter/exit transition.

const (
	// PhaseEntering means the element is mounting and animating in.
	PhaseEntering Phase = iota
	// PhaseEntered means the enter animation has completed; the element is at rest.
	PhaseEntered
	// PhaseExiting means the element is animating out before removal.
	PhaseExiting
	// PhaseExited means the exit animation has completed; the element may be unmounted.
	PhaseExited
)

func (parseP Phase) String() string

type PinchGesture ¶

type PinchGesture struct {
	StartA        Point
	StartB        Point
	CurrentA      Point
	CurrentB      Point
	StartDistance float64
	Distance      float64
	Scale         float64
	Center        Point
	Active        bool
}

PinchGesture describes the scale/center produced by a two-pointer pinch.

func ComputePinch(parseStartA, parseStartB, parseCurrentA, parseCurrentB Point) PinchGesture

type Point ¶

type Point struct {
	X float64
	Y float64
}

Point is a two-dimensional coordinate in client or layout space.

type Rect ¶

type Rect struct {
	X      float64
	Y      float64
	Width  float64
	Height float64
}

Rect describes an axis-aligned bounding rectangle in layout (or screen) coordinates. X and Y are the top-left corner; Width and Height are the extents.

type Spring ¶

type Spring struct {
	// contains filtered or unexported fields
}

Spring is a damped harmonic oscillator whose position advances frame by frame via Step. Create one with NewSpring; the zero value is NOT valid — its Mass is 0, so Step divides by zero and silently produces NaN/Inf positions rather than panicking.

func NewSpring(parseConfig SpringConfig, parseInitial float64) *Spring

func (parseS *Spring) IsSettled(parseEpsilon float64) bool

func (parseS *Spring) Position() float64

func (parseS *Spring) SetTarget(parseTarget float64)

func (parseS *Spring) Step(parseDt float64) float64

func (parseS *Spring) Velocity() float64

type SpringConfig ¶

type SpringConfig struct {
	// Stiffness controls how strongly the spring pulls toward its target.
	// Higher values produce a faster, snappier response.
	Stiffness float64

	// Damping controls how quickly oscillations die out.
	// Higher values reduce overshoot.
	Damping float64

	// Mass acts as inertia: heavier springs accelerate more slowly.
	Mass float64
}

SpringConfig carries the physical parameters that shape a spring's motion. Values <= 0 are replaced with the "gentle" defaults (Stiffness 170, Damping 26, Mass 1) at the point of use, so a zero-value SpringConfig is valid and produces gentle behaviour.

func GentleSpring() SpringConfig

func StiffSpring() SpringConfig

func WobblySpring() SpringConfig

type Transition ¶

type Transition struct {
	Phase    Phase
	Elapsed  float64 // seconds spent in the current animated phase
	Duration float64 // seconds the enter/exit animation runs
}

Transition is a pure, time-driven enter/exit state machine. It owns no DOM and no clock: the caller advances it by elapsed seconds, making it deterministic to unit-test and trivial to drive from a render loop or a fake clock.

func NewTransition(parseDuration float64) Transition

func NewTransitionPref(parseDuration float64, parsePref MotionPreference) Transition

func (parseT Transition) Advance(parseDelta float64) Transition

func (parseT Transition) BeginExit() Transition

func (parseT Transition) IsAnimating() bool

func (parseT Transition) IsRemovable() bool

func (parseT Transition) Progress() float64