@carbon/react 1.33.2 → 1.34.0

package/lib/components/DataTable/DataTable.d.ts

@@ -0,0 +1,541 @@
+/**
+ * Copyright IBM Corp. 2016, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import PropTypes from 'prop-types';
+import React from 'react';
+import type { DataTableSortState } from './state/sortStates';
+import Table from './Table';
+import TableActionList from './TableActionList';
+import TableBatchAction from './TableBatchAction';
+import TableBatchActions from './TableBatchActions';
+import TableBody from './TableBody';
+import TableCell from './TableCell';
+import TableContainer from './TableContainer';
+import TableExpandHeader from './TableExpandHeader';
+import TableExpandRow from './TableExpandRow';
+import TableExpandedRow from './TableExpandedRow';
+import TableHead from './TableHead';
+import TableHeader from './TableHeader';
+import TableRow from './TableRow';
+import TableSelectAll from './TableSelectAll';
+import TableSelectRow from './TableSelectRow';
+import TableToolbar from './TableToolbar';
+import TableToolbarAction from './TableToolbarAction';
+import TableToolbarContent from './TableToolbarContent';
+import TableToolbarSearch from './TableToolbarSearch';
+import TableToolbarMenu from './TableToolbarMenu';
+declare const dataTableDefaultProps: {
+    filterRows: ({ rowIds, headers, cellsById, inputValue, getCellId, }: {
+        rowIds: string[];
+        headers: any[];
+        cellsById: any;
+        inputValue: string;
+        getCellId: Function;
+    }) => string[];
+    locale: string;
+    overflowMenuOnHover: boolean;
+    size: string;
+    sortRow: (cellA: any, cellB: any, { sortDirection, sortStates, locale }: {
+        sortDirection: any;
+        sortStates: any;
+        locale: any;
+    }) => number;
+    translateWithId: (id: any) => string;
+};
+export type DataTableSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface DataTableCell {
+    id: string;
+    value: unknown;
+    isEditable: boolean;
+    isEditing: boolean;
+    isValid: boolean;
+    errors: null | Array<Error>;
+    info: {
+        header: string;
+    };
+}
+export interface DataTableRow {
+    id: string;
+    cells: Array<DataTableCell>;
+    disabled?: boolean;
+    isExpanded?: boolean;
+    isSelected?: boolean;
+}
+export interface DataTableHeader {
+    key: string;
+    header: React.ReactNode;
+}
+export interface DataTableRenderProps {
+    headers: Array<DataTableHeader>;
+    rows: Array<DataTableRow>;
+    selectedRows: Array<DataTableRow>;
+    getHeaderProps: (getHeaderPropsArgs: {
+        header: DataTableHeader;
+        isSortable?: boolean;
+        onClick?: (e: MouseEvent, sortState: {
+            sortHeaderKey: string;
+            sortDirection: DataTableSortState;
+        }) => void;
+        [key: string]: unknown;
+    }) => {
+        isSortable: boolean | undefined;
+        isSortHeader: boolean;
+        key: string;
+        onClick: (e: MouseEvent) => void;
+        sortDirection: DataTableSortState;
+        [key: string]: unknown;
+    };
+    getExpandHeaderProps: (getExpandHeaderPropsArgs?: {
+        onClick?: (e: MouseEvent, expandState: {
+            isExpanded?: boolean;
+        }) => void;
+        onExpand?: (e: MouseEvent) => void;
+        [key: string]: unknown;
+    }) => {
+        ariaLabel: string;
+        isExpanded: boolean;
+        onExpand: (e: MouseEvent) => void;
+        [key: string]: unknown;
+    };
+    getRowProps: (getRowPropsArgs: {
+        onClick?: (e: MouseEvent) => void;
+        row: DataTableRow;
+        [key: string]: unknown;
+    }) => {
+        ariaLabel: string;
+        disabled: boolean | undefined;
+        isExpanded?: boolean;
+        isSelected?: boolean;
+        key: string;
+        onExpand: (e: MouseEvent) => void;
+        [key: string]: unknown;
+    };
+    getSelectionProps: (getSelectionPropsArgs: {
+        onClick?: (e: MouseEvent) => void;
+        row: DataTableRow;
+        [key: string]: unknown;
+    }) => {
+        ariaLabel: string;
+        checked: boolean | undefined;
+        disabled?: boolean | undefined;
+        id: string;
+        indeterminate?: boolean;
+        name: string;
+        onSelect: (e: MouseEvent) => void;
+        radio?: boolean | null;
+        [key: string]: unknown;
+    };
+    getToolbarProps: (getToolbarPropsArgs?: {
+        [key: string]: unknown;
+    }) => {
+        size: 'sm' | undefined;
+        [key: string]: unknown;
+    };
+    getBatchActionProps: (getBatchActionPropsArgs?: {
+        [key: string]: unknown;
+    }) => {
+        onCancel: () => void;
+        shouldShowBatchActions: boolean;
+        totalSelected: number;
+        [key: string]: unknown;
+    };
+    getTableProps: () => {
+        experimentalAutoAlign?: boolean;
+        isSortable?: boolean;
+        overflowMenuOnHover: boolean;
+        size: DataTableSize;
+        stickyHeader?: boolean;
+        useStaticWidth?: boolean;
+        useZebraStyles?: boolean;
+    };
+    getTableContainerProps: () => {
+        stickyHeader?: boolean;
+        useStaticWidth?: boolean;
+    };
+    onInputChange: (e: Event, defaultValue?: string) => void;
+    sortBy: (headerKey: string) => void;
+    selectAll: () => void;
+    selectRow: (rowId: string) => void;
+    expandRow: (rowId: string) => void;
+    expandAll: () => void;
+    radio: boolean | undefined;
+}
+export interface DataTableProps {
+    children?: (renderProps: DataTableRenderProps) => React.ReactElement;
+    experimentalAutoAlign?: boolean;
+    filterRows?: (filterRowsArgs: {
+        cellsById: Record<string, DataTableCell>;
+        getCellId: (rowId: string, header: string) => string;
+        headers: Array<DataTableHeader>;
+        inputValue: string;
+        rowIds: Array<string>;
+    }) => Array<string>;
+    headers: Array<DataTableHeader>;
+    isSortable?: boolean;
+    locale?: string;
+    overflowMenuOnHover?: boolean;
+    radio?: boolean;
+    render?: (renderProps: DataTableRenderProps) => React.ReactElement;
+    rows: Array<Omit<DataTableRow, 'cells'>>;
+    size?: DataTableSize;
+    sortRow?: (cellA: DataTableCell, cellB: DataTableCell, sortRowOptions: {
+        sortDirection: DataTableSortState;
+        sortStates: Record<DataTableSortState, DataTableSortState>;
+        locale: string;
+    }) => number;
+    stickyHeader?: boolean;
+    translateWithId?: (id: string) => string;
+    useStaticWidth?: boolean;
+    useZebraStyles?: boolean;
+}
+interface DataTableState {
+    cellsById: Record<string, DataTableCell>;
+    filterInputValue: string | null;
+    initialRowOrder: Array<string>;
+    isExpandedAll: boolean;
+    rowIds: Array<string>;
+    rowsById: Record<string, DataTableRow>;
+    shouldShowBatchActions: boolean;
+    sortDirection: DataTableSortState;
+    sortHeaderKey: string | null;
+}
+/**
+ * Data Tables are used to represent a collection of resources, displaying a
+ * subset of their fields in columns, or headers. We prioritize direct updates
+ * to the state of what we're rendering, so internally we end up normalizing the
+ * given data and then denormalizing it when rendering.
+ *
+ * As a result, each part of the DataTable is accessible through look-up by id,
+ * and updating the state of the single entity will cascade updates to the
+ * consumer.
+ */
+declare class DataTable extends React.Component<DataTableProps & typeof dataTableDefaultProps, DataTableState> {
+    instanceId: number;
+    static defaultProps: {
+        filterRows: ({ rowIds, headers, cellsById, inputValue, getCellId, }: {
+            rowIds: string[];
+            headers: any[];
+            cellsById: any;
+            inputValue: string;
+            getCellId: Function;
+        }) => string[];
+        locale: string;
+        overflowMenuOnHover: boolean;
+        size: string;
+        sortRow: (cellA: any, cellB: any, { sortDirection, sortStates, locale }: {
+            sortDirection: any;
+            sortStates: any;
+            locale: any;
+        }) => number;
+        translateWithId: (id: any) => string;
+    };
+    static propTypes: {
+        /**
+         * Experimental property. Allows table to align cell contents to the top if there is text wrapping in the content. Might have performance issues, intended for smaller tables
+         */
+        experimentalAutoAlign: PropTypes.Requireable<boolean>;
+        /**
+         * Optional hook to manually control filtering of the rows from the
+         * TableToolbarSearch component
+         */
+        filterRows: PropTypes.Requireable<(...args: any[]) => any>;
+        /**
+         * The `headers` prop represents the order in which the headers should
+         * appear in the table. We expect an array of objects to be passed in, where
+         * `key` is the name of the key in a row object, and `header` is the name of
+         * the header.
+         */
+        headers: PropTypes.Validator<(PropTypes.InferProps<{
+            key: PropTypes.Validator<string>;
+            header: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        }> | null | undefined)[]>;
+        /**
+         * Specify whether the table should be able to be sorted by its headers
+         */
+        isSortable: PropTypes.Requireable<boolean>;
+        /**
+         * Provide a string for the current locale
+         */
+        locale: PropTypes.Requireable<string>;
+        /**
+         * Specify whether the overflow menu (if it exists) should be shown always, or only on hover
+         */
+        overflowMenuOnHover: PropTypes.Requireable<boolean>;
+        /**
+         * Specify whether the control should be a radio button or inline checkbox
+         */
+        radio: PropTypes.Requireable<boolean>;
+        /**
+         * The `rows` prop is where you provide us with a list of all the rows that
+         * you want to render in the table. The only hard requirement is that this
+         * is an array of objects, and that each object has a unique `id` field
+         * available on it.
+         */
+        rows: PropTypes.Validator<(PropTypes.InferProps<{
+            id: PropTypes.Validator<string>;
+            disabled: PropTypes.Requireable<boolean>;
+            isSelected: PropTypes.Requireable<boolean>;
+            isExpanded: PropTypes.Requireable<boolean>;
+        }> | null | undefined)[]>;
+        /**
+         *  Change the row height of table. Currently supports `xs`, `sm`, `md`, `lg`, and `xl`.
+         */
+        size: PropTypes.Requireable<string>;
+        /**
+         * Optional hook to manually control sorting of the rows.
+         */
+        sortRow: PropTypes.Requireable<(...args: any[]) => any>;
+        /**
+         * Specify whether the header should be sticky.
+         * Still experimental: may not work with every combination of table props
+         */
+        stickyHeader: PropTypes.Requireable<boolean>;
+        /**
+         * Optional method that takes in a message id and returns an
+         * internationalized string. See `DataTable.translationKeys` for all
+         * available message ids.
+         */
+        translateWithId: PropTypes.Requireable<(...args: any[]) => any>;
+        /**
+         * `false` If true, will use a width of 'auto' instead of 100%
+         */
+        useStaticWidth: PropTypes.Requireable<boolean>;
+        /**
+         * `true` to add useZebraStyles striping.
+         */
+        useZebraStyles: PropTypes.Requireable<boolean>;
+    };
+    static translationKeys: string[];
+    static Table: typeof Table;
+    static TableActionList: typeof TableActionList;
+    static TableBatchAction: typeof TableBatchAction;
+    static TableBatchActions: typeof TableBatchActions;
+    static TableBody: typeof TableBody;
+    static TableCell: typeof TableCell;
+    static TableContainer: typeof TableContainer;
+    static TableExpandHeader: typeof TableExpandHeader;
+    static TableExpandRow: typeof TableExpandRow;
+    static TableExpandedRow: typeof TableExpandedRow;
+    static TableHead: typeof TableHead;
+    static TableHeader: typeof TableHeader;
+    static TableRow: typeof TableRow;
+    static TableSelectAll: typeof TableSelectAll;
+    static TableSelectRow: typeof TableSelectRow;
+    static TableToolbar: typeof TableToolbar;
+    static TableToolbarAction: typeof TableToolbarAction;
+    static TableToolbarContent: typeof TableToolbarContent;
+    static TableToolbarSearch: typeof TableToolbarSearch;
+    static TableToolbarMenu: typeof TableToolbarMenu;
+    constructor(props: any);
+    shouldComponentUpdate(nextProps: any): boolean;
+    /**
+     * Get the props associated with the given header. Mostly used for adding in
+     * sorting behavior.
+     *
+     * @param {object} config
+     * @param {string} config.header the header we want the props for
+     * @param {Function} config.onClick a custom click handler for the header
+     * @param {boolean} config.isSortable
+     * @returns {object}
+     */
+    getHeaderProps: ({ header, onClick, isSortable, ...rest }: {
+        [key: string]: unknown;
+        header: DataTableHeader;
+        onClick?: ((e: MouseEvent, sortState: {
+            sortHeaderKey: string;
+            sortDirection: DataTableSortState;
+        }) => void) | undefined;
+        isSortable?: boolean | undefined;
+    }) => {
+        key: string;
+        sortDirection: DataTableSortState;
+        isSortable: boolean | undefined;
+        isSortHeader: boolean;
+        onClick: (event: any) => void;
+    };
+    /**
+     * Get the props associated with the given expand header.
+     *
+     * @param {object} config
+     * @param {Function} config.onClick a custom click handler for the expand header
+     * @param {Function} config.onExpand a custom click handler called when header is expanded
+     * @returns {object}
+     */
+    getExpandHeaderProps: ({ onClick, onExpand, ...rest }?: {
+        [key: string]: unknown;
+        onClick?: ((e: MouseEvent, expandState: {
+            isExpanded: boolean;
+        }) => void) | undefined;
+        onExpand?: ((e: MouseEvent) => void) | undefined;
+    }) => {
+        ariaLabel: string;
+        isExpanded: boolean;
+        onExpand: any;
+    };
+    /**
+     * Decorate consumer's `onClick` event handler with sort parameters
+     *
+     * @param {Function} onClick
+     * @param {object} sortParams
+     * @returns {Function}
+     */
+    handleOnHeaderClick: (onClick: any, sortParams: any) => (e: any) => any;
+    /**
+     * Decorate consumer's `onClick` event handler with sort parameters
+     *
+     * @param {Function} onClick
+     * @param {object} expandParams
+     * @returns {Function}
+     */
+    handleOnExpandHeaderClick: (onClick: any, expandParams: any) => (e: any) => any;
+    /**
+     * Get the props associated with the given row. Mostly used for expansion.
+     *
+     * @param {object} config
+     * @param {object} config.row the row we want the props for
+     * @param {Function} config.onClick a custom click handler for the header
+     * @returns {object}
+     */
+    getRowProps: ({ row, onClick, ...rest }: {
+        [key: string]: unknown;
+        onClick?: ((e: MouseEvent) => void) | undefined;
+        row: DataTableRow;
+    }) => {
+        key: string;
+        onExpand: any;
+        isExpanded: boolean | undefined;
+        ariaLabel: string;
+        isSelected: boolean | undefined;
+        disabled: boolean | undefined;
+    };
+    /**
+     * Gets the props associated with selection for a header or a row, where
+     * applicable. Most often used to indicate selection status of the table or
+     * for a specific row.
+     *
+     * @param {object} [row] an optional row that we want to access the props for
+     * @param {Function} row.onClick
+     * @param {object} row.row
+     * @returns {object}
+     */
+    getSelectionProps: ({ onClick, row, ...rest }?: {
+        [key: string]: unknown;
+        onClick?: ((e: MouseEvent) => void) | undefined;
+        row: DataTableRow;
+    }) => {
+        checked: boolean | undefined;
+        onSelect: any;
+        id: string;
+        name: string;
+        ariaLabel: string;
+        disabled: boolean | undefined;
+        radio: true | null;
+    } | {
+        ariaLabel: string;
+        checked: boolean;
+        id: string;
+        indeterminate: boolean;
+        name: string;
+        onSelect: any;
+    };
+    getToolbarProps: (props?: {}) => {
+        [key: string]: unknown;
+        size: 'sm' | undefined;
+    };
+    getBatchActionProps: (props?: {}) => {
+        shouldShowBatchActions: boolean;
+        totalSelected: number;
+        onCancel: () => void;
+    };
+    /**
+     * Helper utility to get the Table Props.
+     */
+    getTableProps: () => {
+        useZebraStyles: boolean | undefined;
+        size: "sm" | "md" | "lg" | "xl" | "xs";
+        isSortable: boolean | undefined;
+        useStaticWidth: boolean | undefined;
+        stickyHeader: boolean | undefined;
+        overflowMenuOnHover: boolean;
+        experimentalAutoAlign: boolean | undefined;
+    };
+    /**
+     * Helper utility to get the TableContainer Props.
+     */
+    getTableContainerProps: () => {
+        stickyHeader: boolean | undefined;
+        useStaticWidth: boolean | undefined;
+    };
+    /**
+     * Helper utility to get all the currently selected rows
+     * @returns {Array<string>} the array of rowIds that are currently selected
+     */
+    getSelectedRows: () => string[];
+    /**
+     * Helper utility to get all of the available rows after applying the filter
+     * @returns {Array<string>} the array of rowIds that are currently included through the filter
+     *  */
+    getFilteredRowIds: () => string[];
+    /**
+     * Helper for getting the table prefix for elements that require an
+     * `id` attribute that is unique.
+     *
+     * @returns {string}
+     */
+    getTablePrefix: () => string;
+    /**
+     * Helper for toggling all selected items in a state. Does not call
+     * setState, so use it when setting state.
+     * @param {object} initialState
+     * @returns {object} object to put into this.setState (use spread operator)
+     */
+    setAllSelectedState: (initialState: any, isSelected: any, filteredRowIds: any) => {
+        rowsById: any;
+    };
+    /**
+     * Handler for the `onCancel` event to hide the batch action bar and
+     * deselect all selected rows
+     */
+    handleOnCancel: () => void;
+    /**
+     * Handler for toggling the selection state of all rows in the database
+     */
+    handleSelectAll: () => void;
+    /**
+     * Handler for toggling the selection state of a given row.
+     *
+     * @param {string} rowId
+     * @returns {Function}
+     */
+    handleOnSelectRow: (rowId: any) => () => void;
+    /**
+     * Handler for toggling the expansion state of a given row.
+     *
+     * @param {string} rowId
+     * @returns {Function}
+     */
+    handleOnExpandRow: (rowId: any) => () => void;
+    /**
+     * Handler for changing the expansion state of all rows.
+     */
+    handleOnExpandAll: () => void;
+    /**
+     * Handler for transitioning to the next sort state of the table
+     *
+     * @param {string} headerKey the field for the header that we are sorting by
+     * @returns {Function}
+     */
+    handleSortBy: (headerKey: any) => () => void;
+    /**
+     * Event handler for transitioning input value state changes for the table
+     * filter component.
+     *
+     * @param {Event} event
+     */
+    handleOnInputValueChange: (event: any, defaultValue: any) => void;
+    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+}
+export default DataTable;

