@algolia/satellite 1.0.0-beta.17 → 1.0.0-beta.170

package/esm/Tables/DataTable/DataTable.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from "react";
+import type { ColumnDefinition, DataConfiguration, GetItemId, PaginationConfiguration, Row, SelectMode, Sorting, Status } from "./types";
+declare type CanSelectItem<Item> = (item: Item, idx: number) => boolean;
+export declare type SortMode = "single" | "multi";
+export declare type DataTableLocale = {
+    selectAllButton?: string;
+    noDataTitle?: string;
+    noDataDescription?: string;
+    loadingTitle?: string;
+    loadingDescription?: string;
+    errorTitle?: string;
+    errorDescription?: string;
+};
+interface BaseDataTableProps<Item> {
+    /** The data which will be passed along to the table for rendering */
+    data: Item[];
+    /** Quite a few cases require you to specify the `itemID` which you can do using this prop */
+    itemId?: GetItemId<Item>;
+    /** The columns define the layout of your table and the respective rows and cells */
+    columns: ColumnDefinition<Item>[];
+    pagination?: PaginationConfiguration;
+    /** the `onChange` is triggered when either sorting or paginating */
+    onChange?(dataConfiguration: DataConfiguration): void;
+    /** Specify the global status of the table */
+    status?: Status;
+    /** Allows for specifying a custom empty state */
+    noDataContent?: ReactNode;
+    /** Allows for specifying a custom error state */
+    errorContent?: ReactNode;
+    canHoverRow?(row: Row<Item>): boolean;
+    onRowHoveredChanged?(row: Row<Item> | null): void;
+    sorting?: Sorting[];
+    sortMode?: SortMode;
+    locale?: DataTableLocale;
+}
+declare type DataTableWithSelectMode<Item> = {
+    selectMode: Exclude<SelectMode, "none">;
+    selection?: string[];
+    onSelectionChange?(rowId: string[]): void;
+    canSelectItem?: CanSelectItem<Item>;
+};
+declare type DataTableWithoutSelectMode = {
+    selectMode?: Extract<SelectMode, "none">;
+    selection?: never;
+    onSelectionChange?: never;
+    canSelectItem?: never;
+};
+export declare type DataTableProps<Item> = BaseDataTableProps<Item> & (DataTableWithSelectMode<Item> | DataTableWithoutSelectMode);
+/**
+ * Tables are used to structure content in a grid to make it easier to see relationships and to facilitate understanding.
+ *
+ * #### Do
+ *
+ * - Organize columns and rows based on the needs of your users. To help people read the table, order the columns by importance from left to right, with the key pieces of content opening the row
+ * - Include units of measurement symbols in the header so you don't need to repeat them throughout the columns
+ * - Indicate sorting capabilities of a column with a chevron in the cell header
+ * - Start by columns with highest value to the user, and continue with less important ones
+ *
+ * #### Do not
+ *
+ * - Center align text in cells
+ *
+ * ## Best practices
+ *
+ * - If a cell is empty or unavailable, keep the cell empty to reduce noise and help with legibility.
+ * - Truncate long text to make it fit into a cell. However, choose column width wisely based on expected values, and adjust the table accordingly
+ */
+export declare const DataTable: <Item extends {}>({ data, itemId, columns, onChange, status, noDataContent, errorContent, sorting, sortMode, pagination, selectMode, selection, onSelectionChange, canSelectItem, canHoverRow, onRowHoveredChanged, locale: propsLocale, }: DataTableProps<Item>) => JSX.Element;
+export default DataTable;

package/esm/Tables/DataTable/DataTable.js

