@ostack.tech/ui 0.1.0

package/dist/types/components/ControlCode/ControlCode.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import { type ControlStatus, type ControlVariant } from "../../utils/control.ts";
+/** Properties of the control's code component. */
+export interface ControlCodeProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Change the component to the HTML tag or custom component of the only child.
+     * This will merge the original component props with the props of the supplied
+     * element/component and change the underlying DOM node.
+     */
+    asChild?: boolean;
+    /** Variant of the control code. */
+    variant?: ControlVariant;
+    /**
+     * Sets the status of the code (this should typically be the same as the
+     * control's status).
+     */
+    status?: ControlStatus;
+    /** Text prefixed to the code to be announced by assistive technologies. */
+    visuallyHiddenPrefix?: React.ReactNode;
+}
+/** Component used to display the "code" of a form control. */
+export declare const ControlCode: React.ForwardRefExoticComponent<ControlCodeProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/ControlCode/index.d.ts

@@ -0,0 +1 @@
+export * from "./ControlCode.tsx";

package/dist/types/components/DataTable/DataTable.d.ts

@@ -0,0 +1,256 @@
+import * as React from "react";
+import { type SortDirection } from "../../utils/sorting.ts";
+import { type DataTableApi } from "./DataTableApi.ts";
+import { type DataTableCellProps } from "./DataTableCell.tsx";
+import { type DataTableColumns } from "./DataTableColumn.tsx";
+import { type DataTableRowProps } from "./DataTableRow.tsx";
+/** Display mode of the data table. */
+export type DataTableDisplayMode = "paged" | "scrolled";
+/**
+ * Options passed to the `getRows` function to get the rows meant to be
+ * rendered.
+ */
+export interface DataTableGetRowsOptions {
+    /** Index from which to fetch rows. */
+    offset: number;
+    /** Limit of rows to fetch. */
+    limit: number;
+    /**
+     * Filter to apply. An empty string will be passed when the results shouldn't
+     * be filtered.
+     */
+    filter: string;
+    /** Column to sort by. `null` is passed when the results shouldn't be sorted. */
+    sortBy: string | null;
+    /**
+     * Direction of the sorting. `null` is passed when the results shouldn't be
+     * sorted.
+     */
+    sortDirection: SortDirection | null;
+    /**
+     * Abort signal provided by the data table which is cancelled when the result
+     * of this `getRows` call is no longer needed.
+     */
+    signal: AbortSignal;
+}
+/** Object which should be returned by `getRows`. */
+export interface DataTableGetRowsResult<T = unknown> {
+    /** Fetched rows for the given options. */
+    rows: T[];
+    /** Total number of rows of the data table. */
+    totalCount: number;
+}
+/** Properties of the data table component. */
+export interface DataTableProps<T = any> extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Display mode of the data table. Rows are displayed either in pages or
+     * within an infinite scroll component.
+     *
+     * @default paged
+     */
+    displayMode?: DataTableDisplayMode;
+    /** Data table columns. */
+    columns: DataTableColumns<T>;
+    /**
+     * Rows of the data table.
+     *
+     * Either this property or `getRows` should be provided.
+     */
+    rows?: T[];
+    /**
+     * Function used to dynamically get the rows of the data table.
+     *
+     * Either this property or `rows` should be provided.
+     */
+    getRows?: (options: DataTableGetRowsOptions) => DataTableGetRowsResult<T> | PromiseLike<DataTableGetRowsResult<T>>;
+    /**
+     * Property of the row that contains the row's key, or a function used to get
+     * it, given the row.
+     *
+     * Keys should be of type `React.Key`, i.e. `string | number | bigint`.
+     */
+    rowKey: string | number | symbol | ((row: T) => React.Key);
+    /**
+     * Number of rows to show when `loading` is `true`, or using `getRows` and the
+     * total count isn't yet known.
+     *
+     * @default 2
+     */
+    loadingCount?: number;
+    /** Marks the data table as "required" when it is being used as a control. */
+    required?: boolean;
+    /** Marks the data table as currently loading data. */
+    loading?: boolean;
+    /**
+     * Default offset from which to display rows. When in paged mode, the actually
+     * used offset will always be a multiple of `limit`.
+     *
+     * @default 0
+     */
+    defaultOffset?: number;
+    /**
+     * Controlled offset from which to display rows. When in paged mode, the
+     * actually used offset will always be a multiple of `limit`.
+     *
+     * Use together with `onOffsetChange` to control the offset.
+     */
+    offset?: number;
+    /**
+     * Function called whenever the offset changes.
+     *
+     * @param offset New offset.
+     */
+    onOffsetChange?: (offset: number) => void;
+    /**
+     * Default value used to limit the number of rows shown on screen.
+     *
+     * @default 10
+     */
+    defaultLimit?: number;
+    /**
+     * Controlled value used to limit the number of rows shown on screen.
+     *
+     * Use together with `onLimitChange` to control the limit.
+     */
+    limit?: number;
+    /**
+     * Function called whenever the limit changes.
+     *
+     * @param limit New limit.
+     */
+    onLimitChange?: (limit: number) => void;
+    /** Default string to filter by. */
+    defaultFilter?: string;
+    /**
+     * Controlled string to filter by. Use together with `onFilterChange` to
+     * change the filter.
+     */
+    filter?: string;
+    /**
+     * Function called whenever the string to filter by changes.
+     *
+     * @param filter New filter.
+     */
+    onFilterChange?: (filter: string) => void;
+    /**
+     * Default column to sort by. When `null`, the table is sorted according to
+     * the rows' natural order.
+     *
+     * @default null
+     */
+    defaultSortBy?: string | null;
+    /**
+     * Controlled column to sort by. When `null`, the table is sorted according to
+     * the rows' natural order.
+     *
+     * Use together with `onSort` to change the sorting order.
+     */
+    sortBy?: string | null;
+    /** Default sort direction. */
+    defaultSortDirection?: SortDirection;
+    /**
+     * Controlled sort direction.
+     *
+     * Use together with `onSort` to change the sort direction.
+     */
+    sortDirection?: SortDirection;
+    /**
+     * Function called whenever the sorting of data changes.
+     *
+     * @param sortBy New column to sort by.
+     * @param sortDirection New direction to sort by.
+     */
+    onSort?: (sortBy: string | null, sortDirection: SortDirection) => void;
+    /**
+     * Prepend a column containing checkboxes used to select rows of the data
+     * table.
+     *
+     * @default false
+     */
+    showSelectionColumn?: boolean;
+    /** Default keys of the selected rows. */
+    defaultSelectedRows?: React.Key[];
+    /**
+     * Controlled keys of the selected rows.
+     *
+     * Use together with `onSelectedRowsChange` to change the selected rows.
+     */
+    selectedRows?: React.Key[];
+    /**
+     * Function called whenever the selected rows of the data table change.
+     *
+     * @param selectedRows Array containing the keys of the newly selected rows.
+     */
+    onSelectedRowsChange?: (selectedRows: React.Key[]) => void;
+    /**
+     * Function used to render each row. This function should typically return a
+     * `DataTableRow` with the provided properties. This function is useful to
+     * wrap each row in its own context.
+     *
+     * @default props => <DataTableRow {...props} />
+     * @param props Properties to pass to the data table row to render.
+     */
+    renderRow?: (props: DataTableRowProps) => React.ReactNode;
+    /**
+     * Function used to render each cell. This function should typically return a
+     * `DataTableCell` with the provided properties. This function is useful to
+     * wrap each cell in its own context.
+     *
+     * @default props => <DataTableCell {...props} />
+     * @param props Properties to pass to the data table cell to render.
+     */
+    renderCell?: (props: DataTableCellProps) => React.ReactNode;
+    /**
+     * Whether the height of each row should be computed dynamically (only
+     * relevant for scrolled mode).
+     *
+     * @default false
+     */
+    dynamicRowHeight?: boolean;
+    /**
+     * Estimated height of each table row.
+     *
+     * A function may be provided to return the actual or estimated height of each
+     * row.
+     *
+     * @default DEFAULT_TABLE_ROW_HEIGHT
+     */
+    estimatedRowHeight?: number | ((index: number) => number);
+    /**
+     * Number of items to render above and below the visible area (only relevant
+     * for scrolled mode).
+     *
+     * @default 5
+     */
+    overscan?: number;
+    /** Reference to interact with the data table's API. */
+    apiRef?: React.Ref<DataTableApi<T> | undefined>;
+}
+/**
+ * The `DataTable` component is the root component used for displaying a data
+ * table. It supports features such as different display modes (paged or
+ * scrolled), pagination, dynamic data loading, custom rows and cells, sorting,
+ * and filtering, allowing flexible data table functionality via configuration.
+ *
+ * It composes the following subcomponents:
+ *
+ * - `DataTableContent`: Represents the core content area of the `DataTable`,
+ *   containing the table itself, including its head and body. It is responsible
+ *   for rendering the main parts of the `DataTable`.
+ * - `DataTableFilter`: Implements filtering functionality, allowing users to
+ *   filter displayed data based on specific conditions.
+ * - `DataTablePagination`: Component responsible for handling the pagination
+ *   functionality of the `DataTable`. Allows control over which page of the
+ *   table to display (when in "paged" mode), or insight into the rows being
+ *   currently rendered (in "scrolled" mode).
+ * - `DataTableRowsPerPage`: Component which allows the user to control the
+ *   `limit` property of the `DataTable`, i.e. how many rows to display per page
+ *   in "paged" mode or how many rows to display at once in "scrolled" mode.
+ * - `DataTableRow`: Represents an individual row of the `DataTable`. This
+ *   component is only relevant when providing a custom data table row via
+ *   `renderRow`.
+ * - `DataTableCell`: Represents an individual cell of the `DataTable`. This
+ *   component is only relevant when providing a custom data table cell via
+ *   `renderCell`.
+ */
+export declare const DataTable: React.ForwardRefExoticComponent<DataTableProps<any> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/DataTable/DataTableApi.d.ts

