Function describeTarget

packages/core/src/SpringValue.test.ts:1059–1191

(name: string, create: (from: number) => OpaqueTarget)

}

function describeTarget(name: string, create: (from: number) => OpaqueTarget) {
  describe('when our target is ' + name, () => {
    let target: OpaqueTarget
    let spring: SpringValue
    let observer: FluidObserver
    beforeEach(() => {
      target = create(1)
      spring = new SpringValue(0)
      // The target is not attached until the spring is observed.
      addFluidObserver(spring, (observer = () => {}))
    })

    it('animates toward the current value', async () => {
      spring.start({ to: target.node })
      expect(spring.priority).toBeGreaterThan(target.node.priority)
      expect(spring.animation).toMatchObject({
        to: target.node,
        toValues: null,
      })

      await global.advanceUntilIdle()
      expect(spring.get()).toBe(target.node.get())
    })

    it('preserves its "onRest" prop between animations', async () => {
      const onRest = vi.fn()
      spring.start({ to: target.node, onRest })
      await global.advanceUntilIdle()
      expect(onRest).toBeCalledTimes(1)

      // When the fluid target moves, the spring re-animates without a
      // fresh start() call. The "onRest" handler should still fire when
      // the new animation settles.
      target.start(2)
      await global.advanceUntilIdle()
      expect(onRest).toBeCalledTimes(2)
    })

    it('can change its target while animating', async () => {
      spring.start({ to: target.node })
      await global.advanceUntilValue(spring, target.node.get() / 2)

      spring.start(0)
      expect(spring.priority).toBe(0)
      expect(spring.animation).toMatchObject({
        to: 0,
        toValues: [0],
      })

      await global.advanceUntilIdle()
      expect(spring.get()).toBe(0)
    })

    describe('when target is done animating', () => {
      it('keeps animating until the target is reached', async () => {
        spring.start({ to: target.node })
        target.start(1.1)