@@ -0,0 +1,258 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import compact from "lodash/compact";
+import get from "lodash/get";
+import { useEffect, useState } from "react";
+import Checkbox from "../../Checkbox";
+import { RadioButton } from "../../RadioGroup";
+import { useLocale } from "../../Satellite";
+import stl from "../../styles/helpers/satellitePrefixer";
+import { toSentenceCase } from "../../utils";
+import Table from "../Table";
+import DataTableBody from "./components/Body";
+import DataTableFooter from "./components/Footer";
+import DataTableHeader from "./components/Header";
+import DataTableLoader from "./components/Loader";
+import { isDeterminatePagination, isIndeterminatePagination } from "./utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var DEFAULT_DATATABLE_LOCALE = {
+  selectAllButton: "Select all",
+  noDataTitle: "Empty",
+  noDataDescription: "There is no data to display",
+  loadingTitle: "It appears to be taking a while to get your data",
+  loadingDescription: "Please hold or try again later",
+  errorTitle: "Error",
+  errorDescription: "An error occurred while loading data."
+};
+
+// Selection
+
+var DEFAULT_GET_ITEM_ID = function DEFAULT_GET_ITEM_ID(_, idx) {
+  return String(idx);
+};
+
+/**
+ * Tables are used to structure content in a grid to make it easier to see relationships and to facilitate understanding.
+ *
+ * #### Do
+ *
+ * - Organize columns and rows based on the needs of your users. To help people read the table, order the columns by importance from left to right, with the key pieces of content opening the row
+ * - Include units of measurement symbols in the header so you don't need to repeat them throughout the columns
+ * - Indicate sorting capabilities of a column with a chevron in the cell header
+ * - Start by columns with highest value to the user, and continue with less important ones
+ *
+ * #### Do not
+ *
+ * - Center align text in cells
+ *
+ * ## Best practices
+ *
+ * - If a cell is empty or unavailable, keep the cell empty to reduce noise and help with legibility.
+ * - Truncate long text to make it fit into a cell. However, choose column width wisely based on expected values, and adjust the table accordingly
+ */
+export var DataTable = function DataTable(_ref) {
+  var data = _ref.data,
+    itemId = _ref.itemId,
+    columns = _ref.columns,
+    onChange = _ref.onChange,
+    _ref$status = _ref.status,
+    status = _ref$status === void 0 ? "success" : _ref$status,
+    noDataContent = _ref.noDataContent,
+    errorContent = _ref.errorContent,
+    _ref$sorting = _ref.sorting,
+    sorting = _ref$sorting === void 0 ? [] : _ref$sorting,
+    _ref$sortMode = _ref.sortMode,
+    sortMode = _ref$sortMode === void 0 ? "single" : _ref$sortMode,
+    _ref$pagination = _ref.pagination,
+    pagination = _ref$pagination === void 0 ? false : _ref$pagination,
+    _ref$selectMode = _ref.selectMode,
+    selectMode = _ref$selectMode === void 0 ? "none" : _ref$selectMode,
+    selection = _ref.selection,
+    onSelectionChange = _ref.onSelectionChange,
+    canSelectItem = _ref.canSelectItem,
+    canHoverRow = _ref.canHoverRow,
+    onRowHoveredChanged = _ref.onRowHoveredChanged,
+    propsLocale = _ref.locale;
+  var contextLocale = useLocale("dataTable");
+  var locale = _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_DATATABLE_LOCALE), contextLocale), propsLocale);
+  if (process.env.NODE_ENV !== "production") {
+    var _selection$length;
+    if (itemId === undefined && (sorting.length > 0 || selectMode !== "none")) {
+      console.warn("You did not provide a custom `itemId` function, but you have defined `sorting` and/or `selectMode`. This can lead to unexpected results.");
+    }
+    if (selectMode === "single" && ((_selection$length = selection === null || selection === void 0 ? void 0 : selection.length) !== null && _selection$length !== void 0 ? _selection$length : 0) > 1) {
+      console.warn("You can only have one selected item at a time in single `selectMode`.");
+    }
+  }
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    hoveredRowId = _useState2[0],
+    setHoveredRowId = _useState2[1];
+  useEffect(function () {
+    // Reset hovered row when data changes to avoid inconsistent state
+    setHoveredRowId(undefined);
+  }, [data]);
+  var computedColumns = compact([selectMode === "single" && {
+    id: "_internal_singleSelect",
+    accessor: "_internal_singleSelect",
+    Header: function Header() {
+      return /*#__PURE__*/_jsx("span", {
+        className: stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["sr-only"]))),
+        children: "Selected row"
+      });
+    },
+    Cell: function Cell(_ref2) {
+      var row = _ref2.row;
+      return /*#__PURE__*/_jsx("div", {
+        className: stl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["flex"]))),
+        children: /*#__PURE__*/_jsx(RadioButton, {
+          defaultChecked: row.selected,
+          disabled: !row.selectable,
+          className: stl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["", ""])), row.hovered || row.selected ? "opacity-100" : "opacity-0 select-none")
+        })
+      });
+    },
+    className: stl(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["w-3"])))
+  }, selectMode === "multi" && {
+    id: "_internal_multiSelect",
+    accessor: "_internal_multiSelect",
+    Header: function Header() {
+      var unselectableRows = rows.filter(function (row) {
+        return !row.selectable && row.selected;
+      }).map(function (r) {
+        return r.id;
+      });
+      var selectableRows = rows.filter(function (row) {
+        return row.selectable;
+      }).map(function (r) {
+        return r.id;
+      });
+      var selectionLength = (selection !== null && selection !== void 0 ? selection : []).length;
+      var dataLength = pagination ? pagination.itemsPerPage : data.length;
+      var isChecked = selectionLength === dataLength;
+      var isIndeterminate = selectionLength > 0 && selectionLength !== dataLength;
+      return /*#__PURE__*/_jsx(Checkbox, {
+        "aria-label": locale.selectAllButton,
+        checked: isChecked,
+        indeterminate: isIndeterminate,
+        onClick: function onClick() {
+          return isChecked ? onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(unselectableRows) : isIndeterminate ? onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange(selectionLength === selectableRows.length + unselectableRows.length ? unselectableRows : [].concat(_toConsumableArray(unselectableRows), _toConsumableArray(selectableRows))) : onSelectionChange === null || onSelectionChange === void 0 ? void 0 : onSelectionChange([].concat(_toConsumableArray(unselectableRows), _toConsumableArray(selectableRows)));
+        }
+      });
+    },
+    Cell: function Cell(_ref3) {
+      var row = _ref3.row;
+      return /*#__PURE__*/_jsx("div", {
+        className: stl(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["flex"]))),
+        children: /*#__PURE__*/_jsx(Checkbox, {
+          checked: row.selected,
+          disabled: !row.selectable,
+          className: stl(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["", ""])), row.hovered || row.selected ? "opacity-100" : "opacity-0 select-none")
+        })
+      });
+    },
+    className: stl(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["w-3"])))
+  }].concat(_toConsumableArray(columns.map(function (c) {
+    var _c$Header;
+    return typeof c === "string" ? {
+      id: c,
+      accessor: c,
+      Header: toSentenceCase(c)
+    } : _objectSpread(_objectSpread({}, c), {}, {
+      Header: (_c$Header = c.Header) !== null && _c$Header !== void 0 ? _c$Header : toSentenceCase(c.id)
+    });
+  }))));
+  var getItemIdInternal = itemId || DEFAULT_GET_ITEM_ID;
+  var rows = data.map(function (item, index) {
+    var _ref4;
+    var id = typeof getItemIdInternal === "string" ? String(get(item, getItemIdInternal, DEFAULT_GET_ITEM_ID(item, index))) : getItemIdInternal(item, index);
+    var hovered = hoveredRowId === id;
+    var sanitizedSelection = (_ref4 = selectMode === "single" ? selection === null || selection === void 0 ? void 0 : selection.slice(0, 1) : selectMode === "none" ? [] : selection) !== null && _ref4 !== void 0 ? _ref4 : [];
+    var selected = sanitizedSelection.includes(id);
+    var selectable = selectMode !== "none" && (!canSelectItem || canSelectItem(item, index));
+    return {
+      item: item,
+      id: id,
+      hovered: hovered,
+      selected: selected,
+      selectable: selectable
+    };
+  });
+  var internalSorting = computedColumns.map(function (c) {
+    var _sorting$find;
+    if (c.sort === undefined) return [c.id, "none"];
+    var columnDirection = (_sorting$find = sorting.find(function (_ref5) {
+      var _ref6 = _slicedToArray(_ref5, 1),
+        columnId = _ref6[0];
+      return columnId === c.id;
+    })) === null || _sorting$find === void 0 ? void 0 : _sorting$find[1];
+    if (columnDirection) return [c.id, columnDirection];
+    return [c.id, "desc"];
+  });
+  var shouldRenderPagination = function shouldRenderPagination() {
+    if (isDeterminatePagination(pagination)) return pagination && pagination.totalItemsCount > 0;
+    if (isIndeterminatePagination(pagination)) return pagination && data.length > 0;
+    return false;
+  };
+  var onRowHoverChange = function onRowHoverChange(row) {
+    setHoveredRowId(row === null || row === void 0 ? void 0 : row.id);
+    onRowHoveredChanged === null || onRowHoveredChanged === void 0 || onRowHoveredChanged(row);
+  };
+  var onToggleSort = function onToggleSort(columnId, direction) {
+    var newSorting = internalSorting.map(function (_ref7) {
+      var _ref8 = _slicedToArray(_ref7, 2),
+        colId = _ref8[0],
+        d = _ref8[1];
+      return columnId === colId ? [columnId, direction] : [colId, sortMode === "multi" ? d : "none"];
+    });
+    onChange === null || onChange === void 0 || onChange({
+      pagination: pagination,
+      sorting: newSorting
+    });
+  };
+  var handlePaginationChange = function handlePaginationChange(dataConfiguration) {
+    return onChange === null || onChange === void 0 ? void 0 : onChange(dataConfiguration);
+  };
+  return /*#__PURE__*/_jsxs("div", {
+    className: stl(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["relative"]))),
+    children: [status === "loading" && /*#__PURE__*/_jsx("div", {
+      className: stl(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["absolute bg-white/50 z-10 w-full h-full flex items-center justify-center"]))),
+      children: /*#__PURE__*/_jsx(DataTableLoader, {
+        className: stl(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["-mt-12"]))),
+        locale: locale
+      })
+    }), /*#__PURE__*/_jsxs(Table, {
+      className: stl(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["datatable ", " ", ""])), status === "loading" && "pointer-events-none select-none", status === "loading" && data.length === 0 && "h-48"),
+      highlight: false,
+      footer: shouldRenderPagination() && /*#__PURE__*/_jsx(DataTableFooter, {
+        pagination: pagination,
+        onChange: handlePaginationChange
+      }),
+      children: [/*#__PURE__*/_jsx(DataTableHeader, {
+        disabled: status !== "success" || rows.length === 0,
+        columns: computedColumns,
+        onToggleSort: onToggleSort,
+        sorting: internalSorting
+      }), /*#__PURE__*/_jsx(DataTableBody, {
+        rows: rows,
+        columns: computedColumns,
+        status: status,
+        noDataContent: noDataContent,
+        errorContent: errorContent,
+        selectMode: selectMode,
+        selection: selection,
+        canHoverRow: canHoverRow,
+        onRowHoverChange: onRowHoverChange,
+        onSelectionChange: onSelectionChange,
+        locale: locale
+      })]
+    })]
+  });
+};
+export default DataTable;

