@itwin/itwinui-react 3.0.0-dev.1 → 3.0.0-dev.11

package/esm/core/Table/hooks/useScrollToRow.d.ts

@@ -1,10 +1,10 @@
-import type { Row } from 'react-table';
+import type { Row } from '../../../react-table/react-table.js';
 import type { TableProps } from '../Table.js';
-declare type ScrollToRow<T extends Record<string, unknown>> = {
+type ScrollToRow<T extends Record<string, unknown>> = {
     scrollToIndex: number | undefined;
     tableRowRef: (row: Row<T>) => (element: HTMLDivElement) => void;
 };
-declare type ScrollToRowProps<T extends Record<string, unknown>> = TableProps<T> & {
+type ScrollToRowProps<T extends Record<string, unknown>> = TableProps<T> & {
     page: Row<T>[];
 };
 export declare function useScrollToRow<T extends Record<string, unknown>>({ data, enableVirtualization, page, paginatorRenderer, scrollToRow, }: ScrollToRowProps<T>): ScrollToRow<T>;

package/esm/core/Table/hooks/useScrollToRow.js

@@ -3,39 +3,46 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import * as React from 'react';
-export function useScrollToRow({ data, enableVirtualization, page, paginatorRenderer, scrollToRow, }) {
-    const rowRefs = React.useRef({});
-    // Refs prevents from having `page` and `data` as dependencies
-    // therefore we avoid unnecessary scroll to row.
-    const pageRef = React.useRef(page);
-    pageRef.current = page;
-    const dataRef = React.useRef(data);
-    dataRef.current = data;
-    // For virtualized tables, all we need to do is pass the index of the item
-    // to the VirtualScroll component
-    const scrollToIndex = React.useMemo(() => {
-        if (!scrollToRow || paginatorRenderer) {
-            return undefined;
-        }
-        const index = scrollToRow(pageRef.current, dataRef.current);
-        return index < 0 ? undefined : index;
-    }, [paginatorRenderer, scrollToRow]);
-    // For non-virtualized tables, we need to add a ref to each row
-    // and scroll to the element
-    React.useEffect(() => {
-        var _a;
-        if (enableVirtualization ||
-            scrollToIndex === undefined ||
-            scrollToIndex === null ||
-            scrollToIndex < 0) {
-            return;
-        }
-        (_a = rowRefs.current[pageRef.current[scrollToIndex].id]) === null || _a === void 0 ? void 0 : _a.scrollIntoView();
-    }, [enableVirtualization, scrollToIndex]);
-    const tableRowRef = React.useCallback((row) => {
-        return (element) => {
-            rowRefs.current[row.id] = element;
-        };
-    }, []);
-    return { scrollToIndex, tableRowRef };
+export function useScrollToRow({
+  data,
+  enableVirtualization,
+  page,
+  paginatorRenderer,
+  scrollToRow,
+}) {
+  const rowRefs = React.useRef({});
+  // Refs prevents from having `page` and `data` as dependencies
+  // therefore we avoid unnecessary scroll to row.
+  const pageRef = React.useRef(page);
+  pageRef.current = page;
+  const dataRef = React.useRef(data);
+  dataRef.current = data;
+  // For virtualized tables, all we need to do is pass the index of the item
+  // to the VirtualScroll component
+  const scrollToIndex = React.useMemo(() => {
+    if (!scrollToRow || paginatorRenderer) {
+      return undefined;
+    }
+    const index = scrollToRow(pageRef.current, dataRef.current);
+    return index < 0 ? undefined : index;
+  }, [paginatorRenderer, scrollToRow]);
+  // For non-virtualized tables, we need to add a ref to each row
+  // and scroll to the element
+  React.useEffect(() => {
+    if (
+      enableVirtualization ||
+      scrollToIndex === undefined ||
+      scrollToIndex === null ||
+      scrollToIndex < 0
+    ) {
+      return;
+    }
+    rowRefs.current[pageRef.current[scrollToIndex]?.id]?.scrollIntoView();
+  }, [enableVirtualization, scrollToIndex]);
+  const tableRowRef = React.useCallback((row) => {
+    return (element) => {
+      rowRefs.current[row.id] = element;
+    };
+  }, []);
+  return { scrollToIndex, tableRowRef };
 }

package/esm/core/Table/hooks/useSelectionCell.d.ts

@@ -1,2 +1,2 @@
-import type { Hooks } from 'react-table';
+import type { Hooks } from '../../../react-table/react-table.js';
 export declare const useSelectionCell: <T extends Record<string, unknown>>(isSelectable: boolean, selectionMode: 'multi' | 'single', isRowDisabled?: ((rowData: T) => boolean) | undefined, density?: 'default' | 'condensed' | 'extra-condensed') => (hooks: Hooks<T>) => void;

package/esm/core/Table/hooks/useSelectionCell.js

@@ -1,13 +1,17 @@
 import { SelectionColumn, SELECTION_CELL_ID } from '../columns/index.js';
-export const useSelectionCell = (isSelectable, selectionMode, isRowDisabled, density = 'default') => (hooks) => {
+export const useSelectionCell =
+  (isSelectable, selectionMode, isRowDisabled, density = 'default') =>
+  (hooks) => {
     if (!isSelectable) {
-        return;
+      return;
     }
-    hooks.allColumns.push((columns) => selectionMode === 'single' ||
-        columns.find((c) => c.id === SELECTION_CELL_ID)
+    hooks.allColumns.push((columns) =>
+      selectionMode === 'single' ||
+      columns.find((c) => c.id === SELECTION_CELL_ID)
         ? columns
         : [
             SelectionColumn({ isDisabled: isRowDisabled, density: density }),
             ...columns,
-        ]);
-};
+          ],
+    );
+  };

package/esm/core/Table/hooks/useStickyColumns.d.ts

@@ -1,2 +1,2 @@
-import type { Hooks } from 'react-table';
+import type { Hooks } from '../../../react-table/react-table.js';
 export declare const useStickyColumns: <T extends Record<string, unknown>>(hooks: Hooks<T>) => void;

package/esm/core/Table/hooks/useStickyColumns.js

@@ -6,70 +6,70 @@ import { actions } from 'react-table';
 actions.setScrolledLeft = 'setScrolledLeft';
 actions.setScrolledRight = 'setScrolledRight';
 export const useStickyColumns = (hooks) => {
-    hooks.stateReducers.push(reducer);
-    hooks.useInstance.push(useInstance);
+  hooks.stateReducers.push(reducer);
+  hooks.useInstance.push(useInstance);
 };
 const reducer = (newState, action) => {
-    var _a, _b;
-    if (action.type === actions.init) {
-        return {
-            ...newState,
-            sticky: {},
-        };
+  if (action.type === actions.init) {
+    return {
+      ...newState,
+      sticky: {},
+    };
+  }
+  if (
+    action.type === actions.setScrolledLeft &&
+    newState.sticky?.isScrolledToLeft !== action.value // Prevents unnecessary re-render
+  ) {
+    return {
+      ...newState,
+      sticky: {
+        ...newState.sticky,
+        isScrolledToLeft: action.value,
+      },
+    };
+  }
+  if (
+    action.type === actions.setScrolledRight &&
+    newState.sticky?.isScrolledToRight !== action.value // Prevents unnecessary re-render
+  ) {
+    return {
+      ...newState,
+      sticky: {
+        ...newState.sticky,
+        isScrolledToRight: action.value,
+      },
+    };
+  }
+  return newState;
+};
+const useInstance = (instance) => {
+  const { flatHeaders } = instance;
+  // Edge case. Saving original sticky state in case sticky columns are reordered.
+  flatHeaders.forEach((header) => {
+    if (!header.originalSticky) {
+      header.originalSticky = header.sticky ?? 'none';
     }
-    if (action.type === actions.setScrolledLeft &&
-        ((_a = newState.sticky) === null || _a === void 0 ? void 0 : _a.isScrolledToLeft) !== action.value // Prevents unnecessary re-render
-    ) {
-        return {
-            ...newState,
-            sticky: {
-                ...newState.sticky,
-                isScrolledToLeft: action.value,
-            },
-        };
+    header.sticky =
+      header.originalSticky === 'none' ? undefined : header.originalSticky;
+  });
+  // If there is a column that is sticked to the left, make every column prior to that sticky too.
+  let hasLeftStickyColumn = false;
+  [...flatHeaders].reverse().forEach((header) => {
+    if (header.sticky === 'left') {
+      hasLeftStickyColumn = true;
     }
-    if (action.type === actions.setScrolledRight &&
-        ((_b = newState.sticky) === null || _b === void 0 ? void 0 : _b.isScrolledToRight) !== action.value // Prevents unnecessary re-render
-    ) {
-        return {
-            ...newState,
-            sticky: {
-                ...newState.sticky,
-                isScrolledToRight: action.value,
-            },
-        };
+    if (hasLeftStickyColumn) {
+      header.sticky = 'left';
     }
-    return newState;
-};
-const useInstance = (instance) => {
-    const { flatHeaders } = instance;
-    // Edge case. Saving original sticky state in case sticky columns are reordered.
-    flatHeaders.forEach((header) => {
-        var _a;
-        if (!header.originalSticky) {
-            header.originalSticky = (_a = header.sticky) !== null && _a !== void 0 ? _a : 'none';
-        }
-        header.sticky =
-            header.originalSticky === 'none' ? undefined : header.originalSticky;
-    });
-    // If there is a column that is sticked to the left, make every column prior to that sticky too.
-    let hasLeftStickyColumn = false;
-    [...flatHeaders].reverse().forEach((header) => {
-        if (header.sticky === 'left') {
-            hasLeftStickyColumn = true;
-        }
-        if (hasLeftStickyColumn) {
-            header.sticky = 'left';
-        }
-    });
-    // If there is a column that is sticked to the right, make every column after to that sticky too.
-    let hasRightStickyColumn = false;
-    flatHeaders.forEach((header) => {
-        if (header.sticky === 'right') {
-            hasRightStickyColumn = true;
-        }
-        if (hasRightStickyColumn) {
-            header.sticky = 'right';
-        }
-    });
+  });
+  // If there is a column that is sticked to the right, make every column after to that sticky too.
+  let hasRightStickyColumn = false;
+  flatHeaders.forEach((header) => {
+    if (header.sticky === 'right') {
+      hasRightStickyColumn = true;
+    }
+    if (hasRightStickyColumn) {
+      header.sticky = 'right';
+    }
+  });
 };

package/esm/core/Table/hooks/useSubRowFiltering.d.ts

@@ -1,2 +1,2 @@
-import type { Hooks } from 'react-table';
+import type { Hooks } from '../../../react-table/react-table.js';
 export declare const useSubRowFiltering: <T extends Record<string, unknown>>(hasAnySubRows: boolean) => (hooks: Hooks<T>) => void;

package/esm/core/Table/hooks/useSubRowFiltering.js

@@ -5,96 +5,101 @@
 import * as React from 'react';
 import { defaultFilterFunctions } from '../filters/defaultFilterFunctions.js';
 export const useSubRowFiltering = (hasAnySubRows) => (hooks) => {
-    hooks.useInstance.push(useInstance.bind({}, hasAnySubRows));
+  hooks.useInstance.push(useInstance.bind({}, hasAnySubRows));
 };
 const useInstance = (hasAnySubRows, instance) => {
-    // There is a bug in react-table that filtered out sub-rows won't be shown after clearing the filter.
-    // Therefore saving original sub-rows separately.
-    // Related issue: https://github.com/tannerlinsley/react-table/issues/2928
-    const setInitialSubRows = (rows) => {
-        rows.forEach((row) => {
-            if (!row.initialSubRows) {
-                row.initialSubRows = row.subRows;
-            }
-            setInitialSubRows(row.subRows);
-        });
+  // There is a bug in react-table that filtered out sub-rows won't be shown after clearing the filter.
+  // Therefore saving original sub-rows separately.
+  // Related issue: https://github.com/tannerlinsley/react-table/issues/2928
+  const setInitialSubRows = (rows) => {
+    rows.forEach((row) => {
+      if (!row.initialSubRows) {
+        row.initialSubRows = row.subRows;
+      }
+      setInitialSubRows(row.subRows);
+    });
+  };
+  setInitialSubRows(instance.initialRows);
+  const {
+    filteredRows = instance.filteredRows,
+    filteredFlatRows = instance.filteredFlatRows,
+    filteredRowsById = instance.filteredRowsById,
+  } = React.useMemo(() => {
+    if (!hasAnySubRows) {
+      return {};
+    }
+    // Restore original sub-rows
+    const setSubRows = (rows) => {
+      rows.forEach((row) => {
+        row.subRows = row.initialSubRows ?? [];
+        setSubRows(row.subRows);
+      });
     };
-    setInitialSubRows(instance.initialRows);
-    const { filteredRows = instance.filteredRows, filteredFlatRows = instance.filteredFlatRows, filteredRowsById = instance.filteredRowsById, } = React.useMemo(() => {
-        if (!hasAnySubRows) {
-            return {};
-        }
-        // Restore original sub-rows
-        const setSubRows = (rows) => {
-            rows.forEach((row) => {
-                var _a;
-                row.subRows = (_a = row.initialSubRows) !== null && _a !== void 0 ? _a : [];
-                setSubRows(row.subRows);
-            });
-        };
-        setSubRows(instance.initialRows);
-        let currentlyFilteredRows = [...instance.initialRows];
-        instance.state.filters.forEach(({ id: columnId, value: filterValue }) => {
-            var _a;
-            const column = instance.allColumns.find((c) => c.id === columnId);
-            if (!column) {
-                return;
-            }
-            const filterTypes = {
-                ...defaultFilterFunctions,
-                ...instance.filterTypes,
-            };
-            const filterFn = typeof column.filter === 'function'
-                ? column.filter
-                : filterTypes[(_a = column.filter) !== null && _a !== void 0 ? _a : 'text'];
-            currentlyFilteredRows = currentlyFilteredRows.filter((row) => handleRowFiltering(row, filterFn, columnId, filterValue));
-        });
-        const filteredRows = [];
-        const filteredFlatRows = [];
-        const filteredRowsById = {};
-        // Setting rows here helps to keep them ordered.
-        const populateRows = (row) => {
-            if (row.depth === 0) {
-                filteredRows.push(row);
-            }
-            filteredFlatRows.push(row);
-            filteredRowsById[row.id] = row;
-            if (row.subRows.length) {
-                row.subRows.forEach((r) => populateRows(r));
-            }
-        };
-        currentlyFilteredRows.forEach((row) => populateRows(row));
-        return { filteredRows, filteredFlatRows, filteredRowsById };
-    }, [
-        instance.allColumns,
-        instance.filterTypes,
-        instance.initialRows,
-        instance.state.filters,
-        hasAnySubRows,
-    ]);
-    Object.assign(instance, {
-        filteredRows,
-        filteredFlatRows,
-        filteredRowsById,
-        rows: filteredRows,
-        flatRows: filteredFlatRows,
-        rowsById: filteredRowsById,
+    setSubRows(instance.initialRows);
+    let currentlyFilteredRows = [...instance.initialRows];
+    instance.state.filters.forEach(({ id: columnId, value: filterValue }) => {
+      const column = instance.allColumns.find((c) => c.id === columnId);
+      if (!column) {
+        return;
+      }
+      const filterTypes = {
+        ...defaultFilterFunctions,
+        ...instance.filterTypes,
+      };
+      const filterFn =
+        typeof column.filter === 'function'
+          ? column.filter
+          : filterTypes[column.filter ?? 'text'];
+      currentlyFilteredRows = currentlyFilteredRows.filter((row) =>
+        handleRowFiltering(row, filterFn, columnId, filterValue),
+      );
     });
+    const filteredRows = [];
+    const filteredFlatRows = [];
+    const filteredRowsById = {};
+    // Setting rows here helps to keep them ordered.
+    const populateRows = (row) => {
+      if (row.depth === 0) {
+        filteredRows.push(row);
+      }
+      filteredFlatRows.push(row);
+      filteredRowsById[row.id] = row;
+      if (row.subRows.length) {
+        row.subRows.forEach((r) => populateRows(r));
+      }
+    };
+    currentlyFilteredRows.forEach((row) => populateRows(row));
+    return { filteredRows, filteredFlatRows, filteredRowsById };
+  }, [
+    instance.allColumns,
+    instance.filterTypes,
+    instance.initialRows,
+    instance.state.filters,
+    hasAnySubRows,
+  ]);
+  Object.assign(instance, {
+    filteredRows,
+    filteredFlatRows,
+    filteredRowsById,
+    rows: filteredRows,
+    flatRows: filteredFlatRows,
+    rowsById: filteredRowsById,
+  });
 };
 const handleRowFiltering = (row, filterFn, columnId, filterValue) => {
-    let hasFilteredSubRows = false;
-    row.subRows = row.initialSubRows.filter((subRow) => {
-        const result = handleRowFiltering(subRow, filterFn, columnId, filterValue);
-        if (result) {
-            hasFilteredSubRows = true;
-        }
-        return result;
-    });
-    // If row has any sub-rows that meet filter conditions,
-    // then that row also needs to be shown.
-    if (hasFilteredSubRows) {
-        return true;
+  let hasFilteredSubRows = false;
+  row.subRows = row.initialSubRows.filter((subRow) => {
+    const result = handleRowFiltering(subRow, filterFn, columnId, filterValue);
+    if (result) {
+      hasFilteredSubRows = true;
     }
-    const result = filterFn([row], [columnId], filterValue);
-    return !!result.length;
+    return result;
+  });
+  // If row has any sub-rows that meet filter conditions,
+  // then that row also needs to be shown.
+  if (hasFilteredSubRows) {
+    return true;
+  }
+  const result = filterFn([row], [columnId], filterValue);
+  return !!result.length;
 };

package/esm/core/Table/hooks/useSubRowSelection.d.ts

@@ -1,2 +1,2 @@
-import type { Hooks } from 'react-table';
+import type { Hooks } from '../../../react-table/react-table.js';
 export declare const useSubRowSelection: <T extends Record<string, unknown>>(hooks: Hooks<T>) => void;

package/esm/core/Table/hooks/useSubRowSelection.js

@@ -4,33 +4,34 @@
  *--------------------------------------------------------------------------------------------*/
 import * as React from 'react';
 export const useSubRowSelection = (hooks) => {
-    hooks.useInstance.push(useInstance);
+  hooks.useInstance.push(useInstance);
 };
 const useInstance = (instance) => {
-    const selectedFlatRows = React.useMemo(() => {
-        const selectedFlatRows = [];
-        const setSelectionState = (row, selectedRowIds) => {
-            let isSomeSubRowsSelected = false;
-            row.subRows.forEach((subRow) => {
-                setSelectionState(subRow, selectedRowIds);
-                if (subRow.isSelected || subRow.isSomeSelected) {
-                    isSomeSubRowsSelected = true;
-                }
-            });
-            if (selectedRowIds[row.id]) {
-                row.isSelected = true;
-                row.isSomeSelected = false;
-                selectedFlatRows.push(row);
-            }
-            else {
-                row.isSelected = false;
-                row.isSomeSelected = isSomeSubRowsSelected;
-            }
-        };
-        instance.rows.forEach((row) => setSelectionState(row, instance.state.selectedRowIds));
-        return selectedFlatRows;
-    }, [instance.rows, instance.state.selectedRowIds]);
-    Object.assign(instance, {
-        selectedFlatRows,
-    });
+  const selectedFlatRows = React.useMemo(() => {
+    const selectedFlatRows = [];
+    const setSelectionState = (row, selectedRowIds) => {
+      let isSomeSubRowsSelected = false;
+      row.subRows.forEach((subRow) => {
+        setSelectionState(subRow, selectedRowIds);
+        if (subRow.isSelected || subRow.isSomeSelected) {
+          isSomeSubRowsSelected = true;
+        }
+      });
+      if (selectedRowIds[row.id]) {
+        row.isSelected = true;
+        row.isSomeSelected = false;
+        selectedFlatRows.push(row);
+      } else {
+        row.isSelected = false;
+        row.isSomeSelected = isSomeSubRowsSelected;
+      }
+    };
+    instance.rows.forEach((row) =>
+      setSelectionState(row, instance.state.selectedRowIds),
+    );
+    return selectedFlatRows;
+  }, [instance.rows, instance.state.selectedRowIds]);
+  Object.assign(instance, {
+    selectedFlatRows,
+  });
 };

package/esm/core/Table/index.d.ts

@@ -1,5 +1,5 @@
 export { Table } from './Table.js';
-export type { TableProps, TablePaginatorRendererProps } from './Table.js';
+export type { TablePaginatorRendererProps } from './Table.js';
 export { BaseFilter, FilterButtonBar, tableFilters } from './filters/index.js';
 export type { BaseFilterProps, DateRangeFilterOptions, FilterButtonBarProps, FilterButtonBarTranslation, TableFilterProps, TableFilterValue, } from './filters/index.js';
 export { DefaultCell, EditableCell } from './cells/index.js';

package/esm/core/Table/index.js

@@ -6,5 +6,9 @@ export { Table } from './Table.js';
 export { BaseFilter, FilterButtonBar, tableFilters } from './filters/index.js';
 export { DefaultCell, EditableCell } from './cells/index.js';
 export { TablePaginator } from './TablePaginator.js';
-export { ActionColumn, ExpanderColumn, SelectionColumn, } from './columns/index.js';
+export {
+  ActionColumn,
+  ExpanderColumn,
+  SelectionColumn,
+} from './columns/index.js';
 export default './Table';

package/esm/core/Table/utils.d.ts

@@ -1,3 +1,3 @@
-import type { ColumnInstance } from 'react-table';
+import type { ColumnInstance } from '../../react-table/react-table.js';
 export declare const getCellStyle: <T extends Record<string, unknown>>(column: ColumnInstance<T>, isTableResizing: boolean) => React.CSSProperties | undefined;
 export declare const getStickyStyle: <T extends Record<string, unknown>>(column: ColumnInstance<T>, columnList: ColumnInstance<T>[]) => React.CSSProperties;

package/esm/core/Table/utils.js

@@ -1,45 +1,47 @@
 export const getCellStyle = (column, isTableResizing) => {
-    const style = {};
-    style.flex = `1 1 145px`;
-    if (column.width) {
-        const width = typeof column.width === 'string' ? column.width : `${column.width}px`;
-        style.width = width;
-        // This allows flexbox to handle the width of the column on table resize
-        if (isTableResizing && column.canResize) {
-            style.flex = `${Number(column.width)} ${Number(column.width)} ${width}`;
-        }
-        else {
-            style.flex = `0 0 ${width}`;
-        }
+  const style = {};
+  style.flex = `1 1 145px`;
+  if (column.width) {
+    const width =
+      typeof column.width === 'string' ? column.width : `${column.width}px`;
+    style.width = width;
+    // This allows flexbox to handle the width of the column on table resize
+    if (isTableResizing && column.canResize) {
+      style.flex = `${Number(column.width)} ${Number(column.width)} ${width}`;
+    } else {
+      style.flex = `0 0 ${width}`;
     }
-    if (column.maxWidth) {
-        style.maxWidth = `${column.maxWidth}px`;
-    }
-    if (column.minWidth) {
-        style.minWidth = `${column.minWidth}px`;
-    }
-    return style;
+  }
+  if (column.maxWidth) {
+    style.maxWidth = `${column.maxWidth}px`;
+  }
+  if (column.minWidth) {
+    style.minWidth = `${column.minWidth}px`;
+  }
+  return style;
 };
 export const getStickyStyle = (column, columnList) => {
-    if (!column.sticky) {
-        return {};
-    }
-    let left = 0;
-    for (const col of columnList) {
-        if (col.id === column.id) {
-            break;
-        }
-        left += Number(col.width || col.resizeWidth || 0);
+  if (!column.sticky) {
+    return {};
+  }
+  let left = 0;
+  for (const col of columnList) {
+    if (col.id === column.id) {
+      break;
     }
-    let right = 0;
-    for (const col of [...columnList].reverse()) {
-        if (col.id === column.id) {
-            break;
-        }
-        right += Number(col.width || col.resizeWidth || 0);
+    left += Number(col.width || col.resizeWidth || 0);
+  }
+  let right = 0;
+  for (const col of [...columnList].reverse()) {
+    if (col.id === column.id) {
+      break;
     }
-    return {
-        '--iui-table-sticky-left': column.sticky === 'left' ? `${left}px` : undefined,
-        '--iui-table-sticky-right': column.sticky === 'right' ? `${right}px` : undefined,
-    };
+    right += Number(col.width || col.resizeWidth || 0);
+  }
+  return {
+    '--iui-table-sticky-left':
+      column.sticky === 'left' ? `${left}px` : undefined,
+    '--iui-table-sticky-right':
+      column.sticky === 'right' ? `${right}px` : undefined,
+  };
 };

package/esm/core/Tabs/Tab.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { PolymorphicForwardRefComponent } from '../utils/index.js';
-declare type TabProps = {
+type TabProps = {
     /**
      * The main label shown in the tab.
      */
@@ -37,4 +37,4 @@ declare type TabProps = {
  * ];
  */
 export declare const Tab: PolymorphicForwardRefComponent<"button", TabProps>;
-export default TabProps;
+export default Tab;