{"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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"}