@flighthq/tween 0.1.0

package/src/tweenProgress.test.ts

@@ -0,0 +1,197 @@
+import { connectSignal } from '@flighthq/signals';
+
+import { createTween } from './tween';
+import { createTweenManager } from './tweenManager';
+import { getTweenProgress, invalidateTween, restartTween, seekTween, setTweenProgress } from './tweenProgress';
+import { updateTweens } from './updateTweens';
+
+describe('getTweenProgress', () => {
+  it('returns 0 before any update', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    expect(getTweenProgress(tween)).toBe(0);
+  });
+  it('returns 0 while still in delay phase', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 }, { delay: 500 });
+    updateTweens(manager, 400);
+    expect(getTweenProgress(tween)).toBe(0);
+  });
+  it('returns 0.5 at the halfway point', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    expect(getTweenProgress(tween)).toBeCloseTo(0.5);
+  });
+  it('returns 1 when complete', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    updateTweens(manager, 1000);
+    expect(getTweenProgress(tween)).toBe(1);
+  });
+});
+
+describe('invalidateTween', () => {
+  it('resets initialized, complete, and elapsed', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 1000);
+    expect(tween.complete).toBe(true);
+    invalidateTween(tween);
+    expect(tween.initialized).toBe(false);
+    expect(tween.complete).toBe(false);
+    expect(tween.elapsed).toBe(0);
+  });
+  it('re-captures start values from current target state on next update', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 1000); // x is now 100
+    invalidateTween(tween);
+    // Re-register: the new start is 100
+    manager.tweens.get(target)?.push(tween);
+    updateTweens(manager, 1000); // tween from 100 to 100 (end is absolute 100, so change is 0)
+    expect(target.x).toBe(100);
+  });
+});
+
+describe('restartTween', () => {
+  it('resets complete and elapsed to zero', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 1000);
+    expect(tween.complete).toBe(true);
+    restartTween(tween);
+    expect(tween.complete).toBe(false);
+    expect(tween.elapsed).toBe(0);
+  });
+  it('includeDelay=false skips the initial delay', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 }, { delay: 500 });
+    restartTween(tween, false);
+    expect(tween.elapsed).toBe(500); // elapsed = delay so active immediately
+  });
+  it('keeps initialized=false so start values are re-captured', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    updateTweens(manager, 500); // gets initialized
+    restartTween(tween);
+    expect(tween.initialized).toBe(false);
+  });
+});
+
+describe('seekTween', () => {
+  it('immediately applies property values at the given time', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    seekTween(tween, 500);
+    expect(target.x).toBeCloseTo(50);
+  });
+  it('clamps to 0 when time is negative', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    seekTween(tween, -100);
+    expect(target.x).toBe(0);
+  });
+  it('clamps to the end value when time exceeds duration', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    seekTween(tween, 9999);
+    expect(target.x).toBe(100);
+    expect(tween.complete).toBe(true);
+  });
+  it('accounts for delay in the elapsed time', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, delay: 500 });
+    seekTween(tween, 1000); // delay=500 + 500ms active = 50%
+    expect(target.x).toBeCloseTo(50);
+  });
+  it('emits onUpdate when applying values', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    let updates = 0;
+    connectSignal(tween.onUpdate, () => updates++);
+    seekTween(tween, 500);
+    expect(updates).toBe(1);
+  });
+  it('fires onComplete when seeking to exact end (delay + duration)', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, delay: 200 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    seekTween(tween, 1200);
+    expect(fired).toBe(1);
+    expect(tween.complete).toBe(true);
+  });
+  it('does not fire onComplete when seeking just before the end', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, delay: 200 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    seekTween(tween, 1199.999);
+    expect(fired).toBe(0);
+    expect(tween.complete).toBe(false);
+  });
+  it('is alias-safe: out === input does not produce wrong values', () => {
+    // The tween's target is both the input (start values are read from it) and the output.
+    // initializeTween reads `target.x` then we write to `target.x`.
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    seekTween(tween, 500);
+    expect(target.x).toBeCloseTo(50);
+    // Calling again should be consistent
+    seekTween(tween, 750);
+    expect(target.x).toBeCloseTo(75);
+  });
+});
+
+describe('setTweenProgress', () => {
+  it('applies the progress fraction to target values', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    setTweenProgress(tween, 0.5);
+    expect(target.x).toBeCloseTo(50);
+  });
+  it('clamps progress to 0', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    setTweenProgress(tween, -1);
+    expect(target.x).toBe(0);
+  });
+  it('clamps progress to 1 and marks tween complete', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    setTweenProgress(tween, 2);
+    expect(target.x).toBe(100);
+    expect(tween.complete).toBe(true);
+  });
+  it('fires onComplete when setting progress to 1', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    setTweenProgress(tween, 1);
+    expect(fired).toBe(1);
+    expect(tween.complete).toBe(true);
+  });
+  it('is alias-safe: multiple sequential calls produce consistent results', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    setTweenProgress(tween, 0.25);
+    expect(target.x).toBeCloseTo(25);
+    setTweenProgress(tween, 0.75);
+    expect(target.x).toBeCloseTo(75);
+  });
+});

