@mui/x-data-grid 9.0.0-alpha.0 → 9.0.0-alpha.2

package/components/quickFilter/QuickFilter.mjs

@@ -0,0 +1,191 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "parser", "formatter", "debounceMs", "defaultExpanded", "expanded", "onExpandedChange"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import debounce from '@mui/utils/debounce';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import useId from '@mui/utils/useId';
+import { isDeepEqual } from '@mui/x-internals/isDeepEqual';
+import { useComponentRenderer } from '@mui/x-internals/useComponentRenderer';
+import { QuickFilterContext } from "./QuickFilterContext.mjs";
+import { useGridApiContext } from "../../hooks/utils/useGridApiContext.mjs";
+import { useGridSelector } from "../../hooks/utils/useGridSelector.mjs";
+import { gridQuickFilterValuesSelector } from "../../hooks/features/filter/index.mjs";
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const DEFAULT_PARSER = searchText => searchText.split(' ').filter(word => word !== '');
+const DEFAULT_FORMATTER = values => values.join(' ');
+
+/**
+ * The top level Quick Filter component that provides context to child components.
+ * It renders a `<div />` element.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilter API](https://mui.com/x/api/data-grid/quick-filter/)
+ */
+function QuickFilter(props) {
+  const rootProps = useGridRootProps();
+  const {
+      render,
+      className,
+      parser = DEFAULT_PARSER,
+      formatter = DEFAULT_FORMATTER,
+      debounceMs = rootProps.filterDebounceMs,
+      defaultExpanded,
+      expanded,
+      onExpandedChange
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const apiRef = useGridApiContext();
+  const controlRef = React.useRef(null);
+  const triggerRef = React.useRef(null);
+  const quickFilterValues = useGridSelector(apiRef, gridQuickFilterValuesSelector);
+  const [value, setValue] = React.useState(formatter(quickFilterValues ?? []));
+  const [internalExpanded, setInternalExpanded] = React.useState(defaultExpanded ?? value.length > 0);
+  const expandedValue = expanded ?? internalExpanded;
+  const state = React.useMemo(() => ({
+    value,
+    expanded: expandedValue
+  }), [value, expandedValue]);
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const ref = React.useRef(null);
+  const controlId = useId();
+  const handleExpandedChange = React.useCallback(newExpanded => {
+    if (onExpandedChange) {
+      onExpandedChange(newExpanded);
+    }
+    if (expanded === undefined) {
+      setInternalExpanded(newExpanded);
+    }
+  }, [onExpandedChange, expanded]);
+  const prevQuickFilterValuesRef = React.useRef(quickFilterValues);
+  React.useEffect(() => {
+    if (!isDeepEqual(prevQuickFilterValuesRef.current, quickFilterValues)) {
+      // The model of quick filter value has been updated
+      prevQuickFilterValuesRef.current = quickFilterValues;
+
+      // Update the input value if needed to match the new model
+      setValue(prevSearchValue => isDeepEqual(parser(prevSearchValue), quickFilterValues) ? prevSearchValue : formatter(quickFilterValues ?? []));
+    }
+  }, [quickFilterValues, formatter, parser]);
+  const isFirstRender = React.useRef(true);
+  const previousExpandedValue = React.useRef(expandedValue);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+
+    // Ensure the expanded state has actually changed before focusing
+    if (previousExpandedValue.current !== expandedValue) {
+      if (expandedValue) {
+        // Ensures the focus does not interupt CSS transitions and animations on the control
+        requestAnimationFrame(() => {
+          controlRef.current?.focus({
+            preventScroll: true
+          });
+        });
+      } else {
+        triggerRef.current?.focus({
+          preventScroll: true
+        });
+      }
+      previousExpandedValue.current = expandedValue;
+    }
+  }, [expandedValue]);
+  const setQuickFilterValueDebounced = React.useMemo(() => debounce(newValue => {
+    const newQuickFilterValues = parser(newValue);
+    prevQuickFilterValuesRef.current = newQuickFilterValues;
+    apiRef.current.setQuickFilterValues(newQuickFilterValues);
+  }, debounceMs), [apiRef, debounceMs, parser]);
+  React.useEffect(() => setQuickFilterValueDebounced.clear, [setQuickFilterValueDebounced]);
+  const handleValueChange = React.useCallback(event => {
+    const newValue = event.target.value;
+    setValue(newValue);
+    setQuickFilterValueDebounced(newValue);
+  }, [setQuickFilterValueDebounced]);
+  const handleClearValue = React.useCallback(() => {
+    setValue('');
+    apiRef.current.setQuickFilterValues([]);
+    controlRef.current?.focus();
+  }, [apiRef, controlRef]);
+  const contextValue = React.useMemo(() => ({
+    controlRef,
+    triggerRef,
+    state,
+    controlId,
+    clearValue: handleClearValue,
+    onValueChange: handleValueChange,
+    onExpandedChange: handleExpandedChange
+  }), [controlId, state, handleValueChange, handleClearValue, handleExpandedChange]);
+  useEnhancedEffect(() => {
+    if (ref.current && triggerRef.current) {
+      ref.current.style.setProperty('--trigger-width', `${triggerRef.current?.offsetWidth}px`);
+    }
+  }, []);
+  const element = useComponentRenderer('div', render, _extends({
+    className: resolvedClassName
+  }, other, {
+    ref
+  }), state);
+  return /*#__PURE__*/_jsx(QuickFilterContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+}
+process.env.NODE_ENV !== "production" ? QuickFilter.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  /**
+   * The debounce time in milliseconds.
+   * @default 150
+   */
+  debounceMs: PropTypes.number,
+  /**
+   * The default expanded state of the quick filter control.
+   * @default false
+   */
+  defaultExpanded: PropTypes.bool,
+  /**
+   * The expanded state of the quick filter control.
+   */
+  expanded: PropTypes.bool,
+  /**
+   * Function responsible for formatting values of quick filter in a string when the model is modified
+   * @param {any[]} values The new values passed to the quick filter model
+   * @returns {string} The string to display in the text field
+   * @default (values: string[]) => values.join(' ')
+   */
+  formatter: PropTypes.func,
+  /**
+   * Callback function that is called when the quick filter input is expanded or collapsed.
+   * @param {boolean} expanded The new expanded state of the quick filter control
+   */
+  onExpandedChange: PropTypes.func,
+  /**
+   * Function responsible for parsing text input in an array of independent values for quick filtering.
+   * @param {string} input The value entered by the user
+   * @returns {any[]} The array of value on which quick filter is applied
+   * @default (searchText: string) => searchText.split(' ').filter((word) => word !== '')
+   */
+  parser: PropTypes.func,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func])
+} : void 0;
+export { QuickFilter };