@@ -0,0 +1,37 @@
+import { type ScrollToOptions } from "@tanstack/react-virtual";
+import * as React from "react";
+/** Options used when using the `goTo` function of the `DataTableApi`. */
+export type DataTableScrollToOptions = ScrollToOptions;
+/** Imperative data table API. */
+export interface DataTableApi<T = unknown> {
+    /**
+     * Function that provides a way of notifying that changes have been made to
+     * the table rows when using the `getRows`/`count` API. Either this function
+     * or `refresh` should be called after changing the table's `count`.
+     *
+     * @param startIndex Index of where to change started.
+     * @param deleteCount Number of rows deleted from `startIndex`. Defaults to
+     *   `0`.
+     * @param added Either the number of rows added, or an array with the added
+     *   rows themselves. Defaults to `0`.
+     */
+    splice: (startIndex: number, deleted?: number, added?: number | T[]) => void;
+    /**
+     * Refreshes the data table provided its new total count (if it changed).
+     *
+     * @param newTotalCount New total number of rows, in case it changed. Set to
+     *   `null` to specify that the new total count is unknown. Set to `undefined`
+     *   when the new total count shouldn't change.
+     */
+    refresh: (newTotalCount?: number | null) => void;
+    /**
+     * Navigates to the row with the provided index.
+     *
+     * @param index Index of row to navigate to.
+     * @param scrollOptions Options used to configure to scrolling to the row
+     *   (only relevant in scrolled display mode).
+     */
+    goTo: (index: number, scrollOptions?: DataTableScrollToOptions) => void;
+}
+/** Hook used to access the data table API. */
+export declare function useDataTableApiRef(): React.RefObject<DataTableApi | null>;