package/src/tweenStagger.test.ts

@@ -0,0 +1,94 @@
+import { createTweenManager } from './tweenManager';
+import { createTweenStagger } from './tweenStagger';
+import { updateTweens } from './updateTweens';
+
+describe('createTweenStagger', () => {
+  it('returns an empty array for empty targets', () => {
+    const manager = createTweenManager();
+    const targets: { x: number }[] = [];
+    expect(createTweenStagger(manager, targets, 1000, {})).toEqual([]);
+  });
+
+  it('returns one tween per target', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }, { x: 0 }];
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 });
+    expect(tweens).toHaveLength(3);
+  });
+
+  it('each tween targets the corresponding element', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }];
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 });
+    expect(tweens[0].target).toBe(targets[0]);
+    expect(tweens[1].target).toBe(targets[1]);
+  });
+
+  it('staggers start delays by each interval (from: start default)', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }, { x: 0 }];
+    // Using ms units throughout. each=200ms.
+    // Formula: position[i] = i/(count-1), delay = position * each * (count-1) = i * each
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 200 });
+    expect(tweens[0].delay).toBeCloseTo(0);
+    expect(tweens[1].delay).toBeCloseTo(200);
+    expect(tweens[2].delay).toBeCloseTo(400);
+  });
+
+  it('from: end reverses the stagger order', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }, { x: 0 }];
+    // each=100ms. from end: last target delay=0, first target delay=200ms
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 100, from: 'end' });
+    expect(tweens[2].delay).toBeCloseTo(0);
+    expect(tweens[0].delay).toBeCloseTo(200);
+  });
+
+  it('from: center staggers outward from the middle', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }, { x: 0 }, { x: 0 }, { x: 0 }];
+    // center index = 2. Distances: [2,1,0,1,2]. Max=2.
+    // positions: [1, 0.5, 0, 0.5, 1] * each * (count-1) = pos * 100 * 4
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 100, from: 'center' });
+    expect(tweens[2].delay).toBeCloseTo(0);
+    expect(tweens[0].delay).toBeCloseTo(400);
+    expect(tweens[4].delay).toBeCloseTo(400);
+  });
+
+  it('from: numeric index staggers outward from that index', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }, { x: 0 }];
+    // Origin index 0, max distance=2. positions: [0, 0.5, 1] * each * (count-1) = pos * 100 * 2
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 100, from: 0 });
+    expect(tweens[0].delay).toBeCloseTo(0);
+    expect(tweens[1].delay).toBeCloseTo(100);
+    expect(tweens[2].delay).toBeCloseTo(200);
+  });
+
+  it('adds baseDelay from options to all stagger delays', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }];
+    // each=100ms, base delay=500ms
+    const tweens = createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 100 }, { delay: 500 });
+    expect(tweens[0].delay).toBeCloseTo(500);
+    expect(tweens[1].delay).toBeCloseTo(600);
+  });
+
+  it('actually animates targets with staggered timing', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }];
+    // each=200ms: target[0] starts at 0ms, target[1] starts at 200ms
+    createTweenStagger(manager, targets, 1000, { x: 100 }, { each: 200 }, { ease: (t) => t });
+    updateTweens(manager, 100); // target[0] at 100/1000=10%; target[1] delay=200 not reached
+    expect(targets[0].x).toBeCloseTo(10);
+    expect(targets[1].x).toBe(0); // still in delay
+  });
+
+  it('passes duration correctly to each tween', () => {
+    const manager = createTweenManager();
+    const targets = [{ x: 0 }, { x: 0 }];
+    const tweens = createTweenStagger(manager, targets, 2000, { x: 100 });
+    expect(tweens[0].duration).toBe(2000);
+    expect(tweens[1].duration).toBe(2000);
+  });
+});

