@chassis-ui/react 0.1.3 → 0.3.0

package/dist/chunks/useDialogElement-CgOnJAzu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDialogElement-CgOnJAzu.js","names":[],"sources":["../../src/hooks/useDialogElement.ts"],"sourcesContent":["import {\n  ForwardedRef,\n  MouseEvent as ReactMouseEvent,\n  MouseEventHandler,\n  SyntheticEvent,\n  useEffect,\n  useRef,\n  useState\n} from 'react'\nimport { usePreventScroll } from 'react-aria'\n\nimport { useControllableState } from './useControllableState'\nimport { useForkedRef } from './useForkedRef'\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect'\nimport { executeAfterTransition } from '../utils/dialogTransition'\n\nexport interface UseDialogElementOptions {\n  /**\n   * Same-named prop from the caller (`Modal`/`Drawer`) — only ever consulted here to\n   * distinguish `'static'` from everything else for the backdrop-click/Escape bounce.\n   */\n  backdrop?: boolean | 'static'\n  /**\n   * Initial open state of an uncontrolled dialog.\n   */\n  defaultVisible?: boolean\n  /**\n   * Disables the open/close transition entirely.\n   */\n  instant?: boolean\n  /**\n   * Whether this open should use `showModal()` (top-layer, native backdrop, scroll-locked) or\n   * `show()` — `Modal` passes its own `modal` prop straight through; `Drawer` derives it from\n   * `backdrop`/`scroll` instead, since its vanilla chassis-css counterpart does the same.\n   */\n  isModal: boolean\n  /**\n   * Closes on the escape key / native `cancel` event.\n   */\n  keyboard?: boolean\n  /**\n   * Fires synchronously right before a closed dialog actually opens (after the \"already open\"\n   * bail-out, before capturing the pre-open trigger element) — `Drawer`'s only hook into the\n   * show effect, used to auto-close every other open drawer first.\n   */\n  onBeforeShow?: (dialog: HTMLDialogElement) => void\n  /**\n   * The caller's own `onClick`, chained ahead of the backdrop-click handling below rather than\n   * left in the props spread — a `<dialog>` needs `onClick` for its own backdrop detection, so\n   * spreading the caller's alongside it silently dropped one of the two. Fires for every click\n   * on the dialog, not just backdrop ones.\n   */\n  onClick?: MouseEventHandler<HTMLDialogElement>\n  onClose?: () => void\n  onClosePrevented?: () => void\n  onHidden?: () => void\n  onShow?: () => void\n  onShown?: () => void\n  /**\n   * Fired with `false` for each close request, beside `onClose`.\n   */\n  onVisibleChange?: (visible: boolean) => void\n  /**\n   * The native `open` attribute the caller renders. Without `visible` or `defaultVisible`, it is\n   * the initial state: the dialog is rendered open (non-modal) from the first paint, server HTML\n   * included, and stays open until a close request, instead of being closed on mount.\n   */\n  open?: boolean\n  ref: ForwardedRef<HTMLDialogElement>\n  /**\n   * Controlled open state; `undefined` means uncontrolled.\n   */\n  visible?: boolean\n}\n\n// The element each open dialog returns focus to when it closes.\nconst restoreTargets = new WeakMap<HTMLDialogElement, HTMLElement | null>()\n\n// The element a closing dialog returns focus to. A dialog opened from another dialog that has\n// closed since (the second alert of a chain) can't return focus to its trigger, which is hidden,\n// so it follows that dialog's own target, and so on. A loop (going back and forth between two\n// dialogs) gives up.\nfunction resolveRestoreTarget(trigger: HTMLElement | null): HTMLElement | null {\n  const seen = new Set<HTMLDialogElement>()\n  let target = trigger\n  let owner = target?.closest('dialog') ?? null\n  while (target && owner && !owner.open) {\n    if (seen.has(owner)) return null\n    seen.add(owner)\n    target = restoreTargets.get(owner) ?? null\n    owner = target?.closest('dialog') ?? null\n  }\n  return target\n}\n\n// Shared open/close machinery for a native `<dialog>`-based component — `Modal` and `Drawer`\n// otherwise duplicated this near-verbatim: forked ref, the show/begin-hide effect (showModal()\n// vs. show(), initial focus, scroll lock), the finish-hide effect (waits out the exit\n// transition), the non-modal Escape-key listener (the native `cancel` event only fires for\n// dialogs opened with `showModal()`), and the static-backdrop \"bounce\" used by both the\n// backdrop-click handler and the Escape/`cancel` handler. What's left in each caller is only\n// what's genuinely component-specific: `Modal`/`Drawer`'s own `_className` building, and\n// `Drawer`'s cross-instance \"auto-close every other open drawer\" registry (wired in via\n// `onBeforeShow`, since it needs to run at one precise point inside the show effect).\n//\n// A dialog has no trigger of its own, so the only change it asks for is a close: Escape, a\n// backdrop click, a close button. That request fires `onClose` and `onVisibleChange(false)`.\n// Controlled by `visible`, the dialog stays open until the caller sets it to `false`; with\n// `defaultVisible` it closes itself.\nexport const useDialogElement = ({\n  backdrop,\n  defaultVisible,\n  instant,\n  isModal,\n  keyboard = true,\n  onBeforeShow,\n  onClick,\n  onClose,\n  onClosePrevented,\n  onHidden,\n  onShow,\n  onShown,\n  onVisibleChange,\n  open,\n  ref,\n  visible\n}: UseDialogElementOptions) => {\n  const dialogRef = useRef<HTMLDialogElement>(null)\n  const forkedRef = useForkedRef(ref, dialogRef)\n\n  const [_visible, setVisible] = useControllableState(\n    visible,\n    defaultVisible ?? open ?? false,\n    onVisibleChange\n  )\n  const [hiding, setHiding] = useState(false)\n  const [staticBounce, setStaticBounce] = useState(false)\n  const [scrollLocked, setScrollLocked] = useState(false)\n  const openedAsModalRef = useRef(false)\n  const triggerRef = useRef<HTMLElement | null>(null)\n\n  // Locked from showModal() until the exit transition finishes (see the show/hide effect\n  // below) — usePreventScroll releases it automatically on unmount too, even mid-transition.\n  usePreventScroll({ isDisabled: !scrollLocked })\n\n  const close = () => {\n    onClose?.()\n    // Several things can ask an open dialog to close while it is closing; only the first is a\n    // change.\n    if (_visible) setVisible(false)\n  }\n\n  const triggerStaticBounce = () => {\n    onClosePrevented?.()\n    const dialog = dialogRef.current\n    if (!dialog) return\n    setStaticBounce(true)\n    executeAfterTransition(dialog, () => setStaticBounce(false), !instant)\n  }\n\n  // Read through refs, kept current every render, so the keydown listener below — which only\n  // resubscribes when `keyboard` changes — never invokes a stale `close`/`triggerStaticBounce`\n  // closure if `onClose`/`onClosePrevented`/`instant` change identity without `keyboard` also\n  // changing. Same pattern as `Drawer`'s own `closeRef` and `useFloatingOverlay`'s `closeRef`.\n  const closeRef = useRef(close)\n  closeRef.current = close\n  const triggerStaticBounceRef = useRef(triggerStaticBounce)\n  triggerStaticBounceRef.current = triggerStaticBounce\n\n  // Show / begin-hide\n  useIsomorphicLayoutEffect(() => {\n    const dialog = dialogRef.current\n    if (!dialog) return undefined\n\n    if (_visible) {\n      if (dialog.open) return undefined\n\n      onBeforeShow?.(dialog)\n\n      triggerRef.current =\n        document.activeElement instanceof HTMLElement ? document.activeElement : null\n\n      restoreTargets.set(dialog, triggerRef.current)\n\n      openedAsModalRef.current = isModal\n      if (isModal) {\n        dialog.showModal()\n        setScrollLocked(true)\n      } else {\n        dialog.show()\n      }\n\n      // `data-autofocus` too: React doesn't write the `autofocus` attribute in a client render (it\n      // calls `focus()` on mount, which a closed dialog ignores), so `autoFocus` alone only works\n      // in server-rendered HTML.\n      // Only this dialog's own: one inside a nested dialog (an `Alert` in a `Modal`) is hidden\n      // while that dialog is closed, and focusing it would fail silently.\n      const autofocusEl = [\n        ...dialog.querySelectorAll<HTMLElement>(\n          '[autofocus], [data-autofocus]:not([data-autofocus=\"false\"])'\n        )\n      ].find((element) => element.closest('dialog') === dialog)\n      if (autofocusEl) {\n        autofocusEl.focus()\n      } else {\n        dialog.setAttribute('tabindex', '-1')\n        dialog.focus()\n      }\n\n      onShow?.()\n      setHiding(false)\n\n      return executeAfterTransition(dialog, () => onShown?.(), !instant)\n    }\n\n    if (!dialog.open) return undefined\n    setHiding(true)\n    return undefined\n  }, [_visible])\n\n  // Finish hide once the exit transition (or lack thereof) completes\n  useEffect(() => {\n    const dialog = dialogRef.current\n    if (!hiding || !dialog) return undefined\n\n    return executeAfterTransition(\n      dialog,\n      () => {\n        // Focus goes back only if this dialog still has it, or nothing does: another dialog\n        // opened from this one (the next alert of a chain) keeps its own. Mirrors `Popover`.\n        const active = document.activeElement\n        const ownsFocus = !active || active === document.body || dialog.contains(active)\n        if (dialog.open) {\n          dialog.close()\n        }\n        if (openedAsModalRef.current) {\n          setScrollLocked(false)\n        }\n        setHiding(false)\n        onHidden?.()\n        const trigger = ownsFocus ? resolveRestoreTarget(triggerRef.current) : null\n        if (trigger && document.contains(trigger)) {\n          trigger.focus()\n        }\n      },\n      !instant\n    )\n  }, [hiding])\n\n  // Escape key for non-modal (show()) dialogs — the native `cancel` event below only\n  // fires for dialogs opened with showModal().\n  useEffect(() => {\n    const dialog = dialogRef.current\n    if (!dialog) return undefined\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key !== 'Escape' || openedAsModalRef.current) return\n      event.preventDefault()\n      if (!keyboard) {\n        triggerStaticBounceRef.current()\n        return\n      }\n      closeRef.current()\n    }\n\n    dialog.addEventListener('keydown', handleKeyDown)\n    return () => dialog.removeEventListener('keydown', handleKeyDown)\n  }, [keyboard])\n\n  const handleCancel = (event: SyntheticEvent<HTMLDialogElement>) => {\n    event.preventDefault()\n    if (!keyboard) {\n      triggerStaticBounce()\n      return\n    }\n    close()\n  }\n\n  const handleBackdropClick = (event: ReactMouseEvent<HTMLDialogElement>) => {\n    onClick?.(event)\n    if (event.target !== dialogRef.current || !openedAsModalRef.current) return\n    if (backdrop === 'static') {\n      triggerStaticBounce()\n      return\n    }\n    close()\n  }\n\n  return { close, dialogRef, forkedRef, handleBackdropClick, handleCancel, hiding, staticBounce }\n}\n"],"mappings":"0TA4EA,MAAM,EAAiB,IAAI,QAM3B,SAAS,EAAqB,EAAiD,CAC7E,IAAM,EAAO,IAAI,IACb,EAAS,EACT,EAAQ,GAAQ,QAAQ,QAAQ,GAAK,KACzC,KAAO,GAAU,GAAS,CAAC,EAAM,MAAM,CACrC,GAAI,EAAK,IAAI,CAAK,EAAG,OAAO,KAC5B,EAAK,IAAI,CAAK,EACd,EAAS,EAAe,IAAI,CAAK,GAAK,KACtC,EAAQ,GAAQ,QAAQ,QAAQ,GAAK,IACvC,CACA,OAAO,CACT,CAgBA,MAAa,GAAoB,CAC/B,WACA,iBACA,UACA,UACA,WAAW,GACX,eACA,UACA,UACA,mBACA,WACA,SACA,UACA,kBACA,OACA,MACA,aAC6B,CAC7B,IAAM,EAAY,EAA0B,IAAI,EAC1C,EAAY,EAAa,EAAK,CAAS,EAEvC,CAAC,EAAU,GAAc,EAC7B,EACA,GAAkB,GAAQ,GAC1B,CACF,EACM,CAAC,EAAQ,GAAa,EAAS,EAAK,EACpC,CAAC,EAAc,GAAmB,EAAS,EAAK,EAChD,CAAC,EAAc,GAAmB,EAAS,EAAK,EAChD,EAAmB,EAAO,EAAK,EAC/B,EAAa,EAA2B,IAAI,EAIlD,EAAiB,CAAE,WAAY,CAAC,CAAa,CAAC,EAE9C,IAAM,MAAc,CAClB,IAAU,EAGN,GAAU,EAAW,EAAK,CAChC,EAEM,MAA4B,CAChC,IAAmB,EACnB,IAAM,EAAS,EAAU,QACpB,IACL,EAAgB,EAAI,EACpB,EAAuB,MAAc,EAAgB,EAAK,EAAG,CAAC,CAAO,EACvE,EAMM,EAAW,EAAO,CAAK,EAC7B,EAAS,QAAU,EACnB,IAAM,EAAyB,EAAO,CAAmB,EA0HzD,MAzHA,GAAuB,QAAU,EAGjC,MAAgC,CAC9B,IAAM,EAAS,EAAU,QACpB,KAEL,IAAI,EAAU,CACZ,GAAI,EAAO,KAAM,OAEjB,IAAe,CAAM,EAErB,EAAW,QACT,SAAS,yBAAyB,YAAc,SAAS,cAAgB,KAE3E,EAAe,IAAI,EAAQ,EAAW,OAAO,EAE7C,EAAiB,QAAU,EACvB,GACF,EAAO,UAAU,EACjB,EAAgB,EAAI,GAEpB,EAAO,KAAK,EAQd,IAAM,EAAc,CAClB,GAAG,EAAO,iBACR,6DACF,CACF,CAAC,CAAC,KAAM,GAAY,EAAQ,QAAQ,QAAQ,IAAM,CAAM,EAWxD,OAVI,EACF,EAAY,MAAM,GAElB,EAAO,aAAa,WAAY,IAAI,EACpC,EAAO,MAAM,GAGf,IAAS,EACT,EAAU,EAAK,EAER,EAAuB,MAAc,IAAU,EAAG,CAAC,CAAO,CACnE,CAEK,EAAO,MACZ,EAAU,EAAI,CAHd,CAKF,EAAG,CAAC,CAAQ,CAAC,EAGb,MAAgB,CACd,IAAM,EAAS,EAAU,QACrB,GAAC,GAAW,EAEhB,OAAO,EACL,MACM,CAGJ,IAAM,EAAS,SAAS,cAClB,EAAY,CAAC,GAAU,IAAW,SAAS,MAAQ,EAAO,SAAS,CAAM,EAC3E,EAAO,MACT,EAAO,MAAM,EAEX,EAAiB,SACnB,EAAgB,EAAK,EAEvB,EAAU,EAAK,EACf,IAAW,EACX,IAAM,EAAU,EAAY,EAAqB,EAAW,OAAO,EAAI,KACnE,GAAW,SAAS,SAAS,CAAO,GACtC,EAAQ,MAAM,CAElB,EACA,CAAC,CACH,CACF,EAAG,CAAC,CAAM,CAAC,EAIX,MAAgB,CACd,IAAM,EAAS,EAAU,QACzB,GAAI,CAAC,EAAQ,OAEb,IAAM,EAAiB,GAAyB,CAC1C,OAAM,MAAQ,UAAY,EAAiB,SAE/C,IADA,EAAM,eAAe,EACjB,CAAC,EAAU,CACb,EAAuB,QAAQ,EAC/B,MACF,CACA,EAAS,QAAQ,CADjB,CAEF,EAGA,OADA,EAAO,iBAAiB,UAAW,CAAa,MACnC,EAAO,oBAAoB,UAAW,CAAa,CAClE,EAAG,CAAC,CAAQ,CAAC,EAqBN,CAAE,QAAO,YAAW,YAAW,oBAVT,GAA8C,CACzE,OAAU,CAAK,EACX,EAAM,SAAW,EAAU,SAAY,EAAiB,QAC5D,IAAI,IAAa,SAAU,CACzB,EAAoB,EACpB,MACF,CACA,EAAM,CADN,CAEF,EAE2D,aAnBrC,GAA6C,CAEjE,GADA,EAAM,eAAe,EACjB,CAAC,EAAU,CACb,EAAoB,EACpB,MACF,CACA,EAAM,CACR,EAYyE,SAAQ,cAAa,CAChG"}