package/esm/Tables/DataTable/DataTable.tailwind.d.ts

@@ -0,0 +1,5 @@
+export = datatablePlugin;
+declare const datatablePlugin: {
+    handler: import("tailwindcss/types/config").PluginCreator;
+    config?: Partial<import("tailwindcss/types/config").Config> | undefined;
+};

package/esm/Tables/DataTable/DataTable.tailwind.js

@@ -0,0 +1,22 @@
+import _plugin from "tailwindcss/plugin";
+// purgecss whitelist: th, td, tr
+
+var plugin = _plugin;
+var datatablePlugin = plugin(function (_ref) {
+  var addComponents = _ref.addComponents,
+    theme = _ref.theme;
+  addComponents({
+    ".datatable": {
+      th: {
+        padding: "0 !important"
+      },
+      "tr.row-disabled td": {
+        cursor: "not-allowed"
+      },
+      "tr:not(.row-disabled):hover td": {
+        backgroundColor: theme("colors.grey.50")
+      }
+    }
+  });
+});
+export default datatablePlugin;

package/esm/Tables/DataTable/components/Body.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+import type { DataTableLocale, DataTableProps } from "../DataTable";
+import type { AdvancedColumnDefinition, Row, SelectMode, Status } from "../types";
+export interface BodyProps<Item> extends Pick<DataTableProps<Item>, "selection" | "onSelectionChange" | "canHoverRow"> {
+    rows: Row<Item>[];
+    status?: Status;
+    noDataContent?: ReactNode;
+    errorContent?: ReactNode;
+    columns: AdvancedColumnDefinition<Item>[];
+    onRowHoverChange(row: Row<Item> | null): void;
+    selectMode: SelectMode;
+    locale: Required<DataTableLocale>;
+}
+export declare const Body: <Item extends {}>({ rows, columns, status, noDataContent, errorContent, selectMode, selection, onSelectionChange, onRowHoverChange, canHoverRow, locale, }: BodyProps<Item>) => JSX.Element;
+export default Body;

