@pyreon/reactivity 0.24.4 → 0.24.6

package/src/tests/resource.test.ts

@@ -1,326 +0,0 @@
-import { createResource } from '../resource'
-import { signal } from '../signal'
-
-describe('createResource', () => {
-  test('fetches data when source changes', async () => {
-    const userId = signal(1)
-    const resource = createResource(
-      () => userId(),
-      (id) => Promise.resolve(`user-${id}`),
-    )
-
-    expect(resource.loading()).toBe(true)
-    expect(resource.data()).toBeUndefined()
-    expect(resource.error()).toBeUndefined()
-
-    await new Promise((r) => setTimeout(r, 10))
-
-    expect(resource.data()).toBe('user-1')
-    expect(resource.loading()).toBe(false)
-    expect(resource.error()).toBeUndefined()
-  })
-
-  test('re-fetches when source signal changes', async () => {
-    const userId = signal(1)
-    const resource = createResource(
-      () => userId(),
-      (id) => Promise.resolve(`user-${id}`),
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-1')
-
-    userId.set(2)
-    expect(resource.loading()).toBe(true)
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-2')
-    expect(resource.loading()).toBe(false)
-  })
-
-  test('handles fetcher errors', async () => {
-    const userId = signal(1)
-    const resource = createResource(
-      () => userId(),
-      (_id) => Promise.reject(new Error('network error')),
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-
-    expect(resource.error()).toBeInstanceOf(Error)
-    expect((resource.error() as Error).message).toBe('network error')
-    expect(resource.loading()).toBe(false)
-    expect(resource.data()).toBeUndefined()
-  })
-
-  test('refetch re-runs the fetcher with current source', async () => {
-    let fetchCount = 0
-    const userId = signal(1)
-    const resource = createResource(
-      () => userId(),
-      (id) => {
-        fetchCount++
-        return Promise.resolve(`user-${id}-${fetchCount}`)
-      },
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-1-1')
-
-    resource.refetch()
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-1-2')
-  })
-
-  test('ignores stale responses (race condition)', async () => {
-    const userId = signal(1)
-    const resolvers: ((v: string) => void)[] = []
-
-    const resource = createResource(
-      () => userId(),
-      (_id) =>
-        new Promise<string>((resolve) => {
-          resolvers.push((v) => resolve(v))
-        }),
-    )
-
-    // First fetch is in flight
-    expect(resolvers.length).toBe(1)
-
-    // Change source — triggers second fetch
-    userId.set(2)
-    expect(resolvers.length).toBe(2)
-
-    // Resolve the SECOND request first
-    resolvers[1]?.('user-2')
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-2')
-
-    // Now resolve the FIRST (stale) request — should be ignored
-    resolvers[0]?.('user-1')
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-2') // still user-2, not user-1
-  })
-
-  test('ignores stale errors (race condition)', async () => {
-    const userId = signal(1)
-    const rejecters: ((e: Error) => void)[] = []
-    const resolvers: ((v: string) => void)[] = []
-
-    const resource = createResource(
-      () => userId(),
-      (_id) =>
-        new Promise<string>((resolve, reject) => {
-          resolvers.push(resolve)
-          rejecters.push(reject)
-        }),
-    )
-
-    // First fetch in flight, change source
-    userId.set(2)
-
-    // Resolve second request
-    resolvers[1]?.('user-2')
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('user-2')
-
-    // Reject first (stale) request — should be ignored
-    rejecters[0]?.(new Error('stale error'))
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.error()).toBeUndefined()
-    expect(resource.data()).toBe('user-2')
-  })
-
-  test('loading returns to true on refetch', async () => {
-    const userId = signal(1)
-    const resource = createResource(
-      () => userId(),
-      (id) => Promise.resolve(`user-${id}`),
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.loading()).toBe(false)
-    expect(resource.data()).toBe('user-1')
-
-    resource.refetch()
-    expect(resource.loading()).toBe(true)
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.loading()).toBe(false)
-  })
-
-  test('error is cleared on successful refetch', async () => {
-    let shouldFail = true
-    const src = signal(1)
-    const resource = createResource(
-      () => src(),
-      (_id) => (shouldFail ? Promise.reject(new Error('fail')) : Promise.resolve('ok')),
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.error()).toBeInstanceOf(Error)
-
-    shouldFail = false
-    resource.refetch()
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.error()).toBeUndefined()
-    expect(resource.data()).toBe('ok')
-  })
-
-  test('error is cleared before each fetch attempt', async () => {
-    let callCount = 0
-    const src = signal(1)
-    const resource = createResource(
-      () => src(),
-      (_id) => {
-        callCount++
-        if (callCount === 1) return Promise.reject(new Error('first fail'))
-        return Promise.resolve('success')
-      },
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.error()).toBeInstanceOf(Error)
-
-    // Trigger re-fetch by changing source
-    src.set(2)
-    // Error should be cleared immediately when new fetch starts
-    expect(resource.error()).toBeUndefined()
-    expect(resource.loading()).toBe(true)
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBe('success')
-  })
-
-  test('data is undefined initially and after error', async () => {
-    const src = signal(1)
-    const resource = createResource(
-      () => src(),
-      (_id) => Promise.reject(new Error('always fails')),
-    )
-
-    expect(resource.data()).toBeUndefined()
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(resource.data()).toBeUndefined()
-    expect(resource.error()).toBeInstanceOf(Error)
-  })
-
-  test('refetch uses current source value', async () => {
-    const src = signal(1)
-    const results: string[] = []
-    const resource = createResource(
-      () => src(),
-      (id) => {
-        const val = `user-${id}`
-        results.push(val)
-        return Promise.resolve(val)
-      },
-    )
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(['user-1'])
-
-    src.set(5)
-    await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(['user-1', 'user-5'])
-
-    // Refetch should use current source value (5)
-    resource.refetch()
-    await new Promise((r) => setTimeout(r, 10))
-    expect(results).toEqual(['user-1', 'user-5', 'user-5'])
-  })
-
-  // Regression: pre-fix, the source-tracking effect ran forever with no API
-  // to stop it. Resources created outside an EffectScope leaked the effect
-  // for the lifetime of the program. dispose() now stops the effect AND
-  // marks pending in-flight responses as stale.
-  describe('dispose', () => {
-    test('stops source-tracking after dispose', async () => {
-      const src = signal(1)
-      const calls: number[] = []
-      const resource = createResource(
-        () => src(),
-        (id) => {
-          calls.push(id)
-          return Promise.resolve(`user-${id}`)
-        },
-      )
-
-      await new Promise((r) => setTimeout(r, 10))
-      expect(calls).toEqual([1])
-
-      resource.dispose()
-
-      // Source change after dispose — should NOT trigger a new fetch.
-      src.set(2)
-      await new Promise((r) => setTimeout(r, 10))
-      expect(calls).toEqual([1])
-    })
-
-    test('refetch is a no-op after dispose', async () => {
-      const src = signal(1)
-      const calls: number[] = []
-      const resource = createResource(
-        () => src(),
-        (id) => {
-          calls.push(id)
-          return Promise.resolve(`user-${id}`)
-        },
-      )
-
-      await new Promise((r) => setTimeout(r, 10))
-      expect(calls).toEqual([1])
-
-      resource.dispose()
-      resource.refetch()
-      await new Promise((r) => setTimeout(r, 10))
-      expect(calls).toEqual([1])
-    })
-
-    test('in-flight response is discarded after dispose', async () => {
-      const src = signal(1)
-      // Capture the resolver via a one-element holder so TS doesn't narrow
-      // the closure-assigned variable to `never` after the new Promise
-      // callback returns. `let r = null` then assignment inside the
-      // callback narrows to `never` post-callback (no follow-callback flow).
-      const holder: { resolve: (v: string) => void } = {
-        resolve: () => undefined,
-      }
-      const resource = createResource(
-        () => src(),
-        () =>
-          new Promise<string>((r) => {
-            holder.resolve = r
-          }),
-      )
-
-      // Don't resolve yet — fetch is in flight.
-      expect(resource.loading()).toBe(true)
-      resource.dispose()
-
-      // Now resolve — handlers should see the bumped requestId and discard.
-      holder.resolve('late-result')
-      await new Promise((r) => setTimeout(r, 10))
-
-      expect(resource.data()).toBeUndefined()
-      // loading was true at dispose; response was discarded so the
-      // post-fetch `loading.set(false)` never ran. That's the documented
-      // contract — dispose freezes the resource at its current state.
-      expect(resource.loading()).toBe(true)
-    })
-
-    test('dispose is idempotent', () => {
-      const src = signal(1)
-      const resource = createResource(
-        () => src(),
-        (id) => Promise.resolve(`user-${id}`),
-      )
-      expect(() => {
-        resource.dispose()
-        resource.dispose()
-        resource.dispose()
-      }).not.toThrow()
-    })
-  })
-})