package/dist/types/components/DataTable/DataTableBody.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { TableBody } from "../Table";
+import { type DataTableContentProps } from "./DataTableContent.tsx";
+/** Properties of the data table foot component. */
+export interface DataTableBodyProps extends React.ComponentPropsWithoutRef<typeof TableBody>, Pick<DataTableContentProps, "emptyMessage" | "emptyMessageProps"> {
+    containerRef: React.MutableRefObject<HTMLDivElement | null>;
+}
+/** Body of the data table. */
+export declare const DataTableBody: React.ForwardRefExoticComponent<DataTableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTableCell.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { TableCell } from "../Table";
+/** Properties of a data table cell. */
+export interface DataTableCellProps extends React.ComponentPropsWithoutRef<typeof TableCell> {
+    columnLabel?: React.ReactNode;
+    columnLabelId?: string;
+}
+/** Data table cell. */
+export declare const DataTableCell: React.ForwardRefExoticComponent<DataTableCellProps & React.RefAttributes<HTMLTableDataCellElement>>;

package/dist/types/components/DataTable/DataTableColumn.d.ts

@@ -0,0 +1,70 @@
+import type * as React from "react";
+import { type MatchAgainstFilter } from "../../utils/filtering.ts";
+import { type TableColumn } from "../Table";
+/** Data table columns. */
+export type DataTableColumns<T = unknown> = Record<string, DataTableColumn<T>>;
+/** Data table column. */
+export interface DataTableColumn<T = unknown, TValue = any> extends Omit<React.ComponentPropsWithRef<typeof TableColumn>, "sorted" | "onSort"> {
+    /**
+     * Whether values of this column can be filtered.
+     *
+     * @default false
+     */
+    filterable?: boolean;
+    /**
+     * Locale of the formatted value.
+     *
+     * Used to perform locale-specific transformations (`toLocaleLowerCase`) on
+     * the formatted value when filtering.
+     */
+    locale?: string;
+    /** Sub columns of this column. */
+    subColumns?: DataTableColumns<T>;
+    /**
+     * Optional function used to get the value associated with this column from
+     * the row. The default getter uses the column identifier as a property to
+     * access the row.
+     */
+    getValue?: (getValueData: DataTableColumnGetValueData<T>) => TValue;
+    /**
+     * Function used to format the value as a string. Automatic filtering is based
+     * on this string. By default, `.toString()` is used.
+     */
+    format?: (formatData: DataTableColumnFormatData<T, TValue>) => string;
+    /**
+     * Function used to render the cell's content. By default, the formatted value
+     * is rendered, possibly highlighted when it matches the filter.
+     */
+    render?: (renderData: DataTableColumnRenderData<T, TValue>) => React.ReactNode;
+    /**
+     * Comparison function used when sorting values of this column. The default
+     * sorting function can handle primitive values and dates. When sorting other
+     * objects, their string representation is used in the comparison.
+     */
+    compare?: (value1: TValue, value2: TValue) => number;
+}
+/** Data passed to a data table column's `getValue` function. */
+export interface DataTableColumnGetValueData<T = unknown> {
+    /** Table row. */
+    row: T;
+    /** Index of the row. */
+    index: number;
+}
+/** Data passed to a data table column's `format` function. */
+export interface DataTableColumnFormatData<T = unknown, TValue = unknown> extends DataTableColumnGetValueData<T> {
+    /** Value to format. */
+    value: TValue;
+}
+/** Data passed to a data column's `render` function. */
+export interface DataTableColumnRenderData<T = unknown, TValue = unknown> extends DataTableColumnFormatData<T, TValue> {
+    /** Formatted value. */
+    formattedValue: string;
+    /** Match of the formatted value against the filter. */
+    match: MatchAgainstFilter | null;
+    /**
+     * Formatted value possibly marked by the filter. When the formatted value
+     * doesn't match the filter, this property will be the same as
+     * `formattedValue`.
+     */
+    markedValue: React.ReactNode;
+}