package/esm/Tables/DataTable/components/Body.js

@@ -0,0 +1,112 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+var _templateObject, _templateObject2, _templateObject3;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import EmptyState from "../../../EmptyState";
+import stl from "../../../styles/helpers/satellitePrefixer";
+import { getCellValue } from "../utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+export var Body = function Body(_ref) {
+  var rows = _ref.rows,
+    columns = _ref.columns,
+    status = _ref.status,
+    noDataContent = _ref.noDataContent,
+    errorContent = _ref.errorContent,
+    selectMode = _ref.selectMode,
+    _ref$selection = _ref.selection,
+    selection = _ref$selection === void 0 ? [] : _ref$selection,
+    onSelectionChange = _ref.onSelectionChange,
+    onRowHoverChange = _ref.onRowHoverChange,
+    _ref$canHoverRow = _ref.canHoverRow,
+    canHoverRow = _ref$canHoverRow === void 0 ? function () {
+      return true;
+    } : _ref$canHoverRow,
+    locale = _ref.locale;
+  var handleRowSelection = function handleRowSelection(row) {
+    if (!onSelectionChange) return;
+    var rowId = row.id;
+    var isSelected = selection.includes(rowId);
+    var newSelection = isSelected ? selection.filter(function (id) {
+      return id !== rowId;
+    }) : selectMode === "multi" ? [].concat(_toConsumableArray(selection), [rowId]) : [rowId];
+    onSelectionChange(newSelection);
+  };
+  var additionalRowProps = function additionalRowProps(row) {
+    return _objectSpread(_objectSpread({}, canHoverRow(row) ? {
+      onMouseEnter: function onMouseEnter() {
+        return onRowHoverChange(row);
+      },
+      onMouseLeave: function onMouseLeave() {
+        return onRowHoverChange(null);
+      },
+      className: "hoverable"
+    } : {
+      className: stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["row-disabled"])))
+    }), row.selectable && {
+      onClick: function onClick() {
+        return handleRowSelection(row);
+      }
+    });
+  };
+  if (status === "error") {
+    return /*#__PURE__*/_jsx("tbody", {
+      children: /*#__PURE__*/_jsx("tr", {
+        children: /*#__PURE__*/_jsx("td", {
+          colSpan: columns.length,
+          children: /*#__PURE__*/_jsx("span", {
+            className: stl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["flex justify-center py-6"]))),
+            children: errorContent || /*#__PURE__*/_jsx(EmptyState, {
+              title: locale.errorTitle,
+              description: locale.errorDescription,
+              centered: true,
+              usageContext: "result"
+            })
+          })
+        })
+      })
+    });
+  }
+  if (rows.length === 0 && status !== "loading") {
+    return /*#__PURE__*/_jsx("tbody", {
+      children: /*#__PURE__*/_jsx("tr", {
+        children: /*#__PURE__*/_jsx("td", {
+          colSpan: columns.length,
+          children: /*#__PURE__*/_jsx("span", {
+            className: stl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["flex justify-center py-6"]))),
+            children: noDataContent || /*#__PURE__*/_jsx(EmptyState, {
+              title: locale.noDataTitle,
+              description: locale.noDataDescription,
+              centered: true,
+              usageContext: "result"
+            })
+          })
+        })
+      })
+    });
+  }
+  return /*#__PURE__*/_jsx("tbody", {
+    children: rows.map(function (row, rowIndex) {
+      return /*#__PURE__*/_createElement("tr", _objectSpread(_objectSpread({}, additionalRowProps(row)), {}, {
+        key: rowIndex
+      }), columns.map(function (column) {
+        var value = getCellValue(column, row);
+        var Cell = column.Cell;
+        return Cell ? /*#__PURE__*/_jsx("td", {
+          className: column === null || column === void 0 ? void 0 : column.className,
+          children: /*#__PURE__*/_jsx(Cell, {
+            row: rows[rowIndex],
+            column: column,
+            value: value
+          })
+        }, column.id) : /*#__PURE__*/_jsx("td", {
+          className: column === null || column === void 0 ? void 0 : column.className,
+          children: value !== null && value !== void 0 ? value : "-"
+        }, column.id);
+      }));
+    })
+  });
+};
+export default Body;

