{"version":3,"file":"react/js/vendor.mui@current-f9ec6c0d.e008506e84e0df617504.js","mappings":"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","sources":["webpack:///./node_modules/@mui/x-data-grid/hooks/features/scroll/useGridScroll.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/sorting/gridSortingSelector.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/sorting/gridSortingUtils.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/sorting/useGridSorting.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/statePersistence/useGridStatePersistence.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/virtualization/gridVirtualizationSelectors.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/virtualization/useGridVirtualScroller.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/virtualization/useGridVirtualization.js"],"sourcesContent":["import * as React from 'react';\nimport { useTheme } from '@mui/material/styles';\nimport { useGridLogger } from '../../utils/useGridLogger';\nimport { gridColumnPositionsSelector, gridVisibleColumnDefinitionsSelector } from '../columns/gridColumnsSelector';\nimport { useGridSelector } from '../../utils/useGridSelector';\nimport { gridPageSelector, gridPageSizeSelector } from '../pagination/gridPaginationSelector';\nimport { gridRowCountSelector } from '../rows/gridRowsSelector';\nimport { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { gridExpandedSortedRowEntriesSelector } from '../filter/gridFilterSelector';\nimport { gridDimensionsSelector } from '../dimensions';\n\n// Logic copied from https://www.w3.org/TR/wai-aria-practices/examples/listbox/js/listbox.js\n// Similar to https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView\nfunction scrollIntoView(dimensions) {\n  const {\n    clientHeight,\n    scrollTop,\n    offsetHeight,\n    offsetTop\n  } = dimensions;\n  const elementBottom = offsetTop + offsetHeight;\n  // Always scroll to top when cell is higher than viewport to avoid scroll jump\n  // See https://github.com/mui/mui-x/issues/4513 and https://github.com/mui/mui-x/issues/4514\n  if (offsetHeight > clientHeight) {\n    return offsetTop;\n  }\n  if (elementBottom - clientHeight > scrollTop) {\n    return elementBottom - clientHeight;\n  }\n  if (offsetTop < scrollTop) {\n    return offsetTop;\n  }\n  return undefined;\n}\n\n/**\n * @requires useGridPagination (state) - can be after, async only\n * @requires useGridColumns (state) - can be after, async only\n * @requires useGridRows (state) - can be after, async only\n * @requires useGridRowsMeta (state) - can be after, async only\n * @requires useGridFilter (state)\n * @requires useGridColumnSpanning (method)\n */\nexport const useGridScroll = (apiRef, props) => {\n  const theme = useTheme();\n  const logger = useGridLogger(apiRef, 'useGridScroll');\n  const colRef = apiRef.current.columnHeadersContainerRef;\n  const virtualScrollerRef = apiRef.current.virtualScrollerRef;\n  const visibleSortedRows = useGridSelector(apiRef, gridExpandedSortedRowEntriesSelector);\n  const scrollToIndexes = React.useCallback(params => {\n    const dimensions = gridDimensionsSelector(apiRef.current.state);\n    const totalRowCount = gridRowCountSelector(apiRef);\n    const visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);\n    const scrollToHeader = params.rowIndex == null;\n    if (!scrollToHeader && totalRowCount === 0 || visibleColumns.length === 0) {\n      return false;\n    }\n    logger.debug(`Scrolling to cell at row ${params.rowIndex}, col: ${params.colIndex} `);\n    let scrollCoordinates = {};\n    if (params.colIndex !== undefined) {\n      const columnPositions = gridColumnPositionsSelector(apiRef);\n      let cellWidth;\n      if (typeof params.rowIndex !== 'undefined') {\n        const rowId = visibleSortedRows[params.rowIndex]?.id;\n        const cellColSpanInfo = apiRef.current.unstable_getCellColSpanInfo(rowId, params.colIndex);\n        if (cellColSpanInfo && !cellColSpanInfo.spannedByColSpan) {\n          cellWidth = cellColSpanInfo.cellProps.width;\n        }\n      }\n      if (typeof cellWidth === 'undefined') {\n        cellWidth = visibleColumns[params.colIndex].computedWidth;\n      }\n      // When using RTL, `scrollLeft` becomes negative, so we must ensure that we only compare values.\n      scrollCoordinates.left = scrollIntoView({\n        clientHeight: dimensions.viewportInnerSize.width,\n        scrollTop: Math.abs(virtualScrollerRef.current.scrollLeft),\n        offsetHeight: cellWidth,\n        offsetTop: columnPositions[params.colIndex]\n      });\n    }\n    if (params.rowIndex !== undefined) {\n      const rowsMeta = gridRowsMetaSelector(apiRef.current.state);\n      const page = gridPageSelector(apiRef);\n      const pageSize = gridPageSizeSelector(apiRef);\n      const elementIndex = !props.pagination ? params.rowIndex : params.rowIndex - page * pageSize;\n      const targetOffsetHeight = rowsMeta.positions[elementIndex + 1] ? rowsMeta.positions[elementIndex + 1] - rowsMeta.positions[elementIndex] : rowsMeta.currentPageTotalHeight - rowsMeta.positions[elementIndex];\n      scrollCoordinates.top = scrollIntoView({\n        clientHeight: dimensions.viewportInnerSize.height,\n        scrollTop: virtualScrollerRef.current.scrollTop,\n        offsetHeight: targetOffsetHeight,\n        offsetTop: rowsMeta.positions[elementIndex]\n      });\n    }\n    scrollCoordinates = apiRef.current.unstable_applyPipeProcessors('scrollToIndexes', scrollCoordinates, params);\n    if (typeof scrollCoordinates.left !== undefined || typeof scrollCoordinates.top !== undefined) {\n      apiRef.current.scroll(scrollCoordinates);\n      return true;\n    }\n    return false;\n  }, [logger, apiRef, virtualScrollerRef, props.pagination, visibleSortedRows]);\n  const scroll = React.useCallback(params => {\n    if (virtualScrollerRef.current && params.left !== undefined && colRef.current) {\n      const direction = theme.direction === 'rtl' ? -1 : 1;\n      colRef.current.scrollLeft = params.left;\n      virtualScrollerRef.current.scrollLeft = direction * params.left;\n      logger.debug(`Scrolling left: ${params.left}`);\n    }\n    if (virtualScrollerRef.current && params.top !== undefined) {\n      virtualScrollerRef.current.scrollTop = params.top;\n      logger.debug(`Scrolling top: ${params.top}`);\n    }\n    logger.debug(`Scrolling, updating container, and viewport`);\n  }, [virtualScrollerRef, theme.direction, colRef, logger]);\n  const getScrollPosition = React.useCallback(() => {\n    if (!virtualScrollerRef?.current) {\n      return {\n        top: 0,\n        left: 0\n      };\n    }\n    return {\n      top: virtualScrollerRef.current.scrollTop,\n      left: virtualScrollerRef.current.scrollLeft\n    };\n  }, [virtualScrollerRef]);\n  const scrollApi = {\n    scroll,\n    scrollToIndexes,\n    getScrollPosition\n  };\n  useGridApiMethod(apiRef, scrollApi, 'public');\n};","import { createSelector, createSelectorMemoized } from '../../../utils/createSelector';\nimport { gridRowTreeSelector, gridRowsLookupSelector } from '../rows/gridRowsSelector';\nimport { GRID_ID_AUTOGENERATED, isAutoGeneratedRow } from '../rows/gridRowsUtils';\n/**\n * @category Sorting\n * @ignore - do not document.\n */\nconst gridSortingStateSelector = state => state.sorting;\n\n/**\n * Get the id of the rows after the sorting process.\n * @category Sorting\n */\nexport const gridSortedRowIdsSelector = createSelector(gridSortingStateSelector, sortingState => sortingState.sortedRows);\n\n/**\n * Get the id and the model of the rows after the sorting process.\n * @category Sorting\n */\nexport const gridSortedRowEntriesSelector = createSelectorMemoized(gridSortedRowIdsSelector, gridRowsLookupSelector, gridRowTreeSelector, (sortedIds, idRowsLookup, rowTree) => sortedIds.reduce((acc, id) => {\n  const model = idRowsLookup[id];\n  if (model) {\n    acc.push({\n      id,\n      model\n    });\n  }\n  const rowNode = rowTree[id];\n  if (rowNode && isAutoGeneratedRow(rowNode)) {\n    acc.push({\n      id,\n      model: {\n        [GRID_ID_AUTOGENERATED]: id\n      }\n    });\n  }\n  return acc;\n}, []));\n\n/**\n * Get the current sorting model.\n * @category Sorting\n */\nexport const gridSortModelSelector = createSelector(gridSortingStateSelector, sorting => sorting.sortModel);\n/**\n * @category Sorting\n * @ignore - do not document.\n */\nexport const gridSortColumnLookupSelector = createSelectorMemoized(gridSortModelSelector, sortModel => {\n  const result = sortModel.reduce((res, sortItem, index) => {\n    res[sortItem.field] = {\n      sortDirection: sortItem.sort,\n      sortIndex: sortModel.length > 1 ? index + 1 : undefined\n    };\n    return res;\n  }, {});\n  return result;\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { buildWarning } from '../../../utils/warning';\nconst sortModelDisableMultiColumnsSortingWarning = buildWarning(['MUI X: The `sortModel` can only contain a single item when the `disableMultipleColumnsSorting` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');\nexport const sanitizeSortModel = (model, disableMultipleColumnsSorting) => {\n  if (disableMultipleColumnsSorting && model.length > 1) {\n    if (process.env.NODE_ENV !== 'production') {\n      sortModelDisableMultiColumnsSortingWarning();\n    }\n    return [model[0]];\n  }\n  return model;\n};\nexport const mergeStateWithSortModel = (sortModel, disableMultipleColumnsSorting) => state => _extends({}, state, {\n  sorting: _extends({}, state.sorting, {\n    sortModel: sanitizeSortModel(sortModel, disableMultipleColumnsSorting)\n  })\n});\nconst isDesc = direction => direction === 'desc';\n\n/**\n * Transform an item of the sorting model into a method comparing two rows.\n * @param {GridSortItem} sortItem The sort item we want to apply.\n * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.\n * @returns {GridParsedSortItem | null} The parsed sort item. Returns `null` is the sort item is not valid.\n */\nconst parseSortItem = (sortItem, apiRef) => {\n  const column = apiRef.current.getColumn(sortItem.field);\n  if (!column || sortItem.sort === null) {\n    return null;\n  }\n  let comparator;\n  if (column.getSortComparator) {\n    comparator = column.getSortComparator(sortItem.sort);\n  } else {\n    comparator = isDesc(sortItem.sort) ? (...args) => -1 * column.sortComparator(...args) : column.sortComparator;\n  }\n  if (!comparator) {\n    return null;\n  }\n  const getSortCellParams = id => ({\n    id,\n    field: column.field,\n    rowNode: apiRef.current.getRowNode(id),\n    value: apiRef.current.getCellValue(id, column.field),\n    api: apiRef.current\n  });\n  return {\n    getSortCellParams,\n    comparator\n  };\n};\n/**\n * Compare two rows according to a list of valid sort items.\n * The `row1Params` and `row2Params` must have the same length as `parsedSortItems`,\n * and each of their index must contain the `GridSortCellParams` of the sort item with the same index.\n * @param {GridParsedSortItem[]} parsedSortItems All the sort items with which we want to compare the rows.\n * @param {GridRowAggregatedSortingParams} row1 The node and params of the 1st row for each sort item.\n * @param {GridRowAggregatedSortingParams} row2 The node and params of the 2nd row for each sort item.\n */\nconst compareRows = (parsedSortItems, row1, row2) => {\n  return parsedSortItems.reduce((res, item, index) => {\n    if (res !== 0) {\n      // return the results of the first comparator which distinguish the two rows\n      return res;\n    }\n    const sortCellParams1 = row1.params[index];\n    const sortCellParams2 = row2.params[index];\n    res = item.comparator(sortCellParams1.value, sortCellParams2.value, sortCellParams1, sortCellParams2);\n    return res;\n  }, 0);\n};\n\n/**\n * Generates a method to easily sort a list of rows according to the current sort model.\n * @param {GridSortModel} sortModel The model with which we want to sort the rows.\n * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.\n * @returns {GridSortingModelApplier | null} A method that generates a list of sorted row ids from a list of rows according to the current sort model. If `null`, we consider that the rows should remain in the order there were provided.\n */\nexport const buildAggregatedSortingApplier = (sortModel, apiRef) => {\n  const comparatorList = sortModel.map(item => parseSortItem(item, apiRef)).filter(comparator => !!comparator);\n  if (comparatorList.length === 0) {\n    return null;\n  }\n  return rowList => rowList.map(node => ({\n    node,\n    params: comparatorList.map(el => el.getSortCellParams(node.id))\n  })).sort((a, b) => compareRows(comparatorList, a, b)).map(row => row.node.id);\n};\nexport const getNextGridSortDirection = (sortingOrder, current) => {\n  const currentIdx = sortingOrder.indexOf(current);\n  if (!current || currentIdx === -1 || currentIdx + 1 === sortingOrder.length) {\n    return sortingOrder[0];\n  }\n  return sortingOrder[currentIdx + 1];\n};\nconst gridNillComparator = (v1, v2) => {\n  if (v1 == null && v2 != null) {\n    return -1;\n  }\n  if (v2 == null && v1 != null) {\n    return 1;\n  }\n  if (v1 == null && v2 == null) {\n    return 0;\n  }\n  return null;\n};\nconst collator = new Intl.Collator();\nexport const gridStringOrNumberComparator = (value1, value2) => {\n  const nillResult = gridNillComparator(value1, value2);\n  if (nillResult !== null) {\n    return nillResult;\n  }\n  if (typeof value1 === 'string') {\n    return collator.compare(value1.toString(), value2.toString());\n  }\n  return value1 - value2;\n};\nexport const gridNumberComparator = (value1, value2) => {\n  const nillResult = gridNillComparator(value1, value2);\n  if (nillResult !== null) {\n    return nillResult;\n  }\n  return Number(value1) - Number(value2);\n};\nexport const gridDateComparator = (value1, value2) => {\n  const nillResult = gridNillComparator(value1, value2);\n  if (nillResult !== null) {\n    return nillResult;\n  }\n  if (value1 > value2) {\n    return 1;\n  }\n  if (value1 < value2) {\n    return -1;\n  }\n  return 0;\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';\nimport { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { useGridLogger } from '../../utils/useGridLogger';\nimport { gridColumnLookupSelector } from '../columns/gridColumnsSelector';\nimport { gridSortedRowEntriesSelector, gridSortedRowIdsSelector, gridSortModelSelector } from './gridSortingSelector';\nimport { GRID_ROOT_GROUP_ID, gridRowTreeSelector } from '../rows';\nimport { useFirstRender } from '../../utils/useFirstRender';\nimport { useGridRegisterStrategyProcessor, GRID_DEFAULT_STRATEGY } from '../../core/strategyProcessing';\nimport { buildAggregatedSortingApplier, mergeStateWithSortModel, getNextGridSortDirection, sanitizeSortModel } from './gridSortingUtils';\nimport { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';\nimport { getTreeNodeDescendants } from '../rows/gridRowsUtils';\nexport const sortingStateInitializer = (state, props) => {\n  const sortModel = props.sortModel ?? props.initialState?.sorting?.sortModel ?? [];\n  return _extends({}, state, {\n    sorting: {\n      sortModel: sanitizeSortModel(sortModel, props.disableMultipleColumnsSorting),\n      sortedRows: []\n    }\n  });\n};\n\n/**\n * @requires useGridRows (event)\n * @requires useGridColumns (event)\n */\nexport const useGridSorting = (apiRef, props) => {\n  const logger = useGridLogger(apiRef, 'useGridSorting');\n  apiRef.current.registerControlState({\n    stateId: 'sortModel',\n    propModel: props.sortModel,\n    propOnChange: props.onSortModelChange,\n    stateSelector: gridSortModelSelector,\n    changeEvent: 'sortModelChange'\n  });\n  const upsertSortModel = React.useCallback((field, sortItem) => {\n    const sortModel = gridSortModelSelector(apiRef);\n    const existingIdx = sortModel.findIndex(c => c.field === field);\n    let newSortModel = [...sortModel];\n    if (existingIdx > -1) {\n      if (sortItem?.sort == null) {\n        newSortModel.splice(existingIdx, 1);\n      } else {\n        newSortModel.splice(existingIdx, 1, sortItem);\n      }\n    } else {\n      newSortModel = [...sortModel, sortItem];\n    }\n    return newSortModel;\n  }, [apiRef]);\n  const createSortItem = React.useCallback((col, directionOverride) => {\n    const sortModel = gridSortModelSelector(apiRef);\n    const existing = sortModel.find(c => c.field === col.field);\n    if (existing) {\n      const nextSort = directionOverride === undefined ? getNextGridSortDirection(col.sortingOrder ?? props.sortingOrder, existing.sort) : directionOverride;\n      return nextSort === undefined ? undefined : _extends({}, existing, {\n        sort: nextSort\n      });\n    }\n    return {\n      field: col.field,\n      sort: directionOverride === undefined ? getNextGridSortDirection(col.sortingOrder ?? props.sortingOrder) : directionOverride\n    };\n  }, [apiRef, props.sortingOrder]);\n  const addColumnMenuItem = React.useCallback((columnMenuItems, colDef) => {\n    if (colDef == null || colDef.sortable === false || props.disableColumnSorting) {\n      return columnMenuItems;\n    }\n    const sortingOrder = colDef.sortingOrder || props.sortingOrder;\n    if (sortingOrder.some(item => !!item)) {\n      return [...columnMenuItems, 'columnMenuSortItem'];\n    }\n    return columnMenuItems;\n  }, [props.sortingOrder, props.disableColumnSorting]);\n\n  /**\n   * API METHODS\n   */\n  const applySorting = React.useCallback(() => {\n    apiRef.current.setState(state => {\n      if (props.sortingMode === 'server') {\n        logger.debug('Skipping sorting rows as sortingMode = server');\n        return _extends({}, state, {\n          sorting: _extends({}, state.sorting, {\n            sortedRows: getTreeNodeDescendants(gridRowTreeSelector(apiRef), GRID_ROOT_GROUP_ID, false)\n          })\n        });\n      }\n      const sortModel = gridSortModelSelector(state, apiRef.current.instanceId);\n      const sortRowList = buildAggregatedSortingApplier(sortModel, apiRef);\n      const sortedRows = apiRef.current.applyStrategyProcessor('sorting', {\n        sortRowList\n      });\n      return _extends({}, state, {\n        sorting: _extends({}, state.sorting, {\n          sortedRows\n        })\n      });\n    });\n    apiRef.current.publishEvent('sortedRowsSet');\n    apiRef.current.forceUpdate();\n  }, [apiRef, logger, props.sortingMode]);\n  const setSortModel = React.useCallback(model => {\n    const currentModel = gridSortModelSelector(apiRef);\n    if (currentModel !== model) {\n      logger.debug(`Setting sort model`);\n      apiRef.current.setState(mergeStateWithSortModel(model, props.disableMultipleColumnsSorting));\n      apiRef.current.forceUpdate();\n      apiRef.current.applySorting();\n    }\n  }, [apiRef, logger, props.disableMultipleColumnsSorting]);\n  const sortColumn = React.useCallback((field, direction, allowMultipleSorting) => {\n    const column = apiRef.current.getColumn(field);\n    const sortItem = createSortItem(column, direction);\n    let sortModel;\n    if (!allowMultipleSorting || props.disableMultipleColumnsSorting) {\n      sortModel = sortItem?.sort == null ? [] : [sortItem];\n    } else {\n      sortModel = upsertSortModel(column.field, sortItem);\n    }\n    apiRef.current.setSortModel(sortModel);\n  }, [apiRef, upsertSortModel, createSortItem, props.disableMultipleColumnsSorting]);\n  const getSortModel = React.useCallback(() => gridSortModelSelector(apiRef), [apiRef]);\n  const getSortedRows = React.useCallback(() => {\n    const sortedRows = gridSortedRowEntriesSelector(apiRef);\n    return sortedRows.map(row => row.model);\n  }, [apiRef]);\n  const getSortedRowIds = React.useCallback(() => gridSortedRowIdsSelector(apiRef), [apiRef]);\n  const getRowIdFromRowIndex = React.useCallback(index => apiRef.current.getSortedRowIds()[index], [apiRef]);\n  const sortApi = {\n    getSortModel,\n    getSortedRows,\n    getSortedRowIds,\n    getRowIdFromRowIndex,\n    setSortModel,\n    sortColumn,\n    applySorting\n  };\n  useGridApiMethod(apiRef, sortApi, 'public');\n\n  /**\n   * PRE-PROCESSING\n   */\n  const stateExportPreProcessing = React.useCallback((prevState, context) => {\n    const sortModelToExport = gridSortModelSelector(apiRef);\n    const shouldExportSortModel =\n    // Always export if the `exportOnlyDirtyModels` property is not activated\n    !context.exportOnlyDirtyModels ||\n    // Always export if the model is controlled\n    props.sortModel != null ||\n    // Always export if the model has been initialized\n    props.initialState?.sorting?.sortModel != null ||\n    // Export if the model is not empty\n    sortModelToExport.length > 0;\n    if (!shouldExportSortModel) {\n      return prevState;\n    }\n    return _extends({}, prevState, {\n      sorting: {\n        sortModel: sortModelToExport\n      }\n    });\n  }, [apiRef, props.sortModel, props.initialState?.sorting?.sortModel]);\n  const stateRestorePreProcessing = React.useCallback((params, context) => {\n    const sortModel = context.stateToRestore.sorting?.sortModel;\n    if (sortModel == null) {\n      return params;\n    }\n    apiRef.current.setState(mergeStateWithSortModel(sortModel, props.disableMultipleColumnsSorting));\n    return _extends({}, params, {\n      callbacks: [...params.callbacks, apiRef.current.applySorting]\n    });\n  }, [apiRef, props.disableMultipleColumnsSorting]);\n  const flatSortingMethod = React.useCallback(params => {\n    const rowTree = gridRowTreeSelector(apiRef);\n    const rootGroupNode = rowTree[GRID_ROOT_GROUP_ID];\n    const sortedChildren = params.sortRowList ? params.sortRowList(rootGroupNode.children.map(childId => rowTree[childId])) : [...rootGroupNode.children];\n    if (rootGroupNode.footerId != null) {\n      sortedChildren.push(rootGroupNode.footerId);\n    }\n    return sortedChildren;\n  }, [apiRef]);\n  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);\n  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);\n  useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'sorting', flatSortingMethod);\n\n  /**\n   * EVENTS\n   */\n  const handleColumnHeaderClick = React.useCallback(({\n    field,\n    colDef\n  }, event) => {\n    if (!colDef.sortable || props.disableColumnSorting) {\n      return;\n    }\n    const allowMultipleSorting = event.shiftKey || event.metaKey || event.ctrlKey;\n    sortColumn(field, undefined, allowMultipleSorting);\n  }, [sortColumn, props.disableColumnSorting]);\n  const handleColumnHeaderKeyDown = React.useCallback(({\n    field,\n    colDef\n  }, event) => {\n    if (!colDef.sortable || props.disableColumnSorting) {\n      return;\n    }\n    // Ctrl + Enter opens the column menu\n    if (event.key === 'Enter' && !event.ctrlKey && !event.metaKey) {\n      sortColumn(field, undefined, event.shiftKey);\n    }\n  }, [sortColumn, props.disableColumnSorting]);\n  const handleColumnsChange = React.useCallback(() => {\n    // When the columns change we check that the sorted columns are still part of the dataset\n    const sortModel = gridSortModelSelector(apiRef);\n    const latestColumns = gridColumnLookupSelector(apiRef);\n    if (sortModel.length > 0) {\n      const newModel = sortModel.filter(sortItem => latestColumns[sortItem.field]);\n      if (newModel.length < sortModel.length) {\n        apiRef.current.setSortModel(newModel);\n      }\n    }\n  }, [apiRef]);\n  const handleStrategyProcessorChange = React.useCallback(methodName => {\n    if (methodName === 'sorting') {\n      apiRef.current.applySorting();\n    }\n  }, [apiRef]);\n  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItem);\n  useGridApiEventHandler(apiRef, 'columnHeaderClick', handleColumnHeaderClick);\n  useGridApiEventHandler(apiRef, 'columnHeaderKeyDown', handleColumnHeaderKeyDown);\n  useGridApiEventHandler(apiRef, 'rowsSet', apiRef.current.applySorting);\n  useGridApiEventHandler(apiRef, 'columnsChange', handleColumnsChange);\n  useGridApiEventHandler(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);\n\n  /**\n   * 1ST RENDER\n   */\n  useFirstRender(() => {\n    apiRef.current.applySorting();\n  });\n\n  /**\n   * EFFECTS\n   */\n  useEnhancedEffect(() => {\n    if (props.sortModel !== undefined) {\n      apiRef.current.setSortModel(props.sortModel);\n    }\n  }, [apiRef, props.sortModel]);\n};","import * as React from 'react';\nimport { useGridApiMethod } from '../../utils';\nexport const useGridStatePersistence = apiRef => {\n  const exportState = React.useCallback((params = {}) => {\n    const stateToExport = apiRef.current.unstable_applyPipeProcessors('exportState', {}, params);\n    return stateToExport;\n  }, [apiRef]);\n  const restoreState = React.useCallback(stateToRestore => {\n    const response = apiRef.current.unstable_applyPipeProcessors('restoreState', {\n      callbacks: []\n    }, {\n      stateToRestore\n    });\n    response.callbacks.forEach(callback => {\n      callback();\n    });\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const statePersistenceApi = {\n    exportState,\n    restoreState\n  };\n  useGridApiMethod(apiRef, statePersistenceApi, 'public');\n};","import { createSelector, createSelectorMemoized } from '../../../utils/createSelector';\n/**\n * Get the columns state\n * @category Virtualization\n */\nexport const gridVirtualizationSelector = state => state.virtualization;\n\n/**\n * Get the enabled state for virtualization\n * @category Virtualization\n */\nexport const gridVirtualizationEnabledSelector = createSelector(gridVirtualizationSelector, state => state.enabled);\n\n/**\n * Get the enabled state for virtualization\n * @category Virtualization\n */\nexport const gridVirtualizationColumnEnabledSelector = createSelector(gridVirtualizationSelector, state => state.enabledForColumns);\n\n/**\n * Get the render context\n * @category Virtualization\n * @ignore - do not document.\n */\nexport const gridRenderContextSelector = createSelector(gridVirtualizationSelector, state => state.renderContext);\n\n/**\n * Get the render context, with only columns filled in.\n * This is cached, so it can be used to only re-render when the column interval changes.\n * @category Virtualization\n * @ignore - do not document.\n */\nexport const gridRenderContextColumnsSelector = createSelectorMemoized(state => state.virtualization.renderContext.firstColumnIndex, state => state.virtualization.renderContext.lastColumnIndex, (firstColumnIndex, lastColumnIndex) => ({\n  firstColumnIndex,\n  lastColumnIndex\n}));","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { unstable_useEnhancedEffect as useEnhancedEffect, unstable_useEventCallback as useEventCallback } from '@mui/utils';\nimport useLazyRef from '@mui/utils/useLazyRef';\nimport useTimeout from '@mui/utils/useTimeout';\nimport { useTheme } from '@mui/material/styles';\nimport { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';\nimport { useGridRootProps } from '../../utils/useGridRootProps';\nimport { useGridSelector } from '../../utils/useGridSelector';\nimport { useResizeObserver } from '../../utils/useResizeObserver';\nimport { useRunOnce } from '../../utils/useRunOnce';\nimport { gridVisibleColumnDefinitionsSelector, gridVisiblePinnedColumnDefinitionsSelector, gridColumnPositionsSelector, gridHasColSpanSelector } from '../columns/gridColumnsSelector';\nimport { gridDimensionsSelector } from '../dimensions/gridDimensionsSelectors';\nimport { gridPinnedRowsSelector } from '../rows/gridRowsSelector';\nimport { gridFocusCellSelector, gridTabIndexCellSelector } from '../focus/gridFocusStateSelector';\nimport { useGridVisibleRows, getVisibleRows } from '../../utils/useGridVisibleRows';\nimport { useGridApiEventHandler } from '../../utils';\nimport { clamp, range } from '../../../utils/utils';\nimport { selectedIdsLookupSelector } from '../rowSelection/gridRowSelectionSelector';\nimport { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';\nimport { getFirstNonSpannedColumnToRender } from '../columns/gridColumnsUtils';\nimport { getMinimalContentHeight } from '../rows/gridRowsUtils';\nimport { gridRenderContextSelector, gridVirtualizationEnabledSelector, gridVirtualizationColumnEnabledSelector } from './gridVirtualizationSelectors';\nimport { EMPTY_RENDER_CONTEXT } from './useGridVirtualization';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst MINIMUM_COLUMN_WIDTH = 50;\nvar ScrollDirection = /*#__PURE__*/function (ScrollDirection) {\n  ScrollDirection[ScrollDirection[\"NONE\"] = 0] = \"NONE\";\n  ScrollDirection[ScrollDirection[\"UP\"] = 1] = \"UP\";\n  ScrollDirection[ScrollDirection[\"DOWN\"] = 2] = \"DOWN\";\n  ScrollDirection[ScrollDirection[\"LEFT\"] = 3] = \"LEFT\";\n  ScrollDirection[ScrollDirection[\"RIGHT\"] = 4] = \"RIGHT\";\n  return ScrollDirection;\n}(ScrollDirection || {});\nconst EMPTY_SCROLL_POSITION = {\n  top: 0,\n  left: 0\n};\nexport const EMPTY_DETAIL_PANELS = Object.freeze(new Map());\nconst createScrollCache = (mode, rowBufferPx, columnBufferPx, verticalBuffer, horizontalBuffer) => ({\n  direction: ScrollDirection.NONE,\n  buffer: bufferForDirection(mode, ScrollDirection.NONE, rowBufferPx, columnBufferPx, verticalBuffer, horizontalBuffer)\n});\nlet isJSDOM = false;\ntry {\n  if (typeof window !== 'undefined') {\n    isJSDOM = /jsdom/.test(window.navigator.userAgent);\n  }\n} catch (_) {\n  /* ignore */\n}\nexport const useGridVirtualScroller = () => {\n  const apiRef = useGridPrivateApiContext();\n  const rootProps = useGridRootProps();\n  const visibleColumns = useGridSelector(apiRef, gridVisibleColumnDefinitionsSelector);\n  const enabled = useGridSelector(apiRef, gridVirtualizationEnabledSelector) && !isJSDOM;\n  const enabledForColumns = useGridSelector(apiRef, gridVirtualizationColumnEnabledSelector) && !isJSDOM;\n  const dimensions = useGridSelector(apiRef, gridDimensionsSelector);\n  const outerSize = dimensions.viewportOuterSize;\n  const pinnedRows = useGridSelector(apiRef, gridPinnedRowsSelector);\n  const pinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);\n  const hasBottomPinnedRows = pinnedRows.bottom.length > 0;\n  const [panels, setPanels] = React.useState(EMPTY_DETAIL_PANELS);\n  const theme = useTheme();\n  const cellFocus = useGridSelector(apiRef, gridFocusCellSelector);\n  const cellTabIndex = useGridSelector(apiRef, gridTabIndexCellSelector);\n  const rowsMeta = useGridSelector(apiRef, gridRowsMetaSelector);\n  const selectedRowsLookup = useGridSelector(apiRef, selectedIdsLookupSelector);\n  const currentPage = useGridVisibleRows(apiRef, rootProps);\n  const gridRootRef = apiRef.current.rootElementRef;\n  const mainRef = apiRef.current.mainElementRef;\n  const scrollerRef = apiRef.current.virtualScrollerRef;\n  const scrollbarVerticalRef = React.useRef(null);\n  const scrollbarHorizontalRef = React.useRef(null);\n  const contentHeight = dimensions.contentSize.height;\n  const columnsTotalWidth = dimensions.columnsTotalWidth;\n  const hasColSpan = useGridSelector(apiRef, gridHasColSpanSelector);\n  useResizeObserver(mainRef, () => apiRef.current.resize());\n\n  /*\n   * Scroll context logic\n   * ====================\n   * We only render the cells contained in the `renderContext`. However, when the user starts scrolling the grid\n   * in a direction, we want to render as many cells as possible in that direction, as to avoid presenting white\n   * areas if the user scrolls too fast/far and the viewport ends up in a region we haven't rendered yet. To render\n   * more cells, we store some offsets to add to the viewport in `scrollCache.buffer`. Those offsets make the render\n   * context wider in the direction the user is going, but also makes the buffer around the viewport `0` for the\n   * dimension (horizontal or vertical) in which the user is not scrolling. So if the normal viewport is 8 columns\n   * wide, with a 1 column buffer (10 columns total), then we want it to be exactly 8 columns wide during vertical\n   * scroll.\n   * However, we don't want the rows in the old context to re-render from e.g. 10 columns to 8 columns, because that's\n   * work that's not necessary. Thus we store the context at the start of the scroll in `frozenContext`, and the rows\n   * that are part of this old context will keep their same render context as to avoid re-rendering.\n   */\n  const scrollPosition = React.useRef(EMPTY_SCROLL_POSITION);\n  const previousContextScrollPosition = React.useRef(EMPTY_SCROLL_POSITION);\n  const previousRowContext = React.useRef(EMPTY_RENDER_CONTEXT);\n  const renderContext = useGridSelector(apiRef, gridRenderContextSelector);\n  const scrollTimeout = useTimeout();\n  const frozenContext = React.useRef(undefined);\n  const scrollCache = useLazyRef(() => createScrollCache(theme.direction, rootProps.rowBufferPx, rootProps.columnBufferPx, dimensions.rowHeight * 15, MINIMUM_COLUMN_WIDTH * 6)).current;\n  const focusedCell = {\n    rowIndex: React.useMemo(() => cellFocus ? currentPage.rows.findIndex(row => row.id === cellFocus.id) : -1, [cellFocus, currentPage.rows]),\n    columnIndex: React.useMemo(() => cellFocus ? visibleColumns.findIndex(column => column.field === cellFocus.field) : -1, [cellFocus, visibleColumns])\n  };\n  const updateRenderContext = React.useCallback(nextRenderContext => {\n    if (areRenderContextsEqual(nextRenderContext, apiRef.current.state.virtualization.renderContext)) {\n      return;\n    }\n    const didRowsIntervalChange = nextRenderContext.firstRowIndex !== previousRowContext.current.firstRowIndex || nextRenderContext.lastRowIndex !== previousRowContext.current.lastRowIndex;\n    apiRef.current.setState(state => {\n      return _extends({}, state, {\n        virtualization: _extends({}, state.virtualization, {\n          renderContext: nextRenderContext\n        })\n      });\n    });\n\n    // The lazy-loading hook is listening to `renderedRowsIntervalChange`,\n    // but only does something if the dimensions are also available.\n    // So we wait until we have valid dimensions before publishing the first event.\n    if (dimensions.isReady && didRowsIntervalChange) {\n      previousRowContext.current = nextRenderContext;\n      apiRef.current.publishEvent('renderedRowsIntervalChange', nextRenderContext);\n    }\n    previousContextScrollPosition.current = scrollPosition.current;\n  }, [apiRef, dimensions.isReady]);\n  const triggerUpdateRenderContext = () => {\n    const newScroll = {\n      top: scrollerRef.current.scrollTop,\n      left: scrollerRef.current.scrollLeft\n    };\n    const dx = newScroll.left - scrollPosition.current.left;\n    const dy = newScroll.top - scrollPosition.current.top;\n    const isScrolling = dx !== 0 || dy !== 0;\n    scrollPosition.current = newScroll;\n    const direction = isScrolling ? directionForDelta(dx, dy) : ScrollDirection.NONE;\n\n    // Since previous render, we have scrolled...\n    const rowScroll = Math.abs(scrollPosition.current.top - previousContextScrollPosition.current.top);\n    const columnScroll = Math.abs(scrollPosition.current.left - previousContextScrollPosition.current.left);\n\n    // PERF: use the computed minimum column width instead of a static one\n    const didCrossThreshold = rowScroll >= dimensions.rowHeight || columnScroll >= MINIMUM_COLUMN_WIDTH;\n    const didChangeDirection = scrollCache.direction !== direction;\n    const shouldUpdate = didCrossThreshold || didChangeDirection;\n    if (!shouldUpdate) {\n      return renderContext;\n    }\n\n    // Render a new context\n\n    if (didChangeDirection) {\n      switch (direction) {\n        case ScrollDirection.NONE:\n        case ScrollDirection.LEFT:\n        case ScrollDirection.RIGHT:\n          frozenContext.current = undefined;\n          break;\n        default:\n          frozenContext.current = renderContext;\n          break;\n      }\n    }\n    scrollCache.direction = direction;\n    scrollCache.buffer = bufferForDirection(theme.direction, direction, rootProps.rowBufferPx, rootProps.columnBufferPx, dimensions.rowHeight * 15, MINIMUM_COLUMN_WIDTH * 6);\n    const inputs = inputsSelector(apiRef, rootProps, enabled, enabledForColumns);\n    const nextRenderContext = computeRenderContext(inputs, scrollPosition.current, scrollCache);\n\n    // Prevents batching render context changes\n    ReactDOM.flushSync(() => {\n      updateRenderContext(nextRenderContext);\n    });\n    scrollTimeout.start(1000, triggerUpdateRenderContext);\n    return nextRenderContext;\n  };\n  const forceUpdateRenderContext = () => {\n    const inputs = inputsSelector(apiRef, rootProps, enabled, enabledForColumns);\n    const nextRenderContext = computeRenderContext(inputs, scrollPosition.current, scrollCache);\n    updateRenderContext(nextRenderContext);\n  };\n  const handleScroll = useEventCallback(event => {\n    const {\n      scrollTop,\n      scrollLeft\n    } = event.currentTarget;\n\n    // On iOS and macOS, negative offsets are possible when swiping past the start\n    if (scrollTop < 0) {\n      return;\n    }\n    if (theme.direction === 'ltr') {\n      if (scrollLeft < 0) {\n        return;\n      }\n    }\n    if (theme.direction === 'rtl') {\n      if (scrollLeft > 0) {\n        return;\n      }\n    }\n    const nextRenderContext = triggerUpdateRenderContext();\n    apiRef.current.publishEvent('scrollPositionChange', {\n      top: scrollTop,\n      left: scrollLeft,\n      renderContext: nextRenderContext\n    });\n  });\n  const handleWheel = useEventCallback(event => {\n    apiRef.current.publishEvent('virtualScrollerWheel', {}, event);\n  });\n  const handleTouchMove = useEventCallback(event => {\n    apiRef.current.publishEvent('virtualScrollerTouchMove', {}, event);\n  });\n  const getRows = (params = {}) => {\n    if (!params.rows && !currentPage.range) {\n      return [];\n    }\n    const baseRenderContext = params.renderContext ?? renderContext;\n    const isLastSection = !hasBottomPinnedRows && params.position === undefined || hasBottomPinnedRows && params.position === 'bottom';\n    const isPinnedSection = params.position !== undefined;\n    let rowIndexOffset;\n    // FIXME: Why is the switch check exhaustiveness not validated with typescript-eslint?\n    // eslint-disable-next-line default-case\n    switch (params.position) {\n      case 'top':\n        rowIndexOffset = 0;\n        break;\n      case 'bottom':\n        rowIndexOffset = pinnedRows.top.length + currentPage.rows.length;\n        break;\n      case undefined:\n        rowIndexOffset = pinnedRows.top.length;\n        break;\n    }\n    const rowModels = params.rows ?? currentPage.rows;\n    const firstRowToRender = baseRenderContext.firstRowIndex;\n    const lastRowToRender = Math.min(baseRenderContext.lastRowIndex, rowModels.length);\n    const rowIndexes = params.rows ? range(0, params.rows.length) : range(firstRowToRender, lastRowToRender);\n    let virtualRowIndex = -1;\n    if (!isPinnedSection && focusedCell.rowIndex !== -1) {\n      if (focusedCell.rowIndex < firstRowToRender) {\n        virtualRowIndex = focusedCell.rowIndex;\n        rowIndexes.unshift(virtualRowIndex);\n      }\n      if (focusedCell.rowIndex >= lastRowToRender) {\n        virtualRowIndex = focusedCell.rowIndex;\n        rowIndexes.push(virtualRowIndex);\n      }\n    }\n    const rows = [];\n    const rowProps = rootProps.slotProps?.row;\n    const columnPositions = gridColumnPositionsSelector(apiRef);\n    rowIndexes.forEach(rowIndexInPage => {\n      const {\n        id,\n        model\n      } = rowModels[rowIndexInPage];\n\n      // NOTE: This is an expensive feature, the colSpan code could be optimized.\n      if (hasColSpan) {\n        const minFirstColumn = pinnedColumns.left.length;\n        const maxLastColumn = visibleColumns.length - pinnedColumns.right.length;\n        apiRef.current.calculateColSpan({\n          rowId: id,\n          minFirstColumn,\n          maxLastColumn,\n          columns: visibleColumns\n        });\n        if (pinnedColumns.left.length > 0) {\n          apiRef.current.calculateColSpan({\n            rowId: id,\n            minFirstColumn: 0,\n            maxLastColumn: pinnedColumns.left.length,\n            columns: visibleColumns\n          });\n        }\n        if (pinnedColumns.right.length > 0) {\n          apiRef.current.calculateColSpan({\n            rowId: id,\n            minFirstColumn: visibleColumns.length - pinnedColumns.right.length,\n            maxLastColumn: visibleColumns.length,\n            columns: visibleColumns\n          });\n        }\n      }\n      const hasFocus = cellFocus?.id === id;\n      const baseRowHeight = !apiRef.current.rowHasAutoHeight(id) ? apiRef.current.unstable_getRowHeight(id) : 'auto';\n      let isSelected;\n      if (selectedRowsLookup[id] == null) {\n        isSelected = false;\n      } else {\n        isSelected = apiRef.current.isRowSelectable(id);\n      }\n      let isFirstVisible = false;\n      if (params.position === undefined) {\n        isFirstVisible = rowIndexInPage === 0;\n      }\n      let isLastVisible = false;\n      if (isLastSection) {\n        if (!isPinnedSection) {\n          const lastIndex = currentPage.rows.length - 1;\n          const isLastVisibleRowIndex = rowIndexInPage === lastIndex;\n          if (isLastVisibleRowIndex) {\n            isLastVisible = true;\n          }\n        } else {\n          isLastVisible = rowIndexInPage === rowModels.length - 1;\n        }\n      }\n      const isVirtualRow = rowIndexInPage === virtualRowIndex;\n      const isNotVisible = isVirtualRow;\n      let tabbableCell = null;\n      if (cellTabIndex !== null && cellTabIndex.id === id) {\n        const cellParams = apiRef.current.getCellParams(id, cellTabIndex.field);\n        tabbableCell = cellParams.cellMode === 'view' ? cellTabIndex.field : null;\n      }\n      let currentRenderContext = baseRenderContext;\n      if (!isPinnedSection && frozenContext.current && rowIndexInPage >= frozenContext.current.firstRowIndex && rowIndexInPage < frozenContext.current.lastRowIndex) {\n        currentRenderContext = frozenContext.current;\n      }\n      const offsetLeft = computeOffsetLeft(columnPositions, currentRenderContext, theme.direction, pinnedColumns.left.length);\n      const rowIndex = (currentPage?.range?.firstRowIndex || 0) + rowIndexOffset + rowIndexInPage;\n      rows.push( /*#__PURE__*/_jsx(rootProps.slots.row, _extends({\n        row: model,\n        rowId: id,\n        index: rowIndex,\n        selected: isSelected,\n        offsetTop: params.rows ? undefined : rowsMeta.positions[rowIndexInPage],\n        offsetLeft: offsetLeft,\n        dimensions: dimensions,\n        rowHeight: baseRowHeight,\n        tabbableCell: tabbableCell,\n        pinnedColumns: pinnedColumns,\n        visibleColumns: visibleColumns,\n        renderContext: currentRenderContext,\n        focusedColumnIndex: hasFocus ? focusedCell.columnIndex : undefined,\n        isFirstVisible: isFirstVisible,\n        isLastVisible: isLastVisible,\n        isNotVisible: isNotVisible\n      }, rowProps), id));\n      const panel = panels.get(id);\n      if (panel) {\n        rows.push(panel);\n      }\n      if (isLastVisible) {\n        rows.push(apiRef.current.getInfiniteLoadingTriggerElement?.({\n          lastRowId: id\n        }));\n      }\n    });\n    return rows;\n  };\n  const needsHorizontalScrollbar = outerSize.width && columnsTotalWidth >= outerSize.width;\n  const scrollerStyle = React.useMemo(() => ({\n    overflowX: !needsHorizontalScrollbar ? 'hidden' : undefined,\n    overflowY: rootProps.autoHeight ? 'hidden' : undefined\n  }), [needsHorizontalScrollbar, rootProps.autoHeight]);\n  const contentSize = React.useMemo(() => {\n    // In cases where the columns exceed the available width,\n    // the horizontal scrollbar should be shown even when there're no rows.\n    // Keeping 1px as minimum height ensures that the scrollbar will visible if necessary.\n    const height = Math.max(contentHeight, 1);\n    const size = {\n      width: needsHorizontalScrollbar ? columnsTotalWidth : 'auto',\n      height\n    };\n    if (rootProps.autoHeight) {\n      if (currentPage.rows.length === 0) {\n        size.height = getMinimalContentHeight(apiRef); // Give room to show the overlay when there no rows.\n      } else {\n        size.height = contentHeight;\n      }\n    }\n    return size;\n  }, [apiRef, columnsTotalWidth, contentHeight, needsHorizontalScrollbar, rootProps.autoHeight, currentPage.rows.length]);\n  React.useEffect(() => {\n    apiRef.current.publishEvent('virtualScrollerContentSizeChange');\n  }, [apiRef, contentSize]);\n  useEnhancedEffect(() => {\n    // FIXME: Is this really necessary?\n    apiRef.current.resize();\n  }, [apiRef, rowsMeta.currentPageTotalHeight]);\n  useEnhancedEffect(() => {\n    if (enabled) {\n      // TODO a scroll reset should not be necessary\n      scrollerRef.current.scrollLeft = 0;\n      scrollerRef.current.scrollTop = 0;\n    }\n  }, [enabled, gridRootRef, scrollerRef]);\n  useRunOnce(outerSize.width !== 0, () => {\n    const inputs = inputsSelector(apiRef, rootProps, enabled, enabledForColumns);\n    const initialRenderContext = computeRenderContext(inputs, scrollPosition.current, scrollCache);\n    updateRenderContext(initialRenderContext);\n    apiRef.current.publishEvent('scrollPositionChange', {\n      top: scrollPosition.current.top,\n      left: scrollPosition.current.left,\n      renderContext: initialRenderContext\n    });\n  });\n  apiRef.current.register('private', {\n    updateRenderContext: forceUpdateRenderContext\n  });\n  useGridApiEventHandler(apiRef, 'columnsChange', forceUpdateRenderContext);\n  useGridApiEventHandler(apiRef, 'filteredRowsSet', forceUpdateRenderContext);\n  useGridApiEventHandler(apiRef, 'rowExpansionChange', forceUpdateRenderContext);\n  return {\n    renderContext,\n    setPanels,\n    getRows,\n    getContainerProps: () => ({\n      ref: mainRef\n    }),\n    getScrollerProps: () => ({\n      ref: scrollerRef,\n      tabIndex: -1,\n      onScroll: handleScroll,\n      onWheel: handleWheel,\n      onTouchMove: handleTouchMove,\n      style: scrollerStyle,\n      role: 'presentation'\n    }),\n    getContentProps: () => ({\n      style: contentSize,\n      role: 'presentation'\n    }),\n    getRenderZoneProps: () => ({\n      role: 'rowgroup'\n    }),\n    getScrollbarVerticalProps: () => ({\n      ref: scrollbarVerticalRef,\n      role: 'presentation'\n    }),\n    getScrollbarHorizontalProps: () => ({\n      ref: scrollbarHorizontalRef,\n      role: 'presentation'\n    })\n  };\n};\nfunction inputsSelector(apiRef, rootProps, enabled, enabledForColumns) {\n  const dimensions = gridDimensionsSelector(apiRef.current.state);\n  const currentPage = getVisibleRows(apiRef, rootProps);\n  const visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);\n  const lastRowId = apiRef.current.state.rows.dataRowIds.at(-1);\n  const lastColumn = visibleColumns.at(-1);\n  return {\n    enabled,\n    enabledForColumns,\n    apiRef,\n    autoHeight: rootProps.autoHeight,\n    rowBufferPx: rootProps.rowBufferPx,\n    columnBufferPx: rootProps.columnBufferPx,\n    leftPinnedWidth: dimensions.leftPinnedWidth,\n    columnsTotalWidth: dimensions.columnsTotalWidth,\n    viewportInnerWidth: dimensions.viewportInnerSize.width,\n    viewportInnerHeight: dimensions.viewportInnerSize.height,\n    lastRowHeight: lastRowId !== undefined ? apiRef.current.unstable_getRowHeight(lastRowId) : 0,\n    lastColumnWidth: lastColumn?.computedWidth ?? 0,\n    rowsMeta: gridRowsMetaSelector(apiRef.current.state),\n    columnPositions: gridColumnPositionsSelector(apiRef),\n    rows: currentPage.rows,\n    range: currentPage.range,\n    pinnedColumns: gridVisiblePinnedColumnDefinitionsSelector(apiRef),\n    visibleColumns\n  };\n}\nfunction computeRenderContext(inputs, scrollPosition, scrollCache) {\n  let renderContext;\n  if (!inputs.enabled) {\n    renderContext = {\n      firstRowIndex: 0,\n      lastRowIndex: inputs.rows.length,\n      firstColumnIndex: 0,\n      lastColumnIndex: inputs.visibleColumns.length\n    };\n  } else {\n    const {\n      top,\n      left\n    } = scrollPosition;\n    const realLeft = Math.abs(left) + inputs.leftPinnedWidth;\n\n    // Clamp the value because the search may return an index out of bounds.\n    // In the last index, this is not needed because Array.slice doesn't include it.\n    const firstRowIndex = Math.min(getNearestIndexToRender(inputs, top, {\n      atStart: true,\n      lastPosition: inputs.rowsMeta.positions[inputs.rowsMeta.positions.length - 1] + inputs.lastRowHeight\n    }), inputs.rowsMeta.positions.length - 1);\n    const lastRowIndex = inputs.autoHeight ? firstRowIndex + inputs.rows.length : getNearestIndexToRender(inputs, top + inputs.viewportInnerHeight);\n    let firstColumnIndex = 0;\n    let lastColumnIndex = inputs.columnPositions.length;\n    if (inputs.enabledForColumns) {\n      let hasRowWithAutoHeight = false;\n      const [firstRowToRender, lastRowToRender] = getIndexesToRender({\n        firstIndex: firstRowIndex,\n        lastIndex: lastRowIndex,\n        minFirstIndex: 0,\n        maxLastIndex: inputs.rows.length,\n        bufferBefore: scrollCache.buffer.rowBefore,\n        bufferAfter: scrollCache.buffer.rowAfter,\n        positions: inputs.rowsMeta.positions,\n        lastSize: inputs.lastRowHeight\n      });\n      for (let i = firstRowToRender; i < lastRowToRender && !hasRowWithAutoHeight; i += 1) {\n        const row = inputs.rows[i];\n        hasRowWithAutoHeight = inputs.apiRef.current.rowHasAutoHeight(row.id);\n      }\n      if (!hasRowWithAutoHeight) {\n        firstColumnIndex = binarySearch(realLeft, inputs.columnPositions, {\n          atStart: true,\n          lastPosition: inputs.columnsTotalWidth\n        });\n        lastColumnIndex = binarySearch(realLeft + inputs.viewportInnerWidth, inputs.columnPositions);\n      }\n    }\n    renderContext = {\n      firstRowIndex,\n      lastRowIndex,\n      firstColumnIndex,\n      lastColumnIndex\n    };\n  }\n  const actualRenderContext = deriveRenderContext(inputs, renderContext, scrollCache);\n  return actualRenderContext;\n}\nfunction getNearestIndexToRender(inputs, offset, options) {\n  const lastMeasuredIndexRelativeToAllRows = inputs.apiRef.current.getLastMeasuredRowIndex();\n  let allRowsMeasured = lastMeasuredIndexRelativeToAllRows === Infinity;\n  if (inputs.range?.lastRowIndex && !allRowsMeasured) {\n    // Check if all rows in this page are already measured\n    allRowsMeasured = lastMeasuredIndexRelativeToAllRows >= inputs.range.lastRowIndex;\n  }\n  const lastMeasuredIndexRelativeToCurrentPage = clamp(lastMeasuredIndexRelativeToAllRows - (inputs.range?.firstRowIndex || 0), 0, inputs.rowsMeta.positions.length);\n  if (allRowsMeasured || inputs.rowsMeta.positions[lastMeasuredIndexRelativeToCurrentPage] >= offset) {\n    // If all rows were measured (when no row has \"auto\" as height) or all rows before the offset\n    // were measured, then use a binary search because it's faster.\n    return binarySearch(offset, inputs.rowsMeta.positions, options);\n  }\n\n  // Otherwise, use an exponential search.\n  // If rows have \"auto\" as height, their positions will be based on estimated heights.\n  // In this case, we can skip several steps until we find a position higher than the offset.\n  // Inspired by https://github.com/bvaughn/react-virtualized/blob/master/source/Grid/utils/CellSizeAndPositionManager.js\n  return exponentialSearch(offset, inputs.rowsMeta.positions, lastMeasuredIndexRelativeToCurrentPage, options);\n}\n\n/**\n * Accepts as input a raw render context (the area visible in the viewport) and adds\n * computes the actual render context based on pinned elements, buffer dimensions and\n * spanning.\n */\nfunction deriveRenderContext(inputs, nextRenderContext, scrollCache) {\n  const [firstRowToRender, lastRowToRender] = getIndexesToRender({\n    firstIndex: nextRenderContext.firstRowIndex,\n    lastIndex: nextRenderContext.lastRowIndex,\n    minFirstIndex: 0,\n    maxLastIndex: inputs.rows.length,\n    bufferBefore: scrollCache.buffer.rowBefore,\n    bufferAfter: scrollCache.buffer.rowAfter,\n    positions: inputs.rowsMeta.positions,\n    lastSize: inputs.lastRowHeight\n  });\n  const [initialFirstColumnToRender, lastColumnToRender] = getIndexesToRender({\n    firstIndex: nextRenderContext.firstColumnIndex,\n    lastIndex: nextRenderContext.lastColumnIndex,\n    minFirstIndex: inputs.pinnedColumns.left.length,\n    maxLastIndex: inputs.visibleColumns.length - inputs.pinnedColumns.right.length,\n    bufferBefore: scrollCache.buffer.columnBefore,\n    bufferAfter: scrollCache.buffer.columnAfter,\n    positions: inputs.columnPositions,\n    lastSize: inputs.lastColumnWidth\n  });\n  const firstColumnToRender = getFirstNonSpannedColumnToRender({\n    firstColumnToRender: initialFirstColumnToRender,\n    apiRef: inputs.apiRef,\n    firstRowToRender,\n    lastRowToRender,\n    visibleRows: inputs.rows\n  });\n  return {\n    firstRowIndex: firstRowToRender,\n    lastRowIndex: lastRowToRender,\n    firstColumnIndex: firstColumnToRender,\n    lastColumnIndex: lastColumnToRender\n  };\n}\n/**\n * Use binary search to avoid looping through all possible positions.\n * The `options.atStart` provides the possibility to match for the first element that\n * intersects the screen, even if said element's start position is before `offset`. In\n * other words, we search for `offset + width`.\n */\nfunction binarySearch(offset, positions, options = undefined, sliceStart = 0, sliceEnd = positions.length) {\n  if (positions.length <= 0) {\n    return -1;\n  }\n  if (sliceStart >= sliceEnd) {\n    return sliceStart;\n  }\n  const pivot = sliceStart + Math.floor((sliceEnd - sliceStart) / 2);\n  const position = positions[pivot];\n  let isBefore;\n  if (options?.atStart) {\n    const width = (pivot === positions.length - 1 ? options.lastPosition : positions[pivot + 1]) - position;\n    isBefore = offset - width < position;\n  } else {\n    isBefore = offset <= position;\n  }\n  return isBefore ? binarySearch(offset, positions, options, sliceStart, pivot) : binarySearch(offset, positions, options, pivot + 1, sliceEnd);\n}\nfunction exponentialSearch(offset, positions, index, options = undefined) {\n  let interval = 1;\n  while (index < positions.length && Math.abs(positions[index]) < offset) {\n    index += interval;\n    interval *= 2;\n  }\n  return binarySearch(offset, positions, options, Math.floor(index / 2), Math.min(index, positions.length));\n}\nfunction getIndexesToRender({\n  firstIndex,\n  lastIndex,\n  bufferBefore,\n  bufferAfter,\n  minFirstIndex,\n  maxLastIndex,\n  positions,\n  lastSize\n}) {\n  const firstPosition = positions[firstIndex] - bufferBefore;\n  const lastPosition = positions[lastIndex] + bufferAfter;\n  const firstIndexPadded = binarySearch(firstPosition, positions, {\n    atStart: true,\n    lastPosition: positions[positions.length - 1] + lastSize\n  });\n  const lastIndexPadded = binarySearch(lastPosition, positions);\n  return [clamp(firstIndexPadded, minFirstIndex, maxLastIndex), clamp(lastIndexPadded, minFirstIndex, maxLastIndex)];\n}\nexport function areRenderContextsEqual(context1, context2) {\n  if (context1 === context2) {\n    return true;\n  }\n  return context1.firstRowIndex === context2.firstRowIndex && context1.lastRowIndex === context2.lastRowIndex && context1.firstColumnIndex === context2.firstColumnIndex && context1.lastColumnIndex === context2.lastColumnIndex;\n}\nexport function computeOffsetLeft(columnPositions, renderContext, direction, pinnedLeftLength) {\n  const factor = direction === 'ltr' ? 1 : -1;\n  const left = factor * (columnPositions[renderContext.firstColumnIndex] ?? 0) - (columnPositions[pinnedLeftLength] ?? 0);\n  return Math.abs(left);\n}\nfunction directionForDelta(dx, dy) {\n  if (dx === 0 && dy === 0) {\n    return ScrollDirection.NONE;\n  }\n  /* eslint-disable */\n  if (Math.abs(dy) >= Math.abs(dx)) {\n    if (dy > 0) {\n      return ScrollDirection.DOWN;\n    } else {\n      return ScrollDirection.UP;\n    }\n  } else {\n    if (dx > 0) {\n      return ScrollDirection.RIGHT;\n    } else {\n      return ScrollDirection.LEFT;\n    }\n  }\n  /* eslint-enable */\n}\nfunction bufferForDirection(mode, direction, rowBufferPx, columnBufferPx, verticalBuffer, horizontalBuffer) {\n  if (mode === 'rtl') {\n    switch (direction) {\n      case ScrollDirection.LEFT:\n        direction = ScrollDirection.RIGHT;\n        break;\n      case ScrollDirection.RIGHT:\n        direction = ScrollDirection.LEFT;\n        break;\n      default:\n    }\n  }\n  switch (direction) {\n    case ScrollDirection.NONE:\n      return {\n        rowAfter: rowBufferPx,\n        rowBefore: rowBufferPx,\n        columnAfter: columnBufferPx,\n        columnBefore: columnBufferPx\n      };\n    case ScrollDirection.LEFT:\n      return {\n        rowAfter: 0,\n        rowBefore: 0,\n        columnAfter: 0,\n        columnBefore: horizontalBuffer\n      };\n    case ScrollDirection.RIGHT:\n      return {\n        rowAfter: 0,\n        rowBefore: 0,\n        columnAfter: horizontalBuffer,\n        columnBefore: 0\n      };\n    case ScrollDirection.UP:\n      return {\n        rowAfter: 0,\n        rowBefore: verticalBuffer,\n        columnAfter: 0,\n        columnBefore: 0\n      };\n    case ScrollDirection.DOWN:\n      return {\n        rowAfter: verticalBuffer,\n        rowBefore: 0,\n        columnAfter: 0,\n        columnBefore: 0\n      };\n    default:\n      // eslint unable to figure out enum exhaustiveness\n      throw new Error('unreachable');\n  }\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nexport const EMPTY_RENDER_CONTEXT = {\n  firstRowIndex: 0,\n  lastRowIndex: 0,\n  firstColumnIndex: 0,\n  lastColumnIndex: 0\n};\nexport const virtualizationStateInitializer = (state, props) => {\n  const virtualization = {\n    enabled: !props.disableVirtualization,\n    enabledForColumns: true,\n    renderContext: EMPTY_RENDER_CONTEXT\n  };\n  return _extends({}, state, {\n    virtualization\n  });\n};\nexport function useGridVirtualization(apiRef, props) {\n  /*\n   * API METHODS\n   */\n\n  const setVirtualization = enabled => {\n    apiRef.current.setState(state => _extends({}, state, {\n      virtualization: _extends({}, state.virtualization, {\n        enabled\n      })\n    }));\n  };\n  const setColumnVirtualization = enabled => {\n    apiRef.current.setState(state => _extends({}, state, {\n      virtualization: _extends({}, state.virtualization, {\n        enabledForColumns: enabled\n      })\n    }));\n  };\n  const api = {\n    unstable_setVirtualization: setVirtualization,\n    unstable_setColumnVirtualization: setColumnVirtualization\n  };\n  useGridApiMethod(apiRef, api, 'public');\n\n  /*\n   * EFFECTS\n   */\n\n  /* eslint-disable react-hooks/exhaustive-deps */\n  React.useEffect(() => {\n    setVirtualization(!props.disableVirtualization);\n  }, [props.disableVirtualization]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n}"],"names":["scrollIntoView","dimensions","clientHeight","scrollTop","offsetHeight","offsetTop","elementBottom","useGridScroll","apiRef","props","theme","logger","colRef","current","columnHeadersContainerRef","virtualScrollerRef","visibleSortedRows","scrollToIndexes","params","state","totalRowCount","visibleColumns","rowIndex","length","debug","colIndex","scrollCoordinates","undefined","columnPositions","cellWidth","rowId","id","cellColSpanInfo","unstable_getCellColSpanInfo","spannedByColSpan","cellProps","width","computedWidth","left","viewportInnerSize","Math","abs","scrollLeft","rowsMeta","page","pageSize","elementIndex","pagination","targetOffsetHeight","positions","currentPageTotalHeight","top","height","unstable_applyPipeProcessors","scroll","scrollApi","direction","getScrollPosition","gridSortingStateSelector","sorting","gridSortedRowIdsSelector","sortingState","sortedRows","gridSortedRowEntriesSelector","sortedIds","idRowsLookup","rowTree","reduce","acc","model","push","rowNode","gridSortModelSelector","sortModel","gridSortColumnLookupSelector","res","sortItem","index","field","sortDirection","sort","sortIndex","sanitizeSortModel","disableMultipleColumnsSorting","mergeStateWithSortModel","buildAggregatedSortingApplier","comparatorList","map","item","column","getColumn","comparator","getSortComparator","args","sortComparator","getSortCellParams","getRowNode","value","getCellValue","api","parseSortItem","filter","rowList","node","el","a","b","compareRows","row1","row2","sortCellParams1","sortCellParams2","row","getNextGridSortDirection","sortingOrder","currentIdx","indexOf","gridNillComparator","v1","v2","collator","Intl","Collator","gridStringOrNumberComparator","value1","value2","nillResult","compare","toString","gridNumberComparator","Number","gridDateComparator","sortingStateInitializer","initialState","useGridSorting","registerControlState","stateId","propModel","propOnChange","onSortModelChange","stateSelector","changeEvent","upsertSortModel","existingIdx","findIndex","c","newSortModel","splice","createSortItem","col","directionOverride","existing","find","nextSort","addColumnMenuItem","columnMenuItems","colDef","sortable","disableColumnSorting","some","applySorting","setState","sortingMode","instanceId","sortRowList","applyStrategyProcessor","publishEvent","forceUpdate","setSortModel","sortColumn","allowMultipleSorting","sortApi","getSortModel","getSortedRows","getSortedRowIds","getRowIdFromRowIndex","stateExportPreProcessing","prevState","context","sortModelToExport","exportOnlyDirtyModels","stateRestorePreProcessing","stateToRestore","callbacks","flatSortingMethod","rootGroupNode","sortedChildren","children","childId","footerId","handleColumnHeaderClick","event","shiftKey","metaKey","ctrlKey","handleColumnHeaderKeyDown","key","handleColumnsChange","latestColumns","newModel","handleStrategyProcessorChange","methodName","useGridStatePersistence","statePersistenceApi","exportState","restoreState","forEach","callback","gridVirtualizationSelector","virtualization","gridVirtualizationEnabledSelector","enabled","gridVirtualizationColumnEnabledSelector","enabledForColumns","gridRenderContextSelector","renderContext","gridRenderContextColumnsSelector","firstColumnIndex","lastColumnIndex","ScrollDirection","EMPTY_SCROLL_POSITION","EMPTY_DETAIL_PANELS","Object","freeze","Map","isJSDOM","window","test","navigator","userAgent","_","useGridVirtualScroller","rootProps","outerSize","viewportOuterSize","pinnedRows","pinnedColumns","hasBottomPinnedRows","bottom","panels","setPanels","cellFocus","cellTabIndex","selectedRowsLookup","currentPage","gridRootRef","rootElementRef","mainRef","mainElementRef","scrollerRef","scrollbarVerticalRef","scrollbarHorizontalRef","contentHeight","contentSize","columnsTotalWidth","hasColSpan","resize","scrollPosition","previousContextScrollPosition","previousRowContext","scrollTimeout","frozenContext","scrollCache","createScrollCache","mode","rowBufferPx","columnBufferPx","verticalBuffer","rowHeight","horizontalBuffer","MINIMUM_COLUMN_WIDTH","NONE","buffer","bufferForDirection","focusedCell","rows","columnIndex","updateRenderContext","nextRenderContext","context1","context2","firstRowIndex","lastRowIndex","areRenderContextsEqual","didRowsIntervalChange","isReady","triggerUpdateRenderContext","newScroll","dx","dy","isScrolling","DOWN","UP","RIGHT","LEFT","directionForDelta","rowScroll","columnScroll","didCrossThreshold","didChangeDirection","computeRenderContext","inputsSelector","start","forceUpdateRenderContext","handleScroll","currentTarget","handleWheel","handleTouchMove","needsHorizontalScrollbar","scrollerStyle","overflowX","overflowY","autoHeight","max","size","initialRenderContext","register","getRows","range","baseRenderContext","isLastSection","position","isPinnedSection","rowIndexOffset","rowModels","firstRowToRender","lastRowToRender","min","rowIndexes","virtualRowIndex","unshift","rowProps","slotProps","rowIndexInPage","minFirstColumn","maxLastColumn","right","calculateColSpan","columns","hasFocus","baseRowHeight","rowHasAutoHeight","unstable_getRowHeight","isSelected","isRowSelectable","isFirstVisible","isLastVisible","isNotVisible","tabbableCell","getCellParams","cellMode","currentRenderContext","offsetLeft","computeOffsetLeft","slots","selected","focusedColumnIndex","panel","get","getInfiniteLoadingTriggerElement","lastRowId","getContainerProps","ref","getScrollerProps","tabIndex","onScroll","onWheel","onTouchMove","style","role","getContentProps","getRenderZoneProps","getScrollbarVerticalProps","getScrollbarHorizontalProps","dataRowIds","at","lastColumn","leftPinnedWidth","viewportInnerWidth","viewportInnerHeight","lastRowHeight","lastColumnWidth","inputs","realLeft","getNearestIndexToRender","atStart","lastPosition","hasRowWithAutoHeight","getIndexesToRender","firstIndex","lastIndex","minFirstIndex","maxLastIndex","bufferBefore","rowBefore","bufferAfter","rowAfter","lastSize","i","binarySearch","actualRenderContext","initialFirstColumnToRender","lastColumnToRender","columnBefore","columnAfter","firstColumnToRender","visibleRows","deriveRenderContext","offset","options","lastMeasuredIndexRelativeToAllRows","getLastMeasuredRowIndex","allRowsMeasured","Infinity","lastMeasuredIndexRelativeToCurrentPage","interval","floor","exponentialSearch","sliceStart","sliceEnd","pivot","isBefore","firstPosition","firstIndexPadded","lastIndexPadded","pinnedLeftLength","Error","EMPTY_RENDER_CONTEXT","virtualizationStateInitializer","disableVirtualization","useGridVirtualization","setVirtualization","unstable_setVirtualization","unstable_setColumnVirtualization"],"sourceRoot":""}