package/dist/chunks/useDisabledAnchorGuard-Cz58UCXy.js

@@ -0,0 +1,2 @@
+const e=(e,t,n)=>r=>{if(e&&t){r.preventDefault();return}n?.(r)};export{e as t};
+//# sourceMappingURL=useDisabledAnchorGuard-Cz58UCXy.js.map

package/dist/chunks/useDisabledAnchorGuard-Cz58UCXy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDisabledAnchorGuard-Cz58UCXy.js","names":[],"sources":["../../src/hooks/useDisabledAnchorGuard.ts"],"sourcesContent":["import { MouseEvent, MouseEventHandler } from 'react'\n\n// A native `<button>`/`<input>` stops firing `click` on its own once `disabled` is set — an\n// `<a>` (or any other non-native-button element standing in for one) has no real `disabled`\n// attribute, so it still fires click (and an anchor still navigates) unless blocked by hand.\n// `guard` is the caller's own \"is this rendering as a non-native-button element\" check (e.g.\n// `Component === 'a'` for `Button`/`CloseButton`, `!isButton` for `Chip`) — kept as an explicit\n// parameter rather than inferred here, since each caller's own set of native, guard-free elements\n// differs slightly.\nexport const useDisabledAnchorGuard = <T extends HTMLElement>(\n  guard: boolean,\n  disabled: boolean | undefined,\n  onClick: MouseEventHandler<T> | undefined\n): MouseEventHandler<T> => {\n  return (event: MouseEvent<T>) => {\n    if (guard && disabled) {\n      event.preventDefault()\n      return\n    }\n    onClick?.(event)\n  }\n}\n"],"mappings":"AASA,MAAa,GACX,EACA,EACA,IAEQ,GAAyB,CAC/B,GAAI,GAAS,EAAU,CACrB,EAAM,eAAe,EACrB,MACF,CACA,IAAU,CAAK,CACjB"}

package/dist/chunks/useFloatingOverlay-DLIvwx-8.js

@@ -0,0 +1,2 @@
+import{useEffect as e,useRef as t,useState as n}from"react";function r({close:r,isOpen:i,onHide:a,onShow:o,triggerRef:s}){let[c,l]=n(null),u=()=>s.current?.closest(`dialog[open]`)??document.body,d=t(!1);e(()=>{let e=!d.current;d.current=!0,i?(l(u()),e||o?.()):e||a?.()},[i]);let f=t(r);return f.current=r,e(()=>{let e=c?.closest(`dialog`);if(!i||!e)return;let t=()=>f.current();return e.addEventListener(`close`,t),()=>e.removeEventListener(`close`,t)},[i,c]),c}function i(e){return{position:`absolute`,...e.style,transform:e.style?.top===void 0?`translateX(-50%)`:`translateY(-50%)`}}function a(e){return e===`entering`||e===`entered`?`fade show`:`fade`}export{a as n,r,i as t};
+//# sourceMappingURL=useFloatingOverlay-DLIvwx-8.js.map