package/dist/types/components/DataTable/DataTableContent.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { Table, type TableBody, type TableFoot, type TableHead } from "../Table";
+/** Properties of the data table content component. */
+export interface DataTableContentProps extends Omit<React.ComponentPropsWithoutRef<typeof Table>, "layout"> {
+    /** Message to display when the data table contains no rows. */
+    emptyMessage?: React.ReactNode;
+    /** Content of the table foot component. */
+    tableFootContent?: React.ReactNode;
+    /**
+     * Whether the table foot show be shown when the data table is empty.
+     *
+     * @default false
+     */
+    showTableFootWhenEmpty?: boolean;
+    /** Properties to pass to the table head component. */
+    tableHeadProps?: React.ComponentPropsWithRef<typeof TableHead>;
+    /** Properties to pass to the table body component. */
+    tableBodyProps?: React.ComponentPropsWithRef<typeof TableBody>;
+    /** Properties to pass to the table foot component, when one exists. */
+    tableFootProps?: React.ComponentPropsWithRef<typeof TableFoot>;
+    /** Properties to pass to the component containing the empty message. */
+    emptyMessageProps?: React.ComponentPropsWithRef<"div">;
+}
+/**
+ * Component containing the "main content" of the data table, i.e. the table
+ * itself.
+ */
+export declare const DataTableContent: React.ForwardRefExoticComponent<DataTableContentProps & React.RefAttributes<HTMLTableElement>>;

