@weasel-js/core 1.9.3 → 1.10.0

package/dist/animation/timeline/booking.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"booking.js","names":["firstAfter","lo","hi","events","mid","isAfter","a","b","createBooker","lookahead","opts","maxLate","cursors","start","bookings","est","mapVirtual","lastScale","playheadCursor","host","unwrapped","ahead","stopWhere","now","pred","err","at","track","c","whenFor","u","playhead","scale","scanTrack","lap","duration","lapStart","horizon","i","lastLap","r","j","ev","when","handle","visit","tracks","moved","virtualNow","residual"],"sources":["../../../src/animation/timeline/booking.ts"],"sourcesContent":["import type { EventBooking, EventBookingHandle, EventTrack, TimelineEvent, Track } from './types';\n\n/** A clock read further than this from the frame clock's prediction is taken\n *  as a discontinuity — a hidden tab, a suspended context — not as jitter. */\nconst RESYNC_MS = 50;\n/** Share of each frame's clock residual folded into the estimate. Small enough\n *  to average out a per-frame read that lands a render quantum early or late;\n *  large enough to follow ppm-scale drift with well under a millisecond of lag. */\nconst SLEW = 0.05;\n/** A pending booking a rate change or resync moves by more than this is\n *  retracted and booked again; anything less is left standing. */\nconst RETIME_MS = 1;\n\n/** Index of the first event after `t`. Binary search: tracks may be long. */\nexport function firstAfter(events: EventTrack['events'], t: number): number {\n  let lo = 0;\n  let hi = events.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (events[mid].t > t) hi = mid; else lo = mid + 1;\n  }\n  return lo;\n}\n\n/** The timeline state a booker reads. `lap` counts wraps since creation and is\n *  never reset, so a (lap, root time) pair names one crossing for good. */\nexport interface BookerHost {\n  tracks: Track[];\n  duration(): number;\n  /** Laps still allowed after the current one; `Infinity` when endless. */\n  lapsLeft(): number;\n  lap(): number;\n  playhead(): number;\n}\n\nexport interface Booker {\n  /** After the frame's wraps and crossings. `scale` is the effective one this\n   *  frame's virtual time advanced at, zero while paused. */\n  tick(virtualNow: number, scale: number): void;\n  /** Stop every booking still ahead of both the playhead and the clock, and\n   *  let the next tick book that span again. */\n  retract(): void;\n  /** After the playhead jumped. Call `retract` first, while it still reads the\n   *  old playhead. */\n  seek(): void;\n  /** After the animator restarted the timeline's virtual clock at zero. */\n  rearm(): void;\n}\n\n/** Every event at root time `<= r` in lap `lap` has been taken. */\ninterface Cursor { lap: number; r: number }\n\ninterface Booking {\n  event: TimelineEvent;\n  lap: number;\n  r: number;\n  when: number;\n  handle?: EventBookingHandle;\n}\n\nconst isAfter = (a: Cursor, b: Cursor): boolean => a.lap > b.lap || (a.lap === b.lap && a.r > b.r);\n\nexport function createBooker(opts: EventBooking, host: BookerHost): Booker {\n  const lookahead = opts.lookahead ?? 100;\n  const maxLate = opts.maxLate ?? Infinity;\n  const cursors = new Map<EventTrack, Cursor>();\n  let start: Cursor = { lap: 0, r: -Infinity };\n  let bookings: Booking[] = [];\n  /** Clock time of the current frame, smoothed. Null until anchored. */\n  let est: number | null = null;\n  let mapVirtual = 0;\n  let lastScale = 0;\n\n  const playheadCursor = (): Cursor => ({ lap: host.lap(), r: host.playhead() });\n\n  const unwrapped = (b: { lap: number; r: number }): number =>\n    (b.lap - host.lap()) * host.duration() + b.r;\n\n  const ahead = (b: Booking): boolean => isAfter(b, playheadCursor());\n\n  const stopWhere = (now: number, pred: (b: Booking) => boolean): void => {\n    bookings = bookings.filter((b) => {\n      if (!b.handle || b.when <= now || !ahead(b) || !pred(b)) return true;\n      try { b.handle.stop(); } catch (err) { console.error('timeline: booking stop threw', err); }\n      return false;\n    });\n    // Back to the playhead, not to each retracted booking: whatever still\n    // stands is skipped by identity, and an edit may have added events behind\n    // the cursor that only a rescan finds.\n    const at = playheadCursor();\n    for (const [track, c] of cursors) if (isAfter(c, at)) cursors.set(track, at);\n    if (isAfter(start, at)) start = at;\n  };\n\n  const whenFor = (u: number, playhead: number, scale: number, now: number): number =>\n    Math.max(est! + (u - playhead) / scale, now);\n\n  const scanTrack = (\n    track: EventTrack, at: number, horizon: number, lastLap: number, now: number, scale: number,\n  ): void => {\n    const lap = host.lap();\n    const duration = host.duration();\n    const playhead = host.playhead();\n    const { events } = track;\n    let c = cursors.get(track) ?? start;\n    for (;;) {\n      const lapStart = (c.lap - lap) * duration;\n      if (lapStart > horizon) break;\n      const i = firstAfter(events, c.r - at);\n      if (i >= events.length || at + events[i].t > duration) {\n        if (c.lap >= lastLap) break;\n        // A frame that skipped whole laps books the outgoing lap's tail and\n        // nothing of the laps in between, as crossings do.\n        c = { lap: Math.max(c.lap + 1, lap), r: -Infinity };\n        continue;\n      }\n      const r = at + events[i].t;\n      const u = lapStart + r;\n      if (u > horizon) break;\n      c = { lap: c.lap, r };\n      for (let j = i; j < events.length && events[j].t === events[i].t; j += 1) {\n        const ev = events[j];\n        if (!ev.book || bookings.some((b) => b.event === ev && b.lap === c.lap)) continue;\n        if ((playhead - u) / scale > maxLate) continue;\n        const when = whenFor(u, playhead, scale, now);\n        let handle: EventBookingHandle | undefined;\n        try {\n          handle = ev.book(when) ?? undefined;\n        } catch (err) {\n          console.error('timeline: book threw', err);\n        }\n        bookings.push({ event: ev, lap: c.lap, r, when, handle });\n      }\n    }\n    cursors.set(track, c);\n  };\n\n  const visit = (\n    tracks: Track[], at: number, horizon: number, lastLap: number, now: number, scale: number,\n  ): void => {\n    for (const track of tracks) {\n      if (track.kind === 'event') scanTrack(track, at, horizon, lastLap, now, scale);\n      else if (track.kind === 'timeline') {\n        visit(track.timeline.tracks, at + track.at, horizon, lastLap, now, scale);\n      }\n    }\n  };\n\n  return {\n    tick(virtualNow, scale) {\n      const now = opts.clock.now();\n      bookings = bookings.filter(ahead);\n      if (!(scale > 0)) {\n        if (lastScale > 0) stopWhere(now, () => true);\n        lastScale = 0;\n        est = null;\n        return;\n      }\n\n      let moved = lastScale > 0 && scale !== lastScale;\n      if (est === null) {\n        est = now;\n      } else {\n        est += (virtualNow - mapVirtual) / scale;\n        const residual = now - est;\n        if (Math.abs(residual) > RESYNC_MS) {\n          est = now;\n          moved = true;\n        } else {\n          est += residual * SLEW;\n        }\n      }\n      mapVirtual = virtualNow;\n      lastScale = scale;\n\n      const playhead = host.playhead();\n      if (moved) {\n        stopWhere(now, (b) => Math.abs(whenFor(unwrapped(b), playhead, scale, now) - b.when) > RETIME_MS);\n      }\n\n      const duration = host.duration();\n      const lastLap = host.lap() + (duration > 0 ? host.lapsLeft() : 0);\n      visit(host.tracks, 0, playhead + lookahead * scale, lastLap, now, scale);\n    },\n    retract() {\n      stopWhere(opts.clock.now(), () => true);\n    },\n    seek() {\n      bookings = [];\n      cursors.clear();\n      start = playheadCursor();\n    },\n    rearm() {\n      est = null;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/animation/timeline/createTimeline.js

@@ -1,116 +0,0 @@
-import { createBooker as e, firstAfter as t } from "./booking.js";
-import { sampleTrack as n } from "./sampleTrack.js";
-//#region src/animation/timeline/createTimeline.ts
-function r(e) {
-	switch (e.kind) {
-		case "sampled": return e.keys.length ? e.keys[e.keys.length - 1].t : 0;
-		case "event": return e.events.length ? e.events[e.events.length - 1].t : 0;
-		case "timeline": return e.at + i(e.timeline.tracks, e.timeline.duration);
-	}
-}
-function i(e, t) {
-	if (t != null) return t;
-	let n = 0;
-	for (let t of e) n = Math.max(n, r(t));
-	return n;
-}
-function a(r, a, o, s) {
-	let c = i(o.tracks, o.duration), l = 0, u = 0, d = 0, f = -Infinity, p = !1, m = !0, h = !1, g = o.autoplay === !1, _ = 1, v = /* @__PURE__ */ new Set(), y = o.loop ?? !1, b = y === !0 ? Infinity : y === !1 ? 0 : y, x = 0, S = o.booking ? e(o.booking, {
-		tracks: o.tracks,
-		duration: () => c,
-		lapsLeft: () => b,
-		lap: () => x,
-		playhead: () => d
-	}) : null, C = !1, w = /* @__PURE__ */ new WeakMap(), T = (e) => {
-		let t = w.get(e);
-		return t || (t = /* @__PURE__ */ new Map(), w.set(e, t)), t;
-	}, E = (e, t) => {
-		for (let r of e) if (r.kind === "sampled") {
-			let e = r, i = n(e, t, T(e));
-			i !== void 0 && e.onTick(i);
-		} else r.kind === "timeline" && E(r.timeline.tracks, t - r.at);
-	}, D = [], O = (e, n, r) => {
-		for (let i = 0; i < e.length; i += 1) {
-			let a = e[i];
-			if (a.kind === "event") {
-				let e = t(a.events, r);
-				for (let o = t(a.events, n); o < e; o += 1) {
-					let e = a.events[o];
-					e.fire?.(r - e.t), s?.watched && (D.push(i), s.fire(a, D, e, r - e.t), D.pop()), e.book && !S && !C && (C = !0, console.warn("timeline: an event has `book` but the timeline has no `booking` clock; it never books."));
-				}
-			} else a.kind === "timeline" && (D.push(i), O(a.timeline.tracks, n - a.at, r - a.at), D.pop());
-		}
-	}, k = () => {
-		O(o.tracks, f, c), f = -Infinity, s?.watched && s.lap(x);
-	}, A = (e, t) => {
-		if (u = e, d = e + l, c > 0 && d >= c) {
-			if (b === Infinity) {
-				let e = Math.floor(d / c);
-				l -= e * c, d -= e * c, x += e, k();
-			} else for (; d >= c && b > 0;) --b, l -= c, d -= c, x += 1, k();
-		}
-		let n = d >= c;
-		return d = Math.min(d, c), E(o.tracks, d), O(o.tracks, f, d), f = d, S?.tick(e, t ?? (N.isPaused() ? 0 : N.timeScale())), n && !p && (p = !0, o.onDone?.()), d < c ? !1 : (m = !1, !0);
-	}, j = () => {
-		h = !0, m = !1, S?.retract();
-	}, M = {
-		id: a,
-		cancelKey: o.cancelKey,
-		tick: A,
-		onCancel: j,
-		kind: "timeline",
-		label: o.label,
-		progress: () => c > 0 ? d / c : 1
-	}, N = r(M);
-	o.autoplay === !1 && N.pause();
-	let P = () => {
-		h || d >= c || (p = !1, !m && (S?.rearm(), u = 0, l = d, m = !0, r({
-			...M,
-			keepExisting: !0
-		}), g && N.pause(), N.setTimeScale(_)));
-	};
-	return {
-		...N,
-		cancel() {
-			j(), N.cancel();
-		},
-		pause() {
-			g = !0, N.pause(), S?.retract();
-		},
-		resume() {
-			g = !1, N.resume();
-		},
-		setTimeScale(e) {
-			_ = e, N.setTimeScale(e);
-		},
-		timeScale: () => m ? N.timeScale() : _,
-		isPaused: () => m ? N.isPaused() : g,
-		seek(e) {
-			S?.retract(), l = e - u, d = e, f = e, S?.seek(), P();
-		},
-		time: () => d,
-		duration: () => c,
-		tracks: () => o.tracks,
-		setLoop(e) {
-			b = e === !0 ? Infinity : e === !1 ? 0 : e, S?.retract();
-		},
-		loop: () => b === Infinity || b !== 0 && b,
-		edit(e) {
-			e(), w = /* @__PURE__ */ new WeakMap(), c = i(o.tracks, o.duration), S?.retract(), P();
-			for (let e of v) try {
-				e();
-			} catch (e) {
-				console.error("timeline: subscriber threw", e);
-			}
-		},
-		subscribe(e) {
-			return v.add(e), () => {
-				v.delete(e);
-			};
-		}
-	};
-}
-//#endregion
-export { a as createTimeline };
-
-//# sourceMappingURL=createTimeline.js.map

package/dist/animation/timeline/createTimeline.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTimeline.js","names":["trackEnd","track","tracksEnd","explicit","max","tracks","createTimeline","duration","opts","offset","lastVirtual","playhead","prevPlayhead","done","live","cancelled","wantPaused","wantScale","subscribers","loopOpt","loopsLeft","lap","booker","createBooker","warnedUnbooked","caches","cacheFor","c","applySampled","st","v","sampleTrack","path","fireEvents","k","end","firstAfter","to","i","from","ev","report","onWrap","tick","virtualNow","laps","finished","scale","base","onCancel","seed","register","rearm","s","t","loop","fn","cb","err"],"sources":["../../../src/animation/timeline/createTimeline.ts"],"sourcesContent":["import type { AnimationHandle } from '../types';\nimport { createBooker, firstAfter } from './booking';\nimport { sampleTrack } from './sampleTrack';\nimport type { EventTrack, SampledTrack, TimelineEvent, TimelineHandle, TimelineOptions, Track } from './types';\n\n/** The animator's internal `register`, narrowed to what a timeline needs. */\nexport type TimelineRegister = (seed: {\n  id: number;\n  cancelKey?: string;\n  /** Registers under an existing `cancelKey` without cancelling whoever holds\n   *  it. A revived timeline is the same animation, not a new claim on the key. */\n  keepExisting?: boolean;\n  /** `scale` is the effective time scale this frame advanced at, zero while\n   *  paused at any level. */\n  tick: (virtualNow: number, scale?: number) => boolean;\n  onCancel?: () => void;\n  kind: 'timeline';\n  label?: string;\n  progress?: () => number;\n}) => AnimationHandle;\n\n/** Where a timeline reports its crossings and laps to `animator.watch`. Each\n *  call site checks `watched` first, so an unwatched timeline builds nothing. */\nexport interface TimelineReport {\n  readonly watched: boolean;\n  /** `path` is a scratch stack the timeline goes on mutating; copy it to keep it. */\n  fire(track: EventTrack, path: readonly number[], event: TimelineEvent, lateBy: number): void;\n  lap(lap: number): void;\n}\n\n/** End time of a track: its last key/event, or a nested timeline's own end. */\nfunction trackEnd(track: Track): number {\n  switch (track.kind) {\n    case 'sampled': return track.keys.length ? track.keys[track.keys.length - 1].t : 0;\n    case 'event': return track.events.length ? track.events[track.events.length - 1].t : 0;\n    case 'timeline': return track.at + tracksEnd(track.timeline.tracks, track.timeline.duration);\n  }\n}\n\nfunction tracksEnd(tracks: Track[], explicit?: number): number {\n  if (explicit != null) return explicit;\n  let max = 0;\n  for (const t of tracks) max = Math.max(max, trackEnd(t));\n  return max;\n}\n\n/**\n * Create a timeline as a registered animator animation.\n *\n * The playhead is NOT the entry's `virtualNow` directly — it is\n * `virtualNow + offset`, where `offset` is what `seek` and looping move. That\n * keeps seek and wrap-around entirely inside the timeline and needs no setter\n * on the animator's entry.\n *\n * A finished timeline leaves the animator's table, so `seek` and a\n * duration-extending `edit` re-register it. Staying registered instead would\n * hold a slot — and the rAF loop — open for every timeline ever created.\n */\nexport function createTimeline(\n  register: TimelineRegister,\n  id: number,\n  opts: TimelineOptions,\n  report?: TimelineReport,\n): TimelineHandle {\n  let duration = tracksEnd(opts.tracks, opts.duration);\n  let offset = 0;\n  let lastVirtual = 0;\n  let playhead = 0;\n  let prevPlayhead = -Infinity;\n  let done = false;\n  let live = true;\n  let cancelled = false;\n  let wantPaused = opts.autoplay === false;\n  let wantScale = 1;\n\n  const subscribers = new Set<() => void>();\n\n  const loopOpt = opts.loop ?? false;\n  let loopsLeft = loopOpt === true ? Infinity : loopOpt === false ? 0 : loopOpt;\n  let lap = 0;\n\n  const booker = opts.booking\n    ? createBooker(opts.booking, {\n      tracks: opts.tracks,\n      duration: () => duration,\n      lapsLeft: () => loopsLeft,\n      lap: () => lap,\n      playhead: () => playhead,\n    })\n    : null;\n  let warnedUnbooked = false;\n\n  // Per-sampled-track sampling caches, dropped wholesale by `edit`.\n  let caches = new WeakMap<object, Map<number, (u: number) => unknown>>();\n  const cacheFor = (track: object): Map<number, (u: number) => unknown> => {\n    let c = caches.get(track);\n    if (!c) { c = new Map(); caches.set(track, c); }\n    return c;\n  };\n\n  const applySampled = (tracks: Track[], t: number): void => {\n    for (const track of tracks) {\n      if (track.kind === 'sampled') {\n        const st = track as SampledTrack<unknown>;\n        const v = sampleTrack(st, t, cacheFor(st));\n        if (v !== undefined) st.onTick(v);\n      } else if (track.kind === 'timeline') {\n        applySampled(track.timeline.tracks, t - track.at);\n      }\n    }\n  };\n\n  // Track indexes from the root down to the track being fired, for `report`.\n  const path: number[] = [];\n  const fireEvents = (tracks: Track[], from: number, to: number): void => {\n    for (let k = 0; k < tracks.length; k += 1) {\n      const track = tracks[k];\n      if (track.kind === 'event') {\n        const end = firstAfter(track.events, to);\n        for (let i = firstAfter(track.events, from); i < end; i += 1) {\n          const ev = track.events[i];\n          ev.fire?.(to - ev.t);\n          if (report?.watched) {\n            path.push(k);\n            report.fire(track, path, ev, to - ev.t);\n            path.pop();\n          }\n          if (ev.book && !booker && !warnedUnbooked) {\n            warnedUnbooked = true;\n            console.warn('timeline: an event has `book` but the timeline has no `booking` clock; it never books.');\n          }\n        }\n      } else if (track.kind === 'timeline') {\n        path.push(k);\n        fireEvents(track.timeline.tracks, from - track.at, to - track.at);\n        path.pop();\n      }\n    }\n  };\n\n  // Flush the outgoing pass's tail before re-arming, or an event between the\n  // last tick and `duration` is dropped whenever a frame straddles the seam.\n  const onWrap = (): void => {\n    fireEvents(opts.tracks, prevPlayhead, duration);\n    prevPlayhead = -Infinity;\n    if (report?.watched) report.lap(lap);\n  };\n\n  const tick = (virtualNow: number, scale?: number): boolean => {\n    lastVirtual = virtualNow;\n    playhead = virtualNow + offset;\n\n    // A far seek can skip a billion laps of a short duration, so an endless\n    // loop takes them in one modulo rather than one iteration each.\n    if (duration > 0 && playhead >= duration) {\n      if (loopsLeft === Infinity) {\n        const laps = Math.floor(playhead / duration);\n        offset -= laps * duration;\n        playhead -= laps * duration;\n        lap += laps;\n        onWrap();\n      } else {\n        while (playhead >= duration && loopsLeft > 0) {\n          loopsLeft -= 1;\n          offset -= duration;\n          playhead -= duration;\n          lap += 1;\n          onWrap();\n        }\n      }\n    }\n\n    const finished = playhead >= duration;\n    playhead = Math.min(playhead, duration);\n\n    // Sampled before fired, so a handler reads the current frame's values.\n    applySampled(opts.tracks, playhead);\n    fireEvents(opts.tracks, prevPlayhead, playhead);\n    prevPlayhead = playhead;\n    booker?.tick(virtualNow, scale ?? (base.isPaused() ? 0 : base.timeScale()));\n\n    if (finished && !done) { done = true; opts.onDone?.(); }\n    // Re-read: `onDone` may have seeked back or extended the duration, and\n    // retiring the entry would strand the replay its own handler just started.\n    if (playhead < duration) return false;\n    live = false;\n    return true;\n  };\n\n  // Every cancel path inside the animator routes through here, so a timeline\n  // cancelled by key or by `cancelAll` is as dead as one cancelled by hand.\n  const onCancel = (): void => { cancelled = true; live = false; booker?.retract(); };\n\n  const progress = (): number => (duration > 0 ? playhead / duration : 1);\n  const seed = { id, cancelKey: opts.cancelKey, tick, onCancel, kind: 'timeline' as const, label: opts.label, progress };\n  const base = register(seed);\n\n  // A paused entry's scale is zero, so `virtualNow` never advances and the\n  // playhead holds at 0 until the consumer resumes.\n  if (opts.autoplay === false) base.pause();\n\n  /** Put a finished timeline back on the animator's table. A re-registered\n   *  entry's `virtualNow` restarts at 0, so `offset` carries the playhead. */\n  const rearm = (): void => {\n    if (cancelled || playhead >= duration) return;\n    done = false;\n    if (live) return;\n    booker?.rearm();\n    lastVirtual = 0;\n    offset = playhead;\n    live = true;\n    register({ ...seed, keepExisting: true });\n    if (wantPaused) base.pause();\n    base.setTimeScale(wantScale);\n  };\n\n  return {\n    ...base,\n    // Not just `onCancel`: cancelling a finished timeline never reaches the\n    // animator, and must still keep a later seek from reviving it.\n    cancel() { onCancel(); base.cancel(); },\n    // Playback intent is tracked here, not read back from the entry: a revived\n    // one is a fresh registration, and defaults to running at scale 1.\n    pause() { wantPaused = true; base.pause(); booker?.retract(); },\n    resume() { wantPaused = false; base.resume(); },\n    setTimeScale(s) { wantScale = s; base.setTimeScale(s); },\n    timeScale: () => (live ? base.timeScale() : wantScale),\n    isPaused: () => (live ? base.isPaused() : wantPaused),\n    seek(t) {\n      booker?.retract();\n      offset = t - lastVirtual;\n      playhead = t;\n      prevPlayhead = t;\n      booker?.seek();\n      rearm();\n    },\n    time: () => playhead,\n    duration: () => duration,\n    tracks: () => opts.tracks,\n    setLoop(loop) {\n      loopsLeft = loop === true ? Infinity : loop === false ? 0 : loop;\n      booker?.retract();\n    },\n    loop: () => (loopsLeft === Infinity ? true : loopsLeft === 0 ? false : loopsLeft),\n    edit(fn) {\n      fn();\n      caches = new WeakMap();\n      duration = tracksEnd(opts.tracks, opts.duration);\n      booker?.retract();\n      rearm();\n      for (const cb of subscribers) {\n        try { cb(); } catch (err) { console.error('timeline: subscriber threw', err); }\n      }\n    },\n    subscribe(cb) {\n      subscribers.add(cb);\n      return () => { subscribers.delete(cb); };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/animation/timeline/sampleTrack.js

@@ -1,71 +0,0 @@
-import { axesOf as e } from "../engine/axes.js";
-import { resolveEasing as t } from "@weasel-js/geom";
-import { keys as n } from "@msb235/blits";
-//#region src/animation/timeline/sampleTrack.ts
-var r = {}, i = -1;
-function a(r, i) {
-	let { keys: a } = r, o = Infinity, s = -Infinity, c = /* @__PURE__ */ new Map();
-	for (let e of a) o = Math.min(o, e.t), s = Math.max(s, e.t), c.set(e.t, e.value);
-	let l = s - o, u = {
-		track: r,
-		keys: a,
-		patch: null,
-		t0: o,
-		span: l,
-		exact: c,
-		first: a[0].value,
-		last: a[a.length - 1].value,
-		read: (e) => e
-	};
-	if (l <= 0) return u;
-	let d = (e) => e.easing ? t(e.easing) : void 0, { interpolator: f, interpolate: p } = r;
-	if (f || p) {
-		let e = a.map((e, t) => ({
-			i: t,
-			value: e.value
-		})), t = (e, t, n) => {
-			if (f) {
-				let r = i?.get(t.i);
-				return r || (r = f(e.value, t.value), i?.set(t.i, r)), {
-					i: -1,
-					value: r(n)
-				};
-			}
-			return {
-				i: -1,
-				value: p(e.value, t.value, n)
-			};
-		};
-		return u.patch = n(1, a.map((t, n) => ({
-			at: (t.t - o) / l,
-			delta: { v: e[n] },
-			ease: d(t)
-		})), { lerpBy: () => t }), u.read = (e) => e.value, u;
-	}
-	let m = e(a[0].value);
-	if (!m) return u;
-	for (let t of a) if (e(t.value)?.shape !== m.shape) throw Error(`sampleTrack: every key needs the shape of the first (${m.shape})`);
-	let h = m.shape === "number";
-	return u.patch = n(1, a.map((e) => ({
-		at: (e.t - o) / l,
-		delta: { v: h ? e.value : m.to(e.value) },
-		ease: d(e)
-	}))), h || (u.read = (e) => m.from(e)), u;
-}
-function o(e, t, n) {
-	if (e.keys.length === 0) return;
-	let o = n, s = o?.get(i);
-	(!s || s.track !== e || s.keys !== e.keys) && (o?.clear(), s = a(e, n), o?.set(i, s));
-	let c = s.exact.get(t);
-	if (c !== void 0 || s.exact.has(t)) return c;
-	if (!s.patch) {
-		if (t < s.t0) return s.first;
-		if (t >= s.t0 + s.span) return s.last;
-		throw Error("sampleTrack: interpolate or interpolator is required for non-numeric keyframe values");
-	}
-	return s.read(s.patch.at((t - s.t0) / s.span, 0, r).v);
-}
-//#endregion
-export { o as sampleTrack };
-
-//# sourceMappingURL=sampleTrack.js.map

package/dist/animation/timeline/sampleTrack.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sampleTrack.js","names":["keys","keysPatch","NO_SETTING","BUILT","build","keys$1","track","t0","t1","exact","k","span","out","v","ease","resolveEasing","interpolator","interpolate","boxes","lerp","fn","cache","b","a","u","keys","i","axes","axesOf","scalar","sampleTrack","segmentCache","hit"],"sources":["../../../src/animation/timeline/sampleTrack.ts"],"sourcesContent":["import { keys as keysPatch, type Patch, type Setting } from '@msb235/blits';\nimport { resolveEasing } from '@weasel-js/geom';\nimport { axesOf } from '../engine/axes';\nimport type { SampledTrack } from './types';\n\ntype Out = { v: unknown };\n/** What an interpolated track's stops carry: blits finds the segment and eases it, and the\n *  track's own function makes the value. */\ninterface Box { i: number; value: unknown }\n\ninterface Built {\n  /** What it was built from, so a cache handed another track, or new keys, rebuilds. */\n  track: object;\n  keys: readonly unknown[];\n  /** Null where there is nothing to interpolate: one key time, or values with no way to lerp. */\n  patch: Patch<number, Out, void> | null;\n  t0: number;\n  span: number;\n  /** Every key's time to the value sampling exactly there returns: the later of keys sharing a\n   *  time, and the key's own value where blits would reach it as `a + (b - a) * ease(1)`. */\n  exact: Map<number, unknown>;\n  first: unknown;\n  last: unknown;\n  read: (v: unknown) => unknown;\n}\n\nconst NO_SETTING = {} as Setting<void>;\n/** Where a cache holds its track's `Built`; segment indexes start at 1. A `WeakMap` keyed on the\n *  cache instead cost about a fifth of every sample. */\nconst BUILT = -1;\n\nfunction build<T>(track: SampledTrack<T>, cache: Map<number, (u: number) => T> | undefined): Built {\n  const { keys } = track;\n  let t0 = Infinity;\n  let t1 = -Infinity;\n  const exact = new Map<number, unknown>();\n  for (const k of keys) {\n    t0 = Math.min(t0, k.t);\n    t1 = Math.max(t1, k.t);\n    exact.set(k.t, k.value);\n  }\n  const span = t1 - t0;\n  const out: Built = { track, keys, patch: null, t0, span, exact, first: keys[0].value, last: keys[keys.length - 1].value, read: (v) => v };\n  if (span <= 0) return out;\n\n  const ease = (k: (typeof keys)[number]) => (k.easing ? resolveEasing(k.easing) : undefined);\n  const { interpolator, interpolate } = track;\n  if (interpolator || interpolate) {\n    const boxes: Box[] = keys.map((k, i) => ({ i, value: k.value }));\n    const lerp = (a: Box, b: Box, u: number): Box => {\n      if (interpolator) {\n        let fn = cache?.get(b.i);\n        if (!fn) {\n          fn = interpolator(a.value as T, b.value as T);\n          cache?.set(b.i, fn);\n        }\n        return { i: -1, value: fn(u) };\n      }\n      return { i: -1, value: interpolate!(a.value as T, b.value as T, u) };\n    };\n    out.patch = keysPatch<number, Out>(\n      1,\n      keys.map((k, i) => ({ at: (k.t - t0) / span, delta: { v: boxes[i] }, ease: ease(k) })),\n      { lerpBy: () => lerp as (a: never, b: never, u: number) => unknown },\n    );\n    out.read = (v) => (v as Box).value;\n    return out;\n  }\n\n  const axes = axesOf(keys[0].value);\n  if (!axes) return out;\n  for (const k of keys) {\n    if (axesOf(k.value)?.shape !== axes.shape) {\n      throw new Error(`sampleTrack: every key needs the shape of the first (${axes.shape})`);\n    }\n  }\n  const scalar = axes.shape === 'number';\n  out.patch = keysPatch<number, Out>(\n    1,\n    keys.map((k) => ({ at: (k.t - t0) / span, delta: { v: scalar ? k.value : axes.to(k.value) }, ease: ease(k) })),\n  );\n  if (!scalar) out.read = (v) => axes.from(v as number[]);\n  return out;\n}\n\n/**\n * Sample a track at `t`. Pure: no state, no side effects, safe to call for any\n * `t` in any order — which is what makes scrubbing free.\n *\n * `segmentCache` holds what sampling builds from the keys: the track's blits\n * patch and its `interpolator` factories. Handed another track or a replaced\n * `keys` array, it rebuilds; a key edited in place needs the cache dropped,\n * which `createTimeline` does on `edit`. With no cache, every call builds afresh.\n */\nexport function sampleTrack<T>(\n  track: SampledTrack<T>,\n  t: number,\n  segmentCache?: Map<number, (u: number) => T>,\n): T | undefined {\n  if (track.keys.length === 0) return undefined;\n  const cache = segmentCache as Map<number, unknown> | undefined;\n  let b = cache?.get(BUILT) as Built | undefined;\n  if (!b || b.track !== track || b.keys !== track.keys) {\n    cache?.clear();\n    b = build(track, segmentCache);\n    cache?.set(BUILT, b);\n  }\n  const hit = b.exact.get(t);\n  if (hit !== undefined || b.exact.has(t)) return hit as T;\n  if (!b.patch) {\n    if (t < b.t0) return b.first as T;\n    if (t >= b.t0 + b.span) return b.last as T;\n    throw new Error('sampleTrack: interpolate or interpolator is required for non-numeric keyframe values');\n  }\n  return b.read(b.patch.at((t - b.t0) / b.span, 0, NO_SETTING).v) as T;\n}\n"],"mappings":"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"}

package/dist/animation/useAnimator.js

@@ -1,378 +0,0 @@
-import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
-import { createLoop as t, createTweenLoop as n } from "./loop.js";
-import { stepSpring as r } from "./engine/integrator.js";
-import { createCodec as i } from "./engine/codec.js";
-import { axesOf as a } from "./engine/axes.js";
-import { createStagger as o } from "./stagger.js";
-import { createTimeline as s } from "./timeline/createTimeline.js";
-import { ColorOverrideRegistry as c } from "./colorRegistry.js";
-import { AnimatorEventHub as l } from "./observe.js";
-import { SPRING_PRESETS as u, easeOut as d, resolveEasing as f } from "@weasel-js/geom";
-import { useCallback as p, useEffect as m, useInsertionEffect as h, useMemo as g, useRef as _ } from "react";
-import { useLatest as v } from "@weasel-js/react";
-//#region src/animation/useAnimator.ts
-function y(e) {
-	let t = e.preset ? u[e.preset] : null;
-	return {
-		stiffness: e.stiffness ?? t?.stiffness ?? 170,
-		damping: e.damping ?? t?.damping ?? 26,
-		mass: e.mass ?? t?.mass ?? 1
-	};
-}
-function b(u = {}) {
-	let b = v(u), x = _(/* @__PURE__ */ new Map()), S = _(1), C = _(0), w = _(null), T = _(1), E = _(!1), D = _(new c()), O = _(/* @__PURE__ */ new Set()), k = _(null), A = e(p((e) => {
-		k.current?.(e);
-	}, []), {
-		requestFrame: u.requestFrame,
-		cancelFrame: u.cancelFrame,
-		onResume: () => {
-			for (let e of x.current.values()) e.lastRealNow = null;
-			w.current = null;
-		}
-	}), j = v(A), M = _(!0), N = _(!1), P = () => !M.current && (N.current || (N.current = !0, (typeof process > "u" || process.env.NODE_ENV !== "production") && console.error("weasel useAnimator: animation tick fired after the host component unmounted. This usually means cleanup logic was bypassed — check for refactors that removed the unmount effect or replaced cancelAll with a custom path.")), !0), { api: F, tickAll: I } = g(() => {
-		let e = () => (b.current.now ?? (typeof performance < "u" ? performance.now.bind(performance) : Date.now))(), c = {
-			setTimer: (e, t) => (b.current.setTimer ?? ((e, t) => setTimeout(e, t)))(e, t),
-			clearTimer: (e) => (b.current.clearTimer ?? ((e) => clearTimeout(e)))(e),
-			now: e
-		}, u = /* @__PURE__ */ new Map(), p = (e) => {
-			let t = u.get(e);
-			if (t) {
-				u.delete(e);
-				for (let e of t) e();
-			}
-		}, m = (e, t) => {
-			let n = u.get(e) ?? [];
-			return n.push(t), u.set(e, n), () => {
-				let n = u.get(e);
-				if (!n) return;
-				let r = n.indexOf(t);
-				r >= 0 && n.splice(r, 1), n.length === 0 && u.delete(e);
-			};
-		}, h = new l(), g = i(), _ = (e) => {
-			if (!e.info) {
-				let t = {
-					id: e.id,
-					kind: e.kind
-				};
-				e.cancelKey != null && (t.key = e.cancelKey), e.label != null && (t.label = e.label), e.info = t;
-			}
-			return e.info;
-		}, v = (e) => {
-			let t = x.current.get(e);
-			t && !t.ended && (t.ended = !0, h.watched && h.emit({
-				type: "end",
-				animation: _(t)
-			}));
-		}, k = (e, t, n) => {
-			let r = x.current.get(e);
-			r && (r.onCancel?.(), g.stop(e), x.current.delete(e), p(e), !(!h.watched || r.ended || n) && h.emit(t ? {
-				type: "interrupt",
-				animation: _(r),
-				by: _(t)
-			} : {
-				type: "cancel",
-				animation: _(r)
-			}));
-		}, A = (e) => {
-			let t = [], n = [], r = w.current == null ? 0 : Math.max(0, e - w.current);
-			w.current = e, g.frame(r * (E.current ? 0 : T.current));
-			for (let r of x.current.values()) {
-				let i = r.lastRealNow == null ? 0 : Math.max(0, e - r.lastRealNow);
-				r.lastRealNow = e;
-				let a = E.current ? 0 : T.current * (r.paused ? 0 : r.timeScale);
-				r.virtualNow += i * a, C.current += 1;
-				try {
-					r.tick(r.virtualNow, a) && t.push(r);
-				} catch (e) {
-					n.push([r, e]);
-				} finally {
-					--C.current;
-				}
-			}
-			for (let [e, t] of n) console.error("useAnimator: animation tick threw; retiring it", t), x.current.get(e.id) === e && (e.ended ? (x.current.delete(e.id), p(e.id)) : k(e.id, void 0, !0), h.watched && h.emit({
-				type: "error",
-				animation: _(e),
-				error: t
-			}));
-			for (let e of t) x.current.get(e.id) === e && (v(e.id), x.current.delete(e.id), p(e.id));
-			for (let e of O.current) try {
-				e();
-			} catch (e) {
-				console.error("useAnimator: onTick subscriber threw", e);
-			}
-			x.current.size > 0 ? j.current.request() : w.current = null;
-		}, M = () => {
-			x.current.size !== 0 && j.current.request();
-		}, N = (e, t) => {
-			let n = [];
-			for (let t of x.current.values()) t.cancelKey === e && n.push(t.id);
-			for (let e of n) k(e, t);
-		}, F = (e) => {
-			g.has(e.id) && g.rate(e.id, e.paused ? 0 : e.timeScale);
-		}, I = (t) => {
-			let n = t;
-			return t.cancelKey != null && !t.keepExisting && N(t.cancelKey, n), n.paused = !1, n.timeScale = 1, n.virtualNow = 0, n.lastRealNow = e(), x.current.set(n.id, n), h.watched && h.emit({
-				type: "start",
-				animation: _(n)
-			}), M(), {
-				id: n.id,
-				cancel: () => k(n.id),
-				pause: () => {
-					let e = x.current.get(n.id);
-					e && (e.paused = !0, F(e));
-				},
-				resume: () => {
-					let e = x.current.get(n.id);
-					e && (e.paused = !1, F(e));
-				},
-				setTimeScale: (e) => {
-					let t = x.current.get(n.id);
-					t && (t.timeScale = e, F(t));
-				},
-				timeScale: () => x.current.get(n.id)?.timeScale ?? 1,
-				isPaused: () => x.current.get(n.id)?.paused ?? !1
-			};
-		}, L = ({ kind: e, cancelKey: t, label: n }) => {
-			let r = S.current++, i, a = I({
-				id: r,
-				kind: e,
-				cancelKey: t,
-				label: n,
-				tick: () => !1,
-				onCancel: () => i?.()
-			});
-			return {
-				id: a.id,
-				cancel: a.cancel,
-				pause: a.pause,
-				resume: a.resume,
-				setTimeScale: a.setTimeScale,
-				timeScale: a.timeScale,
-				isPaused: a.isPaused,
-				setOnCancel: (e) => {
-					i = e;
-				},
-				finish: () => {
-					x.current.has(r) && (v(r), x.current.delete(r), p(r));
-				},
-				cancelKey: t
-			};
-		}, R = (t) => {
-			let n = t.interpolate || t.interpolator ? null : a(t.from), r = n && a(t.to), i = n && r && r.shape === n.shape ? n : null;
-			if (!i && !t.interpolate && !t.interpolator) throw Error("tween: interpolate or interpolator is required for non-numeric T");
-			let o = S.current++, s = f(t.easing ?? d), c = t.interpolator ? t.interpolator(t.from, t.to) : null, l = !1;
-			w.current ??= e();
-			let u = g.tween({
-				id: o,
-				ms: Math.max(t.ms, 1),
-				ease: s,
-				from: i ? i.to(t.from) : [0],
-				to: i ? i.to(t.to) : [1]
-			});
-			return I({
-				id: o,
-				kind: "tween",
-				cancelKey: t.cancelKey,
-				label: t.label,
-				progress: (e) => t.ms <= 0 ? 1 : Math.min(1, e / t.ms),
-				tick(e) {
-					if (P()) return g.stop(o), !0;
-					let n = t.ms <= 0 ? 1 : Math.min(1, e / t.ms), r;
-					if (i) r = n >= 1 ? t.to : i.from(u.cols, u.at);
-					else {
-						let e = n >= 1 ? s(1) : u.cols[u.at];
-						r = c ? c(e) : t.interpolate(t.from, t.to, e);
-					}
-					return t.onTick(r), n >= 1 && !l && (l = !0, g.stop(o), x.current.has(o) && (v(o), t.onDone?.()), !0);
-				}
-			});
-		}, z = (t, n = "physics") => {
-			let i = S.current++;
-			if (typeof t.from != "number" && (!t.add || !t.subtract || !t.scale || !t.magnitude)) throw Error("physics: add/subtract/scale/magnitude are required for non-numeric T");
-			let o = t.add ?? ((e, t) => e + t), s = t.subtract ?? ((e, t) => e - t), c = t.scale ?? ((e, t) => e * t), l = t.magnitude ?? ((e) => Math.abs(e)), { stiffness: u, damping: d, mass: f } = y(t), p = t.restThreshold ?? .01, m = t.to ?? null, h = t.from, _ = t.velocity ?? c(t.from, 0), b = null, x = d > 0 && f > 0 && (u > 0 || n === "decay") ? a(t.from) : null, C = (e) => e == null || a(e)?.shape === x.shape, T = x && C(t.to) && C(t.velocity) ? x : null, E = null;
-			T && (w.current ??= e(), E = g.spring({
-				id: i,
-				axes: T.count,
-				from: T.to(t.from),
-				to: t.to == null ? null : T.to(t.to),
-				velocity: t.velocity == null ? Array(T.count).fill(0) : T.to(t.velocity),
-				stiffness: u,
-				damping: d,
-				mass: f
-			}));
-			let D = I({
-				id: i,
-				kind: n,
-				cancelKey: t.cancelKey,
-				label: t.label,
-				tick(e) {
-					if (P()) return g.stop(i), !0;
-					if (b == null) {
-						if (b = e, m == null && l(_) < p) return g.stop(i), v(i), t.onDone?.(), !0;
-						if (!T) return t.onTick(h), !1;
-					}
-					if (T) {
-						let e = E.motion();
-						h = T.from(e.value), _ = T.from(e.velocity);
-					} else {
-						let t = Math.min(.064, (e - b) / 1e3), n = r({
-							add: o,
-							subtract: s,
-							scale: c
-						}, h, _, m, u, d, f, t);
-						h = n.value, _ = n.velocity;
-					}
-					b = e, t.onTick(h);
-					let n = l(_) < p, a = m == null || l(s(h, m)) < p;
-					return n && a ? (m != null && t.onTick(m), g.stop(i), v(i), t.onDone?.(), !0) : !1;
-				}
-			}), O = (e, t) => {
-				if (!C(e)) throw Error(`physics: ${t} is not the same shape as \`from\``);
-			};
-			return {
-				...D,
-				setTarget: (e) => {
-					T && e != null && O(e, "setTarget"), m = e, T && g.has(i) && g.retarget(i, e == null ? null : T.to(e));
-				},
-				setVelocity: (e) => {
-					T && O(e, "setVelocity"), _ = e, T && g.has(i) && g.push(i, T.to(e));
-				}
-			};
-		}, B = {
-			tween: R,
-			spring: (e) => z(e, "spring"),
-			decay: (e) => {
-				let t = e.friction ?? .95, n = -Math.log(t);
-				return z({
-					from: e.from,
-					to: null,
-					velocity: e.velocity,
-					stiffness: 0,
-					damping: n,
-					mass: 1,
-					restThreshold: e.threshold ?? .5,
-					add: e.add,
-					subtract: (t, n) => e.add(t, e.scale(n, -1)),
-					scale: e.scale,
-					magnitude: e.magnitude,
-					onTick: e.onTick,
-					onDone: e.onDone,
-					cancelKey: e.cancelKey,
-					label: e.label
-				}, "decay");
-			},
-			physics: z,
-			cancel: (e) => k(e.id),
-			cancelKey: (e) => N(e),
-			cancelAll: () => {
-				let e = [];
-				for (let t of x.current.values()) t.onCancel?.(), g.stop(t.id), e.push(t);
-				x.current.clear(), w.current = null;
-				for (let t of e) p(t.id);
-				if (h.watched) for (let t of e) h.emit({
-					type: "cancel",
-					animation: _(t)
-				});
-				j.current.cancel();
-			},
-			isActive: (e) => {
-				if (e == null) return x.current.size > 0;
-				for (let t of x.current.values()) if (t.cancelKey === e) return !0;
-				return !1;
-			},
-			isTicking: () => C.current > 0,
-			pause: () => {
-				E.current = !0;
-			},
-			resume: () => {
-				E.current = !1;
-			},
-			isPaused: () => E.current,
-			setTimeScale: (e) => {
-				T.current = e;
-			},
-			timeScale: () => T.current,
-			pauseKey: (e) => {
-				for (let t of x.current.values()) t.cancelKey === e && (t.paused = !0, F(t));
-			},
-			resumeKey: (e) => {
-				for (let t of x.current.values()) t.cancelKey === e && (t.paused = !1, F(t));
-			},
-			setTimeScaleByKey: (e, t) => {
-				for (let n of x.current.values()) n.cancelKey === e && (n.timeScale = t, F(n));
-			},
-			loop: (e, n) => t(L, e, n),
-			tweenLoop: (e) => n(B, L, e),
-			stagger: ((e, t, n, r) => o(B, c, L, m, e, t, n, r)),
-			timeline: (e) => {
-				let t = S.current++, n = () => {
-					let e = x.current.get(t);
-					return e && _(e);
-				};
-				return s(I, t, e, {
-					get watched() {
-						return h.watched;
-					},
-					fire: (e, t, r, i) => {
-						let a = n();
-						a && h.emit({
-							type: "fire",
-							animation: a,
-							track: e,
-							path: t.slice(),
-							event: r,
-							lateBy: i
-						});
-					},
-					lap: (e) => {
-						let t = n();
-						t && h.emit({
-							type: "lap",
-							animation: t,
-							lap: e
-						});
-					}
-				});
-			},
-			colorOverrides: D.current,
-			onTick: (e) => (O.current.add(e), () => {
-				O.current.delete(e);
-			}),
-			keepAlive: () => {
-				let e = L({ kind: "keepAlive" });
-				return () => e.cancel();
-			},
-			watch: (e) => h.add(e),
-			live: () => {
-				let e = [];
-				for (let t of x.current.values()) {
-					let n = {
-						..._(t),
-						paused: t.paused,
-						timeScale: t.timeScale,
-						elapsed: t.virtualNow,
-						...t.progress ? { progress: t.progress(t.virtualNow) } : {}
-					};
-					e.push(n);
-				}
-				return e;
-			}
-		};
-		return {
-			api: B,
-			tickAll: A
-		};
-	}, [j, b]);
-	return h(() => {
-		k.current = I;
-	}, [I]), m(() => {
-		let e = D.current;
-		return M.current = !0, () => {
-			M.current = !1, F.cancelAll(), e.clearAll();
-		};
-	}, [F]), F;
-}
-//#endregion
-export { b as useAnimator };
-
-//# sourceMappingURL=useAnimator.js.map