package/components/quickFilter/QuickFilterClear.d.mts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { type RenderProp } from '@mui/x-internals/useComponentRenderer';
+import type { GridSlotProps } from "../../models/index.mjs";
+import { type QuickFilterState } from "./QuickFilterContext.mjs";
+export type QuickFilterClearProps = Omit<GridSlotProps['baseIconButton'], 'className'> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<GridSlotProps['baseIconButton'], QuickFilterState>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className?: string | ((state: QuickFilterState) => string);
+};
+/**
+ * A button that resets the filter value.
+ * It renders the `baseIconButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterClear API](https://mui.com/x/api/data-grid/quick-filter-clear/)
+ */
+declare const QuickFilterClear: React.ForwardRefExoticComponent<QuickFilterClearProps> | React.ForwardRefExoticComponent<Omit<QuickFilterClearProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { QuickFilterClear };

package/components/quickFilter/QuickFilterClear.mjs

@@ -0,0 +1,77 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "onClick"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useComponentRenderer } from '@mui/x-internals/useComponentRenderer';
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.mjs";
+import { useQuickFilterContext } from "./QuickFilterContext.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * A button that resets the filter value.
+ * It renders the `baseIconButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterClear API](https://mui.com/x/api/data-grid/quick-filter-clear/)
+ */
+const QuickFilterClear = forwardRef(function QuickFilterClear(props, ref) {
+  const {
+      render,
+      className,
+      onClick
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const {
+    state,
+    clearValue
+  } = useQuickFilterContext();
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleClick = event => {
+    clearValue();
+    onClick?.(event);
+  };
+  const element = useComponentRenderer(rootProps.slots.baseIconButton, render, _extends({}, rootProps.slotProps?.baseIconButton, {
+    className: resolvedClassName,
+    tabIndex: -1
+  }, other, {
+    onClick: handleClick,
+    ref
+  }), state);
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") QuickFilterClear.displayName = "QuickFilterClear";
+process.env.NODE_ENV !== "production" ? QuickFilterClear.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  color: PropTypes.oneOf(['default', 'inherit', 'primary']),
+  disabled: PropTypes.bool,
+  edge: PropTypes.oneOf(['end', 'start', false]),
+  id: PropTypes.string,
+  label: PropTypes.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  role: PropTypes.string,
+  size: PropTypes.oneOf(['large', 'medium', 'small']),
+  style: PropTypes.object,
+  tabIndex: PropTypes.number,
+  title: PropTypes.string,
+  touchRippleRef: PropTypes.any
+} : void 0;
+export { QuickFilterClear };

package/components/quickFilter/QuickFilterContext.js

@@ -2,18 +2,20 @@
 'use client';
 
 var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.QuickFilterContext = void 0;
 exports.useQuickFilterContext = useQuickFilterContext;
+var _formatErrorMessage2 = _interopRequireDefault(require("@mui/x-internals/formatErrorMessage"));
 var React = _interopRequireWildcard(require("react"));
 const QuickFilterContext = exports.QuickFilterContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") QuickFilterContext.displayName = "QuickFilterContext";
 function useQuickFilterContext() {
   const context = React.useContext(QuickFilterContext);
   if (context === undefined) {
-    throw new Error('MUI X: Missing context. Quick Filter subcomponents must be placed within a <QuickFilter /> component.');
+    throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X: Missing context. Quick Filter subcomponents must be placed within a <QuickFilter /> component.' : (0, _formatErrorMessage2.default)(62));
   }
   return context;
 }

package/components/quickFilter/QuickFilterContext.mjs

@@ -0,0 +1,13 @@
+'use client';
+
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
+import * as React from 'react';
+export const QuickFilterContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== "production") QuickFilterContext.displayName = "QuickFilterContext";
+export function useQuickFilterContext() {
+  const context = React.useContext(QuickFilterContext);
+  if (context === undefined) {
+    throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X: Missing context. Quick Filter subcomponents must be placed within a <QuickFilter /> component.' : _formatErrorMessage(62));
+  }
+  return context;
+}

package/components/quickFilter/QuickFilterControl.d.mts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { type RenderProp } from '@mui/x-internals/useComponentRenderer';
+import type { GridSlotProps } from "../../models/index.mjs";
+import { type QuickFilterState } from "./QuickFilterContext.mjs";
+export type QuickFilterControlProps = Omit<GridSlotProps['baseTextField'], 'className'> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<GridSlotProps['baseTextField'], QuickFilterState>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className?: string | ((state: QuickFilterState) => string);
+};
+/**
+ * A component that takes user input and filters row data.
+ * It renders the `baseTextField` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterControl API](https://mui.com/x/api/data-grid/quick-filter-control/)
+ */
+declare const QuickFilterControl: React.ForwardRefExoticComponent<QuickFilterControlProps> | React.ForwardRefExoticComponent<Omit<QuickFilterControlProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { QuickFilterControl };

package/components/quickFilter/QuickFilterControl.mjs

@@ -0,0 +1,124 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "slotProps", "onKeyDown", "onChange"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import useForkRef from '@mui/utils/useForkRef';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useComponentRenderer } from '@mui/x-internals/useComponentRenderer';
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.mjs";
+import { useQuickFilterContext } from "./QuickFilterContext.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * A component that takes user input and filters row data.
+ * It renders the `baseTextField` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterControl API](https://mui.com/x/api/data-grid/quick-filter-control/)
+ */
+const QuickFilterControl = forwardRef(function QuickFilterControl(props, ref) {
+  const {
+      render,
+      className,
+      slotProps,
+      onKeyDown,
+      onChange
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const {
+    state,
+    controlId,
+    controlRef,
+    onValueChange,
+    onExpandedChange,
+    clearValue
+  } = useQuickFilterContext();
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleRef = useForkRef(controlRef, ref);
+  const handleKeyDown = event => {
+    if (event.key === 'Escape') {
+      if (state.value === '') {
+        onExpandedChange(false);
+      } else {
+        clearValue();
+      }
+    }
+    onKeyDown?.(event);
+  };
+  const handleBlur = event => {
+    if (state.value === '') {
+      onExpandedChange(false);
+    }
+    slotProps?.htmlInput?.onBlur?.(event);
+  };
+  const handleChange = event => {
+    if (!state.expanded) {
+      onExpandedChange(true);
+    }
+    onValueChange(event);
+    onChange?.(event);
+  };
+  const element = useComponentRenderer(rootProps.slots.baseTextField, render, _extends({}, rootProps.slotProps?.baseTextField, {
+    slotProps: _extends({
+      htmlInput: _extends({
+        role: 'searchbox',
+        id: controlId,
+        tabIndex: state.expanded ? undefined : -1
+      }, slotProps?.htmlInput, {
+        onBlur: handleBlur
+      })
+    }, slotProps),
+    value: state.value,
+    className: resolvedClassName
+  }, other, {
+    onChange: handleChange,
+    onKeyDown: handleKeyDown,
+    ref: handleRef
+  }), state);
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") QuickFilterControl.displayName = "QuickFilterControl";
+process.env.NODE_ENV !== "production" ? QuickFilterControl.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  autoComplete: PropTypes.string,
+  autoFocus: PropTypes.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  color: PropTypes.oneOf(['error', 'primary']),
+  disabled: PropTypes.bool,
+  error: PropTypes.bool,
+  fullWidth: PropTypes.bool,
+  helperText: PropTypes.string,
+  id: PropTypes.string,
+  inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.object
+  })]),
+  label: PropTypes.node,
+  multiline: PropTypes.bool,
+  placeholder: PropTypes.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  role: PropTypes.string,
+  size: PropTypes.oneOf(['medium', 'small']),
+  slotProps: PropTypes.object,
+  style: PropTypes.object,
+  tabIndex: PropTypes.number,
+  type: PropTypes.string,
+  value: PropTypes.string
+} : void 0;
+export { QuickFilterControl };

package/components/quickFilter/QuickFilterTrigger.d.mts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { type RenderProp } from '@mui/x-internals/useComponentRenderer';
+import type { GridSlotProps } from "../../models/index.mjs";
+import { type QuickFilterState } from "./QuickFilterContext.mjs";
+export type QuickFilterTriggerProps = Omit<GridSlotProps['baseButton'], 'className'> & {
+  /**
+   * A function to customize rendering of the component.
+   */
+  render?: RenderProp<GridSlotProps['baseButton'], QuickFilterState>;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className?: string | ((state: QuickFilterState) => string);
+};
+/**
+ * A button that expands/collapses the quick filter.
+ * It renders the `baseButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterTrigger API](https://mui.com/x/api/data-grid/quick-filter-trigger/)
+ */
+declare const QuickFilterTrigger: React.ForwardRefExoticComponent<QuickFilterTriggerProps> | React.ForwardRefExoticComponent<Omit<QuickFilterTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { QuickFilterTrigger };

package/components/quickFilter/QuickFilterTrigger.mjs

@@ -0,0 +1,80 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "className", "onClick"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useComponentRenderer } from '@mui/x-internals/useComponentRenderer';
+import useForkRef from '@mui/utils/useForkRef';
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.mjs";
+import { useQuickFilterContext } from "./QuickFilterContext.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * A button that expands/collapses the quick filter.
+ * It renders the `baseButton` slot.
+ *
+ * Demos:
+ *
+ * - [Quick Filter](https://mui.com/x/react-data-grid/components/quick-filter/)
+ *
+ * API:
+ *
+ * - [QuickFilterTrigger API](https://mui.com/x/api/data-grid/quick-filter-trigger/)
+ */
+const QuickFilterTrigger = forwardRef(function QuickFilterTrigger(props, ref) {
+  const {
+      render,
+      className,
+      onClick
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const {
+    state,
+    controlId,
+    onExpandedChange,
+    triggerRef
+  } = useQuickFilterContext();
+  const resolvedClassName = typeof className === 'function' ? className(state) : className;
+  const handleRef = useForkRef(triggerRef, ref);
+  const handleClick = event => {
+    onExpandedChange(!state.expanded);
+    onClick?.(event);
+  };
+  const element = useComponentRenderer(rootProps.slots.baseButton, render, _extends({}, rootProps.slotProps?.baseButton, {
+    className: resolvedClassName,
+    'aria-controls': controlId,
+    'aria-expanded': state.expanded
+  }, other, {
+    onClick: handleClick,
+    ref: handleRef
+  }), state);
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") QuickFilterTrigger.displayName = "QuickFilterTrigger";
+process.env.NODE_ENV !== "production" ? QuickFilterTrigger.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  disabled: PropTypes.bool,
+  id: PropTypes.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  role: PropTypes.string,
+  size: PropTypes.oneOf(['large', 'medium', 'small']),
+  startIcon: PropTypes.node,
+  style: PropTypes.object,
+  tabIndex: PropTypes.number,
+  title: PropTypes.string,
+  touchRippleRef: PropTypes.any
+} : void 0;
+export { QuickFilterTrigger };

package/components/quickFilter/index.d.mts

@@ -0,0 +1,4 @@
+export * from "./QuickFilter.mjs";
+export * from "./QuickFilterControl.mjs";
+export * from "./QuickFilterClear.mjs";
+export * from "./QuickFilterTrigger.mjs";

package/components/quickFilter/index.mjs

@@ -0,0 +1,4 @@
+export * from "./QuickFilter.mjs";
+export * from "./QuickFilterControl.mjs";
+export * from "./QuickFilterClear.mjs";
+export * from "./QuickFilterTrigger.mjs";

package/components/reexportable.d.mts

@@ -0,0 +1 @@
+export { GridColumnMenu, GRID_COLUMN_MENU_SLOTS, GRID_COLUMN_MENU_SLOT_PROPS } from "./menu/columnMenu/GridColumnMenu.mjs";

package/components/reexportable.mjs

@@ -0,0 +1 @@
+export { GridColumnMenu, GRID_COLUMN_MENU_SLOTS, GRID_COLUMN_MENU_SLOT_PROPS } from "./menu/columnMenu/GridColumnMenu.mjs";

package/components/toolbar/GridToolbar.d.mts

@@ -0,0 +1,24 @@
+import { type GridToolbarContainerProps } from "../containers/GridToolbarContainer.mjs";
+import { type GridToolbarExportProps } from "./GridToolbarExport.mjs";
+import { type GridToolbarQuickFilterProps } from "./GridToolbarQuickFilter.mjs";
+export interface GridToolbarProps extends GridToolbarContainerProps, GridToolbarExportProps {
+  /**
+   * Show the history controls (undo/redo buttons).
+   * @default true
+   */
+  showHistoryControls?: boolean;
+  /**
+   * Show the quick filter component.
+   * @default true
+   */
+  showQuickFilter?: boolean;
+  /**
+   * Props passed to the quick filter component.
+   */
+  quickFilterProps?: GridToolbarQuickFilterProps;
+}
+/**
+ * @deprecated Use the `showToolbar` prop to show the default toolbar instead. This component will be removed in a future major release.
+ */
+declare const GridToolbar: import("react").ForwardRefExoticComponent<GridToolbarProps> | import("react").ForwardRefExoticComponent<GridToolbarProps & import("react").RefAttributes<HTMLDivElement>>;
+export { GridToolbar };