@chassis-ui/react 0.4.0 → 0.5.0

package/dist/chunks/textarea-C-1cMyH4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textarea-C-1cMyH4.js","names":["useForkedRef","useHeldBack","renderFormField","validationClassName","mergeUnhandledProps","TEXT_FIELD_PROPS","React","classNames","Textarea","forwardRef","invalidProp","validProp","rest","textareaRef","useRef","forkedRef","ref","useFormField","useTextField","describedBy","labelledBy","inputId","disabled","invalid","readOnly","_className","plainText","size","valid","className","inputProps","feedbackId","helpId","labelId"],"sources":["../../src/components/textarea/Textarea.tsx"],"sourcesContent":["import React, { forwardRef, ReactNode, TextareaHTMLAttributes, useRef } from 'react'\nimport classNames from 'classnames'\nimport { AriaTextFieldOptions, useTextField } from 'react-aria'\n\nimport { useForkedRef, useFormField, useHeldBack } from '../../hooks'\nimport { mergeUnhandledProps, TEXT_FIELD_PROPS } from '../../utils/unhandledProps'\nimport { validationClassName } from '../../utils/validationClassName'\nimport { renderFormField } from '../form-field/renderFormField'\n\nexport interface TextareaProps extends Omit<\n  TextareaHTMLAttributes<HTMLTextAreaElement>,\n  'defaultValue' | 'onChange' | 'value'\n> {\n  /**\n   * A string of all className you want applied to the component.\n   */\n  className?: string\n  /**\n   * The value of the textarea, uncontrolled.\n   */\n  defaultValue?: string\n  /**\n   * Toggle the disabled state for the component.\n   */\n  disabled?: boolean\n  /**\n   * A description for the field, rendered below the textarea.\n   */\n  help?: ReactNode\n  /**\n   * Set component validation state to invalid. Left unset, the component shows as invalid by itself\n   * from a submit it held back (an empty `required` one, say) until it no longer would, or its\n   * form is reset. Set it, to `false` too, and it alone decides.\n   */\n  invalid?: boolean\n  /**\n   * An error message for the field, rendered below the textarea when `invalid` is set, and after a\n   * submit the field held back, until it no longer would.\n   */\n  invalidFeedback?: ReactNode\n  /**\n   * The field's caption, rendered as a `FormLabel` associated with this textarea.\n   */\n  label?: ReactNode\n  /**\n   * Handler that is called when the value changes.\n   */\n  onChange?: (value: string) => void\n  /**\n   * Render the component styled as plain text. Removes the default form field styling and preserve the correct margin and padding. Recommend to use only along side `readonly`.\n   */\n  plainText?: boolean\n  /**\n   * Toggle the readonly state for the component.\n   */\n  readOnly?: boolean\n  /**\n   * The number of visible text lines for the control.\n   */\n  rows?: number\n  /**\n   * Size the component sm or lg.\n   */\n  size?: 'sm' | 'lg'\n  /**\n   * Set component validation state to valid.\n   */\n  valid?: boolean\n  /**\n   * A success message for the field, rendered below the textarea when `valid` is set.\n   */\n  validFeedback?: ReactNode\n  /**\n   * The value of the textarea, controlled.\n   */\n  value?: string\n}\n\nexport const Textarea = forwardRef<HTMLTextAreaElement, TextareaProps>(\n  (\n    {\n      className,\n      disabled,\n      help,\n      id,\n      invalid: invalidProp,\n      invalidFeedback,\n      label,\n      plainText,\n      readOnly,\n      rows,\n      size,\n      valid: validProp,\n      validFeedback,\n      ...rest\n    },\n    ref\n  ) => {\n    const textareaRef = useRef<HTMLTextAreaElement>(null)\n    const forkedRef = useForkedRef(ref, textareaRef)\n    // Shown as invalid from a submit it held back until it no longer would (`useHeldBack`):\n    // react-aria cancels the browser's own message, and the form stayed with nothing to say why.\n    const { invalid, valid } = useHeldBack(textareaRef, { invalid: invalidProp, valid: validProp })\n\n    const { describedBy, feedbackId, helpId, inputId, labelId, labelledBy } = useFormField({\n      ariaDescribedBy: rest['aria-describedby'],\n      ariaLabelledBy: rest['aria-labelledby'],\n      help,\n      id,\n      invalid,\n      invalidFeedback,\n      label,\n      valid,\n      validFeedback\n    })\n\n    const { inputProps } = useTextField<'textarea'>(\n      {\n        ...rest,\n        'aria-describedby': describedBy,\n        'aria-labelledby': labelledBy,\n        id: inputId,\n        inputElementType: 'textarea',\n        isDisabled: disabled,\n        isInvalid: invalid,\n        isReadOnly: readOnly\n      } as AriaTextFieldOptions<'textarea'>,\n      textareaRef\n    )\n\n    const _className = classNames(\n      'form-input',\n      plainText && 'plaintext',\n      size,\n      validationClassName(invalid, valid),\n      className\n    )\n\n    return renderFormField({\n      // `aria-describedby` after the spread: see `TextInput`.\n      children: (\n        <textarea\n          {...mergeUnhandledProps(inputProps, rest, TEXT_FIELD_PROPS)}\n          aria-describedby={describedBy}\n          rows={rows}\n          className={_className}\n          ref={forkedRef}\n        />\n      ),\n      help,\n      ids: { feedback: feedbackId, help: helpId, input: inputId, label: labelId },\n      invalid,\n      invalidFeedback,\n      label,\n      valid,\n      validFeedback\n    })\n  }\n)\n\nTextarea.displayName = 'Textarea'\n"],"mappings":"A,8bA8EA,MAAaQ,EAAWC,GAEpB,CACE,YACA,WACA,OACA,KACA,QAASC,EACT,kBACA,QACA,YACA,WACA,OACA,OACA,MAAOC,EACP,gBACA,GAAGC,GAEL,IACG,CACH,IAAMC,EAAcC,EAA4B,IAAI,EAC9CC,EAAYf,EAAagB,EAAKH,CAAW,EAGzC,CAAE,UAAS,SAAUZ,EAAYY,EAAa,CAAE,QAASH,EAAa,MAAOC,CAAU,CAAC,EAExF,CAAE,cAAa,aAAY,SAAQ,UAAS,UAAS,cAAeM,EAAa,CACrF,gBAAiBL,EAAK,oBACtB,eAAgBA,EAAK,mBACrB,OACA,KACA,UACA,kBACA,QACA,QACA,eACF,CAAC,EAEK,CAAE,cAAeM,EACrB,CACE,GAAGN,EACH,mBAAoBO,EACpB,kBAAmBC,EACnB,GAAIC,EACJ,iBAAkB,WAClB,WAAYC,EACZ,UAAWC,EACX,WAAYC,CACd,EACAX,CACF,EAEMY,EAAalB,EACjB,aACAmB,GAAa,YACbC,EACAxB,EAAoBoB,EAASK,CAAK,EAClCC,CACF,EAEA,OAAO3B,EAAgB,CAErB,SACE,kBAAA,cAAC,WAAD,CACE,GAAIE,EAAoB0B,EAAYlB,EAAMP,CAAgB,EAC1D,mBAAkBc,EACZ,OACN,UAAWM,EACX,IAAKV,CACN,CAAA,EAEH,OACA,IAAK,CAAE,SAAUgB,EAAY,KAAMC,EAAQ,MAAOX,EAAS,MAAOY,CAAQ,EAC1E,UACA,kBACA,QACA,QACA,eACF,CAAC,CACH,CACF,EAEA,EAAS,YAAc,W"}

package/dist/chunks/time-field-CbCfOQZz.js

@@ -0,0 +1,2 @@
+import"./focus-ring-Bs80iIBN.js";import{u as e}from"./slot-BQVx1Eew.js";import{t}from"./useForkedRef-WoqMqsWE.js";import{t as ee}from"./useFormField-DH2tlc3e.js";import{t as n}from"./useRequiredValueInput-gYN8I-LY.js";import{t as r}from"./renderFormField-_6WswnEX.js";import{t as te}from"./validationClassName-gRGs4KBm.js";import{n as i,r as ne}from"./DateField-4cdcwt0v.js";import a,{forwardRef as o,useRef as s}from"react";import c from"classnames";import{mergeProps as l,useLocale as u,useTimeField as d}from"react-aria";import{useTimeFieldState as f}from"react-stately";const p=o(({autoFocus:o,className:p,defaultValue:m,disabled:h,form:g,granularity:re,help:_,hideTimeZone:ie,hourCycle:ae,id:oe,invalid:v,invalidFeedback:y,label:b,maxValue:x,minValue:S,name:C,onBlur:w,onChange:T,onFocus:E,onKeyDown:D,onKeyUp:O,placeholderValue:k,readOnly:A,required:j,shouldForceLeadingZeros:M,size:N,valid:P,validFeedback:F,value:I,...L},R)=>{let z=s(null),B=t(R,z),V=s(null),{locale:H}=u(),{inputProps:U,missing:W,valid:G}=n(V,{focus:()=>i(z.current),invalid:v,required:j&&!A,valid:P}),K={"aria-label":L[`aria-label`],autoFocus:o,defaultValue:m,form:g,granularity:re,hideTimeZone:ie,hourCycle:ae,inputRef:V,isDisabled:h,isInvalid:v||W||void 0,isReadOnly:A,isRequired:j,maxValue:x,minValue:S,name:C,onBlur:w,onChange:T,onFocus:E,onKeyDown:D,onKeyUp:O,placeholderValue:k,shouldForceLeadingZeros:M,value:I},q=f({...K,locale:H}),J=v||q.displayValidation.isInvalid,Y=G&&!J,{describedBy:se,feedbackId:ce,helpId:le,inputId:ue,labelId:de,labelledBy:X}=ee({ariaDescribedBy:L[`aria-describedby`],ariaLabelledBy:L[`aria-labelledby`],help:_,id:oe,invalid:J,invalidFeedback:y,label:b,valid:Y,validFeedback:F}),{descriptionProps:Z,errorMessageProps:Q,fieldProps:fe,inputProps:pe}=d({...K,"aria-describedby":se,"aria-labelledby":X,id:ue},q,z),$=e(fe,Z,Q);return r({children:/* @__PURE__ */ a.createElement(a.Fragment,null,/* @__PURE__ */ a.createElement(`div`,{...l($,L),"aria-describedby":$[`aria-describedby`],"aria-labelledby":X,className:c(`form-input`,`time-field`,N,{disabled:h},te(J,Y),p),ref:B,style:{...$.style,...L.style}},/* @__PURE__ */ a.createElement(`div`,{className:`datepicker-field`},q.segments.map((e,t)=>/* @__PURE__ */ a.createElement(ne,{fieldLabelledBy:X,key:t,segment:e,slots:[Z,Q],state:q})))),/* @__PURE__ */ a.createElement(`input`,{...pe,...U,ref:V})),help:_,ids:{feedback:ce,help:le,label:de},invalid:J,invalidFeedback:y,label:b,valid:Y,validFeedback:F})});p.displayName=`TimeField`;export{p as t};
+//# sourceMappingURL=time-field-CbCfOQZz.js.map

package/dist/chunks/time-field-CbCfOQZz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-field-CbCfOQZz.js","names":["withoutSlotIds","useFormField","useRequiredValueInput","renderFormField","validationClassName","focusFirstSegment","DateSegment","React","classNames","TimeField","forwardRef","validProp","rest","fieldRef","useRef","forkedRef","useForkedRef","ref","inputRef","useLocale","requiredInputProps","required","readOnly","baseProps","disabled","invalid","missing","state","useTimeFieldState","showInvalid","showValid","valid","groupProps","useTimeField","describedBy","labelledBy","inputId","group","descriptionProps","errorMessageProps","mergeProps","size","className","index","inputProps","feedbackId","helpId","labelId"],"sources":["../../src/components/time-field/TimeField.tsx"],"sourcesContent":["import React, { forwardRef, HTMLAttributes, ReactNode, useRef } from 'react'\nimport classNames from 'classnames'\nimport { AriaTimeFieldProps, mergeProps, TimeValue, useLocale, useTimeField } from 'react-aria'\nimport { useTimeFieldState } from 'react-stately'\n\nimport { useForkedRef, useFormField, useRequiredValueInput } from '../../hooks'\nimport { withoutSlotIds } from '../../utils/idRefs'\nimport { validationClassName } from '../../utils/validationClassName'\nimport { focusFirstSegment } from '../datepicker/DateField'\nimport { DateSegment } from '../datepicker/DateSegment'\nimport { renderFormField } from '../form-field/renderFormField'\n\nexport interface TimeFieldProps extends Omit<\n  HTMLAttributes<HTMLDivElement>,\n  'defaultValue' | 'onChange'\n> {\n  /**\n   * An accessible label for the field, used when there's no visible `label`.\n   */\n  'aria-label'?: string\n  /**\n   * Identifies a visible element that labels the field.\n   */\n  'aria-labelledby'?: string\n  /**\n   * Focus the first segment when the field mounts.\n   */\n  autoFocus?: boolean\n  /**\n   * A string of all className you want applied to the component.\n   */\n  className?: string\n  /**\n   * The value of the field, uncontrolled.\n   */\n  defaultValue?: TimeValue | null\n  /**\n   * Toggle the disabled state for the component.\n   */\n  disabled?: boolean\n  /**\n   * The id of a form elsewhere on the page that the field belongs to.\n   */\n  form?: string\n  /**\n   * The smallest unit shown and edited.\n   *\n   * @default 'minute'\n   */\n  granularity?: 'hour' | 'minute' | 'second'\n  /**\n   * A description for the field, rendered below it.\n   */\n  help?: ReactNode\n  /**\n   * Hide the time zone of a `ZonedDateTime` value.\n   */\n  hideTimeZone?: boolean\n  /**\n   * Show 12 or 24 hours. Defaults to the locale's.\n   */\n  hourCycle?: 12 | 24\n  /**\n   * Set component validation state to invalid.\n   */\n  invalid?: boolean\n  /**\n   * An error message for the field, rendered below it when `invalid` is set, and after a submit\n   * that an empty `required` field held back.\n   */\n  invalidFeedback?: ReactNode\n  /**\n   * The field's caption, rendered as a `FormLabel` that names the field.\n   */\n  label?: ReactNode\n  /**\n   * The latest time. A later one entered marks the field invalid.\n   */\n  maxValue?: TimeValue | null\n  /**\n   * The earliest time. An earlier one entered marks the field invalid.\n   */\n  minValue?: TimeValue | null\n  /**\n   * The name the value is submitted under with a form, as an ISO 8601 time (`09:30:00`).\n   */\n  name?: string\n  /**\n   * Handler that is called when the value changes: once every segment has a value, and with\n   * `null` once every segment is empty. A partly emptied field keeps its last value.\n   */\n  onChange?: (value: TimeValue | null) => void\n  /**\n   * The time the segments start from when the field is empty, such as `new Time(9)`. It also\n   * sets the type of value `onChange` receives.\n   */\n  placeholderValue?: TimeValue\n  /**\n   * Toggle the readonly state for the component.\n   */\n  readOnly?: boolean\n  /**\n   * Toggle the required state for the component. An empty required field holds its form back\n   * from submitting, takes focus and shows as invalid, with `invalidFeedback`, until it has a\n   * value or the form is reset. `invalid`, once set, and `valid` decide how it looks instead.\n   */\n  required?: boolean\n  /**\n   * Show a leading zero on the hour, as `09:30` rather than `9:30`, whatever the locale does.\n   */\n  shouldForceLeadingZeros?: boolean\n  /**\n   * Size the component sm or lg.\n   */\n  size?: 'sm' | 'lg'\n  /**\n   * Set component validation state to valid.\n   */\n  valid?: boolean\n  /**\n   * A success message for the field, rendered below it when `valid` is set.\n   */\n  validFeedback?: ReactNode\n  /**\n   * The value of the field, controlled: a `Time`, or a `CalendarDateTime` or `ZonedDateTime`\n   * whose date is kept. `null` for an empty field.\n   */\n  value?: TimeValue | null\n}\n\ntype FieldProps = AriaTimeFieldProps<TimeValue>\n\n// A time as `DateField` renders a date for the date pickers: a `.form-input` holding one editable\n// segment per unit, with the segments' styles shared (`DateSegment`). The `.form-input` is the\n// field's group, named by the label; each segment is a spin button named by its unit and the\n// label.\nexport const TimeField = forwardRef<HTMLDivElement, TimeFieldProps>(\n  (\n    {\n      autoFocus,\n      className,\n      defaultValue,\n      disabled,\n      form,\n      granularity,\n      help,\n      hideTimeZone,\n      hourCycle,\n      id,\n      invalid,\n      invalidFeedback,\n      label,\n      maxValue,\n      minValue,\n      name,\n      onBlur,\n      onChange,\n      onFocus,\n      onKeyDown,\n      onKeyUp,\n      placeholderValue,\n      readOnly,\n      required,\n      shouldForceLeadingZeros,\n      size,\n      valid: validProp,\n      validFeedback,\n      value,\n      ...rest\n    },\n    ref\n  ) => {\n    const fieldRef = useRef<HTMLDivElement>(null)\n    const forkedRef = useForkedRef(ref, fieldRef)\n    const inputRef = useRef<HTMLInputElement>(null)\n    const { locale } = useLocale()\n\n    // `required` has to reach an input a form validates (FORMS.md, gotcha 9), and react-aria\n    // writes `aria-required` on the segments alone: an empty required field was submitted. The\n    // segments aren't form controls, and the input that carries the value is `type=\"hidden\"`,\n    // which is barred from constraint validation. So a required field's input is a text input\n    // that isn't displayed (`useRequiredValueInput`), the one react-aria itself renders under\n    // `validationBehavior: 'native'`. That behavior isn't turned on: it also holds a form back\n    // for `invalid` and for a time outside `minValue`/`maxValue`, and shows the latter on blur\n    // where it shows as typed now. The browser has no bubble to show on an input that isn't\n    // displayed: the first segment takes focus in its place, and `missing` marks the field\n    // invalid, as `invalid` does, until it has a value. react-aria's listener on `inputRef` focuses\n    // it too, but only the input it was first given: one that `renderFormField` mounts anew, once\n    // a `label` or `help` comes, is never heard by it. A disabled input isn't validated, and a\n    // read-only field can't be filled in, so it keeps the hidden one.\n    const {\n      inputProps: requiredInputProps,\n      missing,\n      valid\n    } = useRequiredValueInput(inputRef, {\n      focus: () => focusFirstSegment(fieldRef.current),\n      invalid,\n      required: required && !readOnly,\n      valid: validProp\n    })\n\n    // `label` stays out, as the other fields keep it: react-aria would name the field by a label\n    // element of its own, which this component doesn't render.\n    // `inputRef` is the hidden input's: react-aria resets the field with that input's form and\n    // reports validity through it, as react-aria-components passes it, outside the public type.\n    const baseProps: FieldProps & { inputRef: typeof inputRef } = {\n      'aria-label': rest['aria-label'],\n      autoFocus,\n      defaultValue,\n      form,\n      granularity,\n      hideTimeZone,\n      hourCycle,\n      inputRef,\n      isDisabled: disabled,\n      // `false` would override react-aria's own range check: react-stately takes a defined\n      // `isInvalid` as the whole validation state.\n      isInvalid: invalid || missing || undefined,\n      isReadOnly: readOnly,\n      isRequired: required,\n      maxValue,\n      minValue,\n      name,\n      onBlur: onBlur as FieldProps['onBlur'],\n      onChange,\n      onFocus: onFocus as FieldProps['onFocus'],\n      onKeyDown: onKeyDown as FieldProps['onKeyDown'],\n      onKeyUp: onKeyUp as FieldProps['onKeyUp'],\n      placeholderValue,\n      shouldForceLeadingZeros,\n      value\n    }\n    const state = useTimeFieldState({ ...baseProps, locale })\n    // A time outside `minValue`/`maxValue` is invalid too, shown as `invalid` is, and so is a\n    // `missing` one, which the state was given: it knows before the ids are built, so the feedback\n    // describes the field either way.\n    const showInvalid = invalid || state.displayValidation.isInvalid\n    // A time outside the range isn't valid, whatever `valid` says.\n    const showValid = valid && !showInvalid\n\n    const { describedBy, feedbackId, helpId, inputId, labelId, labelledBy } = useFormField({\n      ariaDescribedBy: rest['aria-describedby'],\n      ariaLabelledBy: rest['aria-labelledby'],\n      help,\n      id,\n      invalid: showInvalid,\n      invalidFeedback,\n      label,\n      valid: showValid,\n      validFeedback\n    })\n\n    const {\n      descriptionProps,\n      errorMessageProps,\n      fieldProps: groupProps,\n      inputProps\n    } = useTimeField(\n      { ...baseProps, 'aria-describedby': describedBy, 'aria-labelledby': labelledBy, id: inputId },\n      state,\n      fieldRef\n    )\n\n    // The field's `aria-describedby` from react-aria holds its description of the value, added\n    // once mounted, and the help and feedback given to it; the slot ids come out (FORMS.md, gotcha\n    // 6). It's set again after the spread, where the caller's own value would replace it (gotcha\n    // 4).\n    const group = withoutSlotIds(groupProps, descriptionProps, errorMessageProps)\n\n    return renderFormField({\n      children: (\n        <>\n          <div\n            {...mergeProps(group, rest)}\n            aria-describedby={group['aria-describedby']}\n            aria-labelledby={labelledBy}\n            className={classNames(\n              'form-input',\n              'time-field',\n              size,\n              { disabled },\n              validationClassName(showInvalid, showValid),\n              className\n            )}\n            ref={forkedRef}\n            style={{ ...group.style, ...rest.style }}\n          >\n            <div className=\"datepicker-field\">\n              {state.segments.map((segment, index) => (\n                <DateSegment\n                  fieldLabelledBy={labelledBy}\n                  // eslint-disable-next-line react/no-array-index-key\n                  key={index}\n                  segment={segment}\n                  slots={[descriptionProps, errorMessageProps]}\n                  state={state}\n                />\n              ))}\n            </div>\n          </div>\n          <input {...inputProps} {...requiredInputProps} ref={inputRef} />\n        </>\n      ),\n      help,\n      ids: { feedback: feedbackId, help: helpId, label: labelId },\n      invalid: showInvalid,\n      invalidFeedback,\n      label,\n      valid: showValid,\n      validFeedback\n    })\n  }\n)\n\nTimeField.displayName = 'TimeField'\n"],"mappings":"A,8jBAwIA,MAAaS,EAAYC,GAErB,CACE,YACA,YACA,eACA,WACA,OACA,eACA,OACA,gBACA,aACA,MACA,UACA,kBACA,QACA,WACA,WACA,OACA,SACA,WACA,UACA,YACA,UACA,mBACA,WACA,WACA,0BACA,OACA,MAAOC,EACP,gBACA,QACA,GAAGC,GAEL,IACG,CACH,IAAMC,EAAWC,EAAuB,IAAI,EACtCC,EAAYC,EAAaC,EAAKJ,CAAQ,EACtCK,EAAWJ,EAAyB,IAAI,EACxC,CAAE,UAAWK,EAAU,EAevB,CACJ,WAAYC,EACZ,UACA,SACElB,EAAsBgB,EAAU,CAClC,UAAab,EAAkBQ,EAAS,OAAO,EAC/C,UACA,SAAUQ,GAAY,CAACC,EACvB,MAAOX,CACT,CAAC,EAMKY,EAAwD,CAC5D,aAAcX,EAAK,cACnB,YACA,eACA,OACA,eACA,gBACA,aACA,WACA,WAAYY,EAGZ,UAAWC,GAAWC,GAAW,IAAA,GACjC,WAAYJ,EACZ,WAAYD,EACZ,WACA,WACA,OACQ,SACR,WACS,UACE,YACF,UACT,mBACA,0BACA,OACF,EACMM,EAAQC,EAAkB,CAAE,GAAGL,EAAW,QAAO,CAAC,EAIlDM,EAAcJ,GAAWE,EAAM,kBAAkB,UAEjDG,EAAYC,GAAS,CAACF,EAEtB,CAAE,eAAa,cAAY,UAAQ,WAAS,WAAS,cAAe5B,GAAa,CACrF,gBAAiBW,EAAK,oBACtB,eAAgBA,EAAK,mBACrB,OACA,MACA,QAASiB,EACT,kBACA,QACA,MAAOC,EACP,eACF,CAAC,EAEK,CACJ,mBACA,oBACA,WAAYE,GACZ,eACEC,EACF,CAAE,GAAGV,EAAW,mBAAoBW,GAAa,kBAAmBC,EAAY,GAAIC,EAAQ,EAC5FT,EACAd,CACF,EAMMwB,EAAQrC,EAAegC,GAAYM,EAAkBC,CAAiB,EAE5E,OAAOpC,EAAgB,CACrB,SACE,kBAAA,cAAAI,EAAA,SAAA,KACE,kBAAA,cAAC,MAAD,CACE,GAAIiC,EAAWH,EAAOzB,CAAI,EAC1B,mBAAkByB,EAAM,oBACxB,kBAAiBF,EACjB,UAAW3B,EACT,aACA,aACAiC,EACA,CAAE,UAAS,EACXrC,GAAoByB,EAAaC,CAAS,EAC1CY,CACF,EACA,IAAK3B,EACL,MAAO,CAAE,GAAGsB,EAAM,MAAO,GAAGzB,EAAK,KAAM,CAcpC,EAZH,kBAAA,cAAC,MAAD,CAAK,UAAU,kBAWV,EAVFe,EAAM,SAAS,KAAK,EAAS,IAC5B,kBAAA,cAACrB,GAAD,CACE,gBAAiB6B,EAEjB,IAAKQ,EACI,UACT,MAAO,CAACL,EAAkBC,CAAiB,EACpC,OACR,CAAA,CACF,CACE,CACF,EACL,kBAAA,cAAC,QAAD,CAAO,GAAIK,GAAY,GAAIxB,EAAoB,IAAKF,CAAW,CAAA,CAC/D,EAEJ,OACA,IAAK,CAAE,SAAU2B,GAAY,KAAMC,GAAQ,MAAOC,EAAQ,EAC1D,QAASlB,EACT,kBACA,QACA,MAAOC,EACP,eACF,CAAC,CACH,CACF,EAEA,EAAU,YAAc,Y"}

package/dist/chunks/toast-Dd0J2e1z.js

@@ -0,0 +1,2 @@
+import"./focus-ring-Bs80iIBN.js";import{t as e}from"./polymorphic-CZIFszAy.js";import{n as t,r as n,t as r}from"./useToastRegionQueue-CuAMxAIA.js";import{t as i}from"./Icon-Dk5_q79o.js";import{n as a}from"./iconSlot-DU_WcSL_.js";import{t as o}from"./Portal-BTDylxAi.js";import{t as s}from"./CloseButton-BPUI5iGX.js";import c,{createContext as l,forwardRef as u,useContext as d}from"react";import f from"classnames";import{mergeProps as p}from"react-aria";import{ToastQueue as m}from"react-stately";const h=l({close:()=>{}}),g=()=>d(h);function _({children:e,className:t,closeButton:n,closeLabel:r,component:i,...a},o){let{close:l}=g(),u=i??`div`,d=f(`toast-body`,{"d-flex align-items-start justify-content-between gap-sm":n},t);return/* @__PURE__ */ c.createElement(u,{className:d,...a,ref:o},n?/* @__PURE__ */ c.createElement(`div`,null,e):e,n&&/* @__PURE__ */ c.createElement(s,{label:r,onClick:l}))}const v=e(_,`ToastBody`);function y({children:e,className:t,component:n,...r},i){let a=n??`div`,o=f(`toast-footer`,t);return/* @__PURE__ */ c.createElement(a,{className:o,...r,ref:i},e)}const b=e(y,`ToastFooter`);function x({children:e,className:t,closeButton:n,closeLabel:r,component:i,icon:o,time:l,titleId:u,...d},p){let{close:m}=g(),h=i??`div`,_=f(`toast-header`,t);return/* @__PURE__ */ c.createElement(h,{className:_,...d,ref:p},o!=null&&(typeof o==`string`?/* @__PURE__ */ c.createElement(`span`,{"aria-hidden":`true`,className:`me-sm`},/* @__PURE__ */ c.createElement(a,{value:o,className:`toast-icon`})):/* @__PURE__ */ c.createElement(`span`,{className:`me-sm`},o)),e!=null&&/* @__PURE__ */ c.createElement(`strong`,{id:u,className:`me-auto`},e),l!=null&&/* @__PURE__ */ c.createElement(`small`,null,l),n&&/* @__PURE__ */ c.createElement(s,{label:r,onClick:m}))}const S=e(x,`ToastHeader`),C=u(({children:e,animation:r=!0,autohide:i=!0,className:a,closeButton:o,closeLabel:s,color:l,defaultVisible:u=!1,delay:d=5e3,footer:m,icon:g,message:_,role:y=`status`,solid:x,time:C,title:w,translucent:T,visible:E,onClose:D,onShow:O,onVisibleChange:k,...A},j)=>{let{close:M,entered:N,forkedRef:P,isMounted:F,textId:I,titleId:L,transitionClass:R,visible:z}=t({defaultVisible:u,displayName:`Toast`,onClose:D,onShow:O,onVisibleChange:k,ref:j,visible:E}),B=n({enabled:i,delay:d,visible:z&&N,onHide:M}),V={visible:z,close:M},H=f(`toast`,{fade:r,context:!!l,solid:!!(x&&l),translucent:T},l,a),U=g!=null||w!=null||C!=null,W=o&&(U||_==null),G=o&&!U&&_!=null,K=U||W;return F?/* @__PURE__ */ c.createElement(h.Provider,{value:V},/* @__PURE__ */ c.createElement(`div`,{className:f(H,R),role:y,"aria-labelledby":w==null?void 0:L,"aria-describedby":w!=null&&_!=null?I:void 0,...p(A,B),ref:P},K&&/* @__PURE__ */ c.createElement(S,{icon:g,time:C,titleId:w==null?void 0:L,closeButton:W,closeLabel:s},w),_!=null&&/* @__PURE__ */ c.createElement(v,{id:w!=null&&_!=null?I:void 0,closeButton:G,closeLabel:s},_),e,m!=null&&/* @__PURE__ */ c.createElement(b,null,typeof m==`function`?m(M):m))):null});C.displayName=`Toast`;const w=u(({className:e,...t},n)=>{let r=f(`toast-icon`,e);return/* @__PURE__ */ c.createElement(i,{className:r,...t,ref:n})});w.displayName=`ToastIcon`;const T=new m;function E(e,t={}){return T.add({children:e,...t})}function D(e){T.close(e)}const O=u(({children:e,className:t,placement:n,...i},a)=>{let{forkedRef:s,regionProps:l,state:u}=r(T,a),d=f(`toaster toast-container p-md`,{"position-fixed":n,"position-static":!n,"top-0":n&&n.includes(`top`),"top-50 translate-middle-y":n&&n.includes(`middle`),"bottom-0":n&&n.includes(`bottom`),"start-0":n&&n.includes(`start`),"start-50 translate-middle-x":n&&n.includes(`center`),"end-0":n&&n.includes(`end`)},t),p=t=>u.visibleToasts.length>0||e?/* @__PURE__ */ c.createElement(`div`,{className:d,...l,...i,ref:t},e,u.visibleToasts.map(e=>{let{children:t,...n}=e.content;return/* @__PURE__ */ c.createElement(C,{key:e.key,defaultVisible:!0,...n,onClose:()=>u.close(e.key)},t)})):null;return n?/* @__PURE__ */ c.createElement(o,null,p(s)):p(s)});O.displayName=`Toaster`;export{w as a,b as c,T as i,v as l,E as n,C as o,D as r,S as s,O as t,g as u};
+//# sourceMappingURL=toast-Dd0J2e1z.js.map

package/dist/chunks/toast-Dd0J2e1z.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast-Dd0J2e1z.js","names":["createPolymorphicComponent","useDismissibleTransition","useAutoDismiss","useToastRegionQueue","Icon","ResolvedIcon","Portal","CloseButton","React","classNames","ToastContext","createContext","useToast","useContext","ToastBodyRender","rest","Component","component","_className","closeButton","className","children","closeLabel","close","ToastBody","ToastFooterRender","ToastFooter","ToastHeaderRender","icon","titleId","time","ToastHeader","Toast","forwardRef","_visible","autoDismissProps","autohide","entered","contextValues","animation","color","solid","hasHeaderShorthand","title","headerGetsCloseButton","message","bodyGetsCloseButton","hasHeaderContent","isMounted","transitionClass","textId","mergeProps","forkedRef","footer","ToastIcon","toastQueue","ToastQueue","addToast","options","closeToast","key","Toaster","ref","placement","toaster","state","regionProps","toasterRef","toastChildren","toastProps","queued"],"sources":["../../src/components/toast/context.ts","../../src/components/toast/useToast.ts","../../src/components/toast/ToastBody.tsx","../../src/components/toast/ToastFooter.tsx","../../src/components/toast/ToastHeader.tsx","../../src/components/toast/Toast.tsx","../../src/components/toast/ToastIcon.tsx","../../src/components/toast/toastQueue.ts","../../src/components/toast/Toaster.tsx"],"sourcesContent":["import { createContext } from 'react'\n\nexport interface ToastContextProps {\n  /**\n   * Whether the toast is currently visible.\n   */\n  visible?: boolean\n  /**\n   * Dismisses the toast. Wire this to any element's `onClick` — see `useToast`.\n   */\n  close: () => void\n}\n\nexport const ToastContext = createContext<ToastContextProps>({ close: () => {} })\n","import { useContext } from 'react'\nimport { ToastContext, ToastContextProps } from './context'\n\nexport type UseToastResult = ToastContextProps\n\n// Reach the enclosing `Toast`'s dismiss handler from anywhere in its composed markup — e.g. to\n// close it from a plain `Button` placed in a `ToastFooter`, instead of a dedicated close\n// component. Only meaningful inside a `Toast`; outside one it returns a no-op `close`.\nexport const useToast = (): UseToastResult => useContext(ToastContext)\n","import React, { ElementType, ForwardRefRenderFunction, ReactElement } from 'react'\nimport classNames from 'classnames'\n\nimport { CloseButton } from '../close-button/CloseButton'\nimport { useToast } from './useToast'\nimport {\n  createPolymorphicComponent,\n  PolymorphicComponentProps,\n  PolymorphicRef\n} from '../../utils/polymorphic'\n\ntype ToastBodyOwnProps<C extends ElementType> = {\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n  /**\n   * Adds a close button alongside the body content, so a toast composed without a\n   * `ToastHeader` still gets a dismiss control without any manual layout markup.\n   */\n  closeButton?: boolean\n  /**\n   * Overrides the close button's accessible name (defaults to `'Close'`). Set this for\n   * non-English UIs.\n   */\n  closeLabel?: string\n  /**\n   * Component used for the root node. Either a string to use a HTML element or a component.\n   */\n  component?: C\n}\n\nexport type ToastBodyProps<C extends ElementType = 'div'> = PolymorphicComponentProps<\n  C,\n  ToastBodyOwnProps<C>\n>\n\ntype ToastBodyComponent = (<C extends ElementType = 'div'>(\n  props: ToastBodyProps<C> & { ref?: PolymorphicRef<C> }\n) => ReactElement | null) & { displayName?: string }\n\nfunction ToastBodyRender<C extends ElementType = 'div'>(\n  { children, className, closeButton, closeLabel, component, ...rest }: ToastBodyProps<C>,\n  ref: PolymorphicRef<C>\n) {\n  const { close } = useToast()\n  const Component = component ?? 'div'\n  const _className = classNames(\n    'toast-body',\n    { 'd-flex align-items-start justify-content-between gap-sm': closeButton },\n    className\n  )\n  return (\n    <Component className={_className} {...rest} ref={ref}>\n      {closeButton ? <div>{children}</div> : children}\n      {closeButton && <CloseButton label={closeLabel} onClick={close} />}\n    </Component>\n  )\n}\n\nexport const ToastBody = createPolymorphicComponent<ToastBodyComponent>(\n  ToastBodyRender as ForwardRefRenderFunction<Element, ToastBodyProps<ElementType>>,\n  'ToastBody'\n)\n","import React, { ElementType, ForwardRefRenderFunction, ReactElement } from 'react'\nimport classNames from 'classnames'\n\nimport {\n  createPolymorphicComponent,\n  PolymorphicComponentProps,\n  PolymorphicRef\n} from '../../utils/polymorphic'\n\ntype ToastFooterOwnProps<C extends ElementType> = {\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n  /**\n   * Component used for the root node. Either a string to use a HTML element or a component.\n   */\n  component?: C\n}\n\nexport type ToastFooterProps<C extends ElementType = 'div'> = PolymorphicComponentProps<\n  C,\n  ToastFooterOwnProps<C>\n>\n\ntype ToastFooterComponent = (<C extends ElementType = 'div'>(\n  props: ToastFooterProps<C> & { ref?: PolymorphicRef<C> }\n) => ReactElement | null) & { displayName?: string }\n\nfunction ToastFooterRender<C extends ElementType = 'div'>(\n  { children, className, component, ...rest }: ToastFooterProps<C>,\n  ref: PolymorphicRef<C>\n) {\n  const Component = component ?? 'div'\n  const _className = classNames('toast-footer', className)\n\n  return (\n    <Component className={_className} {...rest} ref={ref}>\n      {children}\n    </Component>\n  )\n}\n\nexport const ToastFooter = createPolymorphicComponent<ToastFooterComponent>(\n  ToastFooterRender as ForwardRefRenderFunction<Element, ToastFooterProps<ElementType>>,\n  'ToastFooter'\n)\n","import React, { ElementType, ForwardRefRenderFunction, ReactElement, ReactNode } from 'react'\nimport classNames from 'classnames'\n\nimport { CloseButton } from '../close-button/CloseButton'\nimport { useToast } from './useToast'\nimport {\n  createPolymorphicComponent,\n  PolymorphicComponentProps,\n  PolymorphicRef\n} from '../../utils/polymorphic'\nimport { ResolvedIcon } from '../icon/iconSlot'\n\ntype ToastHeaderOwnProps<C extends ElementType> = {\n  /**\n   * Heading, rendered before `time` as a `<strong>`.\n   */\n  children?: ReactNode\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n  /**\n   * Automatically add a close button to the header.\n   */\n  closeButton?: boolean\n  /**\n   * Overrides the close button's accessible name (defaults to `'Close'`). Set this for\n   * non-English UIs.\n   */\n  closeLabel?: string\n  /**\n   * Component used for the root node. Either a string to use a HTML element or a component.\n   */\n  component?: C\n  /**\n   * Leading icon. A string is an icon name, rendered like `<ToastIcon name={icon} />` (or by\n   * `IconProvider`'s `component`) and hidden from\n   * assistive technology by default, since it duplicates the heading visually. Pass any other\n   * node for a fully custom icon (typically a logo or avatar) — a custom node is left as-is,\n   * since it may carry its own meaningful accessible name (e.g. an avatar's `alt` text).\n   */\n  icon?: string | ReactNode\n  /**\n   * Trailing timestamp, rendered after the heading.\n   */\n  time?: ReactNode\n  /**\n   * Sets the `id` on the rendered heading element, for `aria-labelledby` wiring. Set\n   * automatically by `Toast` when both `title` and `message` are used together; only needed\n   * here for manual wiring in a fully custom composition.\n   */\n  titleId?: string\n}\n\nexport type ToastHeaderProps<C extends ElementType = 'div'> = PolymorphicComponentProps<\n  C,\n  ToastHeaderOwnProps<C>\n>\n\ntype ToastHeaderComponent = (<C extends ElementType = 'div'>(\n  props: ToastHeaderProps<C> & { ref?: PolymorphicRef<C> }\n) => ReactElement | null) & { displayName?: string }\n\nfunction ToastHeaderRender<C extends ElementType = 'div'>(\n  {\n    children,\n    className,\n    closeButton,\n    closeLabel,\n    component,\n    icon,\n    time,\n    titleId,\n    ...rest\n  }: ToastHeaderProps<C>,\n  ref: PolymorphicRef<C>\n) {\n  const { close } = useToast()\n  const Component = component ?? 'div'\n  const _className = classNames('toast-header', className)\n  return (\n    <Component className={_className} {...rest} ref={ref}>\n      {icon != null &&\n        (typeof icon === 'string' ? (\n          <span aria-hidden=\"true\" className=\"me-sm\">\n            <ResolvedIcon value={icon} className=\"toast-icon\" />\n          </span>\n        ) : (\n          <span className=\"me-sm\">{icon}</span>\n        ))}\n      {children != null && (\n        <strong id={titleId} className=\"me-auto\">\n          {children}\n        </strong>\n      )}\n      {time != null && <small>{time}</small>}\n      {closeButton && <CloseButton label={closeLabel} onClick={close} />}\n    </Component>\n  )\n}\n\nexport const ToastHeader = createPolymorphicComponent<ToastHeaderComponent>(\n  ToastHeaderRender as ForwardRefRenderFunction<Element, ToastHeaderProps<ElementType>>,\n  'ToastHeader'\n)\n","import React, { forwardRef, HTMLAttributes, ReactNode } from 'react'\nimport { mergeProps } from 'react-aria'\nimport classNames from 'classnames'\n\nimport { ContextColor } from '../../types'\nimport { useAutoDismiss, useDismissibleTransition } from '../../hooks'\nimport { ToastContext } from './context'\nimport { ToastBody } from './ToastBody'\nimport { ToastFooter } from './ToastFooter'\nimport { ToastHeader } from './ToastHeader'\n\nexport interface ToastProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {\n  /**\n   * Apply a CSS fade transition to the toast.\n   */\n  animation?: boolean\n  /**\n   * Auto hide the toast. The timer starts once the show transition completes and pauses\n   * while the pointer is over the toast or focus is within it.\n   */\n  autohide?: boolean\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n  /**\n   * Adds a close button — shorthand for `ToastHeader`'s/`ToastBody`'s `closeButton` prop.\n   * Placed in the header when `icon`/`title`/`time` is set; otherwise placed in the body\n   * alongside `message`, or in a header containing only the close button if `message` is\n   * also unset.\n   */\n  closeButton?: boolean\n  /**\n   * Overrides the close button's accessible name (defaults to `'Close'`). Set this for\n   * non-English UIs. Shorthand for `ToastHeader`'s `closeLabel` prop.\n   */\n  closeLabel?: string\n  /**\n   * Sets the color of the component to one of Chassis context colors.\n   */\n  color?: ContextColor\n  /**\n   * Whether the toast is shown when it first renders. Such a toast is uncontrolled: its close\n   * button and the `autohide` timer hide it. Use `visible` to show and hide it from outside.\n   */\n  defaultVisible?: boolean\n  /**\n   * Delay hiding the toast (ms).\n   */\n  delay?: number\n  /**\n   * Trailing content — typically a row of `Button`s — rendered via a single `ToastFooter`,\n   * after `message`/`children`. Pass a function to receive `close` directly, instead of\n   * calling `useToast()` from a child component to wire up a \"Close\" action.\n   */\n  footer?: ReactNode | ((close: () => void) => ReactNode)\n  /**\n   * Leading icon for the header. A string is an icon name, rendered like\n   * `<ToastIcon name={icon} />` (or by `IconProvider`'s `component`); pass\n   * any other node for a fully custom icon (typically a logo or avatar). Shorthand for\n   * `ToastHeader`'s `icon` prop; hidden from assistive technology by default, since it\n   * duplicates `title` visually.\n   */\n  icon?: string | ReactNode\n  /**\n   * Message body, rendered via a single `ToastBody`. For multi-block content, compose\n   * `children` manually instead — `message` wraps everything in one element.\n   */\n  message?: ReactNode\n  /**\n   * Header timestamp, rendered after `title`. Shorthand for `ToastHeader`'s `time` prop.\n   */\n  time?: ReactNode\n  /**\n   * Header heading, rendered before `time`. Shorthand for `ToastHeader`'s children. When set\n   * alongside `message`, wires the toast's `aria-labelledby`/`aria-describedby` to them\n   * automatically.\n   */\n  title?: ReactNode\n  /**\n   * Callback fired once the toast has hidden: after its exit transition.\n   */\n  onClose?: () => void\n  /**\n   * Callback fired when the toast starts to show.\n   */\n  onShow?: () => void\n  /**\n   * Callback fired with `false` when the toast asks to hide: its close button, `close` from\n   * `useToast` or `footer`, or the `autohide` timer. With `visible` set, the toast hides only\n   * when `visible` becomes `false`.\n   */\n  onVisibleChange?: (visible: boolean) => void\n  /**\n   * ARIA live-region role. Use `status` (the default) for confirmation, progress, and\n   * informational messages, which announce politely. Use `alert` for messages that need\n   * immediate attention — validation errors, failed operations — which interrupt speech.\n   */\n  role?: 'status' | 'alert'\n  /**\n   * Apply a full-color background with inverted text. Only meaningful alongside `color`.\n   */\n  solid?: boolean\n  /**\n   * Apply a semi-transparent background.\n   */\n  translucent?: boolean\n  /**\n   * Whether the toast is shown. Setting it makes the toast controlled: it hides only when this\n   * becomes `false`, so pair it with `onVisibleChange`. Without either `visible` or\n   * `defaultVisible` a toast renders nothing.\n   */\n  visible?: boolean\n}\n\nexport const Toast = forwardRef<HTMLDivElement, ToastProps>(\n  (\n    {\n      children,\n      animation = true,\n      autohide = true,\n      className,\n      closeButton,\n      closeLabel,\n      color,\n      defaultVisible = false,\n      delay = 5000,\n      footer,\n      icon,\n      message,\n      role = 'status',\n      solid,\n      time,\n      title,\n      translucent,\n      visible,\n      onClose,\n      onShow,\n      onVisibleChange,\n      ...rest\n    },\n    ref\n  ) => {\n    const {\n      close,\n      entered,\n      forkedRef,\n      isMounted,\n      textId,\n      titleId,\n      transitionClass,\n      visible: _visible\n    } = useDismissibleTransition({\n      defaultVisible,\n      displayName: 'Toast',\n      onClose,\n      onShow,\n      onVisibleChange,\n      ref,\n      visible\n    })\n\n    // The autohide timer is only meaningful once the show transition has actually finished (see\n    // `autohide`'s JSDoc) — gating on `_visible` alone would start it the instant the toast is\n    // asked to show, while it is still fading/sliding in.\n    const autoDismissProps = useAutoDismiss({\n      enabled: autohide,\n      delay,\n      visible: _visible && entered,\n      onHide: close\n    })\n\n    const contextValues = {\n      visible: _visible,\n      close\n    }\n\n    const _className = classNames(\n      'toast',\n      {\n        fade: animation,\n        context: !!color,\n        solid: Boolean(solid && color),\n        translucent\n      },\n      color,\n      className\n    )\n\n    const hasHeaderShorthand = icon != null || title != null || time != null\n    const headerGetsCloseButton = closeButton && (hasHeaderShorthand || message == null)\n    const bodyGetsCloseButton = closeButton && !hasHeaderShorthand && message != null\n    const hasHeaderContent = hasHeaderShorthand || headerGetsCloseButton\n\n    if (!isMounted) return null\n\n    return (\n      <ToastContext.Provider value={contextValues}>\n        <div\n          className={classNames(_className, transitionClass)}\n          role={role}\n          aria-labelledby={title != null ? titleId : undefined}\n          aria-describedby={title != null && message != null ? textId : undefined}\n          {...mergeProps(rest, autoDismissProps)}\n          ref={forkedRef}\n        >\n          {hasHeaderContent && (\n            <ToastHeader\n              icon={icon}\n              time={time}\n              titleId={title != null ? titleId : undefined}\n              closeButton={headerGetsCloseButton}\n              closeLabel={closeLabel}\n            >\n              {title}\n            </ToastHeader>\n          )}\n          {message != null && (\n            <ToastBody\n              id={title != null && message != null ? textId : undefined}\n              closeButton={bodyGetsCloseButton}\n              closeLabel={closeLabel}\n            >\n              {message}\n            </ToastBody>\n          )}\n          {children}\n          {footer != null && (\n            <ToastFooter>{typeof footer === 'function' ? footer(close) : footer}</ToastFooter>\n          )}\n        </div>\n      </ToastContext.Provider>\n    )\n  }\n)\n\nToast.displayName = 'Toast'\n","import React, { forwardRef } from 'react'\nimport classNames from 'classnames'\n\nimport { Icon, IconProps } from '../icon/Icon'\n\nexport type ToastIconProps = IconProps & {\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n}\n\nexport const ToastIcon = forwardRef<HTMLSpanElement | SVGSVGElement, ToastIconProps>(\n  ({ className, ...rest }, ref) => {\n    const _className = classNames('toast-icon', className)\n\n    return <Icon className={_className} {...rest} ref={ref} />\n  }\n)\n\nToastIcon.displayName = 'ToastIcon'\n","import { ReactNode } from 'react'\nimport { ToastQueue } from 'react-stately'\n\nimport { ToastProps } from './Toast'\n\n// What `Toaster` spreads onto the `<Toast>` it renders for a queued toast: every `Toast` prop\n// that describes the toast itself. The queue owns whether it is shown.\nexport interface ToastContent extends Pick<\n  ToastProps,\n  | 'animation'\n  | 'autohide'\n  | 'closeButton'\n  | 'closeLabel'\n  | 'color'\n  | 'delay'\n  | 'footer'\n  | 'icon'\n  | 'message'\n  | 'role'\n  | 'solid'\n  | 'time'\n  | 'title'\n  | 'translucent'\n> {\n  /**\n   * Content of the toast. Compose manually (typically a `ToastHeader`/`ToastBody`/\n   * `ToastFooter`), or leave empty and use the `title`/`message`/`footer` shorthand options\n   * instead.\n   */\n  children?: ReactNode\n}\n\n// The queue backing `Toaster` — a module-level singleton so `addToast()` is callable from\n// anywhere (an event handler, an async callback) without threading a `push` prop through\n// render. `Toaster` subscribes to it via `useToastQueue`; nothing renders until a\n// `<Toaster />` is actually mounted somewhere to display the queue's contents.\nexport const toastQueue = new ToastQueue<ToastContent>()\n\n// Adds a toast to the queue. Returns the toast's key, which can be passed to `closeToast` to\n// dismiss it programmatically. `children` is optional — omit it for a toast composed entirely\n// from the `title`/`message`/`footer` shorthand options.\nexport function addToast(\n  children?: ReactNode,\n  options: Omit<ToastContent, 'children'> = {}\n): string {\n  return toastQueue.add({ children, ...options })\n}\n\n// Removes a queued toast immediately, bypassing its own exit animation.\nexport function closeToast(key: string): void {\n  toastQueue.close(key)\n}\n","import React, { forwardRef, HTMLAttributes } from 'react'\nimport classNames from 'classnames'\n\nimport { useToastRegionQueue } from '../../hooks'\nimport { Portal } from '../portal/Portal'\nimport { Toast } from './Toast'\nimport { toastQueue } from './toastQueue'\n\nexport interface ToasterProps extends HTMLAttributes<HTMLDivElement> {\n  /**\n   * Overrides the toast region's accessible name (defaults to `'Notifications'`, per\n   * react-aria). Set this for non-English UIs, or to distinguish multiple toasters on the\n   * same page.\n   */\n  'aria-label'?: string\n  /**\n   * A string of all className you want applied to the base component.\n   */\n  className?: string\n  /**\n   * Describes the placement of your component.\n   *\n   * @type 'top-start' | 'top-center' | 'top-end' | 'middle-start' | 'middle-center' | 'middle-end' | 'bottom-start' | 'bottom-center' | 'bottom-end' | string\n   */\n  placement?:\n    | 'top-start'\n    | 'top-center'\n    | 'top-end'\n    | 'middle-start'\n    | 'middle-center'\n    | 'middle-end'\n    | 'bottom-start'\n    | 'bottom-center'\n    | 'bottom-end'\n    | string\n}\n\n// Renders the shared `toastQueue` (see `toastQueue.ts` — `addToast()` is how toasts get added\n// to it from anywhere in the app) plus any statically-passed `children`, e.g. a permanently\n// pinned toast alongside dynamic ones.\nexport const Toaster = forwardRef<HTMLDivElement, ToasterProps>(\n  ({ children, className, placement, ...rest }, ref) => {\n    const { forkedRef, regionProps, state } = useToastRegionQueue(toastQueue, ref)\n\n    const _className = classNames(\n      'toaster toast-container p-md',\n      {\n        'position-fixed': placement,\n        'position-static': !placement,\n        'top-0': placement && placement.includes('top'),\n        'top-50 translate-middle-y': placement && placement.includes('middle'),\n        'bottom-0': placement && placement.includes('bottom'),\n        'start-0': placement && placement.includes('start'),\n        'start-50 translate-middle-x': placement && placement.includes('center'),\n        'end-0': placement && placement.includes('end')\n      },\n      className\n    )\n\n    const toaster = (toasterRef?: React.Ref<HTMLDivElement>) => {\n      return state.visibleToasts.length > 0 || children ? (\n        <div className={_className} {...regionProps} {...rest} ref={toasterRef}>\n          {children}\n          {state.visibleToasts.map((queued) => {\n            const { children: toastChildren, ...toastProps } = queued.content\n            return (\n              <Toast\n                key={queued.key}\n                defaultVisible\n                {...toastProps}\n                onClose={() => state.close(queued.key)}\n              >\n                {toastChildren}\n              </Toast>\n            )\n          })}\n        </div>\n      ) : null\n    }\n\n    // A placed region is portaled to `document.body`, on the server as on the client: it renders\n    // nothing until hydration has finished, instead of rendering inline on the server and moving\n    // on the client, which discarded the server's markup.\n    return placement ? <Portal>{toaster(forkedRef)}</Portal> : toaster(forkedRef)\n  }\n)\n\nToaster.displayName = 'Toaster'\n"],"mappings":"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"}

package/dist/chunks/tooltip-CmKeQwYw.js

@@ -0,0 +1,2 @@
+import"./focus-ring-Bs80iIBN.js";import{i as e,o as t}from"./slot-BQVx1Eew.js";import{t as n}from"./useForkedRef-WoqMqsWE.js";import{t as r}from"./useHydrated-Dud4JEwp.js";import{t as i}from"./useTransitionState-sQUQey74.js";import{n as a,r as o,t as s}from"./useFloatingOverlay-BuiI_CCn.js";import{t as c}from"./useOpenStateProps-BhjSQ3f6.js";import{i as l,n as u}from"./overlayPlacement-Q6bcbXA5.js";import{t as d}from"./Portal-BTDylxAi.js";import f,{forwardRef as p,useEffect as m,useRef as h}from"react";import g from"classnames";import{mergeProps as _,useOverlayPosition as v,useTooltip as y,useTooltipTrigger as b}from"react-aria";import{useTooltipTriggerState as x}from"react-stately";const S=p(function({children:p,className:S,content:C,defaultVisible:w,placement:T=`top`,offset:E=[0,6],onHide:D,onShow:O,onVisibleChange:k,style:A,trigger:j,visible:M,...N},P){let F=h(null),I=h(null),L=h(null),ee=n(P,L),R=e(p,`Tooltip`),z=x({...c({defaultVisible:w,onVisibleChange:k,visible:M},`Tooltip`),trigger:j,delay:0,closeDelay:0}),B=M!==void 0&&!k,{triggerProps:V,tooltipProps:H}=b({trigger:j},B?{...z,isOpen:!1}:z,I),{tooltipProps:U}=y({},z),W=z.open;m(()=>{z.isOpen&&W(!0)},[z.isOpen]);let G=o({close:()=>z.close(!0),isOpen:z.isOpen,onHide:D,onShow:O,triggerRef:I}),{overlayProps:K,arrowProps:q,placement:J}=v({targetRef:I,overlayRef:L,placement:l(T),offset:E[1],crossOffset:E[0],arrowSize:8,arrowRef:F,isOpen:z.isOpen}),Y={...A,position:K.style?.position,top:K.style?.top,left:K.style?.left},X=u(T,J),{isMounted:Z,phase:Q}=i({in:z.isOpen&&G!==null,mountOnEnter:!0,nodeRef:L,unmountOnExit:!0}),$=r();return/* @__PURE__ */ f.createElement(f.Fragment,null,R?t(R,_($?V:{...V,"aria-describedby":void 0},$&&B&&z.isOpen?{"aria-describedby":H.id}:{}),I):p,/* @__PURE__ */ f.createElement(d,{container:G},Z&&/* @__PURE__ */ f.createElement(`div`,{..._(H,U,N),className:g(`tooltip cx-tooltip-auto`,a(Q),S),"data-cx-placement":X,ref:ee,style:Y},/* @__PURE__ */ f.createElement(`div`,{className:`tooltip-arrow`,...q,style:s(q)}),/* @__PURE__ */ f.createElement(`div`,{className:`tooltip-inner`},C))))});S.displayName=`Tooltip`;export{S as t};
+//# sourceMappingURL=tooltip-CmKeQwYw.js.map

package/dist/chunks/tooltip-CmKeQwYw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-CmKeQwYw.js","names":["getTriggerChild","renderSlotted","useForkedRef","useHydrated","useTransitionState","getOverlayTransitionClass","useFloatingOverlay","getOverlayArrowStyle","useOpenStateProps","toAriaPlacement","resolveDataPlacement","Portal","React","classNames","Tooltip","forwardRef","offsetProp","rest","arrowRef","useRef","triggerRef","floatingRef","forkedFloatingRef","ref","triggerElement","children","state","useTooltipTriggerState","isHeld","visible","onVisibleChange","tooltipTriggerProps","useTooltipTrigger","useTooltip","registerOpen","useEffect","portalContainer","resolvedPlacement","useOverlayPosition","placement","floatingStyle","style","overlayProps","placementAttr","hydrated","mergeProps","triggerProps","isMounted","tooltipProps","phase","className","arrowProps","content"],"sources":["../../src/components/tooltip/Tooltip.tsx"],"sourcesContent":["import React, {\n  forwardRef,\n  HTMLAttributes,\n  ReactElement,\n  ReactNode,\n  useEffect,\n  useRef\n} from 'react'\nimport classNames from 'classnames'\nimport { mergeProps, useOverlayPosition, useTooltip, useTooltipTrigger } from 'react-aria'\nimport { useTooltipTriggerState } from 'react-stately'\n\nimport {\n  getOverlayArrowStyle,\n  getOverlayTransitionClass,\n  useFloatingOverlay,\n  useForkedRef,\n  useOpenStateProps,\n  useTransitionState\n} from '../../hooks'\nimport { Placement, resolveDataPlacement, toAriaPlacement } from '../../utils/overlayPlacement'\nimport { useHydrated } from '../../hooks/useHydrated'\nimport { Portal } from '../portal/Portal'\nimport { getTriggerChild, renderSlotted } from '../../utils/slot'\n\nexport type { Placement }\n\n// Every attribute besides the component's own props goes to the panel, the `.tooltip` element:\n// `className`, `style`, `id`, `data-*`, ARIA attributes and event handlers. So does the ref.\nexport interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'content'> {\n  /**\n   * The trigger: a single element, which shows the tooltip on hover and focus.\n   */\n  children: ReactElement\n  /**\n   * Content node for your component.\n   */\n  content: ReactNode | string\n  /**\n   * Whether the tooltip is shown when it first renders. Use it instead of `visible` when nothing\n   * outside needs to control the tooltip.\n   */\n  defaultVisible?: boolean\n  /**\n   * Offset of the tooltip relative to its target, as `[crossAxis, mainAxis]`.\n   */\n  offset?: [number, number]\n  /**\n   * Callback fired when the tooltip hides.\n   */\n  onHide?: () => void\n  /**\n   * Callback fired when the tooltip shows.\n   */\n  onShow?: () => void\n  /**\n   * Callback fired when the tooltip asks to show or hide: hover, focus, blur, the Escape key, or\n   * the closing of the dialog it is in. Receives the state it asks for. With `visible` set, the\n   * tooltip changes only when `visible` does.\n   */\n  onVisibleChange?: (visible: boolean) => void\n  /**\n   * Describes the preferred placement of your component. Chassis will flip it to keep it in\n   * view.\n   */\n  placement?: Placement\n  /**\n   * Tooltips always show on focus, since keyboard/screen-reader users need them too. Set to\n   * `'focus'` to disable the hover trigger and show on focus only.\n   */\n  trigger?: 'hover' | 'focus'\n  /**\n   * Whether the tooltip is shown. Setting it makes the tooltip controlled: it shows and hides\n   * only when this changes, so pair it with `onVisibleChange`. Leave it unset, or use\n   * `defaultVisible`, for a tooltip that shows and hides itself.\n   */\n  visible?: boolean\n}\n\nexport const Tooltip = forwardRef<HTMLDivElement, TooltipProps>(function Tooltip(\n  {\n    children,\n    className,\n    content,\n    defaultVisible,\n    placement = 'top',\n    offset: offsetProp = [0, 6],\n    onHide,\n    onShow,\n    onVisibleChange,\n    style,\n    trigger,\n    visible,\n    ...rest\n  },\n  ref\n) {\n  const arrowRef = useRef<HTMLDivElement>(null)\n  const triggerRef = useRef<HTMLElement | null>(null)\n  const floatingRef = useRef<HTMLDivElement>(null)\n  const forkedFloatingRef = useForkedRef(ref, floatingRef)\n\n  // The trigger is rendered as `asChild` renders a child (`renderSlotted`): `triggerProps` merge\n  // into the child's own props, so its handlers chain and its `aria-describedby` adds up, and\n  // `triggerRef` is forked with the ref the caller put on the child.\n  const triggerElement = getTriggerChild(children, 'Tooltip')\n\n  // react-stately defaults to a 1500ms warmup delay (and 500ms cooldown) before a first tooltip\n  // shows, spectrum-style — chassis-css's own JS plugin defaults to instant (`delay: 0`), so\n  // match that here rather than leaving new adopters to wonder why the first hover lags.\n  const state = useTooltipTriggerState({\n    ...useOpenStateProps({ defaultVisible, onVisibleChange, visible }, 'Tooltip'),\n    trigger,\n    delay: 0,\n    closeDelay: 0\n  })\n  // While a tooltip is open, react-aria stops every Escape at the document and closes the\n  // tooltip with it. One held open by `visible` with no `onVisibleChange` never closes, so it\n  // would swallow Escape for the whole page: a popover, a menu or a dialog beside it could no\n  // longer be closed by it. Such a tooltip is passed as closed, which is all the hook reads the\n  // state for besides `aria-describedby`, set below.\n  const isHeld = visible !== undefined && !onVisibleChange\n  const { triggerProps, tooltipProps: tooltipTriggerProps } = useTooltipTrigger(\n    { trigger },\n    isHeld ? { ...state, isOpen: false } : state,\n    triggerRef\n  )\n  const { tooltipProps } = useTooltip({}, state)\n\n  // react-stately shows one tooltip at a time, but counts only a tooltip it opened through\n  // `open()`. One shown by `visible` or `defaultVisible` joins here, so the next tooltip to open\n  // asks it to hide, and it closes the ones already open.\n  const registerOpen = state.open\n  useEffect(() => {\n    if (state.isOpen) registerOpen(true)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [state.isOpen])\n\n  // Bypasses the hook's hover-warmup delay (`close`'s `immediate` argument): a containing dialog\n  // closing applies right away.\n  const portalContainer = useFloatingOverlay({\n    close: () => state.close(true),\n    isOpen: state.isOpen,\n    onHide,\n    onShow,\n    triggerRef\n  })\n\n  const {\n    overlayProps,\n    arrowProps,\n    placement: resolvedPlacement\n  } = useOverlayPosition({\n    targetRef: triggerRef,\n    overlayRef: floatingRef,\n    placement: toAriaPlacement(placement),\n    offset: offsetProp[1],\n    crossOffset: offsetProp[0],\n    arrowSize: 8,\n    arrowRef,\n    isOpen: state.isOpen\n  })\n\n  // The caller's `style` first: the position is the component's to set.\n  const floatingStyle: React.CSSProperties = {\n    ...style,\n    position: overlayProps.style?.position as React.CSSProperties['position'],\n    top: overlayProps.style?.top,\n    left: overlayProps.style?.left\n  }\n  const placementAttr = resolveDataPlacement(placement, resolvedPlacement)\n\n  // The panel mounts once its container is known (`useFloatingOverlay`), and only there.\n  const { isMounted, phase } = useTransitionState({\n    in: state.isOpen && portalContainer !== null,\n    mountOnEnter: true,\n    nodeRef: floatingRef,\n    unmountOnExit: true\n  })\n\n  // The tooltip is portaled, so it exists only once hydration has finished: until then the\n  // trigger isn't described by it, or its HTML would refer to an id no element has.\n  const hydrated = useHydrated()\n\n  return (\n    <>\n      {triggerElement\n        ? renderSlotted(\n            triggerElement,\n            mergeProps(\n              hydrated ? triggerProps : { ...triggerProps, 'aria-describedby': undefined },\n              hydrated && isHeld && state.isOpen\n                ? { 'aria-describedby': tooltipTriggerProps.id }\n                : {}\n            ),\n            triggerRef\n          )\n        : children}\n      <Portal container={portalContainer}>\n        {isMounted && (\n          <div\n            {...mergeProps(tooltipTriggerProps, tooltipProps, rest)}\n            className={classNames(\n              'tooltip cx-tooltip-auto',\n              getOverlayTransitionClass(phase),\n              className\n            )}\n            data-cx-placement={placementAttr}\n            ref={forkedFloatingRef}\n            style={floatingStyle}\n          >\n            <div\n              className=\"tooltip-arrow\"\n              {...arrowProps}\n              style={getOverlayArrowStyle(arrowProps)}\n            ></div>\n            <div className=\"tooltip-inner\">{content}</div>\n          </div>\n        )}\n      </Portal>\n    </>\n  )\n})\n\nTooltip.displayName = 'Tooltip'\n"],"mappings":"A,orBA+EA,MAAac,EAAUC,EAAyC,SAC9D,CACE,WACA,YACA,UACA,iBACA,YAAY,MACZ,OAAQC,EAAa,CAAC,EAAG,CAAC,EAC1B,SACA,SACA,kBACA,QACA,UACA,UACA,GAAGC,GAEL,EACA,CACA,IAAMC,EAAWC,EAAuB,IAAI,EACtCC,EAAaD,EAA2B,IAAI,EAC5CE,EAAcF,EAAuB,IAAI,EACzCG,GAAoBpB,EAAaqB,EAAKF,CAAW,EAKjDG,EAAiBxB,EAAgByB,EAAU,SAAS,EAKpDC,EAAQC,EAAuB,CACnC,GAAGnB,EAAkB,CAAE,iBAAgB,kBAAiB,SAAQ,EAAG,SAAS,EAC5E,UACA,MAAO,EACP,WAAY,CACd,CAAC,EAMKoB,EAASC,IAAY,IAAA,IAAa,CAACC,EACnC,CAAE,eAAc,aAAcC,GAAwBC,EAC1D,CAAE,SAAQ,EACVJ,EAAS,CAAE,GAAGF,EAAO,OAAQ,EAAM,EAAIA,EACvCN,CACF,EACM,CAAE,gBAAiBa,EAAW,CAAC,EAAGP,CAAK,EAKvCQ,EAAeR,EAAM,KAC3BS,MAAgB,CACVT,EAAM,QAAQQ,EAAa,EAAI,CAErC,EAAG,CAACR,EAAM,MAAM,CAAC,EAIjB,IAAMU,EAAkB9B,EAAmB,CACzC,UAAaoB,EAAM,MAAM,EAAI,EAC7B,OAAQA,EAAM,OACd,SACA,SACA,YACF,CAAC,EAEK,CACJ,eACA,aACA,UAAWW,GACTC,EAAmB,CACrB,UAAWlB,EACX,WAAYC,EACZ,UAAWZ,EAAgB8B,CAAS,EACpC,OAAQvB,EAAW,GACnB,YAAaA,EAAW,GACxB,UAAW,EACX,WACA,OAAQU,EAAM,MAChB,CAAC,EAGKc,EAAqC,CACzC,GAAGC,EACH,SAAUC,EAAa,OAAO,SAC9B,IAAKA,EAAa,OAAO,IACzB,KAAMA,EAAa,OAAO,IAC5B,EACMC,EAAgBjC,EAAqB6B,EAAWF,CAAiB,EAGjE,CAAE,YAAW,SAAUjC,EAAmB,CAC9C,GAAIsB,EAAM,QAAUU,IAAoB,KACxC,aAAc,GACd,QAASf,EACT,cAAe,EACjB,CAAC,EAIKuB,EAAWzC,EAAY,EAE7B,MACE,kBAAA,cAAAS,EAAA,SAAA,KACGY,EACGvB,EACEuB,EACAqB,EACED,EAAWE,EAAe,CAAE,GAAGA,EAAc,mBAAoB,IAAA,EAAU,EAC3EF,GAAYhB,GAAUF,EAAM,OACxB,CAAE,mBAAoBK,EAAoB,EAAG,EAC7C,CAAC,CACP,EACAX,CACF,EACAK,EACJ,kBAAA,cAACd,EAAD,CAAQ,UAAWyB,CAqBX,EApBLW,GACC,kBAAA,cAAC,MAAD,CACE,GAAIF,EAAWd,EAAqBiB,EAAc/B,CAAI,EACtD,UAAWJ,EACT,0BACAR,EAA0B4C,CAAK,EAC/BC,CACF,EACA,oBAAmBP,EACnB,IAAKrB,GACL,MAAOkB,CAQJ,EANH,kBAAA,cAAC,MAAD,CACE,UAAU,gBACV,GAAIW,EACJ,MAAO5C,EAAqB4C,CAAU,CAClC,CAAA,EACN,kBAAA,cAAC,MAAD,CAAK,UAAU,eAA8B,EAAbC,CAAa,CAC1C,CAED,CACR,CAEN,CAAC,EAED,EAAQ,YAAc,U"}

package/dist/chunks/tree-DNj_EfUl.js

@@ -0,0 +1,2 @@
+import"./focus-ring-Bs80iIBN.js";import{t as e}from"./iconSlot-DU_WcSL_.js";import t,{createContext as n,forwardRef as r,useContext as i,useMemo as a,useRef as o}from"react";import s from"classnames";import{useButton as c,useCheckbox as l}from"react-aria";import{useToggleState as u}from"react-stately";import{ButtonContext as d,CheckboxContext as f,Collection as p,Tree as m,TreeItem as h,TreeItemContent as g,useContextProps as _,useSlottedContext as v}from"react-aria-components";const y=n({checkboxes:!1}),b=r(({autoFocus:e,checkboxes:n,children:r,className:i,expandIcon:o,renderEmptyState:c,selectionBehavior:l=`toggle`,selectionMode:u=`none`,...d},f)=>{let p=a(()=>({checkboxes:n??(u===`multiple`&&l===`toggle`),expandIcon:o}),[n,o,l,u]);return/* @__PURE__ */ t.createElement(y.Provider,{value:p},/* @__PURE__ */ t.createElement(m,{...d,autoFocus:e===!0?`first`:e,className:s(`tree`,i),ref:f,renderEmptyState:c&&(()=>c()),selectionBehavior:l,selectionMode:u},r))});b.displayName=`Tree`;const x=({disabled:n})=>{let{expandIcon:r}=i(y),[a,o]=_({slot:`chevron`},null,d),{buttonProps:s}=c({...a,isDisabled:n},o);return/* @__PURE__ */ t.createElement(`button`,{...s,className:`tree-item-toggle`,ref:o},/* @__PURE__ */ t.createElement(e,{className:`tree-item-toggle-icon`,icon:`expand`,override:r}))},S=()=>{let e=v(f,`selection`),n=u(e),r=o(null),{inputProps:i}=l(e,n,r);return/* @__PURE__ */ t.createElement(`input`,{...i,"aria-describedby":void 0,className:`check-input tree-item-check`,ref:r})},C=e=>/* @__PURE__ */ t.createElement(`div`,{...e,"aria-labelledby":void 0}),w=({hasChildItems:e,icon:n,isDisabled:r,label:a,selectionMode:o})=>{let{checkboxes:s}=i(y);return/* @__PURE__ */ t.createElement(t.Fragment,null,e?/* @__PURE__ */ t.createElement(x,{disabled:r}):/* @__PURE__ */ t.createElement(`span`,{className:`tree-item-spacer`}),s&&o!==`none`&&/* @__PURE__ */ t.createElement(S,null),n!=null&&/* @__PURE__ */ t.createElement(`span`,{"aria-hidden":`true`,className:`tree-item-icon`},n),/* @__PURE__ */ t.createElement(`span`,{className:`tree-item-label`},a))},T=r(({children:e,className:n,dependencies:r,disabled:i,icon:a,id:o,items:c,label:l,onAction:u,style:d,textValue:f},m)=>{let _=f??(typeof l==`string`||typeof l==`number`?String(l):``);return/* @__PURE__ */ t.createElement(h,{className:({isDisabled:e,isExpanded:t,isSelected:r})=>s(`tree-item`,{active:r,disabled:e,expanded:t},n),id:o,isDisabled:i,onAction:u,ref:m,render:C,style:({level:e})=>({...d,"--cx-tree-level":e}),textValue:_},/* @__PURE__ */ t.createElement(g,null,({hasChildItems:e,isDisabled:n,selectionMode:r})=>/* @__PURE__ */ t.createElement(w,{hasChildItems:e,icon:a,isDisabled:n,label:l,selectionMode:r})),c?/* @__PURE__ */ t.createElement(p,{dependencies:r,items:c},e):typeof e==`function`?null:e)});T.displayName=`TreeItem`;export{b as n,T as t};
+//# sourceMappingURL=tree-DNj_EfUl.js.map

package/dist/chunks/tree-DNj_EfUl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-DNj_EfUl.js","names":["AriaTree","Tree","AriaTreeItem","TreeItem","IconSlot","React","classNames","TreeConfigContext","createContext","Tree$1","forwardRef","rest","config","useMemo","checkboxes","selectionMode","selectionBehavior","expandIcon","Tree","autoFocus","className","renderEmptyState","children","TreeItemToggle","useContext","props","ref","useContextProps","ButtonContext","useButton","disabled","buttonProps","TreeItemCheckbox","useSlottedContext","CheckboxContext","state","useToggleState","useRef","useCheckbox","inputProps","renderRow","TreeItemBody","hasChildItems","isDisabled","icon","label","TreeItem$1","text","textValue","TreeItem","isSelected","isExpanded","style","level","TreeItemContent","items","Collection"],"sources":["../../src/components/tree/context.ts","../../src/components/tree/Tree.tsx","../../src/components/tree/TreeItem.tsx"],"sourcesContent":["import { createContext } from 'react'\n\nimport { IconValue } from '../../utils/iconConfig'\n\n// What a `Tree` tells its items: whether a selectable item draws a checkbox, and the chevron to\n// draw. Private to this folder: an item reads it, nothing outside the tree does.\nexport interface TreeConfig {\n  checkboxes: boolean\n  expandIcon?: IconValue\n}\n\nexport const TreeConfigContext = createContext<TreeConfig>({ checkboxes: false })\n","import React, { CSSProperties, forwardRef, ReactElement, ReactNode, Ref, useMemo } from 'react'\nimport classNames from 'classnames'\nimport { Key, Selection, Tree as AriaTree } from 'react-aria-components'\n\nimport { IconValue } from '../../utils/iconConfig'\nimport { TreeConfigContext } from './context'\nimport './Tree.scss'\n\nexport interface TreeProps<T extends object> {\n  /**\n   * An accessible name for the tree, when no visible heading names it.\n   */\n  'aria-label'?: string\n  /**\n   * The id of the visible heading that names the tree.\n   */\n  'aria-labelledby'?: string\n  /**\n   * Focus the tree when it mounts: `true` or `'first'` focuses its first item, `'last'` its last.\n   */\n  autoFocus?: boolean | 'first' | 'last'\n  /**\n   * Draw a checkbox in every item, which selects the item. On by default with\n   * `selectionMode=\"multiple\"` and the `'toggle'` selection behavior, off otherwise.\n   */\n  checkboxes?: boolean\n  /**\n   * `TreeItem` elements, or a render function called once per entry of `items`, returning that\n   * entry's `TreeItem`.\n   */\n  children: ReactNode | ((item: T) => ReactElement)\n  /**\n   * A string of all className you want applied to the component.\n   */\n  className?: string\n  /**\n   * The keys of the items expanded at first (uncontrolled).\n   */\n  defaultExpandedKeys?: Iterable<Key>\n  /**\n   * The keys of the items selected at first (uncontrolled): `'all'`, or an iterable of keys.\n   */\n  defaultSelectedKeys?: 'all' | Iterable<Key>\n  /**\n   * Values that should rebuild the items when using the `items`/render-function form of\n   * `children` — e.g. a value from outside `items` that the render function reads. Without this,\n   * changing that value won't re-render the items, which are only rebuilt when `items` or\n   * `dependencies` change by reference.\n   */\n  dependencies?: ReadonlyArray<unknown>\n  /**\n   * Whether `disabledKeys` disables every interaction with an item, or only its selection.\n   *\n   * @default 'all'\n   */\n  disabledBehavior?: 'all' | 'selection'\n  /**\n   * The keys of the items that are disabled.\n   */\n  disabledKeys?: Iterable<Key>\n  /**\n   * Keep at least one item selected: the last selected item can't be deselected.\n   */\n  disallowEmptySelection?: boolean\n  /**\n   * The keys of the expanded items (controlled).\n   */\n  expandedKeys?: Iterable<Key>\n  /**\n   * The chevron of an item with child items, in place of `IconProvider`'s `expand` icon: an icon\n   * name, or an element.\n   */\n  expandIcon?: IconValue\n  /**\n   * The id of the tree element.\n   */\n  id?: string\n  /**\n   * The data to render as items, through the function form of `children`.\n   */\n  items?: Iterable<T>\n  /**\n   * Called with an item's key when the item is activated: with Enter, or with a click when the\n   * tree has no selection. An item's own `onAction` is called too.\n   */\n  onAction?: (key: Key) => void\n  /**\n   * Called with the keys of the expanded items when an item expands or collapses.\n   */\n  onExpandedChange?: (keys: Set<Key>) => void\n  /**\n   * Called with the keys of the selected items (`'all'`, or a `Set`) when the selection changes.\n   */\n  onSelectionChange?: (keys: Selection) => void\n  /**\n   * What to render in place of the items when there are none.\n   */\n  renderEmptyState?: () => ReactNode\n  /**\n   * The keys of the selected items (controlled): `'all'`, or an iterable of keys.\n   */\n  selectedKeys?: 'all' | Iterable<Key>\n  /**\n   * How a click changes a multiple selection: `'toggle'` adds or removes the clicked item,\n   * `'replace'` selects it alone, with Ctrl, Cmd and Shift for more, as a file manager does.\n   *\n   * @default 'toggle'\n   */\n  selectionBehavior?: 'toggle' | 'replace'\n  /**\n   * Whether items can be selected, and how many at a time.\n   *\n   * @default 'none'\n   */\n  selectionMode?: 'none' | 'single' | 'multiple'\n  /**\n   * Inline styles for the tree element.\n   */\n  style?: CSSProperties\n}\n\nconst TreeInner = <T extends object>(\n  {\n    autoFocus,\n    checkboxes,\n    children,\n    className,\n    expandIcon,\n    renderEmptyState,\n    selectionBehavior = 'toggle',\n    selectionMode = 'none',\n    ...rest\n  }: TreeProps<T>,\n  ref: Ref<HTMLDivElement>\n) => {\n  // A checkbox per item is the toggle behavior's way of selecting several; the replace behavior\n  // selects by click, as a file manager does.\n  const config = useMemo(\n    () => ({\n      checkboxes: checkboxes ?? (selectionMode === 'multiple' && selectionBehavior === 'toggle'),\n      expandIcon\n    }),\n    [checkboxes, expandIcon, selectionBehavior, selectionMode]\n  )\n\n  // react-aria-components builds the collection from `children`, flattens it by `expandedKeys`\n  // and renders every visible item as a row of a `treegrid`, on the server too, so the server's\n  // HTML holds the expanded items.\n  return (\n    <TreeConfigContext.Provider value={config}>\n      <AriaTree\n        {...rest}\n        // react-aria focuses the tree element itself for `true`; the first item is what a\n        // keyboard user expects.\n        autoFocus={autoFocus === true ? 'first' : autoFocus}\n        className={classNames('tree', className)}\n        ref={ref}\n        renderEmptyState={renderEmptyState && (() => renderEmptyState())}\n        selectionBehavior={selectionBehavior}\n        selectionMode={selectionMode}\n      >\n        {children}\n      </AriaTree>\n    </TreeConfigContext.Provider>\n  )\n}\n\n// `forwardRef` erases type parameters, so the generic component is cast back to a generic\n// signature for callers — the pattern `DataGrid` uses.\nexport const Tree = forwardRef(TreeInner) as <T extends object>(\n  props: TreeProps<T> & { ref?: Ref<HTMLDivElement> }\n) => ReactElement\n\n;(Tree as { displayName?: string }).displayName = 'Tree'\n","import React, {\n  CSSProperties,\n  forwardRef,\n  ReactElement,\n  ReactNode,\n  Ref,\n  useContext,\n  useRef\n} from 'react'\nimport classNames from 'classnames'\nimport { AriaButtonProps, AriaCheckboxProps, useButton, useCheckbox } from 'react-aria'\nimport { useToggleState } from 'react-stately'\nimport {\n  ButtonContext,\n  ButtonProps,\n  CheckboxContext,\n  CheckboxProps,\n  Collection,\n  Key,\n  TreeItem as AriaTreeItem,\n  TreeItemContent,\n  TreeItemContentRenderProps,\n  useContextProps,\n  useSlottedContext\n} from 'react-aria-components'\n\nimport { IconSlot } from '../icon/iconSlot'\nimport { TreeConfigContext } from './context'\n\nexport interface TreeItemProps<T extends object = object> {\n  /**\n   * The item's child items: `TreeItem` elements, or a render function called once per entry of\n   * `items`, returning that entry's `TreeItem`.\n   */\n  children?: ReactNode | ((item: T) => ReactElement)\n  /**\n   * A string of all className you want applied to the item.\n   */\n  className?: string\n  /**\n   * Values that should rebuild the child items when using the `items`/render-function form of\n   * `children`, as `Tree`'s `dependencies`.\n   */\n  dependencies?: ReadonlyArray<unknown>\n  /**\n   * Toggle the disabled state for the item, as a key in the tree's `disabledKeys` does.\n   */\n  disabled?: boolean\n  /**\n   * An icon drawn before the label.\n   */\n  icon?: ReactNode\n  /**\n   * The item's key, named by `expandedKeys`, `selectedKeys` and `disabledKeys`. Defaults to the\n   * key of the data entry the item renders, or to the item's position.\n   */\n  id?: Key\n  /**\n   * The data to render as child items, through the function form of `children`.\n   */\n  items?: Iterable<T>\n  /**\n   * The item's content.\n   */\n  label: ReactNode\n  /**\n   * Called when the item is activated: with Enter, or with a click when the tree has no\n   * selection.\n   */\n  onAction?: () => void\n  /**\n   * Inline styles for the item's row.\n   */\n  style?: CSSProperties\n  /**\n   * The item's text, which typing a letter in the tree searches. Defaults to `label` when it is a\n   * string.\n   */\n  textValue?: string\n}\n\n// The chevron: a button react-aria-components hands its props (the toggle, \"Expand\"/\"Collapse\"\n// named after the row, out of the tab order) through `ButtonContext`'s `chevron` slot, and whose\n// ref it checks for, so it is read from that slot rather than rendered as its own `Button`. The\n// icon goes through `IconSlot`, so `IconProvider` and the tree's `expandIcon` can replace it.\nconst TreeItemToggle = ({ disabled }: { disabled: boolean }) => {\n  const { expandIcon } = useContext(TreeConfigContext)\n  const [props, ref] = useContextProps({ slot: 'chevron' } as ButtonProps, null, ButtonContext)\n  // The slot's `onPress` does nothing on a disabled row, but says nothing of it: the button is\n  // disabled too.\n  const { buttonProps } = useButton({ ...(props as AriaButtonProps), isDisabled: disabled }, ref)\n  return (\n    <button {...buttonProps} className=\"tree-item-toggle\" ref={ref}>\n      <IconSlot className=\"tree-item-toggle-icon\" icon=\"expand\" override={expandIcon} />\n    </button>\n  )\n}\n\n// The selection checkbox: react-aria-components publishes its props (selected, disabled, named\n// \"Select\" after the row) on `CheckboxContext`'s `selection` slot, as `DataGridSelectionCell`\n// reads them. A native `<input class=\"check-input\">` takes chassis-css's checkbox styles as is.\nconst TreeItemCheckbox = () => {\n  const props = useSlottedContext(CheckboxContext, 'selection') as CheckboxProps\n  const state = useToggleState(props as AriaCheckboxProps)\n  const ref = useRef<HTMLInputElement>(null)\n  const { inputProps } = useCheckbox(props as AriaCheckboxProps, state, ref)\n  // `aria-describedby` after the spread: react-aria's own adds ids it never renders (FORMS.md,\n  // gotcha 6), on the server only.\n  return (\n    <input\n      {...inputProps}\n      aria-describedby={undefined}\n      className=\"check-input tree-item-check\"\n      ref={ref}\n    />\n  )\n}\n\n// The row's element. react-aria's `useGridListItem` names the row by itself and a description\n// slot (`aria-labelledby=\"<row> <description>\"`) that nothing renders: the slot id is written on\n// the server and dropped once the browser finds no element with it (FORMS.md, gotcha 6), so the\n// settled row has `aria-label` alone. react-aria-components' `TreeItem` doesn't declare the\n// `render` prop its elements take, hence the cast where it is passed.\nconst renderRow = (props: React.JSX.IntrinsicElements['div']) => (\n  <div {...props} aria-labelledby={undefined} />\n)\n\nconst TreeItemBody = ({\n  hasChildItems,\n  icon,\n  isDisabled,\n  label,\n  selectionMode\n}: Pick<TreeItemContentRenderProps, 'hasChildItems' | 'isDisabled' | 'selectionMode'> & {\n  icon?: ReactNode\n  label: ReactNode\n}) => {\n  const { checkboxes } = useContext(TreeConfigContext)\n  return (\n    <>\n      {hasChildItems ? (\n        <TreeItemToggle disabled={isDisabled} />\n      ) : (\n        <span className=\"tree-item-spacer\" />\n      )}\n      {checkboxes && selectionMode !== 'none' && <TreeItemCheckbox />}\n      {icon != null && (\n        <span aria-hidden=\"true\" className=\"tree-item-icon\">\n          {icon}\n        </span>\n      )}\n      <span className=\"tree-item-label\">{label}</span>\n    </>\n  )\n}\n\nconst TreeItemInner = <T extends object>(\n  {\n    children,\n    className,\n    dependencies,\n    disabled,\n    icon,\n    id,\n    items,\n    label,\n    onAction,\n    style,\n    textValue\n  }: TreeItemProps<T>,\n  ref: Ref<HTMLDivElement>\n) => {\n  const text =\n    textValue ?? (typeof label === 'string' || typeof label === 'number' ? String(label) : '')\n\n  // The row is a `div` with `role=\"row\"`, holding one `gridcell` with the content; child items\n  // render as the rows after it, not inside it. `--cx-tree-level` carries the level to the\n  // stylesheet, which indents by it; written prefixed here because the build prefixes the\n  // stylesheet's custom properties, not this inline one.\n  return (\n    <AriaTreeItem\n      className={({ isDisabled, isExpanded, isSelected }) =>\n        classNames(\n          'tree-item',\n          { active: isSelected, disabled: isDisabled, expanded: isExpanded },\n          className\n        )\n      }\n      id={id}\n      isDisabled={disabled}\n      onAction={onAction}\n      ref={ref}\n      {...({ render: renderRow } as object)}\n      style={({ level }) => ({ ...style, '--cx-tree-level': level }) as CSSProperties}\n      textValue={text}\n    >\n      <TreeItemContent>\n        {({ hasChildItems, isDisabled, selectionMode }) => (\n          <TreeItemBody\n            hasChildItems={hasChildItems}\n            icon={icon}\n            isDisabled={isDisabled}\n            label={label}\n            selectionMode={selectionMode}\n          />\n        )}\n      </TreeItemContent>\n      {items ? (\n        <Collection dependencies={dependencies} items={items}>\n          {children as (item: T) => ReactElement}\n        </Collection>\n      ) : typeof children === 'function' ? null : (\n        // A render function with no `items` has nothing to render: the leaf of a tree whose\n        // one function renders every level.\n        children\n      )}\n    </AriaTreeItem>\n  )\n}\n\n/**\n * An item of a `Tree`: a row with a label, an optional icon, and child items among its children.\n */\nexport const TreeItem = forwardRef(TreeItemInner) as <T extends object = object>(\n  props: TreeItemProps<T> & { ref?: Ref<HTMLDivElement> }\n) => ReactElement\n\n;(TreeItem as { displayName?: string }).displayName = 'TreeItem'\n"],"mappings":"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"}

package/dist/chunks/unhandledProps-9Kdj7WVf.js.map

@@ -1 +1 @@
-{"version":3,"file":"unhandledProps-9Kdj7WVf.js","names":[],"sources":["../../src/utils/unhandledProps.ts"],"sourcesContent":["import { mergeProps } from 'react-aria'\n\n// Every hook reads these through `filterDOMProps`' `labelable` option, and a component merges\n// its own ids into them (`useFormField`'s `labelledBy`/`describedBy`, `useField`'s label id), so\n// the caller's raw value must not win again (FORMS.md, gotcha 4).\nconst LABELLING_PROPS = ['aria-describedby', 'aria-details', 'aria-label', 'aria-labelledby', 'id']\n\n// Read by `useFocusable`, which every focusable input hook calls.\nconst FOCUSABLE_PROPS = ['autoFocus', 'onBlur', 'onFocus', 'onKeyDown', 'onKeyUp']\n\n// Read by `useTextField`, and by `useNumberField` through it.\nexport const TEXT_FIELD_PROPS = [\n  ...FOCUSABLE_PROPS,\n  'defaultValue',\n  'onBeforeInput',\n  'onChange',\n  'onCompositionEnd',\n  'onCompositionStart',\n  'onCompositionUpdate',\n  'onCopy',\n  'onCut',\n  'onInput',\n  'onPaste',\n  'onSelect',\n  'value'\n]\n\n// Read by `useToggle` (`useCheckbox`, `useCheckboxGroupItem`, `useSwitch`) and by `useRadio`.\nexport const TOGGLE_PROPS = [...FOCUSABLE_PROPS, 'onChange', 'onClick', 'value']\n\n// A react-aria hook's DOM props, with the props it didn't handle merged after them. A hook\n// returns only the few props it knows (`filterDOMProps` without its `global` and `events`\n// options), so a `title`, `dir`, `lang`, `onClick` or `tabIndex` given to the component never\n// reached the element. `mergeProps` runs both of two event handlers and lets the caller's value\n// win otherwise. `handled` names the props the hook reads itself: its handlers would run twice,\n// and its values would undo what the hook made of them.\nexport const mergeUnhandledProps = <T extends object>(\n  hookProps: T,\n  props: object,\n  handled: readonly string[] = []\n): T => {\n  const unhandled: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(props)) {\n    if (!LABELLING_PROPS.includes(key) && !handled.includes(key)) unhandled[key] = value\n  }\n  return mergeProps(hookProps, unhandled) as T\n}\n"],"mappings":"wCAKA,MAAM,EAAkB,CAAC,mBAAoB,eAAgB,aAAc,kBAAmB,IAAI,EAG5F,EAAkB,CAAC,YAAa,SAAU,UAAW,YAAa,SAAS,EAGpE,EAAmB,CAC9B,GAAG,EACH,eACA,gBACA,WACA,mBACA,qBACA,sBACA,SACA,QACA,UACA,UACA,WACA,OACF,EAGa,EAAe,CAAC,GAAG,EAAiB,WAAY,UAAW,OAAO,EAQlE,GACX,EACA,EACA,EAA6B,CAAC,IACxB,CACN,IAAM,EAAqC,CAAC,EAC5C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAK,EACzC,CAAC,EAAgB,SAAS,CAAG,GAAK,CAAC,EAAQ,SAAS,CAAG,IAAG,EAAU,GAAO,GAEjF,OAAO,EAAW,EAAW,CAAS,CACxC"}
+{"version":3,"file":"unhandledProps-9Kdj7WVf.js","names":["LABELLING_PROPS","FOCUSABLE_PROPS","TEXT_FIELD_PROPS","TOGGLE_PROPS","mergeUnhandledProps","unhandled","key","value","props","handled","mergeProps","hookProps"],"sources":["../../src/utils/unhandledProps.ts"],"sourcesContent":["import { mergeProps } from 'react-aria'\n\n// Every hook reads these through `filterDOMProps`' `labelable` option, and a component merges\n// its own ids into them (`useFormField`'s `labelledBy`/`describedBy`, `useField`'s label id), so\n// the caller's raw value must not win again (FORMS.md, gotcha 4).\nconst LABELLING_PROPS = ['aria-describedby', 'aria-details', 'aria-label', 'aria-labelledby', 'id']\n\n// Read by `useFocusable`, which every focusable input hook calls.\nconst FOCUSABLE_PROPS = ['autoFocus', 'onBlur', 'onFocus', 'onKeyDown', 'onKeyUp']\n\n// Read by `useTextField`, and by `useNumberField` through it.\nexport const TEXT_FIELD_PROPS = [\n  ...FOCUSABLE_PROPS,\n  'defaultValue',\n  'onBeforeInput',\n  'onChange',\n  'onCompositionEnd',\n  'onCompositionStart',\n  'onCompositionUpdate',\n  'onCopy',\n  'onCut',\n  'onInput',\n  'onPaste',\n  'onSelect',\n  'value'\n]\n\n// Read by `useToggle` (`useCheckbox`, `useCheckboxGroupItem`, `useSwitch`) and by `useRadio`.\nexport const TOGGLE_PROPS = [...FOCUSABLE_PROPS, 'onChange', 'onClick', 'value']\n\n// A react-aria hook's DOM props, with the props it didn't handle merged after them. A hook\n// returns only the few props it knows (`filterDOMProps` without its `global` and `events`\n// options), so a `title`, `dir`, `lang`, `onClick` or `tabIndex` given to the component never\n// reached the element. `mergeProps` runs both of two event handlers and lets the caller's value\n// win otherwise. `handled` names the props the hook reads itself: its handlers would run twice,\n// and its values would undo what the hook made of them.\nexport const mergeUnhandledProps = <T extends object>(\n  hookProps: T,\n  props: object,\n  handled: readonly string[] = []\n): T => {\n  const unhandled: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(props)) {\n    if (!LABELLING_PROPS.includes(key) && !handled.includes(key)) unhandled[key] = value\n  }\n  return mergeProps(hookProps, unhandled) as T\n}\n"],"mappings":"A,wCAKA,MAAMA,EAAkB,CAAC,mBAAoB,eAAgB,aAAc,kBAAmB,IAAI,EAG5FC,EAAkB,CAAC,YAAa,SAAU,UAAW,YAAa,SAAS,EAGpEC,EAAmB,CAC9B,GAAGD,EACH,eACA,gBACA,WACA,mBACA,qBACA,sBACA,SACA,QACA,UACA,UACA,WACA,OACF,EAGaE,EAAe,CAAC,GAAGF,EAAiB,WAAY,UAAW,OAAO,EAQlEG,GACX,EACA,EACA,EAA6B,CAAC,IACxB,CACN,IAAMC,EAAqC,CAAC,EAC5C,IAAK,GAAM,CAACC,EAAKC,KAAU,OAAO,QAAQC,CAAK,EACzC,CAACR,EAAgB,SAASM,CAAG,GAAK,CAACG,EAAQ,SAASH,CAAG,IAAG,EAAUA,GAAOC,GAEjF,OAAOG,EAAWC,EAAWN,CAAS,CACxC,E"}

package/dist/chunks/{useButtonSemantics-CILM_lhi.js → useButtonSemantics-B1SbGaDO.js}

@@ -1,2 +1,2 @@
-import{t as e}from"./useForkedRef-DVEfT-KI.js";import{useRef as t}from"react";import{useButton as n}from"react-aria";const r=(r,{disabled:i,onClick:a})=>{let o=t(null),s=e(r,o),{buttonProps:c}=n({elementType:`div`,isDisabled:i,onClick:a},o);return{buttonProps:c,forkedRef:s}};export{r as t};
-//# sourceMappingURL=useButtonSemantics-CILM_lhi.js.map
+import{t as e}from"./useForkedRef-WoqMqsWE.js";import{useRef as t}from"react";import{useButton as n}from"react-aria";const r=(r,{disabled:i,onClick:a})=>{let o=t(null),s=e(r,o),{buttonProps:c}=n({elementType:`div`,isDisabled:i,onClick:a},o);return{buttonProps:c,forkedRef:s}};export{r as t};
+//# sourceMappingURL=useButtonSemantics-B1SbGaDO.js.map

package/dist/chunks/useButtonSemantics-B1SbGaDO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useButtonSemantics-B1SbGaDO.js","names":["useForkedRef","useButtonSemantics","buttonRef","useRef","forkedRef","ref","useButton","disabled"],"sources":["../../src/hooks/useButtonSemantics.ts"],"sourcesContent":["import { MouseEventHandler, Ref, RefObject, useRef } from 'react'\nimport { AriaButtonProps, useButton } from 'react-aria'\n\nimport { useForkedRef } from './useForkedRef'\n\ninterface UseButtonSemanticsOptions<T extends HTMLElement> {\n  disabled?: boolean\n  onClick?: MouseEventHandler<T>\n}\n\n// Synthesizes native button semantics (role, tabIndex, Enter/Space activation) for a\n// non-native `component` — a `<button>`/`<a>`/`<input>` gets all of this for free from the\n// browser, but an arbitrary `component` (e.g. `'div'`, `'span'`) doesn't. Shared by\n// `Link`/`Button`/`CloseButton`, which otherwise duplicated this ref/hook wiring near-verbatim.\n// `elementType: 'div'` and the `HTMLDivElement` cast below are fixed regardless of the actual\n// rendered tag — `useButton` only uses `elementType` to pick which ARIA attributes apply\n// (a `div`-shaped set is the right one for an arbitrary non-native element either way), not to\n// constrain the ref's real type.\nexport const useButtonSemantics = <T extends HTMLElement>(\n  ref: Ref<T>,\n  { disabled, onClick }: UseButtonSemanticsOptions<T>\n) => {\n  const buttonRef = useRef<T | null>(null)\n  const forkedRef = useForkedRef(ref, buttonRef)\n  const buttonAriaProps: AriaButtonProps<'div'> = {\n    elementType: 'div',\n    isDisabled: disabled,\n    onClick: onClick as unknown as AriaButtonProps<'div'>['onClick']\n  }\n  const { buttonProps } = useButton(buttonAriaProps, buttonRef as RefObject<HTMLDivElement | null>)\n\n  return { buttonProps, forkedRef }\n}\n"],"mappings":"A,qHAkBA,MAAaC,GACX,EACA,CAAE,WAAU,aACT,CACH,IAAMC,EAAYC,EAAiB,IAAI,EACjCC,EAAYJ,EAAaK,EAAKH,CAAS,EAMvC,CAAE,eAAgBI,EAAU,CAJhC,YAAa,MACb,WAAYC,EACH,SAEqC,EAAGL,CAA6C,EAEhG,MAAO,CAAE,cAAa,WAAU,CAClC,E"}

package/dist/chunks/useControllableState-CPUJxfKW.js.map

@@ -1 +1 @@
-{"version":3,"file":"useControllableState-CPUJxfKW.js","names":[],"sources":["../../src/hooks/useControllableState.ts"],"sourcesContent":["import { useState } from 'react'\n\n/**\n * Shared controlled/uncontrolled state pattern: `value` present means controlled (the returned\n * state always mirrors it), otherwise state is tracked internally starting from `defaultValue`.\n * The returned setter updates internal state (when uncontrolled) and always calls `onChange`,\n * leaving the caller free to layer additional logic (e.g. an `onComplete` callback) around it.\n */\nexport function useControllableState<T>(\n  value: T | undefined,\n  defaultValue: T,\n  onChange?: (value: T) => void\n): [T, (next: T) => void] {\n  const isControlled = value !== undefined\n  const [uncontrolledValue, setUncontrolledValue] = useState<T>(defaultValue)\n  const state = isControlled ? (value as T) : uncontrolledValue\n\n  const setState = (next: T) => {\n    if (!isControlled) setUncontrolledValue(next)\n    onChange?.(next)\n  }\n\n  return [state, setState]\n}\n"],"mappings":"iCAQA,SAAgB,EACd,EACA,EACA,EACwB,CACxB,IAAM,EAAe,IAAU,IAAA,GACzB,CAAC,EAAmB,GAAwB,EAAY,CAAY,EAQ1E,MAAO,CAPO,EAAgB,EAAc,EAE1B,GAAY,CACvB,GAAc,EAAqB,CAAI,EAC5C,IAAW,CAAI,CACjB,CAEuB,CACzB"}
+{"version":3,"file":"useControllableState-CPUJxfKW.js","names":["useControllableState","isControlled","value","uncontrolledValue","setUncontrolledValue","useState","defaultValue","next","onChange"],"sources":["../../src/hooks/useControllableState.ts"],"sourcesContent":["import { useState } from 'react'\n\n/**\n * Shared controlled/uncontrolled state pattern: `value` present means controlled (the returned\n * state always mirrors it), otherwise state is tracked internally starting from `defaultValue`.\n * The returned setter updates internal state (when uncontrolled) and always calls `onChange`,\n * leaving the caller free to layer additional logic (e.g. an `onComplete` callback) around it.\n */\nexport function useControllableState<T>(\n  value: T | undefined,\n  defaultValue: T,\n  onChange?: (value: T) => void\n): [T, (next: T) => void] {\n  const isControlled = value !== undefined\n  const [uncontrolledValue, setUncontrolledValue] = useState<T>(defaultValue)\n  const state = isControlled ? (value as T) : uncontrolledValue\n\n  const setState = (next: T) => {\n    if (!isControlled) setUncontrolledValue(next)\n    onChange?.(next)\n  }\n\n  return [state, setState]\n}\n"],"mappings":"A,iCAQA,SAAgBA,EACd,EACA,EACA,EACwB,CACxB,IAAMC,EAAeC,IAAU,IAAA,GACzB,CAACC,EAAmBC,GAAwBC,EAAYC,CAAY,EAQ1E,MAAO,CAPOL,EAAgBC,EAAcC,EAE1B,GAAY,CACvBF,GAAcG,EAAqBG,CAAI,EAC5CC,IAAWD,CAAI,CACjB,CAEuB,CACzB,C"}

package/dist/chunks/useDialogElement-BfygWBPZ.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useForkedRef-WoqMqsWE.js";import{t}from"./useControllableState-CPUJxfKW.js";import{t as n}from"./useIsomorphicLayoutEffect-BbqRwuqn.js";import{t as r}from"./dialogTransition-C8fYTsSa.js";import{n as i,t as a}from"./overlayStack-BXtTGCRm.js";import{useEffect as o,useRef as s,useState as c}from"react";import{usePreventScroll as l}from"react-aria";const u=/* @__PURE__ */ new WeakMap;function d(e){let t=/* @__PURE__ */ new Set,n=e,r=n?.closest(`dialog`)??null;for(;n&&r&&!r.open;){if(t.has(r))return null;t.add(r),n=u.get(r)??null,r=n?.closest(`dialog`)??null}return n}const f=({backdrop:f,defaultVisible:p,instant:m,isModal:h,keyboard:g=!0,lockScroll:_=h,onBeforeShow:v,onClick:y,onClose:b,onClosePrevented:x,onHidden:S,onKeyDown:C,onShow:w,onShown:T,onVisibleChange:E,open:D,ref:O,visible:k})=>{let A=s(null),j=e(O,A),[M,N]=t(k,p??D??!1,E),[P,F]=c(D?`open`:`closed`),I=s(P),L=e=>{I.current=e,F(e)},[R,z]=c(!1),[B,V]=c(!1),H=s(!1),U=s(!1),W=s(null);l({isDisabled:!B});let G=()=>{M&&(b?.(),N(!1))},K=()=>{x?.();let e=A.current;e&&(z(!0),r(e,()=>z(!1),!m))},q={onBeforeShow:v,onHidden:S,onShow:w,onShown:T},J=s(q);J.current=q;let Y=e=>{let t=document.activeElement,n=!t||t===document.body||e.contains(t);L(`closed`),e.open&&e.close(),U.current&&(U.current=!1,V(!1)),J.current.onHidden?.();let r=n?d(W.current):null;r&&document.contains(r)&&r.focus()};n(()=>{let e=A.current;if(!e)return;let t=I.current;if(M!==(t===`opening`||t===`open`)){if(M){if(J.current.onBeforeShow?.(e),!e.open){W.current=document.activeElement instanceof HTMLElement?document.activeElement:null,u.set(e,W.current),H.current=h,U.current=h&&_,h?e.showModal():e.show(),U.current&&V(!0);let t=[...e.querySelectorAll(`[autofocus], [data-autofocus]:not([data-autofocus="false"])`)].find(t=>t.closest(`dialog`)===e);t?t.focus():(e.setAttribute(`tabindex`,`-1`),e.focus())}J.current.onShow?.(),L(`opening`)}else e.open?L(`closing`):Y(e)}},[M]),o(()=>{let e=A.current;if(e){if(P===`opening`)return r(e,()=>{L(`open`),J.current.onShown?.()},!m);if(P===`closing`)return r(e,()=>Y(e),!m)}},[P]);let X=s(!1);n(()=>(X.current=!0,()=>{X.current=!1;let e=A.current,t=document.activeElement;if(!e||I.current===`closed`||!t||!e.contains(t))return;let n=W.current;queueMicrotask(()=>{if(X.current)return;let e=document.activeElement;if(e&&e!==document.body)return;let t=d(n);t&&document.contains(t)&&t.focus()})}),[]);let Z=P!==`closed`;return o(()=>{if(Z&&H.current)return i({nodes:()=>[A.current]})},[Z]),{close:G,dialogRef:A,forkedRef:j,handleBackdropClick:e=>{y?.(e),e.target===A.current&&H.current&&(f===`static`?K():G())},handleCancel:e=>{e.preventDefault(),g?G():K()},handleKeyDown:e=>{if(C?.(e),e.key!==`Escape`||e.defaultPrevented||H.current)return;let t=A.current;t&&a(t)||(e.preventDefault(),g?G():K())},handleNativeClose:()=>{let e=A.current;e&&I.current!==`closed`&&(G(),Y(e))},hiding:P===`closing`,staticBounce:R}};export{f as t};
+//# sourceMappingURL=useDialogElement-BfygWBPZ.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDialogElement-BfygWBPZ.js","names":["useForkedRef","useIsomorphicLayoutEffect","executeAfterTransition","pushOverlay","hasOverlayWithin","restoreTargets","resolveRestoreTarget","seen","target","trigger","owner","useDialogElement","isModal","dialogRef","useRef","forkedRef","ref","_visible","setVisible","useControllableState","visible","defaultVisible","open","onVisibleChange","phase","setPhaseState","useState","phaseRef","setPhase","next","staticBounce","setStaticBounce","scrollLocked","setScrollLocked","openedAsModalRef","lockedScrollRef","triggerRef","usePreventScroll","close","onClose","triggerStaticBounce","onClosePrevented","dialog","instant","callbacks","callbacksRef","finishHide","active","ownsFocus","current","lockScroll","autofocusEl","element","useEffect","mountedRef","isOpen","onClick","event","backdrop","keyboard","onKeyDown"],"sources":["../../src/hooks/useDialogElement.ts"],"sourcesContent":["import {\n  ForwardedRef,\n  KeyboardEvent as ReactKeyboardEvent,\n  KeyboardEventHandler,\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'\nimport { hasOverlayWithin, pushOverlay } from '../utils/overlayStack'\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   * Whether a modal open locks the page's scroll, for as long as the dialog is open. Defaults to\n   * `isModal`. `Drawer` passes `!scroll`: its `scroll` lets the page scroll behind a drawer that is\n   * still modal for its backdrop.\n   */\n  lockScroll?: 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  /**\n   * The caller's own `onKeyDown`, chained ahead of the Escape handling of a non-modal dialog, for\n   * the reason `onClick` is.\n   */\n  onKeyDown?: KeyboardEventHandler<HTMLDialogElement>\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// Where a dialog is in its show/hide cycle. The native dialog is open in every phase but\n// `closed`: it stays in the top layer for as long as its exit lasts.\ntype DialogPhase = 'closed' | 'opening' | 'open' | 'closing'\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`, `Alert` and\n// `Drawer` otherwise duplicated this near-verbatim: forked ref, the show/begin-hide effect\n// (showModal() vs. show(), initial focus, scroll lock), the effect that waits out the enter and\n// exit transitions, the non-modal Escape-key handler (the native `cancel` event only fires for\n// dialogs opened with `showModal()`), the native `close` event, and the static-backdrop \"bounce\"\n// used by both the backdrop-click handler and the Escape/`cancel` handler. What's left in each\n// caller is only what's genuinely component-specific: `Modal`/`Drawer`'s own `_className`\n// building, and `Drawer`'s cross-instance \"auto-close every other open drawer\" registry (wired in\n// via `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  lockScroll = isModal,\n  onBeforeShow,\n  onClick,\n  onClose,\n  onClosePrevented,\n  onHidden,\n  onKeyDown,\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  // A dialog rendered with the native `open` attribute is open before any effect has run.\n  const [phase, setPhaseState] = useState<DialogPhase>(open ? 'open' : 'closed')\n  // Mirrors `phase` at the moment it is set, not at the next render, as `useTransitionState`\n  // does: StrictMode runs the show effect twice on mount, and the second run has to see that the\n  // first has shown the dialog. It is also what tells a reopening during the exit from a first\n  // opening, and the browser's `close` event from the one that follows our own `close()`.\n  const phaseRef = useRef(phase)\n  const setPhase = (next: DialogPhase) => {\n    phaseRef.current = next\n    setPhaseState(next)\n  }\n  const [staticBounce, setStaticBounce] = useState(false)\n  const [scrollLocked, setScrollLocked] = useState(false)\n  const openedAsModalRef = useRef(false)\n  const lockedScrollRef = 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  // Several things can ask an open dialog to close while it is closing; only the first is a\n  // request, for `onClose` as for `onVisibleChange`.\n  const close = () => {\n    if (!_visible) return\n    onClose?.()\n    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 a ref, kept current every render, so a transition that ends renders later\n  // calls the callbacks of that moment, and a caller can pass them inline.\n  const callbacks = { onBeforeShow, onHidden, onShow, onShown }\n  const callbacksRef = useRef(callbacks)\n  callbacksRef.current = callbacks\n\n  const finishHide = (dialog: HTMLDialogElement) => {\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    // Settled before `close()`, so the native `close` event it fires isn't taken for the\n    // browser's (`handleNativeClose`).\n    setPhase('closed')\n    if (dialog.open) {\n      dialog.close()\n    }\n    if (lockedScrollRef.current) {\n      lockedScrollRef.current = false\n      setScrollLocked(false)\n    }\n    callbacksRef.current.onHidden?.()\n    const trigger = ownsFocus ? resolveRestoreTarget(triggerRef.current) : null\n    if (trigger && document.contains(trigger)) {\n      trigger.focus()\n    }\n  }\n\n  // Show / begin-hide\n  useIsomorphicLayoutEffect(() => {\n    const dialog = dialogRef.current\n    if (!dialog) return\n\n    const current = phaseRef.current\n    const isShown = current === 'opening' || current === 'open'\n    if (_visible === isShown) return\n\n    if (_visible) {\n      callbacksRef.current.onBeforeShow?.(dialog)\n\n      // Reopened while its exit runs, the dialog is still open: it stays as it is, with the\n      // trigger and the scroll lock of its first opening, and leaving the `closing` phase drops\n      // the wait that would have closed it.\n      if (!dialog.open) {\n        triggerRef.current =\n          document.activeElement instanceof HTMLElement ? document.activeElement : null\n\n        restoreTargets.set(dialog, triggerRef.current)\n\n        openedAsModalRef.current = isModal\n        lockedScrollRef.current = isModal && lockScroll\n        if (isModal) {\n          dialog.showModal()\n        } else {\n          dialog.show()\n        }\n        if (lockedScrollRef.current) setScrollLocked(true)\n\n        // `data-autofocus` too: React doesn't write the `autofocus` attribute in a client render\n        // (it calls `focus()` on mount, which a closed dialog ignores), so `autoFocus` alone only\n        // works 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\n      callbacksRef.current.onShow?.()\n      setPhase('opening')\n      return\n    }\n\n    // Closed by the browser already, with its `close` event still to come.\n    if (!dialog.open) {\n      finishHide(dialog)\n      return\n    }\n    setPhase('closing')\n  }, [_visible])\n\n  // Finish the show or the hide once the transition (or lack thereof) completes. A phase that is\n  // left before that drops its wait: a dialog closed while it opens never reports `onShown`, and\n  // one reopened while it closes is never closed.\n  useEffect(() => {\n    const dialog = dialogRef.current\n    if (!dialog) return undefined\n\n    if (phase === 'opening') {\n      return executeAfterTransition(\n        dialog,\n        () => {\n          setPhase('open')\n          callbacksRef.current.onShown?.()\n        },\n        !instant\n      )\n    }\n    if (phase === 'closing') {\n      return executeAfterTransition(dialog, () => finishHide(dialog), !instant)\n    }\n    return undefined\n  }, [phase])\n\n  // Unmounted while open (`{open && <Modal visible>}`), the dialog never reaches `finishHide`, so\n  // focus it held fell to `<body>` with it. Focus goes back to the trigger here instead, under the\n  // same condition. Whether the dialog held focus is read in the layout cleanup, before React\n  // takes the element out; the focus waits for a microtask, by which time the dialog has left the\n  // top layer and the trigger is no longer inert. StrictMode's simulated unmount runs this cleanup\n  // too, and mounts again within the same task: `mountedRef` tells the two apart.\n  const mountedRef = useRef(false)\n  useIsomorphicLayoutEffect(() => {\n    mountedRef.current = true\n    return () => {\n      mountedRef.current = false\n      const dialog = dialogRef.current\n      const active = document.activeElement\n      if (!dialog || phaseRef.current === 'closed' || !active || !dialog.contains(active)) return\n      const trigger = triggerRef.current\n      queueMicrotask(() => {\n        if (mountedRef.current) return\n        const current = document.activeElement\n        if (current && current !== document.body) return\n        const target = resolveRestoreTarget(trigger)\n        if (target && document.contains(target)) target.focus()\n      })\n    }\n  }, [])\n\n  // A modal dialog holds a place among the open overlays for as long as it is open, so Escape\n  // doesn't reach a popover or a menu left open under it (`overlayStack`).\n  const isOpen = phase !== 'closed'\n  useEffect(() => {\n    if (!isOpen || !openedAsModalRef.current) return undefined\n    return pushOverlay({ nodes: () => [dialogRef.current] })\n  }, [isOpen])\n\n  // The native `close` event. After our own `close()` the phase is settled and there is nothing\n  // left to do. Otherwise the browser closed the dialog by itself: a second Escape in a row,\n  // whose `cancel` it doesn't let a page prevent, a `<form method=\"dialog\">`, or a caller's own\n  // `close()`. The state follows: a close request, the scroll lock released, `onHidden`. A\n  // caller that holds `visible` through that request has a closed dialog until `visible` changes.\n  const handleNativeClose = () => {\n    const dialog = dialogRef.current\n    if (!dialog || phaseRef.current === 'closed') return\n    close()\n    finishHide(dialog)\n  }\n\n  // Escape key for non-modal (show()) dialogs — the native `cancel` event below only fires for\n  // dialogs opened with showModal(). A React handler, so an Escape that something inside the\n  // dialog has handled and stopped never arrives, wherever that thing is portaled. One it has\n  // only prevented, or that an overlay open inside this dialog is about to take on `window`\n  // (`overlayStack`), is left alone too: Escape closes the innermost overlay only.\n  const handleKeyDown = (event: ReactKeyboardEvent<HTMLDialogElement>) => {\n    onKeyDown?.(event)\n    if (event.key !== 'Escape' || event.defaultPrevented || openedAsModalRef.current) return\n    const dialog = dialogRef.current\n    if (dialog && hasOverlayWithin(dialog)) return\n    event.preventDefault()\n    if (!keyboard) {\n      triggerStaticBounce()\n      return\n    }\n    close()\n  }\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 {\n    close,\n    dialogRef,\n    forkedRef,\n    handleBackdropClick,\n    handleCancel,\n    handleKeyDown,\n    handleNativeClose,\n    hiding: phase === 'closing',\n    staticBounce\n  }\n}\n"],"mappings":"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"}

package/dist/chunks/useDialogTitle-DiB4YDGI.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useHydrated-Dud4JEwp.js";import{useCallback as t,useState as n}from"react";function r(r){let i=e(),[a,o]=n(),s=t(e=>(o(e),()=>o(t=>t===e?void 0:t)),[]);return[i?a:r,s]}export{r as t};
+//# sourceMappingURL=useDialogTitle-DiB4YDGI.js.map

package/dist/chunks/useDialogTitle-DiB4YDGI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDialogTitle-DiB4YDGI.js","names":["useHydrated","useDialogTitle","hydrated","titleId","setTitleId","useState","registerTitle","useCallback","id","current","generatedId"],"sources":["../../src/hooks/useDialogTitle.ts"],"sourcesContent":["import { useCallback, useState } from 'react'\n\nimport { useHydrated } from './useHydrated'\n\nexport type RegisterDialogTitle = (id: string) => () => void\n\n// The title a `Modal` or a `Drawer` is labelled by. `ModalTitle` and `DrawerTitle` register the id\n// they have in the DOM, from a layout effect, and take it out when they unmount, so the dialog's\n// `aria-labelledby` names an element that is there: the generated id of the context, or the `id`\n// a caller gave the title. A dialog with no title has no `aria-labelledby`, which would be a\n// dangling reference, and one that outranks a caller's `aria-label` besides.\n//\n// A server can't know what the dialog's children render, and an effect doesn't run there. Its\n// HTML names `generatedId`, the id a title takes by default, so a dialog rendered open is named\n// before the JavaScript loads; hydration then settles on what registered.\nexport function useDialogTitle(generatedId: string): [string | undefined, RegisterDialogTitle] {\n  const hydrated = useHydrated()\n  const [titleId, setTitleId] = useState<string>()\n  const registerTitle = useCallback<RegisterDialogTitle>((id) => {\n    setTitleId(id)\n    return () => setTitleId((current) => (current === id ? undefined : current))\n  }, [])\n\n  return [hydrated ? titleId : generatedId, registerTitle]\n}\n"],"mappings":"A,gGAeA,SAAgBC,EAAe,EAAgE,CAC7F,IAAMC,EAAWF,EAAY,EACvB,CAACG,EAASC,GAAcC,EAAiB,EACzCC,EAAgBC,EAAkC,IACtDH,EAAWI,CAAE,MACAJ,EAAY,GAAaK,IAAYD,EAAK,IAAA,GAAYC,CAAQ,GAC1E,CAAC,CAAC,EAEL,MAAO,CAACP,EAAWC,EAAUO,EAAaJ,CAAa,CACzD,C"}

package/dist/chunks/useDisabledAnchorGuard-CH6df46a.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDisabledAnchorGuard-CH6df46a.js","names":["useDisabledAnchorGuard","guard","disabled","event","onClick"],"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,MAAaA,GACX,EACA,EACA,IAEQ,GAAyB,CAC3BC,GAASC,EACXC,EAAM,eAAe,EAGvBC,IAAUD,CAAK,CACjB,E"}

package/dist/chunks/useFloatingOverlay-BuiI_CCn.js

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

package/dist/chunks/useFloatingOverlay-BuiI_CCn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFloatingOverlay-BuiI_CCn.js","names":["resolvePortalContainer","trigger","useFloatingOverlay","portal","setPortal","useState","isOpen","triggerRef","useEffect","container","current","reportedOpenRef","useRef","onShow","onHide","portalContainer","closeRef","close","dialog","handleClose","getOverlayArrowStyle","arrowProps","getOverlayTransitionClass","phase"],"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// The open dialog a trigger is in, where its overlay is portaled, so it renders in that dialog's\n// top layer and closes with it. `document.body` otherwise.\nconst resolvePortalContainer = (trigger: HTMLElement): Element =>\n  trigger.closest('dialog[open]') ?? document.body\n\n/**\n * Shared portal-container/visibility wiring for `Popover` and `Tooltip`: resolves the `<dialog>`\n * a trigger lives inside (if any), `null` while an open overlay's isn't known yet, 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): Element | null {\n  // The container, and whether it was resolved for the open that is current.\n  const [portal, setPortal] = useState<{ container: Element; open: boolean } | null>(null)\n\n  // Resolved in the render that opens the overlay, while the trigger the user pressed is in the\n  // DOM, so the panel mounts straight into its container. A passive effect resolved it after the\n  // panel had mounted into `document.body`: inside a dialog the panel then mounted a second time,\n  // its effects ran twice, its state was lost and its first fade with it.\n  if (isOpen && !portal?.open && triggerRef.current) {\n    setPortal({ container: resolvePortalContainer(triggerRef.current), open: true })\n  } else if (!isOpen && portal?.open) {\n    setPortal({ container: portal.container, open: false })\n  }\n\n  // Checked again once the commit is done, after the layout effects that open dialogs: an overlay\n  // mounted open has no trigger element in its first render, and one opened in the same commit\n  // as the dialog around it found that dialog still closed. Only these move the panel. An overlay\n  // waits for its container (`null` while open), so one mounted open mounts its panel once too.\n  useEffect(() => {\n    const trigger = triggerRef.current\n    if (!isOpen || !trigger) return\n    const container = resolvePortalContainer(trigger)\n    setPortal((current) =>\n      current?.open && current.container === container ? current : { container, open: true }\n    )\n  }, [isOpen])\n\n  // `onShow`/`onHide` report changes of the open state, against the value of the last run: not\n  // the first commit (mounting closed is not a hide, mounting open not a show), and not\n  // StrictMode's second run of the effect on mount, which a `mounted` flag let through.\n  const reportedOpenRef = useRef(isOpen)\n  useEffect(() => {\n    if (reportedOpenRef.current === isOpen) return\n    reportedOpenRef.current = isOpen\n    if (isOpen) onShow?.()\n    else onHide?.()\n  }, [isOpen])\n\n  // `null` while the container of the current open isn't known yet. Kept through the exit, so a\n  // closing panel stays where it is.\n  const portalContainer = isOpen && !portal?.open ? null : (portal?.container ?? null)\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":"A,4DA2BA,MAAMA,EAA0B,GAC9BC,EAAQ,QAAQ,cAAc,GAAK,SAAS,KAS9C,SAAgBC,EAAmB,CACjC,QACA,SACA,SACA,SACA,cAC4C,CAE5C,GAAM,CAACC,EAAQC,GAAaC,EAAuD,IAAI,EAMnFC,GAAU,CAACH,GAAQ,MAAQI,EAAW,QACxCH,EAAU,CAAE,UAAWJ,EAAuBO,EAAW,OAAO,EAAG,KAAM,EAAK,CAAC,EACtE,CAACD,GAAUH,GAAQ,MAC5BC,EAAU,CAAE,UAAWD,EAAO,UAAW,KAAM,EAAM,CAAC,EAOxDK,MAAgB,CACd,IAAMP,EAAUM,EAAW,QAC3B,GAAI,CAACD,GAAU,CAACL,EAAS,OACzB,IAAMQ,EAAYT,EAAuBC,CAAO,EAChDG,EAAW,GACTM,GAAS,MAAQA,EAAQ,YAAcD,EAAYC,EAAU,CAAE,YAAW,KAAM,EAAK,CACvF,CACF,EAAG,CAACJ,CAAM,CAAC,EAKX,IAAMK,EAAkBC,EAAON,CAAM,EACrCE,MAAgB,CACVG,EAAgB,UAAYL,IAChC,EAAgB,QAAUA,EACtBA,EAAQO,IAAS,EAChBC,IAAS,EAChB,EAAG,CAACR,CAAM,CAAC,EAIX,IAAMS,EAAkBT,GAAU,CAACH,GAAQ,KAAO,KAAQA,GAAQ,WAAa,KAKzEa,EAAWJ,EAAOK,CAAK,EAc7B,MAbA,GAAS,QAAUA,EAInBT,MAAgB,CACd,IAAMU,EAASH,GAAiB,QAAQ,QAAQ,EAChD,GAAI,CAACT,GAAU,CAACY,EAAQ,OAExB,IAAMC,MAAoBH,EAAS,QAAQ,EAE3C,OADAE,EAAO,iBAAiB,QAASC,CAAW,MAC/BD,EAAO,oBAAoB,QAASC,CAAW,CAC9D,EAAG,CAACb,EAAQS,CAAe,CAAC,EAErBA,CACT,CASA,SAAgBK,EAAqB,EAA2D,CAC9F,MAAO,CACL,SAAU,WACV,GAAGC,EAAW,MACd,UAAWA,EAAW,OAAO,MAAQ,IAAA,GAAiC,mBAArB,kBACnD,CACF,CAIA,SAAgBC,EAA0B,EAAgC,CACxE,OAAOC,IAAU,YAAcA,IAAU,UAAY,YAAc,MACrE,C"}

package/dist/chunks/useForkedRef-WoqMqsWE.js

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

package/dist/chunks/useForkedRef-WoqMqsWE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForkedRef-WoqMqsWE.js","names":["useForkedRef","refs","useMemo","ref","cleanups","assignRef","node","cleanup","index","isFunction","value","error"],"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\n// What a callback ref may return: since React 19, a function to run when the element goes away,\n// in place of a second call with `null`.\ntype RefCleanup = () => void\n\n// A callback ref is typed to return `void`, which takes a function returning anything: one that\n// returns a cleanup, and one that returns something else by accident (an arrow function around\n// `set.add(node)`, an async function).\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): RefCleanup | undefined => {\n      const cleanups = refs.map((ref) => assignRef(ref, node))\n      // Called with `null` by hand (React doesn't, given the cleanup below): every ref has its\n      // `null` already.\n      if (node == null) return undefined\n      // React runs this in place of calling the forked ref with `null`. A ref that returned a\n      // cleanup gets that and no `null`, as React treats it on an element of its own; every other\n      // ref is reset.\n      return () => {\n        refs.forEach((ref, index) => {\n          const cleanup = cleanups[index]\n          if (cleanup) cleanup()\n          else assignRef(ref, null)\n        })\n      }\n    }\n  }, refs)\n}\n\n// Returns the cleanup a callback ref returned, if it returned one.\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): RefCleanup | undefined {\n  if (ref == null) return undefined\n  if (isFunction(ref)) {\n    const cleanup: unknown = ref(value)\n    return isFunction(cleanup) ? (cleanup as RefCleanup) : undefined\n  }\n  try {\n    ref.current = value\n  } catch (error) {\n    throw new Error(`Cannot assign value \"${value}\" to ref \"${ref}\"`, { cause: error })\n  }\n  return undefined\n}\n\n// `typeof` rather than a `[object Function]` tag check, which an async function fails: an async\n// callback ref was taken for an object ref and never called.\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 typeof value === 'function'\n}\n"],"mappings":"A,gCAmBA,SAAgBA,EACd,GAAGC,EACH,CACA,OAAOC,MACDD,EAAK,MAAO,GAAQE,GAAO,IAAI,EAC1B,KAGD,GAAsC,CAC5C,IAAMC,EAAWH,EAAK,IAAK,GAAQI,EAAUF,EAAKG,CAAI,CAAC,EAGvD,GAAIA,GAAQ,KAIZ,UAAa,CACXL,EAAK,SAAS,EAAK,IAAU,CAC3B,IAAMM,EAAUH,EAASI,GACrBD,EAASA,EAAQ,EAChBF,EAAUF,EAAK,IAAI,CAC1B,CAAC,CACH,CACF,EACCF,CAAI,CACT,CAIA,SAAgBI,EACd,EAEA,EACwB,CACxB,GAAIF,GAAO,KACX,IAAIM,EAAWN,CAAG,EAAG,CACnB,IAAMI,EAAmBJ,EAAIO,CAAK,EAClC,OAAOD,EAAWF,CAAO,EAAKA,EAAyB,IAAA,EACzD,CACA,GAAI,CACF,EAAI,QAAUG,CAChB,OAASC,EAAO,CACd,MAAU,MAAM,wBAAwBD,EAAM,YAAYP,EAAI,GAAI,CAAE,MAAOQ,CAAM,CAAC,CACpF,CALA,CAOF,CAKA,SAAgBF,EAAW,EAA+B,CACxD,OAAO,OAAOC,GAAU,UAC1B,C"}

package/dist/chunks/useFormField-DH2tlc3e.js

@@ -0,0 +1,2 @@
+import{l as e}from"./slot-BQVx1Eew.js";import{t}from"./context-HDVxTNPi.js";import{useContext as n,useId as r}from"react";const i=({ariaDescribedBy:i,ariaLabelledBy:a,help:o,id:s,invalid:c,invalidFeedback:l,label:u,valid:d,validFeedback:f})=>{let p=n(t),m=r(),h=s??p?.inputId??m,g=`${m}-label`,_=`${m}-help`,v=`${m}-feedback`;return{describedBy:e(!!o&&_,!!(c&&l||d&&f)&&v,p?.describedBy,i),feedbackId:v,helpId:_,inputId:h,labelId:g,labelledBy:e(!!u&&g,p?.labelId,a)}};export{i as t};
+//# sourceMappingURL=useFormField-DH2tlc3e.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFormField-DH2tlc3e.js","names":["joinUniqueIds","useFormField","field","useContext","FormFieldContext","generatedId","useId","inputId","id","labelId","helpId","feedbackId","help","invalid","invalidFeedback","valid","validFeedback","ariaDescribedBy","label","ariaLabelledBy"],"sources":["../../src/hooks/useFormField.ts"],"sourcesContent":["import { ReactNode, useContext, useId } from 'react'\n\nimport { FormFieldContext } from '../components/form-field/context'\nimport { joinUniqueIds } from '../utils/idRefs'\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 + the ids a wrapping\n   * `FloatingInput` renders + `ariaDescribedBy`), or `undefined` when none apply. Safe to spread\n   * straight onto the real control: `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`). The caller's `id`, else the id a wrapping `FloatingInput` points its label at,\n   * else a generated one. 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 + the label of a wrapping\n   * `FloatingInput` + `ariaLabelledBy`), or `undefined` when none 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.\n//\n// Inside a `FloatingInput` the field also takes what `FormFieldContext` hands down: the id the\n// floating label points at, that label as a name and the wrapper's help and feedback as a\n// description. An id the consumer repeats by hand is written once.\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 field = useContext(FormFieldContext)\n  const generatedId = useId()\n  const inputId = id ?? field?.inputId ?? 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 = joinUniqueIds(\n    Boolean(help) && helpId,\n    Boolean(showInvalidFeedback || showValidFeedback) && feedbackId,\n    field?.describedBy,\n    ariaDescribedBy\n  )\n\n  const labelledBy = joinUniqueIds(Boolean(label) && labelId, field?.labelId, ariaLabelledBy)\n\n  return { describedBy, feedbackId, helpId, inputId, labelId, labelledBy }\n}\n"],"mappings":"A,0HAoEA,MAAaC,GAAgB,CAC3B,kBACA,iBACA,OACA,KACA,UACA,kBACA,QACA,QACA,mBAC6C,CAC7C,IAAMC,EAAQC,EAAWC,CAAgB,EACnCC,EAAcC,EAAM,EACpBC,EAAUC,GAAMN,GAAO,SAAWG,EAClCI,EAAU,GAAGJ,EAAY,QACzBK,EAAS,GAAGL,EAAY,OACxBM,EAAa,GAAGN,EAAY,WAclC,MAAO,CAAE,YATWL,EAClB,EAAQY,GAASF,EACjB,GAL0BG,GAAWC,GACbC,GAASC,IAIoBL,EACrDT,GAAO,YACPe,CAKiB,EAAG,aAAY,SAAQ,UAAS,UAAS,WAFzCjB,EAAc,EAAQkB,GAAUT,EAASP,GAAO,QAASiB,CAEP,CAAE,CACzE,E"}

package/dist/chunks/useHeldBack-eeTfpa_t.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useIsomorphicLayoutEffect-BbqRwuqn.js";import{t}from"./context-DCg95BgR.js";import{useContext as n,useEffect as r,useRef as i,useState as a}from"react";const o=`input, select, textarea`,s=e=>e.matches(o),c=e=>s(e)?[e]:Array.from(e.querySelectorAll(o)),l=e=>e.willValidate&&!e.validity.valid,u=e=>{let t=e?c(e).filter(e=>e.willValidate):[];return t.length===0?`none`:t.some(l)?`invalid`:`valid`},d=e=>Array.from(e.elements).find(e=>e.validity?.valid===!1),f=(o,{enabled:l=!0,focus:f,invalid:p,valid:m})=>{let h=n(t),g=i(h);g.current=h;let[_,v]=a(!1),[y,b]=a(`none`),x=i(f);x.current=f;let S=i(null);r(()=>{let e=l?o.current:null,t=e?(s(e)?e:c(e)[0])?.form??e.closest(`form`):null,n=S.current;if(n?.target===e&&n?.form===t||(n?.stop(),S.current=null,!e))return;let r=e=>{v(!0),x.current&&(!e.defaultPrevented&&t&&d(t)===e.target&&x.current(),e.preventDefault())},i=()=>v(!1),a=e.ownerDocument.defaultView,f=t=>{if(!(t.target instanceof Node)||!e.contains(t.target))return;let n=u(e);n!==`invalid`&&v(!1),g.current&&b(n)},p=!s(e);e.addEventListener(`invalid`,r,p),a?.addEventListener(`input`,f),a?.addEventListener(`change`,f),t?.addEventListener(`reset`,i),S.current={form:t,stop:()=>{e.removeEventListener(`invalid`,r,p),a?.removeEventListener(`input`,f),a?.removeEventListener(`change`,f),t?.removeEventListener(`reset`,i)},target:e}}),r(()=>()=>{S.current?.stop(),S.current=null},[]),e(()=>{if(!_&&!h)return;let e=u(l?o.current:null);e!==`invalid`&&v(!1),h&&b(e)});let C=p!==void 0||!!m,w=_&&!C,T=h&&!C?y:`none`;return{heldBack:w,invalid:p??(w||T===`invalid`||void 0),valid:m||T===`valid`||void 0}};export{f as t};
+//# sourceMappingURL=useHeldBack-eeTfpa_t.js.map

package/dist/chunks/useHeldBack-eeTfpa_t.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHeldBack-eeTfpa_t.js","names":["useIsomorphicLayoutEffect","CONTROLS","isControl","element","controlsOf","target","holdsBack","control","validityOf","controls","firstInvalidControl","form","useHeldBack","validated","useContext","FormValidatedContext","validatedRef","useRef","blocked","setBlocked","useState","validity","setValidity","focusRef","focus","listening","useEffect","enabled","ref","current","onInvalid","event","onReset","view","onEdit","next","capture","decided","invalid","valid","heldBack","shown"],"sources":["../../src/hooks/useHeldBack.ts"],"sourcesContent":["import { RefObject, useContext, useEffect, useRef, useState } from 'react'\n\nimport { FormValidatedContext } from '../components/form/context'\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect'\n\ntype Control = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement\n\nexport interface UseHeldBackOptions {\n  /**\n   * Whether to listen at all. `false` for a field with nothing a form would validate: a value\n   * input that is `type=\"hidden\"` until the field is required.\n   */\n  enabled?: boolean\n  /**\n   * Moves focus into the field once a form is held back and this control is its first invalid\n   * one, and cancels the event: for a control that isn't displayed, which a browser can neither\n   * focus nor show a message on. Omit it where react-aria's own listener does both already,\n   * which is every control one of its hooks was given.\n   */\n  focus?: () => void\n  /**\n   * The caller's `invalid`. Once it is set, to `false` too, the caller decides how the field\n   * looks: it is never shown as held back, nor by its form's `validated`.\n   */\n  invalid?: boolean\n  /**\n   * The caller's `valid`. While it is `true`, the caller decides how the field looks, as it does\n   * once `invalid` is set.\n   */\n  valid?: boolean\n}\n\nexport interface UseHeldBackResult {\n  /**\n   * `true` from a submit the field held back until it would no longer hold one back, or its form\n   * is reset.\n   */\n  heldBack: boolean\n  /**\n   * What the field shows as invalid: the caller's `invalid` where it is set, `true` while\n   * `heldBack` or while its form is `validated` and it would hold the form back.\n   */\n  invalid: boolean | undefined\n  /**\n   * What the field shows as valid: the caller's `valid`, or `true` while its form is `validated`\n   * and it would let the form submit. Unless the caller decides how the field looks.\n   */\n  valid: boolean | undefined\n}\n\ninterface Listening {\n  form: HTMLFormElement | null\n  stop: () => void\n  target: HTMLElement\n}\n\n// By its tag and not by a `validity` property: a `<fieldset>` has one too, and validates nothing.\nconst CONTROLS = 'input, select, textarea'\nconst isControl = (element: HTMLElement): element is Control => element.matches(CONTROLS)\n\n// The controls a form validates under `target`: itself, or the inputs inside a group.\nconst controlsOf = (target: HTMLElement): Control[] =>\n  isControl(target) ? [target] : Array.from(target.querySelectorAll<Control>(CONTROLS))\n\nconst holdsBack = (control: Control) => control.willValidate && !control.validity.valid\n\ntype Validity = 'invalid' | 'none' | 'valid'\n\n// What a form would make of the controls under `target`. `none` when it validates none of them:\n// a disabled control, a `type=\"hidden\"` one, or a group with no control.\nconst validityOf = (target: HTMLElement | null): Validity => {\n  const controls = target ? controlsOf(target).filter((control) => control.willValidate) : []\n  if (controls.length === 0) return 'none'\n  return controls.some(holdsBack) ? 'invalid' : 'valid'\n}\n\nconst firstInvalidControl = (form: HTMLFormElement) =>\n  Array.from(form.elements).find(\n    (control) => (control as HTMLInputElement).validity?.valid === false\n  )\n\n// A field that held its form back from submitting shows as invalid until it no longer would.\n//\n// A form with an invalid control isn't submitted, and the browser says why in a message beside\n// the first such control. react-aria cancels that message for every control its hooks are given\n// (`useFormValidation` calls `preventDefault()` on the `invalid` event, whatever\n// `validationBehavior` is) and focuses the control instead, and a control that isn't displayed\n// has no message to begin with. Either way the form stayed and nothing said why. A native control\n// no hook is given keeps the browser's message, on the first invalid one alone: the others, and\n// it once the message has gone, looked as they did before the submit. So the field\n// reads the `invalid` event itself and shows it as it shows the `invalid` prop: the class, the\n// ARIA state and the caller's `invalidFeedback`. react-stately's `displayValidation` doesn't\n// have it: it stays empty unless the whole field is under `validationBehavior: 'native'`, which\n// also moves every other validation to blur.\n//\n// A `Form` with `validated` shows each of its fields by the same test from then on, with no\n// submit, and as valid once it would let the form submit (FORMS.md, gotcha 10).\n// chassis-css's own gate, `[data-cx-validate]` with `:user-valid`/`:user-invalid`, styles the\n// control alone, never the feedback the field renders, and wins over the class the caller's\n// `invalid` or `valid` sets.\n//\n// `ref` is the control, or the element around several: the fieldset of a group, the boxes of a\n// code. The event doesn't bubble, so a group hears its controls in the capture phase.\nexport const useHeldBack = (\n  ref: RefObject<HTMLElement | null>,\n  { enabled = true, focus, invalid, valid }: UseHeldBackOptions\n): UseHeldBackResult => {\n  const validated = useContext(FormValidatedContext)\n  const validatedRef = useRef(validated)\n  validatedRef.current = validated\n  const [blocked, setBlocked] = useState(false)\n  // Read only while the form is `validated`.\n  const [validity, setValidity] = useState<Validity>('none')\n  const focusRef = useRef(focus)\n  focusRef.current = focus\n  const listening = useRef<Listening | null>(null)\n\n  // Runs after every render and listens again only when the target is another element (an\n  // `Autocomplete` that turns `multiple`) or belongs to another form (`form`). The listeners\n  // stay the same ones otherwise: a browser runs the render a listener asked for before it calls\n  // the next listener of the same event, and one removed and added again by that render is not\n  // called at all. A `reset` after react-aria's own listener, or after the other input's of a\n  // `DateRangePicker`, was lost that way.\n  useEffect(() => {\n    const target = enabled ? ref.current : null\n    const form = target\n      ? ((isControl(target) ? target : controlsOf(target)[0])?.form ?? target.closest('form'))\n      : null\n    const current = listening.current\n    if (current?.target === target && current?.form === form) return\n    current?.stop()\n    listening.current = null\n    if (!target) return\n\n    // `checkValidity()` and `reportValidity()` fire it too, as a submit does.\n    const onInvalid = (event: Event) => {\n      setBlocked(true)\n      if (!focusRef.current) return\n      if (!event.defaultPrevented && form && firstInvalidControl(form) === event.target) {\n        focusRef.current()\n      }\n      // Cancelled, as react-aria cancels it: the browser has nothing to show for a control that\n      // isn't displayed, and Chromium logs an error for an invalid control it can't focus.\n      event.preventDefault()\n    }\n    const onReset = () => setBlocked(false)\n    // A native control that keeps its own value (a `Select` with no `value`, a `FileInput`)\n    // changes with no render to follow, and the effect below would never look again.\n    //\n    // Heard on the window, after React's own listener on its root. For a real keystroke the\n    // browser runs the render a listener asks for before the next listener: a render asked for\n    // on the control itself ran before React had read the edit, wrote the old value back, and an\n    // empty field lost the first character typed into it.\n    const view = target.ownerDocument.defaultView\n    const onEdit = (event: Event) => {\n      if (!(event.target instanceof Node) || !target.contains(event.target)) return\n      const next = validityOf(target)\n      if (next !== 'invalid') setBlocked(false)\n      if (validatedRef.current) setValidity(next)\n    }\n    const capture = !isControl(target)\n\n    target.addEventListener('invalid', onInvalid, capture)\n    view?.addEventListener('input', onEdit)\n    view?.addEventListener('change', onEdit)\n    form?.addEventListener('reset', onReset)\n    listening.current = {\n      form,\n      stop: () => {\n        target.removeEventListener('invalid', onInvalid, capture)\n        view?.removeEventListener('input', onEdit)\n        view?.removeEventListener('change', onEdit)\n        form?.removeEventListener('reset', onReset)\n      },\n      target\n    }\n  })\n  useEffect(\n    () => () => {\n      listening.current?.stop()\n      listening.current = null\n    },\n    []\n  )\n\n  // The mark lasts while the field would still hold the form back. Read after each render, where\n  // its controls have the values just rendered, and before the paint: the field never shows a\n  // value and the mark together. A control that has gone, is disabled or is no longer invalid\n  // doesn't hold anything back either.\n  // A `validated` form's field is read at the same point, for the same reason.\n  useIsomorphicLayoutEffect(() => {\n    if (!blocked && !validated) return\n    const next = validityOf(enabled ? ref.current : null)\n    if (next !== 'invalid') setBlocked(false)\n    if (validated) setValidity(next)\n  })\n\n  const decided = invalid !== undefined || Boolean(valid)\n  const heldBack = blocked && !decided\n  const shown = validated && !decided ? validity : 'none'\n  return {\n    heldBack,\n    invalid: invalid ?? (heldBack || shown === 'invalid' || undefined),\n    valid: valid || shown === 'valid' || undefined\n  }\n}\n"],"mappings":"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"}

package/dist/chunks/useHydrated-Dud4JEwp.js

@@ -0,0 +1,2 @@
+import{useSyncExternalStore as e}from"react";const t=()=>()=>{};function n(){return e(t,()=>!0,()=>!1)}export{n as t};
+//# sourceMappingURL=useHydrated-Dud4JEwp.js.map

package/dist/chunks/useHydrated-Dud4JEwp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHydrated-Dud4JEwp.js","names":["subscribe","useHydrated","useSyncExternalStore"],"sources":["../../src/hooks/useHydrated.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react'\n\n// Nothing to subscribe to: the value only differs between the server snapshot and the client one.\nconst subscribe = () => () => {}\n\n/**\n * `false` on the server and during hydration, `true` afterwards and in a client-only render. React\n * hydrates against the server snapshot, then re-renders with the client one once hydration has\n * finished, so a component can render something that only exists in the browser without\n * mismatching the server's HTML.\n */\nexport function useHydrated(): boolean {\n  return useSyncExternalStore(\n    subscribe,\n    () => true,\n    () => false\n  )\n}\n"],"mappings":"A,6CAGA,MAAMA,UAAwB,CAAC,EAQ/B,SAAgBC,GAAuB,CACrC,OAAOC,EACLF,MACM,OACA,EACR,CACF,C"}

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

@@ -1 +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"}
+{"version":3,"file":"useIsomorphicLayoutEffect-BbqRwuqn.js","names":["useIsomorphicLayoutEffect","useEffect","useLayoutEffect"],"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":"A,uDAQA,MAAaA,EAA4B,OAAO,OAAW,IAAcC,EAAYC,E"}

package/dist/chunks/{useOpenStateProps-DykUbnPJ.js → useOpenStateProps-BhjSQ3f6.js}

@@ -1,2 +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
+import{S as e}from"./slot-BQVx1Eew.js";import{t}from"./visibleState-CWyQak65.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-BhjSQ3f6.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOpenStateProps-BhjSQ3f6.js","names":["devWarning","DEPRECATED_OPEN_STATE_PROPS","useOpenStateProps","deprecated","replacement","props","displayName","propsRef","useRef","onOpenChange","useCallback","current","warnDroppedVisibleRequest","next"],"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":"A,iIAcA,MAAMC,EAA8B,CAClC,CAAC,SAAU,SAAS,EACpB,CAAC,cAAe,gBAAgB,EAChC,CAAC,eAAgB,iBAAiB,CACpC,EAWA,SAAgBC,EACd,EACA,EACA,CACA,IAAK,GAAM,CAACC,EAAYC,KAAgBH,EACtCD,EACEK,EAAMF,KAAgB,IAAA,GACtB,GAAGG,EAAY,QAAQH,EAAW,2BAA2BC,EAAY,wDAE3E,EAGF,IAAMG,EAAWC,EAAOH,CAAK,EAC7B,EAAS,QAAUA,EAEnB,IAAMI,EAAeC,EAClB,GAAkB,CACjB,IAAMC,EAAUJ,EAAS,QACzBK,EACE,CACE,gBAAiBD,EAAQ,iBAAmBA,EAAQ,aACpD,QAASA,EAAQ,SAAWA,EAAQ,MACtC,EACAE,EACAP,CACF,EACAK,EAAQ,kBAAkBE,CAAI,EAC9BF,EAAQ,eAAeE,CAAI,CAC7B,EACA,CAACP,CAAW,CACd,EAEA,MAAO,CACL,YAAaD,EAAM,gBAAkBA,EAAM,YAC3C,OAAQA,EAAM,SAAWA,EAAM,OAC/B,cACF,CACF,C"}

