@pyreon/hooks 0.11.4 → 0.11.6

package/src/__tests__/useColorScheme.test.ts

@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 let mountCallbacks: Array<() => unknown> = []
 let unmountCallbacks: Array<() => void> = []
 
-vi.mock("@pyreon/core", () => ({
+vi.mock('@pyreon/core', () => ({
   onMount: (fn: () => unknown) => {
     mountCallbacks.push(fn)
   },
@@ -12,9 +12,9 @@ vi.mock("@pyreon/core", () => ({
   },
 }))
 
-import { useColorScheme } from "../useColorScheme"
+import { useColorScheme } from '../useColorScheme'
 
-describe("useColorScheme", () => {
+describe('useColorScheme', () => {
   let changeListeners: Map<string, (e: MediaQueryListEvent) => void>
 
   beforeEach(() => {
@@ -22,35 +22,35 @@ describe("useColorScheme", () => {
     unmountCallbacks = []
     changeListeners = new Map()
 
-    Object.defineProperty(window, "matchMedia", {
+    Object.defineProperty(window, 'matchMedia', {
       writable: true,
       value: vi.fn((query: string) => ({
         matches: false,
         media: query,
         addEventListener: vi.fn((event: string, cb: (e: MediaQueryListEvent) => void) => {
-          if (event === "change") changeListeners.set(query, cb)
+          if (event === 'change') changeListeners.set(query, cb)
         }),
         removeEventListener: vi.fn(),
       })),
     })
   })
 
-  it("returns light by default", () => {
+  it('returns light by default', () => {
     const scheme = useColorScheme()
     mountCallbacks.forEach((cb) => {
       cb()
     })
-    expect(scheme()).toBe("light")
+    expect(scheme()).toBe('light')
   })
 
-  it("returns dark when prefers-color-scheme is dark", () => {
-    Object.defineProperty(window, "matchMedia", {
+  it('returns dark when prefers-color-scheme is dark', () => {
+    Object.defineProperty(window, 'matchMedia', {
       writable: true,
       value: vi.fn((query: string) => ({
         matches: true,
         media: query,
         addEventListener: vi.fn((event: string, cb: (e: MediaQueryListEvent) => void) => {
-          if (event === "change") changeListeners.set(query, cb)
+          if (event === 'change') changeListeners.set(query, cb)
         }),
         removeEventListener: vi.fn(),
       })),
@@ -60,29 +60,29 @@ describe("useColorScheme", () => {
     mountCallbacks.forEach((cb) => {
       cb()
     })
-    expect(scheme()).toBe("dark")
+    expect(scheme()).toBe('dark')
   })
 
-  it("updates when color scheme changes from light to dark", () => {
+  it('updates when color scheme changes from light to dark', () => {
     const scheme = useColorScheme()
     mountCallbacks.forEach((cb) => {
       cb()
     })
-    expect(scheme()).toBe("light")
+    expect(scheme()).toBe('light')
 
-    const listener = changeListeners.get("(prefers-color-scheme: dark)")
+    const listener = changeListeners.get('(prefers-color-scheme: dark)')
     listener?.({ matches: true } as MediaQueryListEvent)
-    expect(scheme()).toBe("dark")
+    expect(scheme()).toBe('dark')
   })
 
-  it("updates when color scheme changes from dark to light", () => {
-    Object.defineProperty(window, "matchMedia", {
+  it('updates when color scheme changes from dark to light', () => {
+    Object.defineProperty(window, 'matchMedia', {
       writable: true,
       value: vi.fn((query: string) => ({
         matches: true,
         media: query,
         addEventListener: vi.fn((event: string, cb: (e: MediaQueryListEvent) => void) => {
-          if (event === "change") changeListeners.set(query, cb)
+          if (event === 'change') changeListeners.set(query, cb)
         }),
         removeEventListener: vi.fn(),
       })),
@@ -92,10 +92,10 @@ describe("useColorScheme", () => {
     mountCallbacks.forEach((cb) => {
       cb()
     })
-    expect(scheme()).toBe("dark")
+    expect(scheme()).toBe('dark')
 
-    const listener = changeListeners.get("(prefers-color-scheme: dark)")
+    const listener = changeListeners.get('(prefers-color-scheme: dark)')
     listener?.({ matches: false } as MediaQueryListEvent)
-    expect(scheme()).toBe("light")
+    expect(scheme()).toBe('light')
   })
 })

package/src/__tests__/useControllableState.test.ts

@@ -1,43 +1,43 @@
-import { describe, expect, it, vi } from "vitest"
-import { useControllableState } from "../useControllableState"
+import { describe, expect, it, vi } from 'vitest'
+import { useControllableState } from '../useControllableState'
 
-describe("useControllableState", () => {
-  it("uses defaultValue when uncontrolled", () => {
-    const [value] = useControllableState({ defaultValue: "hello" })
-    expect(value()).toBe("hello")
+describe('useControllableState', () => {
+  it('uses defaultValue when uncontrolled', () => {
+    const [value] = useControllableState({ defaultValue: 'hello' })
+    expect(value()).toBe('hello')
   })
 
-  it("updates internal state when uncontrolled", () => {
+  it('updates internal state when uncontrolled', () => {
     const [value, setValue] = useControllableState({ defaultValue: 0 })
     setValue(5)
     expect(value()).toBe(5)
   })
 
-  it("uses value when controlled", () => {
-    const [value] = useControllableState({ value: "controlled", defaultValue: "default" })
-    expect(value()).toBe("controlled")
+  it('uses value when controlled', () => {
+    const [value] = useControllableState({ value: 'controlled', defaultValue: 'default' })
+    expect(value()).toBe('controlled')
   })
 
-  it("does not update internal state when controlled", () => {
+  it('does not update internal state when controlled', () => {
     const onChange = vi.fn()
     const [value, setValue] = useControllableState({
-      value: "controlled",
-      defaultValue: "default",
+      value: 'controlled',
+      defaultValue: 'default',
       onChange,
     })
-    setValue("new")
-    expect(value()).toBe("controlled")
-    expect(onChange).toHaveBeenCalledWith("new")
+    setValue('new')
+    expect(value()).toBe('controlled')
+    expect(onChange).toHaveBeenCalledWith('new')
   })
 
-  it("calls onChange in uncontrolled mode", () => {
+  it('calls onChange in uncontrolled mode', () => {
     const onChange = vi.fn()
     const [, setValue] = useControllableState({ defaultValue: 0, onChange })
     setValue(10)
     expect(onChange).toHaveBeenCalledWith(10)
   })
 
-  it("supports updater function", () => {
+  it('supports updater function', () => {
     const [value, setValue] = useControllableState({ defaultValue: 1 })
     setValue((prev: number) => prev + 1)
     expect(value()).toBe(2)

package/src/__tests__/useDebouncedCallback.test.ts

@@ -1,54 +1,54 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { useDebouncedCallback } from "../useDebouncedCallback"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useDebouncedCallback } from '../useDebouncedCallback'
 
 // Mock onUnmount since it requires component lifecycle context
-vi.mock("@pyreon/core", () => ({
+vi.mock('@pyreon/core', () => ({
   onMount: (fn: () => void) => fn(),
   onUnmount: (_fn: () => void) => {
     /* no-op */
   },
 }))
 
-describe("useDebouncedCallback", () => {
+describe('useDebouncedCallback', () => {
   beforeEach(() => vi.useFakeTimers())
   afterEach(() => vi.useRealTimers())
 
-  it("debounces the callback", () => {
+  it('debounces the callback', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
-    debounced("a")
-    debounced("b")
-    debounced("c")
+    debounced('a')
+    debounced('b')
+    debounced('c')
 
     expect(fn).not.toHaveBeenCalled()
     vi.advanceTimersByTime(100)
     expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith("c")
+    expect(fn).toHaveBeenCalledWith('c')
   })
 
-  it("cancel prevents the callback", () => {
+  it('cancel prevents the callback', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
-    debounced("a")
+    debounced('a')
     debounced.cancel()
     vi.advanceTimersByTime(200)
 
     expect(fn).not.toHaveBeenCalled()
   })
 
-  it("flush invokes immediately", () => {
+  it('flush invokes immediately', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
-    debounced("x")
+    debounced('x')
     debounced.flush()
 
-    expect(fn).toHaveBeenCalledWith("x")
+    expect(fn).toHaveBeenCalledWith('x')
   })
 
-  it("flush is a no-op when no pending timer", () => {
+  it('flush is a no-op when no pending timer', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
@@ -56,11 +56,11 @@ describe("useDebouncedCallback", () => {
     expect(fn).not.toHaveBeenCalled()
   })
 
-  it("flush is a no-op after timer already fired", () => {
+  it('flush is a no-op after timer already fired', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
-    debounced("a")
+    debounced('a')
     vi.advanceTimersByTime(100)
     expect(fn).toHaveBeenCalledTimes(1)
 
@@ -68,11 +68,11 @@ describe("useDebouncedCallback", () => {
     expect(fn).toHaveBeenCalledTimes(1)
   })
 
-  it("flush is a no-op after cancel", () => {
+  it('flush is a no-op after cancel', () => {
     const fn = vi.fn()
     const debounced = useDebouncedCallback(fn, 100)
 
-    debounced("a")
+    debounced('a')
     debounced.cancel()
     debounced.flush()
     expect(fn).not.toHaveBeenCalled()

package/src/__tests__/useDebouncedValue.test.ts

@@ -1,16 +1,16 @@
-import { signal } from "@pyreon/reactivity"
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { useDebouncedValue } from "../useDebouncedValue"
+import { signal } from '@pyreon/reactivity'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useDebouncedValue } from '../useDebouncedValue'
 
 // Mock onUnmount since it requires component lifecycle context
-vi.mock("@pyreon/core", () => ({
+vi.mock('@pyreon/core', () => ({
   onMount: (fn: () => void) => fn(),
   onUnmount: (_fn: () => void) => {
     /* no-op */
   },
 }))
 
-describe("useDebouncedValue", () => {
+describe('useDebouncedValue', () => {
   beforeEach(() => {
     vi.useFakeTimers()
   })
@@ -19,33 +19,33 @@ describe("useDebouncedValue", () => {
     vi.useRealTimers()
   })
 
-  it("returns the initial value immediately", () => {
+  it('returns the initial value immediately', () => {
     const source = signal(42)
     const debounced = useDebouncedValue(source, 300)
     expect(debounced()).toBe(42)
   })
 
-  it("does not update immediately when source changes", () => {
-    const source = signal("hello")
+  it('does not update immediately when source changes', () => {
+    const source = signal('hello')
     const debounced = useDebouncedValue(source, 300)
-    expect(debounced()).toBe("hello")
+    expect(debounced()).toBe('hello')
 
-    source.set("world")
-    expect(debounced()).toBe("hello")
+    source.set('world')
+    expect(debounced()).toBe('hello')
   })
 
-  it("updates after the delay elapses", () => {
-    const source = signal("hello")
+  it('updates after the delay elapses', () => {
+    const source = signal('hello')
     const debounced = useDebouncedValue(source, 300)
 
-    source.set("world")
-    expect(debounced()).toBe("hello")
+    source.set('world')
+    expect(debounced()).toBe('hello')
 
     vi.advanceTimersByTime(300)
-    expect(debounced()).toBe("world")
+    expect(debounced()).toBe('world')
   })
 
-  it("resets the timer on rapid changes", () => {
+  it('resets the timer on rapid changes', () => {
     const source = signal(1)
     const debounced = useDebouncedValue(source, 300)
 
@@ -62,7 +62,7 @@ describe("useDebouncedValue", () => {
     expect(debounced()).toBe(4)
   })
 
-  it("only applies the last value after debounce", () => {
+  it('only applies the last value after debounce', () => {
     const source = signal(0)
     const debounced = useDebouncedValue(source, 200)
 
@@ -76,20 +76,20 @@ describe("useDebouncedValue", () => {
     expect(debounced()).toBe(5)
   })
 
-  it("handles multiple debounce cycles", () => {
-    const source = signal("a")
+  it('handles multiple debounce cycles', () => {
+    const source = signal('a')
     const debounced = useDebouncedValue(source, 100)
 
-    source.set("b")
+    source.set('b')
     vi.advanceTimersByTime(100)
-    expect(debounced()).toBe("b")
+    expect(debounced()).toBe('b')
 
-    source.set("c")
+    source.set('c')
     vi.advanceTimersByTime(100)
-    expect(debounced()).toBe("c")
+    expect(debounced()).toBe('c')
   })
 
-  it("works with zero delay", () => {
+  it('works with zero delay', () => {
     const source = signal(1)
     const debounced = useDebouncedValue(source, 0)
 
@@ -98,9 +98,9 @@ describe("useDebouncedValue", () => {
     expect(debounced()).toBe(2)
   })
 
-  it("works with object values", () => {
-    const obj1 = { name: "Alice" }
-    const obj2 = { name: "Bob" }
+  it('works with object values', () => {
+    const obj1 = { name: 'Alice' }
+    const obj2 = { name: 'Bob' }
     const source = signal(obj1)
     const debounced = useDebouncedValue(source, 100)
     expect(debounced()).toBe(obj1)

package/src/__tests__/useElementSize.test.ts

@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 let mountCallbacks: Array<() => unknown> = []
 let unmountCallbacks: Array<() => void> = []
 
-vi.mock("@pyreon/core", () => ({
+vi.mock('@pyreon/core', () => ({
   onMount: (fn: () => unknown) => {
     mountCallbacks.push(fn)
   },
@@ -12,9 +12,9 @@ vi.mock("@pyreon/core", () => ({
   },
 }))
 
-import { useElementSize } from "../useElementSize"
+import { useElementSize } from '../useElementSize'
 
-describe("useElementSize", () => {
+describe('useElementSize', () => {
   let resizeCallback: ((entries: ResizeObserverEntry[]) => void) | undefined
   let observeSpy: ReturnType<typeof vi.fn>
   let disconnectSpy: ReturnType<typeof vi.fn>
@@ -36,15 +36,15 @@ describe("useElementSize", () => {
     }) as unknown as typeof ResizeObserver
   })
 
-  it("returns initial size of 0x0", () => {
+  it('returns initial size of 0x0', () => {
     const size = useElementSize(() => null)
     expect(size().width).toBe(0)
     expect(size().height).toBe(0)
   })
 
-  it("measures initial element size on mount", () => {
-    const el = document.createElement("div")
-    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+  it('measures initial element size on mount', () => {
+    const el = document.createElement('div')
+    vi.spyOn(el, 'getBoundingClientRect').mockReturnValue({
       width: 200,
       height: 100,
       x: 0,
@@ -67,9 +67,9 @@ describe("useElementSize", () => {
     expect(size().height).toBe(100)
   })
 
-  it("observes the element with ResizeObserver", () => {
-    const el = document.createElement("div")
-    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+  it('observes the element with ResizeObserver', () => {
+    const el = document.createElement('div')
+    vi.spyOn(el, 'getBoundingClientRect').mockReturnValue({
       width: 0,
       height: 0,
       x: 0,
@@ -91,9 +91,9 @@ describe("useElementSize", () => {
     expect(observeSpy).toHaveBeenCalledWith(el)
   })
 
-  it("updates size when ResizeObserver fires", () => {
-    const el = document.createElement("div")
-    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+  it('updates size when ResizeObserver fires', () => {
+    const el = document.createElement('div')
+    vi.spyOn(el, 'getBoundingClientRect').mockReturnValue({
       width: 100,
       height: 50,
       x: 0,
@@ -124,7 +124,7 @@ describe("useElementSize", () => {
     expect(size().height).toBe(150)
   })
 
-  it("does nothing on mount when element is null", () => {
+  it('does nothing on mount when element is null', () => {
     useElementSize(() => null)
     mountCallbacks.forEach((cb) => {
       cb()
@@ -133,9 +133,9 @@ describe("useElementSize", () => {
     expect(observeSpy).not.toHaveBeenCalled()
   })
 
-  it("disconnects ResizeObserver on unmount", () => {
-    const el = document.createElement("div")
-    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+  it('disconnects ResizeObserver on unmount', () => {
+    const el = document.createElement('div')
+    vi.spyOn(el, 'getBoundingClientRect').mockReturnValue({
       width: 0,
       height: 0,
       x: 0,
@@ -160,9 +160,9 @@ describe("useElementSize", () => {
     expect(disconnectSpy).toHaveBeenCalled()
   })
 
-  it("handles ResizeObserver callback with no entry", () => {
-    const el = document.createElement("div")
-    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+  it('handles ResizeObserver callback with no entry', () => {
+    const el = document.createElement('div')
+    vi.spyOn(el, 'getBoundingClientRect').mockReturnValue({
       width: 50,
       height: 25,
       x: 0,

package/src/__tests__/useFocus.test.ts

@@ -1,19 +1,19 @@
-import { describe, expect, it } from "vitest"
-import { useFocus } from "../useFocus"
+import { describe, expect, it } from 'vitest'
+import { useFocus } from '../useFocus'
 
-describe("useFocus", () => {
-  it("initializes with focused=false", () => {
+describe('useFocus', () => {
+  it('initializes with focused=false', () => {
     const { focused } = useFocus()
     expect(focused()).toBe(false)
   })
 
-  it("sets focused to true on focus", () => {
+  it('sets focused to true on focus', () => {
     const { focused, props } = useFocus()
     props.onFocus()
     expect(focused()).toBe(true)
   })
 
-  it("sets focused to false on blur", () => {
+  it('sets focused to false on blur', () => {
     const { focused, props } = useFocus()
     props.onFocus()
     expect(focused()).toBe(true)
@@ -21,7 +21,7 @@ describe("useFocus", () => {
     expect(focused()).toBe(false)
   })
 
-  it("toggles focus state through multiple cycles", () => {
+  it('toggles focus state through multiple cycles', () => {
     const { focused, props } = useFocus()
     props.onFocus()
     expect(focused()).toBe(true)
@@ -31,22 +31,22 @@ describe("useFocus", () => {
     expect(focused()).toBe(true)
   })
 
-  it("calling blur when not focused is safe", () => {
+  it('calling blur when not focused is safe', () => {
     const { focused, props } = useFocus()
     props.onBlur()
     expect(focused()).toBe(false)
   })
 
-  it("calling focus multiple times stays true", () => {
+  it('calling focus multiple times stays true', () => {
     const { focused, props } = useFocus()
     props.onFocus()
     props.onFocus()
     expect(focused()).toBe(true)
   })
 
-  it("returns props object with onFocus and onBlur", () => {
+  it('returns props object with onFocus and onBlur', () => {
     const { props } = useFocus()
-    expect(typeof props.onFocus).toBe("function")
-    expect(typeof props.onBlur).toBe("function")
+    expect(typeof props.onFocus).toBe('function')
+    expect(typeof props.onBlur).toBe('function')
   })
 })