package/lib/components/DataTable/DataTable.js

@@ -14,12 +14,12 @@ var PropTypes = require('prop-types');
 var React = require('react');
 var isEqual = require('lodash.isequal');
 var getDerivedStateFromProps = require('./state/getDerivedStateFromProps.js');
-var sorting = require('./state/sorting.js');
+var sorting$1 = require('./state/sorting.js');
 var cells = require('./tools/cells.js');
 var denormalize = require('./tools/denormalize.js');
 var events = require('../../tools/events.js');
 var filter = require('./tools/filter.js');
-var sorting$1 = require('./tools/sorting.js');
+var sorting = require('./tools/sorting.js');
 var instanceId = require('./tools/instanceId.js');
 var Table = require('./Table.js');
 var TableActionList = require('./TableActionList.js');
@@ -70,7 +70,14 @@ const defaultTranslations = {
   [translationKeys.unselectRow]: 'Unselect row'
 };
 const translateWithId = id => defaultTranslations[id];
-
+const dataTableDefaultProps = {
+  filterRows: filter.defaultFilterRows,
+  locale: 'en',
+  overflowMenuOnHover: true,
+  size: 'lg',
+  sortRow: sorting.defaultSortRow,
+  translateWithId
+};
 /**
  * Data Tables are used to represent a collection of resources, displaying a
  * subset of their fields in columns, or headers. We prioritize direct updates
@@ -86,6 +93,7 @@ class DataTable extends React__default["default"].Component {
     var _this;
     super(_props);
     _this = this;
+    _rollupPluginBabelHelpers.defineProperty(this, "instanceId", void 0);
     /**
      * Get the props associated with the given header. Mostly used for adding in
      * sorting behavior.
@@ -114,7 +122,7 @@ class DataTable extends React__default["default"].Component {
         isSortable,
         isSortHeader: sortHeaderKey === header.key,
         onClick: event => {
-          const nextSortState = sorting.getNextSortState(this.props, this.state, {
+          const nextSortState = sorting$1.getNextSortState(this.props, this.state, {
             key: header.key
           });
           this.setState(nextSortState, () => {
@@ -156,9 +164,9 @@ class DataTable extends React__default["default"].Component {
         isExpanded,
         // Compose the event handlers so we don't overwrite a consumer's `onClick`
         // handler
-        onExpand: events.composeEventHandlers([_this.handleOnExpandAll, onExpand, onClick ? _this.handleOnExpandHeaderClick(onClick, {
+        onExpand: events.composeEventHandlers([_this.handleOnExpandAll, onExpand, onClick && _this.handleOnExpandHeaderClick(onClick, {
           isExpanded
-        }) : null])
+        })])
       };
     });
     /**
@@ -268,7 +276,7 @@ class DataTable extends React__default["default"].Component {
       const {
         size
       } = _this.props;
-      let isSmall = size === 'xs' || size === 'sm';
+      const isSmall = size === 'xs' || size === 'sm';
       return {
         ...props,
         size: isSmall ? 'sm' : undefined
@@ -506,7 +514,7 @@ class DataTable extends React__default["default"].Component {
      * @returns {Function}
      */
     _rollupPluginBabelHelpers.defineProperty(this, "handleSortBy", headerKey => () => {
-      this.setState(state => sorting.getNextSortState(this.props, state, {
+      this.setState(state => sorting$1.getNextSortState(this.props, state, {
         key: headerKey
       }));
     });
@@ -612,6 +620,7 @@ class DataTable extends React__default["default"].Component {
     return null;
   }
 }
+_rollupPluginBabelHelpers.defineProperty(DataTable, "defaultProps", dataTableDefaultProps);
 _rollupPluginBabelHelpers.defineProperty(DataTable, "propTypes", {
   /**
    * Experimental property. Allows table to align cell contents to the top if there is text wrapping in the content. Might have performance issues, intended for smaller tables
@@ -688,15 +697,28 @@ _rollupPluginBabelHelpers.defineProperty(DataTable, "propTypes", {
    */
   useZebraStyles: PropTypes__default["default"].bool
 });
-_rollupPluginBabelHelpers.defineProperty(DataTable, "defaultProps", {
-  sortRow: sorting$1.defaultSortRow,
-  filterRows: filter.defaultFilterRows,
-  locale: 'en',
-  size: 'lg',
-  overflowMenuOnHover: true,
-  translateWithId
-});
 _rollupPluginBabelHelpers.defineProperty(DataTable, "translationKeys", Object.values(translationKeys));
+// Static properties for sub-components
+_rollupPluginBabelHelpers.defineProperty(DataTable, "Table", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableActionList", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableBatchAction", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableBatchActions", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableBody", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableCell", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableContainer", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableExpandHeader", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableExpandRow", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableExpandedRow", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableHead", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableHeader", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableRow", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableSelectAll", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableSelectRow", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableToolbar", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableToolbarAction", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableToolbarContent", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableToolbarSearch", void 0);
+_rollupPluginBabelHelpers.defineProperty(DataTable, "TableToolbarMenu", void 0);
 DataTable.Table = Table.Table;
 DataTable.TableActionList = TableActionList["default"];
 DataTable.TableBatchAction = TableBatchAction["default"];
@@ -717,6 +739,5 @@ DataTable.TableToolbarAction = TableToolbarAction["default"];
 DataTable.TableToolbarContent = TableToolbarContent["default"];
 DataTable.TableToolbarSearch = TableToolbarSearch["default"];
 DataTable.TableToolbarMenu = TableToolbarMenu["default"];
-var DataTable$1 = DataTable;
 
-exports["default"] = DataTable$1;
+exports["default"] = DataTable;

package/lib/components/DataTable/index.d.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import DataTable from './DataTable';
+import DataTable, { type DataTableCell, type DataTableHeader, type DataTableRow, type DataTableProps, type DataTableRenderProps, type DataTableSize } from './DataTable';
 import Table from './Table';
 import TableActionList from './TableActionList';
 import TableBatchAction from './TableBatchAction';
@@ -25,5 +25,5 @@ import TableToolbarAction from './TableToolbarAction';
 import TableToolbarContent from './TableToolbarContent';
 import TableToolbarSearch from './TableToolbarSearch';
 import TableToolbarMenu from './TableToolbarMenu';
-export { DataTable, Table, TableActionList, TableBatchAction, TableBatchActions, TableBody, TableCell, TableContainer, TableExpandHeader, TableExpandRow, TableExpandedRow, TableHead, TableHeader, TableRow, TableSelectAll, TableSelectRow, TableToolbar, TableToolbarAction, TableToolbarContent, TableToolbarSearch, TableToolbarMenu, };
+export { DataTable, type DataTableCell, type DataTableHeader, type DataTableProps, type DataTableRenderProps, type DataTableRow, type DataTableSize, Table, TableActionList, TableBatchAction, TableBatchActions, TableBody, TableCell, TableContainer, TableExpandHeader, TableExpandRow, TableExpandedRow, TableHead, TableHeader, TableRow, TableSelectAll, TableSelectRow, TableToolbar, TableToolbarAction, TableToolbarContent, TableToolbarSearch, TableToolbarMenu, };
 export default DataTable;