package/dist/chunks/useFloatingOverlay-DLIvwx-8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFloatingOverlay-DLIvwx-8.js","names":[],"sources":["../../src/hooks/useFloatingOverlay.ts"],"sourcesContent":["import { CSSProperties, HTMLAttributes, RefObject, useEffect, useRef, useState } from 'react'\n\nimport { TransitionPhase } from './useTransitionState'\n\nexport interface UseFloatingOverlayOptions {\n  /**\n   * Imperatively closes the overlay — called when the containing `<dialog>` fires its native\n   * `close` event. Pass a stable callback (e.g. the trigger state's own `close`) where possible;\n   * an inline arrow is fine too, since only its latest value is ever invoked.\n   */\n  close: () => void\n  /**\n   * Whether the overlay is currently open — drives `onShow`/`onHide` and portal-container\n   * resolution.\n   */\n  isOpen: boolean\n  onHide?: () => void\n  onShow?: () => void\n  /**\n   * Ref to the element that triggers the overlay, used to resolve which `<dialog>` (if any) it\n   * lives inside.\n   */\n  triggerRef: RefObject<HTMLElement | null>\n}\n\n/**\n * Shared portal-container/visibility wiring for `Popover` and `Tooltip`: resolves the `<dialog>`\n * a trigger lives inside (if any), fires `onShow`/`onHide`, and resets on the containing dialog's\n * native `close` event. The open state itself is the trigger state's, which each component builds\n * from `visible`/`defaultVisible`/`onVisibleChange` (`toOpenStateProps`). Positioning-specific\n * concerns (placement, arrow, escape/outside-click dismissal) stay in each component.\n */\nexport function useFloatingOverlay({\n  close,\n  isOpen,\n  onHide,\n  onShow,\n  triggerRef\n}: UseFloatingOverlayOptions) {\n  const [portalContainer, setPortalContainer] = useState<Element | null>(null)\n\n  // Overlays inside an open `<dialog>` are appended to that dialog instead of `document.body`,\n  // so they render in its top layer and close with it automatically.\n  const resolvePortalContainer = () => triggerRef.current?.closest('dialog[open]') ?? document.body\n\n  // `onShow`/`onHide` report *transitions*, so neither fires for the initial commit — mounting\n  // closed is not a hide. Without this guard the `else` branch ran on mount and every\n  // `<Popover onHide>`/`<Tooltip onHide>` on the page reported a close that never happened,\n  // before `onShow` had ever fired once. The portal container still resolves on mount, since\n  // an overlay mounted already-open needs one immediately.\n  const mountedRef = useRef(false)\n\n  useEffect(() => {\n    const isInitialCommit = !mountedRef.current\n    mountedRef.current = true\n\n    if (isOpen) {\n      setPortalContainer(resolvePortalContainer())\n      if (!isInitialCommit) onShow?.()\n    } else if (!isInitialCommit) {\n      onHide?.()\n    }\n  }, [isOpen])\n\n  // `close` is read through a ref so this effect only re-subscribes when `isOpen`/\n  // `portalContainer` actually change, regardless of whether the caller passes a stable\n  // callback or a fresh inline arrow each render.\n  const closeRef = useRef(close)\n  closeRef.current = close\n\n  // A dialog fires a native `close` event on ESC, backdrop click, or `.close()`, so resetting\n  // on it keeps a reopened dialog from showing a stale, already-open overlay.\n  useEffect(() => {\n    const dialog = portalContainer?.closest('dialog')\n    if (!isOpen || !dialog) return\n\n    const handleClose = () => closeRef.current()\n    dialog.addEventListener('close', handleClose)\n    return () => dialog.removeEventListener('close', handleClose)\n  }, [isOpen, portalContainer])\n\n  return portalContainer\n}\n\n// `useOverlayPosition`'s `arrowProps.style` sets a single cross-axis offset (`top` for a\n// left/right overlay, `left` for a top/bottom one) to the trigger's center point, not the arrow\n// element's top-left corner — so it must be recentered by half the arrow's own size on that\n// axis. Chassis-css's JS plugin never has this problem since Floating UI's `arrow` middleware\n// returns a top-left-corner coordinate directly; react-aria's is center-based. Unlike the\n// chassis-css JS plugin, react-aria also never sets `position: absolute` on the arrow element\n// itself, so without it the offset has no effect and the arrow renders in normal document flow.\nexport function getOverlayArrowStyle(arrowProps: HTMLAttributes<HTMLDivElement>): CSSProperties {\n  return {\n    position: 'absolute',\n    ...arrowProps.style,\n    transform: arrowProps.style?.top !== undefined ? 'translateY(-50%)' : 'translateX(-50%)'\n  }\n}\n\n// Mounted without `show`, shown once those styles are computed, and without it again for as\n// long as the exit lasts: chassis-css's `.fade` transitions the opacity between the two.\nexport function getOverlayTransitionClass(phase: TransitionPhase): string {\n  return phase === 'entering' || phase === 'entered' ? 'fade show' : 'fade'\n}\n"],"mappings":"4DAgCA,SAAgB,EAAmB,CACjC,QACA,SACA,SACA,SACA,cAC4B,CAC5B,GAAM,CAAC,EAAiB,GAAsB,EAAyB,IAAI,EAIrE,MAA+B,EAAW,SAAS,QAAQ,cAAc,GAAK,SAAS,KAOvF,EAAa,EAAO,EAAK,EAE/B,MAAgB,CACd,IAAM,EAAkB,CAAC,EAAW,QACpC,EAAW,QAAU,GAEjB,GACF,EAAmB,EAAuB,CAAC,EACtC,GAAiB,IAAS,GACrB,GACV,IAAS,CAEb,EAAG,CAAC,CAAM,CAAC,EAKX,IAAM,EAAW,EAAO,CAAK,EAc7B,MAbA,GAAS,QAAU,EAInB,MAAgB,CACd,IAAM,EAAS,GAAiB,QAAQ,QAAQ,EAChD,GAAI,CAAC,GAAU,CAAC,EAAQ,OAExB,IAAM,MAAoB,EAAS,QAAQ,EAE3C,OADA,EAAO,iBAAiB,QAAS,CAAW,MAC/B,EAAO,oBAAoB,QAAS,CAAW,CAC9D,EAAG,CAAC,EAAQ,CAAe,CAAC,EAErB,CACT,CASA,SAAgB,EAAqB,EAA2D,CAC9F,MAAO,CACL,SAAU,WACV,GAAG,EAAW,MACd,UAAW,EAAW,OAAO,MAAQ,IAAA,GAAiC,mBAArB,kBACnD,CACF,CAIA,SAAgB,EAA0B,EAAgC,CACxE,OAAO,IAAU,YAAc,IAAU,UAAY,YAAc,MACrE"}

package/dist/chunks/useForkedRef-DVEfT-KI.js

@@ -0,0 +1,2 @@
+import{useMemo as e}from"react";function t(...t){return e(()=>t.every(e=>e==null)?null:e=>{t.forEach(t=>{n(t,e)})},t)}function n(e,t){if(e!=null){if(r(e))e(t);else try{e.current=t}catch(n){throw Error(`Cannot assign value "${t}" to ref "${e}"`,{cause:n})}}}function r(e){return!!(e&&{}.toString.call(e)==`[object Function]`)}export{t};
+//# sourceMappingURL=useForkedRef-DVEfT-KI.js.map

package/dist/chunks/useForkedRef-DVEfT-KI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForkedRef-DVEfT-KI.js","names":[],"sources":["../../src/hooks/useForkedRef.ts"],"sourcesContent":["// code borrowed from https://github.com/reach/reach-ui\n// problem described https://github.com/facebook/react/issues/13029\n\nimport { useMemo } from 'react'\n\nexport type AssignableRef<ValueType> =\n  | {\n      bivarianceHack(instance: ValueType | null): void\n    }['bivarianceHack']\n  | React.MutableRefObject<ValueType | null>\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForkedRef<RefValueType = any>(\n  ...refs: (AssignableRef<RefValueType> | null | undefined)[]\n) {\n  return useMemo(() => {\n    if (refs.every((ref) => ref == null)) {\n      return null\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (node: any) => {\n      refs.forEach((ref) => {\n        assignRef(ref, node)\n      })\n    }\n  }, refs)\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function assignRef<RefValueType = any>(\n  ref: AssignableRef<RefValueType> | null | undefined,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  value: any\n) {\n  if (ref == null) return\n  if (isFunction(ref)) {\n    ref(value)\n  } else {\n    try {\n      ref.current = value\n    } catch (error) {\n      throw new Error(`Cannot assign value \"${value}\" to ref \"${ref}\"`, { cause: error })\n    }\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type\nexport function isFunction(value: any): value is Function {\n  return !!(value && {}.toString.call(value) == '[object Function]')\n}\n"],"mappings":"gCAYA,SAAgB,EACd,GAAG,EACH,CACA,OAAO,MACD,EAAK,MAAO,GAAQ,GAAO,IAAI,EAC1B,KAGD,GAAc,CACpB,EAAK,QAAS,GAAQ,CACpB,EAAU,EAAK,CAAI,CACrB,CAAC,CACH,EACC,CAAI,CACT,CAGA,SAAgB,EACd,EAEA,EACA,CACI,MAAO,KACX,IAAI,EAAW,CAAG,EAChB,EAAI,CAAK,OAET,GAAI,CACF,EAAI,QAAU,CAChB,OAAS,EAAO,CACd,MAAU,MAAM,wBAAwB,EAAM,YAAY,EAAI,GAAI,CAAE,MAAO,CAAM,CAAC,CACpF,EAEJ,CAGA,SAAgB,EAAW,EAA+B,CACxD,MAAO,CAAC,EAAE,GAAS,CAAC,EAAE,SAAS,KAAK,CAAK,GAAK,oBAChD"}

package/dist/chunks/useFormField-BOqmBTC4.js

@@ -0,0 +1,2 @@
+import{useId as e}from"react";const t=({ariaDescribedBy:t,ariaLabelledBy:n,help:r,id:i,invalid:a,invalidFeedback:o,label:s,valid:c,validFeedback:l})=>{let u=e(),d=i??u,f=`${u}-label`,p=`${u}-help`,m=`${u}-feedback`;return{describedBy:[r&&p,(a&&o||c&&l)&&m,t].filter(Boolean).join(` `)||void 0,feedbackId:m,helpId:p,inputId:d,labelId:f,labelledBy:[s&&f,n].filter(Boolean).join(` `)||void 0}};export{t};
+//# sourceMappingURL=useFormField-BOqmBTC4.js.map

package/dist/chunks/useFormField-BOqmBTC4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormField-BOqmBTC4.js","names":[],"sources":["../../src/hooks/useFormField.ts"],"sourcesContent":["import { ReactNode, useId } from 'react'\n\nexport interface UseFormFieldOptions {\n  /**\n   * A caller-supplied `aria-describedby` to merge in alongside the generated help/feedback ids\n   * (e.g. `rest['aria-describedby']`).\n   */\n  ariaDescribedBy?: string\n  /**\n   * A caller-supplied `aria-labelledby` to merge in alongside `labelId` (e.g.\n   * `rest['aria-labelledby']`). Relevant for the `role=\"group\"` shape and for any single-input\n   * component backed by a react-aria hook — see `labelledBy`.\n   */\n  ariaLabelledBy?: string\n  help?: ReactNode\n  id?: string\n  invalid?: boolean\n  invalidFeedback?: ReactNode\n  label?: ReactNode\n  valid?: boolean\n  validFeedback?: ReactNode\n}\n\nexport interface UseFormFieldResult {\n  /**\n   * Merged `aria-describedby` value (help id + feedback id, if shown + `ariaDescribedBy`), or\n   * `undefined` when none apply. Safe to spread straight onto the real control:\n   * `aria-describedby={describedBy}`.\n   */\n  describedBy?: string\n  feedbackId: string\n  helpId: string\n  /**\n   * Id for the one real focusable control — pair with `<FormLabel htmlFor={inputId}>` (via\n   * `ids.input`). Ignore this and use `labelId`/`labelledBy` instead for a `role=\"group\"` wrapper\n   * with no single input to target — see FORMS.md's \"`htmlFor` vs `aria-labelledby`\" section.\n   */\n  inputId: string\n  /**\n   * This field's own label id, for a control to reference via its own `aria-labelledby` (via\n   * `ids.label`) instead of `htmlFor`.\n   */\n  labelId: string\n  /**\n   * Merged `aria-labelledby` value (`labelId`, only when `label` is set + `ariaLabelledBy`), or\n   * `undefined` when neither applies. Feed this into the underlying react-aria hook's own\n   * `aria-labelledby` (in addition to any `htmlFor`-based association) so its own dev-mode\n   * \"no accessible label\" warning knows about a visible `label` it can't otherwise see.\n   */\n  labelledBy?: string\n}\n\n// Shared id-generation and aria-describedby/aria-labelledby merge logic behind every\n// renderFormField-based component (see FORMS.md's \"The two engines\" section). Every id is\n// generated with React's own useId(), not react-aria's — see FORMS.md for why that's deliberate.\n//\n// If you spread the result of a react-aria hook via mergeProps(hookProps, rest) instead of\n// directly onto the control, re-apply `describedBy`/`labelledBy` as explicit props *after* that\n// spread — mergeProps lets the later argument win, so rest's raw (un-merged) aria-describedby/\n// aria-labelledby can silently overwrite these otherwise. See FORMS.md gotcha #4.\nexport const useFormField = ({\n  ariaDescribedBy,\n  ariaLabelledBy,\n  help,\n  id,\n  invalid,\n  invalidFeedback,\n  label,\n  valid,\n  validFeedback\n}: UseFormFieldOptions): UseFormFieldResult => {\n  const generatedId = useId()\n  const inputId = id ?? generatedId\n  const labelId = `${generatedId}-label`\n  const helpId = `${generatedId}-help`\n  const feedbackId = `${generatedId}-feedback`\n\n  const showInvalidFeedback = invalid && invalidFeedback\n  const showValidFeedback = valid && validFeedback\n\n  const describedBy =\n    [help && helpId, (showInvalidFeedback || showValidFeedback) && feedbackId, ariaDescribedBy]\n      .filter(Boolean)\n      .join(' ') || undefined\n\n  const labelledBy = [label && labelId, ariaLabelledBy].filter(Boolean).join(' ') || undefined\n\n  return { describedBy, feedbackId, helpId, inputId, labelId, labelledBy }\n}\n"],"mappings":"8BA4DA,MAAa,GAAgB,CAC3B,kBACA,iBACA,OACA,KACA,UACA,kBACA,QACA,QACA,mBAC6C,CAC7C,IAAM,EAAc,EAAM,EACpB,EAAU,GAAM,EAChB,EAAU,GAAG,EAAY,QACzB,EAAS,GAAG,EAAY,OACxB,EAAa,GAAG,EAAY,WAYlC,MAAO,CAAE,YANP,CAAC,GAAQ,GAJiB,GAAW,GACb,GAAS,IAG8B,EAAY,CAAe,CAAC,CACxF,OAAO,OAAO,CAAC,CACf,KAAK,GAAG,GAAK,IAAA,GAII,aAAY,SAAQ,UAAS,UAAS,WAFzC,CAAC,GAAS,EAAS,CAAc,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,GAAK,IAAA,EAEZ,CACzE"}

package/dist/chunks/useIsomorphicLayoutEffect-BbqRwuqn.js

@@ -0,0 +1,2 @@
+import{useEffect as e,useLayoutEffect as t}from"react";const n=typeof window>`u`?e:t;export{n as t};
+//# sourceMappingURL=useIsomorphicLayoutEffect-BbqRwuqn.js.map

package/dist/chunks/useIsomorphicLayoutEffect-BbqRwuqn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsomorphicLayoutEffect-BbqRwuqn.js","names":[],"sources":["../../src/hooks/useIsomorphicLayoutEffect.ts"],"sourcesContent":["import { useEffect, useLayoutEffect } from 'react'\n\n// `useLayoutEffect` logs a console warning (\"does nothing on the server\") whenever it's called\n// during SSR, even though no effect — layout or otherwise — ever actually runs server-side;\n// React only cares that the hook itself was invoked under `renderToString`/\n// `renderToPipeableStream`. Swapping to `useEffect` in that environment silences the warning with\n// no behavior change, since neither hook runs server-side anyway — this only picks which one\n// no-ops there.\nexport const useIsomorphicLayoutEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect\n"],"mappings":"uDAQA,MAAa,EAA4B,OAAO,OAAW,IAAc,EAAY"}

package/dist/chunks/useOpenStateProps-DykUbnPJ.js

@@ -0,0 +1,2 @@
+import{v as e}from"./slot-CNhFZdHF.js";import{t}from"./visibleState-B_i1zHu2.js";import{useCallback as n,useRef as r}from"react";const i=[[`isOpen`,`visible`],[`defaultOpen`,`defaultVisible`],[`onOpenChange`,`onVisibleChange`]];function a(a,o){for(let[t,n]of i)e(a[t]!==void 0,`${o}: the ${t} prop is deprecated, use ${n} instead. It will be removed in a future major version.`);let s=r(a);s.current=a;let c=n(e=>{let n=s.current;t({onVisibleChange:n.onVisibleChange??n.onOpenChange,visible:n.visible??n.isOpen},e,o),n.onVisibleChange?.(e),n.onOpenChange?.(e)},[o]);return{defaultOpen:a.defaultVisible??a.defaultOpen,isOpen:a.visible??a.isOpen,onOpenChange:c}}export{a as t};
+//# sourceMappingURL=useOpenStateProps-DykUbnPJ.js.map

package/dist/chunks/useOpenStateProps-DykUbnPJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOpenStateProps-DykUbnPJ.js","names":[],"sources":["../../src/hooks/useOpenStateProps.ts"],"sourcesContent":["import { useCallback, useRef } from 'react'\n\nimport { devWarning } from '../utils/devWarning'\nimport { VisibleStateProps, warnDroppedVisibleRequest } from '../utils/visibleState'\n\n// The names react-aria gives the same three props. `DatePicker` and `DateRangePicker` took them\n// under these names first; they are deprecated in favour of the `visible` ones, which win when\n// both are passed.\nexport interface DeprecatedOpenStateProps {\n  defaultOpen?: boolean\n  isOpen?: boolean\n  onOpenChange?: (isOpen: boolean) => void\n}\n\nconst DEPRECATED_OPEN_STATE_PROPS = [\n  ['isOpen', 'visible'],\n  ['defaultOpen', 'defaultVisible'],\n  ['onOpenChange', 'onVisibleChange']\n] as const\n\n/**\n * `visible`/`defaultVisible`/`onVisibleChange` as react-stately's trigger states take them\n * (`useOverlayTriggerState`, `useTooltipTriggerState`, `useMenuTriggerState`, the date picker\n * states). Those states are controlled by `isOpen` already, and call `onOpenChange` only for a\n * value that differs from the current one.\n *\n * `onOpenChange` keeps one identity. The state's `open`/`close`/`toggle` are rebuilt whenever it\n * changes, and components subscribe to window events in effects that depend on them.\n */\nexport function useOpenStateProps(\n  props: VisibleStateProps & DeprecatedOpenStateProps,\n  displayName: string\n) {\n  for (const [deprecated, replacement] of DEPRECATED_OPEN_STATE_PROPS) {\n    devWarning(\n      props[deprecated] !== undefined,\n      `${displayName}: the ${deprecated} prop is deprecated, use ${replacement} instead. It ` +\n        'will be removed in a future major version.'\n    )\n  }\n\n  const propsRef = useRef(props)\n  propsRef.current = props\n\n  const onOpenChange = useCallback(\n    (next: boolean) => {\n      const current = propsRef.current\n      warnDroppedVisibleRequest(\n        {\n          onVisibleChange: current.onVisibleChange ?? current.onOpenChange,\n          visible: current.visible ?? current.isOpen\n        },\n        next,\n        displayName\n      )\n      current.onVisibleChange?.(next)\n      current.onOpenChange?.(next)\n    },\n    [displayName]\n  )\n\n  return {\n    defaultOpen: props.defaultVisible ?? props.defaultOpen,\n    isOpen: props.visible ?? props.isOpen,\n    onOpenChange\n  }\n}\n"],"mappings":"iIAcA,MAAM,EAA8B,CAClC,CAAC,SAAU,SAAS,EACpB,CAAC,cAAe,gBAAgB,EAChC,CAAC,eAAgB,iBAAiB,CACpC,EAWA,SAAgB,EACd,EACA,EACA,CACA,IAAK,GAAM,CAAC,EAAY,KAAgB,EACtC,EACE,EAAM,KAAgB,IAAA,GACtB,GAAG,EAAY,QAAQ,EAAW,2BAA2B,EAAY,wDAE3E,EAGF,IAAM,EAAW,EAAO,CAAK,EAC7B,EAAS,QAAU,EAEnB,IAAM,EAAe,EAClB,GAAkB,CACjB,IAAM,EAAU,EAAS,QACzB,EACE,CACE,gBAAiB,EAAQ,iBAAmB,EAAQ,aACpD,QAAS,EAAQ,SAAW,EAAQ,MACtC,EACA,EACA,CACF,EACA,EAAQ,kBAAkB,CAAI,EAC9B,EAAQ,eAAe,CAAI,CAC7B,EACA,CAAC,CAAW,CACd,EAEA,MAAO,CACL,YAAa,EAAM,gBAAkB,EAAM,YAC3C,OAAQ,EAAM,SAAW,EAAM,OAC/B,cACF,CACF"}

package/dist/chunks/useToastRegionQueue-CIV5SdiE.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useForkedRef-DVEfT-KI.js";import{t}from"./useControllableState-CPUJxfKW.js";import{n}from"./Portal-CgeR1WXV.js";import{t as r}from"./visibleState-B_i1zHu2.js";import{t as i}from"./useTransitionState-e5ToY7eX.js";import{useCallback as a,useEffect as o,useId as s,useRef as c}from"react";import{useToastRegion as l}from"react-aria";import{useToastQueue as u}from"react-stately";function d({enabled:e=!1,delay:t=5e3,visible:n,onHide:r}){let i=c(void 0),s=c(!1),l=c(!1),u=a(()=>{clearTimeout(i.current),i.current=void 0},[]),d=a(()=>{u(),!(!e||s.current||l.current)&&(i.current=window.setTimeout(r,t))},[e,t,r,u]);return o(()=>u,[u]),o(()=>{n?d():u()},[n,e,t,d,u]),{onMouseEnter:a(()=>{s.current=!0,u()},[u]),onMouseLeave:a(()=>{s.current=!1,d()},[d]),onFocus:a(()=>{l.current=!0,u()},[u]),onBlur:a(()=>{l.current=!1,d()},[d])}}function f({defaultVisible:l,displayName:u,onClose:d,onShow:f,onVisibleChange:p,ref:m,visible:h}){let g=h!==void 0,[_,v]=t(h,l,p),y=c(null),b=e(m,y),x=s(),S=s(),C=c(!1),w=c(d);w.current=d;let T=a(()=>{C.current&&(C.current=!1,w.current?.())},[]),E=c(()=>{});E.current=()=>{_&&(g||(C.current=!0),r({onVisibleChange:p,visible:h},!1,u),v(!1))};let D=a(()=>E.current(),[]),O=n(),{isMounted:k,phase:A}=i({appear:O,in:_,nodeRef:y,onEnter:()=>{C.current=!1,f?.()},onExit:()=>{C.current=!0},onExited:T,unmountOnExit:!0});o(()=>T,[T]);let j=c(!O&&_);return o(()=>{j.current&&(j.current=!1,f?.())},[]),{close:D,entered:A===`entered`,forkedRef:b,isMounted:k,textId:S,titleId:x,transitionClass:A===`entering`||A===`exiting`?`show showing`:A===`entered`?`show`:void 0,visible:_}}function p(t,n){let r=u(t),i=c(null),{regionProps:a}=l({},r,i);return{forkedRef:e(n,i),regionProps:a,state:r}}export{f as n,d as r,p as t};
+//# sourceMappingURL=useToastRegionQueue-CIV5SdiE.js.map

package/dist/chunks/useToastRegionQueue-CIV5SdiE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToastRegionQueue-CIV5SdiE.js","names":[],"sources":["../../src/hooks/useAutoDismiss.ts","../../src/hooks/useDismissibleTransition.ts","../../src/hooks/useToastRegionQueue.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react'\n\nexport interface UseAutoDismissOptions {\n  /**\n   * Enables the auto-dismiss timer. When `false`, `onHide` is never called and the returned\n   * handlers are no-ops.\n   */\n  enabled?: boolean\n  /**\n   * Delay in ms before `onHide` fires once the timer is (re)started.\n   */\n  delay?: number\n  /**\n   * Whether the dismissible element is currently visible. The timer only runs while `true`.\n   */\n  visible: boolean\n  /**\n   * Called once the delay elapses without an intervening pointer/focus interaction.\n   */\n  onHide: () => void\n}\n\nexport interface UseAutoDismissResult {\n  onMouseEnter: () => void\n  onMouseLeave: () => void\n  onFocus: () => void\n  onBlur: () => void\n}\n\n// Shared timer logic for components that auto-dismiss after a delay, pausing while the pointer\n// or focus is on the element (mirrors the behavior `Toast` already implements). Extracted so new\n// auto-dismissing components don't reimplement the pause/resume bookkeeping.\nexport function useAutoDismiss({\n  enabled = false,\n  delay = 5000,\n  visible,\n  onHide\n}: UseAutoDismissOptions): UseAutoDismissResult {\n  // `useRef<number>()` (no argument) isn't valid under @types/react 19 — the overload requires\n  // an initial value, and the ref has to admit `undefined` for `clearAutoDismissTimeout` to reset\n  // it back to \"no timer scheduled\".\n  const timeout = useRef<number | undefined>(undefined)\n  const hasMouseInteraction = useRef(false)\n  const hasKeyboardInteraction = useRef(false)\n\n  const clearAutoDismissTimeout = useCallback(() => {\n    clearTimeout(timeout.current)\n    timeout.current = undefined\n  }, [])\n\n  const maybeScheduleHide = useCallback(() => {\n    clearAutoDismissTimeout()\n    if (!enabled || hasMouseInteraction.current || hasKeyboardInteraction.current) {\n      return\n    }\n    timeout.current = window.setTimeout(onHide, delay)\n  }, [enabled, delay, onHide, clearAutoDismissTimeout])\n\n  // Clears on unmount.\n  useEffect(() => clearAutoDismissTimeout, [clearAutoDismissTimeout])\n\n  useEffect(() => {\n    if (visible) {\n      maybeScheduleHide()\n    } else {\n      clearAutoDismissTimeout()\n    }\n  }, [visible, enabled, delay, maybeScheduleHide, clearAutoDismissTimeout])\n\n  const onMouseEnter = useCallback(() => {\n    hasMouseInteraction.current = true\n    clearAutoDismissTimeout()\n  }, [clearAutoDismissTimeout])\n\n  const onMouseLeave = useCallback(() => {\n    hasMouseInteraction.current = false\n    maybeScheduleHide()\n  }, [maybeScheduleHide])\n\n  const onFocus = useCallback(() => {\n    hasKeyboardInteraction.current = true\n    clearAutoDismissTimeout()\n  }, [clearAutoDismissTimeout])\n\n  const onBlur = useCallback(() => {\n    hasKeyboardInteraction.current = false\n    maybeScheduleHide()\n  }, [maybeScheduleHide])\n\n  return { onMouseEnter, onMouseLeave, onFocus, onBlur }\n}\n","import { ForwardedRef, useCallback, useEffect, useId, useRef } from 'react'\n\nimport { useHydrated } from '../components/portal/Portal'\nimport { warnDroppedVisibleRequest } from '../utils/visibleState'\nimport { useControllableState } from './useControllableState'\nimport { useForkedRef } from './useForkedRef'\nimport { useTransitionState } from './useTransitionState'\n\nexport interface UseDismissibleTransitionOptions {\n  /**\n   * Initial state of an uncontrolled component. `Toast` starts hidden, `Notification` shown.\n   */\n  defaultVisible: boolean\n  /**\n   * The component's name, for the development warning about a dropped close request.\n   */\n  displayName: string\n  /**\n   * Callback fired once the exit transition completes and the component is fully hidden, or\n   * when the component unmounts before its exit could complete.\n   */\n  onClose?: () => void\n  /**\n   * Callback fired when the component starts to show.\n   */\n  onShow?: () => void\n  /**\n   * Callback fired with `false` when the component asks to hide: its close button, `close()`\n   * from its context, or the autohide timer.\n   */\n  onVisibleChange?: (visible: boolean) => void\n  ref: ForwardedRef<HTMLDivElement>\n  /**\n   * Controlled state; `undefined` means uncontrolled.\n   */\n  visible?: boolean\n}\n\nexport interface UseDismissibleTransitionResult {\n  /**\n   * Requests the component be closed. Uncontrolled, that hides it: the exit transition starts\n   * and `onClose` fires once it finishes. Controlled by `visible`, it only reports to\n   * `onVisibleChange`. Stable across re-renders (see the hook's own doc comment for why that\n   * matters).\n   */\n  close: () => void\n  /**\n   * Whether the entrance transition has actually finished — `false` while still fading/sliding\n   * in, even though `visible` is already `true`. Gate anything that should only start once the\n   * component is fully, visibly present (e.g. an autohide timer) on this rather than `visible`\n   * alone.\n   */\n  entered: boolean\n  forkedRef: ReturnType<typeof useForkedRef<HTMLDivElement>>\n  /**\n   * `false` before the component first shows and after it has exited: render nothing.\n   */\n  isMounted: boolean\n  textId: string\n  titleId: string\n  /**\n   * chassis-css's classes for the current phase: `show showing` while entering or exiting,\n   * `show` once settled, none while hidden.\n   */\n  transitionClass: string | undefined\n  /**\n   * The state that drives the transition: the `visible` prop when it is set, the component's own\n   * state otherwise.\n   */\n  visible: boolean\n}\n\n// Shared dismiss/transition machinery for `Toast` and `Notification` — both otherwise duplicated\n// this near-verbatim: visible-state + prop-sync effect, a forked ref, the phase-to-class mapping,\n// `titleId`/`textId` via `useId()`, and the enter/exit callback wiring of `useTransitionState`.\n//\n// `close` is memoized once here with `useCallback` (empty deps — it reads everything it needs\n// through refs) specifically so it has a stable identity across re-renders. Previously each component built its own unmemoized\n// `() => setVisible(false)` inline and passed it straight into `useAutoDismiss`, whose scheduling\n// effect depends on that closure's identity — since `Toaster`/`NotificationStack` re-render every\n// mounted item whenever the shared queue changes (`ToastQueue.add()`/`.close()` notify all\n// subscribers synchronously), that meant adding or dismissing any one toast/notification silently\n// restarted every other visible one's autohide countdown, with no code change needed to trigger\n// it beyond normal multi-item usage.\n//\n// `entered` similarly gates \"has the entrance transition actually finished\" uniformly for both —\n// `Toast` already had this (gating on `visible` alone would start the autohide timer the instant\n// `visible` flips true, while still fading/sliding in); `Notification` didn't, so this extraction\n// gives it the same fix for free.\n//\n// `onClose` normally fires when the exit transition has finished. A component that unmounts\n// before that (a `Toaster` remounted by a navigation 50 ms after its toast's action was clicked,\n// issue #40) would never report the close it was asked for, and a queued toast would come back\n// with the next `Toaster`. So an unmount with a close still owed reports it then. It is owed from\n// the `close()` call itself, not from the start of the exit, because the unmount can land in the\n// same commit as the state change `close()` asked for. That holds for an uncontrolled component,\n// where `close()` is the change. A controlled one owes `onClose` only once `visible` has become\n// `false` and the exit has started: until then `close()` is a request its owner may decline.\nexport function useDismissibleTransition({\n  defaultVisible,\n  displayName,\n  onClose,\n  onShow,\n  onVisibleChange,\n  ref,\n  visible\n}: UseDismissibleTransitionOptions): UseDismissibleTransitionResult {\n  const isControlled = visible !== undefined\n  const [_visible, setVisible] = useControllableState(visible, defaultVisible, onVisibleChange)\n  const nodeRef = useRef<HTMLDivElement>(null)\n  const forkedRef = useForkedRef(ref, nodeRef)\n  const titleId = useId()\n  const textId = useId()\n\n  const closeOwedRef = useRef(false)\n  const onCloseRef = useRef(onClose)\n  onCloseRef.current = onClose\n\n  const reportClose = useCallback(() => {\n    if (!closeOwedRef.current) return\n    closeOwedRef.current = false\n    onCloseRef.current?.()\n  }, [])\n\n  // Replaced every render, so the stable `close` below always reports to the current props.\n  const requestHideRef = useRef(() => {})\n  requestHideRef.current = () => {\n    // Closing what is already hidden asks for nothing, so it owes no `onClose`.\n    if (!_visible) return\n    if (!isControlled) closeOwedRef.current = true\n    warnDroppedVisibleRequest({ onVisibleChange, visible }, false, displayName)\n    setVisible(false)\n  }\n\n  const close = useCallback(() => requestHideRef.current(), [])\n\n  // A component mounted visible plays its enter transition, except in the server's HTML and\n  // while hydrating it: there is nothing on screen to animate from, and starting hidden left the\n  // page without the component until the JavaScript had loaded. It starts settled, with `show`.\n  const hydrated = useHydrated()\n\n  const { isMounted, phase } = useTransitionState({\n    appear: hydrated,\n    in: _visible,\n    nodeRef,\n    onEnter: () => {\n      closeOwedRef.current = false\n      onShow?.()\n    },\n    onExit: () => {\n      closeOwedRef.current = true\n    },\n    onExited: reportClose,\n    unmountOnExit: true\n  })\n\n  useEffect(() => reportClose, [reportClose])\n\n  // Settled from the start, the component never enters, which is where `onShow` fires: fire it\n  // once on mount instead, since it did show. The ref keeps StrictMode's second run from firing\n  // it again.\n  const showOwedRef = useRef(!hydrated && _visible)\n  useEffect(() => {\n    if (!showOwedRef.current) return\n    showOwedRef.current = false\n    onShow?.()\n  }, [])\n\n  return {\n    close,\n    entered: phase === 'entered',\n    forkedRef,\n    isMounted,\n    textId,\n    titleId,\n    transitionClass:\n      phase === 'entering' || phase === 'exiting'\n        ? 'show showing'\n        : phase === 'entered'\n          ? 'show'\n          : undefined,\n    visible: _visible\n  }\n}\n","import { ForwardedRef, useRef } from 'react'\nimport { ToastRegionAria, useToastRegion } from 'react-aria'\nimport { ToastQueue, ToastState, useToastQueue } from 'react-stately'\n\nimport { useForkedRef } from './useForkedRef'\n\nexport interface UseToastRegionQueueResult<T> {\n  forkedRef: ReturnType<typeof useForkedRef<HTMLDivElement>>\n  regionProps: ToastRegionAria['regionProps']\n  state: ToastState<T>\n}\n\n// Shared setup for `Toaster`/`NotificationStack` — both otherwise duplicated this near-verbatim:\n// subscribe to a `ToastQueue` singleton, wire up react-aria's toast-region accessibility\n// plumbing, and fork the caller's ref onto the same node the region hook needs. Differs only in\n// which queue is passed.\nexport function useToastRegionQueue<T>(\n  queue: ToastQueue<T>,\n  ref: ForwardedRef<HTMLDivElement>\n): UseToastRegionQueueResult<T> {\n  const state = useToastQueue(queue)\n  const regionRef = useRef<HTMLDivElement>(null)\n  const { regionProps } = useToastRegion({}, state, regionRef)\n  const forkedRef = useForkedRef(ref, regionRef)\n\n  return { forkedRef, regionProps, state }\n}\n"],"mappings":"6YAgCA,SAAgB,EAAe,CAC7B,UAAU,GACV,QAAQ,IACR,UACA,UAC8C,CAI9C,IAAM,EAAU,EAA2B,IAAA,EAAS,EAC9C,EAAsB,EAAO,EAAK,EAClC,EAAyB,EAAO,EAAK,EAErC,EAA0B,MAAkB,CAChD,aAAa,EAAQ,OAAO,EAC5B,EAAQ,QAAU,IAAA,EACpB,EAAG,CAAC,CAAC,EAEC,EAAoB,MAAkB,CAC1C,EAAwB,EACpB,GAAC,GAAW,EAAoB,SAAW,EAAuB,WAGtE,EAAQ,QAAU,OAAO,WAAW,EAAQ,CAAK,EACnD,EAAG,CAAC,EAAS,EAAO,EAAQ,CAAuB,CAAC,EAiCpD,OA9BA,MAAgB,EAAyB,CAAC,CAAuB,CAAC,EAElE,MAAgB,CACV,EACF,EAAkB,EAElB,EAAwB,CAE5B,EAAG,CAAC,EAAS,EAAS,EAAO,EAAmB,CAAuB,CAAC,EAsBjE,CAAE,aApBY,MAAkB,CACrC,EAAoB,QAAU,GAC9B,EAAwB,CAC1B,EAAG,CAAC,CAAuB,CAiBP,EAAG,aAfF,MAAkB,CACrC,EAAoB,QAAU,GAC9B,EAAkB,CACpB,EAAG,CAAC,CAAiB,CAYa,EAAG,QAVrB,MAAkB,CAChC,EAAuB,QAAU,GACjC,EAAwB,CAC1B,EAAG,CAAC,CAAuB,CAOgB,EAAG,OAL/B,MAAkB,CAC/B,EAAuB,QAAU,GACjC,EAAkB,CACpB,EAAG,CAAC,CAAiB,CAE8B,CAAE,CACvD,CCQA,SAAgB,EAAyB,CACvC,iBACA,cACA,UACA,SACA,kBACA,MACA,WACkE,CAClE,IAAM,EAAe,IAAY,IAAA,GAC3B,CAAC,EAAU,GAAc,EAAqB,EAAS,EAAgB,CAAe,EACtF,EAAU,EAAuB,IAAI,EACrC,EAAY,EAAa,EAAK,CAAO,EACrC,EAAU,EAAM,EAChB,EAAS,EAAM,EAEf,EAAe,EAAO,EAAK,EAC3B,EAAa,EAAO,CAAO,EACjC,EAAW,QAAU,EAErB,IAAM,EAAc,MAAkB,CAC/B,EAAa,UAClB,EAAa,QAAU,GACvB,EAAW,UAAU,EACvB,EAAG,CAAC,CAAC,EAGC,EAAiB,MAAa,CAAC,CAAC,EACtC,EAAe,YAAgB,CAExB,IACA,IAAc,EAAa,QAAU,IAC1C,EAA0B,CAAE,kBAAiB,SAAQ,EAAG,GAAO,CAAW,EAC1E,EAAW,EAAK,EAClB,EAEA,IAAM,EAAQ,MAAkB,EAAe,QAAQ,EAAG,CAAC,CAAC,EAKtD,EAAW,EAAY,EAEvB,CAAE,YAAW,SAAU,EAAmB,CAC9C,OAAQ,EACR,GAAI,EACJ,UACA,YAAe,CACb,EAAa,QAAU,GACvB,IAAS,CACX,EACA,WAAc,CACZ,EAAa,QAAU,EACzB,EACA,SAAU,EACV,cAAe,EACjB,CAAC,EAED,MAAgB,EAAa,CAAC,CAAW,CAAC,EAK1C,IAAM,EAAc,EAAO,CAAC,GAAY,CAAQ,EAOhD,OANA,MAAgB,CACT,EAAY,UACjB,EAAY,QAAU,GACtB,IAAS,EACX,EAAG,CAAC,CAAC,EAEE,CACL,QACA,QAAS,IAAU,UACnB,YACA,YACA,SACA,UACA,gBACE,IAAU,YAAc,IAAU,UAC9B,eACA,IAAU,UACR,OACA,IAAA,GACR,QAAS,CACX,CACF,CCvKA,SAAgB,EACd,EACA,EAC8B,CAC9B,IAAM,EAAQ,EAAc,CAAK,EAC3B,EAAY,EAAuB,IAAI,EACvC,CAAE,eAAgB,EAAe,CAAC,EAAG,EAAO,CAAS,EAG3D,MAAO,CAAE,UAFS,EAAa,EAAK,CAEnB,EAAG,cAAa,OAAM,CACzC"}

package/dist/chunks/useTransitionState-e5ToY7eX.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useIsomorphicLayoutEffect-BbqRwuqn.js";import{t}from"./dialogTransition-i9vw0i2Z.js";import{useRef as n,useState as r}from"react";const i=e=>void e?.offsetHeight;function a({appear:a=!1,in:o,mountOnEnter:s=!1,nodeRef:c,onEnter:l,onEntering:u,onEntered:d,onExit:f,onExiting:p,onExited:m,unmountOnExit:h=!1}){let[g,_]=r(()=>o?a?`exited`:`entered`:s||h?`unmounted`:`exited`),v=n(g),y=e=>{v.current=e,_(e)},b={onEnter:l,onEntering:u,onEntered:d,onExit:f,onExiting:p,onExited:m},x=n(b);x.current=b,e(()=>{let e=v.current;o!==(e===`entering`||e===`entered`)&&(o?(i(c.current),x.current.onEnter?.(),y(`entering`)):(x.current.onExit?.(),y(`exiting`)))},[o]),e(()=>{if(g!==`entering`&&g!==`exiting`)return;let e=()=>{g===`entering`?(y(`entered`),x.current.onEntered?.()):(y(h?`unmounted`:`exited`),x.current.onExited?.())};g===`entering`?x.current.onEntering?.():x.current.onExiting?.();let n=c.current;if(!n){e();return}return t(n,e,!0)},[g]);let S=o&&g===`unmounted`?`exited`:g;return{isMounted:S!==`unmounted`,phase:S}}export{a as t};
+//# sourceMappingURL=useTransitionState-e5ToY7eX.js.map

package/dist/chunks/useTransitionState-e5ToY7eX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransitionState-e5ToY7eX.js","names":[],"sources":["../../src/hooks/useTransitionState.ts"],"sourcesContent":["import { RefObject, useRef, useState } from 'react'\n\nimport { executeAfterTransition } from '../utils/dialogTransition'\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect'\n\n/**\n * Where a component is in its show/hide cycle. `exited` is mounted and hidden, `unmounted` is\n * not rendered at all.\n */\nexport type TransitionPhase = 'unmounted' | 'exited' | 'entering' | 'entered' | 'exiting'\n\nexport interface UseTransitionStateOptions {\n  /**\n   * Plays the enter transition on the first mount too, when `in` is already `true`. Without it\n   * a component mounted visible starts settled, in `entered`.\n   */\n  appear?: boolean\n  /**\n   * Whether the component is shown.\n   */\n  in: boolean\n  /**\n   * Keeps the component out of the DOM until it is first shown.\n   */\n  mountOnEnter?: boolean\n  /**\n   * The element the classes are applied to. Its own CSS transition decides how long `entering`\n   * and `exiting` last.\n   */\n  nodeRef: RefObject<HTMLElement | null>\n  /**\n   * Fires before `entering` is rendered, while the element still has its hidden styles.\n   */\n  onEnter?: () => void\n  /**\n   * Fires once `entering` is in the DOM, before the browser paints it.\n   */\n  onEntering?: () => void\n  /**\n   * Fires when the enter transition has finished.\n   */\n  onEntered?: () => void\n  /**\n   * Fires before `exiting` is rendered, while the element still has its shown styles.\n   */\n  onExit?: () => void\n  /**\n   * Fires once `exiting` is in the DOM, before the browser paints it.\n   */\n  onExiting?: () => void\n  /**\n   * Fires when the exit transition has finished. With `unmountOnExit` the element is still in\n   * the DOM at this point.\n   */\n  onExited?: () => void\n  /**\n   * Takes the component out of the DOM once it has exited.\n   */\n  unmountOnExit?: boolean\n}\n\nexport interface UseTransitionStateResult {\n  /**\n   * `false` while there is nothing to render.\n   */\n  isMounted: boolean\n  phase: TransitionPhase\n}\n\nconst forceReflow = (node: HTMLElement | null) => void node?.offsetHeight\n\n// The show/hide state machine behind `Collapse`, `TabPanel`, `Toast`, `Notification`, `Tooltip`\n// and `Popover`. It only reports a phase. Each component maps phases to chassis-css's classes\n// (`fade`, `show`, `showing`, `collapsing`), because those mappings differ.\n//\n// A phase lasts as long as the element's own CSS transition: it ends on `transitionend`, or\n// after the computed duration when that event never comes (`executeAfterTransition`, which\n// chassis-css's own plugins and `Modal`/`Drawer`/`Menu` use too). Nothing here holds a duration,\n// so a theme that changes one, and `prefers-reduced-motion`, under which chassis-css sets\n// `transition: none`, are followed without a second source of truth.\n//\n// Every step runs in a layout effect, so the browser never paints a state between two steps,\n// and a step that needs the previous styles computed first (an element that was just mounted,\n// or `display: none` a moment ago) forces a reflow itself.\nexport function useTransitionState({\n  appear = false,\n  in: inProp,\n  mountOnEnter = false,\n  nodeRef,\n  onEnter,\n  onEntering,\n  onEntered,\n  onExit,\n  onExiting,\n  onExited,\n  unmountOnExit = false\n}: UseTransitionStateOptions): UseTransitionStateResult {\n  const [phase, setPhaseState] = useState<TransitionPhase>(() => {\n    if (inProp) return appear ? 'exited' : 'entered'\n    return mountOnEnter || unmountOnExit ? 'unmounted' : 'exited'\n  })\n\n  // Mirrors `phase` at the moment it is set, not at the next render: StrictMode runs the effect\n  // below twice on mount, and the second run has to see that the first already started.\n  const phaseRef = useRef(phase)\n  const setPhase = (next: TransitionPhase) => {\n    phaseRef.current = next\n    setPhaseState(next)\n  }\n\n  // Read through a ref so a caller can pass inline callbacks without restarting a transition.\n  const callbacks = { onEnter, onEntering, onEntered, onExit, onExiting, onExited }\n  const callbacksRef = useRef(callbacks)\n  callbacksRef.current = callbacks\n\n  useIsomorphicLayoutEffect(() => {\n    const current = phaseRef.current\n    const isIn = current === 'entering' || current === 'entered'\n    if (inProp === isIn) return\n\n    if (inProp) {\n      forceReflow(nodeRef.current)\n      callbacksRef.current.onEnter?.()\n      setPhase('entering')\n    } else {\n      callbacksRef.current.onExit?.()\n      setPhase('exiting')\n    }\n  }, [inProp])\n\n  useIsomorphicLayoutEffect(() => {\n    if (phase !== 'entering' && phase !== 'exiting') return undefined\n\n    const finish = () => {\n      if (phase === 'entering') {\n        setPhase('entered')\n        callbacksRef.current.onEntered?.()\n      } else {\n        setPhase(unmountOnExit ? 'unmounted' : 'exited')\n        callbacksRef.current.onExited?.()\n      }\n    }\n\n    if (phase === 'entering') callbacksRef.current.onEntering?.()\n    else callbacksRef.current.onExiting?.()\n\n    // Nothing rendered means nothing to wait for.\n    const node = nodeRef.current\n    if (!node) {\n      finish()\n      return undefined\n    }\n    return executeAfterTransition(node, finish, true)\n  }, [phase])\n\n  // Shown while still `unmounted`: render it hidden in this same pass, so the element exists\n  // when the effect above starts the enter from it.\n  const rendered = inProp && phase === 'unmounted' ? 'exited' : phase\n\n  return { isMounted: rendered !== 'unmounted', phase: rendered }\n}\n"],"mappings":"uJAqEA,MAAM,EAAe,GAA6B,KAAK,GAAM,aAe7D,SAAgB,EAAmB,CACjC,SAAS,GACT,GAAI,EACJ,eAAe,GACf,UACA,UACA,aACA,YACA,SACA,YACA,WACA,gBAAgB,IACsC,CACtD,GAAM,CAAC,EAAO,GAAiB,MACzB,EAAe,EAAS,SAAW,UAChC,GAAgB,EAAgB,YAAc,QACtD,EAIK,EAAW,EAAO,CAAK,EACvB,EAAY,GAA0B,CAC1C,EAAS,QAAU,EACnB,EAAc,CAAI,CACpB,EAGM,EAAY,CAAE,UAAS,aAAY,YAAW,SAAQ,YAAW,UAAS,EAC1E,EAAe,EAAO,CAAS,EACrC,EAAa,QAAU,EAEvB,MAAgC,CAC9B,IAAM,EAAU,EAAS,QAErB,KADS,IAAY,YAAc,IAAY,aAG/C,GACF,EAAY,EAAQ,OAAO,EAC3B,EAAa,QAAQ,UAAU,EAC/B,EAAS,UAAU,IAEnB,EAAa,QAAQ,SAAS,EAC9B,EAAS,SAAS,GAEtB,EAAG,CAAC,CAAM,CAAC,EAEX,MAAgC,CAC9B,GAAI,IAAU,YAAc,IAAU,UAAW,OAEjD,IAAM,MAAe,CACf,IAAU,YACZ,EAAS,SAAS,EAClB,EAAa,QAAQ,YAAY,IAEjC,EAAS,EAAgB,YAAc,QAAQ,EAC/C,EAAa,QAAQ,WAAW,EAEpC,EAEI,IAAU,WAAY,EAAa,QAAQ,aAAa,EACvD,EAAa,QAAQ,YAAY,EAGtC,IAAM,EAAO,EAAQ,QACrB,GAAI,CAAC,EAAM,CACT,EAAO,EACP,MACF,CACA,OAAO,EAAuB,EAAM,EAAQ,EAAI,CAClD,EAAG,CAAC,CAAK,CAAC,EAIV,IAAM,EAAW,GAAU,IAAU,YAAc,SAAW,EAE9D,MAAO,CAAE,UAAW,IAAa,YAAa,MAAO,CAAS,CAChE"}

package/dist/chunks/validationClassName-gRGs4KBm.js

@@ -0,0 +1,2 @@
+const e=(e,t)=>({"is-invalid":e,"is-valid":t});export{e as t};
+//# sourceMappingURL=validationClassName-gRGs4KBm.js.map

package/dist/chunks/validationClassName-gRGs4KBm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationClassName-gRGs4KBm.js","names":[],"sources":["../../src/utils/validationClassName.ts"],"sourcesContent":["// Chassis-css's validation-state classes, shared by every form control that supports\n// `invalid`/`valid` (Radio, Switch, RangeInput, Select, TextInput, Textarea). Returns a\n// `classNames`-compatible object rather than a resolved string so callers can still combine it\n// with their own base/size classes and `className` in one `classNames(...)` call.\nexport const validationClassName = (invalid?: boolean, valid?: boolean) => ({\n  'is-invalid': invalid,\n  'is-valid': valid\n})\n"],"mappings":"AAIA,MAAa,GAAuB,EAAmB,KAAqB,CAC1E,aAAc,EACd,WAAY,CACd"}

package/dist/chunks/visibleState-B_i1zHu2.js

@@ -0,0 +1,2 @@
+import{v as e}from"./slot-CNhFZdHF.js";function t({onVisibleChange:t,visible:n},r,i){e(n!==void 0&&!t,`${i}: asked to ${r?`show`:`hide`}, but \`visible\` is set and there is no \`onVisibleChange\`, so nothing changed. Pass \`onVisibleChange\` to follow its requests, or \`defaultVisible\` to set only the initial state.`)}export{t};
+//# sourceMappingURL=visibleState-B_i1zHu2.js.map

package/dist/chunks/visibleState-B_i1zHu2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibleState-B_i1zHu2.js","names":[],"sources":["../../src/utils/visibleState.ts"],"sourcesContent":["import { devWarning } from './devWarning'\n\n// The open-state props of every component that can show and hide itself (see `CONVENTIONS.md`):\n// `visible` is controlled, `defaultVisible` is the initial state of an uncontrolled component, and\n// `onVisibleChange` reports each change the component asks for. Each component declares the three\n// itself, so its prop table says what asks for a change there.\nexport interface VisibleStateProps {\n  defaultVisible?: boolean\n  onVisibleChange?: (visible: boolean) => void\n  visible?: boolean\n}\n\n/**\n * Warns when a component asks to show or hide and nothing can follow the request: `visible` is\n * set and there is no `onVisibleChange`. Holding a component open or closed that way is allowed,\n * so this reports only a request that was dropped, not the props themselves.\n */\nexport function warnDroppedVisibleRequest(\n  { onVisibleChange, visible }: VisibleStateProps,\n  next: boolean,\n  displayName: string\n): void {\n  devWarning(\n    visible !== undefined && !onVisibleChange,\n    `${displayName}: asked to ${next ? 'show' : 'hide'}, but \\`visible\\` is set and there is no ` +\n      '`onVisibleChange`, so nothing changed. Pass `onVisibleChange` to follow its requests, or ' +\n      '`defaultVisible` to set only the initial state.'\n  )\n}\n"],"mappings":"uCAiBA,SAAgB,EACd,CAAE,kBAAiB,WACnB,EACA,EACM,CACN,EACE,IAAY,IAAA,IAAa,CAAC,EAC1B,GAAG,EAAY,aAAa,EAAO,OAAS,OAAO,wLAGrD,CACF"}

package/dist/close-button.d.ts

@@ -0,0 +1,2 @@
+import { n as CloseButtonProps, t as CloseButton } from "./chunks/index-BnR7wjax.js";
+export { CloseButton, type CloseButtonProps };

package/dist/close-button.js

@@ -0,0 +1 @@
+"use client";import"./chunks/focus-ring-SR_LwaN7.js";import{t as e}from"./chunks/CloseButton-DPgQztE0.js";export{e as CloseButton};

package/dist/collapse.d.ts

@@ -0,0 +1,2 @@
+import { n as CollapseProps, t as Collapse } from "./chunks/index-BA-raEMm.js";
+export { Collapse, type CollapseProps };

package/dist/collapse.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/collapse--Go2Y73B.js";export{e as Collapse};

package/dist/color-input.d.ts

@@ -0,0 +1,2 @@
+import { n as ColorInputProps, t as ColorInput } from "./chunks/index-DHGgezXU.js";
+export { ColorInput, type ColorInputProps };

package/dist/color-input.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/color-input-Bwl5ef5B.js";export{e as ColorInput};

package/dist/combobox.d.ts

@@ -0,0 +1,3 @@
+import { i as ComboboxGroupProps, n as ComboboxItemProps, r as ComboboxGroup, t as ComboboxItem } from "./chunks/ComboboxItem-C9TpoJOI.js";
+import { n as ComboboxProps, t as Combobox } from "./chunks/index-Bi8FFadV.js";
+export { Combobox, ComboboxGroup, type ComboboxGroupProps, ComboboxItem, type ComboboxItemProps, type ComboboxProps };

package/dist/combobox.js

@@ -0,0 +1 @@
+"use client";import{o as e}from"./chunks/ComboboxListBox-Cm3L1ULl.js";import{n as t,t as n}from"./chunks/combobox-Bp1tIaiW.js";export{n as Combobox,t as ComboboxGroup,e as ComboboxItem};

package/dist/context-menu.d.ts

@@ -0,0 +1,2 @@
+import { n as ContextMenuProps, t as ContextMenu } from "./chunks/index-BF3OWUVc.js";
+export { ContextMenu, type ContextMenuProps };

package/dist/context-menu.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/context-menu-B4a0tS-h.js";export{e as ContextMenu};

package/dist/datagrid.d.ts

@@ -0,0 +1,2 @@
+import { a as DataGridRowProps, c as DataGridCell, d as DataGridProps, f as DataGridHeader, h as DataGridBodyProps, i as DataGridRow, l as DataGridCellProps, m as DataGridBody, n as DataGridSelectionCell, o as DataGridColumn, p as DataGridHeaderProps, r as DataGridSelectionCellProps, s as DataGridColumnProps, t as DataGridSelectAllCell, u as DataGrid } from "./chunks/index-BTTeKpiE.js";
+export { DataGrid, DataGridBody, type DataGridBodyProps, DataGridCell, type DataGridCellProps, DataGridColumn, type DataGridColumnProps, DataGridHeader, type DataGridHeaderProps, type DataGridProps, DataGridRow, type DataGridRowProps, DataGridSelectAllCell, DataGridSelectionCell, type DataGridSelectionCellProps };

package/dist/datagrid.js

@@ -0,0 +1 @@
+"use client";import{a as e,c as t,i as n,n as r,o as i,r as a,s as o,t as s}from"./chunks/datagrid-CH3Cy-q7.js";export{t as DataGrid,o as DataGridBody,i as DataGridCell,e as DataGridColumn,n as DataGridHeader,a as DataGridRow,s as DataGridSelectAllCell,r as DataGridSelectionCell};

package/dist/datepicker.d.ts

@@ -0,0 +1,2 @@
+import { a as DatePickerProps, i as DatePickerMultipleProps, n as DateRangePickerProps, o as DatePickerSingleProps, r as DatePicker, t as DateRangePicker } from "./chunks/index-CqZ68Z8R.js";
+export { DatePicker, type DatePickerMultipleProps, type DatePickerProps, type DatePickerSingleProps, DateRangePicker, type DateRangePickerProps };

package/dist/datepicker.js

@@ -0,0 +1 @@
+"use client";import{n as e,t}from"./chunks/datepicker-bOiM_zhJ.js";export{e as DatePicker,t as DateRangePicker};

package/dist/divider.d.ts

@@ -0,0 +1,2 @@
+import { n as DividerProps, t as Divider } from "./chunks/index-9rQeMqVI.js";
+export { Divider, type DividerProps };

package/dist/divider.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/divider-CjbF4OfA.js";export{e as Divider};

package/dist/drawer.d.ts

@@ -0,0 +1,2 @@
+import { a as DrawerHeader, c as DrawerFooterProps, d as Drawer, f as DrawerProps, i as DrawerTitleProps, l as DrawerBody, n as useDrawer, o as DrawerHeaderProps, r as DrawerTitle, s as DrawerFooter, t as UseDrawerResult, u as DrawerBodyProps } from "./chunks/index-Cc4SSslb.js";
+export { Drawer, DrawerBody, type DrawerBodyProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerProps, DrawerTitle, type DrawerTitleProps, type UseDrawerResult, useDrawer };

package/dist/drawer.js

@@ -0,0 +1 @@
+"use client";import{a as e,i as t,n,o as r,r as i,t as a}from"./chunks/drawer-C7Tz4XU_.js";export{r as Drawer,t as DrawerBody,i as DrawerFooter,n as DrawerHeader,a as DrawerTitle,e as useDrawer};

package/dist/file-input.d.ts

@@ -0,0 +1,2 @@
+import { n as FileInputProps, t as FileInput } from "./chunks/index-CCXJXToc.js";
+export { FileInput, type FileInputProps };

package/dist/file-input.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/file-input-CDM6qrmV.js";export{e as FileInput};

package/dist/flex.d.ts

@@ -0,0 +1,2 @@
+import { n as FlexProps, t as Flex } from "./chunks/index-CVUMS0x7.js";
+export { Flex, type FlexProps };

package/dist/flex.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/flex-CmlJbKVj.js";export{e as Flex};

package/dist/floating-input.d.ts

@@ -0,0 +1,2 @@
+import { n as FloatingInputProps, t as FloatingInput } from "./chunks/index-CsARGAzD.js";
+export { FloatingInput, type FloatingInputProps };

package/dist/floating-input.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/floating-input-DmSZZc27.js";export{e as FloatingInput};

package/dist/form-field.d.ts

@@ -0,0 +1,2 @@
+import { n as FormFieldProps, t as FormField } from "./chunks/index-Ci7AEgEc.js";
+export { FormField, type FormFieldProps };

package/dist/form-field.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/form-field-CNPGTMiW.js";export{e as FormField};

package/dist/form.d.ts

@@ -0,0 +1,2 @@
+import { a as FormLabel, c as FormProps, i as FormHelpProps, n as FormFeedbackProps, o as FormLabelProps, r as FormHelp, s as Form, t as FormFeedback } from "./chunks/index-DAoPg59I.js";
+export { Form, FormFeedback, type FormFeedbackProps, FormHelp, type FormHelpProps, FormLabel, type FormLabelProps, type FormProps };

package/dist/form.js

@@ -0,0 +1 @@
+"use client";import{n as e,t}from"./chunks/FormHelp-AE6_iSLJ.js";import{t as n}from"./chunks/FormLabel-CYcQiFUI.js";import{t as r}from"./chunks/form-GpdAyWWi.js";export{r as Form,e as FormFeedback,t as FormHelp,n as FormLabel};

package/dist/grid.d.ts

@@ -0,0 +1,2 @@
+import { a as GridItemProps, c as GridProps, d as Col, f as ColProps, i as GridItemLayout, l as Container, n as RowProps, o as Grid, r as GridItem, s as GridLayout, t as Row, u as ContainerProps } from "./chunks/index-RHJhkSY-.js";
+export { Col, type ColProps, Container, type ContainerProps, Grid, GridItem, type GridItemLayout, type GridItemProps, type GridLayout, type GridProps, Row, type RowProps };

package/dist/grid.js

@@ -0,0 +1 @@
+"use client";import{a as e,i as t,n,r,t as i}from"./chunks/grid-DK_vxz-4.js";export{e as Col,t as Container,r as Grid,n as GridItem,i as Row};

package/dist/icon.d.ts

@@ -0,0 +1,4 @@
+import { n as IconProps, t as Icon } from "./chunks/Icon-CioraWLF.js";
+import { i as IconValue, r as IconKey, t as IconComponentProps } from "./chunks/iconConfig-C6gbYhsD.js";
+import { n as IconProviderProps, t as IconProvider } from "./chunks/index-BxROljJI.js";
+export { Icon, type IconComponentProps, type IconKey, type IconProps, IconProvider, type IconProviderProps, type IconValue };

package/dist/icon.js

@@ -0,0 +1 @@
+"use client";import{t as e}from"./chunks/Icon-DLB1f88W.js";import{t}from"./chunks/icon-BQsT6YtE.js";export{e as Icon,t as IconProvider};