{"version":3,"file":"react/js/vendor.mui@current-b77b0167.8e7b3c7de658a83d0784.js","mappings":"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","sources":["webpack:///./node_modules/@mui/x-data-grid/hooks/features/clipboard/useGridClipboard.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnGrouping/gridColumnGroupsSelector.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnGrouping/gridColumnGroupsUtils.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnGrouping/useGridColumnGrouping.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnHeaders/useGridColumnHeaders.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnMenu/columnMenuSelector.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnMenu/useGridColumnMenu.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnMenu/useGridColumnMenuSlots.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnResize/gridColumnResizeApi.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columnResize/useGridColumnResize.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columns/gridColumnsInterfaces.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columns/gridColumnsSelector.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columns/gridColumnsUtils.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columns/useGridColumnSpanning.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/columns/useGridColumns.js"],"sourcesContent":["import * as React from 'react';\nimport { useGridApiOptionHandler, useGridNativeEventListener } from '../../utils';\nimport { gridFocusCellSelector } from '../focus/gridFocusStateSelector';\nimport { serializeCellValue } from '../export/serializers/csvSerializer';\nfunction writeToClipboardPolyfill(data) {\n  const span = document.createElement('span');\n  span.style.whiteSpace = 'pre';\n  span.style.userSelect = 'all';\n  span.style.opacity = '0px';\n  span.textContent = data;\n  document.body.appendChild(span);\n  const range = document.createRange();\n  range.selectNode(span);\n  const selection = window.getSelection();\n  selection.removeAllRanges();\n  selection.addRange(range);\n  try {\n    document.execCommand('copy');\n  } finally {\n    document.body.removeChild(span);\n  }\n}\nfunction copyToClipboard(data) {\n  if (navigator.clipboard) {\n    navigator.clipboard.writeText(data).catch(() => {\n      writeToClipboardPolyfill(data);\n    });\n  } else {\n    writeToClipboardPolyfill(data);\n  }\n}\nfunction hasNativeSelection(element) {\n  // When getSelection is called on an <iframe> that is not displayed Firefox will return null.\n  if (window.getSelection()?.toString()) {\n    return true;\n  }\n\n  // window.getSelection() returns an empty string in Firefox for selections inside a form element.\n  // See: https://bugzilla.mozilla.org/show_bug.cgi?id=85686.\n  // Instead, we can use element.selectionStart that is only defined on form elements.\n  if (element && (element.selectionEnd || 0) - (element.selectionStart || 0) > 0) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * @requires useGridCsvExport (method)\n * @requires useGridSelection (method)\n */\nexport const useGridClipboard = (apiRef, props) => {\n  const ignoreValueFormatterProp = props.ignoreValueFormatterDuringExport;\n  const ignoreValueFormatter = (typeof ignoreValueFormatterProp === 'object' ? ignoreValueFormatterProp?.clipboardExport : ignoreValueFormatterProp) || false;\n  const clipboardCopyCellDelimiter = props.clipboardCopyCellDelimiter;\n  const handleCopy = React.useCallback(event => {\n    if (!((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 'c' && !event.shiftKey && !event.altKey)) {\n      return;\n    }\n\n    // Do nothing if there's a native selection\n    if (hasNativeSelection(event.target)) {\n      return;\n    }\n    let textToCopy = '';\n    const selectedRows = apiRef.current.getSelectedRows();\n    if (selectedRows.size > 0) {\n      textToCopy = apiRef.current.getDataAsCsv({\n        includeHeaders: false,\n        delimiter: clipboardCopyCellDelimiter,\n        shouldAppendQuotes: false,\n        escapeFormulas: false\n      });\n    } else {\n      const focusedCell = gridFocusCellSelector(apiRef);\n      if (focusedCell) {\n        const cellParams = apiRef.current.getCellParams(focusedCell.id, focusedCell.field);\n        textToCopy = serializeCellValue(cellParams, {\n          csvOptions: {\n            delimiter: clipboardCopyCellDelimiter,\n            shouldAppendQuotes: false,\n            escapeFormulas: false\n          },\n          ignoreValueFormatter\n        });\n      }\n    }\n    textToCopy = apiRef.current.unstable_applyPipeProcessors('clipboardCopy', textToCopy);\n    if (textToCopy) {\n      copyToClipboard(textToCopy);\n      apiRef.current.publishEvent('clipboardCopy', textToCopy);\n    }\n  }, [apiRef, ignoreValueFormatter, clipboardCopyCellDelimiter]);\n  useGridNativeEventListener(apiRef, apiRef.current.rootElementRef, 'keydown', handleCopy);\n  useGridApiOptionHandler(apiRef, 'clipboardCopy', props.onClipboardCopy);\n};","import { createSelector, createSelectorMemoized } from '../../../utils/createSelector';\n/**\n * @category ColumnGrouping\n * @ignore - do not document.\n */\nexport const gridColumnGroupingSelector = state => state.columnGrouping;\nexport const gridColumnGroupsUnwrappedModelSelector = createSelectorMemoized(gridColumnGroupingSelector, columnGrouping => columnGrouping?.unwrappedGroupingModel ?? {});\nexport const gridColumnGroupsLookupSelector = createSelectorMemoized(gridColumnGroupingSelector, columnGrouping => columnGrouping?.lookup ?? {});\nexport const gridColumnGroupsHeaderStructureSelector = createSelectorMemoized(gridColumnGroupingSelector, columnGrouping => columnGrouping?.headerStructure ?? []);\nexport const gridColumnGroupsHeaderMaxDepthSelector = createSelector(gridColumnGroupingSelector, columnGrouping => columnGrouping?.maxDepth ?? 0);","import { isLeaf } from '../../../models/gridColumnGrouping';\nimport { isDeepEqual } from '../../../utils/utils';\n// This is the recurrence function that help writing `unwrapGroupingColumnModel()`\nconst recurrentUnwrapGroupingColumnModel = (columnGroupNode, parents, unwrappedGroupingModelToComplete) => {\n  if (isLeaf(columnGroupNode)) {\n    if (unwrappedGroupingModelToComplete[columnGroupNode.field] !== undefined) {\n      throw new Error([`MUI X: columnGroupingModel contains duplicated field`, `column field ${columnGroupNode.field} occurs two times in the grouping model:`, `- ${unwrappedGroupingModelToComplete[columnGroupNode.field].join(' > ')}`, `- ${parents.join(' > ')}`].join('\\n'));\n    }\n    unwrappedGroupingModelToComplete[columnGroupNode.field] = parents;\n    return;\n  }\n  const {\n    groupId,\n    children\n  } = columnGroupNode;\n  children.forEach(child => {\n    recurrentUnwrapGroupingColumnModel(child, [...parents, groupId], unwrappedGroupingModelToComplete);\n  });\n};\n\n/**\n * This is a function that provide for each column the array of its parents.\n * Parents are ordered from the root to the leaf.\n * @param columnGroupingModel The model such as provided in DataGrid props\n * @returns An object `{[field]: groupIds}` where `groupIds` is the parents of the column `field`\n */\nexport const unwrapGroupingColumnModel = columnGroupingModel => {\n  if (!columnGroupingModel) {\n    return {};\n  }\n  const unwrappedSubTree = {};\n  columnGroupingModel.forEach(columnGroupNode => {\n    recurrentUnwrapGroupingColumnModel(columnGroupNode, [], unwrappedSubTree);\n  });\n  return unwrappedSubTree;\n};\nexport const getColumnGroupsHeaderStructure = (orderedColumns, unwrappedGroupingModel, pinnedFields) => {\n  const getParents = field => unwrappedGroupingModel[field] ?? [];\n  const groupingHeaderStructure = [];\n  const maxDepth = Math.max(...orderedColumns.map(field => getParents(field).length));\n  const haveSameParents = (field1, field2, depth) => isDeepEqual(getParents(field1).slice(0, depth + 1), getParents(field2).slice(0, depth + 1));\n  const haveDifferentContainers = (field1, field2) => {\n    if (pinnedFields?.left && pinnedFields.left.includes(field1) && !pinnedFields.left.includes(field2)) {\n      return true;\n    }\n    if (pinnedFields?.right && !pinnedFields.right.includes(field1) && pinnedFields.right.includes(field2)) {\n      return true;\n    }\n    return false;\n  };\n  for (let depth = 0; depth < maxDepth; depth += 1) {\n    const depthStructure = orderedColumns.reduce((structure, newField) => {\n      const groupId = getParents(newField)[depth] ?? null;\n      if (structure.length === 0) {\n        return [{\n          columnFields: [newField],\n          groupId\n        }];\n      }\n      const lastGroup = structure[structure.length - 1];\n      const prevField = lastGroup.columnFields[lastGroup.columnFields.length - 1];\n      const prevGroupId = lastGroup.groupId;\n      if (prevGroupId !== groupId || !haveSameParents(prevField, newField, depth) ||\n      // Fix for https://github.com/mui/mui-x/issues/7041\n      haveDifferentContainers(prevField, newField)) {\n        // It's a new group\n        return [...structure, {\n          columnFields: [newField],\n          groupId\n        }];\n      }\n\n      // It extends the previous group\n      return [...structure.slice(0, structure.length - 1), {\n        columnFields: [...lastGroup.columnFields, newField],\n        groupId\n      }];\n    }, []);\n    groupingHeaderStructure.push(depthStructure);\n  }\n  return groupingHeaderStructure;\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"groupId\", \"children\"];\nimport * as React from 'react';\nimport { isLeaf } from '../../../models/gridColumnGrouping';\nimport { gridColumnGroupsLookupSelector, gridColumnGroupsUnwrappedModelSelector } from './gridColumnGroupsSelector';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { getColumnGroupsHeaderStructure, unwrapGroupingColumnModel } from './gridColumnGroupsUtils';\nimport { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';\nimport { gridColumnFieldsSelector, gridVisibleColumnFieldsSelector } from '../columns';\nconst createGroupLookup = columnGroupingModel => {\n  let groupLookup = {};\n  columnGroupingModel.forEach(node => {\n    if (isLeaf(node)) {\n      return;\n    }\n    const {\n        groupId,\n        children\n      } = node,\n      other = _objectWithoutPropertiesLoose(node, _excluded);\n    if (!groupId) {\n      throw new Error('MUI X: An element of the columnGroupingModel does not have either `field` or `groupId`.');\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      if (!children) {\n        console.warn(`MUI X: group groupId=${groupId} has no children.`);\n      }\n    }\n    const groupParam = _extends({}, other, {\n      groupId\n    });\n    const subTreeLookup = createGroupLookup(children);\n    if (subTreeLookup[groupId] !== undefined || groupLookup[groupId] !== undefined) {\n      throw new Error(`MUI X: The groupId ${groupId} is used multiple times in the columnGroupingModel.`);\n    }\n    groupLookup = _extends({}, groupLookup, subTreeLookup, {\n      [groupId]: groupParam\n    });\n  });\n  return _extends({}, groupLookup);\n};\nexport const columnGroupsStateInitializer = (state, props, apiRef) => {\n  if (!props.columnGroupingModel) {\n    return state;\n  }\n  const columnFields = gridColumnFieldsSelector(apiRef);\n  const visibleColumnFields = gridVisibleColumnFieldsSelector(apiRef);\n  const groupLookup = createGroupLookup(props.columnGroupingModel ?? []);\n  const unwrappedGroupingModel = unwrapGroupingColumnModel(props.columnGroupingModel ?? []);\n  const columnGroupsHeaderStructure = getColumnGroupsHeaderStructure(columnFields, unwrappedGroupingModel, apiRef.current.state.pinnedColumns ?? {});\n  const maxDepth = visibleColumnFields.length === 0 ? 0 : Math.max(...visibleColumnFields.map(field => unwrappedGroupingModel[field]?.length ?? 0));\n  return _extends({}, state, {\n    columnGrouping: {\n      lookup: groupLookup,\n      unwrappedGroupingModel,\n      headerStructure: columnGroupsHeaderStructure,\n      maxDepth\n    }\n  });\n};\n\n/**\n * @requires useGridColumns (method, event)\n * @requires useGridParamsApi (method)\n */\nexport const useGridColumnGrouping = (apiRef, props) => {\n  /**\n   * API METHODS\n   */\n  const getColumnGroupPath = React.useCallback(field => {\n    const unwrappedGroupingModel = gridColumnGroupsUnwrappedModelSelector(apiRef);\n    return unwrappedGroupingModel[field] ?? [];\n  }, [apiRef]);\n  const getAllGroupDetails = React.useCallback(() => {\n    const columnGroupLookup = gridColumnGroupsLookupSelector(apiRef);\n    return columnGroupLookup;\n  }, [apiRef]);\n  const columnGroupingApi = {\n    getColumnGroupPath,\n    getAllGroupDetails\n  };\n  useGridApiMethod(apiRef, columnGroupingApi, 'public');\n  const handleColumnIndexChange = React.useCallback(() => {\n    const unwrappedGroupingModel = unwrapGroupingColumnModel(props.columnGroupingModel ?? []);\n    apiRef.current.setState(state => {\n      const orderedFields = state.columns?.orderedFields ?? [];\n      const pinnedColumns = state.pinnedColumns ?? {};\n      const columnGroupsHeaderStructure = getColumnGroupsHeaderStructure(orderedFields, unwrappedGroupingModel, pinnedColumns);\n      return _extends({}, state, {\n        columnGrouping: _extends({}, state.columnGrouping, {\n          headerStructure: columnGroupsHeaderStructure\n        })\n      });\n    });\n  }, [apiRef, props.columnGroupingModel]);\n  const updateColumnGroupingState = React.useCallback(columnGroupingModel => {\n    // @ts-expect-error Move this logic to `Pro` package\n    const pinnedColumns = apiRef.current.getPinnedColumns?.() ?? {};\n    const columnFields = gridColumnFieldsSelector(apiRef);\n    const visibleColumnFields = gridVisibleColumnFieldsSelector(apiRef);\n    const groupLookup = createGroupLookup(columnGroupingModel ?? []);\n    const unwrappedGroupingModel = unwrapGroupingColumnModel(columnGroupingModel ?? []);\n    const columnGroupsHeaderStructure = getColumnGroupsHeaderStructure(columnFields, unwrappedGroupingModel, pinnedColumns);\n    const maxDepth = visibleColumnFields.length === 0 ? 0 : Math.max(...visibleColumnFields.map(field => unwrappedGroupingModel[field]?.length ?? 0));\n    apiRef.current.setState(state => {\n      return _extends({}, state, {\n        columnGrouping: {\n          lookup: groupLookup,\n          unwrappedGroupingModel,\n          headerStructure: columnGroupsHeaderStructure,\n          maxDepth\n        }\n      });\n    });\n  }, [apiRef]);\n  useGridApiEventHandler(apiRef, 'columnIndexChange', handleColumnIndexChange);\n  useGridApiEventHandler(apiRef, 'columnsChange', () => {\n    updateColumnGroupingState(props.columnGroupingModel);\n  });\n  useGridApiEventHandler(apiRef, 'columnVisibilityModelChange', () => {\n    updateColumnGroupingState(props.columnGroupingModel);\n  });\n\n  /**\n   * EFFECTS\n   */\n  React.useEffect(() => {\n    updateColumnGroupingState(props.columnGroupingModel);\n  }, [updateColumnGroupingState, props.columnGroupingModel]);\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport clsx from 'clsx';\nimport { styled, useTheme } from '@mui/material/styles';\nimport { useGridSelector } from '../../utils';\nimport { useGridRootProps } from '../../utils/useGridRootProps';\nimport { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';\nimport { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';\nimport { GridColumnHeaderItem } from '../../../components/columnHeaders/GridColumnHeaderItem';\nimport { gridDimensionsSelector } from '../dimensions';\nimport { gridRenderContextColumnsSelector, gridVirtualizationColumnEnabledSelector } from '../virtualization';\nimport { computeOffsetLeft } from '../virtualization/useGridVirtualScroller';\nimport { GridColumnGroupHeader } from '../../../components/columnHeaders/GridColumnGroupHeader';\nimport { GridPinnedColumnPosition, gridColumnPositionsSelector, gridVisiblePinnedColumnDefinitionsSelector } from '../columns';\nimport { gridColumnGroupsUnwrappedModelSelector } from '../columnGrouping/gridColumnGroupsSelector';\nimport { GridScrollbarFillerCell as ScrollbarFiller } from '../../../components/GridScrollbarFillerCell';\nimport { getPinnedCellOffset } from '../../../internals/utils/getPinnedCellOffset';\nimport { GridColumnHeaderSeparatorSides } from '../../../components/columnHeaders/GridColumnHeaderSeparator';\nimport { gridClasses } from '../../../constants/gridClasses';\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nexport const GridColumnHeaderRow = styled('div', {\n  name: 'MuiDataGrid',\n  slot: 'ColumnHeaderRow',\n  overridesResolver: (_, styles) => styles.columnHeaderRow\n})({\n  display: 'flex'\n});\nexport const useGridColumnHeaders = props => {\n  const {\n    visibleColumns,\n    sortColumnLookup,\n    filterColumnLookup,\n    columnHeaderTabIndexState,\n    columnGroupHeaderTabIndexState,\n    columnHeaderFocus,\n    columnGroupHeaderFocus,\n    headerGroupingMaxDepth,\n    columnMenuState,\n    columnVisibility,\n    columnGroupsHeaderStructure,\n    hasOtherElementInTabSequence\n  } = props;\n  const [dragCol, setDragCol] = React.useState('');\n  const [resizeCol, setResizeCol] = React.useState('');\n  const apiRef = useGridPrivateApiContext();\n  const theme = useTheme();\n  const rootProps = useGridRootProps();\n  const dimensions = useGridSelector(apiRef, gridDimensionsSelector);\n  const hasVirtualization = useGridSelector(apiRef, gridVirtualizationColumnEnabledSelector);\n  const columnGroupsModel = useGridSelector(apiRef, gridColumnGroupsUnwrappedModelSelector);\n  const columnPositions = useGridSelector(apiRef, gridColumnPositionsSelector);\n  const renderContext = useGridSelector(apiRef, gridRenderContextColumnsSelector);\n  const pinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);\n  const offsetLeft = computeOffsetLeft(columnPositions, renderContext, theme.direction, pinnedColumns.left.length);\n  const gridHasFiller = dimensions.columnsTotalWidth < dimensions.viewportOuterSize.width;\n  React.useEffect(() => {\n    apiRef.current.columnHeadersContainerRef.current.scrollLeft = 0;\n  }, [apiRef]);\n  const handleColumnResizeStart = React.useCallback(params => setResizeCol(params.field), []);\n  const handleColumnResizeStop = React.useCallback(() => setResizeCol(''), []);\n  const handleColumnReorderStart = React.useCallback(params => setDragCol(params.field), []);\n  const handleColumnReorderStop = React.useCallback(() => setDragCol(''), []);\n  const leftRenderContext = React.useMemo(() => {\n    return pinnedColumns.left.length ? {\n      firstColumnIndex: 0,\n      lastColumnIndex: pinnedColumns.left.length\n    } : null;\n  }, [pinnedColumns.left.length]);\n  const rightRenderContext = React.useMemo(() => {\n    return pinnedColumns.right.length ? {\n      firstColumnIndex: visibleColumns.length - pinnedColumns.right.length,\n      lastColumnIndex: visibleColumns.length\n    } : null;\n  }, [pinnedColumns.right.length, visibleColumns.length]);\n  useGridApiEventHandler(apiRef, 'columnResizeStart', handleColumnResizeStart);\n  useGridApiEventHandler(apiRef, 'columnResizeStop', handleColumnResizeStop);\n  useGridApiEventHandler(apiRef, 'columnHeaderDragStart', handleColumnReorderStart);\n  useGridApiEventHandler(apiRef, 'columnHeaderDragEnd', handleColumnReorderStop);\n\n  // Helper for computation common between getColumnHeaders and getColumnGroupHeaders\n  const getColumnsToRender = params => {\n    const {\n      renderContext: currentContext = renderContext,\n      // TODO: `minFirstColumn` is not used anymore, could be refactored out.\n      maxLastColumn = visibleColumns.length\n    } = params || {};\n    const firstColumnToRender = !hasVirtualization ? 0 : currentContext.firstColumnIndex;\n    const lastColumnToRender = !hasVirtualization ? maxLastColumn : currentContext.lastColumnIndex;\n    const renderedColumns = visibleColumns.slice(firstColumnToRender, lastColumnToRender);\n    return {\n      renderedColumns,\n      firstColumnToRender,\n      lastColumnToRender\n    };\n  };\n  const getFillers = (params, children, leftOverflow, borderTop = false) => {\n    const isPinnedRight = params?.position === GridPinnedColumnPosition.RIGHT;\n    const isNotPinned = params?.position === undefined;\n    const hasScrollbarFiller = pinnedColumns.right.length > 0 && isPinnedRight || pinnedColumns.right.length === 0 && isNotPinned;\n    const leftOffsetWidth = offsetLeft - leftOverflow;\n    return /*#__PURE__*/_jsxs(React.Fragment, {\n      children: [isNotPinned && /*#__PURE__*/_jsx(\"div\", {\n        role: \"presentation\",\n        style: {\n          width: leftOffsetWidth\n        }\n      }), children, isNotPinned && /*#__PURE__*/_jsx(\"div\", {\n        role: \"presentation\",\n        className: clsx(gridClasses.filler, borderTop && gridClasses['filler--borderTop'])\n      }), hasScrollbarFiller && /*#__PURE__*/_jsx(ScrollbarFiller, {\n        header: true,\n        borderTop: borderTop,\n        pinnedRight: isPinnedRight\n      })]\n    });\n  };\n  const getCellOffsetStyle = ({\n    pinnedPosition,\n    columnIndex,\n    computedWidth\n  }) => {\n    let style;\n    if (pinnedPosition === 'left' || pinnedPosition === 'right') {\n      const pinnedOffset = getPinnedCellOffset(pinnedPosition, computedWidth, columnIndex, columnPositions, dimensions);\n      if (pinnedPosition === 'left') {\n        style = {\n          left: pinnedOffset\n        };\n      }\n      if (pinnedPosition === 'right') {\n        style = {\n          right: pinnedOffset\n        };\n      }\n    }\n    return style;\n  };\n  const getColumnHeaders = (params, other = {}) => {\n    const {\n      renderedColumns,\n      firstColumnToRender\n    } = getColumnsToRender(params);\n    const columns = [];\n    for (let i = 0; i < renderedColumns.length; i += 1) {\n      const colDef = renderedColumns[i];\n      const columnIndex = firstColumnToRender + i;\n      const isFirstColumn = columnIndex === 0;\n      const tabIndex = columnHeaderTabIndexState !== null && columnHeaderTabIndexState.field === colDef.field || isFirstColumn && !hasOtherElementInTabSequence ? 0 : -1;\n      const hasFocus = columnHeaderFocus !== null && columnHeaderFocus.field === colDef.field;\n      const open = columnMenuState.open && columnMenuState.field === colDef.field;\n      const pinnedPosition = params?.position;\n      const style = getCellOffsetStyle({\n        pinnedPosition,\n        columnIndex,\n        computedWidth: colDef.computedWidth\n      });\n      columns.push( /*#__PURE__*/_jsx(GridColumnHeaderItem, _extends({}, sortColumnLookup[colDef.field], {\n        columnMenuOpen: open,\n        filterItemsCounter: filterColumnLookup[colDef.field] && filterColumnLookup[colDef.field].length,\n        headerHeight: dimensions.headerHeight,\n        isDragging: colDef.field === dragCol,\n        colDef: colDef,\n        colIndex: columnIndex,\n        isResizing: resizeCol === colDef.field,\n        isLast: columnIndex === columnPositions.length - 1,\n        hasFocus: hasFocus,\n        tabIndex: tabIndex,\n        pinnedPosition: pinnedPosition,\n        style: style,\n        indexInSection: i,\n        sectionLength: renderedColumns.length,\n        gridHasFiller: gridHasFiller\n      }, other), colDef.field));\n    }\n    return getFillers(params, columns, 0);\n  };\n  const getColumnHeadersRow = () => {\n    return /*#__PURE__*/_jsxs(GridColumnHeaderRow, {\n      role: \"row\",\n      \"aria-rowindex\": headerGroupingMaxDepth + 1,\n      ownerState: rootProps,\n      children: [leftRenderContext && getColumnHeaders({\n        position: GridPinnedColumnPosition.LEFT,\n        renderContext: leftRenderContext,\n        minFirstColumn: leftRenderContext.firstColumnIndex,\n        maxLastColumn: leftRenderContext.lastColumnIndex\n      }, {\n        disableReorder: true\n      }), getColumnHeaders({\n        renderContext,\n        minFirstColumn: pinnedColumns.left.length,\n        maxLastColumn: visibleColumns.length - pinnedColumns.right.length\n      }), rightRenderContext && getColumnHeaders({\n        position: GridPinnedColumnPosition.RIGHT,\n        renderContext: rightRenderContext,\n        minFirstColumn: rightRenderContext.firstColumnIndex,\n        maxLastColumn: rightRenderContext.lastColumnIndex\n      }, {\n        disableReorder: true,\n        separatorSide: GridColumnHeaderSeparatorSides.Left\n      })]\n    });\n  };\n  const getColumnGroupHeaders = ({\n    depth,\n    params\n  }) => {\n    const columnsToRender = getColumnsToRender(params);\n    if (columnsToRender.renderedColumns.length === 0) {\n      return null;\n    }\n    const {\n      renderedColumns,\n      firstColumnToRender,\n      lastColumnToRender\n    } = columnsToRender;\n    const rowStructure = columnGroupsHeaderStructure[depth];\n    const firstColumnFieldToRender = visibleColumns[firstColumnToRender].field;\n    const firstGroupToRender = columnGroupsModel[firstColumnFieldToRender]?.[depth] ?? null;\n    const firstGroupIndex = rowStructure.findIndex(({\n      groupId,\n      columnFields\n    }) => groupId === firstGroupToRender && columnFields.includes(firstColumnFieldToRender));\n    const lastColumnFieldToRender = visibleColumns[lastColumnToRender - 1].field;\n    const lastGroupToRender = columnGroupsModel[lastColumnFieldToRender]?.[depth] ?? null;\n    const lastGroupIndex = rowStructure.findIndex(({\n      groupId,\n      columnFields\n    }) => groupId === lastGroupToRender && columnFields.includes(lastColumnFieldToRender));\n    const visibleColumnGroupHeader = rowStructure.slice(firstGroupIndex, lastGroupIndex + 1).map(groupStructure => {\n      return _extends({}, groupStructure, {\n        columnFields: groupStructure.columnFields.filter(field => columnVisibility[field] !== false)\n      });\n    }).filter(groupStructure => groupStructure.columnFields.length > 0);\n    const firstVisibleColumnIndex = visibleColumnGroupHeader[0].columnFields.indexOf(firstColumnFieldToRender);\n    const hiddenGroupColumns = visibleColumnGroupHeader[0].columnFields.slice(0, firstVisibleColumnIndex);\n    const leftOverflow = hiddenGroupColumns.reduce((acc, field) => {\n      const column = apiRef.current.getColumn(field);\n      return acc + (column.computedWidth ?? 0);\n    }, 0);\n    let columnIndex = firstColumnToRender;\n    const children = visibleColumnGroupHeader.map(({\n      groupId,\n      columnFields\n    }, index) => {\n      const hasFocus = columnGroupHeaderFocus !== null && columnGroupHeaderFocus.depth === depth && columnFields.includes(columnGroupHeaderFocus.field);\n      const tabIndex = columnGroupHeaderTabIndexState !== null && columnGroupHeaderTabIndexState.depth === depth && columnFields.includes(columnGroupHeaderTabIndexState.field) ? 0 : -1;\n      const headerInfo = {\n        groupId,\n        width: columnFields.reduce((acc, field) => acc + apiRef.current.getColumn(field).computedWidth, 0),\n        fields: columnFields,\n        colIndex: columnIndex,\n        hasFocus,\n        tabIndex\n      };\n      const pinnedPosition = params.position;\n      const style = getCellOffsetStyle({\n        pinnedPosition,\n        columnIndex,\n        computedWidth: headerInfo.width\n      });\n      columnIndex += columnFields.length;\n      let indexInSection = index;\n      if (pinnedPosition === 'left') {\n        // Group headers can expand to multiple columns, we need to adjust the index\n        indexInSection = columnIndex - 1;\n      }\n      return /*#__PURE__*/_jsx(GridColumnGroupHeader, {\n        groupId: groupId,\n        width: headerInfo.width,\n        fields: headerInfo.fields,\n        colIndex: headerInfo.colIndex,\n        depth: depth,\n        isLastColumn: headerInfo.colIndex === visibleColumns.length - headerInfo.fields.length,\n        maxDepth: headerGroupingMaxDepth,\n        height: dimensions.headerHeight,\n        hasFocus: hasFocus,\n        tabIndex: tabIndex,\n        pinnedPosition: pinnedPosition,\n        style: style,\n        indexInSection: indexInSection,\n        sectionLength: renderedColumns.length,\n        gridHasFiller: gridHasFiller\n      }, index);\n    });\n    return getFillers(params, children, leftOverflow);\n  };\n  const getColumnGroupHeadersRows = () => {\n    if (headerGroupingMaxDepth === 0) {\n      return null;\n    }\n    const headerRows = [];\n    for (let depth = 0; depth < headerGroupingMaxDepth; depth += 1) {\n      headerRows.push( /*#__PURE__*/_jsxs(GridColumnHeaderRow, {\n        role: \"row\",\n        \"aria-rowindex\": depth + 1,\n        ownerState: rootProps,\n        children: [leftRenderContext && getColumnGroupHeaders({\n          depth,\n          params: {\n            position: GridPinnedColumnPosition.LEFT,\n            renderContext: leftRenderContext,\n            minFirstColumn: leftRenderContext.firstColumnIndex,\n            maxLastColumn: leftRenderContext.lastColumnIndex\n          }\n        }), getColumnGroupHeaders({\n          depth,\n          params: {\n            renderContext\n          }\n        }), rightRenderContext && getColumnGroupHeaders({\n          depth,\n          params: {\n            position: GridPinnedColumnPosition.RIGHT,\n            renderContext: rightRenderContext,\n            minFirstColumn: rightRenderContext.firstColumnIndex,\n            maxLastColumn: rightRenderContext.lastColumnIndex\n          }\n        })]\n      }, depth));\n    }\n    return headerRows;\n  };\n  return {\n    renderContext,\n    leftRenderContext,\n    rightRenderContext,\n    pinnedColumns,\n    visibleColumns,\n    getCellOffsetStyle,\n    getFillers,\n    getColumnHeadersRow,\n    getColumnsToRender,\n    getColumnGroupHeadersRows,\n    isDragging: !!dragCol,\n    getInnerProps: () => ({\n      role: 'rowgroup'\n    })\n  };\n};","export const gridColumnMenuSelector = state => state.columnMenu;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { useGridLogger, useGridApiMethod, useGridApiEventHandler } from '../../utils';\nimport { gridColumnMenuSelector } from './columnMenuSelector';\nimport { gridColumnLookupSelector, gridColumnVisibilityModelSelector, gridColumnFieldsSelector } from '../columns/gridColumnsSelector';\nexport const columnMenuStateInitializer = state => _extends({}, state, {\n  columnMenu: {\n    open: false\n  }\n});\n\n/**\n * @requires useGridColumnResize (event)\n * @requires useGridInfiniteLoader (event)\n */\nexport const useGridColumnMenu = apiRef => {\n  const logger = useGridLogger(apiRef, 'useGridColumnMenu');\n\n  /**\n   * API METHODS\n   */\n  const showColumnMenu = React.useCallback(field => {\n    const columnMenuState = gridColumnMenuSelector(apiRef.current.state);\n    const newState = {\n      open: true,\n      field\n    };\n    const shouldUpdate = newState.open !== columnMenuState.open || newState.field !== columnMenuState.field;\n    if (shouldUpdate) {\n      apiRef.current.setState(state => {\n        if (state.columnMenu.open && state.columnMenu.field === field) {\n          return state;\n        }\n        logger.debug('Opening Column Menu');\n        return _extends({}, state, {\n          columnMenu: {\n            open: true,\n            field\n          }\n        });\n      });\n      apiRef.current.hidePreferences();\n      apiRef.current.forceUpdate();\n    }\n  }, [apiRef, logger]);\n  const hideColumnMenu = React.useCallback(() => {\n    const columnMenuState = gridColumnMenuSelector(apiRef.current.state);\n    if (columnMenuState.field) {\n      const columnLookup = gridColumnLookupSelector(apiRef);\n      const columnVisibilityModel = gridColumnVisibilityModelSelector(apiRef);\n      const orderedFields = gridColumnFieldsSelector(apiRef);\n      let fieldToFocus = columnMenuState.field;\n\n      // If the column was removed from the grid, we need to find the closest visible field\n      if (!columnLookup[fieldToFocus]) {\n        fieldToFocus = orderedFields[0];\n      }\n\n      // If the field to focus is hidden, we need to find the closest visible field\n      if (columnVisibilityModel[fieldToFocus] === false) {\n        // contains visible column fields + the field that was just hidden\n        const visibleOrderedFields = orderedFields.filter(field => {\n          if (field === fieldToFocus) {\n            return true;\n          }\n          return columnVisibilityModel[field] !== false;\n        });\n        const fieldIndex = visibleOrderedFields.indexOf(fieldToFocus);\n        fieldToFocus = visibleOrderedFields[fieldIndex + 1] || visibleOrderedFields[fieldIndex - 1];\n      }\n      apiRef.current.setColumnHeaderFocus(fieldToFocus);\n    }\n    const newState = {\n      open: false,\n      field: undefined\n    };\n    const shouldUpdate = newState.open !== columnMenuState.open || newState.field !== columnMenuState.field;\n    if (shouldUpdate) {\n      apiRef.current.setState(state => {\n        logger.debug('Hiding Column Menu');\n        return _extends({}, state, {\n          columnMenu: newState\n        });\n      });\n      apiRef.current.forceUpdate();\n    }\n  }, [apiRef, logger]);\n  const toggleColumnMenu = React.useCallback(field => {\n    logger.debug('Toggle Column Menu');\n    const columnMenu = gridColumnMenuSelector(apiRef.current.state);\n    if (!columnMenu.open || columnMenu.field !== field) {\n      showColumnMenu(field);\n    } else {\n      hideColumnMenu();\n    }\n  }, [apiRef, logger, showColumnMenu, hideColumnMenu]);\n  const columnMenuApi = {\n    showColumnMenu,\n    hideColumnMenu,\n    toggleColumnMenu\n  };\n  useGridApiMethod(apiRef, columnMenuApi, 'public');\n  useGridApiEventHandler(apiRef, 'columnResizeStart', hideColumnMenu);\n  useGridApiEventHandler(apiRef, 'virtualScrollerWheel', apiRef.current.hideColumnMenu);\n  useGridApiEventHandler(apiRef, 'virtualScrollerTouchMove', apiRef.current.hideColumnMenu);\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"displayOrder\"];\nimport * as React from 'react';\nimport Divider from '@mui/material/Divider';\nimport { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';\nconst useGridColumnMenuSlots = props => {\n  const apiRef = useGridPrivateApiContext();\n  const {\n    defaultSlots,\n    defaultSlotProps,\n    slots = {},\n    slotProps = {},\n    hideMenu,\n    colDef,\n    addDividers = true\n  } = props;\n  const processedComponents = React.useMemo(() => _extends({}, defaultSlots, slots), [defaultSlots, slots]);\n  const processedSlotProps = React.useMemo(() => {\n    if (!slotProps || Object.keys(slotProps).length === 0) {\n      return defaultSlotProps;\n    }\n    const mergedProps = _extends({}, slotProps);\n    Object.entries(defaultSlotProps).forEach(([key, currentSlotProps]) => {\n      mergedProps[key] = _extends({}, currentSlotProps, slotProps[key] || {});\n    });\n    return mergedProps;\n  }, [defaultSlotProps, slotProps]);\n  const defaultItems = apiRef.current.unstable_applyPipeProcessors('columnMenu', [], props.colDef);\n  const userItems = React.useMemo(() => {\n    const defaultComponentKeys = Object.keys(defaultSlots);\n    return Object.keys(slots).filter(key => !defaultComponentKeys.includes(key));\n  }, [slots, defaultSlots]);\n  return React.useMemo(() => {\n    const uniqueItems = Array.from(new Set([...defaultItems, ...userItems]));\n    const cleansedItems = uniqueItems.filter(key => processedComponents[key] != null);\n    const sorted = cleansedItems.sort((a, b) => {\n      const leftItemProps = processedSlotProps[a];\n      const rightItemProps = processedSlotProps[b];\n      const leftDisplayOrder = Number.isFinite(leftItemProps?.displayOrder) ? leftItemProps.displayOrder : 100;\n      const rightDisplayOrder = Number.isFinite(rightItemProps?.displayOrder) ? rightItemProps.displayOrder : 100;\n      return leftDisplayOrder - rightDisplayOrder;\n    });\n    return sorted.reduce((acc, key, index) => {\n      let itemProps = {\n        colDef,\n        onClick: hideMenu\n      };\n      const processedComponentProps = processedSlotProps[key];\n      if (processedComponentProps) {\n        const customProps = _objectWithoutPropertiesLoose(processedComponentProps, _excluded);\n        itemProps = _extends({}, itemProps, customProps);\n      }\n      return addDividers && index !== sorted.length - 1 ? [...acc, [processedComponents[key], itemProps], [Divider, {}]] : [...acc, [processedComponents[key], itemProps]];\n    }, []);\n  }, [addDividers, colDef, defaultItems, hideMenu, processedComponents, processedSlotProps, userItems]);\n};\nexport { useGridColumnMenuSlots };","export const DEFAULT_GRID_AUTOSIZE_OPTIONS = {\n  includeHeaders: true,\n  includeOutliers: false,\n  outliersFactor: 1.5,\n  expand: false\n};\n\n/**\n * The Resize API interface that is available in the grid `apiRef`.\n */","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_ownerDocument as ownerDocument, unstable_useEventCallback as useEventCallback } from '@mui/utils';\nimport useLazyRef from '@mui/utils/useLazyRef';\nimport { useTheme } from '@mui/material/styles';\nimport { findGridCellElementsFromCol, findGridElement, findLeftPinnedCellsAfterCol, findRightPinnedCellsBeforeCol, getFieldFromHeaderElem, findHeaderElementFromField, getFieldsFromGroupHeaderElem, findGroupHeaderElementsFromField, findGridHeader, findGridCells, findParentElementFromClassName, findLeftPinnedHeadersAfterCol, findRightPinnedHeadersBeforeCol, escapeOperandAttributeSelector } from '../../../utils/domUtils';\nimport { DEFAULT_GRID_AUTOSIZE_OPTIONS } from './gridColumnResizeApi';\nimport { gridClasses } from '../../../constants/gridClasses';\nimport { useGridApiEventHandler, useGridApiMethod, useGridApiOptionHandler, useGridLogger, useGridNativeEventListener, useGridSelector, useOnMount } from '../../utils';\nimport { gridVirtualizationColumnEnabledSelector } from '../virtualization';\nimport { createControllablePromise } from '../../../utils/createControllablePromise';\nimport { clamp } from '../../../utils/utils';\nimport { useTimeout } from '../../utils/useTimeout';\nimport { GridPinnedColumnPosition } from '../columns/gridColumnsInterfaces';\nimport { gridColumnsStateSelector } from '../columns';\nfunction trackFinger(event, currentTouchId) {\n  if (currentTouchId !== undefined && event.changedTouches) {\n    for (let i = 0; i < event.changedTouches.length; i += 1) {\n      const touch = event.changedTouches[i];\n      if (touch.identifier === currentTouchId) {\n        return {\n          x: touch.clientX,\n          y: touch.clientY\n        };\n      }\n    }\n    return false;\n  }\n  return {\n    x: event.clientX,\n    y: event.clientY\n  };\n}\nfunction computeNewWidth(initialOffsetToSeparator, clickX, columnBounds, resizeDirection) {\n  let newWidth = initialOffsetToSeparator;\n  if (resizeDirection === 'Right') {\n    newWidth += clickX - columnBounds.left;\n  } else {\n    newWidth += columnBounds.right - clickX;\n  }\n  return newWidth;\n}\nfunction computeOffsetToSeparator(clickX, columnBounds, resizeDirection) {\n  if (resizeDirection === 'Left') {\n    return clickX - columnBounds.left;\n  }\n  return columnBounds.right - clickX;\n}\nfunction flipResizeDirection(side) {\n  if (side === 'Right') {\n    return 'Left';\n  }\n  return 'Right';\n}\nfunction getResizeDirection(separator, direction) {\n  const side = separator.classList.contains(gridClasses['columnSeparator--sideRight']) ? 'Right' : 'Left';\n  if (direction === 'rtl') {\n    // Resizing logic should be mirrored in the RTL case\n    return flipResizeDirection(side);\n  }\n  return side;\n}\nfunction preventClick(event) {\n  event.preventDefault();\n  event.stopImmediatePropagation();\n}\n\n/**\n * Checker that returns a promise that resolves when the column virtualization\n * is disabled.\n */\nfunction useColumnVirtualizationDisabled(apiRef) {\n  const promise = React.useRef();\n  const selector = () => gridVirtualizationColumnEnabledSelector(apiRef);\n  const value = useGridSelector(apiRef, selector);\n  React.useEffect(() => {\n    if (promise.current && value === false) {\n      promise.current.resolve();\n      promise.current = undefined;\n    }\n  });\n  const asyncCheck = () => {\n    if (!promise.current) {\n      if (selector() === false) {\n        return Promise.resolve();\n      }\n      promise.current = createControllablePromise();\n    }\n    return promise.current;\n  };\n  return asyncCheck;\n}\n\n/**\n * Basic statistical outlier detection, checks if the value is `F * IQR` away from\n * the Q1 and Q3 boundaries. IQR: interquartile range.\n */\nfunction excludeOutliers(inputValues, factor) {\n  if (inputValues.length < 4) {\n    return inputValues;\n  }\n  const values = inputValues.slice();\n  values.sort((a, b) => a - b);\n  const q1 = values[Math.floor(values.length * 0.25)];\n  const q3 = values[Math.floor(values.length * 0.75) - 1];\n  const iqr = q3 - q1;\n\n  // We make a small adjustment if `iqr < 5` for the cases where the IQR is\n  // very small (for example zero) due to very close by values in the input data.\n  // Otherwise, with an IQR of `0`, anything outside that would be considered\n  // an outlier, but it makes more sense visually to allow for this 5px variance\n  // rather than showing a cropped cell.\n  const deviation = iqr < 5 ? 5 : iqr * factor;\n  return values.filter(v => v > q1 - deviation && v < q3 + deviation);\n}\nfunction extractColumnWidths(apiRef, options, columns) {\n  const widthByField = {};\n  const root = apiRef.current.rootElementRef.current;\n  root.classList.add(gridClasses.autosizing);\n  columns.forEach(column => {\n    const cells = findGridCells(apiRef.current, column.field);\n    const widths = cells.map(cell => {\n      return cell.getBoundingClientRect().width ?? 0;\n    });\n    const filteredWidths = options.includeOutliers ? widths : excludeOutliers(widths, options.outliersFactor);\n    if (options.includeHeaders) {\n      const header = findGridHeader(apiRef.current, column.field);\n      if (header) {\n        const title = header.querySelector(`.${gridClasses.columnHeaderTitle}`);\n        const content = header.querySelector(`.${gridClasses.columnHeaderTitleContainerContent}`);\n        const iconContainer = header.querySelector(`.${gridClasses.iconButtonContainer}`);\n        const menuContainer = header.querySelector(`.${gridClasses.menuIcon}`);\n        const element = title ?? content;\n        const style = window.getComputedStyle(header, null);\n        const paddingWidth = parseInt(style.paddingLeft, 10) + parseInt(style.paddingRight, 10);\n        const contentWidth = element.scrollWidth + 1;\n        const width = contentWidth + paddingWidth + (iconContainer?.clientWidth ?? 0) + (menuContainer?.clientWidth ?? 0);\n        filteredWidths.push(width);\n      }\n    }\n    const hasColumnMin = column.minWidth !== -Infinity && column.minWidth !== undefined;\n    const hasColumnMax = column.maxWidth !== Infinity && column.maxWidth !== undefined;\n    const min = hasColumnMin ? column.minWidth : 0;\n    const max = hasColumnMax ? column.maxWidth : Infinity;\n    const maxContent = filteredWidths.length === 0 ? 0 : Math.max(...filteredWidths);\n    widthByField[column.field] = clamp(maxContent, min, max);\n  });\n  root.classList.remove(gridClasses.autosizing);\n  return widthByField;\n}\nexport const columnResizeStateInitializer = state => _extends({}, state, {\n  columnResize: {\n    resizingColumnField: ''\n  }\n});\nfunction createResizeRefs() {\n  return {\n    colDef: undefined,\n    initialColWidth: 0,\n    initialTotalWidth: 0,\n    previousMouseClickEvent: undefined,\n    columnHeaderElement: undefined,\n    headerFilterElement: undefined,\n    groupHeaderElements: [],\n    cellElements: [],\n    leftPinnedCellsAfter: [],\n    rightPinnedCellsBefore: [],\n    fillerLeft: undefined,\n    fillerRight: undefined,\n    leftPinnedHeadersAfter: [],\n    rightPinnedHeadersBefore: []\n  };\n}\n\n/**\n * @requires useGridColumns (method, event)\n * TODO: improve experience for last column\n */\nexport const useGridColumnResize = (apiRef, props) => {\n  const theme = useTheme();\n  const logger = useGridLogger(apiRef, 'useGridColumnResize');\n  const refs = useLazyRef(createResizeRefs).current;\n\n  // To improve accessibility, the separator has padding on both sides.\n  // Clicking inside the padding area should be treated as a click in the separator.\n  // This ref stores the offset between the click and the separator.\n  const initialOffsetToSeparator = React.useRef();\n  const resizeDirection = React.useRef();\n  const stopResizeEventTimeout = useTimeout();\n  const touchId = React.useRef();\n  const updateWidth = newWidth => {\n    logger.debug(`Updating width to ${newWidth} for col ${refs.colDef.field}`);\n    const prevWidth = refs.columnHeaderElement.offsetWidth;\n    const widthDiff = newWidth - prevWidth;\n    const columnWidthDiff = newWidth - refs.initialColWidth;\n    const newTotalWidth = refs.initialTotalWidth + columnWidthDiff;\n    apiRef.current.rootElementRef?.current?.style.setProperty('--DataGrid-rowWidth', `${newTotalWidth}px`);\n    refs.colDef.computedWidth = newWidth;\n    refs.colDef.width = newWidth;\n    refs.colDef.flex = 0;\n    refs.columnHeaderElement.style.width = `${newWidth}px`;\n    refs.columnHeaderElement.style.minWidth = `${newWidth}px`;\n    refs.columnHeaderElement.style.maxWidth = `${newWidth}px`;\n    const headerFilterElement = refs.headerFilterElement;\n    if (headerFilterElement) {\n      headerFilterElement.style.width = `${newWidth}px`;\n      headerFilterElement.style.minWidth = `${newWidth}px`;\n      headerFilterElement.style.maxWidth = `${newWidth}px`;\n    }\n    refs.groupHeaderElements.forEach(element => {\n      const div = element;\n      let finalWidth;\n      if (div.getAttribute('aria-colspan') === '1') {\n        finalWidth = `${newWidth}px`;\n      } else {\n        // Cell with colspan > 1 cannot be just updated width new width.\n        // Instead, we add width diff to the current width.\n        finalWidth = `${div.offsetWidth + widthDiff}px`;\n      }\n      div.style.width = finalWidth;\n      div.style.minWidth = finalWidth;\n      div.style.maxWidth = finalWidth;\n    });\n    refs.cellElements.forEach(element => {\n      const div = element;\n      let finalWidth;\n      if (div.getAttribute('aria-colspan') === '1') {\n        finalWidth = `${newWidth}px`;\n      } else {\n        // Cell with colspan > 1 cannot be just updated width new width.\n        // Instead, we add width diff to the current width.\n        finalWidth = `${div.offsetWidth + widthDiff}px`;\n      }\n      div.style.setProperty('--width', finalWidth);\n    });\n    const pinnedPosition = apiRef.current.unstable_applyPipeProcessors('isColumnPinned', false, refs.colDef.field);\n    if (pinnedPosition === GridPinnedColumnPosition.LEFT) {\n      updateProperty(refs.fillerLeft, 'width', widthDiff);\n      refs.leftPinnedCellsAfter.forEach(cell => {\n        updateProperty(cell, 'left', widthDiff);\n      });\n      refs.leftPinnedHeadersAfter.forEach(header => {\n        updateProperty(header, 'left', widthDiff);\n      });\n    }\n    if (pinnedPosition === GridPinnedColumnPosition.RIGHT) {\n      updateProperty(refs.fillerRight, 'width', widthDiff);\n      refs.rightPinnedCellsBefore.forEach(cell => {\n        updateProperty(cell, 'right', widthDiff);\n      });\n      refs.rightPinnedHeadersBefore.forEach(header => {\n        updateProperty(header, 'right', widthDiff);\n      });\n    }\n  };\n  const finishResize = nativeEvent => {\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    stopListening();\n\n    // Prevent double-clicks from being interpreted as two separate clicks\n    if (refs.previousMouseClickEvent) {\n      const prevEvent = refs.previousMouseClickEvent;\n      const prevTimeStamp = prevEvent.timeStamp;\n      const prevClientX = prevEvent.clientX;\n      const prevClientY = prevEvent.clientY;\n\n      // Check if the current event is part of a double-click\n      if (nativeEvent.timeStamp - prevTimeStamp < 300 && nativeEvent.clientX === prevClientX && nativeEvent.clientY === prevClientY) {\n        refs.previousMouseClickEvent = undefined;\n        return;\n      }\n    }\n    if (refs.colDef) {\n      apiRef.current.setColumnWidth(refs.colDef.field, refs.colDef.width);\n      logger.debug(`Updating col ${refs.colDef.field} with new width: ${refs.colDef.width}`);\n\n      // Since during resizing we update the columns width outside of React, React is unable to\n      // reapply the right style properties. We need to sync the state manually.\n      // So we reapply the same logic as in https://github.com/mui/mui-x/blob/0511bf65543ca05d2602a5a3e0a6156f2fc8e759/packages/x-data-grid/src/hooks/features/columnHeaders/useGridColumnHeaders.tsx#L405\n      const columnsState = gridColumnsStateSelector(apiRef.current.state);\n      refs.groupHeaderElements.forEach(element => {\n        const fields = getFieldsFromGroupHeaderElem(element);\n        const div = element;\n        const newWidth = fields.reduce((acc, field) => {\n          if (columnsState.columnVisibilityModel[field] !== false) {\n            return acc + columnsState.lookup[field].computedWidth;\n          }\n          return acc;\n        }, 0);\n        const finalWidth = `${newWidth}px`;\n        div.style.width = finalWidth;\n        div.style.minWidth = finalWidth;\n        div.style.maxWidth = finalWidth;\n      });\n    }\n    stopResizeEventTimeout.start(0, () => {\n      apiRef.current.publishEvent('columnResizeStop', null, nativeEvent);\n    });\n  };\n  const storeReferences = (colDef, separator, xStart) => {\n    const root = apiRef.current.rootElementRef.current;\n    refs.initialColWidth = colDef.computedWidth;\n    refs.initialTotalWidth = apiRef.current.getRootDimensions().rowWidth;\n    refs.colDef = colDef;\n    refs.columnHeaderElement = findHeaderElementFromField(apiRef.current.columnHeadersContainerRef.current, colDef.field);\n    const headerFilterElement = root.querySelector(`.${gridClasses.headerFilterRow} [data-field=\"${escapeOperandAttributeSelector(colDef.field)}\"]`);\n    if (headerFilterElement) {\n      refs.headerFilterElement = headerFilterElement;\n    }\n    refs.groupHeaderElements = findGroupHeaderElementsFromField(apiRef.current.columnHeadersContainerRef?.current, colDef.field);\n    refs.cellElements = findGridCellElementsFromCol(refs.columnHeaderElement, apiRef.current);\n    refs.fillerLeft = findGridElement(apiRef.current, 'filler--pinnedLeft');\n    refs.fillerRight = findGridElement(apiRef.current, 'filler--pinnedRight');\n    const pinnedPosition = apiRef.current.unstable_applyPipeProcessors('isColumnPinned', false, refs.colDef.field);\n    refs.leftPinnedCellsAfter = pinnedPosition !== GridPinnedColumnPosition.LEFT ? [] : findLeftPinnedCellsAfterCol(apiRef.current, refs.columnHeaderElement);\n    refs.rightPinnedCellsBefore = pinnedPosition !== GridPinnedColumnPosition.RIGHT ? [] : findRightPinnedCellsBeforeCol(apiRef.current, refs.columnHeaderElement);\n    refs.leftPinnedHeadersAfter = pinnedPosition !== GridPinnedColumnPosition.LEFT ? [] : findLeftPinnedHeadersAfterCol(apiRef.current, refs.columnHeaderElement);\n    refs.rightPinnedHeadersBefore = pinnedPosition !== GridPinnedColumnPosition.RIGHT ? [] : findRightPinnedHeadersBeforeCol(apiRef.current, refs.columnHeaderElement);\n    resizeDirection.current = getResizeDirection(separator, theme.direction);\n    initialOffsetToSeparator.current = computeOffsetToSeparator(xStart, refs.columnHeaderElement.getBoundingClientRect(), resizeDirection.current);\n  };\n  const handleResizeMouseUp = useEventCallback(finishResize);\n  const handleResizeMouseMove = useEventCallback(nativeEvent => {\n    // Cancel move in case some other element consumed a mouseup event and it was not fired.\n    if (nativeEvent.buttons === 0) {\n      handleResizeMouseUp(nativeEvent);\n      return;\n    }\n    let newWidth = computeNewWidth(initialOffsetToSeparator.current, nativeEvent.clientX, refs.columnHeaderElement.getBoundingClientRect(), resizeDirection.current);\n    newWidth = clamp(newWidth, refs.colDef.minWidth, refs.colDef.maxWidth);\n    updateWidth(newWidth);\n    const params = {\n      element: refs.columnHeaderElement,\n      colDef: refs.colDef,\n      width: newWidth\n    };\n    apiRef.current.publishEvent('columnResize', params, nativeEvent);\n  });\n  const handleTouchEnd = useEventCallback(nativeEvent => {\n    const finger = trackFinger(nativeEvent, touchId.current);\n    if (!finger) {\n      return;\n    }\n    finishResize(nativeEvent);\n  });\n  const handleTouchMove = useEventCallback(nativeEvent => {\n    const finger = trackFinger(nativeEvent, touchId.current);\n    if (!finger) {\n      return;\n    }\n\n    // Cancel move in case some other element consumed a touchmove event and it was not fired.\n    if (nativeEvent.type === 'mousemove' && nativeEvent.buttons === 0) {\n      handleTouchEnd(nativeEvent);\n      return;\n    }\n    let newWidth = computeNewWidth(initialOffsetToSeparator.current, finger.x, refs.columnHeaderElement.getBoundingClientRect(), resizeDirection.current);\n    newWidth = clamp(newWidth, refs.colDef.minWidth, refs.colDef.maxWidth);\n    updateWidth(newWidth);\n    const params = {\n      element: refs.columnHeaderElement,\n      colDef: refs.colDef,\n      width: newWidth\n    };\n    apiRef.current.publishEvent('columnResize', params, nativeEvent);\n  });\n  const handleTouchStart = useEventCallback(event => {\n    const cellSeparator = findParentElementFromClassName(event.target, gridClasses['columnSeparator--resizable']);\n    // Let the event bubble if the target is not a col separator\n    if (!cellSeparator) {\n      return;\n    }\n    const touch = event.changedTouches[0];\n    if (touch != null) {\n      // A number that uniquely identifies the current finger in the touch session.\n      touchId.current = touch.identifier;\n    }\n    const columnHeaderElement = findParentElementFromClassName(event.target, gridClasses.columnHeader);\n    const field = getFieldFromHeaderElem(columnHeaderElement);\n    const colDef = apiRef.current.getColumn(field);\n    logger.debug(`Start Resize on col ${colDef.field}`);\n    apiRef.current.publishEvent('columnResizeStart', {\n      field\n    }, event);\n    storeReferences(colDef, cellSeparator, touch.clientX);\n    const doc = ownerDocument(event.currentTarget);\n    doc.addEventListener('touchmove', handleTouchMove);\n    doc.addEventListener('touchend', handleTouchEnd);\n  });\n  const stopListening = React.useCallback(() => {\n    const doc = ownerDocument(apiRef.current.rootElementRef.current);\n    doc.body.style.removeProperty('cursor');\n    doc.removeEventListener('mousemove', handleResizeMouseMove);\n    doc.removeEventListener('mouseup', handleResizeMouseUp);\n    doc.removeEventListener('touchmove', handleTouchMove);\n    doc.removeEventListener('touchend', handleTouchEnd);\n    // The click event runs right after the mouseup event, we want to wait until it\n    // has been canceled before removing our handler.\n    setTimeout(() => {\n      doc.removeEventListener('click', preventClick, true);\n    }, 100);\n    if (refs.columnHeaderElement) {\n      refs.columnHeaderElement.style.pointerEvents = 'unset';\n    }\n  }, [apiRef, refs, handleResizeMouseMove, handleResizeMouseUp, handleTouchMove, handleTouchEnd]);\n  const handleResizeStart = React.useCallback(({\n    field\n  }) => {\n    apiRef.current.setState(state => _extends({}, state, {\n      columnResize: _extends({}, state.columnResize, {\n        resizingColumnField: field\n      })\n    }));\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const handleResizeStop = React.useCallback(() => {\n    apiRef.current.setState(state => _extends({}, state, {\n      columnResize: _extends({}, state.columnResize, {\n        resizingColumnField: ''\n      })\n    }));\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const handleColumnResizeMouseDown = useEventCallback(({\n    colDef\n  }, event) => {\n    // Only handle left clicks\n    if (event.button !== 0) {\n      return;\n    }\n\n    // Skip if the column isn't resizable\n    if (!event.currentTarget.classList.contains(gridClasses['columnSeparator--resizable'])) {\n      return;\n    }\n\n    // Avoid text selection\n    event.preventDefault();\n    logger.debug(`Start Resize on col ${colDef.field}`);\n    apiRef.current.publishEvent('columnResizeStart', {\n      field: colDef.field\n    }, event);\n    storeReferences(colDef, event.currentTarget, event.clientX);\n    const doc = ownerDocument(apiRef.current.rootElementRef.current);\n    doc.body.style.cursor = 'col-resize';\n    refs.previousMouseClickEvent = event.nativeEvent;\n    doc.addEventListener('mousemove', handleResizeMouseMove);\n    doc.addEventListener('mouseup', handleResizeMouseUp);\n\n    // Prevent the click event if we have resized the column.\n    // Fixes https://github.com/mui/mui-x/issues/4777\n    doc.addEventListener('click', preventClick, true);\n  });\n  const handleColumnSeparatorDoubleClick = useEventCallback((params, event) => {\n    if (props.disableAutosize) {\n      return;\n    }\n\n    // Only handle left clicks\n    if (event.button !== 0) {\n      return;\n    }\n    const column = apiRef.current.state.columns.lookup[params.field];\n    if (column.resizable === false) {\n      return;\n    }\n    apiRef.current.autosizeColumns(_extends({}, props.autosizeOptions, {\n      columns: [column.field]\n    }));\n  });\n\n  /**\n   * API METHODS\n   */\n\n  const columnVirtualizationDisabled = useColumnVirtualizationDisabled(apiRef);\n  const isAutosizingRef = React.useRef(false);\n  const autosizeColumns = React.useCallback(async userOptions => {\n    const root = apiRef.current.rootElementRef?.current;\n    if (!root) {\n      return;\n    }\n    if (isAutosizingRef.current) {\n      return;\n    }\n    isAutosizingRef.current = true;\n    const state = gridColumnsStateSelector(apiRef.current.state);\n    const options = _extends({}, DEFAULT_GRID_AUTOSIZE_OPTIONS, userOptions, {\n      columns: userOptions?.columns ?? state.orderedFields\n    });\n    options.columns = options.columns.filter(c => state.columnVisibilityModel[c] !== false);\n    const columns = options.columns.map(c => apiRef.current.state.columns.lookup[c]);\n    try {\n      apiRef.current.unstable_setColumnVirtualization(false);\n      await columnVirtualizationDisabled();\n      const widthByField = extractColumnWidths(apiRef, options, columns);\n      const newColumns = columns.map(column => _extends({}, column, {\n        width: widthByField[column.field],\n        computedWidth: widthByField[column.field]\n      }));\n      if (options.expand) {\n        const visibleColumns = state.orderedFields.map(field => state.lookup[field]).filter(c => state.columnVisibilityModel[c.field] !== false);\n        const totalWidth = visibleColumns.reduce((total, column) => total + (widthByField[column.field] ?? column.computedWidth ?? column.width), 0);\n        const availableWidth = apiRef.current.getRootDimensions().viewportInnerSize.width;\n        const remainingWidth = availableWidth - totalWidth;\n        if (remainingWidth > 0) {\n          const widthPerColumn = remainingWidth / (newColumns.length || 1);\n          newColumns.forEach(column => {\n            column.width += widthPerColumn;\n            column.computedWidth += widthPerColumn;\n          });\n        }\n      }\n      apiRef.current.updateColumns(newColumns);\n      newColumns.forEach((newColumn, index) => {\n        if (newColumn.width !== columns[index].width) {\n          const width = newColumn.width;\n          apiRef.current.publishEvent('columnWidthChange', {\n            element: apiRef.current.getColumnHeaderElement(newColumn.field),\n            colDef: newColumn,\n            width\n          });\n        }\n      });\n    } finally {\n      apiRef.current.unstable_setColumnVirtualization(true);\n      isAutosizingRef.current = false;\n    }\n  }, [apiRef, columnVirtualizationDisabled]);\n\n  /**\n   * EFFECTS\n   */\n\n  React.useEffect(() => stopListening, [stopListening]);\n  useOnMount(() => {\n    if (props.autosizeOnMount) {\n      Promise.resolve().then(() => {\n        apiRef.current.autosizeColumns(props.autosizeOptions);\n      });\n    }\n  });\n  useGridNativeEventListener(apiRef, () => apiRef.current.columnHeadersContainerRef?.current, 'touchstart', handleTouchStart, {\n    passive: true\n  });\n  useGridApiMethod(apiRef, {\n    autosizeColumns\n  }, 'public');\n  useGridApiEventHandler(apiRef, 'columnResizeStop', handleResizeStop);\n  useGridApiEventHandler(apiRef, 'columnResizeStart', handleResizeStart);\n  useGridApiEventHandler(apiRef, 'columnSeparatorMouseDown', handleColumnResizeMouseDown);\n  useGridApiEventHandler(apiRef, 'columnSeparatorDoubleClick', handleColumnSeparatorDoubleClick);\n  useGridApiOptionHandler(apiRef, 'columnResize', props.onColumnResize);\n  useGridApiOptionHandler(apiRef, 'columnWidthChange', props.onColumnWidthChange);\n};\nfunction updateProperty(element, property, delta) {\n  if (!element) {\n    return;\n  }\n  element.style[property] = `${parseInt(element.style[property], 10) + delta}px`;\n}","export let GridPinnedColumnPosition = /*#__PURE__*/function (GridPinnedColumnPosition) {\n  GridPinnedColumnPosition[\"LEFT\"] = \"left\";\n  GridPinnedColumnPosition[\"RIGHT\"] = \"right\";\n  return GridPinnedColumnPosition;\n}({});\nexport const EMPTY_PINNED_COLUMN_FIELDS = {\n  left: [],\n  right: []\n};","import { createSelector, createSelectorMemoized } from '../../../utils/createSelector';\nimport { EMPTY_PINNED_COLUMN_FIELDS } from './gridColumnsInterfaces';\nimport { gridThemeSelector } from '../../core/gridCoreSelector';\n\n/**\n * Get the columns state\n * @category Columns\n */\nexport const gridColumnsStateSelector = state => state.columns;\n\n/**\n * Get an array of column fields in the order rendered on screen.\n * @category Columns\n */\nexport const gridColumnFieldsSelector = createSelector(gridColumnsStateSelector, columnsState => columnsState.orderedFields);\n\n/**\n * Get the columns as a lookup (an object containing the field for keys and the definition for values).\n * @category Columns\n */\nexport const gridColumnLookupSelector = createSelector(gridColumnsStateSelector, columnsState => columnsState.lookup);\n\n/**\n * Get an array of column definitions in the order rendered on screen..\n * @category Columns\n */\nexport const gridColumnDefinitionsSelector = createSelectorMemoized(gridColumnFieldsSelector, gridColumnLookupSelector, (allFields, lookup) => allFields.map(field => lookup[field]));\n\n/**\n * Get the column visibility model, containing the visibility status of each column.\n * If a column is not registered in the model, it is visible.\n * @category Visible Columns\n */\nexport const gridColumnVisibilityModelSelector = createSelector(gridColumnsStateSelector, columnsState => columnsState.columnVisibilityModel);\n\n/**\n * Get the visible columns as a lookup (an object containing the field for keys and the definition for values).\n * @category Visible Columns\n */\nexport const gridVisibleColumnDefinitionsSelector = createSelectorMemoized(gridColumnDefinitionsSelector, gridColumnVisibilityModelSelector, (columns, columnVisibilityModel) => columns.filter(column => columnVisibilityModel[column.field] !== false));\n\n/**\n * Get the field of each visible column.\n * @category Visible Columns\n */\nexport const gridVisibleColumnFieldsSelector = createSelectorMemoized(gridVisibleColumnDefinitionsSelector, visibleColumns => visibleColumns.map(column => column.field));\n\n/**\n * Get the visible pinned columns model.\n * @category Visible Columns\n */\nexport const gridPinnedColumnsSelector = state => state.pinnedColumns;\n\n/**\n * Get the visible pinned columns.\n * @category Visible Columns\n */\nexport const gridVisiblePinnedColumnDefinitionsSelector = createSelectorMemoized(gridColumnsStateSelector, gridPinnedColumnsSelector, gridVisibleColumnFieldsSelector, gridThemeSelector, (columnsState, model, visibleColumnFields, theme) => {\n  const visiblePinnedFields = filterVisibleColumns(model, visibleColumnFields, theme.direction === 'rtl');\n  const visiblePinnedColumns = {\n    left: visiblePinnedFields.left.map(field => columnsState.lookup[field]),\n    right: visiblePinnedFields.right.map(field => columnsState.lookup[field])\n  };\n  return visiblePinnedColumns;\n});\nfunction filterVisibleColumns(pinnedColumns, columns, invert) {\n  if (!Array.isArray(pinnedColumns.left) && !Array.isArray(pinnedColumns.right)) {\n    return EMPTY_PINNED_COLUMN_FIELDS;\n  }\n  if (pinnedColumns.left?.length === 0 && pinnedColumns.right?.length === 0) {\n    return EMPTY_PINNED_COLUMN_FIELDS;\n  }\n  const filter = (newPinnedColumns, remainingColumns) => {\n    if (!Array.isArray(newPinnedColumns)) {\n      return [];\n    }\n    return newPinnedColumns.filter(field => remainingColumns.includes(field));\n  };\n  const leftPinnedColumns = filter(pinnedColumns.left, columns);\n  const columnsWithoutLeftPinnedColumns = columns.filter(\n  // Filter out from the remaining columns those columns already pinned to the left\n  field => !leftPinnedColumns.includes(field));\n  const rightPinnedColumns = filter(pinnedColumns.right, columnsWithoutLeftPinnedColumns);\n  if (invert) {\n    return {\n      left: rightPinnedColumns,\n      right: leftPinnedColumns\n    };\n  }\n  return {\n    left: leftPinnedColumns,\n    right: rightPinnedColumns\n  };\n}\n\n/**\n * Get the left position in pixel of each visible columns relative to the left of the first column.\n * @category Visible Columns\n */\nexport const gridColumnPositionsSelector = createSelectorMemoized(gridVisibleColumnDefinitionsSelector, visibleColumns => {\n  const positions = [];\n  let currentPosition = 0;\n  for (let i = 0; i < visibleColumns.length; i += 1) {\n    positions.push(currentPosition);\n    currentPosition += visibleColumns[i].computedWidth;\n  }\n  return positions;\n});\n\n/**\n * Get the summed width of all the visible columns.\n * @category Visible Columns\n */\nexport const gridColumnsTotalWidthSelector = createSelector(gridVisibleColumnDefinitionsSelector, gridColumnPositionsSelector, (visibleColumns, positions) => {\n  const colCount = visibleColumns.length;\n  if (colCount === 0) {\n    return 0;\n  }\n  return positions[colCount - 1] + visibleColumns[colCount - 1].computedWidth;\n});\n\n/**\n * Get the filterable columns as an array.\n * @category Columns\n */\nexport const gridFilterableColumnDefinitionsSelector = createSelectorMemoized(gridColumnDefinitionsSelector, columns => columns.filter(col => col.filterable));\n\n/**\n * Get the filterable columns as a lookup (an object containing the field for keys and the definition for values).\n * @category Columns\n */\nexport const gridFilterableColumnLookupSelector = createSelectorMemoized(gridColumnDefinitionsSelector, columns => columns.reduce((acc, col) => {\n  if (col.filterable) {\n    acc[col.field] = col;\n  }\n  return acc;\n}, {}));\n\n/**\n * Checks if some column has a colSpan field.\n * @category Columns\n * @ignore - Do not document\n */\nexport const gridHasColSpanSelector = createSelectorMemoized(gridColumnDefinitionsSelector, columns => columns.some(column => column.colSpan !== undefined));","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { DEFAULT_GRID_COL_TYPE_KEY, GRID_STRING_COL_DEF, getGridDefaultColumnTypes } from '../../../colDef';\nimport { gridColumnsStateSelector, gridColumnVisibilityModelSelector } from './gridColumnsSelector';\nimport { clamp } from '../../../utils/utils';\nimport { gridDensityFactorSelector } from '../density/densitySelector';\nimport { gridHeaderFilteringEnabledSelector } from '../headerFiltering/gridHeaderFilteringSelectors';\nimport { gridColumnGroupsHeaderMaxDepthSelector } from '../columnGrouping/gridColumnGroupsSelector';\nexport const COLUMNS_DIMENSION_PROPERTIES = ['maxWidth', 'minWidth', 'width', 'flex'];\nconst COLUMN_TYPES = getGridDefaultColumnTypes();\n\n/**\n * Computes width for flex columns.\n * Based on CSS Flexbox specification:\n * https://drafts.csswg.org/css-flexbox-1/#resolve-flexible-lengths\n */\nexport function computeFlexColumnsWidth({\n  initialFreeSpace,\n  totalFlexUnits,\n  flexColumns\n}) {\n  const uniqueFlexColumns = new Set(flexColumns.map(col => col.field));\n  const flexColumnsLookup = {\n    all: {},\n    frozenFields: [],\n    freeze: field => {\n      const value = flexColumnsLookup.all[field];\n      if (value && value.frozen !== true) {\n        flexColumnsLookup.all[field].frozen = true;\n        flexColumnsLookup.frozenFields.push(field);\n      }\n    }\n  };\n\n  // Step 5 of https://drafts.csswg.org/css-flexbox-1/#resolve-flexible-lengths\n  function loopOverFlexItems() {\n    // 5a: If all the flex items on the line are frozen, free space has been distributed.\n    if (flexColumnsLookup.frozenFields.length === uniqueFlexColumns.size) {\n      return;\n    }\n    const violationsLookup = {\n      min: {},\n      max: {}\n    };\n    let remainingFreeSpace = initialFreeSpace;\n    let flexUnits = totalFlexUnits;\n    let totalViolation = 0;\n\n    // 5b: Calculate the remaining free space\n    flexColumnsLookup.frozenFields.forEach(field => {\n      remainingFreeSpace -= flexColumnsLookup.all[field].computedWidth;\n      flexUnits -= flexColumnsLookup.all[field].flex;\n    });\n    for (let i = 0; i < flexColumns.length; i += 1) {\n      const column = flexColumns[i];\n      if (flexColumnsLookup.all[column.field] && flexColumnsLookup.all[column.field].frozen === true) {\n        continue;\n      }\n\n      // 5c: Distribute remaining free space proportional to the flex factors\n      const widthPerFlexUnit = remainingFreeSpace / flexUnits;\n      let computedWidth = widthPerFlexUnit * column.flex;\n\n      // 5d: Fix min/max violations\n      if (computedWidth < column.minWidth) {\n        totalViolation += column.minWidth - computedWidth;\n        computedWidth = column.minWidth;\n        violationsLookup.min[column.field] = true;\n      } else if (computedWidth > column.maxWidth) {\n        totalViolation += column.maxWidth - computedWidth;\n        computedWidth = column.maxWidth;\n        violationsLookup.max[column.field] = true;\n      }\n      flexColumnsLookup.all[column.field] = {\n        frozen: false,\n        computedWidth,\n        flex: column.flex\n      };\n    }\n\n    // 5e: Freeze over-flexed items\n    if (totalViolation < 0) {\n      // Freeze all the items with max violations\n      Object.keys(violationsLookup.max).forEach(field => {\n        flexColumnsLookup.freeze(field);\n      });\n    } else if (totalViolation > 0) {\n      // Freeze all the items with min violations\n      Object.keys(violationsLookup.min).forEach(field => {\n        flexColumnsLookup.freeze(field);\n      });\n    } else {\n      // Freeze all items\n      flexColumns.forEach(({\n        field\n      }) => {\n        flexColumnsLookup.freeze(field);\n      });\n    }\n\n    // 5f: Return to the start of this loop\n    loopOverFlexItems();\n  }\n  loopOverFlexItems();\n  return flexColumnsLookup.all;\n}\n\n/**\n * Compute the `computedWidth` (ie: the width the column should have during rendering) based on the `width` / `flex` / `minWidth` / `maxWidth` properties of `GridColDef`.\n * The columns already have been merged with there `type` default values for `minWidth`, `maxWidth` and `width`, thus the `!` for those properties below.\n * TODO: Unit test this function in depth and only keep basic cases for the whole grid testing.\n * TODO: Improve the `GridColDef` typing to reflect the fact that `minWidth` / `maxWidth` and `width` can't be null after the merge with the `type` default values.\n */\nexport const hydrateColumnsWidth = (rawState, dimensions) => {\n  const columnsLookup = {};\n  let totalFlexUnits = 0;\n  let widthAllocatedBeforeFlex = 0;\n  const flexColumns = [];\n\n  // For the non-flex columns, compute their width\n  // For the flex columns, compute their minimum width and how much width must be allocated during the flex allocation\n  rawState.orderedFields.forEach(columnField => {\n    let column = rawState.lookup[columnField];\n    let computedWidth = 0;\n    let isFlex = false;\n    if (rawState.columnVisibilityModel[columnField] !== false) {\n      if (column.flex && column.flex > 0) {\n        totalFlexUnits += column.flex;\n        isFlex = true;\n      } else {\n        computedWidth = clamp(column.width || GRID_STRING_COL_DEF.width, column.minWidth || GRID_STRING_COL_DEF.minWidth, column.maxWidth || GRID_STRING_COL_DEF.maxWidth);\n      }\n      widthAllocatedBeforeFlex += computedWidth;\n    }\n    if (column.computedWidth !== computedWidth) {\n      column = _extends({}, column, {\n        computedWidth\n      });\n    }\n    if (isFlex) {\n      flexColumns.push(column);\n    }\n    columnsLookup[columnField] = column;\n  });\n  const availableWidth = dimensions === undefined ? 0 : dimensions.viewportOuterSize.width - (dimensions.hasScrollY ? dimensions.scrollbarSize : 0);\n  const initialFreeSpace = Math.max(availableWidth - widthAllocatedBeforeFlex, 0);\n\n  // Allocate the remaining space to the flex columns\n  if (totalFlexUnits > 0 && availableWidth > 0) {\n    const computedColumnWidths = computeFlexColumnsWidth({\n      initialFreeSpace,\n      totalFlexUnits,\n      flexColumns\n    });\n    Object.keys(computedColumnWidths).forEach(field => {\n      columnsLookup[field].computedWidth = computedColumnWidths[field].computedWidth;\n    });\n  }\n  return _extends({}, rawState, {\n    lookup: columnsLookup\n  });\n};\n\n/**\n * Apply the order and the dimensions of the initial state.\n * The columns not registered in `orderedFields` will be placed after the imported columns.\n */\nexport const applyInitialState = (columnsState, initialState) => {\n  if (!initialState) {\n    return columnsState;\n  }\n  const {\n    orderedFields = [],\n    dimensions = {}\n  } = initialState;\n  const columnsWithUpdatedDimensions = Object.keys(dimensions);\n  if (columnsWithUpdatedDimensions.length === 0 && orderedFields.length === 0) {\n    return columnsState;\n  }\n  const orderedFieldsLookup = {};\n  const cleanOrderedFields = [];\n  for (let i = 0; i < orderedFields.length; i += 1) {\n    const field = orderedFields[i];\n\n    // Ignores the fields in the initialState that matches no field on the current column state\n    if (columnsState.lookup[field]) {\n      orderedFieldsLookup[field] = true;\n      cleanOrderedFields.push(field);\n    }\n  }\n  const newOrderedFields = cleanOrderedFields.length === 0 ? columnsState.orderedFields : [...cleanOrderedFields, ...columnsState.orderedFields.filter(field => !orderedFieldsLookup[field])];\n  const newColumnLookup = _extends({}, columnsState.lookup);\n  for (let i = 0; i < columnsWithUpdatedDimensions.length; i += 1) {\n    const field = columnsWithUpdatedDimensions[i];\n    const newColDef = _extends({}, newColumnLookup[field], {\n      hasBeenResized: true\n    });\n    Object.entries(dimensions[field]).forEach(([key, value]) => {\n      newColDef[key] = value === -1 ? Infinity : value;\n    });\n    newColumnLookup[field] = newColDef;\n  }\n  const newColumnsState = _extends({}, columnsState, {\n    orderedFields: newOrderedFields,\n    lookup: newColumnLookup\n  });\n  return newColumnsState;\n};\nfunction getDefaultColTypeDef(type) {\n  let colDef = COLUMN_TYPES[DEFAULT_GRID_COL_TYPE_KEY];\n  if (type && COLUMN_TYPES[type]) {\n    colDef = COLUMN_TYPES[type];\n  }\n  return colDef;\n}\nexport const createColumnsState = ({\n  apiRef,\n  columnsToUpsert,\n  initialState,\n  columnVisibilityModel = gridColumnVisibilityModelSelector(apiRef),\n  keepOnlyColumnsToUpsert = false\n}) => {\n  const isInsideStateInitializer = !apiRef.current.state.columns;\n  let columnsState;\n  if (isInsideStateInitializer) {\n    columnsState = {\n      orderedFields: [],\n      lookup: {},\n      columnVisibilityModel\n    };\n  } else {\n    const currentState = gridColumnsStateSelector(apiRef.current.state);\n    columnsState = {\n      orderedFields: keepOnlyColumnsToUpsert ? [] : [...currentState.orderedFields],\n      lookup: _extends({}, currentState.lookup),\n      // Will be cleaned later if keepOnlyColumnsToUpsert=true\n      columnVisibilityModel\n    };\n  }\n  let columnsToKeep = {};\n  if (keepOnlyColumnsToUpsert && !isInsideStateInitializer) {\n    columnsToKeep = Object.keys(columnsState.lookup).reduce((acc, key) => _extends({}, acc, {\n      [key]: false\n    }), {});\n  }\n  const columnsToUpsertLookup = {};\n  columnsToUpsert.forEach(newColumn => {\n    const {\n      field\n    } = newColumn;\n    columnsToUpsertLookup[field] = true;\n    columnsToKeep[field] = true;\n    let existingState = columnsState.lookup[field];\n    if (existingState == null) {\n      existingState = _extends({}, getDefaultColTypeDef(newColumn.type), {\n        field,\n        hasBeenResized: false\n      });\n      columnsState.orderedFields.push(field);\n    } else if (keepOnlyColumnsToUpsert) {\n      columnsState.orderedFields.push(field);\n    }\n\n    // If the column type has changed - merge the existing state with the default column type definition\n    if (existingState && existingState.type !== newColumn.type) {\n      existingState = _extends({}, getDefaultColTypeDef(newColumn.type), {\n        field\n      });\n    }\n    let hasBeenResized = existingState.hasBeenResized;\n    COLUMNS_DIMENSION_PROPERTIES.forEach(key => {\n      if (newColumn[key] !== undefined) {\n        hasBeenResized = true;\n        if (newColumn[key] === -1) {\n          newColumn[key] = Infinity;\n        }\n      }\n    });\n    columnsState.lookup[field] = _extends({}, existingState, newColumn, {\n      hasBeenResized\n    });\n  });\n  if (keepOnlyColumnsToUpsert && !isInsideStateInitializer) {\n    Object.keys(columnsState.lookup).forEach(field => {\n      if (!columnsToKeep[field]) {\n        delete columnsState.lookup[field];\n      }\n    });\n  }\n  const columnsStateWithPreProcessing = apiRef.current.unstable_applyPipeProcessors('hydrateColumns', columnsState);\n  const columnsStateWithPortableColumns = applyInitialState(columnsStateWithPreProcessing, initialState);\n  return hydrateColumnsWidth(columnsStateWithPortableColumns, apiRef.current.getRootDimensions?.() ?? undefined);\n};\nexport function getFirstNonSpannedColumnToRender({\n  firstColumnToRender,\n  apiRef,\n  firstRowToRender,\n  lastRowToRender,\n  visibleRows\n}) {\n  let firstNonSpannedColumnToRender = firstColumnToRender;\n  for (let i = firstRowToRender; i < lastRowToRender; i += 1) {\n    const row = visibleRows[i];\n    if (row) {\n      const rowId = visibleRows[i].id;\n      const cellColSpanInfo = apiRef.current.unstable_getCellColSpanInfo(rowId, firstColumnToRender);\n      if (cellColSpanInfo && cellColSpanInfo.spannedByColSpan) {\n        firstNonSpannedColumnToRender = cellColSpanInfo.leftVisibleCellIndex;\n      }\n    }\n  }\n  return firstNonSpannedColumnToRender;\n}\nexport function getTotalHeaderHeight(apiRef, props) {\n  const densityFactor = gridDensityFactorSelector(apiRef);\n  const maxDepth = gridColumnGroupsHeaderMaxDepthSelector(apiRef);\n  const isHeaderFilteringEnabled = gridHeaderFilteringEnabledSelector(apiRef);\n  const columnHeadersHeight = Math.floor(props.columnHeaderHeight * densityFactor);\n  const filterHeadersHeight = isHeaderFilteringEnabled ? Math.floor((props.headerFilterHeight ?? props.columnHeaderHeight) * densityFactor) : 0;\n  return columnHeadersHeight * (1 + (maxDepth ?? 0)) + filterHeadersHeight;\n}","import * as React from 'react';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';\n/**\n * @requires useGridColumns (method, event)\n * @requires useGridParamsApi (method)\n */\nexport const useGridColumnSpanning = apiRef => {\n  const lookup = React.useRef({});\n  const getCellColSpanInfo = (rowId, columnIndex) => {\n    return lookup.current[rowId]?.[columnIndex];\n  };\n  const resetColSpan = () => {\n    lookup.current = {};\n  };\n\n  // Calculate `colSpan` for each cell in the row\n  const calculateColSpan = React.useCallback(({\n    rowId,\n    minFirstColumn,\n    maxLastColumn,\n    columns\n  }) => {\n    for (let i = minFirstColumn; i < maxLastColumn; i += 1) {\n      const cellProps = calculateCellColSpan({\n        apiRef,\n        lookup: lookup.current,\n        columnIndex: i,\n        rowId,\n        minFirstColumnIndex: minFirstColumn,\n        maxLastColumnIndex: maxLastColumn,\n        columns\n      });\n      if (cellProps.colSpan > 1) {\n        i += cellProps.colSpan - 1;\n      }\n    }\n  }, [apiRef]);\n  const columnSpanningPublicApi = {\n    unstable_getCellColSpanInfo: getCellColSpanInfo\n  };\n  const columnSpanningPrivateApi = {\n    resetColSpan,\n    calculateColSpan\n  };\n  useGridApiMethod(apiRef, columnSpanningPublicApi, 'public');\n  useGridApiMethod(apiRef, columnSpanningPrivateApi, 'private');\n  useGridApiEventHandler(apiRef, 'columnOrderChange', resetColSpan);\n};\nfunction calculateCellColSpan(params) {\n  const {\n    apiRef,\n    lookup,\n    columnIndex,\n    rowId,\n    minFirstColumnIndex,\n    maxLastColumnIndex,\n    columns\n  } = params;\n  const columnsLength = columns.length;\n  const column = columns[columnIndex];\n  const row = apiRef.current.getRow(rowId);\n  const value = apiRef.current.getRowValue(row, column);\n  const colSpan = typeof column.colSpan === 'function' ? column.colSpan(value, row, column, apiRef) : column.colSpan;\n  if (!colSpan || colSpan === 1) {\n    setCellColSpanInfo(lookup, rowId, columnIndex, {\n      spannedByColSpan: false,\n      cellProps: {\n        colSpan: 1,\n        width: column.computedWidth\n      }\n    });\n    return {\n      colSpan: 1\n    };\n  }\n  let width = column.computedWidth;\n  for (let j = 1; j < colSpan; j += 1) {\n    const nextColumnIndex = columnIndex + j;\n    // Cells should be spanned only within their column section (left-pinned, right-pinned and unpinned).\n    if (nextColumnIndex >= minFirstColumnIndex && nextColumnIndex < maxLastColumnIndex) {\n      const nextColumn = columns[nextColumnIndex];\n      width += nextColumn.computedWidth;\n      setCellColSpanInfo(lookup, rowId, columnIndex + j, {\n        spannedByColSpan: true,\n        rightVisibleCellIndex: Math.min(columnIndex + colSpan, columnsLength - 1),\n        leftVisibleCellIndex: columnIndex\n      });\n    }\n    setCellColSpanInfo(lookup, rowId, columnIndex, {\n      spannedByColSpan: false,\n      cellProps: {\n        colSpan,\n        width\n      }\n    });\n  }\n  return {\n    colSpan\n  };\n}\nfunction setCellColSpanInfo(lookup, rowId, columnIndex, cellColSpanInfo) {\n  if (!lookup[rowId]) {\n    lookup[rowId] = {};\n  }\n  lookup[rowId][columnIndex] = cellColSpanInfo;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { useGridLogger } from '../../utils/useGridLogger';\nimport { gridColumnFieldsSelector, gridColumnDefinitionsSelector, gridColumnLookupSelector, gridColumnsStateSelector, gridColumnVisibilityModelSelector, gridVisibleColumnDefinitionsSelector, gridColumnPositionsSelector } from './gridColumnsSelector';\nimport { GridSignature, useGridApiEventHandler } from '../../utils/useGridApiEventHandler';\nimport { useGridRegisterPipeProcessor, useGridRegisterPipeApplier } from '../../core/pipeProcessing';\nimport { EMPTY_PINNED_COLUMN_FIELDS } from './gridColumnsInterfaces';\nimport { hydrateColumnsWidth, createColumnsState, COLUMNS_DIMENSION_PROPERTIES } from './gridColumnsUtils';\nimport { GridPreferencePanelsValue } from '../preferencesPanel';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const columnsStateInitializer = (state, props, apiRef) => {\n  const columnsState = createColumnsState({\n    apiRef,\n    columnsToUpsert: props.columns,\n    initialState: props.initialState?.columns,\n    columnVisibilityModel: props.columnVisibilityModel ?? props.initialState?.columns?.columnVisibilityModel ?? {},\n    keepOnlyColumnsToUpsert: true\n  });\n  return _extends({}, state, {\n    columns: columnsState,\n    // In pro/premium, this part of the state is defined. We give it an empty but defined value\n    // for the community version.\n    pinnedColumns: state.pinnedColumns ?? EMPTY_PINNED_COLUMN_FIELDS\n  });\n};\n\n/**\n * @requires useGridParamsApi (method)\n * @requires useGridDimensions (method, event) - can be after\n * TODO: Impossible priority - useGridParamsApi also needs to be after useGridColumns\n */\nexport function useGridColumns(apiRef, props) {\n  const logger = useGridLogger(apiRef, 'useGridColumns');\n  const previousColumnsProp = React.useRef(props.columns);\n  apiRef.current.registerControlState({\n    stateId: 'visibleColumns',\n    propModel: props.columnVisibilityModel,\n    propOnChange: props.onColumnVisibilityModelChange,\n    stateSelector: gridColumnVisibilityModelSelector,\n    changeEvent: 'columnVisibilityModelChange'\n  });\n  const setGridColumnsState = React.useCallback(columnsState => {\n    logger.debug('Updating columns state.');\n    apiRef.current.setState(mergeColumnsState(columnsState));\n    apiRef.current.publishEvent('columnsChange', columnsState.orderedFields);\n    apiRef.current.updateRenderContext?.();\n    apiRef.current.forceUpdate();\n  }, [logger, apiRef]);\n\n  /**\n   * API METHODS\n   */\n  const getColumn = React.useCallback(field => gridColumnLookupSelector(apiRef)[field], [apiRef]);\n  const getAllColumns = React.useCallback(() => gridColumnDefinitionsSelector(apiRef), [apiRef]);\n  const getVisibleColumns = React.useCallback(() => gridVisibleColumnDefinitionsSelector(apiRef), [apiRef]);\n  const getColumnIndex = React.useCallback((field, useVisibleColumns = true) => {\n    const columns = useVisibleColumns ? gridVisibleColumnDefinitionsSelector(apiRef) : gridColumnDefinitionsSelector(apiRef);\n    return columns.findIndex(col => col.field === field);\n  }, [apiRef]);\n  const getColumnPosition = React.useCallback(field => {\n    const index = getColumnIndex(field);\n    return gridColumnPositionsSelector(apiRef)[index];\n  }, [apiRef, getColumnIndex]);\n  const setColumnVisibilityModel = React.useCallback(model => {\n    const currentModel = gridColumnVisibilityModelSelector(apiRef);\n    if (currentModel !== model) {\n      apiRef.current.setState(state => _extends({}, state, {\n        columns: createColumnsState({\n          apiRef,\n          columnsToUpsert: [],\n          initialState: undefined,\n          columnVisibilityModel: model,\n          keepOnlyColumnsToUpsert: false\n        })\n      }));\n      apiRef.current.updateRenderContext?.();\n      apiRef.current.forceUpdate();\n    }\n  }, [apiRef]);\n  const updateColumns = React.useCallback(columns => {\n    const columnsState = createColumnsState({\n      apiRef,\n      columnsToUpsert: columns,\n      initialState: undefined,\n      keepOnlyColumnsToUpsert: false\n    });\n    setGridColumnsState(columnsState);\n  }, [apiRef, setGridColumnsState]);\n  const setColumnVisibility = React.useCallback((field, isVisible) => {\n    const columnVisibilityModel = gridColumnVisibilityModelSelector(apiRef);\n    const isCurrentlyVisible = columnVisibilityModel[field] ?? true;\n    if (isVisible !== isCurrentlyVisible) {\n      const newModel = _extends({}, columnVisibilityModel, {\n        [field]: isVisible\n      });\n      apiRef.current.setColumnVisibilityModel(newModel);\n    }\n  }, [apiRef]);\n  const getColumnIndexRelativeToVisibleColumns = React.useCallback(field => {\n    const allColumns = gridColumnFieldsSelector(apiRef);\n    return allColumns.findIndex(col => col === field);\n  }, [apiRef]);\n  const setColumnIndex = React.useCallback((field, targetIndexPosition) => {\n    const allColumns = gridColumnFieldsSelector(apiRef);\n    const oldIndexPosition = getColumnIndexRelativeToVisibleColumns(field);\n    if (oldIndexPosition === targetIndexPosition) {\n      return;\n    }\n    logger.debug(`Moving column ${field} to index ${targetIndexPosition}`);\n    const updatedColumns = [...allColumns];\n    const fieldRemoved = updatedColumns.splice(oldIndexPosition, 1)[0];\n    updatedColumns.splice(targetIndexPosition, 0, fieldRemoved);\n    setGridColumnsState(_extends({}, gridColumnsStateSelector(apiRef.current.state), {\n      orderedFields: updatedColumns\n    }));\n    const params = {\n      column: apiRef.current.getColumn(field),\n      targetIndex: apiRef.current.getColumnIndexRelativeToVisibleColumns(field),\n      oldIndex: oldIndexPosition\n    };\n    apiRef.current.publishEvent('columnIndexChange', params);\n  }, [apiRef, logger, setGridColumnsState, getColumnIndexRelativeToVisibleColumns]);\n  const setColumnWidth = React.useCallback((field, width) => {\n    logger.debug(`Updating column ${field} width to ${width}`);\n    const columnsState = gridColumnsStateSelector(apiRef.current.state);\n    const column = columnsState.lookup[field];\n    const newColumn = _extends({}, column, {\n      width,\n      hasBeenResized: true\n    });\n    setGridColumnsState(hydrateColumnsWidth(_extends({}, columnsState, {\n      lookup: _extends({}, columnsState.lookup, {\n        [field]: newColumn\n      })\n    }), apiRef.current.getRootDimensions()));\n    apiRef.current.publishEvent('columnWidthChange', {\n      element: apiRef.current.getColumnHeaderElement(field),\n      colDef: newColumn,\n      width\n    });\n  }, [apiRef, logger, setGridColumnsState]);\n  const columnApi = {\n    getColumn,\n    getAllColumns,\n    getColumnIndex,\n    getColumnPosition,\n    getVisibleColumns,\n    getColumnIndexRelativeToVisibleColumns,\n    updateColumns,\n    setColumnVisibilityModel,\n    setColumnVisibility,\n    setColumnWidth\n  };\n  const columnReorderApi = {\n    setColumnIndex\n  };\n  useGridApiMethod(apiRef, columnApi, 'public');\n  useGridApiMethod(apiRef, columnReorderApi, props.signature === GridSignature.DataGrid ? 'private' : 'public');\n\n  /**\n   * PRE-PROCESSING\n   */\n  const stateExportPreProcessing = React.useCallback((prevState, context) => {\n    const columnsStateToExport = {};\n    const columnVisibilityModelToExport = gridColumnVisibilityModelSelector(apiRef);\n    const shouldExportColumnVisibilityModel =\n    // Always export if the `exportOnlyDirtyModels` property is not activated\n    !context.exportOnlyDirtyModels ||\n    // Always export if the model is controlled\n    props.columnVisibilityModel != null ||\n    // Always export if the model has been initialized\n    // TODO v6 Do a nullish check instead to export even if the initial model equals \"{}\"\n    Object.keys(props.initialState?.columns?.columnVisibilityModel ?? {}).length > 0 ||\n    // Always export if the model is not empty\n    Object.keys(columnVisibilityModelToExport).length > 0;\n    if (shouldExportColumnVisibilityModel) {\n      columnsStateToExport.columnVisibilityModel = columnVisibilityModelToExport;\n    }\n    columnsStateToExport.orderedFields = gridColumnFieldsSelector(apiRef);\n    const columns = gridColumnDefinitionsSelector(apiRef);\n    const dimensions = {};\n    columns.forEach(colDef => {\n      if (colDef.hasBeenResized) {\n        const colDefDimensions = {};\n        COLUMNS_DIMENSION_PROPERTIES.forEach(propertyName => {\n          let propertyValue = colDef[propertyName];\n          if (propertyValue === Infinity) {\n            propertyValue = -1;\n          }\n          colDefDimensions[propertyName] = propertyValue;\n        });\n        dimensions[colDef.field] = colDefDimensions;\n      }\n    });\n    if (Object.keys(dimensions).length > 0) {\n      columnsStateToExport.dimensions = dimensions;\n    }\n    return _extends({}, prevState, {\n      columns: columnsStateToExport\n    });\n  }, [apiRef, props.columnVisibilityModel, props.initialState?.columns]);\n  const stateRestorePreProcessing = React.useCallback((params, context) => {\n    const columnVisibilityModelToImport = context.stateToRestore.columns?.columnVisibilityModel;\n    const initialState = context.stateToRestore.columns;\n    if (columnVisibilityModelToImport == null && initialState == null) {\n      return params;\n    }\n    const columnsState = createColumnsState({\n      apiRef,\n      columnsToUpsert: [],\n      initialState,\n      columnVisibilityModel: columnVisibilityModelToImport,\n      keepOnlyColumnsToUpsert: false\n    });\n    apiRef.current.setState(mergeColumnsState(columnsState));\n    if (initialState != null) {\n      apiRef.current.publishEvent('columnsChange', columnsState.orderedFields);\n    }\n    return params;\n  }, [apiRef]);\n  const preferencePanelPreProcessing = React.useCallback((initialValue, value) => {\n    if (value === GridPreferencePanelsValue.columns) {\n      const ColumnsPanel = props.slots.columnsPanel;\n      return /*#__PURE__*/_jsx(ColumnsPanel, _extends({}, props.slotProps?.columnsPanel));\n    }\n    return initialValue;\n  }, [props.slots.columnsPanel, props.slotProps?.columnsPanel]);\n  const addColumnMenuItems = React.useCallback(columnMenuItems => {\n    if (props.disableColumnSelector) {\n      return columnMenuItems;\n    }\n    return [...columnMenuItems, 'columnMenuColumnsItem'];\n  }, [props.disableColumnSelector]);\n  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItems);\n  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);\n  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);\n  useGridRegisterPipeProcessor(apiRef, 'preferencePanel', preferencePanelPreProcessing);\n\n  /*\n   * EVENTS\n   */\n\n  const prevInnerWidth = React.useRef(null);\n  const handleGridSizeChange = viewportInnerSize => {\n    if (prevInnerWidth.current !== viewportInnerSize.width) {\n      prevInnerWidth.current = viewportInnerSize.width;\n      setGridColumnsState(hydrateColumnsWidth(gridColumnsStateSelector(apiRef.current.state), apiRef.current.getRootDimensions()));\n    }\n  };\n  useGridApiEventHandler(apiRef, 'viewportInnerSizeChange', handleGridSizeChange);\n\n  /**\n   * APPLIERS\n   */\n  const hydrateColumns = React.useCallback(() => {\n    logger.info(`Columns pipe processing have changed, regenerating the columns`);\n    const columnsState = createColumnsState({\n      apiRef,\n      columnsToUpsert: [],\n      initialState: undefined,\n      keepOnlyColumnsToUpsert: false\n    });\n    setGridColumnsState(columnsState);\n  }, [apiRef, logger, setGridColumnsState]);\n  useGridRegisterPipeApplier(apiRef, 'hydrateColumns', hydrateColumns);\n\n  /*\n   * EFFECTS\n   */\n  // The effect do not track any value defined synchronously during the 1st render by hooks called after `useGridColumns`\n  // As a consequence, the state generated by the 1st run of this useEffect will always be equal to the initialization one\n  const isFirstRender = React.useRef(true);\n  React.useEffect(() => {\n    if (isFirstRender.current) {\n      isFirstRender.current = false;\n      return;\n    }\n    logger.info(`GridColumns have changed, new length ${props.columns.length}`);\n    if (previousColumnsProp.current === props.columns) {\n      return;\n    }\n    const columnsState = createColumnsState({\n      apiRef,\n      initialState: undefined,\n      // If the user provides a model, we don't want to set it in the state here because it has it's dedicated `useEffect` which calls `setColumnVisibilityModel`\n      columnsToUpsert: props.columns,\n      keepOnlyColumnsToUpsert: true\n    });\n    previousColumnsProp.current = props.columns;\n    setGridColumnsState(columnsState);\n  }, [logger, apiRef, setGridColumnsState, props.columns]);\n  React.useEffect(() => {\n    if (props.columnVisibilityModel !== undefined) {\n      apiRef.current.setColumnVisibilityModel(props.columnVisibilityModel);\n    }\n  }, [apiRef, logger, props.columnVisibilityModel]);\n}\nfunction mergeColumnsState(columnsState) {\n  return state => _extends({}, state, {\n    columns: columnsState\n  });\n}"],"names":["writeToClipboardPolyfill","data","span","document","createElement","style","whiteSpace","userSelect","opacity","textContent","body","appendChild","range","createRange","selectNode","selection","window","getSelection","removeAllRanges","addRange","execCommand","removeChild","useGridClipboard","apiRef","props","ignoreValueFormatterProp","ignoreValueFormatterDuringExport","ignoreValueFormatter","clipboardExport","clipboardCopyCellDelimiter","handleCopy","event","ctrlKey","metaKey","key","toLowerCase","shiftKey","altKey","element","target","toString","selectionEnd","selectionStart","textToCopy","current","getSelectedRows","size","getDataAsCsv","includeHeaders","delimiter","shouldAppendQuotes","escapeFormulas","focusedCell","cellParams","getCellParams","id","field","csvOptions","unstable_applyPipeProcessors","navigator","clipboard","writeText","catch","publishEvent","rootElementRef","onClipboardCopy","gridColumnGroupingSelector","state","columnGrouping","gridColumnGroupsUnwrappedModelSelector","unwrappedGroupingModel","gridColumnGroupsLookupSelector","lookup","gridColumnGroupsHeaderStructureSelector","headerStructure","gridColumnGroupsHeaderMaxDepthSelector","maxDepth","recurrentUnwrapGroupingColumnModel","columnGroupNode","parents","unwrappedGroupingModelToComplete","undefined","Error","join","groupId","children","forEach","child","unwrapGroupingColumnModel","columnGroupingModel","unwrappedSubTree","getColumnGroupsHeaderStructure","orderedColumns","pinnedFields","getParents","groupingHeaderStructure","Math","max","map","length","haveSameParents","field1","field2","depth","slice","depthStructure","reduce","structure","newField","columnFields","lastGroup","prevField","left","includes","right","push","_excluded","createGroupLookup","groupLookup","node","other","groupParam","subTreeLookup","columnGroupsStateInitializer","visibleColumnFields","columnGroupsHeaderStructure","pinnedColumns","useGridColumnGrouping","columnGroupingApi","getColumnGroupPath","getAllGroupDetails","useGridApiMethod","handleColumnIndexChange","setState","orderedFields","columns","updateColumnGroupingState","getPinnedColumns","useGridApiEventHandler","GridColumnHeaderRow","name","slot","overridesResolver","_","styles","columnHeaderRow","display","useGridColumnHeaders","visibleColumns","sortColumnLookup","filterColumnLookup","columnHeaderTabIndexState","columnGroupHeaderTabIndexState","columnHeaderFocus","columnGroupHeaderFocus","headerGroupingMaxDepth","columnMenuState","columnVisibility","hasOtherElementInTabSequence","dragCol","setDragCol","resizeCol","setResizeCol","theme","rootProps","dimensions","hasVirtualization","columnGroupsModel","columnPositions","renderContext","offsetLeft","direction","gridHasFiller","columnsTotalWidth","viewportOuterSize","width","columnHeadersContainerRef","scrollLeft","handleColumnResizeStart","params","handleColumnResizeStop","handleColumnReorderStart","handleColumnReorderStop","leftRenderContext","firstColumnIndex","lastColumnIndex","rightRenderContext","getColumnsToRender","currentContext","maxLastColumn","firstColumnToRender","lastColumnToRender","renderedColumns","getFillers","leftOverflow","borderTop","isPinnedRight","position","RIGHT","isNotPinned","hasScrollbarFiller","leftOffsetWidth","role","className","filler","header","pinnedRight","getCellOffsetStyle","pinnedPosition","columnIndex","computedWidth","pinnedOffset","getColumnHeaders","i","colDef","isFirstColumn","tabIndex","hasFocus","open","columnMenuOpen","filterItemsCounter","headerHeight","isDragging","colIndex","isResizing","isLast","indexInSection","sectionLength","getColumnGroupHeaders","columnsToRender","rowStructure","firstColumnFieldToRender","firstGroupToRender","firstGroupIndex","findIndex","lastColumnFieldToRender","lastGroupToRender","lastGroupIndex","visibleColumnGroupHeader","groupStructure","filter","firstVisibleColumnIndex","indexOf","acc","getColumn","index","headerInfo","fields","isLastColumn","height","getColumnHeadersRow","ownerState","LEFT","minFirstColumn","disableReorder","separatorSide","Left","getColumnGroupHeadersRows","headerRows","getInnerProps","gridColumnMenuSelector","columnMenu","columnMenuStateInitializer","useGridColumnMenu","logger","showColumnMenu","newState","debug","hidePreferences","forceUpdate","hideColumnMenu","columnLookup","columnVisibilityModel","fieldToFocus","visibleOrderedFields","fieldIndex","setColumnHeaderFocus","toggleColumnMenu","columnMenuApi","useGridColumnMenuSlots","defaultSlots","defaultSlotProps","slots","slotProps","hideMenu","addDividers","processedComponents","processedSlotProps","Object","keys","mergedProps","entries","currentSlotProps","defaultItems","userItems","defaultComponentKeys","sorted","Array","from","Set","sort","a","b","leftItemProps","rightItemProps","Number","isFinite","displayOrder","itemProps","onClick","processedComponentProps","customProps","DEFAULT_GRID_AUTOSIZE_OPTIONS","includeOutliers","outliersFactor","expand","trackFinger","currentTouchId","changedTouches","touch","identifier","x","clientX","y","clientY","computeNewWidth","initialOffsetToSeparator","clickX","columnBounds","resizeDirection","newWidth","preventClick","preventDefault","stopImmediatePropagation","extractColumnWidths","options","widthByField","root","classList","add","gridClasses","autosizing","column","widths","cell","getBoundingClientRect","filteredWidths","inputValues","factor","values","q1","floor","q3","iqr","deviation","v","excludeOutliers","title","querySelector","columnHeaderTitle","content","columnHeaderTitleContainerContent","iconContainer","iconButtonContainer","menuContainer","menuIcon","getComputedStyle","paddingWidth","parseInt","paddingLeft","paddingRight","scrollWidth","clientWidth","hasColumnMin","minWidth","Infinity","hasColumnMax","maxWidth","min","maxContent","remove","columnResizeStateInitializer","columnResize","resizingColumnField","createResizeRefs","initialColWidth","initialTotalWidth","previousMouseClickEvent","columnHeaderElement","headerFilterElement","groupHeaderElements","cellElements","leftPinnedCellsAfter","rightPinnedCellsBefore","fillerLeft","fillerRight","leftPinnedHeadersAfter","rightPinnedHeadersBefore","useGridColumnResize","useTheme","useGridLogger","refs","useLazyRef","stopResizeEventTimeout","useTimeout","touchId","updateWidth","prevWidth","offsetWidth","widthDiff","columnWidthDiff","newTotalWidth","setProperty","flex","div","finalWidth","getAttribute","updateProperty","finishResize","nativeEvent","stopListening","prevEvent","prevTimeStamp","timeStamp","prevClientX","prevClientY","setColumnWidth","columnsState","start","storeReferences","separator","xStart","getRootDimensions","rowWidth","headerFilterRow","side","contains","flipResizeDirection","getResizeDirection","computeOffsetToSeparator","handleResizeMouseUp","useEventCallback","handleResizeMouseMove","buttons","handleTouchEnd","handleTouchMove","finger","type","handleTouchStart","cellSeparator","columnHeader","doc","ownerDocument","currentTarget","addEventListener","removeProperty","removeEventListener","setTimeout","pointerEvents","handleResizeStart","handleResizeStop","handleColumnResizeMouseDown","button","cursor","handleColumnSeparatorDoubleClick","disableAutosize","resizable","autosizeColumns","autosizeOptions","columnVirtualizationDisabled","promise","selector","value","useGridSelector","resolve","Promise","createControllablePromise","useColumnVirtualizationDisabled","isAutosizingRef","async","userOptions","c","unstable_setColumnVirtualization","newColumns","totalWidth","total","remainingWidth","viewportInnerSize","widthPerColumn","updateColumns","newColumn","getColumnHeaderElement","useOnMount","autosizeOnMount","then","useGridNativeEventListener","passive","onColumnResize","onColumnWidthChange","property","delta","GridPinnedColumnPosition","EMPTY_PINNED_COLUMN_FIELDS","gridColumnsStateSelector","gridColumnFieldsSelector","gridColumnLookupSelector","gridColumnDefinitionsSelector","allFields","gridColumnVisibilityModelSelector","gridVisibleColumnDefinitionsSelector","gridVisibleColumnFieldsSelector","gridVisiblePinnedColumnDefinitionsSelector","model","visiblePinnedFields","invert","isArray","newPinnedColumns","remainingColumns","leftPinnedColumns","columnsWithoutLeftPinnedColumns","rightPinnedColumns","filterVisibleColumns","gridColumnPositionsSelector","positions","currentPosition","gridColumnsTotalWidthSelector","colCount","gridFilterableColumnDefinitionsSelector","col","filterable","gridFilterableColumnLookupSelector","gridHasColSpanSelector","some","colSpan","COLUMNS_DIMENSION_PROPERTIES","COLUMN_TYPES","hydrateColumnsWidth","rawState","columnsLookup","totalFlexUnits","widthAllocatedBeforeFlex","flexColumns","columnField","isFlex","availableWidth","hasScrollY","scrollbarSize","initialFreeSpace","computedColumnWidths","uniqueFlexColumns","flexColumnsLookup","all","frozenFields","freeze","frozen","loopOverFlexItems","violationsLookup","remainingFreeSpace","flexUnits","totalViolation","computeFlexColumnsWidth","getDefaultColTypeDef","createColumnsState","columnsToUpsert","initialState","keepOnlyColumnsToUpsert","isInsideStateInitializer","currentState","columnsToKeep","columnsToUpsertLookup","existingState","hasBeenResized","columnsStateWithPortableColumns","columnsWithUpdatedDimensions","orderedFieldsLookup","cleanOrderedFields","newOrderedFields","newColumnLookup","newColDef","applyInitialState","getFirstNonSpannedColumnToRender","firstRowToRender","lastRowToRender","visibleRows","firstNonSpannedColumnToRender","rowId","cellColSpanInfo","unstable_getCellColSpanInfo","spannedByColSpan","leftVisibleCellIndex","getTotalHeaderHeight","densityFactor","isHeaderFilteringEnabled","columnHeaderHeight","headerFilterHeight","useGridColumnSpanning","resetColSpan","columnSpanningPublicApi","columnSpanningPrivateApi","calculateColSpan","cellProps","calculateCellColSpan","minFirstColumnIndex","maxLastColumnIndex","columnsLength","row","getRow","getRowValue","setCellColSpanInfo","j","nextColumnIndex","rightVisibleCellIndex","columnsStateInitializer","useGridColumns","previousColumnsProp","registerControlState","stateId","propModel","propOnChange","onColumnVisibilityModelChange","stateSelector","changeEvent","setGridColumnsState","mergeColumnsState","updateRenderContext","getAllColumns","getVisibleColumns","getColumnIndex","useVisibleColumns","getColumnPosition","setColumnVisibilityModel","setColumnVisibility","isVisible","newModel","getColumnIndexRelativeToVisibleColumns","setColumnIndex","targetIndexPosition","allColumns","oldIndexPosition","updatedColumns","fieldRemoved","splice","targetIndex","oldIndex","columnApi","columnReorderApi","signature","DataGrid","stateExportPreProcessing","prevState","context","columnsStateToExport","columnVisibilityModelToExport","exportOnlyDirtyModels","colDefDimensions","propertyName","propertyValue","stateRestorePreProcessing","columnVisibilityModelToImport","stateToRestore","preferencePanelPreProcessing","initialValue","ColumnsPanel","columnsPanel","addColumnMenuItems","columnMenuItems","disableColumnSelector","prevInnerWidth","hydrateColumns","info","isFirstRender"],"sourceRoot":""}