@pyreon/hooks 0.11.5 → 0.11.6

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')
   })
 })

package/src/__tests__/useFocusTrap.test.ts

@@ -1,9 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 let mountCallbacks: Array<() => void> = []
 let unmountCallbacks: Array<() => void> = []
 
-vi.mock("@pyreon/core", () => ({
+vi.mock('@pyreon/core', () => ({
   onMount: (fn: () => unknown) => {
     mountCallbacks.push(fn as () => void)
   },
@@ -12,9 +12,9 @@ vi.mock("@pyreon/core", () => ({
   },
 }))
 
-import { useFocusTrap } from "../useFocusTrap"
+import { useFocusTrap } from '../useFocusTrap'
 
-describe("useFocusTrap", () => {
+describe('useFocusTrap', () => {
   let container: HTMLDivElement
   let btn1: HTMLButtonElement
   let btn2: HTMLButtonElement
@@ -23,10 +23,10 @@ describe("useFocusTrap", () => {
   beforeEach(() => {
     mountCallbacks = []
     unmountCallbacks = []
-    container = document.createElement("div")
-    btn1 = document.createElement("button")
-    btn2 = document.createElement("button")
-    btn3 = document.createElement("button")
+    container = document.createElement('div')
+    btn1 = document.createElement('button')
+    btn2 = document.createElement('button')
+    btn3 = document.createElement('button')
     container.append(btn1, btn2, btn3)
     document.body.appendChild(container)
   })
@@ -35,84 +35,84 @@ describe("useFocusTrap", () => {
     document.body.removeChild(container)
   })
 
-  it("wraps focus from last to first on Tab", () => {
+  it('wraps focus from last to first on Tab', () => {
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
     btn3.focus()
-    const event = new KeyboardEvent("keydown", { key: "Tab", bubbles: true })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true })
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).toHaveBeenCalled()
     expect(document.activeElement).toBe(btn1)
   })
 
-  it("wraps focus from first to last on Shift+Tab", () => {
+  it('wraps focus from first to last on Shift+Tab', () => {
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
     btn1.focus()
-    const event = new KeyboardEvent("keydown", {
-      key: "Tab",
+    const event = new KeyboardEvent('keydown', {
+      key: 'Tab',
       shiftKey: true,
       bubbles: true,
     })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).toHaveBeenCalled()
     expect(document.activeElement).toBe(btn3)
   })
 
-  it("does not wrap when Tab on middle element", () => {
+  it('does not wrap when Tab on middle element', () => {
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
     btn2.focus()
-    const event = new KeyboardEvent("keydown", { key: "Tab", bubbles: true })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true })
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).not.toHaveBeenCalled()
   })
 
-  it("ignores non-Tab keys", () => {
+  it('ignores non-Tab keys', () => {
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
     btn3.focus()
-    const event = new KeyboardEvent("keydown", { key: "Enter", bubbles: true })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const event = new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).not.toHaveBeenCalled()
   })
 
-  it("does nothing when element is null", () => {
+  it('does nothing when element is null', () => {
     useFocusTrap(() => null)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
-    const event = new KeyboardEvent("keydown", { key: "Tab", bubbles: true })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true })
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).not.toHaveBeenCalled()
   })
 
-  it("does nothing when container has no focusable children", () => {
-    const emptyContainer = document.createElement("div")
-    emptyContainer.appendChild(document.createElement("div"))
+  it('does nothing when container has no focusable children', () => {
+    const emptyContainer = document.createElement('div')
+    emptyContainer.appendChild(document.createElement('div'))
     document.body.appendChild(emptyContainer)
 
     useFocusTrap(() => emptyContainer)
@@ -120,16 +120,16 @@ describe("useFocusTrap", () => {
       cb()
     })
 
-    const event = new KeyboardEvent("keydown", { key: "Tab", bubbles: true })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true })
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).not.toHaveBeenCalled()
     document.body.removeChild(emptyContainer)
   })
 
-  it("cleans up event listener on unmount", () => {
-    const removeSpy = vi.spyOn(document, "removeEventListener")
+  it('cleans up event listener on unmount', () => {
+    const removeSpy = vi.spyOn(document, 'removeEventListener')
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
@@ -138,23 +138,23 @@ describe("useFocusTrap", () => {
       cb()
     })
 
-    expect(removeSpy).toHaveBeenCalledWith("keydown", expect.any(Function))
+    expect(removeSpy).toHaveBeenCalledWith('keydown', expect.any(Function))
     removeSpy.mockRestore()
   })
 
-  it("does not prevent default when Shift+Tab on non-first element", () => {
+  it('does not prevent default when Shift+Tab on non-first element', () => {
     useFocusTrap(() => container)
     mountCallbacks.forEach((cb) => {
       cb()
     })
 
     btn2.focus()
-    const event = new KeyboardEvent("keydown", {
-      key: "Tab",
+    const event = new KeyboardEvent('keydown', {
+      key: 'Tab',
       shiftKey: true,
       bubbles: true,
     })
-    const prevented = vi.spyOn(event, "preventDefault")
+    const prevented = vi.spyOn(event, 'preventDefault')
     document.dispatchEvent(event)
 
     expect(prevented).not.toHaveBeenCalled()