package/esm/Tables/DataTable/components/Footer.d.ts

@@ -0,0 +1,8 @@
+import type { VFC } from "react";
+import type { DataConfiguration, PaginationConfiguration } from "../types";
+export interface FooterProps {
+    pagination: PaginationConfiguration;
+    onChange(dataConfiguration: DataConfiguration): void;
+}
+export declare const Footer: VFC<FooterProps>;
+export default Footer;

package/esm/Tables/DataTable/components/Footer.js

@@ -0,0 +1,53 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import Pagination, { CompactPagination } from "../../../Pagination";
+import { isDeterminatePagination, isIndeterminatePagination } from "../utils";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var Footer = function Footer(_ref) {
+  var pagination = _ref.pagination,
+    onChange = _ref.onChange;
+  return isDeterminatePagination(pagination) ? /*#__PURE__*/_jsx(Pagination, {
+    nbPages: Math.ceil(pagination.totalItemsCount / pagination.itemsPerPage),
+    currentPage: pagination.currentPage,
+    maxButtons: 8,
+    onChange: function (_onChange) {
+      function onChange(_x) {
+        return _onChange.apply(this, arguments);
+      }
+      onChange.toString = function () {
+        return _onChange.toString();
+      };
+      return onChange;
+    }(function (page) {
+      return onChange({
+        pagination: _objectSpread(_objectSpread({}, pagination), {}, {
+          currentPage: page
+        }),
+        sorting: []
+      });
+    })
+  }) : isIndeterminatePagination(pagination) ? /*#__PURE__*/_jsx(CompactPagination, {
+    label: "compact",
+    currentPage: pagination.currentPage,
+    showGoToFirstPage: true,
+    nextDisabled: pagination.isLastPage,
+    onChange: function (_onChange2) {
+      function onChange(_x2) {
+        return _onChange2.apply(this, arguments);
+      }
+      onChange.toString = function () {
+        return _onChange2.toString();
+      };
+      return onChange;
+    }(function (page) {
+      return onChange({
+        pagination: _objectSpread(_objectSpread({}, pagination), {}, {
+          currentPage: page
+        }),
+        sorting: []
+      });
+    })
+  }) : null;
+};
+export default Footer;

