@fluentui/react-table 0.0.0-nightly-20221007-1237.1

package/dist/index.d.ts

@@ -0,0 +1,647 @@
+/// <reference types="react" />
+
+import { ARIAButtonSlotProps } from '@fluentui/react-aria';
+import type { AvatarSizes } from '@fluentui/react-avatar';
+import type { Checkbox } from '@fluentui/react-checkbox';
+import type { CheckboxProps } from '@fluentui/react-checkbox';
+import type { ComponentProps } from '@fluentui/react-utilities';
+import type { ComponentState } from '@fluentui/react-utilities';
+import type { ForwardRefComponent } from '@fluentui/react-utilities';
+import * as React_2 from 'react';
+import type { Slot } from '@fluentui/react-utilities';
+import type { SlotClassNames } from '@fluentui/react-utilities';
+
+export declare interface ColumnDefinition<TItem> {
+    columnId: ColumnId;
+    compare?: (a: TItem, b: TItem) => number;
+}
+
+export declare type ColumnId = string | number;
+
+export declare interface HeadlessTableState<TItem> extends Pick<UseTableOptions<TItem>, 'items' | 'getRowId'> {
+    /**
+     * The row data for rendering
+     * @param rowEnhancer - Enhances the row with extra user data
+     */
+    getRows: <TRowState extends RowState<TItem> = RowState<TItem>>(rowEnhancer?: RowEnhancer<TItem, TRowState>) => TRowState[];
+    /**
+     * State and actions to manage row selection
+     */
+    selection: TableSelectionState;
+    /**
+     * State and actions to manage row sorting
+     */
+    sort: TableSortState<TItem>;
+    /**
+     * Table columns
+     */
+    columns: ColumnDefinition<TItem>[];
+}
+
+/**
+ * Render the final JSX of Table
+ */
+export declare const renderTable_unstable: (state: TableState, contextValues: TableContextValues) => JSX.Element;
+
+/**
+ * Render the final JSX of TableBody
+ */
+export declare const renderTableBody_unstable: (state: TableBodyState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableCell
+ */
+export declare const renderTableCell_unstable: (state: TableCellState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableCellActions
+ */
+export declare const renderTableCellActions_unstable: (state: TableCellActionsState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableCellLayout
+ */
+export declare const renderTableCellLayout_unstable: (state: TableCellLayoutState, contextValues: TableCellLayoutContextValues) => JSX.Element;
+
+/**
+ * Render the final JSX of TableHeader
+ */
+export declare const renderTableHeader_unstable: (state: TableHeaderState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableHeaderCell
+ */
+export declare const renderTableHeaderCell_unstable: (state: TableHeaderCellState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableRow
+ */
+export declare const renderTableRow_unstable: (state: TableRowState) => JSX.Element;
+
+/**
+ * Render the final JSX of TableSelectionCell
+ */
+export declare const renderTableSelectionCell_unstable: (state: TableSelectionCellState) => JSX.Element;
+
+declare type RowEnhancer<TItem, TRowState extends RowState<TItem> = RowState<TItem>> = (row: RowState<TItem>) => TRowState;
+
+export declare type RowId = string | number;
+
+export declare interface RowState<TItem> {
+    /**
+     * User provided data
+     */
+    item: TItem;
+    /**
+     * The row id, defaults to index position in the collection
+     */
+    rowId: RowId;
+}
+
+declare type SelectionMode_2 = 'single' | 'multiselect';
+
+export declare type SortDirection = 'ascending' | 'descending';
+
+declare interface SortState {
+    sortColumn: ColumnId | undefined;
+    sortDirection: SortDirection;
+}
+
+/**
+ * Table component - TODO: add more docs
+ */
+export declare const Table: ForwardRefComponent<TableProps>;
+
+/**
+ * TableBody component - TODO: add more docs
+ */
+export declare const TableBody: ForwardRefComponent<TableBodyProps>;
+
+export declare const tableBodyClassName = "fui-TableBody";
+
+export declare const tableBodyClassNames: SlotClassNames<TableBodySlots>;
+
+/**
+ * TableBody Props
+ */
+export declare type TableBodyProps = ComponentProps<TableBodySlots>;
+
+export declare type TableBodySlots = {
+    root: Slot<'tbody', 'div'>;
+};
+
+/**
+ * State used in rendering TableBody
+ */
+export declare type TableBodyState = ComponentState<TableBodySlots> & Pick<TableContextValue, 'noNativeElements'>;
+
+/**
+ * TableCell component - TODO: add more docs
+ */
+export declare const TableCell: ForwardRefComponent<TableCellProps>;
+
+/**
+ * TableCellActions component - TODO: add more docs
+ */
+export declare const TableCellActions: ForwardRefComponent<TableCellActionsProps>;
+
+export declare const tableCellActionsClassNames: SlotClassNames<TableCellActionsSlots>;
+
+/**
+ * TableCellActions Props
+ */
+export declare type TableCellActionsProps = ComponentProps<TableCellActionsSlots> & {
+    /**
+     * When true, the actions are always visible regardless of row hover.
+     * Can be useful keeping the actions visible when a popout surface is opened.
+     */
+    visible?: boolean;
+};
+
+export declare type TableCellActionsSlots = {
+    root: Slot<'div'>;
+};
+
+/**
+ * State used in rendering TableCellActions
+ */
+export declare type TableCellActionsState = ComponentState<TableCellActionsSlots> & Pick<Required<TableCellActionsProps>, 'visible'>;
+
+export declare const tableCellClassName = "fui-TableCell";
+
+export declare const tableCellClassNames: SlotClassNames<TableCellSlots>;
+
+/**
+ * TableCellLayout component - TODO: add more docs
+ */
+export declare const TableCellLayout: ForwardRefComponent<TableCellLayoutProps>;
+
+export declare const tableCellLayoutClassNames: SlotClassNames<TableCellLayoutSlots>;
+
+declare type TableCellLayoutContextValues = {
+    avatar: {
+        size?: AvatarSizes;
+    };
+};
+
+/**
+ * TableCellLayout Props
+ */
+export declare type TableCellLayoutProps = ComponentProps<Partial<TableCellLayoutSlots>> & {
+    appearance?: 'primary';
+};
+
+export declare type TableCellLayoutSlots = {
+    root: Slot<'div'>;
+    /**
+     * Slot for an icon or other visual element
+     */
+    media: Slot<'span'>;
+    /**
+     * Main text for the table cell. Children of the root slot are automatically rendered here
+     */
+    main: Slot<'span'>;
+    /**
+     * Secondary text that describes or complements the main text
+     */
+    description: Slot<'span'>;
+    /**
+     * A layout wrapper for the main and description slots
+     */
+    wrapper: Slot<'div'>;
+};
+
+/**
+ * State used in rendering TableCellLayout
+ */
+export declare type TableCellLayoutState = ComponentState<TableCellLayoutSlots> & Pick<TableCellLayoutProps, 'appearance'> & {
+    avatarSize: AvatarSizes | undefined;
+};
+
+/**
+ * TableCell Props
+ */
+export declare type TableCellProps = ComponentProps<TableCellSlots> & {};
+
+export declare type TableCellSlots = {
+    root: Slot<'td', 'div'>;
+};
+
+/**
+ * State used in rendering TableCell
+ */
+export declare type TableCellState = ComponentState<TableCellSlots> & Pick<TableContextValue, 'noNativeElements'>;
+
+export declare const tableClassName = "fui-Table";
+
+export declare const tableClassNames: SlotClassNames<TableSlots>;
+
+export declare const TableContextProvider: React_2.Provider<TableContextValue | undefined>;
+
+export declare type TableContextValue = {
+    /**
+     * Affects the sizes of all table subcomponents
+     * @default medium
+     */
+    size: 'small' | 'smaller' | 'medium';
+    /**
+     * Render all table elements as divs intead of semantic table elements
+     * Using divs no longer uses `display: table` layout but `display: flex`
+     */
+    noNativeElements: boolean;
+    /**
+     * Whether the table is sortable
+     */
+    sortable: boolean;
+};
+
+export declare type TableContextValues = {
+    table: TableContextValue;
+};
+
+/**
+ * TableHeader component - TODO: add more docs
+ */
+export declare const TableHeader: ForwardRefComponent<TableHeaderProps>;
+
+/**
+ * TableHeaderCell component - TODO: add more docs
+ */
+export declare const TableHeaderCell: ForwardRefComponent<TableHeaderCellProps>;
+
+export declare const tableHeaderCellClassName = "fui-TableHeaderCell";
+
+export declare const tableHeaderCellClassNames: SlotClassNames<TableHeaderCellSlots>;
+
+/**
+ * TableHeaderCell Props
+ */
+export declare type TableHeaderCellProps = ComponentProps<Partial<TableHeaderCellSlots>> & {
+    sortDirection?: SortDirection;
+};
+
+export declare type TableHeaderCellSlots = {
+    root: Slot<'th', 'div'>;
+    sortIcon: Slot<'span'>;
+    /**
+     * Button handles correct narration and interactions for sorting;
+     */
+    button: NonNullable<Slot<ARIAButtonSlotProps>>;
+};
+
+/**
+ * State used in rendering TableHeaderCell
+ */
+export declare type TableHeaderCellState = ComponentState<TableHeaderCellSlots> & Pick<TableContextValue, 'noNativeElements' | 'sortable'>;
+
+export declare const tableHeaderClassName = "fui-TableHeader";
+
+export declare const tableHeaderClassNames: SlotClassNames<TableHeaderSlots>;
+
+/**
+ * TableHeader Props
+ */
+export declare type TableHeaderProps = ComponentProps<TableHeaderSlots> & {};
+
+export declare type TableHeaderSlots = {
+    root: Slot<'thead', 'div'>;
+};
+
+/**
+ * State used in rendering TableHeader
+ */
+export declare type TableHeaderState = ComponentState<TableHeaderSlots> & Pick<TableContextValue, 'noNativeElements'>;
+
+/**
+ * Table Props
+ */
+export declare type TableProps = ComponentProps<TableSlots> & Partial<TableContextValue>;
+
+/**
+ * TableRow component - TODO: add more docs
+ */
+export declare const TableRow: ForwardRefComponent<TableRowProps>;
+
+export declare const tableRowClassName = "fui-TableRow";
+
+export declare const tableRowClassNames: SlotClassNames<TableRowSlots>;
+
+/**
+ * TableRow Props
+ */
+export declare type TableRowProps = ComponentProps<TableRowSlots> & {};
+
+export declare type TableRowSlots = {
+    root: Slot<'tr', 'div'>;
+};
+
+/**
+ * State used in rendering TableRow
+ */
+export declare type TableRowState = ComponentState<TableRowSlots> & Pick<TableContextValue, 'noNativeElements' | 'size'>;
+
+/**
+ * TableSelectionCell component - TODO: add more docs
+ */
+export declare const TableSelectionCell: ForwardRefComponent<TableSelectionCellProps>;
+
+export declare const tableSelectionCellClassNames: SlotClassNames<TableSelectionCellSlots>;
+
+/**
+ * TableSelectionCell Props
+ */
+export declare type TableSelectionCellProps = ComponentProps<Partial<Omit<TableSelectionCellSlots, 'media'>>> & {
+    /**
+     * A table can have two kinds of selection modes
+     */
+    type?: 'checkbox' | 'radio';
+    checked?: CheckboxProps['checked'];
+};
+
+export declare type TableSelectionCellSlots = {
+    /**
+     * Selection indicator if selection type is checkbox
+     */
+    checkboxIndicator: Slot<typeof Checkbox>;
+    /**
+     * Selection indicator if selection type is radio
+     */
+    radioIndicator: Slot<'span'>;
+} & Pick<TableCellSlots, 'root'>;
+
+/**
+ * State used in rendering TableSelectionCell
+ */
+export declare type TableSelectionCellState = ComponentState<TableSelectionCellSlots> & Pick<Required<TableSelectionCellProps>, 'type' | 'checked'> & Pick<TableContextValue, 'noNativeElements'>;
+
+export declare interface TableSelectionState {
+    /**
+     * Clears all selected rows
+     */
+    clearRows: () => void;
+    /**
+     * Selects single row
+     */
+    selectRow: (rowId: RowId) => void;
+    /**
+     * De-selects single row
+     */
+    deselectRow: (rowId: RowId) => void;
+    /**
+     * Toggle selection of all rows
+     */
+    toggleAllRows: () => void;
+    /**
+     * Toggle selection of single row
+     */
+    toggleRow: (rowId: RowId) => void;
+    /**
+     * Collection of row ids corresponding to selected rows
+     */
+    selectedRows: Set<RowId>;
+    /**
+     * Whether all rows are selected
+     */
+    allRowsSelected: boolean;
+    /**
+     * Whether some rows are selected
+     */
+    someRowsSelected: boolean;
+    /**
+     * Checks if a given rowId is selected
+     */
+    isRowSelected: (rowId: RowId) => boolean;
+}
+
+export declare type TableSlots = {
+    root: Slot<'table', 'div'>;
+};
+
+export declare interface TableSortState<TItem> {
+    /**
+     * Current sort direction
+     */
+    sortDirection: SortDirection;
+    /**
+     * Column id of the currently sorted column
+     */
+    sortColumn: ColumnId | undefined;
+    /**
+     * Set the sort direction for the specified column
+     */
+    setColumnSort: (columnId: ColumnId, sortDirection: SortDirection) => void;
+    /**
+     * Toggles the sort direction for specified column
+     */
+    toggleColumnSort: (columnId: ColumnId) => void;
+    /**
+     * Returns the sort direction if a column is sorted,
+     * returns undefined if the column is not sorted
+     */
+    getSortDirection: (columnId: ColumnId) => SortDirection | undefined;
+    /**
+     * Sorts rows and returns a **shallow** copy of original items
+     */
+    sort: (rows: RowState<TItem>[]) => RowState<TItem>[];
+}
+
+/**
+ * State used in rendering Table
+ */
+export declare type TableState = ComponentState<TableSlots> & Pick<Required<TableProps>, 'size' | 'noNativeElements'> & TableContextValue;
+
+export declare type TableStatePlugin = <TItem>(tableState: HeadlessTableState<TItem>) => HeadlessTableState<TItem>;
+
+export declare function useSelection<TItem>(options: UseSelectionOptions): (tableState: HeadlessTableState<TItem>) => HeadlessTableState<TItem>;
+
+declare interface UseSelectionOptions {
+    /**
+     * Can be multi or single select
+     */
+    selectionMode: SelectionMode_2;
+    /**
+     * Used in uncontrolled mode to set initial selected rows on mount
+     */
+    defaultSelectedItems?: Set<RowId>;
+    /**
+     * Used to control row selection
+     */
+    selectedItems?: Set<RowId>;
+    /**
+     * Called when selection changes
+     */
+    onSelectionChange?: (selectedItems: Set<RowId>) => void;
+}
+
+export declare function useSort<TItem>(options: UseSortOptions): (tableState: HeadlessTableState<TItem>) => HeadlessTableState<TItem>;
+
+declare interface UseSortOptions {
+    /**
+     * Used to control sorting
+     */
+    sortState?: SortState;
+    /**
+     * Used in uncontrolled mode to set initial sort column and direction on mount
+     */
+    defaultSortState?: SortState;
+    /**
+     * Called when sort changes
+     */
+    onSortChange?: (state: SortState) => void;
+}
+
+export declare function useTable<TItem>(options: UseTableOptions<TItem>, plugins?: TableStatePlugin[]): HeadlessTableState<TItem>;
+
+/**
+ * Create the state required to render Table.
+ *
+ * The returned state can be modified with hooks such as useTableStyles_unstable,
+ * before being passed to renderTable_unstable.
+ *
+ * @param props - props from this instance of Table
+ * @param ref - reference to root HTMLElement of Table
+ */
+export declare const useTable_unstable: (props: TableProps, ref: React_2.Ref<HTMLElement>) => TableState;
+
+/**
+ * Create the state required to render TableBody.
+ *
+ * The returned state can be modified with hooks such as useTableBodyStyles_unstable,
+ * before being passed to renderTableBody_unstable.
+ *
+ * @param props - props from this instance of TableBody
+ * @param ref - reference to root HTMLElement of TableBody
+ */
+export declare const useTableBody_unstable: (props: TableBodyProps, ref: React_2.Ref<HTMLElement>) => TableBodyState;
+
+/**
+ * Apply styling to the TableBody slots based on the state
+ */
+export declare const useTableBodyStyles_unstable: (state: TableBodyState) => TableBodyState;
+
+/**
+ * Create the state required to render TableCell.
+ *
+ * The returned state can be modified with hooks such as useTableCellStyles_unstable,
+ * before being passed to renderTableCell_unstable.
+ *
+ * @param props - props from this instance of TableCell
+ * @param ref - reference to root HTMLElement of TableCell
+ */
+export declare const useTableCell_unstable: (props: TableCellProps, ref: React_2.Ref<HTMLElement>) => TableCellState;
+
+/**
+ * Create the state required to render TableCellActions.
+ *
+ * The returned state can be modified with hooks such as useTableCellActionsStyles_unstable,
+ * before being passed to renderTableCellActions_unstable.
+ *
+ * @param props - props from this instance of TableCellActions
+ * @param ref - reference to root HTMLElement of TableCellActions
+ */
+export declare const useTableCellActions_unstable: (props: TableCellActionsProps, ref: React_2.Ref<HTMLElement>) => TableCellActionsState;
+
+/**
+ * Apply styling to the TableCellActions slots based on the state
+ */
+export declare const useTableCellActionsStyles_unstable: (state: TableCellActionsState) => TableCellActionsState;
+
+/**
+ * Create the state required to render TableCellLayout.
+ *
+ * The returned state can be modified with hooks such as useTableCellLayoutStyles_unstable,
+ * before being passed to renderTableCellLayout_unstable.
+ *
+ * @param props - props from this instance of TableCellLayout
+ * @param ref - reference to root HTMLElement of TableCellLayout
+ */
+export declare const useTableCellLayout_unstable: (props: TableCellLayoutProps, ref: React_2.Ref<HTMLElement>) => TableCellLayoutState;
+
+/**
+ * Apply styling to the TableCellLayout slots based on the state
+ */
+export declare const useTableCellLayoutStyles_unstable: (state: TableCellLayoutState) => TableCellLayoutState;
+
+/**
+ * Apply styling to the TableCell slots based on the state
+ */
+export declare const useTableCellStyles_unstable: (state: TableCellState) => TableCellState;
+
+export declare const useTableContext: () => TableContextValue;
+
+/**
+ * Create the state required to render TableHeader.
+ *
+ * The returned state can be modified with hooks such as useTableHeaderStyles_unstable,
+ * before being passed to renderTableHeader_unstable.
+ *
+ * @param props - props from this instance of TableHeader
+ * @param ref - reference to root HTMLElement of TableHeader
+ */
+export declare const useTableHeader_unstable: (props: TableHeaderProps, ref: React_2.Ref<HTMLElement>) => TableHeaderState;
+
+/**
+ * Create the state required to render TableHeaderCell.
+ *
+ * The returned state can be modified with hooks such as useTableHeaderCellStyles_unstable,
+ * before being passed to renderTableHeaderCell_unstable.
+ *
+ * @param props - props from this instance of TableHeaderCell
+ * @param ref - reference to root HTMLElement of TableHeaderCell
+ */
+export declare const useTableHeaderCell_unstable: (props: TableHeaderCellProps, ref: React_2.Ref<HTMLElement>) => TableHeaderCellState;
+
+/**
+ * Apply styling to the TableHeaderCell slots based on the state
+ */
+export declare const useTableHeaderCellStyles_unstable: (state: TableHeaderCellState) => TableHeaderCellState;
+
+/**
+ * Apply styling to the TableHeader slots based on the state
+ */
+export declare const useTableHeaderStyles_unstable: (state: TableHeaderState) => TableHeaderState;
+
+export declare interface UseTableOptions<TItem> {
+    columns: ColumnDefinition<TItem>[];
+    items: TItem[];
+    getRowId?: (item: TItem) => RowId;
+}
+
+/**
+ * Create the state required to render TableRow.
+ *
+ * The returned state can be modified with hooks such as useTableRowStyles_unstable,
+ * before being passed to renderTableRow_unstable.
+ *
+ * @param props - props from this instance of TableRow
+ * @param ref - reference to root HTMLElement of TableRow
+ */
+export declare const useTableRow_unstable: (props: TableRowProps, ref: React_2.Ref<HTMLElement>) => TableRowState;
+
+/**
+ * Apply styling to the TableRow slots based on the state
+ */
+export declare const useTableRowStyles_unstable: (state: TableRowState) => TableRowState;
+
+/**
+ * Create the state required to render TableSelectionCell.
+ *
+ * The returned state can be modified with hooks such as useTableSelectionCellStyles_unstable,
+ * before being passed to renderTableSelectionCell_unstable.
+ *
+ * @param props - props from this instance of TableSelectionCell
+ * @param ref - reference to root HTMLElement of TableSelectionCell
+ */
+export declare const useTableSelectionCell_unstable: (props: TableSelectionCellProps, ref: React_2.Ref<HTMLElement>) => TableSelectionCellState;
+
+/**
+ * Apply styling to the TableSelectionCell slots based on the state
+ */
+export declare const useTableSelectionCellStyles_unstable: (state: TableSelectionCellState) => TableSelectionCellState;
+
+/**
+ * Apply styling to the Table slots based on the state
+ */
+export declare const useTableStyles_unstable: (state: TableState) => TableState;
+
+export { }

package/lib/Table.js

@@ -0,0 +1,2 @@
+export * from './components/Table/index';
+//# sourceMappingURL=Table.js.map

package/lib/Table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/Table.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC","sourcesContent":["export * from './components/Table/index';\n"]}

package/lib/TableBody.js

@@ -0,0 +1,2 @@
+export * from './components/TableBody/index';
+//# sourceMappingURL=TableBody.js.map

package/lib/TableBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableBody.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/TableBody.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC","sourcesContent":["export * from './components/TableBody/index';\n"]}

package/lib/TableCell.js

@@ -0,0 +1,2 @@
+export * from './components/TableCell/index';
+//# sourceMappingURL=TableCell.js.map

package/lib/TableCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableCell.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/TableCell.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC","sourcesContent":["export * from './components/TableCell/index';\n"]}

package/lib/TableCellActions.js

@@ -0,0 +1,2 @@
+export * from './components/TableCellActions/index';
+//# sourceMappingURL=TableCellActions.js.map

package/lib/TableCellActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableCellActions.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/TableCellActions.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC","sourcesContent":["export * from './components/TableCellActions/index';\n"]}

package/lib/TableCellLayout.js

@@ -0,0 +1,2 @@
+export * from './components/TableCellLayout/index';
+//# sourceMappingURL=TableCellLayout.js.map

package/lib/TableCellLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableCellLayout.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/TableCellLayout.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC","sourcesContent":["export * from './components/TableCellLayout/index';\n"]}

package/lib/TableCellPrimaryLayout.js

@@ -0,0 +1,2 @@
+export * from './components/TableCellLayout/index';
+//# sourceMappingURL=TableCellPrimaryLayout.js.map

package/lib/TableCellPrimaryLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableCellPrimaryLayout.js","sourceRoot":"","sources":["../../../../../../../packages/react-components/react-table/src/TableCellPrimaryLayout.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC","sourcesContent":["export * from './components/TableCellLayout/index';\n"]}

package/lib/TableHeader.js

@@ -0,0 +1,2 @@
+export * from './components/TableHeader/index';
+//# sourceMappingURL=TableHeader.js.map