{"version":3,"file":"useSlotProps-e2e8ad6b.cjs","sources":["../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../node_modules/@mui/utils/esm/useForkRef/useForkRef.js","../../node_modules/@mui/utils/esm/composeClasses/composeClasses.js","../../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js","../../node_modules/@mui/base/generateUtilityClass/index.js","../../node_modules/@mui/base/generateUtilityClasses/index.js","../../node_modules/@mui/base/utils/extractEventHandlers.js","../../node_modules/@mui/base/utils/isHostComponent.js","../../node_modules/@mui/base/utils/appendOwnerState.js","../../node_modules/@mui/base/utils/ClassNameConfigurator.js","../../node_modules/@mui/base/utils/resolveComponentProps.js","../../node_modules/@mui/base/utils/omitEventHandlers.js","../../node_modules/@mui/base/utils/mergeSlotProps.js","../../node_modules/@mui/base/utils/useSlotProps.js"],"sourcesContent":["export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","'use client';\n\nimport * as React from 'react';\nimport setRef from '../setRef';\nexport default function useForkRef(...refs) {\n  /**\n   * This will create a new function if the refs passed to this hook change and are all defined.\n   * This means react will call the old forkRef with `null` and the new forkRef\n   * with the ref. Cleanup naturally emerges from this behavior.\n   */\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return instance => {\n      refs.forEach(ref => {\n        setRef(ref, instance);\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}","export default function composeClasses(slots, getUtilityClass, classes = undefined) {\n  const output = {};\n  Object.keys(slots).forEach(\n  // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.\n  // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208\n  slot => {\n    output[slot] = slots[slot].reduce((acc, key) => {\n      if (key) {\n        const utilityClass = getUtilityClass(key);\n        if (utilityClass !== '') {\n          acc.push(utilityClass);\n        }\n        if (classes && classes[key]) {\n          acc.push(classes[key]);\n        }\n      }\n      return acc;\n    }, []).join(' ');\n  });\n  return output;\n}","import ClassNameGenerator from '../ClassNameGenerator';\nexport const globalStateClasses = {\n  active: 'active',\n  checked: 'checked',\n  completed: 'completed',\n  disabled: 'disabled',\n  error: 'error',\n  expanded: 'expanded',\n  focused: 'focused',\n  focusVisible: 'focusVisible',\n  open: 'open',\n  readOnly: 'readOnly',\n  required: 'required',\n  selected: 'selected'\n};\nexport default function generateUtilityClass(componentName, slot, globalStatePrefix = 'Mui') {\n  const globalStateClass = globalStateClasses[slot];\n  return globalStateClass ? `${globalStatePrefix}-${globalStateClass}` : `${ClassNameGenerator.generate(componentName)}-${slot}`;\n}\nexport function isGlobalState(slot) {\n  return globalStateClasses[slot] !== undefined;\n}","import { globalStateClasses } from '@mui/utils/generateUtilityClass';\nconst GLOBAL_CLASS_PREFIX = 'base';\nfunction buildStateClass(state) {\n  return `${GLOBAL_CLASS_PREFIX}--${state}`;\n}\nfunction buildSlotClass(componentName, slot) {\n  return `${GLOBAL_CLASS_PREFIX}-${componentName}-${slot}`;\n}\nexport function generateUtilityClass(componentName, slot) {\n  const globalStateClass = globalStateClasses[slot];\n  return globalStateClass ? buildStateClass(globalStateClass) : buildSlotClass(componentName, slot);\n}\nexport function isGlobalState(slot) {\n  return globalStateClasses[slot] !== undefined;\n}","import { generateUtilityClass } from '../generateUtilityClass';\nexport function generateUtilityClasses(componentName, slots) {\n  const result = {};\n  slots.forEach(slot => {\n    result[slot] = generateUtilityClass(componentName, slot);\n  });\n  return result;\n}","/**\n * Extracts event handlers from a given object.\n * A prop is considered an event handler if it is a function and its name starts with `on`.\n *\n * @param object An object to extract event handlers from.\n * @param excludeKeys An array of keys to exclude from the returned object.\n */\nexport function extractEventHandlers(object, excludeKeys = []) {\n  if (object === undefined) {\n    return {};\n  }\n  const result = {};\n  Object.keys(object).filter(prop => prop.match(/^on[A-Z]/) && typeof object[prop] === 'function' && !excludeKeys.includes(prop)).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}","/**\n * Determines if a given element is a DOM element name (i.e. not a React component).\n */\nexport function isHostComponent(element) {\n  return typeof element === 'string';\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { isHostComponent } from './isHostComponent';\n\n/**\n * Type of the ownerState based on the type of an element it applies to.\n * This resolves to the provided OwnerState for React components and `undefined` for host components.\n * Falls back to `OwnerState | undefined` when the exact type can't be determined in development time.\n */\n\n/**\n * Appends the ownerState object to the props, merging with the existing one if necessary.\n *\n * @param elementType Type of the element that owns the `existingProps`. If the element is a DOM node or undefined, `ownerState` is not applied.\n * @param otherProps Props of the element.\n * @param ownerState\n */\nexport function appendOwnerState(elementType, otherProps, ownerState) {\n  if (elementType === undefined || isHostComponent(elementType)) {\n    return otherProps;\n  }\n  return _extends({}, otherProps, {\n    ownerState: _extends({}, otherProps.ownerState, ownerState)\n  });\n}","'use client';\n\nimport * as React from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst defaultContextValue = {\n  disableDefaultClasses: false\n};\nconst ClassNameConfiguratorContext = /*#__PURE__*/React.createContext(defaultContextValue);\n/**\n * @ignore - internal hook.\n *\n * Wraps the `generateUtilityClass` function and controls how the classes are generated.\n * Currently it only affects whether the classes are applied or not.\n *\n * @returns Function to be called with the `generateUtilityClass` function specific to a component to generate the classes.\n */\nexport function useClassNamesOverride(generateUtilityClass) {\n  const {\n    disableDefaultClasses\n  } = React.useContext(ClassNameConfiguratorContext);\n  return slot => {\n    if (disableDefaultClasses) {\n      return '';\n    }\n    return generateUtilityClass(slot);\n  };\n}\n\n/**\n * Allows to configure the components within to not apply any built-in classes.\n */\nexport function ClassNameConfigurator(props) {\n  const {\n    disableDefaultClasses,\n    children\n  } = props;\n  const contextValue = React.useMemo(() => ({\n    disableDefaultClasses: disableDefaultClasses != null ? disableDefaultClasses : false\n  }), [disableDefaultClasses]);\n  return /*#__PURE__*/_jsx(ClassNameConfiguratorContext.Provider, {\n    value: contextValue,\n    children: children\n  });\n}","/**\n * If `componentProps` is a function, calls it with the provided `ownerState`.\n * Otherwise, just returns `componentProps`.\n */\nexport function resolveComponentProps(componentProps, ownerState, slotState) {\n  if (typeof componentProps === 'function') {\n    return componentProps(ownerState, slotState);\n  }\n  return componentProps;\n}","/**\n * Removes event handlers from the given object.\n * A field is considered an event handler if it is a function with a name beginning with `on`.\n *\n * @param object Object to remove event handlers from.\n * @returns Object with event handlers removed.\n */\nexport function omitEventHandlers(object) {\n  if (object === undefined) {\n    return {};\n  }\n  const result = {};\n  Object.keys(object).filter(prop => !(prop.match(/^on[A-Z]/) && typeof object[prop] === 'function')).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport clsx from 'clsx';\nimport { extractEventHandlers } from './extractEventHandlers';\nimport { omitEventHandlers } from './omitEventHandlers';\n/**\n * Merges the slot component internal props (usually coming from a hook)\n * with the externally provided ones.\n *\n * The merge order is (the latter overrides the former):\n * 1. The internal props (specified as a getter function to work with get*Props hook result)\n * 2. Additional props (specified internally on a Base UI component)\n * 3. External props specified on the owner component. These should only be used on a root slot.\n * 4. External props specified in the `slotProps.*` prop.\n * 5. The `className` prop - combined from all the above.\n * @param parameters\n * @returns\n */\nexport function mergeSlotProps(parameters) {\n  const {\n    getSlotProps,\n    additionalProps,\n    externalSlotProps,\n    externalForwardedProps,\n    className\n  } = parameters;\n  if (!getSlotProps) {\n    // The simpler case - getSlotProps is not defined, so no internal event handlers are defined,\n    // so we can simply merge all the props without having to worry about extracting event handlers.\n    const joinedClasses = clsx(additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n    const mergedStyle = _extends({}, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n    const props = _extends({}, additionalProps, externalForwardedProps, externalSlotProps);\n    if (joinedClasses.length > 0) {\n      props.className = joinedClasses;\n    }\n    if (Object.keys(mergedStyle).length > 0) {\n      props.style = mergedStyle;\n    }\n    return {\n      props,\n      internalRef: undefined\n    };\n  }\n\n  // In this case, getSlotProps is responsible for calling the external event handlers.\n  // We don't need to include them in the merged props because of this.\n\n  const eventHandlers = extractEventHandlers(_extends({}, externalForwardedProps, externalSlotProps));\n  const componentsPropsWithoutEventHandlers = omitEventHandlers(externalSlotProps);\n  const otherPropsWithoutEventHandlers = omitEventHandlers(externalForwardedProps);\n  const internalSlotProps = getSlotProps(eventHandlers);\n\n  // The order of classes is important here.\n  // Emotion (that we use in libraries consuming Base UI) depends on this order\n  // to properly override style. It requires the most important classes to be last\n  // (see https://github.com/mui/material-ui/pull/33205) for the related discussion.\n  const joinedClasses = clsx(internalSlotProps == null ? void 0 : internalSlotProps.className, additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n  const mergedStyle = _extends({}, internalSlotProps == null ? void 0 : internalSlotProps.style, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n  const props = _extends({}, internalSlotProps, additionalProps, otherPropsWithoutEventHandlers, componentsPropsWithoutEventHandlers);\n  if (joinedClasses.length > 0) {\n    props.className = joinedClasses;\n  }\n  if (Object.keys(mergedStyle).length > 0) {\n    props.style = mergedStyle;\n  }\n  return {\n    props,\n    internalRef: internalSlotProps.ref\n  };\n}","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"elementType\", \"externalSlotProps\", \"ownerState\", \"skipResolvingSlotProps\"];\nimport { unstable_useForkRef as useForkRef } from '@mui/utils';\nimport { appendOwnerState } from './appendOwnerState';\nimport { mergeSlotProps } from './mergeSlotProps';\nimport { resolveComponentProps } from './resolveComponentProps';\n/**\n * @ignore - do not document.\n * Builds the props to be passed into the slot of an unstyled component.\n * It merges the internal props of the component with the ones supplied by the user, allowing to customize the behavior.\n * If the slot component is not a host component, it also merges in the `ownerState`.\n *\n * @param parameters.getSlotProps - A function that returns the props to be passed to the slot component.\n */\nexport function useSlotProps(parameters) {\n  var _parameters$additiona;\n  const {\n      elementType,\n      externalSlotProps,\n      ownerState,\n      skipResolvingSlotProps = false\n    } = parameters,\n    rest = _objectWithoutPropertiesLoose(parameters, _excluded);\n  const resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);\n  const {\n    props: mergedProps,\n    internalRef\n  } = mergeSlotProps(_extends({}, rest, {\n    externalSlotProps: resolvedComponentsProps\n  }));\n  const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, (_parameters$additiona = parameters.additionalProps) == null ? void 0 : _parameters$additiona.ref);\n  const props = appendOwnerState(elementType, _extends({}, mergedProps, {\n    ref\n  }), ownerState);\n  return props;\n}"],"names":["_objectWithoutPropertiesLoose","source","excluded","target","sourceKeys","key","i","useForkRef","refs","React","ref","instance","setRef","composeClasses","slots","getUtilityClass","classes","output","slot","acc","utilityClass","globalStateClasses","GLOBAL_CLASS_PREFIX","buildStateClass","state","buildSlotClass","componentName","generateUtilityClass","globalStateClass","generateUtilityClasses","result","extractEventHandlers","object","excludeKeys","prop","isHostComponent","element","appendOwnerState","elementType","otherProps","ownerState","_extends","defaultContextValue","ClassNameConfiguratorContext","useClassNamesOverride","disableDefaultClasses","resolveComponentProps","componentProps","slotState","omitEventHandlers","mergeSlotProps","parameters","getSlotProps","additionalProps","externalSlotProps","externalForwardedProps","className","joinedClasses","clsx","mergedStyle","props","eventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","_excluded","useSlotProps","_parameters$additiona","skipResolvingSlotProps","rest","resolvedComponentsProps","mergedProps","internalRef"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13]}