package/esm/Tables/DataTable/components/Header.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { AdvancedColumnDefinition, Sorting, SortingDirection } from "../types";
+export interface HeaderProps<Item> {
+    columns: AdvancedColumnDefinition<Item>[];
+    sorting?: Sorting[];
+    onToggleSort: (columnId: string, direction: SortingDirection) => void;
+    disabled?: boolean;
+}
+export declare const Header: <Item extends {}>({ columns, sorting, onToggleSort, disabled }: HeaderProps<Item>) => JSX.Element;
+export default Header;

package/esm/Tables/DataTable/components/Header.js

@@ -0,0 +1,32 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import HeaderCell from "./HeaderCell";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var Header = function Header(_ref) {
+  var columns = _ref.columns,
+    _ref$sorting = _ref.sorting,
+    sorting = _ref$sorting === void 0 ? [] : _ref$sorting,
+    onToggleSort = _ref.onToggleSort,
+    disabled = _ref.disabled;
+  return /*#__PURE__*/_jsx("thead", {
+    children: /*#__PURE__*/_jsx("tr", {
+      children: columns.map(function (column) {
+        var Header = column.Header;
+        var sortingDirection = sorting.find(function (_ref2) {
+          var _ref3 = _slicedToArray(_ref2, 1),
+            colId = _ref3[0];
+          return colId === column.id;
+        }) || [null];
+        return /*#__PURE__*/_jsx(HeaderCell, {
+          column: column,
+          disabled: disabled,
+          sortingDirection: sortingDirection[1],
+          onToggleSort: onToggleSort,
+          children: !Header ? null : typeof Header === "string" ? Header : /*#__PURE__*/_jsx(Header, {
+            column: column
+          })
+        }, column.id);
+      })
+    })
+  });
+};
+export default Header;