package/dist/types/components/DataTable/DataTableContext.d.ts

@@ -0,0 +1,141 @@
+import * as React from "react";
+import { type SortDirection } from "../../utils/sorting.ts";
+import { type DataTableDisplayMode, type DataTableGetRowsOptions, type DataTableGetRowsResult } from "./DataTable.tsx";
+import { type DataTableApi } from "./DataTableApi.ts";
+import { type DataTableCellProps } from "./DataTableCell.tsx";
+import { type DataTableColumns } from "./DataTableColumn.tsx";
+import { type DataTableRowProps } from "./DataTableRow.tsx";
+/** Value of the data table context. */
+export interface DataTableContextValue<T = any> {
+    displayMode: DataTableDisplayMode;
+    rowKey: string | number | symbol | ((row: T) => React.Key);
+    required?: boolean;
+    showSelectionColumn: boolean;
+    renderRow?: (props: DataTableRowProps) => React.ReactNode;
+    renderCell?: (props: DataTableCellProps) => React.ReactNode;
+    dynamicRowHeight: boolean;
+    estimatedRowHeight: number | ((index: number) => number);
+    overscan: number;
+    generatedId: string;
+    apiRef?: React.Ref<DataTableApi<T> | undefined>;
+    store: DataTableStore<T>;
+}
+/** State of the data table. */
+export interface DataTableState<T = any> {
+    columns: DataTableColumns<T>;
+    leafColumns: DataTableColumns<T>;
+    headCount: number;
+    _rows?: T[];
+    _filteredRows: () => T[] | undefined;
+    transformedRows: () => T[] | undefined;
+    getRows?: (options: DataTableGetRowsOptions) => DataTableGetRowsResult<T> | PromiseLike<DataTableGetRowsResult<T>>;
+    loading: boolean;
+    loadingCount: number;
+    updateCounter: number;
+    ongoingGetRows?: {
+        from: number;
+        to: number;
+    };
+    abortController?: AbortController;
+    cachedRows?: Record<number, T | undefined>;
+    rowsWindow: (offset: number, limit: number) => (T | undefined)[];
+    _totalCount?: number;
+    totalCount: () => number | undefined;
+    bodyCount: () => number;
+    _offset: number;
+    offset: () => number;
+    currentPage: () => number;
+    pageOffset: () => number;
+    limit: number;
+    pageLimit: () => number | undefined;
+    filter: string;
+    sortBy: string | null;
+    sortDirection: SortDirection;
+    selectedRows: [Set<React.Key>];
+    scrolledRangeStart: number;
+    scrolledRangeEnd: number;
+    tableHeadHeight?: number;
+    tableFootHeight?: number;
+    actions: DataTableActions<T>;
+}
+/** Actions of the data table. */
+export interface DataTableActions<T> {
+    setGetRows: (getRows: DataTableState["getRows"]) => void;
+    setOffset: (offset: number) => void;
+    setLimit: (limit: number) => void;
+    setFilter: (filter: string) => void;
+    setSort: (sortBy: string | null, sortDirection: SortDirection) => void;
+    selectRows: (keys: React.Key[]) => void;
+    unselectRows: (keys: React.Key[]) => void;
+    updateWindow: (offset: number, limit: number) => void;
+    spliceWindow: (offset: number, limit: number, startIndex: number, deleted?: number, added?: number | T[]) => void;
+    refresh: (newTotalCount?: number | null) => void;
+}
+/** Data table store. */
+export type DataTableStore<T> = ReturnType<typeof useCreateDataTableContext<T>>["store"];
+/** Data table context. */
+export declare const DataTableContext: React.Context<DataTableContextValue<any> | null>;
+/** Options used to create the data table context value. */
+export interface UseCreateDataTableContextOptions<T> extends Omit<DataTableContextValue, "generatedId" | "store"> {
+    columns: DataTableColumns<T>;
+    leafColumns: DataTableColumns<T>;
+    headCount: number;
+    rows?: T[];
+    getRows?: (options: DataTableGetRowsOptions) => DataTableGetRowsResult<T> | PromiseLike<DataTableGetRowsResult<T>>;
+    loading: boolean;
+    loadingCount: number;
+    defaultOffset: number;
+    offset?: number;
+    onOffsetChange?: (offset: number) => void;
+    defaultLimit: number;
+    limit?: number;
+    onLimitChange?: (limit: number) => void;
+    defaultFilter: string;
+    filter?: string;
+    onFilterChange?: (filter: string) => void;
+    defaultSortBy: string | null;
+    sortBy?: string | null;
+    defaultSortDirection: SortDirection | undefined;
+    sortDirection?: SortDirection;
+    onSort?: (sortBy: string | null, sortDirection: SortDirection) => void;
+    showSelectionColumn: boolean;
+    defaultSelectedRows?: React.Key[];
+    selectedRows?: React.Key[];
+    onSelectedRowsChange?: (selectedRows: React.Key[]) => void;
+}
+/** Hook which creates the data table context value. */
+export declare function useCreateDataTableContext<T>({ displayMode, columns, rows, getRows, rowKey, loadingCount, required, loading, renderRow, renderCell, dynamicRowHeight, estimatedRowHeight, overscan, apiRef, leafColumns, headCount, defaultOffset, offset, onOffsetChange, defaultLimit, limit, onLimitChange, defaultFilter, filter, onFilterChange, defaultSortBy, sortBy, defaultSortDirection, sortDirection, onSort, showSelectionColumn, defaultSelectedRows, selectedRows, onSelectedRowsChange, }: UseCreateDataTableContextOptions<T>): {
+    displayMode: DataTableDisplayMode;
+    rowKey: string | number | symbol | ((row: any) => React.Key);
+    required: boolean | undefined;
+    showSelectionColumn: boolean;
+    renderRow: ((props: DataTableRowProps) => React.ReactNode) | undefined;
+    renderCell: ((props: DataTableCellProps) => React.ReactNode) | undefined;
+    dynamicRowHeight: boolean;
+    estimatedRowHeight: number | ((index: number) => number);
+    overscan: number;
+    generatedId: string;
+    apiRef: React.Ref<DataTableApi<any> | undefined> | undefined;
+    store: Omit<import("zustand").StoreApi<DataTableState<T>>, "subscribe"> & {
+        subscribe: {
+            (listener: (selectedState: DataTableState<T>, previousSelectedState: DataTableState<T>) => void): () => void;
+            <U>(selector: (state: DataTableState<T>) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+                equalityFn?: ((a: U, b: U) => boolean) | undefined;
+                fireImmediately?: boolean;
+            } | undefined): () => void;
+        };
+    };
+};
+/** Hook providing access to the data table context. */
+export declare function useDataTableContext<T = unknown>(): DataTableContextValue<T>;
+/** Context value of a data table cell. */
+export interface DataTableCellContextValue {
+    columnLabel?: React.ReactNode;
+    columnLabelId?: string;
+}
+/** Data table cell context. */
+export declare const DataTableCellContext: React.Context<DataTableCellContextValue | null>;
+/** Column label accessible within a data table cell. */
+export declare function useDataTableColumnLabel(): React.ReactNode;
+/** Column label id accessible within a data table cell. */
+export declare function useDataTableColumnLabelId(): string | null;

