yummies 7.10.0 → 7.12.0

package/react.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"react.cjs","sources":["../src/react/attach-refs.ts","../src/react/hooks/use-constant.ts","../src/react/hooks/use-abort-controller.ts","../src/react/hooks/use-abort-signal.ts","../src/react/hooks/use-sync-ref.ts","../src/react/hooks/use-event-listener.ts","../src/react/hooks/use-click-outside.ts","../src/react/hooks/use-define-ref.ts","../src/react/hooks/use-element-ref.ts","../src/react/hooks/use-event.ts","../src/react/hooks/use-flag.ts","../src/react/hooks/use-force-update.ts","../src/react/hooks/use-initial-height.ts","../src/react/hooks/use-instance.ts","../src/react/hooks/use-intersection-observer.ts","../src/react/hooks/use-last-defined-value.ts","../src/react/hooks/use-last-value-ref.ts","../src/react/hooks/use-life-cycle.ts","../src/react/hooks/use-resize-observer.ts","../src/react/hooks/use-toggle.ts","../src/react/hooks/use-value.ts","../src/react/hooks/use-visibility-state.ts"],"sourcesContent":["import type { LegacyRef, RefObject } from 'react';\nimport type { Maybe } from 'yummies/types';\n\nexport const attachRefs = <T>(\n  value: T | null,\n  ...refs: Maybe<RefObject<T> | RefObject<T | null> | LegacyRef<T>>[]\n) =>\n  refs.forEach((ref) => {\n    if (typeof ref === 'function') {\n      ref(value);\n    } else if (ref && typeof ref !== 'string') {\n      // @ts-expect-error\n      ref.current = value;\n    }\n  });\n","import { useRef } from 'react';\n\n/**\n * React hook for creating a value exactly once.\n * useMemo doesn't give this guarantee unfortunately -\n * https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily\n * https://reactjs.org/docs/hooks-reference.html#usememo\n * @param defineValue Function which returns defined value.\n */\nexport const useConstant = <T>(defineValue: () => T): T => {\n  const ref = useRef<{ value: T }>();\n\n  if (!ref.current) {\n    ref.current = { value: defineValue() };\n  }\n\n  return ref.current.value;\n};\n","import { useEffect } from 'react';\n\nimport { useConstant } from './use-constant.js';\n\nexport const useAbortController = () => {\n  const controller = useConstant(() => new AbortController());\n\n  useEffect(() => {\n    return () => {\n      controller.abort();\n    };\n  }, []);\n\n  return controller;\n};\n","import { useAbortController } from './use-abort-controller.js';\n\nexport const useAbortSignal = () => {\n  return useAbortController().signal;\n};\n","import { useRef } from 'react';\n\nexport const useSyncRef = <T>(value: T) => {\n  const ref = useRef(value);\n  ref.current = value;\n  return ref;\n};\n","/* eslint-disable @typescript-eslint/ban-ts-comment */\nimport { useEffect } from 'react';\nimport { useSyncRef } from './use-sync-ref.js';\n\nexport const useEventListener = <EventName extends keyof HTMLElementEventMap>({\n  event,\n  handler,\n  options,\n  deps = [],\n  debounce,\n  node = document,\n}: {\n  event: EventName;\n  handler: (e: HTMLElementEventMap[EventName]) => void;\n  options?: boolean | AddEventListenerOptions;\n  deps?: unknown[];\n  debounce?: number;\n  node?: HTMLElement | Document | Window;\n}) => {\n  const handlerRef = useSyncRef(handler);\n\n  useEffect(() => {\n    let timerId: ReturnType<typeof setTimeout> | undefined;\n\n    const handleEvent = (e: HTMLElementEventMap[EventName]) => {\n      if (debounce == null) {\n        handlerRef.current(e);\n      } else {\n        clearTimeout(timerId);\n        timerId = setTimeout(() => {\n          handlerRef.current(e);\n          timerId = undefined;\n        }, debounce);\n      }\n    };\n\n    // @ts-expect-error\n    node.addEventListener(event, handleEvent, options);\n    return () => {\n      // @ts-expect-error\n      node.removeEventListener(event, handleEvent, options);\n      clearTimeout(timerId);\n    };\n  }, deps);\n};\n","import type { MutableRefObject } from 'react';\nimport { useEventListener } from './use-event-listener.js';\n\ntype ClickOutsideInput = {\n  contentRef: MutableRefObject<HTMLElement | null>;\n  onClick: VoidFunction;\n  options?: AddEventListenerOptions;\n};\n\nexport const useClickOutside = ({\n  contentRef,\n  onClick,\n  options,\n}: ClickOutsideInput) => {\n  useEventListener({\n    event: 'mousedown',\n    handler: (event) => {\n      if (\n        contentRef.current &&\n        !contentRef.current.contains(event.target as Node)\n      ) {\n        onClick();\n      }\n    },\n    options,\n  });\n};\n","import { type MutableRefObject, useRef } from 'react';\n\n/**\n * React hook for creating a value exactly once.\n * useMemo doesn't give this guarantee unfortunately -\n * https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily\n * https://reactjs.org/docs/hooks-reference.html#usememo\n * @param defineFn Function which returns defined value.\n */\nexport const useDefineRef = <T>(defineFn: () => T): MutableRefObject<T> => {\n  const ref = useRef<T>(void 0 as T);\n\n  if (!ref.current) {\n    ref.current = defineFn();\n  }\n\n  return ref;\n};\n","import { useLayoutEffect, useRef } from 'react';\n\nexport const useElementRef = <T extends HTMLElement>(selector: () => T) => {\n  const ref = useRef<T>();\n\n  useLayoutEffect(() => {\n    ref.current = selector();\n  }, []);\n\n  return ref;\n};\n","/**\n * A Hook to define an event handler with an always-stable function identity.\n *\n * borrowed from @gaeron\n * https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md\n */\nimport { useCallback, useLayoutEffect, useRef } from 'react';\nimport type { AnyFunction } from 'yummies/types';\n\nexport const useEvent = <H extends AnyFunction>(handler: H): H => {\n  const handlerRef = useRef<H>(handler);\n\n  // In a real implementation, this would run before layout effects\n  useLayoutEffect(() => {\n    handlerRef.current = handler;\n  });\n\n  return useCallback((...args: unknown[]) => {\n    // In a real implementation, this would throw if called during render\n    const fn = handlerRef.current as AnyFunction;\n    return fn(...args);\n  }, []) as unknown as H;\n};\n","import { useCallback, useRef, useState } from 'react';\n\nexport interface FlagHook {\n  enabled: boolean;\n  toggle: VoidFunction;\n  enable: VoidFunction;\n  disable: VoidFunction;\n}\n\nexport const useFlag = (defaultValue = false): FlagHook => {\n  const [enabled, setEnabled] = useState(defaultValue);\n\n  const toggle = useCallback(() => setEnabled((value) => !value), []);\n  const enable = useCallback(() => setEnabled(true), []);\n  const disable = useCallback(() => setEnabled(false), []);\n\n  const flagObjRef = useRef<FlagHook>({\n    enabled,\n    toggle,\n    enable,\n    disable,\n  });\n\n  flagObjRef.current.enabled = enabled;\n\n  return flagObjRef.current;\n};\n","import { useCallback, useState } from 'react';\n\nexport const useForceUpdate = () => {\n  const [, setState] = useState<unknown>(null);\n\n  return useCallback(() => {\n    setState({});\n  }, []);\n};\n","import { useEffect, useRef, useState } from 'react';\n\nexport const useInitialHeight = <T extends HTMLElement>() => {\n  const ref = useRef<T | null>(null);\n  const [initialHeight, setInitialHeight] = useState<number | undefined>(\n    undefined,\n  );\n\n  useEffect(() => {\n    if (ref.current && !initialHeight) {\n      setInitialHeight(ref.current.offsetHeight);\n    }\n  }, [initialHeight]);\n\n  return { ref, initialHeight };\n};\n","import { useLayoutEffect } from 'react';\nimport { useAbortSignal } from './use-abort-signal.js';\nimport { useConstant } from './use-constant.js';\n\nexport type InstanceCreateConfig<TPayload, TExtension = {}> = TExtension & {\n  abortSignal: AbortSignal;\n  payload: TPayload;\n};\n\nexport const createUseInstanceHook =\n  <TExtension = {}>(extension?: TExtension) =>\n  <TInstance, TPayload>(\n    factory: (\n      config: InstanceCreateConfig<NoInfer<TPayload>, TExtension>,\n    ) => TInstance,\n    config?: {\n      payload?: TPayload;\n      onUpdate?: (payload: TPayload) => void;\n    },\n  ) => {\n    const abortSignal = useAbortSignal();\n\n    const instance = useConstant(() =>\n      factory({\n        ...(extension as TExtension),\n        abortSignal,\n        payload: config?.payload as any,\n      }),\n    );\n\n    useLayoutEffect(() => {\n      config?.onUpdate?.(config.payload!);\n    }, [config?.payload]);\n\n    return instance;\n  };\n\n/**\n * The `useInstance` hook is used to create and manage an instance of an object\n * that requires access to the root store and an abort signal.\n *\n * You can create YOUR OWN CUSTOM `useInstance` hook using `createUseInstanceHook` if you need\n * to provide some specific data\n *\n * @param factory - A factory function that takes a configuration and returns an instance.\n * @param config - An optional configuration containing additional input parameters and an update function.\n * @returns An instance created by the factory function.\n */\nexport const useInstance = createUseInstanceHook();\n","import { useEffect, useState } from 'react';\n\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n) => {\n  const [intersectionObserver] = useState(\n    () => new IntersectionObserver(callback, options),\n  );\n\n  useEffect(() => {\n    return () => {\n      intersectionObserver.disconnect();\n    };\n  }, []);\n\n  return intersectionObserver;\n};\n","import { useRef } from 'react';\n\nexport const useLastDefinedValue = <T>(value: T) => {\n  const ref = useRef(value);\n  if (value != null) {\n    ref.current = value;\n  }\n  return ref.current;\n};\n","import { useRef } from 'react';\n\nexport const useLastValueRef = <T>(value: T | null | undefined) => {\n  const ref = useRef(value);\n\n  if (value != null) {\n    ref.current = value;\n  }\n\n  return ref;\n};\n","import { useEffect } from 'react';\nimport { useSyncRef } from './use-sync-ref.js';\n\nexport const useLifeCycle = (\n  fn: () => {\n    mount?: VoidFunction;\n    unmount?: VoidFunction;\n  },\n) => {\n  const fnRef = useSyncRef(fn);\n\n  useEffect(() => {\n    const fnOperation = fnRef.current();\n    fnOperation.mount?.();\n    return fnOperation.unmount?.();\n  }, []);\n};\n","import { useLayoutEffect } from 'react';\nimport { useDefineRef } from './use-define-ref.js';\n\nexport const useResizeObserver = (callback: ResizeObserverCallback) => {\n  const resizeObserverRef = useDefineRef(() => new ResizeObserver(callback));\n\n  useLayoutEffect(() => {\n    return () => {\n      resizeObserverRef.current.disconnect();\n    };\n  }, []);\n\n  return resizeObserverRef;\n};\n","import { useCallback, useState } from 'react';\n\nexport const useToggle = (initialState?: boolean) => {\n  const [toggled, setToggled] = useState(!!initialState);\n\n  const toggle = useCallback(() => setToggled((toggled) => !toggled), []);\n\n  return [toggled, toggle, setToggled] as const;\n};\n","import { useState } from 'react';\n\nexport const useValue = <T>(defaults: T | (() => T)) => {\n  const [value, setValue] = useState<T>(defaults);\n\n  return {\n    value,\n    set: setValue,\n  };\n};\n","import { useEffect, useState } from 'react';\n\nexport const useVisibilityState = () => {\n  const [state, setState] = useState<DocumentVisibilityState>();\n\n  useEffect(() => {\n    const handleVisibilityChange = () => {\n      setState(document.visibilityState);\n    };\n\n    document.addEventListener('visibilitychange', handleVisibilityChange);\n\n    return () => {\n      document.removeEventListener('visibilitychange', handleVisibilityChange);\n    };\n  }, []);\n\n  return state;\n};\n"],"names":["useRef","useEffect","useLayoutEffect","useCallback","useState","toggled"],"mappings":"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"}
+{"version":3,"file":"react.cjs","names":[],"sources":["../src/react/attach-refs.ts","../src/react/hooks/use-constant.ts","../src/react/hooks/use-abort-controller.ts","../src/react/hooks/use-abort-signal.ts","../src/react/hooks/use-sync-ref.ts","../src/react/hooks/use-event-listener.ts","../src/react/hooks/use-click-outside.ts","../src/react/hooks/use-define-ref.ts","../src/react/hooks/use-element-ref.ts","../src/react/hooks/use-event.ts","../src/react/hooks/use-flag.ts","../src/react/hooks/use-force-update.ts","../src/react/hooks/use-initial-height.ts","../src/react/hooks/use-instance.ts","../src/react/hooks/use-intersection-observer.ts","../src/react/hooks/use-last-defined-value.ts","../src/react/hooks/use-last-value-ref.ts","../src/react/hooks/use-life-cycle.ts","../src/react/hooks/use-resize-observer.ts","../src/react/hooks/use-toggle.ts","../src/react/hooks/use-value.ts","../src/react/hooks/use-visibility-state.ts"],"sourcesContent":["import type { LegacyRef, RefObject } from 'react';\nimport type { Maybe } from 'yummies/types';\n\n/**\n * Assigns the same value to multiple React refs, including callback refs.\n *\n * @template T Referenced value type.\n * @param value Value that should be written into every provided ref.\n * @param refs Target refs to update.\n *\n * @example\n * ```ts\n * attachRefs(node, localRef, forwardedRef);\n * ```\n *\n * @example\n * ```ts\n * attachRefs(null, inputRef, (value) => console.log(value));\n * ```\n */\nexport const attachRefs = <T>(\n  value: T | null,\n  ...refs: Maybe<RefObject<T> | RefObject<T | null> | LegacyRef<T>>[]\n) =>\n  refs.forEach((ref) => {\n    if (typeof ref === 'function') {\n      ref(value);\n    } else if (ref && typeof ref !== 'string') {\n      // @ts-expect-error\n      ref.current = value;\n    }\n  });\n","import { useRef } from 'react';\n\n/**\n * React hook for creating a value exactly once.\n *\n * Unlike `useMemo`, this guarantees that the initializer is executed only once\n * for the component lifetime.\n *\n * @template T Value type.\n * @param defineValue Function that lazily creates the value.\n * @returns Stable value created on the first render.\n *\n * @example\n * ```ts\n * const id = useConstant(() => crypto.randomUUID());\n * ```\n *\n * @example\n * ```ts\n * const formatter = useConstant(() => new Intl.NumberFormat('en-US'));\n * ```\n */\nexport const useConstant = <T>(defineValue: () => T): T => {\n  const ref = useRef<{ value: T }>();\n\n  if (!ref.current) {\n    ref.current = { value: defineValue() };\n  }\n\n  return ref.current.value;\n};\n","import { useEffect } from 'react';\n\nimport { useConstant } from './use-constant.js';\n\n/**\n * Creates a single `AbortController` instance for the component lifetime.\n *\n * The controller is aborted automatically during unmount.\n *\n * @returns Stable abort controller instance.\n *\n * @example\n * ```ts\n * const controller = useAbortController();\n * fetch('/api', { signal: controller.signal });\n * ```\n *\n * @example\n * ```ts\n * const controller = useAbortController();\n * controller.abort();\n * ```\n */\nexport const useAbortController = () => {\n  const controller = useConstant(() => new AbortController());\n\n  useEffect(() => {\n    return () => {\n      controller.abort();\n    };\n  }, []);\n\n  return controller;\n};\n","import { useAbortController } from './use-abort-controller.js';\n\n/**\n * Returns an `AbortSignal` tied to the component lifecycle.\n *\n * The signal is aborted automatically on unmount.\n *\n * @returns Lifecycle-bound abort signal.\n *\n * @example\n * ```ts\n * const signal = useAbortSignal();\n * fetch('/api/users', { signal });\n * ```\n *\n * @example\n * ```ts\n * const signal = useAbortSignal();\n * someAsyncTask({ signal });\n * ```\n */\nexport const useAbortSignal = () => {\n  return useAbortController().signal;\n};\n","import { useRef } from 'react';\n\n/**\n * Returns a ref whose `current` value is synchronized with the latest input\n * on every render.\n *\n * @template T Value type.\n * @param value Current value to expose through the ref.\n * @returns Ref containing the latest value.\n *\n * @example\n * ```ts\n * const latestHandler = useSyncRef(onSubmit);\n * latestHandler.current();\n * ```\n *\n * @example\n * ```ts\n * const latestValue = useSyncRef(props.value);\n * latestValue.current;\n * ```\n */\nexport const useSyncRef = <T>(value: T) => {\n  const ref = useRef(value);\n  ref.current = value;\n  return ref;\n};\n","/* eslint-disable @typescript-eslint/ban-ts-comment */\nimport { useEffect } from 'react';\nimport { useSyncRef } from './use-sync-ref.js';\n\n/**\n * Subscribes to a DOM event and keeps the latest handler without resubscribing\n * on every render.\n *\n * Supports optional debounce and custom effect dependencies.\n *\n * @template EventName DOM event name from `HTMLElementEventMap`.\n * @param config Event subscription configuration.\n *\n * @example\n * ```ts\n * useEventListener({\n *   event: 'click',\n *   handler: () => console.log('clicked'),\n * });\n * ```\n *\n * @example\n * ```ts\n * useEventListener({\n *   event: 'scroll',\n *   node: window,\n *   debounce: 100,\n *   handler: () => console.log('scroll'),\n * });\n * ```\n */\nexport const useEventListener = <EventName extends keyof HTMLElementEventMap>({\n  event,\n  handler,\n  options,\n  deps = [],\n  debounce,\n  node = document,\n}: {\n  event: EventName;\n  handler: (e: HTMLElementEventMap[EventName]) => void;\n  options?: boolean | AddEventListenerOptions;\n  deps?: unknown[];\n  debounce?: number;\n  node?: HTMLElement | Document | Window;\n}) => {\n  const handlerRef = useSyncRef(handler);\n\n  useEffect(() => {\n    let timerId: ReturnType<typeof setTimeout> | undefined;\n\n    const handleEvent = (e: HTMLElementEventMap[EventName]) => {\n      if (debounce == null) {\n        handlerRef.current(e);\n      } else {\n        clearTimeout(timerId);\n        timerId = setTimeout(() => {\n          handlerRef.current(e);\n          timerId = undefined;\n        }, debounce);\n      }\n    };\n\n    // @ts-expect-error\n    node.addEventListener(event, handleEvent, options);\n    return () => {\n      // @ts-expect-error\n      node.removeEventListener(event, handleEvent, options);\n      clearTimeout(timerId);\n    };\n  }, deps);\n};\n","import type { MutableRefObject } from 'react';\nimport { useEventListener } from './use-event-listener.js';\n\ntype ClickOutsideInput = {\n  contentRef: MutableRefObject<HTMLElement | null>;\n  onClick: VoidFunction;\n  options?: AddEventListenerOptions;\n};\n\n/**\n * Calls a handler when a pointer interaction happens outside the referenced element.\n *\n * @param input Target element ref, callback and event listener options.\n *\n * @example\n * ```ts\n * useClickOutside({\n *   contentRef: modalRef,\n *   onClick: () => closeModal(),\n * });\n * ```\n *\n * @example\n * ```ts\n * useClickOutside({\n *   contentRef: dropdownRef,\n *   onClick: hideDropdown,\n *   options: { capture: true },\n * });\n * ```\n */\nexport const useClickOutside = ({\n  contentRef,\n  onClick,\n  options,\n}: ClickOutsideInput) => {\n  useEventListener({\n    event: 'mousedown',\n    handler: (event) => {\n      if (\n        contentRef.current &&\n        !contentRef.current.contains(event.target as Node)\n      ) {\n        onClick();\n      }\n    },\n    options,\n  });\n};\n","import { type MutableRefObject, useRef } from 'react';\n\n/**\n * Creates a mutable ref whose value is initialized exactly once.\n *\n * @template T Ref value type.\n * @param defineFn Function that lazily creates the initial ref value.\n * @returns Mutable ref with a stable initialized value.\n *\n * @example\n * ```ts\n * const cacheRef = useDefineRef(() => new Map());\n * ```\n *\n * @example\n * ```ts\n * const observerRef = useDefineRef(() => new ResizeObserver(() => {}));\n * ```\n */\nexport const useDefineRef = <T>(defineFn: () => T): MutableRefObject<T> => {\n  const ref = useRef<T>(void 0 as T);\n\n  if (!ref.current) {\n    ref.current = defineFn();\n  }\n\n  return ref;\n};\n","import { useLayoutEffect, useRef } from 'react';\n\n/**\n * Resolves an element once after mount and stores it in a ref.\n *\n * @template T Element type.\n * @param selector Function returning the target element.\n * @returns Ref containing the selected element.\n *\n * @example\n * ```ts\n * const buttonRef = useElementRef(() => document.getElementById('save') as HTMLButtonElement);\n * ```\n *\n * @example\n * ```ts\n * const modalRef = useElementRef(() => document.querySelector('.modal') as HTMLDivElement);\n * ```\n */\nexport const useElementRef = <T extends HTMLElement>(selector: () => T) => {\n  const ref = useRef<T>();\n\n  useLayoutEffect(() => {\n    ref.current = selector();\n  }, []);\n\n  return ref;\n};\n","import { useCallback, useLayoutEffect, useRef } from 'react';\nimport type { AnyFunction } from 'yummies/types';\n\n/**\n * Creates an event callback with a stable function identity and up-to-date logic.\n *\n * Borrowed from the `useEvent` RFC idea by React contributors.\n *\n * @template H Handler function type.\n * @param handler Latest callback implementation.\n * @returns Stable callback that always delegates to the latest handler.\n *\n * @example\n * ```ts\n * const onClick = useEvent(() => {\n *   console.log('clicked');\n * });\n * ```\n *\n * @example\n * ```ts\n * const onSubmit = useEvent((value: string) => save(value));\n * ```\n */\nexport const useEvent = <H extends AnyFunction>(handler: H): H => {\n  const handlerRef = useRef<H>(handler);\n\n  // In a real implementation, this would run before layout effects\n  useLayoutEffect(() => {\n    handlerRef.current = handler;\n  });\n\n  return useCallback((...args: unknown[]) => {\n    // In a real implementation, this would throw if called during render\n    const fn = handlerRef.current as AnyFunction;\n    return fn(...args);\n  }, []) as unknown as H;\n};\n","import { useCallback, useRef, useState } from 'react';\n\nexport interface FlagHook {\n  enabled: boolean;\n  toggle: VoidFunction;\n  enable: VoidFunction;\n  disable: VoidFunction;\n}\n\n/**\n * Manages a reusable boolean flag object with stable helper methods.\n *\n * @param defaultValue Initial enabled state.\n * @returns Stable object exposing current state and mutators.\n *\n * @example\n * ```ts\n * const modal = useFlag();\n * modal.enable();\n * ```\n *\n * @example\n * ```ts\n * const loading = useFlag(true);\n * loading.disable();\n * ```\n */\nexport const useFlag = (defaultValue = false): FlagHook => {\n  const [enabled, setEnabled] = useState(defaultValue);\n\n  const toggle = useCallback(() => setEnabled((value) => !value), []);\n  const enable = useCallback(() => setEnabled(true), []);\n  const disable = useCallback(() => setEnabled(false), []);\n\n  const flagObjRef = useRef<FlagHook>({\n    enabled,\n    toggle,\n    enable,\n    disable,\n  });\n\n  flagObjRef.current.enabled = enabled;\n\n  return flagObjRef.current;\n};\n","import { useCallback, useState } from 'react';\n\n/**\n * Forces a component re-render by updating an internal dummy state.\n *\n * @returns Stable callback that triggers a re-render.\n *\n * @example\n * ```ts\n * const forceUpdate = useForceUpdate();\n * forceUpdate();\n * ```\n *\n * @example\n * ```ts\n * const rerender = useForceUpdate();\n * setTimeout(rerender, 1000);\n * ```\n */\nexport const useForceUpdate = () => {\n  const [, setState] = useState<unknown>(null);\n\n  return useCallback(() => {\n    setState({});\n  }, []);\n};\n","import { useEffect, useRef, useState } from 'react';\n\n/**\n * Captures an element's height the first time its ref becomes available.\n *\n * @template T Element type attached to the returned ref.\n * @returns Ref and the initial measured height.\n *\n * @example\n * ```ts\n * const { ref, initialHeight } = useInitialHeight<HTMLDivElement>();\n * ```\n *\n * @example\n * ```ts\n * const state = useInitialHeight<HTMLTextAreaElement>();\n * state.initialHeight;\n * ```\n */\nexport const useInitialHeight = <T extends HTMLElement>() => {\n  const ref = useRef<T | null>(null);\n  const [initialHeight, setInitialHeight] = useState<number | undefined>(\n    undefined,\n  );\n\n  useEffect(() => {\n    if (ref.current && !initialHeight) {\n      setInitialHeight(ref.current.offsetHeight);\n    }\n  }, [initialHeight]);\n\n  return { ref, initialHeight };\n};\n","import { useLayoutEffect } from 'react';\nimport { useAbortSignal } from './use-abort-signal.js';\nimport { useConstant } from './use-constant.js';\n\nexport type InstanceCreateConfig<TPayload, TExtension = {}> = TExtension & {\n  abortSignal: AbortSignal;\n  payload: TPayload;\n};\n\n/**\n * Builds a custom hook that creates an instance once and wires lifecycle helpers\n * such as an `AbortSignal` and optional extension data into the factory.\n *\n * @template TExtension Extra configuration injected into every factory call.\n * @param extension Optional static extension object merged into the factory config.\n * @returns Hook factory that creates stable instances from a supplied factory.\n *\n * @example\n * ```ts\n * const useStoreInstance = createUseInstanceHook({ api });\n * ```\n *\n * @example\n * ```ts\n * const useService = createUseInstanceHook({ logger });\n * const service = useService(({ logger, payload }) => new Service(logger, payload));\n * ```\n */\nexport const createUseInstanceHook =\n  <TExtension = {}>(extension?: TExtension) =>\n  <TInstance, TPayload>(\n    factory: (\n      config: InstanceCreateConfig<NoInfer<TPayload>, TExtension>,\n    ) => TInstance,\n    config?: {\n      payload?: TPayload;\n      onUpdate?: (payload: TPayload) => void;\n    },\n  ) => {\n    const abortSignal = useAbortSignal();\n\n    const instance = useConstant(() =>\n      factory({\n        ...(extension as TExtension),\n        abortSignal,\n        payload: config?.payload as any,\n      }),\n    );\n\n    useLayoutEffect(() => {\n      config?.onUpdate?.(config.payload!);\n    }, [config?.payload]);\n\n    return instance;\n  };\n\n/**\n * The `useInstance` hook is used to create and manage an instance of an object\n * that requires access to the root store and an abort signal.\n *\n * You can create YOUR OWN CUSTOM `useInstance` hook using `createUseInstanceHook` if you need\n * to provide some specific data\n *\n * @param factory - A factory function that takes a configuration and returns an instance.\n * @param config - An optional configuration containing additional input parameters and an update function.\n * @returns An instance created by the factory function.\n *\n * @example\n * ```ts\n * const service = useInstance(({ abortSignal }) => new UsersService({ abortSignal }));\n * ```\n *\n * @example\n * ```ts\n * const store = useInstance(\n *   ({ payload }) => new UserStore(payload),\n *   { payload: userId, onUpdate: (nextId) => console.log(nextId) },\n * );\n * ```\n */\nexport const useInstance = createUseInstanceHook();\n","import { useEffect, useState } from 'react';\n\n/**\n * Creates a single `IntersectionObserver` instance and disposes it on unmount.\n *\n * @param callback Observer callback invoked for intersection changes.\n * @param options Optional observer configuration.\n * @returns Stable `IntersectionObserver` instance.\n *\n * @example\n * ```ts\n * const observer = useIntersectionObserver((entries) => {\n *   console.log(entries[0]?.isIntersecting);\n * });\n * ```\n *\n * @example\n * ```ts\n * const observer = useIntersectionObserver(handleIntersect, { threshold: 0.5 });\n * observer.observe(element);\n * ```\n */\nexport const useIntersectionObserver = (\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverInit,\n) => {\n  const [intersectionObserver] = useState(\n    () => new IntersectionObserver(callback, options),\n  );\n\n  useEffect(() => {\n    return () => {\n      intersectionObserver.disconnect();\n    };\n  }, []);\n\n  return intersectionObserver;\n};\n","import { useRef } from 'react';\n\n/**\n * Remembers and returns the last non-nullish value passed to the hook.\n *\n * @template T Value type.\n * @param value Current value that may be `null` or `undefined`.\n * @returns Current value when defined, otherwise the previous defined value.\n *\n * @example\n * ```ts\n * const title = useLastDefinedValue(props.title);\n * ```\n *\n * @example\n * ```ts\n * const user = useLastDefinedValue<User | null>(selectedUser);\n * ```\n */\nexport const useLastDefinedValue = <T>(value: T) => {\n  const ref = useRef(value);\n  if (value != null) {\n    ref.current = value;\n  }\n  return ref.current;\n};\n","import { useRef } from 'react';\n\n/**\n * Returns a ref that always points to the last non-nullish value.\n *\n * @template T Value type.\n * @param value Current value that may temporarily become `null` or `undefined`.\n * @returns Ref containing the last defined value.\n *\n * @example\n * ```ts\n * const latestUserRef = useLastValueRef(user);\n * latestUserRef.current;\n * ```\n *\n * @example\n * ```ts\n * const latestNodeRef = useLastValueRef<HTMLDivElement | null>(node);\n * ```\n */\nexport const useLastValueRef = <T>(value: T | null | undefined) => {\n  const ref = useRef(value);\n\n  if (value != null) {\n    ref.current = value;\n  }\n\n  return ref;\n};\n","import { useEffect } from 'react';\nimport { useSyncRef } from './use-sync-ref.js';\n\n/**\n * Runs mount and unmount callbacks returned by a factory function.\n *\n * The latest factory is stored in a ref, while the effect itself is only\n * subscribed once.\n *\n * @param fn Factory returning optional `mount` and `unmount` handlers.\n *\n * @example\n * ```ts\n * useLifeCycle(() => ({\n *   mount: () => console.log('mounted'),\n *   unmount: () => console.log('unmounted'),\n * }));\n * ```\n *\n * @example\n * ```ts\n * useLifeCycle(() => ({\n *   mount: subscribe,\n *   unmount: unsubscribe,\n * }));\n * ```\n */\nexport const useLifeCycle = (\n  fn: () => {\n    mount?: VoidFunction;\n    unmount?: VoidFunction;\n  },\n) => {\n  const fnRef = useSyncRef(fn);\n\n  useEffect(() => {\n    const fnOperation = fnRef.current();\n    fnOperation.mount?.();\n    return fnOperation.unmount?.();\n  }, []);\n};\n","import { useLayoutEffect } from 'react';\nimport { useDefineRef } from './use-define-ref.js';\n\n/**\n * Creates a stable `ResizeObserver` instance and disconnects it on unmount.\n *\n * @param callback Resize observer callback.\n * @returns Ref containing the observer instance.\n *\n * @example\n * ```ts\n * const observerRef = useResizeObserver((entries) => {\n *   console.log(entries[0]?.contentRect.width);\n * });\n * ```\n *\n * @example\n * ```ts\n * const resizeObserver = useResizeObserver(handleResize);\n * resizeObserver.current.observe(element);\n * ```\n */\nexport const useResizeObserver = (callback: ResizeObserverCallback) => {\n  const resizeObserverRef = useDefineRef(() => new ResizeObserver(callback));\n\n  useLayoutEffect(() => {\n    return () => {\n      resizeObserverRef.current.disconnect();\n    };\n  }, []);\n\n  return resizeObserverRef;\n};\n","import { useCallback, useState } from 'react';\n\n/**\n * Manages a boolean state and returns helpers to toggle or set it directly.\n *\n * @param initialState Initial boolean value.\n * @returns Tuple with current state, toggle callback and raw setter.\n *\n * @example\n * ```ts\n * const [open, toggleOpen] = useToggle();\n * toggleOpen();\n * ```\n *\n * @example\n * ```ts\n * const [enabled, , setEnabled] = useToggle(true);\n * setEnabled(false);\n * ```\n */\nexport const useToggle = (initialState?: boolean) => {\n  const [toggled, setToggled] = useState(!!initialState);\n\n  const toggle = useCallback(() => setToggled((toggled) => !toggled), []);\n\n  return [toggled, toggle, setToggled] as const;\n};\n","import { useState } from 'react';\n\n/**\n * Wraps `useState` and returns the state value as an object with a `set` method.\n *\n * @template T State value type.\n * @param defaults Initial state value or lazy initializer.\n * @returns Object containing the current value and setter.\n *\n * @example\n * ```ts\n * const counter = useValue(0);\n * counter.set(1);\n * ```\n *\n * @example\n * ```ts\n * const user = useValue(() => ({ name: 'Ann' }));\n * user.value.name;\n * ```\n */\nexport const useValue = <T>(defaults: T | (() => T)) => {\n  const [value, setValue] = useState<T>(defaults);\n\n  return {\n    value,\n    set: setValue,\n  };\n};\n","import { useEffect, useState } from 'react';\n\n/**\n * Tracks `document.visibilityState` and updates when the page visibility changes.\n *\n * @returns Current document visibility state.\n *\n * @example\n * ```ts\n * const visibility = useVisibilityState();\n * ```\n *\n * @example\n * ```ts\n * const isHidden = useVisibilityState() === 'hidden';\n * ```\n */\nexport const useVisibilityState = () => {\n  const [state, setState] = useState<DocumentVisibilityState>();\n\n  useEffect(() => {\n    const handleVisibilityChange = () => {\n      setState(document.visibilityState);\n    };\n\n    document.addEventListener('visibilitychange', handleVisibilityChange);\n\n    return () => {\n      document.removeEventListener('visibilitychange', handleVisibilityChange);\n    };\n  }, []);\n\n  return state;\n};\n"],"mappings":"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"}

