@effect-tui/react 0.9.3 → 0.10.0

package/src/motion/index.ts

@@ -5,10 +5,13 @@ export { useAnimationFrame } from "./frame.js"
 export type { ColorInput, MotionValue, RGBA, SpringOptions } from "./motion-value.js"
 export {
 	// Color springs
+	COLOR_MOTION_VALUE_BRAND,
 	ColorMotionValue,
+	MOTION_VALUE_BRAND,
 	motionValue,
 	useColorMotionValue,
 	useColorSpring,
+	useColorSpringState,
 	useMotionValue,
 	useMotionValueEvent,
 	useSpring,

package/src/motion/motion-value.ts

@@ -3,11 +3,14 @@
  * Inspired by framer-motion's MotionValue.
  */
 
+import { MOTION_VALUE_BRAND } from "./brands.js"
 import { EventEmitter } from "./event-emitter.js"
 import { subscribeFrame } from "./frame.js"
 import { createSpringResolver, springFromVisualDuration } from "./spring-math.js"
 import { DEFAULT_SPRING_OPTIONS, type SpringOptions } from "./types.js"
 
+export { MOTION_VALUE_BRAND } from "./brands.js"
+
 /** Create a MotionValue. Factory function like Motion's motionValue(). */
 export function motionValue<T>(initial: T): MotionValue<T> {
 	return new MotionValue(initial)
@@ -17,6 +20,9 @@ export function motionValue<T>(initial: T): MotionValue<T> {
  * MotionValue tracks a value and its velocity, supporting spring animations.
  */
 export class MotionValue<T = number> extends EventEmitter<T> {
+	/** @internal Brand for safe type detection */
+	readonly [MOTION_VALUE_BRAND] = true
+
 	private current: T
 	private target: T
 	private velocity = 0
@@ -124,11 +130,12 @@ export class MotionValue<T = number> extends EventEmitter<T> {
 }
 
 export type { ColorInput, RGBA } from "./color.js"
-export { ColorMotionValue } from "./color-motion-value.js"
+export { COLOR_MOTION_VALUE_BRAND, ColorMotionValue } from "./color-motion-value.js"
 export type { EventName, Subscriber } from "./event-emitter.js"
 export {
 	useColorMotionValue,
 	useColorSpring,
+	useColorSpringState,
 	useMotionValue,
 	useMotionValueEvent,
 	useSpring,

package/src/motion/use-sequence.ts

@@ -1,17 +1,51 @@
 // useSequence - Timed discrete state sequences (motion.dev-style keyframes)
 // For animating through discrete values like emojis, strings, or any non-numeric state
 
-import { useEffect, useState } from "react"
+import { useCallback, useEffect, useRef, useState } from "react"
 
 export interface SequenceOptions<T> {
 	/** Array of values to animate through */
 	keyframes: T[]
-	/** Position of each keyframe as 0-1 fraction (must match keyframes length) */
-	times: number[]
+	/** Position of each keyframe as 0-1 fraction (defaults to evenly spaced) */
+	times?: number[]
 	/** Total duration in milliseconds */
 	duration: number
+	/** Initial delay before starting (ms) */
+	delay?: number
 	/** Start automatically (default: true) */
 	autoPlay?: boolean
+	/** Change this value to replay the sequence */
+	playKey?: unknown
+	/** Optional callback when the sequence finishes */
+	onComplete?: () => void
+	/** Optional callback for each keyframe change */
+	onUpdate?: (value: T, index: number) => void
+}
+
+function clamp01(value: number) {
+	if (!Number.isFinite(value)) return 0
+	if (value < 0) return 0
+	if (value > 1) return 1
+	return value
+}
+
+function resolveTimes(count: number, times?: number[]): number[] {
+	if (count <= 0) return []
+	if (!times || times.length !== count) {
+		if (count === 1) return [0]
+		const step = 1 / (count - 1)
+		return Array.from({ length: count }, (_, i) => i * step)
+	}
+
+	const resolved = new Array<number>(count)
+	let prev = 0
+	resolved[0] = 0
+	for (let i = 1; i < count; i++) {
+		const next = Math.max(prev, clamp01(times[i] ?? 0))
+		resolved[i] = next
+		prev = next
+	}
+	return resolved
 }
 
 /**
@@ -30,22 +64,88 @@ export interface SequenceOptions<T> {
  * ```
  */
 export function useSequence<T>(options: SequenceOptions<T>): T {
-	const { keyframes, times, duration, autoPlay = true } = options
+	const { keyframes, autoPlay = true, playKey } = options
 	const [index, setIndex] = useState(0)
+	const optionsRef = useRef(options)
+	optionsRef.current = options
+	const timersRef = useRef<NodeJS.Timeout[]>([])
+	const runIdRef = useRef(0)
+	const prevPlayKeyRef = useRef<unknown>(playKey)
+	const hasInitializedRef = useRef(false)
 
-	useEffect(() => {
-		if (!autoPlay || keyframes.length <= 1) return
+	const clearTimers = useCallback(() => {
+		for (const timer of timersRef.current) {
+			clearTimeout(timer)
+		}
+		timersRef.current = []
+	}, [])
+
+	const play = useCallback(() => {
+		const { keyframes, times, duration, delay = 0, onComplete, onUpdate } = optionsRef.current
+		clearTimers()
+		runIdRef.current += 1
+		const runId = runIdRef.current
+
+		if (keyframes.length === 0) return
+
+		setIndex((prev) => (prev === 0 ? prev : 0))
+		onUpdate?.(keyframes[0], 0)
+
+		if (keyframes.length === 1) {
+			onComplete?.()
+			return
+		}
 
-		const timers: NodeJS.Timeout[] = []
+		const resolvedTimes = resolveTimes(keyframes.length, times)
+		const durationMs = Number.isFinite(duration) ? Math.max(0, duration) : 0
+		const delayMs = Number.isFinite(delay) ? Math.max(0, delay) : 0
 
-		// Schedule each keyframe transition
 		for (let i = 1; i < keyframes.length; i++) {
-			const delayMs = times[i]! * duration
-			timers.push(setTimeout(() => setIndex(i), delayMs))
+			const targetDelay = delayMs + resolvedTimes[i]! * durationMs
+			const timer = setTimeout(() => {
+				if (runId !== runIdRef.current) return
+				setIndex(i)
+				onUpdate?.(keyframes[i]!, i)
+				if (i === keyframes.length - 1) {
+					onComplete?.()
+				}
+			}, targetDelay)
+			timersRef.current.push(timer)
+		}
+	}, [clearTimers])
+
+	// Handle autoPlay on initial mount
+	useEffect(() => {
+		if (hasInitializedRef.current) return
+		hasInitializedRef.current = true
+		if (autoPlay) {
+			play()
 		}
+		return () => clearTimers()
+	}, [autoPlay, play, clearTimers])
 
-		return () => timers.forEach(clearTimeout)
-	}, [keyframes, times, duration, autoPlay])
+	// Handle playKey changes - ALWAYS replay regardless of autoPlay
+	useEffect(() => {
+		if (playKey !== prevPlayKeyRef.current) {
+			prevPlayKeyRef.current = playKey
+			play()
+		}
+	}, [playKey, play])
+
+	useEffect(() => {
+		return () => clearTimers()
+	}, [clearTimers])
+
+	useEffect(() => {
+		if (keyframes.length === 0) return
+		if (index >= keyframes.length) {
+			setIndex(keyframes.length - 1)
+		}
+	}, [index, keyframes.length])
 
-	return keyframes[index]!
+	if (keyframes.length === 0) {
+		return undefined as T
+	}
+	const safeIndex = Math.min(index, keyframes.length - 1)
+	return keyframes[safeIndex]!
 }