package/src/tests/scope.test.ts

@@ -1,231 +0,0 @@
-import { effect } from '../effect'
-import { EffectScope, effectScope, getCurrentScope, setCurrentScope } from '../scope'
-import { signal } from '../signal'
-
-describe('effectScope', () => {
-  test('creates an EffectScope instance', () => {
-    const scope = effectScope()
-    expect(scope).toBeInstanceOf(EffectScope)
-  })
-
-  test('getCurrentScope returns null by default', () => {
-    expect(getCurrentScope()).toBeNull()
-  })
-
-  test('setCurrentScope sets and clears the current scope', () => {
-    const scope = effectScope()
-    setCurrentScope(scope)
-    expect(getCurrentScope()).toBe(scope)
-    setCurrentScope(null)
-    expect(getCurrentScope()).toBeNull()
-  })
-
-  test('effects created within a scope are disposed on stop', () => {
-    const scope = effectScope()
-    setCurrentScope(scope)
-
-    const s = signal(0)
-    let count = 0
-    effect(() => {
-      s()
-      count++
-    })
-
-    setCurrentScope(null)
-
-    expect(count).toBe(1)
-    s.set(1)
-    expect(count).toBe(2)
-
-    scope.stop()
-    s.set(2)
-    expect(count).toBe(2) // effect disposed, no re-run
-  })
-
-  test('stop is idempotent — second call does nothing', () => {
-    const scope = effectScope()
-    setCurrentScope(scope)
-
-    const s = signal(0)
-    let count = 0
-    effect(() => {
-      s()
-      count++
-    })
-
-    setCurrentScope(null)
-    scope.stop()
-    scope.stop() // should not throw
-    s.set(1)
-    expect(count).toBe(1)
-  })
-
-  test('add is ignored after scope is stopped', () => {
-    const scope = effectScope()
-    scope.stop()
-    // Should not throw — add is silently ignored
-    scope.add({ dispose() {} })
-  })
-
-  test('runInScope temporarily re-activates the scope', () => {
-    const scope = effectScope()
-    setCurrentScope(null)
-
-    const s = signal(0)
-    let count = 0
-
-    scope.runInScope(() => {
-      effect(() => {
-        s()
-        count++
-      })
-    })
-
-    expect(getCurrentScope()).toBeNull() // restored
-    expect(count).toBe(1)
-    s.set(1)
-    expect(count).toBe(2)
-
-    scope.stop()
-    s.set(2)
-    expect(count).toBe(2) // disposed via scope
-  })
-
-  test('runInScope restores previous scope even on error', () => {
-    const scope = effectScope()
-    const prevScope = effectScope()
-    setCurrentScope(prevScope)
-
-    try {
-      scope.runInScope(() => {
-        expect(getCurrentScope()).toBe(scope)
-        throw new Error('test')
-      })
-    } catch {
-      // expected
-    }
-
-    expect(getCurrentScope()).toBe(prevScope)
-    setCurrentScope(null)
-  })
-
-  test("runInScope returns the function's return value", () => {
-    const scope = effectScope()
-    const result = scope.runInScope(() => 42)
-    expect(result).toBe(42)
-  })
-
-  test('addUpdateHook + notifyEffectRan fires hooks via microtask', async () => {
-    const scope = effectScope()
-    let hookCalled = 0
-
-    scope.addUpdateHook(() => {
-      hookCalled++
-    })
-
-    scope.notifyEffectRan()
-    expect(hookCalled).toBe(0) // not yet — microtask
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(hookCalled).toBe(1)
-  })
-
-  test('notifyEffectRan does nothing when no update hooks', async () => {
-    const scope = effectScope()
-    // Should not throw — early return when _updateHooks is empty
-    scope.notifyEffectRan()
-    await new Promise((r) => setTimeout(r, 10))
-  })
-
-  test('notifyEffectRan does nothing after scope is stopped', async () => {
-    const scope = effectScope()
-    let hookCalled = 0
-
-    scope.addUpdateHook(() => {
-      hookCalled++
-    })
-
-    scope.stop()
-    scope.notifyEffectRan()
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(hookCalled).toBe(0)
-  })
-
-  test('notifyEffectRan deduplicates — only one microtask while pending', async () => {
-    const scope = effectScope()
-    let hookCalled = 0
-
-    scope.addUpdateHook(() => {
-      hookCalled++
-    })
-
-    scope.notifyEffectRan()
-    scope.notifyEffectRan()
-    scope.notifyEffectRan()
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(hookCalled).toBe(1) // only fired once
-  })
-
-  test('notifyEffectRan skips hooks if scope stopped before microtask fires', async () => {
-    const scope = effectScope()
-    let hookCalled = 0
-
-    scope.addUpdateHook(() => {
-      hookCalled++
-    })
-
-    scope.notifyEffectRan()
-    scope.stop() // stop before microtask runs
-
-    await new Promise((r) => setTimeout(r, 10))
-    expect(hookCalled).toBe(0)
-  })
-
-  test('onUpdate hook errors are caught and logged', async () => {
-    const scope = effectScope()
-    const errors: unknown[] = []
-    const origError = console.error
-    console.error = (...args: unknown[]) => errors.push(args)
-
-    scope.addUpdateHook(() => {
-      throw new Error('hook error')
-    })
-
-    scope.notifyEffectRan()
-    await new Promise((r) => setTimeout(r, 10))
-
-    expect(errors.length).toBe(1)
-    console.error = origError
-  })
-
-  // Regression: pre-fix, addUpdateHook always allocated `_updateHooks` and
-  // pushed the fn even after `stop()`. The fn never fired (because
-  // notifyEffectRan checks `_active` first), but the registration leaked
-  // an array allocation and gave the caller no signal that the hook was
-  // futile. Mirrors `add()`'s silent-no-op-when-stopped contract.
-  test('addUpdateHook honors _active — silently no-ops on stopped scope', () => {
-    const scope = effectScope()
-    scope.stop()
-
-    let hookFired = false
-    scope.addUpdateHook(() => {
-      hookFired = true
-    })
-
-    // Cause an update — the hook should NOT fire because scope is stopped.
-    scope.notifyEffectRan()
-    expect(hookFired).toBe(false)
-
-    // The internal `_updateHooks` should not have been allocated either.
-    // We can't introspect the private field, but the observable contract
-    // is "stopped scopes don't fire hooks under any circumstance" — which
-    // would have held pre-fix too because `notifyEffectRan` already
-    // gated on `_active`. The fix prevents the array allocation; we test
-    // the consequence: no fire, regardless of how often you push.
-    for (let i = 0; i < 100; i++) scope.addUpdateHook(() => {})
-    scope.notifyEffectRan()
-    expect(hookFired).toBe(false)
-  })
-})