package/react.d.ts

@@ -2,10 +2,65 @@ import * as react from 'react';
 import { RefObject, LegacyRef, MutableRefObject } from 'react';
 import { Maybe, AnyFunction } from 'yummies/types';
 
+/**
+ * Assigns the same value to multiple React refs, including callback refs.
+ *
+ * @template T Referenced value type.
+ * @param value Value that should be written into every provided ref.
+ * @param refs Target refs to update.
+ *
+ * @example
+ * ```ts
+ * attachRefs(node, localRef, forwardedRef);
+ * ```
+ *
+ * @example
+ * ```ts
+ * attachRefs(null, inputRef, (value) => console.log(value));
+ * ```
+ */
 declare const attachRefs: <T>(value: T | null, ...refs: Maybe<RefObject<T> | RefObject<T | null> | LegacyRef<T>>[]) => void;
 
+/**
+ * Creates a single `AbortController` instance for the component lifetime.
+ *
+ * The controller is aborted automatically during unmount.
+ *
+ * @returns Stable abort controller instance.
+ *
+ * @example
+ * ```ts
+ * const controller = useAbortController();
+ * fetch('/api', { signal: controller.signal });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const controller = useAbortController();
+ * controller.abort();
+ * ```
+ */
 declare const useAbortController: () => AbortController;
 