package/dist/chunks/useOverlayMaxHeight-8mQL2Q6d.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useIsomorphicLayoutEffect-BbqRwuqn.js";import{useEffect as t,useRef as n}from"react";const r=e=>{e.style.maxHeight&&e.style.removeProperty(`max-height`)};function i(i,a){let o=n(null);e(()=>{let e=a?i.current:null,t=o.current;if(e&&r(e),t?.node===e||(t?.observer.disconnect(),o.current=null,!e||typeof MutationObserver>`u`))return;let n=new MutationObserver(()=>r(e));n.observe(e,{attributes:!0,attributeFilter:[`style`]}),o.current={node:e,observer:n}}),t(()=>()=>{o.current?.observer.disconnect(),o.current=null},[])}export{i as t};
+//# sourceMappingURL=useOverlayMaxHeight-8mQL2Q6d.js.map

package/dist/chunks/useOverlayMaxHeight-8mQL2Q6d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOverlayMaxHeight-8mQL2Q6d.js","names":["useIsomorphicLayoutEffect","releaseMaxHeight","node","useOverlayMaxHeight","observedRef","useRef","isOpen","overlayRef","observed","observer","useEffect"],"sources":["../../src/hooks/useOverlayMaxHeight.ts"],"sourcesContent":["import { RefObject, useEffect, useRef } from 'react'\n\nimport { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect'\n\nconst releaseMaxHeight = (node: HTMLElement) => {\n  if (node.style.maxHeight) node.style.removeProperty('max-height')\n}\n\n// Leaves the height of a `.menu` panel to chassis-css's `--cx-menu-max-height`. react-aria's\n// `useOverlayPosition` writes the room it finds for the overlay as an inline `max-height`, on the\n// element itself rather than in the style it returns, and again each time it places the overlay\n// (a resize, the overlay's own size changing). Inline, that outranks the theme's cap: a\n// `Combobox` list 360.5px tall against a 320px token. The value is taken off each time it is\n// written, before the paint.\n//\n// For `Menu`, `MenuSubmenu`, `ContextMenu`, `Combobox` and `Autocomplete`, which take only the\n// position from the hook (`resolveMenuOverlayPositioning`). Call it after `useOverlayPosition`, so\n// its layout effect runs after the hook's own.\nexport function useOverlayMaxHeight(overlayRef: RefObject<HTMLElement | null>, isOpen: boolean) {\n  const observedRef = useRef<{ node: HTMLElement; observer: MutationObserver } | null>(null)\n\n  // Every commit: the panel can be a new element (a list moved into a dialog), and the hook\n  // places it again in its own layout effect.\n  useIsomorphicLayoutEffect(() => {\n    const node = isOpen ? overlayRef.current : null\n    const observed = observedRef.current\n    if (node) releaseMaxHeight(node)\n    if (observed?.node === node) return\n    observed?.observer.disconnect()\n    observedRef.current = null\n    if (!node || typeof MutationObserver === 'undefined') return\n    const observer = new MutationObserver(() => releaseMaxHeight(node))\n    observer.observe(node, { attributes: true, attributeFilter: ['style'] })\n    observedRef.current = { node, observer }\n  })\n\n  useEffect(\n    () => () => {\n      observedRef.current?.observer.disconnect()\n      observedRef.current = null\n    },\n    []\n  )\n}\n"],"mappings":"A,0GAIA,MAAMC,EAAoB,GAAsB,CAC1CC,EAAK,MAAM,WAAWA,EAAK,MAAM,eAAe,YAAY,CAClE,EAYA,SAAgBC,EAAoB,EAA2C,EAAiB,CAC9F,IAAMC,EAAcC,EAAiE,IAAI,EAIzFL,MAAgC,CAC9B,IAAME,EAAOI,EAASC,EAAW,QAAU,KACrCC,EAAWJ,EAAY,QAK7B,GAJIF,GAAMD,EAAiBC,CAAI,EAC3BM,GAAU,OAASN,IACvBM,GAAU,SAAS,WAAW,EAC9B,EAAY,QAAU,KAClB,CAACN,GAAQ,OAAO,iBAAqB,KAAa,OACtD,IAAMO,EAAW,IAAI,qBAAuBR,EAAiBC,CAAI,CAAC,EAClEO,EAAS,QAAQP,EAAM,CAAE,WAAY,GAAM,gBAAiB,CAAC,OAAO,CAAE,CAAC,EACvE,EAAY,QAAU,CAAE,OAAM,UAAS,CACzC,CAAC,EAEDQ,UACc,CACVN,EAAY,SAAS,SAAS,WAAW,EACzC,EAAY,QAAU,IACxB,EACA,CAAC,CACH,CACF,C"}

package/dist/chunks/useRequiredValueInput-gYN8I-LY.js

@@ -0,0 +1,2 @@
+import{t as e}from"./useHeldBack-eeTfpa_t.js";const t={hidden:!0,onChange:()=>void 0,required:!0,type:`text`},n=(n,{focus:r,invalid:i,required:a,valid:o})=>{let s=e(n,{enabled:!!a,focus:r,invalid:i,valid:o});return{inputProps:a?t:void 0,missing:i===void 0&&!!s.invalid,valid:s.valid}};export{n as t};
+//# sourceMappingURL=useRequiredValueInput-gYN8I-LY.js.map

package/dist/chunks/useRequiredValueInput-gYN8I-LY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRequiredValueInput-gYN8I-LY.js","names":["useHeldBack","REQUIRED_INPUT_PROPS","useRequiredValueInput","shown","inputRef","required","invalid"],"sources":["../../src/hooks/useRequiredValueInput.ts"],"sourcesContent":["import { RefObject } from 'react'\n\nimport { useHeldBack } from './useHeldBack'\n\n// What makes the input that carries a field's value hold its form back. `type=\"hidden\"` is barred\n// from constraint validation, so it is a text input that isn't displayed, the one react-aria\n// renders under `validationBehavior: 'native'`. `onChange` because React takes an input with a\n// `value` and no handler for a mistake; nobody types in this one.\nconst REQUIRED_INPUT_PROPS = {\n  hidden: true,\n  onChange: () => undefined,\n  required: true,\n  type: 'text'\n} as const\n\nexport interface UseRequiredValueInputOptions {\n  /**\n   * Moves focus into the field once a form is held back and this input is its first invalid\n   * control, which a browser does itself for an input it displays. Omit it where something else\n   * does already: react-aria's own listener on the input of a `TimeField`.\n   */\n  focus?: () => void\n  /**\n   * The caller's `invalid`. Once it is set, to `false` too, the caller decides how the field\n   * looks: `missing` stays `false` and `valid` is the caller's.\n   */\n  invalid?: boolean\n  /**\n   * Whether the field is required and can be filled in: not read-only, since an input in that\n   * state isn't validated. A disabled one isn't either, which its `disabled` attribute says.\n   */\n  required?: boolean\n  /**\n   * The caller's `valid`. While it is `true`, `missing` stays `false`.\n   */\n  valid?: boolean\n}\n\nexport interface UseRequiredValueInputResult {\n  /**\n   * Spread onto the value input after its own props, `type` included, while the field is\n   * required. `undefined` otherwise, which leaves the input as it is.\n   */\n  inputProps?: typeof REQUIRED_INPUT_PROPS\n  /**\n   * `true` from a submit this input held back until the field has a value, or its form is reset,\n   * and while its form is `validated` and the field has no value. Show the field as invalid while\n   * it is.\n   */\n  missing: boolean\n  /**\n   * What the field shows as valid: the caller's `valid`, or `true` while its form is `validated`\n   * and the field has its value.\n   */\n  valid: boolean | undefined\n}\n\n// `required` for a field whose value isn't in a native input a form validates (FORMS.md, gotcha\n// 9): the segments of a date or a time, a toggle that opens a list. The field renders the input\n// that carries its value with `inputProps`, and an empty one then holds its form back.\n//\n// The browser has no bubble to show on an input that isn't displayed, so nothing told the user\n// why the form stayed. `missing` does (`useHeldBack`): the field shows it as it shows `invalid`,\n// with the caller's `invalidFeedback`, and `focus` puts the user in the field.\nexport const useRequiredValueInput = (\n  inputRef: RefObject<HTMLInputElement | null>,\n  { focus, invalid, required, valid }: UseRequiredValueInputOptions\n): UseRequiredValueInputResult => {\n  const shown = useHeldBack(inputRef, {\n    enabled: Boolean(required),\n    focus,\n    invalid,\n    valid\n  })\n\n  return {\n    inputProps: required ? REQUIRED_INPUT_PROPS : undefined,\n    missing: invalid === undefined && Boolean(shown.invalid),\n    valid: shown.valid\n  }\n}\n"],"mappings":"A,8CAQA,MAAMC,EAAuB,CAC3B,OAAQ,GACR,aAAgB,IAAA,GAChB,SAAU,GACV,KAAM,MACR,EAmDaC,GACX,EACA,CAAE,QAAO,UAAS,WAAU,WACI,CAChC,IAAMC,EAAQH,EAAYI,EAAU,CAClC,QAAS,EAAQC,EACjB,QACA,UACA,OACF,CAAC,EAED,MAAO,CACL,WAAYA,EAAWJ,EAAuB,IAAA,GAC9C,QAASK,IAAY,IAAA,IAAa,EAAQH,EAAM,QAChD,MAAOA,EAAM,KACf,CACF,E"}