@weasel-js/core 1.9.4 → 1.10.0

package/dist/animation/useAnimator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAnimator.js","names":["resolveSpringConstants","preset","o","SPRING_PRESETS","useAnimator","optsRef","useLatest","opts","animations","useRef","nextId","tickDepth","codecFrameT","globalTimeScale","globalPaused","colorOverrides","ColorOverrideRegistry","tickSubscribers","tickAllRef","frameLoop","useVisibleRaf","useCallback","t","anim","frameLoopRef","mountedRef","trippedRef","tripwire","useMemo","now","afterTicks","completionListeners","fireCompletion","ls","id","cb","watchCompletion","cur","idx","hub","AnimatorEventHub","codec","createCodec","infoOf","a","info","reportEnd","retire","error","by","tickAll","finished","threw","frameDt","realDt","scale","err","sub","ensureLoop","cancelByKey","ids","key","rateOf","register","seed","s","createSupervisor","onCancelCb","onRateCb","onFrameCb","base","virtualNow","paused","timeScale","tween","fromAxes","axesOf","toAxes","axes","easing","resolveEasing","easeOut","factoryFn","lastValueEmitted","reader","nowMs","value","eased","physics","add","b","subtract","v","k","magnitude","kBase","restThreshold","target","velocity","lastTime","damping","mass","kind","sameShape","baseHandle","m","dt","next","stepSpring","velRested","posRested","checkShape","what","newTo","api","friction","handle","retired","createLoop","factory","loopOpts","createTweenLoop","tweenLoopOpts","createStagger","items","delay","staggerOpts","createTimeline","animation","path","sup","listener","rows","row","useInsertionEffect","useEffect","overrides"],"sources":["../../src/animation/useAnimator.ts"],"sourcesContent":["import { useCallback, useEffect, useInsertionEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../scheduling/useVisibleRaf';\nimport { easeOut, SPRING_PRESETS, resolveEasing } from '@weasel-js/geom';\nimport { createLoop, createTweenLoop } from './loop';\nimport { stepSpring } from './engine/integrator';\nimport { createCodec, type SpringReader } from './engine/codec';\nimport { axesOf } from './engine/axes';\nimport { createStagger } from './stagger';\nimport { createTimeline } from './timeline/createTimeline';\nimport { ColorOverrideRegistry } from './colorRegistry';\nimport { AnimatorEventHub } from './observe';\nimport type { Supervisor, SupervisorOptions, WatchCompletion } from './supervisor';\nimport type {\n  AnimationHandle,\n  AnimationInfo,\n  AnimationKind,\n  Animator,\n  TweenOptions,\n  SpringOptions,\n  DecayOptions,\n  PhysicsOptions,\n  PhysicsHandle,\n  UseAnimatorOptions,\n  LiveAnimation,\n} from './types';\nimport type { TimelineOptions } from './timeline/types';\n\ninterface ActiveAnimation {\n  id: number;\n  kind: AnimationKind;\n  cancelKey?: string;\n  label?: string;\n  /** Built the first time something reports on this entry, then shared. */\n  info?: AnimationInfo;\n  /** 0–1 where the animation has an end to measure against. */\n  progress?(virtualNow: number): number;\n  /** Its `end` is reported, though the entry stays on the table until the\n   *  frame's ticks are done. */\n  ended?: boolean;\n  paused: boolean;\n  timeScale: number;\n  virtualNow: number;\n  lastRealNow: number | null;\n  /** Returns true when finished. Called once per frame with the current\n   *  virtual-ms timestamp and the effective scale it advanced at this frame. */\n  tick(virtualNow: number, scale: number): boolean;\n  /** Called when the animation is cancelled. Skips onDone. */\n  onCancel?(): void;\n  /** Called when its pause state or time scale is set, by handle or by key. */\n  onRate?(paused: boolean, timeScale: number): void;\n}\n\nfunction resolveSpringConstants(o: { preset?: string; stiffness?: number; damping?: number; mass?: number }) {\n  const preset = o.preset ? SPRING_PRESETS[o.preset as keyof typeof SPRING_PRESETS] : null;\n  return {\n    stiffness: o.stiffness ?? preset?.stiffness ?? 170,\n    damping: o.damping ?? preset?.damping ?? 26,\n    mass: o.mass ?? preset?.mass ?? 1,\n  };\n}\n\n/** Create the animator for a canvas. One rAF loop drives every animation it\n *  owns, and everything still running is cancelled on unmount. */\nexport function useAnimator(opts: UseAnimatorOptions = {}): Animator {\n  const optsRef = useLatest(opts);\n  const animations = useRef<Map<number, ActiveAnimation>>(new Map());\n  const nextId = useRef(1);\n  /**\n   * Re-entrancy counter incremented around each animation tick in tickAll.\n   * Exposed via `isTicking()`. > 0 ⇒ we're currently inside an animation's\n   * onTick; an adapter wrapper (`animateOnSetPose`) seeing this flag should\n   * write through to the base adapter rather than schedule a new tween.\n   */\n  const tickDepth = useRef(0);\n  /** The timestamp the codec last advanced to. Null after the page was hidden and while nothing\n   *  runs, so neither gap is charged to the codec; a tween starting then seeds it from `now()`. */\n  const codecFrameT = useRef<number | null>(null);\n  const globalTimeScale = useRef(1);\n  const globalPaused = useRef(false);\n  const colorOverrides = useRef<ColorOverrideRegistry>(new ColorOverrideRegistry());\n  // Per-frame tick subscribers. Notified after each batch of animation\n  // ticks (i.e. after `colorOverrides` has settled to its latest values\n  // but before the next RAF schedules). Used by `<SceneCanvas animator>`\n  // to request a redraw on every active frame.\n  const tickSubscribers = useRef<Set<() => void>>(new Set());\n\n  // The loop runs behind the visibility gate. `tickAll` is built inside the\n  // memo below, so the frame callback reaches it through a ref, published\n  // once the memo's render commits.\n  const tickAllRef = useRef<((t: number) => void) | null>(null);\n  const frameLoop = useVisibleRaf(\n    useCallback((t: number) => { tickAllRef.current?.(t); }, []),\n    {\n      requestFrame: opts.requestFrame,\n      cancelFrame: opts.cancelFrame,\n      // An hour spent hidden is not an hour the animation ran: dropping each\n      // animation's last timestamp makes the resuming frame's `realDt` zero.\n      onResume: () => {\n        for (const anim of animations.current.values()) anim.lastRealNow = null;\n        codecFrameT.current = null;\n      },\n    },\n  );\n  const frameLoopRef = useLatest(frameLoop);\n\n  // Tripwire: dev-only flag that every tween/spring/decay's tick reads to\n  // detect \"animation fired after the host component unmounted.\" This is a\n  // symptom of cleanup not running (regression) — typically because someone\n  // refactored useAnimator and forgot to wire the unmount effect. The flag\n  // flips false on cleanup; ticks see it and log a one-time error so the\n  // bug is loud rather than just visually-doubled animation.\n  const mountedRef = useRef(true);\n  const trippedRef = useRef(false);\n  const tripwire = (): boolean => {\n    if (mountedRef.current) return false;\n    if (!trippedRef.current) {\n      trippedRef.current = true;\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) {\n        console.error(\n          'weasel useAnimator: animation tick fired after the host component unmounted. ' +\n          'This usually means cleanup logic was bypassed — check for refactors that ' +\n          'removed the unmount effect or replaced cancelAll with a custom path.',\n        );\n      }\n    }\n    return true;\n  };\n\n  const { api, tickAll } = useMemo(() => {\n    // Default to performance.now() so the time origin matches the\n    // requestAnimationFrame callback's DOMHighResTimeStamp argument.\n    // Using Date.now() here would mix epoch-millis with page-relative-millis,\n    // producing huge negative `elapsed` values that clamp tween `t` to 0\n    // forever (never reaching completion).\n    const now = (): number =>\n      (optsRef.current.now ?? (typeof performance !== 'undefined' ? performance.now.bind(performance) : Date.now))();\n    /** Supervisor frame callbacks due this frame, run once its ticks are done. */\n    const afterTicks: (() => void)[] = [];\n\n    // Per-id one-shot completion listeners. Used by stagger to detect when\n    // each child has left the registry (natural completion OR cancel) so the\n    // supervising composite can retire itself when the last child finishes.\n    const completionListeners = new Map<number, (() => void)[]>();\n    const fireCompletion = (id: number): void => {\n      const ls = completionListeners.get(id);\n      if (!ls) return;\n      completionListeners.delete(id);\n      for (const cb of ls) cb();\n    };\n    const watchCompletion: WatchCompletion = (id, cb) => {\n      if (!animations.current.has(id)) {\n        cb();\n        return () => {};\n      }\n      const ls = completionListeners.get(id) ?? [];\n      ls.push(cb);\n      completionListeners.set(id, ls);\n      return () => {\n        const cur = completionListeners.get(id);\n        if (!cur) return;\n        const idx = cur.indexOf(cb);\n        if (idx >= 0) cur.splice(idx, 1);\n        if (cur.length === 0) completionListeners.delete(id);\n      };\n    };\n\n    const hub = new AnimatorEventHub();\n    const codec = createCodec();\n    const infoOf = (a: ActiveAnimation): AnimationInfo => {\n      if (!a.info) {\n        const info: { -readonly [K in keyof AnimationInfo]: AnimationInfo[K] } = { id: a.id, kind: a.kind };\n        if (a.cancelKey != null) info.key = a.cancelKey;\n        if (a.label != null) info.label = a.label;\n        a.info = info;\n      }\n      return a.info;\n    };\n\n    /** Report `id` as finished, ahead of its `onDone`, so whatever that\n     *  handler starts is heard after it. Nothing revives a primitive; a\n     *  timeline, which can be revived, is reported as it leaves the table. */\n    const reportEnd = (id: number): void => {\n      const a = animations.current.get(id);\n      if (!a || a.ended) return;\n      a.ended = true;\n      if (hub.watched) hub.emit({ type: 'end', animation: infoOf(a) });\n    };\n\n    /** Take `id` off the table as canceled — or, given `by`, as interrupted by\n     *  the animation claiming its key; given `error`, the caller reports it. */\n    const retire = (id: number, by?: ActiveAnimation, error?: true): void => {\n      const a = animations.current.get(id);\n      if (!a) return;\n      a.onCancel?.();\n      codec.stop(id);\n      animations.current.delete(id);\n      fireCompletion(id);\n      if (!hub.watched || a.ended || error) return;\n      hub.emit(by\n        ? { type: 'interrupt', animation: infoOf(a), by: infoOf(by) }\n        : { type: 'cancel', animation: infoOf(a) });\n    };\n\n    const tickAll = (t: number): void => {\n      const finished: ActiveAnimation[] = [];\n      const threw: [ActiveAnimation, unknown][] = [];\n      const frameDt = codecFrameT.current == null ? 0 : Math.max(0, t - codecFrameT.current);\n      codecFrameT.current = t;\n      codec.frame(frameDt * (globalPaused.current ? 0 : globalTimeScale.current));\n      // A snapshot: an animation registered by this frame's ticks first ticks on the\n      // next, or a zero-duration loop would chain inside one frame and never leave it.\n      for (const anim of [...animations.current.values()]) {\n        if (animations.current.get(anim.id) !== anim) continue;\n        // `t` comes from the frame clock; `lastRealNow` is seeded at register()\n        // from `now()`. The two share a time origin in a browser, where the rAF\n        // timestamp and `performance.now()` are both page-relative — but not\n        // everywhere: jsdom starts them ~600ms apart, which made the first\n        // frame's delta hugely negative and left `virtualNow` climbing back\n        // toward zero for dozens of frames before a tween advanced at all.\n        // Time never runs backwards, so a negative sample is never real.\n        const realDt = anim.lastRealNow == null ? 0 : Math.max(0, t - anim.lastRealNow);\n        anim.lastRealNow = t;\n        const scale = globalPaused.current\n          ? 0\n          : globalTimeScale.current * (anim.paused ? 0 : anim.timeScale);\n        anim.virtualNow += realDt * scale;\n        // Increment tick depth around each animation's tick so re-entrant\n        // calls (e.g. `decay.onTick` → `adapter.setPose` →\n        // `animateOnSetPose` checking `isTicking()`) see the flag and\n        // skip scheduling a new wrap-tween that would fight the caller.\n        tickDepth.current += 1;\n        try {\n          if (anim.tick(anim.virtualNow, scale)) finished.push(anim);\n        } catch (error) {\n          threw.push([anim, error]);\n        } finally {\n          tickDepth.current -= 1;\n        }\n      }\n      for (const [anim, error] of threw) {\n        console.error('useAnimator: animation tick threw; retiring it', error);\n        if (animations.current.get(anim.id) !== anim) continue;\n        // One that ended before throwing (from `onDone`) is finished, not canceled.\n        if (anim.ended) {\n          animations.current.delete(anim.id);\n          fireCompletion(anim.id);\n        } else {\n          retire(anim.id, undefined, true);\n        }\n        if (hub.watched) hub.emit({ type: 'error', animation: infoOf(anim), error });\n      }\n      for (const anim of finished) {\n        // Gone already if its own tick canceled it; replaced if something\n        // revived it under the same id since.\n        if (animations.current.get(anim.id) !== anim) continue;\n        reportEnd(anim.id);\n        animations.current.delete(anim.id);\n        fireCompletion(anim.id);\n      }\n      for (const cb of afterTicks.splice(0)) {\n        try { cb(); } catch (err) { console.error('useAnimator: a staggered start threw', err); }\n      }\n      // Notify every onTick subscriber AFTER the tick batch so they\n      // see the latest `colorOverrides` / pose values. Errors in one\n      // subscriber don't suppress the others.\n      for (const sub of tickSubscribers.current) {\n        try { sub(); } catch (err) { console.error('useAnimator: onTick subscriber threw', err); }\n      }\n      if (animations.current.size > 0) frameLoopRef.current.request();\n      else codecFrameT.current = null;\n    };\n\n    const ensureLoop = (): void => {\n      if (animations.current.size === 0) return;\n      frameLoopRef.current.request();\n    };\n\n    const cancelByKey = (key: string, by?: ActiveAnimation): void => {\n      const ids: number[] = [];\n      for (const anim of animations.current.values()) {\n        if (anim.cancelKey === key) ids.push(anim.id);\n      }\n      for (const id of ids) retire(id, by);\n    };\n\n    type AnimationSeed =\n      Omit<ActiveAnimation, 'paused' | 'timeScale' | 'virtualNow' | 'lastRealNow'>\n      & {\n        /** Registers under an existing `cancelKey` without cancelling whoever\n         *  holds it. For an animation re-registering itself — a revived\n         *  timeline — which is not a new claim on the key. */\n        keepExisting?: boolean;\n      };\n    /** Gives a codec subject the rate its own pause and time scale now ask for. */\n    const rateOf = (a: ActiveAnimation): void => {\n      if (codec.has(a.id)) codec.rate(a.id, a.paused ? 0 : a.timeScale);\n      a.onRate?.(a.paused, a.timeScale);\n    };\n\n    const register = (seed: AnimationSeed): AnimationHandle => {\n      const anim = seed as ActiveAnimation;\n      if (seed.cancelKey != null && !seed.keepExisting) cancelByKey(seed.cancelKey, anim);\n      anim.paused = false;\n      anim.timeScale = 1;\n      anim.virtualNow = 0;\n      // Seed lastRealNow at registration so the first frame's realDt reflects\n      // the gap between register() and the first RAF callback: it places a\n      // tween's end, and gives spring/decay a non-zero first dt sample.\n      anim.lastRealNow = now();\n      animations.current.set(anim.id, anim);\n      if (hub.watched) hub.emit({ type: 'start', animation: infoOf(anim) });\n      ensureLoop();\n      return {\n        id: anim.id,\n        cancel: () => retire(anim.id),\n        pause: () => { const a = animations.current.get(anim.id); if (a) { a.paused = true; rateOf(a); } },\n        resume: () => { const a = animations.current.get(anim.id); if (a) { a.paused = false; rateOf(a); } },\n        setTimeScale: (s) => { const a = animations.current.get(anim.id); if (a) { a.timeScale = s; rateOf(a); } },\n        timeScale: () => animations.current.get(anim.id)?.timeScale ?? 1,\n        isPaused: () => animations.current.get(anim.id)?.paused ?? false,\n      };\n    };\n\n    // Supervisor: a registered animation whose tick is a no-op (never\n    // finishes naturally) so loop/stagger can sit in the animator's id table\n    // and benefit from `cancel`/`cancelKey`/`isActive`. The owning composite\n    // (loop/stagger) installs an onCancel to actually tear down its children.\n    const createSupervisor = ({ kind, cancelKey, label }: SupervisorOptions): Supervisor => {\n      const id = nextId.current++;\n      let onCancelCb: (() => void) | undefined;\n      let onRateCb: ((paused: boolean, timeScale: number) => void) | undefined;\n      let onFrameCb: ((virtualNow: number) => void) | undefined;\n      const base = register({\n        id,\n        kind,\n        cancelKey,\n        label,\n        // tick is a no-op: the supervisor only ends when the owner calls\n        // `cancel()` (either via animator.cancel, animator.cancelKey, or the\n        // composite's natural-completion path which forwards to `cancel`).\n        tick: (virtualNow) => {\n          if (onFrameCb) afterTicks.push(() => onFrameCb?.(virtualNow));\n          return false;\n        },\n        onCancel: () => onCancelCb?.(),\n        onRate: (paused, timeScale) => onRateCb?.(paused, timeScale),\n      });\n      return {\n        id: base.id,\n        cancel: base.cancel,\n        pause: base.pause,\n        resume: base.resume,\n        setTimeScale: base.setTimeScale,\n        timeScale: base.timeScale,\n        isPaused: base.isPaused,\n        setOnCancel: (cb) => { onCancelCb = cb; },\n        setOnRate: (cb) => { onRateCb = cb; },\n        setOnFrame: (cb) => { onFrameCb = cb; },\n        finish: () => {\n          if (!animations.current.has(id)) return;\n          reportEnd(id);\n          animations.current.delete(id);\n          fireCompletion(id);\n        },\n        cancelKey,\n      };\n    };\n\n    const tween = <T,>(o: TweenOptions<T>): AnimationHandle => {\n      // blits blends in a straight line, which a caller's own function may not do.\n      const fromAxes = o.interpolate || o.interpolator ? null : axesOf(o.from);\n      const toAxes = fromAxes && axesOf(o.to);\n      const axes = fromAxes && toAxes && toAxes.shape === fromAxes.shape ? fromAxes : null;\n      // Refused here rather than on a tick, where a throw would stop every other animation.\n      if (!axes && !o.interpolate && !o.interpolator) {\n        throw new Error('tween: interpolate or interpolator is required for non-numeric T');\n      }\n      const id = nextId.current++;\n      const easing = resolveEasing(o.easing ?? easeOut);\n      // Precedence: factory > per-tick. Factory is built once at tween start so\n      // expensive setup (color space conversion etc.) doesn't repeat per frame.\n      const factoryFn = o.interpolator ? o.interpolator(o.from, o.to) : null;\n      let lastValueEmitted = false;\n      // Seeds the codec's clock where `register` seeds the call's, so both charge the same wait.\n      if (codecFrameT.current == null) codecFrameT.current = now();\n      // Started ahead of `register`, whose `start` listeners may already cancel it.\n      const reader = codec.tween({\n        id, ms: Math.max(o.ms, 1), ease: easing,\n        from: axes ? axes.to(o.from) : [0],\n        to: axes ? axes.to(o.to) : [1],\n      });\n      return register({\n        id,\n        kind: 'tween',\n        cancelKey: o.cancelKey,\n        label: o.label,\n        progress: (virtualNow) => (o.ms <= 0 ? 1 : Math.min(1, virtualNow / o.ms)),\n        // `nowMs` is the call's own virtual time, so it still decides when the tween ends; the codec\n        // supplies only the value in between.\n        tick(nowMs) {\n          if (tripwire()) { codec.stop(id); return true; }\n          const t = o.ms <= 0 ? 1 : Math.min(1, nowMs / o.ms);\n          let value: T;\n          if (axes) {\n            value = t >= 1 ? o.to : axes.from(reader.cols, reader.at);\n          } else {\n            const eased = t >= 1 ? easing(1) : reader.cols[reader.at]!;\n            value = factoryFn ? factoryFn(eased) : o.interpolate!(o.from, o.to, eased);\n          }\n          o.onTick(value);\n          if (t >= 1 && !lastValueEmitted) {\n            lastValueEmitted = true;\n            codec.stop(id);\n            // That last onTick may have cancelled us — deregistering the id.\n            // A cancelled tween never completes, whenever the cancel landed.\n            if (animations.current.has(id)) {\n              reportEnd(id);\n              o.onDone?.();\n            }\n            return true;\n          }\n          return false;\n        },\n      });\n    };\n\n    const physics = <T,>(o: PhysicsOptions<T>, kind: AnimationKind = 'physics'): PhysicsHandle<T> => {\n      const id = nextId.current++;\n      const isNumeric = typeof o.from === 'number';\n      if (!isNumeric && (!o.add || !o.subtract || !o.scale || !o.magnitude)) {\n        throw new Error('physics: add/subtract/scale/magnitude are required for non-numeric T');\n      }\n      const add = o.add ?? ((a: T, b: T) => ((a as unknown as number) + (b as unknown as number)) as unknown as T);\n      const subtract = o.subtract ?? ((a: T, b: T) => ((a as unknown as number) - (b as unknown as number)) as unknown as T);\n      const scale = o.scale ?? ((v: T, k: number) => ((v as unknown as number) * k) as unknown as T);\n      const magnitude = o.magnitude ?? ((v: T) => Math.abs(v as unknown as number));\n      const { stiffness: kBase, damping, mass } = resolveSpringConstants(o);\n      const restThreshold = o.restThreshold ?? 0.01;\n\n      let target: T | null = o.to ?? null;\n      let value = o.from;\n      // Default to zero velocity: assumes scale(_, 0) returns the zero vector of T. Pass an explicit velocity for unusual T where this isn't true.\n      let velocity: T = o.velocity ?? scale(o.from, 0);\n      let lastTime: number | null = null;\n\n      // blits' closed forms need positive damping and mass, and a spring with a target needs\n      // stiffness; decay's handle never takes a target.\n      const solvable = damping > 0 && mass > 0 && (kBase > 0 || kind === 'decay');\n      const fromAxes = solvable ? axesOf(o.from) : null;\n      const sameShape = (v: T | null | undefined): boolean => v == null || axesOf(v)?.shape === fromAxes!.shape;\n      const axes = fromAxes && sameShape(o.to) && sameShape(o.velocity) ? fromAxes : null;\n      let reader: SpringReader | null = null;\n      if (axes) {\n        // Seeds the codec's clock where `register` seeds the call's, so both charge the same wait.\n        if (codecFrameT.current == null) codecFrameT.current = now();\n        // Started ahead of `register`, whose `start` listeners may already cancel it.\n        reader = codec.spring({\n          id, axes: axes.count,\n          from: axes.to(o.from),\n          to: o.to == null ? null : axes.to(o.to),\n          velocity: o.velocity == null ? new Array<number>(axes.count).fill(0) : axes.to(o.velocity),\n          stiffness: kBase, damping, mass,\n        });\n      }\n\n      const baseHandle = register({\n        id,\n        kind,\n        cancelKey: o.cancelKey,\n        label: o.label,\n        tick(nowMs) {\n          if (tripwire()) { codec.stop(id); return true; }\n          if (lastTime == null) {\n            lastTime = nowMs;\n            // Already-at-rest short-circuit: decay-mode (target == null)\n            // with starting velocity below threshold should complete\n            // immediately rather than emit a tick and wait a frame.\n            if (target == null && magnitude(velocity) < restThreshold) {\n              codec.stop(id);\n              reportEnd(id);\n              o.onDone?.();\n              return true;\n            }\n            // The codec's voice has run since registration, so only Euler starts its clock here.\n            if (!axes) {\n              o.onTick(value);\n              return false;\n            }\n          }\n          if (axes) {\n            const m = reader!.motion();\n            value = axes.from(m.value);\n            velocity = axes.from(m.velocity);\n          } else {\n            // Semi-implicit Euler, for a T blits cannot move as axes, or constants its closed forms can't solve.\n            const dt = Math.min(0.064, (nowMs - lastTime) / 1000);\n            const next = stepSpring({ add, subtract, scale }, value, velocity, target, kBase, damping, mass, dt);\n            value = next.value;\n            velocity = next.velocity;\n          }\n          lastTime = nowMs;\n          o.onTick(value);\n          const velRested = magnitude(velocity) < restThreshold;\n          const posRested = target == null\n            ? true\n            : magnitude(subtract(value, target)) < restThreshold;\n          if (velRested && posRested) {\n            if (target != null) o.onTick(target);\n            codec.stop(id);\n            // As for a tween: canceled from its own onTick, it never completes.\n            if (animations.current.has(id)) {\n              reportEnd(id);\n              o.onDone?.();\n            }\n            return true;\n          }\n          return false;\n        },\n      });\n\n      const checkShape = (v: T, what: string): void => {\n        if (!sameShape(v)) throw new Error(`physics: ${what} is not the same shape as \\`from\\``);\n      };\n      const handle: PhysicsHandle<T> = {\n        ...baseHandle,\n        setTarget: (newTo: T | null) => {\n          if (axes && newTo != null) checkShape(newTo, 'setTarget');\n          target = newTo;\n          if (axes && codec.has(id)) codec.retarget(id, newTo == null ? null : axes.to(newTo));\n        },\n        setVelocity: (v: T) => {\n          if (axes) checkShape(v, 'setVelocity');\n          velocity = v;\n          if (axes && codec.has(id)) codec.push(id, axes.to(v));\n        },\n      };\n      return handle;\n    };\n\n    const spring = <T,>(o: SpringOptions<T>): AnimationHandle => physics<T>(o, 'spring');\n\n    const decay = <T,>(o: DecayOptions<T>): AnimationHandle => {\n      const friction = o.friction ?? 0.95;\n      // Per-second friction v(t) = v0 * friction^t corresponds to\n      // m*dv/dt = -c*v with c = -ln(friction), m = 1, k = 0.\n      const damping = -Math.log(friction);\n      return physics<T>({\n        from: o.from,\n        to: null,\n        velocity: o.velocity,\n        stiffness: 0,\n        damping,\n        mass: 1,\n        restThreshold: o.threshold ?? 0.5,\n        add: o.add,\n        // DecayOptions doesn't carry subtract; derive from add+scale.\n        subtract: (a, b) => o.add(a, o.scale(b, -1)),\n        scale: o.scale,\n        magnitude: o.magnitude,\n        onTick: o.onTick,\n        onDone: o.onDone,\n        cancelKey: o.cancelKey,\n        label: o.label,\n      }, 'decay');\n    };\n\n    const cancelAll = (): void => {\n      const retired: ActiveAnimation[] = [];\n      for (const a of animations.current.values()) {\n        a.onCancel?.();\n        codec.stop(a.id);\n        retired.push(a);\n      }\n      animations.current.clear();\n      codecFrameT.current = null;\n      for (const a of retired) fireCompletion(a.id);\n      if (hub.watched) for (const a of retired) hub.emit({ type: 'cancel', animation: infoOf(a) });\n      frameLoopRef.current.cancel();\n    };\n    const api: Animator = {\n      tween,\n      spring,\n      decay,\n      physics,\n      cancel: (handle) => retire(handle.id),\n      cancelKey: (key) => cancelByKey(key),\n      cancelAll,\n      isActive: (key) => {\n        if (key == null) return animations.current.size > 0;\n        for (const a of animations.current.values()) {\n          if (a.cancelKey === key) return true;\n        }\n        return false;\n      },\n      isTicking: () => tickDepth.current > 0,\n      pause: () => { globalPaused.current = true; },\n      resume: () => { globalPaused.current = false; },\n      isPaused: () => globalPaused.current,\n      setTimeScale: (s) => { globalTimeScale.current = s; },\n      timeScale: () => globalTimeScale.current,\n      pauseKey: (key) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) { a.paused = true; rateOf(a); }\n      },\n      resumeKey: (key) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) { a.paused = false; rateOf(a); }\n      },\n      setTimeScaleByKey: (key, s) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) { a.timeScale = s; rateOf(a); }\n      },\n      loop: (factory, loopOpts) => createLoop(createSupervisor, factory, loopOpts),\n      tweenLoop: (tweenLoopOpts) =>\n        createTweenLoop(api, createSupervisor, tweenLoopOpts),\n      stagger: ((items, delay, factory, staggerOpts) =>\n        createStagger(\n          api,\n          createSupervisor,\n          watchCompletion,\n          items,\n          delay,\n          factory as never,\n          staggerOpts,\n        )) as Animator['stagger'],\n      timeline: (o: TimelineOptions) => {\n        const id = nextId.current++;\n        const info = (): AnimationInfo | undefined => {\n          const a = animations.current.get(id);\n          return a && infoOf(a);\n        };\n        return createTimeline(register, id, o, {\n          get watched() { return hub.watched; },\n          fire: (track, path, event, lateBy) => {\n            const animation = info();\n            if (animation) hub.emit({ type: 'fire', animation, track, path: path.slice(), event, lateBy });\n          },\n          lap: (lap) => {\n            const animation = info();\n            if (animation) hub.emit({ type: 'lap', animation, lap });\n          },\n        });\n      },\n      colorOverrides: colorOverrides.current,\n      onTick: (cb) => {\n        tickSubscribers.current.add(cb);\n        return () => { tickSubscribers.current.delete(cb); };\n      },\n      keepAlive: () => {\n        const sup = createSupervisor({ kind: 'keepAlive' });\n        return () => sup.cancel();\n      },\n      watch: (listener) => hub.add(listener),\n      live: () => {\n        const rows: LiveAnimation[] = [];\n        for (const a of animations.current.values()) {\n          const row: LiveAnimation = {\n            ...infoOf(a),\n            paused: a.paused,\n            timeScale: a.timeScale,\n            elapsed: a.virtualNow,\n            ...(a.progress ? { progress: a.progress(a.virtualNow) } : {}),\n          };\n          rows.push(row);\n        }\n        return rows;\n      },\n    };\n    return { api, tickAll };\n  }, [frameLoopRef, optsRef]);\n\n  useInsertionEffect(() => {\n    tickAllRef.current = tickAll;\n  }, [tickAll]);\n\n  // StrictMode-safe cleanup: when the component unmounts (including the\n  // dev-mode double-mount that StrictMode performs), cancel every running\n  // animation and stop the RAF loop. Without this, the FIRST mount's\n  // animator keeps ticking with stale callbacks pointing at the unmounted\n  // adapter, while the SECOND mount creates its own animator on top —\n  // visible to the user as every animation playing twice.\n  useEffect(() => {\n    const overrides = colorOverrides.current;\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n      api.cancelAll();\n      overrides.clearAll();\n    };\n  }, [api]);\n\n  return api;\n}\n"],"mappings":"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"}

package/dist/autoPoseDescriptor-Ct7yqivU.d.ts

@@ -1,108 +0,0 @@
-import { Path } from '@weasel-js/geom';
-import { Bounds } from '@weasel-js/routing';
-
-/** `Bounds` with a required rotation angle (radians). Pivot is the AABB
- *  center of the unrotated `{x, y, width, height}`. */
-interface RotatedPose extends Bounds {
-    rotation: number;
-}
-/**
- * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.
- * The hook reads bounds via `getBounds`, runs anchor-relative math on those
- * bounds, then asks `remapBounds` to project the result back into TPose.
- *
- * `remapBounds(pose, src, dst)` is a single operation that subsumes both
- * "set my own AABB to dst" (single-leaf resize) and "scale me as a leaf
- * inside parent's src→dst rect" (group resize) — they're the same affine
- * map. For rect-shaped poses the default geometry interprets the pose as
- * its own bounds; for Path or polygon poses the consumer supplies a
- * projection that knows how to read and rewrite the underlying geometry.
- */
-interface PoseDescriptor<TPose, TNode = unknown> {
-    getBounds(pose: TPose): Bounds;
-    remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;
-    /** A pose occupying `bounds`, of the same kind as `template`. Unlike
-     *  `remapBounds`, the result carries none of the template's shape. */
-    fromBounds(bounds: Bounds, template: TPose): TPose;
-    /** Translate the pose by (dx, dy). Optional — when omitted, callers fall
-     *  back to a translation derived from `remapBounds` (origin shifted, no
-     *  scale). Path-shaped poses should provide this for performance. */
-    translate?(pose: TPose, dx: number, dy: number): TPose;
-    /** Interpolate between two poses. Optional — animation helpers fall back to
-     *  rect-shape lerp when omitted (which fails for non-rect poses). */
-    lerp?(a: TPose, b: TPose, t: number): TPose;
-    /** Read the pose's rotation in radians. Pivot is the AABB center
-     *  (`getBounds(pose)` center). Default 0 when omitted — descriptor
-     *  declares "this pose has no rotation." When supplied and non-zero,
-     *  `useResize` projects the drag delta into the leaf's local frame,
-     *  runs anchor math there, and translates the resulting pose so the
-     *  diagonally opposite world-space corner is pinned. */
-    getRotation?(pose: TPose): number;
-    /** True iff this pose shape can carry a rotation. Consulted by the
-     *  rotation affordance to decide whether to render the rotate cursor /
-     *  drag-band over a selection. When omitted, the kit assumes `true` for
-     *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`
-     *  fields (e.g. polygon Paths) should return `false` so the affordance
-     *  hides instead of exposing a non-functional rotate cursor. */
-    supportsRotation?(pose: TPose): boolean;
-    /** Write a rotation (radians) into the pose, bounds unchanged. Absent means
-     *  the pose cannot carry one, and the rotate action leaves it alone. */
-    withRotation?(pose: TPose, rotation: number): TPose;
-    /**
-     * A descriptor specialized to one node. Every other method here sees only
-     * the pose, so shapes sharing a pose type — a sphere and a box both posed by
-     * position/rotation/scale — are indistinguishable to them. Implement this to
-     * read `node.data` once and hand back a descriptor that knows which shape it
-     * is describing.
-     *
-     * Callers reach it through {@link poseDescriptorForNode}, at whichever site
-     * holds the node; the specialized descriptor then travels into the bounds and
-     * hit-test helpers in place of this one. Sites with only an id keep using the
-     * unspecialized descriptor, which is why this is optional on both ends.
-     */
-    forNode?(node: TNode): PoseDescriptor<TPose, TNode>;
-}
-/** The descriptor `node` should be read through: its own specialization when
- *  it declares one, and otherwise the descriptor unchanged. */
-declare function poseDescriptorForNode<TPose, TNode>(descriptor: PoseDescriptor<TPose, TNode>, node: TNode): PoseDescriptor<TPose, TNode>;
-/** Identity geometry for `TPose extends Bounds`. Treats the pose as its
- *  own bounds and remaps via affine scale against `src`/`dst`. */
-declare const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds>;
-/** Identity geometry for `RotatedPose`. Inherits rect-shape projection
- *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`
- *  subtype lets the rect descriptor's methods apply directly; `remapBounds`
- *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so
- *  `useResize` knows to take the rotation-aware math path. */
-declare const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose>;
-/** The pose's visual bounds: its box expanded to cover the box as drawn
- *  under its rotation and `transform`, so a turned or skewed shape reports
- *  the extent of its ink. */
-declare function visualBoundsViaDescriptor<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds;
-/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted
- *  copy of the pose's own bounds when the descriptor has none. */
-declare function translatePoseViaDescriptor<TPose>(pose: TPose, dx: number, dy: number, geometry: PoseDescriptor<TPose>): TPose;
-
-/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
- *  callers that need to fork between `pathPoseDescriptor` and
- *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire
- *  `poseDescriptor` explicitly. */
-declare function isPathLike(p: unknown): p is Path;
-/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only
- *  shape the rect descriptor and the kit's built-in painters can read. */
-declare function isRectPose(p: unknown): p is {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-};
-/** Per-call dispatch: if the pose looks like a Path, route to
- *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
- *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`
- *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses
- *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to
- *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated
- *  selection chrome and rotation-aware corner hit-tests. */
-declare const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown>;
-
-export { AUTO_POSE_DESCRIPTOR as A, type PoseDescriptor as P, RECT_POSE_DESCRIPTOR as R, ROTATED_POSE_DESCRIPTOR as a, isRectPose as b, type RotatedPose as c, isPathLike as i, poseDescriptorForNode as p, translatePoseViaDescriptor as t, visualBoundsViaDescriptor as v };