package/src/updateTweens.test.ts

@@ -0,0 +1,292 @@
+import { connectSignal } from '@flighthq/signals';
+
+import { createTween, pauseTween, resumeTween } from './tween';
+import { createTweenManager } from './tweenManager';
+import { completeTween, updateTweens } from './updateTweens';
+
+describe('completeTween', () => {
+  it('jumps target to end value and marks tween complete', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    completeTween(tween);
+    expect(target.x).toBe(100);
+    expect(tween.complete).toBe(true);
+  });
+
+  it('emits onComplete', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    completeTween(tween);
+    expect(fired).toBe(1);
+  });
+
+  it('works on an uninitialized tween (before first update)', () => {
+    const manager = createTweenManager();
+    const target = { x: 25 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    expect(tween.initialized).toBe(false);
+    completeTween(tween);
+    expect(target.x).toBe(100);
+  });
+
+  it('lands on start value when reverse=true', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, reverse: true });
+    completeTween(tween);
+    expect(target.x).toBe(0); // reverse completes at start (0), not end (100)
+    expect(tween.complete).toBe(true);
+  });
+
+  it('is a no-op on an already complete tween', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    completeTween(tween);
+    target.x = 0;
+    completeTween(tween);
+    expect(target.x).toBe(0);
+  });
+});
+
+describe('smartRotation', () => {
+  it('takes the short path for a large positive delta', () => {
+    const manager = createTweenManager();
+    const target = { rotation: 0 };
+    // 350° forward is the same as -10° backward — smart path is -10
+    createTween(manager, target, 1000, { rotation: 350 }, { ease: (t) => t, smartRotation: true });
+    updateTweens(manager, 500);
+    expect(target.rotation).toBeCloseTo(-5);
+  });
+
+  it('takes the short path for a large negative delta', () => {
+    const manager = createTweenManager();
+    const target = { rotation: 0 };
+    // -350° backward is the same as +10° forward — smart path is +10
+    createTween(manager, target, 1000, { rotation: -350 }, { ease: (t) => t, smartRotation: true });
+    updateTweens(manager, 500);
+    expect(target.rotation).toBeCloseTo(5);
+  });
+
+  it('finds the short path when starting from a non-zero angle', () => {
+    const manager = createTweenManager();
+    const target = { rotation: 350 };
+    // Naive delta: 10 - 350 = -340°. Smart path: +20° (go forward, not backward).
+    // start=350, change=+20, midpoint: 360, end: 370
+    createTween(manager, target, 1000, { rotation: 10 }, { ease: (t) => t, smartRotation: true });
+    updateTweens(manager, 500);
+    expect(target.rotation).toBeCloseTo(360);
+    updateTweens(manager, 500);
+    expect(target.rotation).toBeCloseTo(370);
+  });
+
+  it('leaves small deltas unchanged', () => {
+    const manager = createTweenManager();
+    const target = { rotation: 0 };
+    createTween(manager, target, 1000, { rotation: 90 }, { ease: (t) => t, smartRotation: true });
+    updateTweens(manager, 500);
+    expect(target.rotation).toBeCloseTo(45);
+  });
+});
+
+describe('updateTweens', () => {
+  it('interpolates property toward target value', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50);
+  });
+
+  it('reaches target value at end of duration', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 1000);
+    expect(target.x).toBe(100);
+  });
+
+  it('animates multiple properties independently to their respective targets', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    createTween(manager, target, 1000, { x: 100, y: 200 }, { ease: (t) => t });
+    updateTweens(manager, 1000);
+    expect(target.x).toBe(100);
+    expect(target.y).toBe(200);
+  });
+
+  it('marks tween complete after duration', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    updateTweens(manager, 1000);
+    expect(tween.complete).toBe(true);
+  });
+
+  it('removes completed tweens from manager', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 });
+    updateTweens(manager, 1000);
+    updateTweens(manager, 0);
+    expect(manager.tweens.has(target)).toBe(false);
+  });
+
+  it('emits onComplete when finished', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    updateTweens(manager, 1000);
+    expect(fired).toBe(1);
+  });
+
+  it('emits onUpdate each tick', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let updates = 0;
+    connectSignal(tween.onUpdate, () => updates++);
+    updateTweens(manager, 250);
+    updateTweens(manager, 250);
+    expect(updates).toBe(2);
+  });
+
+  it('respects delay before starting', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, delay: 500 });
+    updateTweens(manager, 500);
+    expect(target.x).toBe(0);
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50);
+  });
+
+  it('repeats the specified number of times', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: 2 });
+    let repeats = 0;
+    connectSignal(tween.onRepeat, () => repeats++);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    expect(repeats).toBe(2);
+    expect(tween.complete).toBe(true);
+  });
+
+  it('reverse: true animates from end value back to start', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    // At 10% duration, a reversed linear tween is at 90% of the range
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, reverse: true });
+    updateTweens(manager, 100);
+    expect(target.x).toBeCloseTo(90);
+    updateTweens(manager, 900);
+    expect(target.x).toBe(0);
+  });
+
+  it('reflect reverses direction on each repeat, arriving back at start', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: 1, reflect: true });
+    updateTweens(manager, 1000); // play 1 forward: x → 100
+    expect(target.x).toBe(100);
+    updateTweens(manager, 250); // 25% into reflected play 2: going backward, so x = 75 not 25
+    expect(target.x).toBeCloseTo(75);
+    updateTweens(manager, 750); // play 2 completes: x → 0
+    expect(target.x).toBe(0);
+  });
+
+  it('emits onYoyo on direction flip with reflect', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: 1, reflect: true });
+    let yoyos = 0;
+    connectSignal(tween.onYoyo, () => yoyos++);
+    updateTweens(manager, 1000);
+    expect(yoyos).toBe(1);
+  });
+
+  it('does not emit onYoyo without reflect', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: 1 });
+    let yoyos = 0;
+    connectSignal(tween.onYoyo, () => yoyos++);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    expect(yoyos).toBe(0);
+  });
+
+  it('emits onYoyo each reflect cycle', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: 3, reflect: true });
+    let yoyos = 0;
+    connectSignal(tween.onYoyo, () => yoyos++);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    expect(yoyos).toBe(3);
+  });
+
+  it('repeat: -1 loops indefinitely without ever completing', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, repeat: -1 });
+    let repeats = 0;
+    connectSignal(tween.onRepeat, () => repeats++);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    expect(repeats).toBe(3);
+    expect(tween.complete).toBe(false);
+    expect(tween.repeat).toBe(-1);
+  });
+
+  it('rounds values when snapping=true', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t, snapping: true });
+    updateTweens(manager, 333);
+    expect(Number.isInteger(target.x)).toBe(true);
+  });
+
+  it('does not update paused tween', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    pauseTween(tween);
+    updateTweens(manager, 500);
+    expect(target.x).toBe(0);
+  });
+
+  it('resumes after pause', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    pauseTween(tween);
+    updateTweens(manager, 500);
+    resumeTween(tween);
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50);
+  });
+
+  it('elapsed does not accumulate while paused', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    pauseTween(tween);
+    updateTweens(manager, 500);
+    expect(tween.elapsed).toBe(0);
+    resumeTween(tween);
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50); // 500ms of actual animation, not 1000ms
+  });
+});