{"version":3,"file":"react/js/vendor.mui@current-0b69f8a7.64296ff599d6a8a0a649.js","mappings":"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","sources":["webpack:///./node_modules/@mui/x-data-grid/hooks/features/density/densitySelector.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/density/useGridDensity.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/dimensions/gridDimensionsSelectors.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/dimensions/useGridDimensions.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/editing/gridEditingSelectors.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/editing/useGridCellEditing.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/editing/useGridRowEditing.js","webpack:///./node_modules/@mui/x-data-grid/hooks/features/editing/useGridEditing.js"],"sourcesContent":["import { createSelector } from '../../../utils/createSelector';\nexport const COMPACT_DENSITY_FACTOR = 0.7;\nexport const COMFORTABLE_DENSITY_FACTOR = 1.3;\nconst DENSITY_FACTORS = {\n  compact: COMPACT_DENSITY_FACTOR,\n  comfortable: COMFORTABLE_DENSITY_FACTOR,\n  standard: 1\n};\nexport const gridDensitySelector = state => state.density;\nexport const gridDensityFactorSelector = createSelector(gridDensitySelector, density => DENSITY_FACTORS[density]);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport useEventCallback from '@mui/utils/useEventCallback';\nimport { useGridLogger } from '../../utils/useGridLogger';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { gridDensitySelector } from './densitySelector';\nimport { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';\nexport const densityStateInitializer = (state, props) => _extends({}, state, {\n  density: props.initialState?.density ?? props.density ?? 'standard'\n});\nexport const useGridDensity = (apiRef, props) => {\n  const logger = useGridLogger(apiRef, 'useDensity');\n  apiRef.current.registerControlState({\n    stateId: 'density',\n    propModel: props.density,\n    propOnChange: props.onDensityChange,\n    stateSelector: gridDensitySelector,\n    changeEvent: 'densityChange'\n  });\n  const setDensity = useEventCallback(newDensity => {\n    const currentDensity = gridDensitySelector(apiRef.current.state);\n    if (currentDensity === newDensity) {\n      return;\n    }\n    logger.debug(`Set grid density to ${newDensity}`);\n    apiRef.current.setState(state => _extends({}, state, {\n      density: newDensity\n    }));\n  });\n  const densityApi = {\n    setDensity\n  };\n  useGridApiMethod(apiRef, densityApi, 'public');\n  const stateExportPreProcessing = React.useCallback((prevState, context) => {\n    const exportedDensity = gridDensitySelector(apiRef.current.state);\n    const shouldExportRowCount =\n    // Always export if the `exportOnlyDirtyModels` property is not activated\n    !context.exportOnlyDirtyModels ||\n    // Always export if the `density` is controlled\n    props.density != null ||\n    // Always export if the `density` has been initialized\n    props.initialState?.density != null;\n    if (!shouldExportRowCount) {\n      return prevState;\n    }\n    return _extends({}, prevState, {\n      density: exportedDensity\n    });\n  }, [apiRef, props.density, props.initialState?.density]);\n  const stateRestorePreProcessing = React.useCallback((params, context) => {\n    const restoredDensity = context.stateToRestore?.density ? context.stateToRestore.density : gridDensitySelector(apiRef.current.state);\n    apiRef.current.setState(state => _extends({}, state, {\n      density: restoredDensity\n    }));\n    return params;\n  }, [apiRef]);\n  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);\n  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);\n  React.useEffect(() => {\n    if (props.density) {\n      apiRef.current.setDensity(props.density);\n    }\n  }, [apiRef, props.density]);\n};","export const gridDimensionsSelector = state => state.dimensions;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useEventCallback as useEventCallback, unstable_ownerWindow as ownerWindow } from '@mui/utils';\nimport { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { throttle } from '../../../utils/throttle';\nimport { useGridLogger } from '../../utils/useGridLogger';\nimport { gridColumnsTotalWidthSelector, gridVisiblePinnedColumnDefinitionsSelector } from '../columns';\nimport { gridDimensionsSelector } from './gridDimensionsSelectors';\nimport { gridDensityFactorSelector } from '../density';\nimport { gridRenderContextSelector } from '../virtualization';\nimport { useGridSelector } from '../../utils';\nimport { getVisibleRows } from '../../utils/useGridVisibleRows';\nimport { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';\nimport { calculatePinnedRowsHeight } from '../rows/gridRowsUtils';\nimport { getTotalHeaderHeight } from '../columns/gridColumnsUtils';\nconst EMPTY_SIZE = {\n  width: 0,\n  height: 0\n};\nconst EMPTY_DIMENSIONS = {\n  isReady: false,\n  root: EMPTY_SIZE,\n  viewportOuterSize: EMPTY_SIZE,\n  viewportInnerSize: EMPTY_SIZE,\n  contentSize: EMPTY_SIZE,\n  minimumSize: EMPTY_SIZE,\n  hasScrollX: false,\n  hasScrollY: false,\n  scrollbarSize: 0,\n  headerHeight: 0,\n  headerFilterHeight: 0,\n  rowWidth: 0,\n  rowHeight: 0,\n  columnsTotalWidth: 0,\n  leftPinnedWidth: 0,\n  rightPinnedWidth: 0,\n  headersTotalHeight: 0,\n  topContainerHeight: 0,\n  bottomContainerHeight: 0\n};\nexport const dimensionsStateInitializer = state => {\n  const dimensions = EMPTY_DIMENSIONS;\n  return _extends({}, state, {\n    dimensions\n  });\n};\nexport function useGridDimensions(apiRef, props) {\n  const logger = useGridLogger(apiRef, 'useResizeContainer');\n  const errorShown = React.useRef(false);\n  const rootDimensionsRef = React.useRef(EMPTY_SIZE);\n  const rowsMeta = useGridSelector(apiRef, gridRowsMetaSelector);\n  const pinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);\n  const densityFactor = useGridSelector(apiRef, gridDensityFactorSelector);\n  const rowHeight = Math.floor(props.rowHeight * densityFactor);\n  const headerHeight = Math.floor(props.columnHeaderHeight * densityFactor);\n  const headerFilterHeight = Math.floor((props.headerFilterHeight ?? props.columnHeaderHeight) * densityFactor);\n  const columnsTotalWidth = roundToDecimalPlaces(gridColumnsTotalWidthSelector(apiRef), 6);\n  const headersTotalHeight = getTotalHeaderHeight(apiRef, props);\n  const leftPinnedWidth = pinnedColumns.left.reduce((w, col) => w + col.computedWidth, 0);\n  const rightPinnedWidth = pinnedColumns.right.reduce((w, col) => w + col.computedWidth, 0);\n  const [savedSize, setSavedSize] = React.useState();\n  const debouncedSetSavedSize = React.useMemo(() => throttle(setSavedSize, props.resizeThrottleMs), [props.resizeThrottleMs]);\n  const previousSize = React.useRef();\n  const getRootDimensions = () => apiRef.current.state.dimensions;\n  const setDimensions = useEventCallback(dimensions => {\n    apiRef.current.setState(state => _extends({}, state, {\n      dimensions\n    }));\n  });\n  const resize = React.useCallback(() => {\n    const element = apiRef.current.mainElementRef.current;\n    if (!element) {\n      return;\n    }\n    const computedStyle = ownerWindow(element).getComputedStyle(element);\n    const height = parseFloat(computedStyle.height) || 0;\n    const width = parseFloat(computedStyle.width) || 0;\n    const hasHeightChanged = height !== previousSize.current?.height;\n    const hasWidthChanged = width !== previousSize.current?.width;\n    if (!previousSize.current || hasHeightChanged || hasWidthChanged) {\n      const size = {\n        width,\n        height\n      };\n      apiRef.current.publishEvent('resize', size);\n      previousSize.current = size;\n    }\n  }, [apiRef]);\n  const getViewportPageSize = React.useCallback(() => {\n    const dimensions = gridDimensionsSelector(apiRef.current.state);\n    if (!dimensions.isReady) {\n      return 0;\n    }\n    const currentPage = getVisibleRows(apiRef, {\n      pagination: props.pagination,\n      paginationMode: props.paginationMode\n    });\n\n    // TODO: Use a combination of scrollTop, dimensions.viewportInnerSize.height and rowsMeta.possitions\n    // to find out the maximum number of rows that can fit in the visible part of the grid\n    if (props.getRowHeight) {\n      const renderContext = gridRenderContextSelector(apiRef);\n      const viewportPageSize = renderContext.lastRowIndex - renderContext.firstRowIndex;\n      return Math.min(viewportPageSize - 1, currentPage.rows.length);\n    }\n    const maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);\n    return Math.min(maximumPageSizeWithoutScrollBar, currentPage.rows.length);\n  }, [apiRef, props.pagination, props.paginationMode, props.getRowHeight, rowHeight]);\n  const updateDimensions = React.useCallback(() => {\n    const rootElement = apiRef.current.rootElementRef.current;\n    const pinnedRowsHeight = calculatePinnedRowsHeight(apiRef);\n    const scrollbarSize = measureScrollbarSize(rootElement, columnsTotalWidth, props.scrollbarSize);\n    const topContainerHeight = headersTotalHeight + pinnedRowsHeight.top;\n    const bottomContainerHeight = pinnedRowsHeight.bottom;\n    const nonPinnedColumnsTotalWidth = columnsTotalWidth - leftPinnedWidth - rightPinnedWidth;\n    const contentSize = {\n      width: nonPinnedColumnsTotalWidth,\n      height: rowsMeta.currentPageTotalHeight\n    };\n    let viewportOuterSize;\n    let viewportInnerSize;\n    let hasScrollX = false;\n    let hasScrollY = false;\n    if (props.autoHeight) {\n      hasScrollY = false;\n      hasScrollX = Math.round(columnsTotalWidth) > Math.round(rootDimensionsRef.current.width);\n      viewportOuterSize = {\n        width: rootDimensionsRef.current.width,\n        height: topContainerHeight + bottomContainerHeight + contentSize.height\n      };\n      viewportInnerSize = {\n        width: Math.max(0, viewportOuterSize.width - (hasScrollY ? scrollbarSize : 0)),\n        height: Math.max(0, viewportOuterSize.height - (hasScrollX ? scrollbarSize : 0))\n      };\n    } else {\n      viewportOuterSize = {\n        width: rootDimensionsRef.current.width,\n        height: rootDimensionsRef.current.height\n      };\n      viewportInnerSize = {\n        width: Math.max(0, viewportOuterSize.width - leftPinnedWidth - rightPinnedWidth),\n        height: Math.max(0, viewportOuterSize.height - topContainerHeight - bottomContainerHeight)\n      };\n      const content = contentSize;\n      const container = viewportInnerSize;\n      const hasScrollXIfNoYScrollBar = content.width > container.width;\n      const hasScrollYIfNoXScrollBar = content.height > container.height;\n      if (hasScrollXIfNoYScrollBar || hasScrollYIfNoXScrollBar) {\n        hasScrollY = hasScrollYIfNoXScrollBar;\n        hasScrollX = content.width + (hasScrollY ? scrollbarSize : 0) > container.width;\n\n        // We recalculate the scroll y to consider the size of the x scrollbar.\n        if (hasScrollX) {\n          hasScrollY = content.height + scrollbarSize > container.height;\n        }\n      }\n      if (hasScrollY) {\n        viewportInnerSize.width -= scrollbarSize;\n      }\n      if (hasScrollX) {\n        viewportInnerSize.height -= scrollbarSize;\n      }\n    }\n    const rowWidth = Math.max(viewportOuterSize.width, columnsTotalWidth + (hasScrollY ? scrollbarSize : 0));\n    const minimumSize = {\n      width: columnsTotalWidth,\n      height: topContainerHeight + contentSize.height + bottomContainerHeight\n    };\n    const newDimensions = {\n      isReady: true,\n      root: rootDimensionsRef.current,\n      viewportOuterSize,\n      viewportInnerSize,\n      contentSize,\n      minimumSize,\n      hasScrollX,\n      hasScrollY,\n      scrollbarSize,\n      headerHeight,\n      headerFilterHeight,\n      rowWidth,\n      rowHeight,\n      columnsTotalWidth,\n      leftPinnedWidth,\n      rightPinnedWidth,\n      headersTotalHeight,\n      topContainerHeight,\n      bottomContainerHeight\n    };\n    const prevDimensions = apiRef.current.state.dimensions;\n    setDimensions(newDimensions);\n    if (newDimensions.viewportInnerSize.width !== prevDimensions.viewportInnerSize.width || newDimensions.viewportInnerSize.height !== prevDimensions.viewportInnerSize.height) {\n      apiRef.current.publishEvent('viewportInnerSizeChange', newDimensions.viewportInnerSize);\n    }\n    apiRef.current.updateRenderContext?.();\n  }, [apiRef, setDimensions, props.scrollbarSize, props.autoHeight, rowsMeta.currentPageTotalHeight, rowHeight, headerHeight, headerFilterHeight, columnsTotalWidth, headersTotalHeight, leftPinnedWidth, rightPinnedWidth]);\n  const apiPublic = {\n    resize,\n    getRootDimensions\n  };\n  const apiPrivate = {\n    updateDimensions,\n    getViewportPageSize\n  };\n  useGridApiMethod(apiRef, apiPublic, 'public');\n  useGridApiMethod(apiRef, apiPrivate, 'private');\n  useEnhancedEffect(() => {\n    if (savedSize) {\n      updateDimensions();\n      apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);\n    }\n  }, [apiRef, savedSize, updateDimensions]);\n  const root = apiRef.current.rootElementRef.current;\n  const dimensions = apiRef.current.state.dimensions;\n  useEnhancedEffect(() => {\n    if (!root) {\n      return;\n    }\n    const set = (k, v) => root.style.setProperty(k, v);\n    set('--DataGrid-width', `${dimensions.viewportOuterSize.width}px`);\n    set('--DataGrid-hasScrollX', `${Number(dimensions.hasScrollX)}`);\n    set('--DataGrid-hasScrollY', `${Number(dimensions.hasScrollY)}`);\n    set('--DataGrid-scrollbarSize', `${dimensions.scrollbarSize}px`);\n    set('--DataGrid-rowWidth', `${dimensions.rowWidth}px`);\n    set('--DataGrid-columnsTotalWidth', `${dimensions.columnsTotalWidth}px`);\n    set('--DataGrid-leftPinnedWidth', `${dimensions.leftPinnedWidth}px`);\n    set('--DataGrid-rightPinnedWidth', `${dimensions.rightPinnedWidth}px`);\n    set('--DataGrid-headerHeight', `${dimensions.headerHeight}px`);\n    set('--DataGrid-headersTotalHeight', `${dimensions.headersTotalHeight}px`);\n    set('--DataGrid-topContainerHeight', `${dimensions.topContainerHeight}px`);\n    set('--DataGrid-bottomContainerHeight', `${dimensions.bottomContainerHeight}px`);\n    set('--height', `${dimensions.rowHeight}px`);\n  }, [root, dimensions]);\n  const isFirstSizing = React.useRef(true);\n  const handleResize = React.useCallback(size => {\n    rootDimensionsRef.current = size;\n\n    // jsdom has no layout capabilities\n    const isJSDOM = /jsdom/.test(window.navigator.userAgent);\n    if (size.height === 0 && !errorShown.current && !props.autoHeight && !isJSDOM) {\n      logger.error(['The parent DOM element of the data grid has an empty height.', 'Please make sure that this element has an intrinsic height.', 'The grid displays with a height of 0px.', '', 'More details: https://mui.com/r/x-data-grid-no-dimensions.'].join('\\n'));\n      errorShown.current = true;\n    }\n    if (size.width === 0 && !errorShown.current && !isJSDOM) {\n      logger.error(['The parent DOM element of the data grid has an empty width.', 'Please make sure that this element has an intrinsic width.', 'The grid displays with a width of 0px.', '', 'More details: https://mui.com/r/x-data-grid-no-dimensions.'].join('\\n'));\n      errorShown.current = true;\n    }\n    if (isFirstSizing.current) {\n      // We want to initialize the grid dimensions as soon as possible to avoid flickering\n      setSavedSize(size);\n      isFirstSizing.current = false;\n      return;\n    }\n    debouncedSetSavedSize(size);\n  }, [props.autoHeight, debouncedSetSavedSize, logger]);\n  useEnhancedEffect(updateDimensions, [updateDimensions]);\n  useGridApiOptionHandler(apiRef, 'sortedRowsSet', updateDimensions);\n  useGridApiOptionHandler(apiRef, 'paginationModelChange', updateDimensions);\n  useGridApiOptionHandler(apiRef, 'columnsChange', updateDimensions);\n  useGridApiEventHandler(apiRef, 'resize', handleResize);\n  useGridApiOptionHandler(apiRef, 'debouncedResize', props.onResize);\n}\nfunction measureScrollbarSize(rootElement, columnsTotalWidth, scrollbarSize) {\n  if (scrollbarSize !== undefined) {\n    return scrollbarSize;\n  }\n  if (rootElement === null || columnsTotalWidth === 0) {\n    return 0;\n  }\n  const doc = ownerDocument(rootElement);\n  const scrollDiv = doc.createElement('div');\n  scrollDiv.style.width = '99px';\n  scrollDiv.style.height = '99px';\n  scrollDiv.style.position = 'absolute';\n  scrollDiv.style.overflow = 'scroll';\n  scrollDiv.className = 'scrollDiv';\n  rootElement.appendChild(scrollDiv);\n  const size = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n  rootElement.removeChild(scrollDiv);\n  return size;\n}\n\n// Get rid of floating point imprecision errors\n// https://github.com/mui/mui-x/issues/9550#issuecomment-1619020477\nfunction roundToDecimalPlaces(value, decimals) {\n  return Math.round(value * 10 ** decimals) / 10 ** decimals;\n}","// TODO v6: rename to gridEditingStateSelector\nexport const gridEditRowsStateSelector = state => state.editRows;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _toPropertyKey from \"@babel/runtime/helpers/esm/toPropertyKey\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"id\", \"field\"],\n  _excluded2 = [\"id\", \"field\"];\nimport * as React from 'react';\nimport { unstable_useEventCallback as useEventCallback, unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';\nimport { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';\nimport { GridEditModes, GridCellModes } from '../../../models/gridEditRowModel';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { gridEditRowsStateSelector } from './gridEditingSelectors';\nimport { isPrintableKey, isPasteShortcut } from '../../../utils/keyboardUtils';\nimport { buildWarning } from '../../../utils/warning';\nimport { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';\nimport { deepClone } from '../../../utils/utils';\nimport { GridCellEditStartReasons, GridCellEditStopReasons } from '../../../models/params/gridEditCellParams';\nconst missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, for example `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');\nexport const useGridCellEditing = (apiRef, props) => {\n  const [cellModesModel, setCellModesModel] = React.useState({});\n  const cellModesModelRef = React.useRef(cellModesModel);\n  const prevCellModesModel = React.useRef({});\n  const {\n    processRowUpdate,\n    onProcessRowUpdateError,\n    cellModesModel: cellModesModelProp,\n    onCellModesModelChange\n  } = props;\n  const runIfEditModeIsCell = callback => (...args) => {\n    if (props.editMode === GridEditModes.Cell) {\n      callback(...args);\n    }\n  };\n  const throwIfNotEditable = React.useCallback((id, field) => {\n    const params = apiRef.current.getCellParams(id, field);\n    if (!apiRef.current.isCellEditable(params)) {\n      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not editable.`);\n    }\n  }, [apiRef]);\n  const throwIfNotInMode = React.useCallback((id, field, mode) => {\n    if (apiRef.current.getCellMode(id, field) !== mode) {\n      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not in ${mode} mode.`);\n    }\n  }, [apiRef]);\n  const handleCellDoubleClick = React.useCallback((params, event) => {\n    if (!params.isEditable) {\n      return;\n    }\n    if (params.cellMode === GridCellModes.Edit) {\n      return;\n    }\n    const newParams = _extends({}, params, {\n      reason: GridCellEditStartReasons.cellDoubleClick\n    });\n    apiRef.current.publishEvent('cellEditStart', newParams, event);\n  }, [apiRef]);\n  const handleCellFocusOut = React.useCallback((params, event) => {\n    if (params.cellMode === GridCellModes.View) {\n      return;\n    }\n    if (apiRef.current.getCellMode(params.id, params.field) === GridCellModes.View) {\n      return;\n    }\n    const newParams = _extends({}, params, {\n      reason: GridCellEditStopReasons.cellFocusOut\n    });\n    apiRef.current.publishEvent('cellEditStop', newParams, event);\n  }, [apiRef]);\n  const handleCellKeyDown = React.useCallback((params, event) => {\n    if (params.cellMode === GridCellModes.Edit) {\n      // Wait until IME is settled for Asian languages like Japanese and Chinese\n      // TODO: `event.which` is deprecated but this is a temporary workaround\n      if (event.which === 229) {\n        return;\n      }\n      let reason;\n      if (event.key === 'Escape') {\n        reason = GridCellEditStopReasons.escapeKeyDown;\n      } else if (event.key === 'Enter') {\n        reason = GridCellEditStopReasons.enterKeyDown;\n      } else if (event.key === 'Tab') {\n        reason = event.shiftKey ? GridCellEditStopReasons.shiftTabKeyDown : GridCellEditStopReasons.tabKeyDown;\n        event.preventDefault(); // Prevent going to the next element in the tab sequence\n      }\n      if (reason) {\n        const newParams = _extends({}, params, {\n          reason\n        });\n        apiRef.current.publishEvent('cellEditStop', newParams, event);\n      }\n    } else if (params.isEditable) {\n      let reason;\n      const canStartEditing = apiRef.current.unstable_applyPipeProcessors('canStartEditing', true, {\n        event,\n        cellParams: params,\n        editMode: 'cell'\n      });\n      if (!canStartEditing) {\n        return;\n      }\n      if (isPrintableKey(event)) {\n        reason = GridCellEditStartReasons.printableKeyDown;\n      } else if (isPasteShortcut(event)) {\n        reason = GridCellEditStartReasons.pasteKeyDown;\n      } else if (event.key === 'Enter') {\n        reason = GridCellEditStartReasons.enterKeyDown;\n      } else if (event.key === 'Backspace' || event.key === 'Delete') {\n        reason = GridCellEditStartReasons.deleteKeyDown;\n      }\n      if (reason) {\n        const newParams = _extends({}, params, {\n          reason,\n          key: event.key\n        });\n        apiRef.current.publishEvent('cellEditStart', newParams, event);\n      }\n    }\n  }, [apiRef]);\n  const handleCellEditStart = React.useCallback(params => {\n    const {\n      id,\n      field,\n      reason\n    } = params;\n    const startCellEditModeParams = {\n      id,\n      field\n    };\n    if (reason === GridCellEditStartReasons.printableKeyDown || reason === GridCellEditStartReasons.deleteKeyDown || reason === GridCellEditStartReasons.pasteKeyDown) {\n      startCellEditModeParams.deleteValue = true;\n    }\n    apiRef.current.startCellEditMode(startCellEditModeParams);\n  }, [apiRef]);\n  const handleCellEditStop = React.useCallback(params => {\n    const {\n      id,\n      field,\n      reason\n    } = params;\n    apiRef.current.runPendingEditCellValueMutation(id, field);\n    let cellToFocusAfter;\n    if (reason === GridCellEditStopReasons.enterKeyDown) {\n      cellToFocusAfter = 'below';\n    } else if (reason === GridCellEditStopReasons.tabKeyDown) {\n      cellToFocusAfter = 'right';\n    } else if (reason === GridCellEditStopReasons.shiftTabKeyDown) {\n      cellToFocusAfter = 'left';\n    }\n    const ignoreModifications = reason === 'escapeKeyDown';\n    apiRef.current.stopCellEditMode({\n      id,\n      field,\n      ignoreModifications,\n      cellToFocusAfter\n    });\n  }, [apiRef]);\n  const runIfNoFieldErrors = callback => async (...args) => {\n    if (callback) {\n      const {\n        id,\n        field\n      } = args[0];\n      const editRowsState = apiRef.current.state.editRows;\n      const hasFieldErrors = editRowsState[id][field]?.error;\n      if (!hasFieldErrors) {\n        callback(...args);\n      }\n    }\n  };\n  useGridApiEventHandler(apiRef, 'cellDoubleClick', runIfEditModeIsCell(handleCellDoubleClick));\n  useGridApiEventHandler(apiRef, 'cellFocusOut', runIfEditModeIsCell(handleCellFocusOut));\n  useGridApiEventHandler(apiRef, 'cellKeyDown', runIfEditModeIsCell(handleCellKeyDown));\n  useGridApiEventHandler(apiRef, 'cellEditStart', runIfEditModeIsCell(handleCellEditStart));\n  useGridApiEventHandler(apiRef, 'cellEditStop', runIfEditModeIsCell(handleCellEditStop));\n  useGridApiOptionHandler(apiRef, 'cellEditStart', props.onCellEditStart);\n  useGridApiOptionHandler(apiRef, 'cellEditStop', runIfNoFieldErrors(props.onCellEditStop));\n  const getCellMode = React.useCallback((id, field) => {\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const isEditing = editingState[id] && editingState[id][field];\n    return isEditing ? GridCellModes.Edit : GridCellModes.View;\n  }, [apiRef]);\n  const updateCellModesModel = useEventCallback(newModel => {\n    const isNewModelDifferentFromProp = newModel !== props.cellModesModel;\n    if (onCellModesModelChange && isNewModelDifferentFromProp) {\n      onCellModesModelChange(newModel, {\n        api: apiRef.current\n      });\n    }\n    if (props.cellModesModel && isNewModelDifferentFromProp) {\n      return; // The prop always win\n    }\n    setCellModesModel(newModel);\n    cellModesModelRef.current = newModel;\n    apiRef.current.publishEvent('cellModesModelChange', newModel);\n  });\n  const updateFieldInCellModesModel = React.useCallback((id, field, newProps) => {\n    // We use the ref because it always contain the up-to-date value, different from the state\n    // that needs a rerender to reflect the new value\n    const newModel = _extends({}, cellModesModelRef.current);\n    if (newProps !== null) {\n      newModel[id] = _extends({}, newModel[id], {\n        [field]: _extends({}, newProps)\n      });\n    } else {\n      const _newModel$id = newModel[id],\n        otherFields = _objectWithoutPropertiesLoose(_newModel$id, [field].map(_toPropertyKey)); // Ensure that we have a new object, not a reference\n      newModel[id] = otherFields;\n      if (Object.keys(newModel[id]).length === 0) {\n        delete newModel[id];\n      }\n    }\n    updateCellModesModel(newModel);\n  }, [updateCellModesModel]);\n  const updateOrDeleteFieldState = React.useCallback((id, field, newProps) => {\n    apiRef.current.setState(state => {\n      const newEditingState = _extends({}, state.editRows);\n      if (newProps !== null) {\n        newEditingState[id] = _extends({}, newEditingState[id], {\n          [field]: _extends({}, newProps)\n        });\n      } else {\n        delete newEditingState[id][field];\n        if (Object.keys(newEditingState[id]).length === 0) {\n          delete newEditingState[id];\n        }\n      }\n      return _extends({}, state, {\n        editRows: newEditingState\n      });\n    });\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const startCellEditMode = React.useCallback(params => {\n    const {\n        id,\n        field\n      } = params,\n      other = _objectWithoutPropertiesLoose(params, _excluded);\n    throwIfNotEditable(id, field);\n    throwIfNotInMode(id, field, GridCellModes.View);\n    updateFieldInCellModesModel(id, field, _extends({\n      mode: GridCellModes.Edit\n    }, other));\n  }, [throwIfNotEditable, throwIfNotInMode, updateFieldInCellModesModel]);\n  const updateStateToStartCellEditMode = useEventCallback(params => {\n    const {\n      id,\n      field,\n      deleteValue,\n      initialValue\n    } = params;\n    let newValue = apiRef.current.getCellValue(id, field);\n    if (deleteValue) {\n      const fieldType = apiRef.current.getColumn(field).type;\n      switch (fieldType) {\n        case 'boolean':\n          newValue = false;\n          break;\n        case 'date':\n        case 'dateTime':\n        case 'number':\n          newValue = undefined;\n          break;\n        case 'singleSelect':\n          newValue = null;\n          break;\n        case 'string':\n        default:\n          newValue = '';\n          break;\n      }\n    } else if (initialValue) {\n      newValue = initialValue;\n    }\n    const newProps = {\n      value: newValue,\n      error: false,\n      isProcessingProps: false\n    };\n    updateOrDeleteFieldState(id, field, newProps);\n    apiRef.current.setCellFocus(id, field);\n  });\n  const stopCellEditMode = React.useCallback(params => {\n    const {\n        id,\n        field\n      } = params,\n      other = _objectWithoutPropertiesLoose(params, _excluded2);\n    throwIfNotInMode(id, field, GridCellModes.Edit);\n    updateFieldInCellModesModel(id, field, _extends({\n      mode: GridCellModes.View\n    }, other));\n  }, [throwIfNotInMode, updateFieldInCellModesModel]);\n  const updateStateToStopCellEditMode = useEventCallback(async params => {\n    const {\n      id,\n      field,\n      ignoreModifications,\n      cellToFocusAfter = 'none'\n    } = params;\n    throwIfNotInMode(id, field, GridCellModes.Edit);\n    apiRef.current.runPendingEditCellValueMutation(id, field);\n    const finishCellEditMode = () => {\n      updateOrDeleteFieldState(id, field, null);\n      updateFieldInCellModesModel(id, field, null);\n      if (cellToFocusAfter !== 'none') {\n        apiRef.current.moveFocusToRelativeCell(id, field, cellToFocusAfter);\n      }\n    };\n    if (ignoreModifications) {\n      finishCellEditMode();\n      return;\n    }\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const {\n      error,\n      isProcessingProps\n    } = editingState[id][field];\n    if (error || isProcessingProps) {\n      // Attempt to change cell mode to \"view\" was not successful\n      // Update previous mode to allow another attempt\n      prevCellModesModel.current[id][field].mode = GridCellModes.Edit;\n      // Revert the mode in the cellModesModel prop back to \"edit\"\n      updateFieldInCellModesModel(id, field, {\n        mode: GridCellModes.Edit\n      });\n      return;\n    }\n    const rowUpdate = apiRef.current.getRowWithUpdatedValuesFromCellEditing(id, field);\n    if (processRowUpdate) {\n      const handleError = errorThrown => {\n        prevCellModesModel.current[id][field].mode = GridCellModes.Edit;\n        // Revert the mode in the cellModesModel prop back to \"edit\"\n        updateFieldInCellModesModel(id, field, {\n          mode: GridCellModes.Edit\n        });\n        if (onProcessRowUpdateError) {\n          onProcessRowUpdateError(errorThrown);\n        } else if (process.env.NODE_ENV !== 'production') {\n          missingOnProcessRowUpdateErrorWarning();\n        }\n      };\n      try {\n        const row = apiRef.current.getRow(id);\n        Promise.resolve(processRowUpdate(rowUpdate, row)).then(finalRowUpdate => {\n          apiRef.current.updateRows([finalRowUpdate]);\n          finishCellEditMode();\n        }).catch(handleError);\n      } catch (errorThrown) {\n        handleError(errorThrown);\n      }\n    } else {\n      apiRef.current.updateRows([rowUpdate]);\n      finishCellEditMode();\n    }\n  });\n  const setCellEditingEditCellValue = React.useCallback(async params => {\n    const {\n      id,\n      field,\n      value,\n      debounceMs,\n      unstable_skipValueParser: skipValueParser\n    } = params;\n    throwIfNotEditable(id, field);\n    throwIfNotInMode(id, field, GridCellModes.Edit);\n    const column = apiRef.current.getColumn(field);\n    const row = apiRef.current.getRow(id);\n    let parsedValue = value;\n    if (column.valueParser && !skipValueParser) {\n      parsedValue = column.valueParser(value, row, column, apiRef);\n    }\n    let editingState = gridEditRowsStateSelector(apiRef.current.state);\n    let newProps = _extends({}, editingState[id][field], {\n      value: parsedValue,\n      changeReason: debounceMs ? 'debouncedSetEditCellValue' : 'setEditCellValue'\n    });\n    if (column.preProcessEditCellProps) {\n      const hasChanged = value !== editingState[id][field].value;\n      newProps = _extends({}, newProps, {\n        isProcessingProps: true\n      });\n      updateOrDeleteFieldState(id, field, newProps);\n      newProps = await Promise.resolve(column.preProcessEditCellProps({\n        id,\n        row,\n        props: newProps,\n        hasChanged\n      }));\n    }\n\n    // Check again if the cell is in edit mode because the user may have\n    // discarded the changes while the props were being processed.\n    if (apiRef.current.getCellMode(id, field) === GridCellModes.View) {\n      return false;\n    }\n    editingState = gridEditRowsStateSelector(apiRef.current.state);\n    newProps = _extends({}, newProps, {\n      isProcessingProps: false\n    });\n    // We don't update the value with the one coming from the props pre-processing\n    // because when the promise resolves it may be already outdated. The only\n    // exception to this rule is when there's no pre-processing.\n    newProps.value = column.preProcessEditCellProps ? editingState[id][field].value : parsedValue;\n    updateOrDeleteFieldState(id, field, newProps);\n    editingState = gridEditRowsStateSelector(apiRef.current.state);\n    return !editingState[id]?.[field]?.error;\n  }, [apiRef, throwIfNotEditable, throwIfNotInMode, updateOrDeleteFieldState]);\n  const getRowWithUpdatedValuesFromCellEditing = React.useCallback((id, field) => {\n    const column = apiRef.current.getColumn(field);\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const row = apiRef.current.getRow(id);\n    if (!editingState[id] || !editingState[id][field]) {\n      return apiRef.current.getRow(id);\n    }\n    const {\n      value\n    } = editingState[id][field];\n    return column.valueSetter ? column.valueSetter(value, row, column, apiRef) : _extends({}, row, {\n      [field]: value\n    });\n  }, [apiRef]);\n  const editingApi = {\n    getCellMode,\n    startCellEditMode,\n    stopCellEditMode\n  };\n  const editingPrivateApi = {\n    setCellEditingEditCellValue,\n    getRowWithUpdatedValuesFromCellEditing\n  };\n  useGridApiMethod(apiRef, editingApi, 'public');\n  useGridApiMethod(apiRef, editingPrivateApi, 'private');\n  React.useEffect(() => {\n    if (cellModesModelProp) {\n      updateCellModesModel(cellModesModelProp);\n    }\n  }, [cellModesModelProp, updateCellModesModel]);\n\n  // Run this effect synchronously so that the keyboard event can impact the yet-to-be-rendered input.\n  useEnhancedEffect(() => {\n    const idToIdLookup = gridRowsDataRowIdToIdLookupSelector(apiRef);\n\n    // Update the ref here because updateStateToStopCellEditMode may change it later\n    const copyOfPrevCellModes = prevCellModesModel.current;\n    prevCellModesModel.current = deepClone(cellModesModel); // Do a deep-clone because the attributes might be changed later\n\n    Object.entries(cellModesModel).forEach(([id, fields]) => {\n      Object.entries(fields).forEach(([field, params]) => {\n        const prevMode = copyOfPrevCellModes[id]?.[field]?.mode || GridCellModes.View;\n        const originalId = idToIdLookup[id] ?? id;\n        if (params.mode === GridCellModes.Edit && prevMode === GridCellModes.View) {\n          updateStateToStartCellEditMode(_extends({\n            id: originalId,\n            field\n          }, params));\n        } else if (params.mode === GridCellModes.View && prevMode === GridCellModes.Edit) {\n          updateStateToStopCellEditMode(_extends({\n            id: originalId,\n            field\n          }, params));\n        }\n      });\n    });\n  }, [apiRef, cellModesModel, updateStateToStartCellEditMode, updateStateToStopCellEditMode]);\n};","import _toPropertyKey from \"@babel/runtime/helpers/esm/toPropertyKey\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"id\"],\n  _excluded2 = [\"id\"];\nimport * as React from 'react';\nimport { unstable_useEventCallback as useEventCallback, unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';\nimport { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';\nimport { GridEditModes, GridRowModes } from '../../../models/gridEditRowModel';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { gridEditRowsStateSelector } from './gridEditingSelectors';\nimport { isPrintableKey, isPasteShortcut } from '../../../utils/keyboardUtils';\nimport { gridColumnFieldsSelector, gridVisibleColumnFieldsSelector } from '../columns/gridColumnsSelector';\nimport { buildWarning } from '../../../utils/warning';\nimport { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';\nimport { deepClone } from '../../../utils/utils';\nimport { GridRowEditStopReasons, GridRowEditStartReasons } from '../../../models/params/gridRowParams';\nimport { GRID_ACTIONS_COLUMN_TYPE } from '../../../colDef';\nconst missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, for example `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');\nexport const useGridRowEditing = (apiRef, props) => {\n  const [rowModesModel, setRowModesModel] = React.useState({});\n  const rowModesModelRef = React.useRef(rowModesModel);\n  const prevRowModesModel = React.useRef({});\n  const focusTimeout = React.useRef();\n  const nextFocusedCell = React.useRef(null);\n  const {\n    processRowUpdate,\n    onProcessRowUpdateError,\n    rowModesModel: rowModesModelProp,\n    onRowModesModelChange\n  } = props;\n  const runIfEditModeIsRow = callback => (...args) => {\n    if (props.editMode === GridEditModes.Row) {\n      callback(...args);\n    }\n  };\n  const throwIfNotEditable = React.useCallback((id, field) => {\n    const params = apiRef.current.getCellParams(id, field);\n    if (!apiRef.current.isCellEditable(params)) {\n      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not editable.`);\n    }\n  }, [apiRef]);\n  const throwIfNotInMode = React.useCallback((id, mode) => {\n    if (apiRef.current.getRowMode(id) !== mode) {\n      throw new Error(`MUI X: The row with id=${id} is not in ${mode} mode.`);\n    }\n  }, [apiRef]);\n  const hasFieldsWithErrors = React.useCallback(rowId => {\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    return Object.values(editingState[rowId]).some(fieldProps => fieldProps.error);\n  }, [apiRef]);\n  const handleCellDoubleClick = React.useCallback((params, event) => {\n    if (!params.isEditable) {\n      return;\n    }\n    if (apiRef.current.getRowMode(params.id) === GridRowModes.Edit) {\n      return;\n    }\n    const rowParams = apiRef.current.getRowParams(params.id);\n    const newParams = _extends({}, rowParams, {\n      field: params.field,\n      reason: GridRowEditStartReasons.cellDoubleClick\n    });\n    apiRef.current.publishEvent('rowEditStart', newParams, event);\n  }, [apiRef]);\n  const handleCellFocusIn = React.useCallback(params => {\n    nextFocusedCell.current = params;\n  }, []);\n  const handleCellFocusOut = React.useCallback((params, event) => {\n    if (!params.isEditable) {\n      return;\n    }\n    if (apiRef.current.getRowMode(params.id) === GridRowModes.View) {\n      return;\n    }\n    // The mechanism to detect if we can stop editing a row is different from\n    // the cell editing. Instead of triggering it when clicking outside a cell,\n    // we must check if another cell in the same row was not clicked. To achieve\n    // that, first we keep track of all cells that gained focus. When a cell loses\n    // focus we check if the next cell that received focus is from a different row.\n    nextFocusedCell.current = null;\n    focusTimeout.current = setTimeout(() => {\n      if (nextFocusedCell.current?.id !== params.id) {\n        // The row might have been deleted during the click\n        if (!apiRef.current.getRow(params.id)) {\n          return;\n        }\n\n        // The row may already changed its mode\n        if (apiRef.current.getRowMode(params.id) === GridRowModes.View) {\n          return;\n        }\n        if (hasFieldsWithErrors(params.id)) {\n          return;\n        }\n        const rowParams = apiRef.current.getRowParams(params.id);\n        const newParams = _extends({}, rowParams, {\n          field: params.field,\n          reason: GridRowEditStopReasons.rowFocusOut\n        });\n        apiRef.current.publishEvent('rowEditStop', newParams, event);\n      }\n    });\n  }, [apiRef, hasFieldsWithErrors]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(focusTimeout.current);\n    };\n  }, []);\n  const handleCellKeyDown = React.useCallback((params, event) => {\n    if (params.cellMode === GridRowModes.Edit) {\n      // Wait until IME is settled for Asian languages like Japanese and Chinese\n      // TODO: `event.which` is deprecated but this is a temporary workaround\n      if (event.which === 229) {\n        return;\n      }\n      let reason;\n      if (event.key === 'Escape') {\n        reason = GridRowEditStopReasons.escapeKeyDown;\n      } else if (event.key === 'Enter') {\n        reason = GridRowEditStopReasons.enterKeyDown;\n      } else if (event.key === 'Tab') {\n        const columnFields = gridVisibleColumnFieldsSelector(apiRef).filter(field => {\n          const column = apiRef.current.getColumn(field);\n          if (column.type === GRID_ACTIONS_COLUMN_TYPE) {\n            return true;\n          }\n          return apiRef.current.isCellEditable(apiRef.current.getCellParams(params.id, field));\n        });\n        if (event.shiftKey) {\n          if (params.field === columnFields[0]) {\n            // Exit if user pressed Shift+Tab on the first field\n            reason = GridRowEditStopReasons.shiftTabKeyDown;\n          }\n        } else if (params.field === columnFields[columnFields.length - 1]) {\n          // Exit if user pressed Tab on the last field\n          reason = GridRowEditStopReasons.tabKeyDown;\n        }\n\n        // Always prevent going to the next element in the tab sequence because the focus is\n        // handled manually to support edit components rendered inside Portals\n        event.preventDefault();\n        if (!reason) {\n          const index = columnFields.findIndex(field => field === params.field);\n          const nextFieldToFocus = columnFields[event.shiftKey ? index - 1 : index + 1];\n          apiRef.current.setCellFocus(params.id, nextFieldToFocus);\n        }\n      }\n      if (reason) {\n        if (reason !== GridRowEditStopReasons.escapeKeyDown && hasFieldsWithErrors(params.id)) {\n          return;\n        }\n        const newParams = _extends({}, apiRef.current.getRowParams(params.id), {\n          reason,\n          field: params.field\n        });\n        apiRef.current.publishEvent('rowEditStop', newParams, event);\n      }\n    } else if (params.isEditable) {\n      let reason;\n      const canStartEditing = apiRef.current.unstable_applyPipeProcessors('canStartEditing', true, {\n        event,\n        cellParams: params,\n        editMode: 'row'\n      });\n      if (!canStartEditing) {\n        return;\n      }\n      if (isPrintableKey(event)) {\n        reason = GridRowEditStartReasons.printableKeyDown;\n      } else if (isPasteShortcut(event)) {\n        reason = GridRowEditStartReasons.printableKeyDown;\n      } else if (event.key === 'Enter') {\n        reason = GridRowEditStartReasons.enterKeyDown;\n      } else if (event.key === 'Backspace' || event.key === 'Delete') {\n        reason = GridRowEditStartReasons.deleteKeyDown;\n      }\n      if (reason) {\n        const rowParams = apiRef.current.getRowParams(params.id);\n        const newParams = _extends({}, rowParams, {\n          field: params.field,\n          reason\n        });\n        apiRef.current.publishEvent('rowEditStart', newParams, event);\n      }\n    }\n  }, [apiRef, hasFieldsWithErrors]);\n  const handleRowEditStart = React.useCallback(params => {\n    const {\n      id,\n      field,\n      reason\n    } = params;\n    const startRowEditModeParams = {\n      id,\n      fieldToFocus: field\n    };\n    if (reason === GridRowEditStartReasons.printableKeyDown || reason === GridRowEditStartReasons.deleteKeyDown) {\n      startRowEditModeParams.deleteValue = !!field;\n    }\n    apiRef.current.startRowEditMode(startRowEditModeParams);\n  }, [apiRef]);\n  const handleRowEditStop = React.useCallback(params => {\n    const {\n      id,\n      reason,\n      field\n    } = params;\n    apiRef.current.runPendingEditCellValueMutation(id);\n    let cellToFocusAfter;\n    if (reason === GridRowEditStopReasons.enterKeyDown) {\n      cellToFocusAfter = 'below';\n    } else if (reason === GridRowEditStopReasons.tabKeyDown) {\n      cellToFocusAfter = 'right';\n    } else if (reason === GridRowEditStopReasons.shiftTabKeyDown) {\n      cellToFocusAfter = 'left';\n    }\n    const ignoreModifications = reason === 'escapeKeyDown';\n    apiRef.current.stopRowEditMode({\n      id,\n      ignoreModifications,\n      field,\n      cellToFocusAfter\n    });\n  }, [apiRef]);\n  useGridApiEventHandler(apiRef, 'cellDoubleClick', runIfEditModeIsRow(handleCellDoubleClick));\n  useGridApiEventHandler(apiRef, 'cellFocusIn', runIfEditModeIsRow(handleCellFocusIn));\n  useGridApiEventHandler(apiRef, 'cellFocusOut', runIfEditModeIsRow(handleCellFocusOut));\n  useGridApiEventHandler(apiRef, 'cellKeyDown', runIfEditModeIsRow(handleCellKeyDown));\n  useGridApiEventHandler(apiRef, 'rowEditStart', runIfEditModeIsRow(handleRowEditStart));\n  useGridApiEventHandler(apiRef, 'rowEditStop', runIfEditModeIsRow(handleRowEditStop));\n  useGridApiOptionHandler(apiRef, 'rowEditStart', props.onRowEditStart);\n  useGridApiOptionHandler(apiRef, 'rowEditStop', props.onRowEditStop);\n  const getRowMode = React.useCallback(id => {\n    if (props.editMode === GridEditModes.Cell) {\n      return GridRowModes.View;\n    }\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const isEditing = editingState[id] && Object.keys(editingState[id]).length > 0;\n    return isEditing ? GridRowModes.Edit : GridRowModes.View;\n  }, [apiRef, props.editMode]);\n  const updateRowModesModel = useEventCallback(newModel => {\n    const isNewModelDifferentFromProp = newModel !== props.rowModesModel;\n    if (onRowModesModelChange && isNewModelDifferentFromProp) {\n      onRowModesModelChange(newModel, {\n        api: apiRef.current\n      });\n    }\n    if (props.rowModesModel && isNewModelDifferentFromProp) {\n      return; // The prop always win\n    }\n    setRowModesModel(newModel);\n    rowModesModelRef.current = newModel;\n    apiRef.current.publishEvent('rowModesModelChange', newModel);\n  });\n  const updateRowInRowModesModel = React.useCallback((id, newProps) => {\n    const newModel = _extends({}, rowModesModelRef.current);\n    if (newProps !== null) {\n      newModel[id] = _extends({}, newProps);\n    } else {\n      delete newModel[id];\n    }\n    updateRowModesModel(newModel);\n  }, [updateRowModesModel]);\n  const updateOrDeleteRowState = React.useCallback((id, newProps) => {\n    apiRef.current.setState(state => {\n      const newEditingState = _extends({}, state.editRows);\n      if (newProps !== null) {\n        newEditingState[id] = newProps;\n      } else {\n        delete newEditingState[id];\n      }\n      return _extends({}, state, {\n        editRows: newEditingState\n      });\n    });\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const updateOrDeleteFieldState = React.useCallback((id, field, newProps) => {\n    apiRef.current.setState(state => {\n      const newEditingState = _extends({}, state.editRows);\n      if (newProps !== null) {\n        newEditingState[id] = _extends({}, newEditingState[id], {\n          [field]: _extends({}, newProps)\n        });\n      } else {\n        delete newEditingState[id][field];\n        if (Object.keys(newEditingState[id]).length === 0) {\n          delete newEditingState[id];\n        }\n      }\n      return _extends({}, state, {\n        editRows: newEditingState\n      });\n    });\n    apiRef.current.forceUpdate();\n  }, [apiRef]);\n  const startRowEditMode = React.useCallback(params => {\n    const {\n        id\n      } = params,\n      other = _objectWithoutPropertiesLoose(params, _excluded);\n    throwIfNotInMode(id, GridRowModes.View);\n    updateRowInRowModesModel(id, _extends({\n      mode: GridRowModes.Edit\n    }, other));\n  }, [throwIfNotInMode, updateRowInRowModesModel]);\n  const updateStateToStartRowEditMode = useEventCallback(params => {\n    const {\n      id,\n      fieldToFocus,\n      deleteValue,\n      initialValue\n    } = params;\n    const columnFields = gridColumnFieldsSelector(apiRef);\n    const newProps = columnFields.reduce((acc, field) => {\n      const cellParams = apiRef.current.getCellParams(id, field);\n      if (!cellParams.isEditable) {\n        return acc;\n      }\n      let newValue = apiRef.current.getCellValue(id, field);\n      if (fieldToFocus === field && (deleteValue || initialValue)) {\n        newValue = deleteValue ? '' : initialValue;\n      }\n      acc[field] = {\n        value: newValue,\n        error: false,\n        isProcessingProps: false\n      };\n      return acc;\n    }, {});\n    updateOrDeleteRowState(id, newProps);\n    if (fieldToFocus) {\n      apiRef.current.setCellFocus(id, fieldToFocus);\n    }\n  });\n  const stopRowEditMode = React.useCallback(params => {\n    const {\n        id\n      } = params,\n      other = _objectWithoutPropertiesLoose(params, _excluded2);\n    throwIfNotInMode(id, GridRowModes.Edit);\n    updateRowInRowModesModel(id, _extends({\n      mode: GridRowModes.View\n    }, other));\n  }, [throwIfNotInMode, updateRowInRowModesModel]);\n  const updateStateToStopRowEditMode = useEventCallback(params => {\n    const {\n      id,\n      ignoreModifications,\n      field: focusedField,\n      cellToFocusAfter = 'none'\n    } = params;\n    apiRef.current.runPendingEditCellValueMutation(id);\n    const finishRowEditMode = () => {\n      if (cellToFocusAfter !== 'none' && focusedField) {\n        apiRef.current.moveFocusToRelativeCell(id, focusedField, cellToFocusAfter);\n      }\n      updateOrDeleteRowState(id, null);\n      updateRowInRowModesModel(id, null);\n    };\n    if (ignoreModifications) {\n      finishRowEditMode();\n      return;\n    }\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const row = apiRef.current.getRow(id);\n    const isSomeFieldProcessingProps = Object.values(editingState[id]).some(fieldProps => fieldProps.isProcessingProps);\n    if (isSomeFieldProcessingProps) {\n      prevRowModesModel.current[id].mode = GridRowModes.Edit;\n      return;\n    }\n    if (hasFieldsWithErrors(id)) {\n      prevRowModesModel.current[id].mode = GridRowModes.Edit;\n      // Revert the mode in the rowModesModel prop back to \"edit\"\n      updateRowInRowModesModel(id, {\n        mode: GridRowModes.Edit\n      });\n      return;\n    }\n    const rowUpdate = apiRef.current.getRowWithUpdatedValuesFromRowEditing(id);\n    if (processRowUpdate) {\n      const handleError = errorThrown => {\n        prevRowModesModel.current[id].mode = GridRowModes.Edit;\n        // Revert the mode in the rowModesModel prop back to \"edit\"\n        updateRowInRowModesModel(id, {\n          mode: GridRowModes.Edit\n        });\n        if (onProcessRowUpdateError) {\n          onProcessRowUpdateError(errorThrown);\n        } else if (process.env.NODE_ENV !== 'production') {\n          missingOnProcessRowUpdateErrorWarning();\n        }\n      };\n      try {\n        Promise.resolve(processRowUpdate(rowUpdate, row)).then(finalRowUpdate => {\n          apiRef.current.updateRows([finalRowUpdate]);\n          finishRowEditMode();\n        }).catch(handleError);\n      } catch (errorThrown) {\n        handleError(errorThrown);\n      }\n    } else {\n      apiRef.current.updateRows([rowUpdate]);\n      finishRowEditMode();\n    }\n  });\n  const setRowEditingEditCellValue = React.useCallback(params => {\n    const {\n      id,\n      field,\n      value,\n      debounceMs,\n      unstable_skipValueParser: skipValueParser\n    } = params;\n    throwIfNotEditable(id, field);\n    const column = apiRef.current.getColumn(field);\n    const row = apiRef.current.getRow(id);\n    let parsedValue = value;\n    if (column.valueParser && !skipValueParser) {\n      parsedValue = column.valueParser(value, row, column, apiRef);\n    }\n    let editingState = gridEditRowsStateSelector(apiRef.current.state);\n    let newProps = _extends({}, editingState[id][field], {\n      value: parsedValue,\n      changeReason: debounceMs ? 'debouncedSetEditCellValue' : 'setEditCellValue'\n    });\n    if (!column.preProcessEditCellProps) {\n      updateOrDeleteFieldState(id, field, newProps);\n    }\n    return new Promise(resolve => {\n      const promises = [];\n      if (column.preProcessEditCellProps) {\n        const hasChanged = newProps.value !== editingState[id][field].value;\n        newProps = _extends({}, newProps, {\n          isProcessingProps: true\n        });\n        updateOrDeleteFieldState(id, field, newProps);\n        const _editingState$id = editingState[id],\n          otherFieldsProps = _objectWithoutPropertiesLoose(_editingState$id, [field].map(_toPropertyKey));\n        const promise = Promise.resolve(column.preProcessEditCellProps({\n          id,\n          row,\n          props: newProps,\n          hasChanged,\n          otherFieldsProps\n        })).then(processedProps => {\n          // Check again if the row is in edit mode because the user may have\n          // discarded the changes while the props were being processed.\n          if (apiRef.current.getRowMode(id) === GridRowModes.View) {\n            resolve(false);\n            return;\n          }\n          editingState = gridEditRowsStateSelector(apiRef.current.state);\n          processedProps = _extends({}, processedProps, {\n            isProcessingProps: false\n          });\n          // We don't reuse the value from the props pre-processing because when the\n          // promise resolves it may be already outdated. The only exception to this rule\n          // is when there's no pre-processing.\n          processedProps.value = column.preProcessEditCellProps ? editingState[id][field].value : parsedValue;\n          updateOrDeleteFieldState(id, field, processedProps);\n        });\n        promises.push(promise);\n      }\n      Object.entries(editingState[id]).forEach(([thisField, fieldProps]) => {\n        if (thisField === field) {\n          return;\n        }\n        const fieldColumn = apiRef.current.getColumn(thisField);\n        if (!fieldColumn.preProcessEditCellProps) {\n          return;\n        }\n        fieldProps = _extends({}, fieldProps, {\n          isProcessingProps: true\n        });\n        updateOrDeleteFieldState(id, thisField, fieldProps);\n        editingState = gridEditRowsStateSelector(apiRef.current.state);\n        const _editingState$id2 = editingState[id],\n          otherFieldsProps = _objectWithoutPropertiesLoose(_editingState$id2, [thisField].map(_toPropertyKey));\n        const promise = Promise.resolve(fieldColumn.preProcessEditCellProps({\n          id,\n          row,\n          props: fieldProps,\n          hasChanged: false,\n          otherFieldsProps\n        })).then(processedProps => {\n          // Check again if the row is in edit mode because the user may have\n          // discarded the changes while the props were being processed.\n          if (apiRef.current.getRowMode(id) === GridRowModes.View) {\n            resolve(false);\n            return;\n          }\n          processedProps = _extends({}, processedProps, {\n            isProcessingProps: false\n          });\n          updateOrDeleteFieldState(id, thisField, processedProps);\n        });\n        promises.push(promise);\n      });\n      Promise.all(promises).then(() => {\n        if (apiRef.current.getRowMode(id) === GridRowModes.Edit) {\n          editingState = gridEditRowsStateSelector(apiRef.current.state);\n          resolve(!editingState[id][field].error);\n        } else {\n          resolve(false);\n        }\n      });\n    });\n  }, [apiRef, throwIfNotEditable, updateOrDeleteFieldState]);\n  const getRowWithUpdatedValuesFromRowEditing = React.useCallback(id => {\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    const row = apiRef.current.getRow(id);\n    if (!editingState[id]) {\n      return apiRef.current.getRow(id);\n    }\n    let rowUpdate = _extends({}, row);\n    Object.entries(editingState[id]).forEach(([field, fieldProps]) => {\n      const column = apiRef.current.getColumn(field);\n      if (column.valueSetter) {\n        rowUpdate = column.valueSetter(fieldProps.value, rowUpdate, column, apiRef);\n      } else {\n        rowUpdate[field] = fieldProps.value;\n      }\n    });\n    return rowUpdate;\n  }, [apiRef]);\n  const editingApi = {\n    getRowMode,\n    startRowEditMode,\n    stopRowEditMode\n  };\n  const editingPrivateApi = {\n    setRowEditingEditCellValue,\n    getRowWithUpdatedValuesFromRowEditing\n  };\n  useGridApiMethod(apiRef, editingApi, 'public');\n  useGridApiMethod(apiRef, editingPrivateApi, 'private');\n  React.useEffect(() => {\n    if (rowModesModelProp) {\n      updateRowModesModel(rowModesModelProp);\n    }\n  }, [rowModesModelProp, updateRowModesModel]);\n\n  // Run this effect synchronously so that the keyboard event can impact the yet-to-be-rendered input.\n  useEnhancedEffect(() => {\n    const idToIdLookup = gridRowsDataRowIdToIdLookupSelector(apiRef);\n\n    // Update the ref here because updateStateToStopRowEditMode may change it later\n    const copyOfPrevRowModesModel = prevRowModesModel.current;\n    prevRowModesModel.current = deepClone(rowModesModel); // Do a deep-clone because the attributes might be changed later\n\n    const ids = new Set([...Object.keys(rowModesModel), ...Object.keys(copyOfPrevRowModesModel)]);\n    Array.from(ids).forEach(id => {\n      const params = rowModesModel[id] ?? {\n        mode: GridRowModes.View\n      };\n      const prevMode = copyOfPrevRowModesModel[id]?.mode || GridRowModes.View;\n      const originalId = idToIdLookup[id] ?? id;\n      if (params.mode === GridRowModes.Edit && prevMode === GridRowModes.View) {\n        updateStateToStartRowEditMode(_extends({\n          id: originalId\n        }, params));\n      } else if (params.mode === GridRowModes.View && prevMode === GridRowModes.Edit) {\n        updateStateToStopRowEditMode(_extends({\n          id: originalId\n        }, params));\n      }\n    });\n  }, [apiRef, rowModesModel, updateStateToStartRowEditMode, updateStateToStopRowEditMode]);\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { useGridApiMethod } from '../../utils/useGridApiMethod';\nimport { useGridCellEditing } from './useGridCellEditing';\nimport { GridCellModes, GridEditModes } from '../../../models/gridEditRowModel';\nimport { useGridRowEditing } from './useGridRowEditing';\nimport { gridEditRowsStateSelector } from './gridEditingSelectors';\nimport { isAutoGeneratedRow } from '../rows/gridRowsUtils';\nexport const editingStateInitializer = state => _extends({}, state, {\n  editRows: {}\n});\nexport const useGridEditing = (apiRef, props) => {\n  useGridCellEditing(apiRef, props);\n  useGridRowEditing(apiRef, props);\n  const debounceMap = React.useRef({});\n  const {\n    isCellEditable: isCellEditableProp\n  } = props;\n  const isCellEditable = React.useCallback(params => {\n    if (isAutoGeneratedRow(params.rowNode)) {\n      return false;\n    }\n    if (!params.colDef.editable) {\n      return false;\n    }\n    if (!params.colDef.renderEditCell) {\n      return false;\n    }\n    if (isCellEditableProp) {\n      return isCellEditableProp(params);\n    }\n    return true;\n  }, [isCellEditableProp]);\n  const maybeDebounce = (id, field, debounceMs, callback) => {\n    if (!debounceMs) {\n      callback();\n      return;\n    }\n    if (!debounceMap.current[id]) {\n      debounceMap.current[id] = {};\n    }\n    if (debounceMap.current[id][field]) {\n      const [timeout] = debounceMap.current[id][field];\n      clearTimeout(timeout);\n    }\n\n    // To run the callback immediately without waiting the timeout\n    const runImmediately = () => {\n      const [timeout] = debounceMap.current[id][field];\n      clearTimeout(timeout);\n      callback();\n      delete debounceMap.current[id][field];\n    };\n    const timeout = setTimeout(() => {\n      callback();\n      delete debounceMap.current[id][field];\n    }, debounceMs);\n    debounceMap.current[id][field] = [timeout, runImmediately];\n  };\n  React.useEffect(() => {\n    const debounces = debounceMap.current;\n    return () => {\n      Object.entries(debounces).forEach(([id, fields]) => {\n        Object.keys(fields).forEach(field => {\n          const [timeout] = debounces[id][field];\n          clearTimeout(timeout);\n          delete debounces[id][field];\n        });\n      });\n    };\n  }, []);\n  const runPendingEditCellValueMutation = React.useCallback((id, field) => {\n    if (!debounceMap.current[id]) {\n      return;\n    }\n    if (!field) {\n      Object.keys(debounceMap.current[id]).forEach(debouncedField => {\n        const [, runCallback] = debounceMap.current[id][debouncedField];\n        runCallback();\n      });\n    } else if (debounceMap.current[id][field]) {\n      const [, runCallback] = debounceMap.current[id][field];\n      runCallback();\n    }\n  }, []);\n  const setEditCellValue = React.useCallback(params => {\n    const {\n      id,\n      field,\n      debounceMs\n    } = params;\n    return new Promise(resolve => {\n      maybeDebounce(id, field, debounceMs, async () => {\n        const setEditCellValueToCall = props.editMode === GridEditModes.Row ? apiRef.current.setRowEditingEditCellValue : apiRef.current.setCellEditingEditCellValue;\n\n        // Check if the cell is in edit mode\n        // By the time this callback runs the user may have cancelled the editing\n        if (apiRef.current.getCellMode(id, field) === GridCellModes.Edit) {\n          const result = await setEditCellValueToCall(params);\n          resolve(result);\n        }\n      });\n    });\n  }, [apiRef, props.editMode]);\n  const getRowWithUpdatedValues = React.useCallback((id, field) => {\n    return props.editMode === GridEditModes.Cell ? apiRef.current.getRowWithUpdatedValuesFromCellEditing(id, field) : apiRef.current.getRowWithUpdatedValuesFromRowEditing(id);\n  }, [apiRef, props.editMode]);\n  const getEditCellMeta = React.useCallback((id, field) => {\n    const editingState = gridEditRowsStateSelector(apiRef.current.state);\n    return editingState[id]?.[field] ?? null;\n  }, [apiRef]);\n  const editingSharedApi = {\n    isCellEditable,\n    setEditCellValue,\n    getRowWithUpdatedValues,\n    unstable_getEditCellMeta: getEditCellMeta\n  };\n  const editingSharedPrivateApi = {\n    runPendingEditCellValueMutation\n  };\n  useGridApiMethod(apiRef, editingSharedApi, 'public');\n  useGridApiMethod(apiRef, editingSharedPrivateApi, 'private');\n};"],"names":["DENSITY_FACTORS","compact","comfortable","standard","gridDensitySelector","state","density","gridDensityFactorSelector","densityStateInitializer","props","initialState","useGridDensity","apiRef","logger","current","registerControlState","stateId","propModel","propOnChange","onDensityChange","stateSelector","changeEvent","densityApi","setDensity","newDensity","debug","setState","stateExportPreProcessing","prevState","context","exportedDensity","exportOnlyDirtyModels","stateRestorePreProcessing","params","restoredDensity","stateToRestore","gridDimensionsSelector","dimensions","EMPTY_SIZE","width","height","EMPTY_DIMENSIONS","isReady","root","viewportOuterSize","viewportInnerSize","contentSize","minimumSize","hasScrollX","hasScrollY","scrollbarSize","headerHeight","headerFilterHeight","rowWidth","rowHeight","columnsTotalWidth","leftPinnedWidth","rightPinnedWidth","headersTotalHeight","topContainerHeight","bottomContainerHeight","dimensionsStateInitializer","useGridDimensions","errorShown","rootDimensionsRef","rowsMeta","pinnedColumns","densityFactor","Math","floor","columnHeaderHeight","value","decimals","round","left","reduce","w","col","computedWidth","right","savedSize","setSavedSize","debouncedSetSavedSize","resizeThrottleMs","previousSize","setDimensions","resize","element","mainElementRef","computedStyle","getComputedStyle","parseFloat","hasHeightChanged","hasWidthChanged","size","publishEvent","getViewportPageSize","currentPage","pagination","paginationMode","getRowHeight","renderContext","viewportPageSize","lastRowIndex","firstRowIndex","min","rows","length","maximumPageSizeWithoutScrollBar","updateDimensions","rootElement","rootElementRef","pinnedRowsHeight","undefined","doc","scrollDiv","createElement","style","position","overflow","className","appendChild","offsetWidth","clientWidth","removeChild","measureScrollbarSize","top","bottom","currentPageTotalHeight","autoHeight","max","content","container","hasScrollXIfNoYScrollBar","hasScrollYIfNoXScrollBar","newDimensions","prevDimensions","updateRenderContext","apiPublic","getRootDimensions","apiPrivate","set","k","v","setProperty","Number","isFirstSizing","handleResize","isJSDOM","test","window","navigator","userAgent","error","join","onResize","gridEditRowsStateSelector","editRows","_excluded","_excluded2","editingStateInitializer","useGridEditing","cellModesModel","setCellModesModel","cellModesModelRef","prevCellModesModel","processRowUpdate","onProcessRowUpdateError","cellModesModelProp","onCellModesModelChange","runIfEditModeIsCell","callback","args","editMode","Cell","throwIfNotEditable","id","field","getCellParams","isCellEditable","Error","throwIfNotInMode","mode","getCellMode","handleCellDoubleClick","event","isEditable","cellMode","Edit","newParams","reason","cellDoubleClick","handleCellFocusOut","View","cellFocusOut","handleCellKeyDown","which","key","escapeKeyDown","enterKeyDown","shiftKey","shiftTabKeyDown","tabKeyDown","preventDefault","unstable_applyPipeProcessors","cellParams","printableKeyDown","pasteKeyDown","deleteKeyDown","handleCellEditStart","startCellEditModeParams","deleteValue","startCellEditMode","handleCellEditStop","cellToFocusAfter","runPendingEditCellValueMutation","ignoreModifications","stopCellEditMode","useGridApiEventHandler","onCellEditStart","onCellEditStop","async","editRowsState","hasFieldErrors","editingState","updateCellModesModel","useEventCallback","newModel","isNewModelDifferentFromProp","api","updateFieldInCellModesModel","newProps","_newModel$id","otherFields","map","Object","keys","updateOrDeleteFieldState","newEditingState","forceUpdate","other","updateStateToStartCellEditMode","initialValue","newValue","getCellValue","getColumn","type","isProcessingProps","setCellFocus","updateStateToStopCellEditMode","finishCellEditMode","moveFocusToRelativeCell","rowUpdate","getRowWithUpdatedValuesFromCellEditing","handleError","errorThrown","row","getRow","Promise","resolve","then","finalRowUpdate","updateRows","catch","editingApi","editingPrivateApi","setCellEditingEditCellValue","debounceMs","unstable_skipValueParser","skipValueParser","column","parsedValue","valueParser","changeReason","preProcessEditCellProps","hasChanged","valueSetter","useGridApiMethod","useEnhancedEffect","idToIdLookup","copyOfPrevCellModes","entries","forEach","fields","prevMode","originalId","useGridCellEditing","rowModesModel","setRowModesModel","rowModesModelRef","prevRowModesModel","focusTimeout","nextFocusedCell","rowModesModelProp","onRowModesModelChange","runIfEditModeIsRow","Row","getRowMode","hasFieldsWithErrors","rowId","values","some","fieldProps","rowParams","getRowParams","handleCellFocusIn","setTimeout","rowFocusOut","clearTimeout","columnFields","filter","index","findIndex","nextFieldToFocus","handleRowEditStart","startRowEditModeParams","fieldToFocus","startRowEditMode","handleRowEditStop","stopRowEditMode","onRowEditStart","onRowEditStop","updateRowModesModel","updateRowInRowModesModel","updateOrDeleteRowState","updateStateToStartRowEditMode","acc","updateStateToStopRowEditMode","focusedField","finishRowEditMode","getRowWithUpdatedValuesFromRowEditing","setRowEditingEditCellValue","promises","_editingState$id","otherFieldsProps","promise","processedProps","push","thisField","fieldColumn","_editingState$id2","all","copyOfPrevRowModesModel","ids","Set","Array","from","useGridRowEditing","debounceMap","isCellEditableProp","rowNode","colDef","editable","renderEditCell","debounces","timeout","runCallback","debouncedField","editingSharedApi","setEditCellValue","maybeDebounce","setEditCellValueToCall","result","getRowWithUpdatedValues","unstable_getEditCellMeta","editingSharedPrivateApi"],"sourceRoot":""}