package/esm/Tables/DataTable/components/HeaderCell.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import type { AdvancedColumnDefinition, SortingDirection } from "../types";
+export interface HeaderCellProps<Item> extends HTMLAttributes<HTMLTableCellElement> {
+    column: AdvancedColumnDefinition<Item>;
+    disabled?: boolean;
+    isSortingEnabled?: boolean;
+    sortingDirection?: SortingDirection;
+    onToggleSort: (columnId: string, sortingDirection: SortingDirection) => void;
+    children: ReactNode;
+}
+export declare const HeaderCell: <Item extends {}>({ sortingDirection, onToggleSort, column: { id, className, sort }, disabled, children, ...props }: HeaderCellProps<Item>) => JSX.Element;
+export default HeaderCell;

package/esm/Tables/DataTable/components/HeaderCell.js

@@ -0,0 +1,52 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _excluded = ["sortingDirection", "onToggleSort", "column", "disabled", "children"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import cx from "clsx";
+import { ChevronDown, ChevronUp } from "react-feather";
+import stl from "../../../styles/helpers/satellitePrefixer";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var iconClassName = stl(_templateObject || (_templateObject = _taggedTemplateLiteral(["h-4 inline ml-1"])));
+export var HeaderCell = function HeaderCell(_ref) {
+  var _ref$sortingDirection = _ref.sortingDirection,
+    sortingDirection = _ref$sortingDirection === void 0 ? "none" : _ref$sortingDirection,
+    onToggleSort = _ref.onToggleSort,
+    _ref$column = _ref.column,
+    id = _ref$column.id,
+    className = _ref$column.className,
+    _ref$column$sort = _ref$column.sort,
+    sort = _ref$column$sort === void 0 ? false : _ref$column$sort,
+    disabled = _ref.disabled,
+    children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var InternalCellComponent = sort && !disabled ? "button" : "span";
+  var handleSorting = function handleSorting() {
+    if (disabled) return;
+    onToggleSort(id, sortingDirection === "desc" ? "asc" : sortingDirection === "asc" ? "none" : "desc");
+  };
+  var sortButtonProps = sort ? {
+    onClick: function onClick() {
+      return handleSorting();
+    },
+    className: disabled ? stl(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["cursor-not-allowed"]))) : stl(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["cursor-pointer"])))
+  } : {};
+  return /*#__PURE__*/_jsx("th", _objectSpread(_objectSpread({}, props), {}, {
+    "aria-sort": sortingDirection === "desc" ? "descending" : sortingDirection === "asc" ? "ascending" : "none",
+    className: className,
+    children: /*#__PURE__*/_jsxs(InternalCellComponent, _objectSpread(_objectSpread({}, sortButtonProps), {}, {
+      className: cx(stl(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["group/cell px-4 py-[14px] inline-flex items-center focus:outline-none focus:text-accent-600"]))), sortButtonProps.className),
+      children: [children, sort ? sortingDirection === "desc" ? /*#__PURE__*/_jsx(ChevronDown, {
+        className: iconClassName
+      }) : sortingDirection === "asc" ? /*#__PURE__*/_jsx(ChevronUp, {
+        className: iconClassName
+      }) : /*#__PURE__*/_jsx(ChevronDown, {
+        className: cx(iconClassName, stl(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["text-grey-300 invisible group-hover/cell:visible group-focus/cell:visible"]))))
+      }) : null]
+    }))
+  }));
+};
+export default HeaderCell;