package/dist/types/components/DataTable/DataTableEmptyOrLoadingRows.d.ts

@@ -0,0 +1,9 @@
+import { type DataTableContentProps } from "./DataTableContent.tsx";
+/** Properties of the data table empty/loading row. */
+export interface DataTableEmptyOrLoadingRowProps extends Pick<DataTableContentProps, "emptyMessage" | "emptyMessageProps"> {
+}
+/**
+ * Data table rows displayed when the data table is either loading or has no
+ * rows.
+ */
+export declare function DataTableEmptyOrLoadingRows({ emptyMessage, emptyMessageProps, }: DataTableEmptyOrLoadingRowProps): import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];

package/dist/types/components/DataTable/DataTableFilter.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { Input } from "../Input";
+/** Properties of the data table filter component. */
+export interface DataTableFilterProps extends Omit<React.ComponentPropsWithoutRef<typeof Input>, "defaultValue" | "value"> {
+}
+/** Input used to globally filter a data table. */
+export declare const DataTableFilter: React.ForwardRefExoticComponent<DataTableFilterProps & React.RefAttributes<HTMLInputElement>>;

package/dist/types/components/DataTable/DataTableFoot.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { TableFoot } from "../Table";
+/** Properties of the data table foot component. */
+export interface DataTableFootProps extends React.ComponentPropsWithoutRef<typeof TableFoot> {
+    showWhenEmpty: boolean;
+}
+/** Foot of the data table. */
+export declare const DataTableFoot: React.ForwardRefExoticComponent<DataTableFootProps & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTableHead.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { TableHead } from "../Table";
+/** Properties of the data table head component. */
+export interface DataTableHeadProps extends React.ComponentPropsWithoutRef<typeof TableHead> {
+}
+/** Head of the data table. */
+export declare const DataTableHead: React.ForwardRefExoticComponent<DataTableHeadProps & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/DataTable/DataTablePagination.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+/** Properties of the data table pagination component. */
+export interface DataTablePaginationProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Function used to render the range of displayed rows.
+     *
+     * @param range Node representing the range of rows (note that, in paged mode,
+     *   this is a select).
+     * @param total Total number of rows.
+     */
+    rowsRange?: (range: React.ReactNode, total: number) => React.ReactNode;
+    /** Label of the previous page button (only relevant in paged mode). */
+    previousPageButtonLabel?: string;
+    /** Label of the next page button (only relevant in paged mode). */
+    nextPageButtonLabel?: string;
+}
+/** Component used to provide pagination to the data table. */
+export declare const DataTablePagination: React.ForwardRefExoticComponent<DataTablePaginationProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/DataTable/DataTableRow.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { TableRow } from "../Table";
+/** Properties of a data table row. */
+export interface DataTableRowProps<T = any> extends React.ComponentPropsWithoutRef<typeof TableRow> {
+    /** Row data. When `undefined`, the row is rendered as "loading". */
+    row: T | undefined;
+    /** Row index. */
+    index: number;
+}
+/** Data table row. */
+export declare const DataTableRow: React.NamedExoticComponent<DataTableRowProps<any> & React.RefAttributes<HTMLTableRowElement>>;