+/**
+ * Returns an `AbortSignal` tied to the component lifecycle.
+ *
+ * The signal is aborted automatically on unmount.
+ *
+ * @returns Lifecycle-bound abort signal.
+ *
+ * @example
+ * ```ts
+ * const signal = useAbortSignal();
+ * fetch('/api/users', { signal });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const signal = useAbortSignal();
+ * someAsyncTask({ signal });
+ * ```
+ */
 declare const useAbortSignal: () => AbortSignal;
 
 type ClickOutsideInput = {
@@ -13,30 +68,140 @@ type ClickOutsideInput = {
     onClick: VoidFunction;
     options?: AddEventListenerOptions;
 };
+/**
+ * Calls a handler when a pointer interaction happens outside the referenced element.
+ *
+ * @param input Target element ref, callback and event listener options.
+ *
+ * @example
+ * ```ts
+ * useClickOutside({
+ *   contentRef: modalRef,
+ *   onClick: () => closeModal(),
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * useClickOutside({
+ *   contentRef: dropdownRef,
+ *   onClick: hideDropdown,
+ *   options: { capture: true },
+ * });
+ * ```
+ */
 declare const useClickOutside: ({ contentRef, onClick, options, }: ClickOutsideInput) => void;
 
 /**
  * React hook for creating a value exactly once.
- * useMemo doesn't give this guarantee unfortunately -
- * https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily
- * https://reactjs.org/docs/hooks-reference.html#usememo
- * @param defineValue Function which returns defined value.
+ *
+ * Unlike `useMemo`, this guarantees that the initializer is executed only once
+ * for the component lifetime.
+ *
+ * @template T Value type.
+ * @param defineValue Function that lazily creates the value.
+ * @returns Stable value created on the first render.
+ *
+ * @example
+ * ```ts
+ * const id = useConstant(() => crypto.randomUUID());
+ * ```
+ *
+ * @example
+ * ```ts
+ * const formatter = useConstant(() => new Intl.NumberFormat('en-US'));
+ * ```
  */
 declare const useConstant: <T>(defineValue: () => T) => T;
 
 /**
- * React hook for creating a value exactly once.
- * useMemo doesn't give this guarantee unfortunately -
- * https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily
- * https://reactjs.org/docs/hooks-reference.html#usememo
- * @param defineFn Function which returns defined value.
+ * Creates a mutable ref whose value is initialized exactly once.
+ *
+ * @template T Ref value type.
+ * @param defineFn Function that lazily creates the initial ref value.
+ * @returns Mutable ref with a stable initialized value.
+ *
+ * @example
+ * ```ts
+ * const cacheRef = useDefineRef(() => new Map());
+ * ```
+ *
+ * @example
+ * ```ts
+ * const observerRef = useDefineRef(() => new ResizeObserver(() => {}));
+ * ```
  */
 declare const useDefineRef: <T>(defineFn: () => T) => MutableRefObject<T>;
 
+/**
+ * Resolves an element once after mount and stores it in a ref.
+ *
+ * @template T Element type.
+ * @param selector Function returning the target element.
+ * @returns Ref containing the selected element.
+ *
+ * @example
+ * ```ts
+ * const buttonRef = useElementRef(() => document.getElementById('save') as HTMLButtonElement);
+ * ```
+ *
+ * @example
+ * ```ts
+ * const modalRef = useElementRef(() => document.querySelector('.modal') as HTMLDivElement);
+ * ```
+ */
 declare const useElementRef: <T extends HTMLElement>(selector: () => T) => react.MutableRefObject<T | undefined>;
 
+/**
+ * Creates an event callback with a stable function identity and up-to-date logic.
+ *
+ * Borrowed from the `useEvent` RFC idea by React contributors.
+ *
+ * @template H Handler function type.
+ * @param handler Latest callback implementation.
+ * @returns Stable callback that always delegates to the latest handler.
+ *
+ * @example
+ * ```ts
+ * const onClick = useEvent(() => {
+ *   console.log('clicked');
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const onSubmit = useEvent((value: string) => save(value));
+ * ```
+ */
 declare const useEvent: <H extends AnyFunction>(handler: H) => H;
 
+/**
+ * Subscribes to a DOM event and keeps the latest handler without resubscribing
+ * on every render.
+ *
+ * Supports optional debounce and custom effect dependencies.
+ *
+ * @template EventName DOM event name from `HTMLElementEventMap`.
+ * @param config Event subscription configuration.
+ *
+ * @example
+ * ```ts
+ * useEventListener({
+ *   event: 'click',
+ *   handler: () => console.log('clicked'),
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * useEventListener({
+ *   event: 'scroll',
+ *   node: window,
+ *   debounce: 100,
+ *   handler: () => console.log('scroll'),
+ * });
+ * ```
+ */
 declare const useEventListener: <EventName extends keyof HTMLElementEventMap>({ event, handler, options, deps, debounce, node, }: {
     event: EventName;
     handler: (e: HTMLElementEventMap[EventName]) => void;
@@ -52,10 +217,62 @@ interface FlagHook {
     enable: VoidFunction;
     disable: VoidFunction;
 }
+/**
+ * Manages a reusable boolean flag object with stable helper methods.
+ *
+ * @param defaultValue Initial enabled state.
+ * @returns Stable object exposing current state and mutators.
+ *
+ * @example
+ * ```ts
+ * const modal = useFlag();
+ * modal.enable();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const loading = useFlag(true);
+ * loading.disable();
+ * ```
+ */
 declare const useFlag: (defaultValue?: boolean) => FlagHook;
 
+/**
+ * Forces a component re-render by updating an internal dummy state.
+ *
+ * @returns Stable callback that triggers a re-render.
+ *
+ * @example
+ * ```ts
+ * const forceUpdate = useForceUpdate();
+ * forceUpdate();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const rerender = useForceUpdate();
+ * setTimeout(rerender, 1000);
+ * ```
+ */
 declare const useForceUpdate: () => () => void;
 
+/**
+ * Captures an element's height the first time its ref becomes available.
+ *
+ * @template T Element type attached to the returned ref.
+ * @returns Ref and the initial measured height.
+ *
+ * @example
+ * ```ts
+ * const { ref, initialHeight } = useInitialHeight<HTMLDivElement>();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const state = useInitialHeight<HTMLTextAreaElement>();
+ * state.initialHeight;
+ * ```
+ */
 declare const useInitialHeight: <T extends HTMLElement>() => {
     ref: react.MutableRefObject<T | null>;
     initialHeight: number | undefined;
@@ -65,6 +282,25 @@ type InstanceCreateConfig<TPayload, TExtension = {}> = TExtension & {
     abortSignal: AbortSignal;
     payload: TPayload;
 };
+/**
+ * Builds a custom hook that creates an instance once and wires lifecycle helpers
+ * such as an `AbortSignal` and optional extension data into the factory.
+ *
+ * @template TExtension Extra configuration injected into every factory call.
+ * @param extension Optional static extension object merged into the factory config.
+ * @returns Hook factory that creates stable instances from a supplied factory.
+ *
+ * @example
+ * ```ts
+ * const useStoreInstance = createUseInstanceHook({ api });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const useService = createUseInstanceHook({ logger });
+ * const service = useService(({ logger, payload }) => new Service(logger, payload));
+ * ```
+ */
 declare const createUseInstanceHook: <TExtension = {}>(extension?: TExtension) => <TInstance, TPayload>(factory: (config: InstanceCreateConfig<NoInfer<TPayload>, TExtension>) => TInstance, config?: {
     payload?: TPayload;
     onUpdate?: (payload: TPayload) => void;
@@ -79,6 +315,19 @@ declare const createUseInstanceHook: <TExtension = {}>(extension?: TExtension) =
  * @param factory - A factory function that takes a configuration and returns an instance.
  * @param config - An optional configuration containing additional input parameters and an update function.
  * @returns An instance created by the factory function.
+ *
+ * @example
+ * ```ts
+ * const service = useInstance(({ abortSignal }) => new UsersService({ abortSignal }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const store = useInstance(
+ *   ({ payload }) => new UserStore(payload),
+ *   { payload: userId, onUpdate: (nextId) => console.log(nextId) },
+ * );
+ * ```
  */
 declare const useInstance: <TInstance, TPayload>(factory: (config: {
     abortSignal: AbortSignal;
@@ -88,28 +337,198 @@ declare const useInstance: <TInstance, TPayload>(factory: (config: {
     onUpdate?: ((payload: TPayload) => void) | undefined;
 } | undefined) => TInstance;
 
+/**
+ * Creates a single `IntersectionObserver` instance and disposes it on unmount.
+ *
+ * @param callback Observer callback invoked for intersection changes.
+ * @param options Optional observer configuration.
+ * @returns Stable `IntersectionObserver` instance.
+ *
+ * @example
+ * ```ts
+ * const observer = useIntersectionObserver((entries) => {
+ *   console.log(entries[0]?.isIntersecting);
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const observer = useIntersectionObserver(handleIntersect, { threshold: 0.5 });
+ * observer.observe(element);
+ * ```
+ */
 declare const useIntersectionObserver: (callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => IntersectionObserver;
 
+/**
+ * Remembers and returns the last non-nullish value passed to the hook.
+ *
+ * @template T Value type.
+ * @param value Current value that may be `null` or `undefined`.
+ * @returns Current value when defined, otherwise the previous defined value.
+ *
+ * @example
+ * ```ts
+ * const title = useLastDefinedValue(props.title);
+ * ```
+ *
+ * @example
+ * ```ts
+ * const user = useLastDefinedValue<User | null>(selectedUser);
+ * ```
+ */
 declare const useLastDefinedValue: <T>(value: T) => T;
 
+/**
+ * Returns a ref that always points to the last non-nullish value.
+ *
+ * @template T Value type.
+ * @param value Current value that may temporarily become `null` or `undefined`.
+ * @returns Ref containing the last defined value.
+ *
+ * @example
+ * ```ts
+ * const latestUserRef = useLastValueRef(user);
+ * latestUserRef.current;
+ * ```
+ *
+ * @example
+ * ```ts
+ * const latestNodeRef = useLastValueRef<HTMLDivElement | null>(node);
+ * ```
+ */
 declare const useLastValueRef: <T>(value: T | null | undefined) => react.MutableRefObject<T | null | undefined>;
 
+/**
+ * Runs mount and unmount callbacks returned by a factory function.
+ *
+ * The latest factory is stored in a ref, while the effect itself is only
+ * subscribed once.
+ *
+ * @param fn Factory returning optional `mount` and `unmount` handlers.
+ *
+ * @example
+ * ```ts
+ * useLifeCycle(() => ({
+ *   mount: () => console.log('mounted'),
+ *   unmount: () => console.log('unmounted'),
+ * }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * useLifeCycle(() => ({
+ *   mount: subscribe,
+ *   unmount: unsubscribe,
+ * }));
+ * ```
+ */
 declare const useLifeCycle: (fn: () => {
     mount?: VoidFunction;
     unmount?: VoidFunction;
 }) => void;
 
+/**
+ * Creates a stable `ResizeObserver` instance and disconnects it on unmount.
+ *
+ * @param callback Resize observer callback.
+ * @returns Ref containing the observer instance.
+ *
+ * @example
+ * ```ts
+ * const observerRef = useResizeObserver((entries) => {
+ *   console.log(entries[0]?.contentRect.width);
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const resizeObserver = useResizeObserver(handleResize);
+ * resizeObserver.current.observe(element);
+ * ```
+ */
 declare const useResizeObserver: (callback: ResizeObserverCallback) => react.MutableRefObject<ResizeObserver>;
 
+/**
+ * Returns a ref whose `current` value is synchronized with the latest input
+ * on every render.
+ *
+ * @template T Value type.
+ * @param value Current value to expose through the ref.
+ * @returns Ref containing the latest value.
+ *
+ * @example
+ * ```ts
+ * const latestHandler = useSyncRef(onSubmit);
+ * latestHandler.current();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const latestValue = useSyncRef(props.value);
+ * latestValue.current;
+ * ```
+ */
 declare const useSyncRef: <T>(value: T) => react.MutableRefObject<T>;
 
+/**
+ * Manages a boolean state and returns helpers to toggle or set it directly.
+ *
+ * @param initialState Initial boolean value.
+ * @returns Tuple with current state, toggle callback and raw setter.
+ *
+ * @example
+ * ```ts
+ * const [open, toggleOpen] = useToggle();
+ * toggleOpen();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const [enabled, , setEnabled] = useToggle(true);
+ * setEnabled(false);
+ * ```
+ */
 declare const useToggle: (initialState?: boolean) => readonly [boolean, () => void, react.Dispatch<react.SetStateAction<boolean>>];
 
+/**
+ * Wraps `useState` and returns the state value as an object with a `set` method.
+ *
+ * @template T State value type.
+ * @param defaults Initial state value or lazy initializer.
+ * @returns Object containing the current value and setter.
+ *
+ * @example
+ * ```ts
+ * const counter = useValue(0);
+ * counter.set(1);
+ * ```
+ *
+ * @example
+ * ```ts
+ * const user = useValue(() => ({ name: 'Ann' }));
+ * user.value.name;
+ * ```
+ */
 declare const useValue: <T>(defaults: T | (() => T)) => {
     value: T;
     set: react.Dispatch<react.SetStateAction<T>>;
 };
 
+/**
+ * Tracks `document.visibilityState` and updates when the page visibility changes.
+ *
+ * @returns Current document visibility state.
+ *
+ * @example
+ * ```ts
+ * const visibility = useVisibilityState();
+ * ```
+ *
+ * @example
+ * ```ts
+ * const isHidden = useVisibilityState() === 'hidden';
+ * ```
+ */
 declare const useVisibilityState: () => DocumentVisibilityState | undefined;
 
 export { attachRefs, createUseInstanceHook, useAbortController, useAbortSignal, useClickOutside, useConstant, useDefineRef, useElementRef, useEvent, useEventListener, useFlag, useForceUpdate, useInitialHeight, useInstance, useIntersectionObserver, useLastDefinedValue, useLastValueRef, useLifeCycle, useResizeObserver, useSyncRef, useToggle, useValue, useVisibilityState };