@hitachivantara/uikit-react-lab 3.38.0

package/dist/Table/hooks/useTable.d.ts

@@ -0,0 +1,336 @@
+/* eslint-disable no-use-before-define */
+import {
+  Cell,
+  CellPropGetter,
+  CellProps,
+  ColumnInstance,
+  ColumnInterface,
+  FooterPropGetter,
+  HeaderPropGetter,
+  HeaderProps,
+  Hooks,
+  PluginHook,
+  Renderer,
+  Row,
+  RowPropGetter,
+  TableCellProps,
+  TableFooterProps,
+  TableHeaderProps,
+  TableInstance,
+  TableOptions,
+  TablePropGetter,
+  TableProps,
+  TableRowProps,
+  TableState,
+  UseColumnOrderInstanceProps,
+  UseColumnOrderState,
+  UseExpandedHooks,
+  UseExpandedInstanceProps,
+  UseExpandedOptions,
+  UseExpandedState,
+  UseFiltersColumnOptions,
+  UseFiltersColumnProps,
+  UseFiltersInstanceProps,
+  UseFiltersOptions,
+  UseFiltersState,
+  UseGlobalFiltersInstanceProps,
+  UseGlobalFiltersOptions,
+  UseGlobalFiltersState,
+  UseGroupByCellProps,
+  UseGroupByColumnOptions,
+  UseGroupByColumnProps,
+  UseGroupByHooks,
+  UseGroupByInstanceProps,
+  UseGroupByOptions,
+  UseGroupByRowProps,
+  UseGroupByState,
+  UsePaginationInstanceProps,
+  UsePaginationOptions,
+  UsePaginationState,
+  UseResizeColumnsColumnOptions,
+  UseResizeColumnsColumnProps,
+  UseResizeColumnsOptions,
+  UseResizeColumnsState,
+  UseSortByColumnOptions,
+  UseSortByColumnProps,
+  UseSortByHooks,
+  UseSortByInstanceProps,
+  UseSortByOptions,
+  UseSortByState,
+} from "react-table";
+
+import {
+  UseHvTableStylesTableOptions,
+  UseHvTableStylesColumnOptions,
+  UseHvTableStylesTableCellProps,
+  UseHvTableStylesTableRowProps,
+} from "./useTableStyles";
+import {
+  UseHvTableStickyCellProps,
+  UseHvTableStickyColumnProps,
+  UseHvTableStickyHooks,
+  UseHvTableStickyTableInstance,
+  UseHvTableStickyTableOptions,
+  UseHvTableStickyTableProps,
+} from "./useSticky";
+import { UseHvSortByColumnProps, UseHvSortByTableCellProps } from "./useSortBy";
+import {
+  UseHvRowSelectionHooks,
+  UseHvRowSelectionRowInstance,
+  UseHvRowSelectionState,
+  UseHvRowSelectionTableInstance,
+  UseHvRowSelectionTableOptions,
+  UseHvRowSelectionTableRowProps,
+} from "./useRowSelection";
+import { UseHvPaginationHooks, UseHvPaginationTableInstance } from "./usePagination";
+import {
+  UseHvBulkActionsHooks,
+  UseHvBulkActionsTableInstanceProps,
+  UseHvBulkActionsTableOptions,
+} from "./useBulkActions";
+import {
+  UseHvRowExpandTableOptions,
+  UseHvRowExpandRowInstance,
+  UseHvRowExpandTableRowProps,
+} from "./useRowExpand";
+import {
+  UseHvHeaderGroupsColumnProps,
+  UseHvHeaderGroupsCellProps,
+  UseHvHeaderGroupsInstance,
+} from "./useHeaderGroups";
+import { UseHvResizeColumnProps, UseHvResizeTableCellProps } from "./useResizeColumns";
+
+type Accessor<D extends object> = (
+  originalRow: D,
+  index: number,
+  sub: {
+    subRows: D[];
+    depth: number;
+    data: D[];
+  }
+) => CellValue;
+
+type StringKey<D> = Extract<keyof D, string>;
+type IdType<D> = StringKey<D> | string;
+type CellValue<V = any> = V;
+
+interface HvColumnInterfaceBasedOnValue<D extends object = Record<string, unknown>, V = any> {
+  Cell?: Renderer<HvCellProps<D, V>>;
+}
+
+interface HvColumnGroupInterface<D extends object> {
+  columns: Array<HvTableColumnConfig<D>>;
+}
+
+type HvColumnGroup<D extends object = Record<string, unknown>> = HvTableColumnOptions<D> &
+  HvColumnGroupInterface<D> &
+  (
+    | { Header: string }
+    | ({ id: IdType<D> } & {
+        Header: Renderer<HeaderProps<D>>;
+      })
+  ) & { accessor?: Accessor<D> }; // Not used, but needed for backwards compatibility
+
+type ValueOf<T> = T[keyof T];
+
+// The accessors like `foo.bar` are not supported, use functions instead
+type HvColumnWithStrictAccessor<D extends object = Record<string, unknown>> =
+  HvTableColumnOptions<D> &
+    ValueOf<{
+      [K in keyof D]: {
+        accessor: K;
+      } & HvColumnInterfaceBasedOnValue<D, D[K]>;
+    }>;
+
+type HvColumnWithLooseAccessor<D extends object = Record<string, unknown>> =
+  HvTableColumnOptions<D> &
+    HvColumnInterfaceBasedOnValue<D> &
+    (
+      | { Header: string }
+      | { id: IdType<D> }
+      | { accessor: keyof D extends never ? IdType<D> : never }
+    ) & { accessor?: keyof D extends never ? IdType<D> | Accessor<D> : Accessor<D> };
+
+export type HvCellProps<D extends object, V = any> = CellProps<D, V> & {
+  column: HvColumnInstance<D>;
+  row: HvRowInstance<D>;
+  cell: HvCellInstance<D, V>;
+};
+
+export type HvTableDefinitionConfig<D extends object = Record<string, unknown>> = HvTableOptions<D>;
+
+export type HvTableColumnConfig<D extends object = Record<string, unknown>> =
+  | HvColumnGroup<D>
+  | HvColumnWithLooseAccessor<D>
+  | HvColumnWithStrictAccessor<D>;
+
+// #region HOOKS
+export interface HvHooks<D extends object = Record<string, unknown>>
+  extends Hooks<D>,
+    UseExpandedHooks<D>,
+    UseGroupByHooks<D>,
+    UseSortByHooks<D>,
+    UseHvRowSelectionHooks<D>,
+    UseHvTableStickyHooks<D>,
+    UseHvPaginationHooks<D>,
+    UseHvBulkActionsHooks<D> {}
+// #endregion
+
+// #region STATE
+export interface HvTableState<D extends object = Record<string, unknown>>
+  extends TableState<D>,
+    UseColumnOrderState<D>,
+    UseExpandedState<D>,
+    UseFiltersState<D>,
+    UseGlobalFiltersState<D>,
+    UseGroupByState<D>,
+    UsePaginationState<D>,
+    UseResizeColumnsState<D>,
+    UseSortByState<D>,
+    UseHvRowSelectionState<D> {
+  rowCount: number;
+}
+// #endregion
+
+// #region OPTIONS
+export interface HvTableOptions<D extends object>
+  extends Omit<TableOptions<D>, "columns" | "data">,
+    UseExpandedOptions<D>,
+    UseFiltersOptions<D>,
+    UseFiltersOptions<D>,
+    UseGlobalFiltersOptions<D>,
+    UseGroupByOptions<D>,
+    UsePaginationOptions<D>,
+    UseResizeColumnsOptions<D>,
+    UseSortByOptions<D>,
+    UseHvTableStylesTableOptions,
+    UseHvRowSelectionTableOptions,
+    UseHvTableStickyTableOptions,
+    UseHvBulkActionsTableOptions,
+    UseHvRowExpandTableOptions {
+  columns?: Array<HvTableColumnConfig<D>>;
+  data?: D[];
+
+  initialState?: Partial<HvTableState<D>>;
+
+  labels?: Record<string, string>;
+}
+
+export interface HvTableColumnOptions<D extends object = Record<string, unknown>>
+  extends ColumnInterface<D>,
+    UseFiltersColumnOptions<D>,
+    UseGroupByColumnOptions<D>,
+    UseResizeColumnsColumnOptions<D>,
+    UseSortByColumnOptions<D>,
+    UseHvTableStylesColumnOptions {}
+// #endregion
+
+// #region INSTANCE
+export interface HvTableInstance<D extends object = Record<string, unknown>>
+  extends TableInstance<D>,
+    Omit<HvTableOptions<D>, "columns" | "pageCount" | "initialState" | "data">,
+    UseColumnOrderInstanceProps<D>,
+    UseExpandedInstanceProps<D>,
+    UseFiltersInstanceProps<D>,
+    UseGlobalFiltersInstanceProps<D>,
+    UseGroupByInstanceProps<D>,
+    UsePaginationInstanceProps<D>,
+    UseSortByInstanceProps<D>,
+    UseHvRowSelectionTableInstance<D>,
+    UseHvTableStickyTableInstance<D>,
+    UseHvHeaderGroupsInstance,
+    UseHvPaginationTableInstance<D>,
+    UseHvBulkActionsTableInstanceProps<D> {
+  initialState: Partial<HvTableState<D>>;
+  state: HvTableState<D>;
+  columns: Array<HvColumnInstance<D>>;
+  allColumns: Array<HvColumnInstance<D>>;
+  visibleColumns: Array<HvColumnInstance<D>>;
+  headers: Array<HvColumnInstance<D>>;
+  flatHeaders: Array<HvColumnInstance<D>>;
+  rows: Array<HvRowInstance<D>>;
+  page: Array<HvRowInstance<D>>;
+  rowsById: Record<string, HvRowInstance<D>>;
+  flatRows: Array<HvRowInstance<D>>;
+  getHooks: () => HvHooks<D>;
+  getTableProps: (propGetter?: TablePropGetter<D>) => HvTableProps;
+  selectedFlatRows: Array<HvRowInstance<D>>;
+
+  initialRows: Array<HvRowInstance<D>>;
+  initialRowsById: Record<string, HvRowInstance<D>>;
+
+  labels: Record<string, string>;
+}
+
+export interface HvColumnInstance<D extends object = Record<string, unknown>>
+  extends ColumnInstance<D>,
+    Omit<HvTableColumnOptions<D>, "id">,
+    UseFiltersColumnProps<D>,
+    UseGroupByColumnProps<D>,
+    UseResizeColumnsColumnProps<D>,
+    UseSortByColumnProps<D> {
+  Cell?: Renderer<HvCellProps<D>>;
+  columns: Array<HvColumnInstance<D>>;
+  parent: HvColumnInstance<D>; // not documented
+  placeholderOf?: HvColumnInstance;
+  getHeaderProps: (propGetter?: HeaderPropGetter<D>) => HvTableHeaderProps;
+  getFooterProps: (propGetter?: FooterPropGetter<D>) => HvTableFooterProps;
+}
+
+export interface HvRowInstance<D extends object = Record<string, unknown>>
+  extends Row<D>,
+    UseGroupByRowProps<D>,
+    UseHvRowSelectionRowInstance,
+    UseHvRowExpandRowInstance<D> {
+  cells: Array<HvCellInstance<D>>;
+  allCells: Array<HvCellInstance<D>>;
+  getRowProps: (propGetter?: RowPropGetter<D>) => HvTableRowProps;
+  index: number;
+  original: D;
+  id: string;
+  subRows: Array<HvRowInstance<D>>;
+}
+
+export interface HvCellInstance<D extends object = Record<string, unknown>, V = any>
+  extends Cell<D, V>,
+    UseGroupByCellProps<D> {
+  column: HvColumnInstance<D>;
+  row: HvRowInstance<D>;
+  getCellProps: (propGetter?: CellPropGetter<D>) => HvTableCellProps;
+}
+// #endregion
+
+// #region PROPS
+export interface HvTableProps extends TableProps, UseHvTableStickyTableProps {}
+
+export interface HvTableHeaderProps
+  extends TableHeaderProps,
+    UseHvTableStylesTableCellProps,
+    UseHvTableStickyColumnProps,
+    UseHvHeaderGroupsColumnProps,
+    UseHvResizeColumnProps,
+    UseHvSortByColumnProps {}
+export interface HvTableFooterProps extends TableFooterProps, UseHvTableStylesTableCellProps {}
+
+export interface HvTableRowProps
+  extends TableRowProps,
+    UseHvTableStylesTableRowProps,
+    UseHvRowSelectionTableRowProps,
+    UseHvRowExpandTableRowProps {}
+
+export interface HvTableCellProps
+  extends TableCellProps,
+    UseHvTableStylesTableCellProps,
+    UseHvTableStickyCellProps,
+    UseHvHeaderGroupsCellProps,
+    UseHvResizeTableCellProps,
+    UseHvSortByTableCellProps {}
+
+// #endregion
+
+export default function useHvTable<D extends object = Record<string, unknown>>(
+  options: HvTableOptions<D>,
+  ...plugins: Array<PluginHook<D>>
+): HvTableInstance<D>;
+
+export { PluginHook as HvTablePluginHook };

package/dist/Table/hooks/useTable.js

@@ -0,0 +1,156 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+require("core-js/modules/es.string.trim.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.replace.js");
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.array.includes.js");
+
+require("core-js/modules/es.array.find-index.js");
+
+require("core-js/modules/es.array.splice.js");
+
+var _react = require("react");
+
+var _reactTable = require("react-table");
+
+var _useTableStyles = _interopRequireDefault(require("./useTableStyles"));
+
+var _excluded = ["data", "columns"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var toTitleCase = function toTitleCase(str) {
+  return str.replace(/([^A-Z])([A-Z])/g, "$1 $2") // split cameCase
+  .replace(/[_-]+/g, " ") // split snake_case and lisp-case
+  .toLowerCase().replace(/(^\w|\b\w)/g, function (m) {
+    return m.toUpperCase();
+  }) // title case words
+  .replace(/\s+/g, " ") // collapse repeated whitespace
+  .trim(); // remove leading/trailing whitespace
+};
+
+var useDefaultData = function useDefaultData(data) {
+  return (0, _react.useMemo)(function () {
+    return data || [];
+  }, [data]);
+};
+
+var useDefaultColumns = function useDefaultColumns(columns, data) {
+  return (0, _react.useMemo)(function () {
+    if (columns != null) {
+      return columns;
+    }
+
+    var uniqueKeys = Object.keys(_extends2.default.apply(void 0, [{}].concat((0, _toConsumableArray2.default)(data))));
+    return uniqueKeys.filter(function (key) {
+      return !["subRows", "subComponent"].includes(key);
+    }).map(function (key) {
+      return {
+        accessor: key,
+        Header: toTitleCase(key)
+      };
+    });
+  }, [columns, data]);
+};
+
+var ensureCorePluginInstallation = function ensureCorePluginInstallation(plugins, hvPluginName, corePluginToInstall) {
+  var indexOfCorePlugin = plugins.findIndex(function (plugin) {
+    return plugin.pluginName === corePluginToInstall.pluginName;
+  });
+  var indexOfHvPlugin = plugins.findIndex(function (plugin) {
+    return plugin.pluginName === hvPluginName;
+  });
+
+  if (indexOfHvPlugin !== -1 && (indexOfCorePlugin === -1 || indexOfCorePlugin > indexOfHvPlugin)) {
+    if (indexOfCorePlugin > -1) {
+      plugins.splice(indexOfCorePlugin, 1);
+    }
+
+    plugins.splice(indexOfHvPlugin, 0, corePluginToInstall);
+  }
+};
+
+var useInstanceHook = function useInstanceHook(instance) {
+  var rowsById = instance.rowsById;
+  (0, _extends2.default)(instance, {
+    initialRowsById: rowsById
+  });
+};
+
+var useHvTableSetup = function useHvTableSetup(hooks) {
+  hooks.useInstance.push(useInstanceHook);
+};
+
+useHvTableSetup.pluginName = "useHvTableSetup";
+
+var useHvTable = function useHvTable(props) {
+  var dataProp = props.data,
+      columnsProp = props.columns,
+      others = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var data = useDefaultData(dataProp);
+  var columns = useDefaultColumns(columnsProp, data);
+
+  for (var _len = arguments.length, plugins = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    plugins[_key - 1] = arguments[_key];
+  }
+
+  ensureCorePluginInstallation(plugins, "useHvPagination", _reactTable.usePagination);
+  ensureCorePluginInstallation(plugins, "useHvRowExpand", _reactTable.useExpanded);
+  ensureCorePluginInstallation(plugins, "useHvSortBy", _reactTable.useSortBy);
+  ensureCorePluginInstallation(plugins, "useHvResizeColumns", _reactTable.useResizeColumns);
+  var indexOfHvTableStylesPlugin = plugins.findIndex(function (plugin) {
+    return plugin.pluginName === "useHvTableStyles";
+  });
+
+  if (indexOfHvTableStylesPlugin === -1) {
+    plugins.push(_useTableStyles.default);
+  } // main hook call
+
+
+  return _reactTable.useTable.apply(void 0, [_objectSpread({
+    data: data,
+    columns: columns
+  }, others), useHvTableSetup].concat(plugins));
+};
+
+var _default = useHvTable;
+exports.default = _default;
+//# sourceMappingURL=useTable.js.map

package/dist/Table/hooks/useTable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/Table/hooks/useTable.js"],"names":["toTitleCase","str","replace","toLowerCase","m","toUpperCase","trim","useDefaultData","data","useDefaultColumns","columns","uniqueKeys","Object","keys","filter","key","includes","map","accessor","Header","ensureCorePluginInstallation","plugins","hvPluginName","corePluginToInstall","indexOfCorePlugin","findIndex","plugin","pluginName","indexOfHvPlugin","splice","useInstanceHook","instance","rowsById","initialRowsById","useHvTableSetup","hooks","useInstance","push","useHvTable","props","dataProp","columnsProp","others","usePagination","useExpanded","useSortBy","useResizeColumns","indexOfHvTableStylesPlugin","useHvTableStyles","useTable"],"mappings":"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","sourcesContent":["import { useMemo } from \"react\";\nimport { useTable, usePagination, useExpanded, useSortBy, useResizeColumns } from \"react-table\";\n\nimport useHvTableStyles from \"./useTableStyles\";\n\nconst toTitleCase = (str) => {\n  return str\n    .replace(/([^A-Z])([A-Z])/g, \"$1 $2\") // split cameCase\n    .replace(/[_-]+/g, \" \") // split snake_case and lisp-case\n    .toLowerCase()\n    .replace(/(^\\w|\\b\\w)/g, (m) => m.toUpperCase()) // title case words\n    .replace(/\\s+/g, \" \") // collapse repeated whitespace\n    .trim(); // remove leading/trailing whitespace\n};\n\nconst useDefaultData = (data) =>\n  useMemo(() => {\n    return data || [];\n  }, [data]);\n\nconst useDefaultColumns = (columns, data) =>\n  useMemo(() => {\n    if (columns != null) {\n      return columns;\n    }\n\n    const uniqueKeys = Object.keys(Object.assign({}, ...data));\n    return uniqueKeys\n      .filter((key) => ![\"subRows\", \"subComponent\"].includes(key))\n      .map((key) => ({\n        accessor: key,\n        Header: toTitleCase(key),\n      }));\n  }, [columns, data]);\n\nconst ensureCorePluginInstallation = (plugins, hvPluginName, corePluginToInstall) => {\n  const indexOfCorePlugin = plugins.findIndex(\n    (plugin) => plugin.pluginName === corePluginToInstall.pluginName\n  );\n  const indexOfHvPlugin = plugins.findIndex((plugin) => plugin.pluginName === hvPluginName);\n\n  if (indexOfHvPlugin !== -1 && (indexOfCorePlugin === -1 || indexOfCorePlugin > indexOfHvPlugin)) {\n    if (indexOfCorePlugin > -1) {\n      plugins.splice(indexOfCorePlugin, 1);\n    }\n\n    plugins.splice(indexOfHvPlugin, 0, corePluginToInstall);\n  }\n};\n\nconst useInstanceHook = (instance) => {\n  const { rowsById } = instance;\n\n  Object.assign(instance, {\n    initialRowsById: rowsById,\n  });\n};\n\nconst useHvTableSetup = (hooks) => {\n  hooks.useInstance.push(useInstanceHook);\n};\n\nuseHvTableSetup.pluginName = \"useHvTableSetup\";\n\nconst useHvTable = (props, ...plugins) => {\n  const { data: dataProp, columns: columnsProp, ...others } = props;\n\n  const data = useDefaultData(dataProp);\n  const columns = useDefaultColumns(columnsProp, data);\n\n  ensureCorePluginInstallation(plugins, \"useHvPagination\", usePagination);\n  ensureCorePluginInstallation(plugins, \"useHvRowExpand\", useExpanded);\n  ensureCorePluginInstallation(plugins, \"useHvSortBy\", useSortBy);\n  ensureCorePluginInstallation(plugins, \"useHvResizeColumns\", useResizeColumns);\n\n  const indexOfHvTableStylesPlugin = plugins.findIndex(\n    (plugin) => plugin.pluginName === \"useHvTableStyles\"\n  );\n  if (indexOfHvTableStylesPlugin === -1) {\n    plugins.push(useHvTableStyles);\n  }\n\n  // main hook call\n  return useTable(\n    {\n      data,\n      columns,\n      ...others,\n    },\n    useHvTableSetup,\n    ...plugins\n  );\n};\n\nexport default useHvTable;\n"],"file":"useTable.js"}

package/dist/Table/hooks/useTableStyles.d.ts

@@ -0,0 +1,41 @@
+import { CSSProperties } from "react";
+import { Hooks } from "react-table";
+
+// table definition:
+export type UseHvTableStylesTableOptions = {
+  style?: CSSProperties;
+  className?: string;
+  classes?: Record<string, string>;
+};
+
+// column definition:
+export interface UseHvTableStylesColumnOptions {
+  variant?: "checkbox" | "expand" | "actions" | "default" | "none";
+  align?: "center" | "inherit" | "justify" | "left" | "right";
+
+  style?: CSSProperties;
+  className?: string;
+  classes?: Record<string, string>;
+
+  headerStyle?: CSSProperties;
+  headerClassName?: string;
+  headerClasses?: Record<string, string>;
+
+  cellStyle?: CSSProperties;
+  cellClassName?: string;
+  cellClasses?: Record<string, string>;
+}
+
+// PROPS:
+export interface UseHvTableStylesTableRowProps {
+  hover?: boolean;
+}
+
+export interface UseHvTableStylesTableCellProps {
+  variant?: "checkbox" | "expand" | "actions" | "default" | "none";
+  align?: "center" | "inherit" | "justify" | "left" | "right";
+}
+
+export default function useTableStyles<D extends object = Record<string, unknown>>(
+  hooks: Hooks<D>
+): void;

package/dist/Table/hooks/useTableStyles.js

@@ -0,0 +1,132 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+
+require("core-js/modules/web.dom-collections.for-each.js");
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTablePropsHook = exports.getRowPropsHook = exports.getHeaderFooterPropsHook = exports.getCellPropsHook = exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _clsx = _interopRequireDefault(require("clsx"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+// props target: <table>
+var getTablePropsHook = function getTablePropsHook(props, _ref) {
+  var instance = _ref.instance;
+  var nextProps = {
+    component: instance.tableComponent
+  };
+
+  if (instance.style != null) {
+    nextProps.style = instance.style;
+  }
+
+  if (instance.className != null) {
+    nextProps.className = instance.className;
+  }
+
+  if (instance.classes != null) {
+    nextProps.classes = instance.classes;
+  }
+
+  return [props, nextProps];
+}; // props target: <table><thead><tr><th>
+
+
+exports.getTablePropsHook = getTablePropsHook;
+
+var getHeaderFooterPropsHook = function getHeaderFooterPropsHook(props, _ref2) {
+  var column = _ref2.column;
+  var nextProps = {
+    variant: column.variant,
+    align: column.align
+  };
+
+  if (column.style != null || column.headerStyle != null) {
+    nextProps.style = _objectSpread(_objectSpread(_objectSpread({}, props.style), column.style), column.headerStyle);
+  }
+
+  if (column.className != null || column.headerClassName != null) {
+    nextProps.className = (0, _clsx.default)(props.className, column.className, column.headerClassName);
+  }
+
+  if (column.classes != null || column.headerClasses) {
+    nextProps.classes = _objectSpread(_objectSpread(_objectSpread({}, props.classes), column.classes), column.headerClasses);
+  }
+
+  return [props, nextProps];
+}; // props target: <table><tbody><tr>
+
+
+exports.getHeaderFooterPropsHook = getHeaderFooterPropsHook;
+
+var getRowPropsHook = function getRowPropsHook(props) {
+  var nextProps = {
+    hover: true
+  };
+  return [props, nextProps];
+}; // props target: <table><tbody><tr><td>
+
+
+exports.getRowPropsHook = getRowPropsHook;
+
+var getCellPropsHook = function getCellPropsHook(props, _ref3) {
+  var cell = _ref3.cell;
+  var nextProps = {
+    variant: cell.column.variant,
+    align: cell.column.align
+  };
+
+  if (cell.column.style != null || cell.column.cellStyle != null) {
+    nextProps.style = _objectSpread(_objectSpread(_objectSpread({}, props.style), cell.column.style), cell.column.cellStyle);
+  }
+
+  if (cell.column.className != null || cell.column.cellClassName != null) {
+    nextProps.className = (0, _clsx.default)(props.className, cell.column.className, cell.column.cellClassName);
+  }
+
+  if (cell.column.classes != null || cell.column.cellClasses) {
+    nextProps.classes = _objectSpread(_objectSpread(_objectSpread({}, props.classes), cell.column.classes), cell.column.cellClasses);
+  }
+
+  return [props, nextProps];
+};
+
+exports.getCellPropsHook = getCellPropsHook;
+
+var useTableStyles = function useTableStyles(hooks) {
+  // props target: <table>
+  hooks.getTableProps.push(getTablePropsHook); // props target: <table><thead><tr><th>
+
+  hooks.getHeaderProps.push(getHeaderFooterPropsHook); // props target: <table><tfoot><tr><td>
+
+  hooks.getFooterProps.push(getHeaderFooterPropsHook); // props target: <table><tbody><tr>
+
+  hooks.getRowProps.push(getRowPropsHook); // props target: <table><tbody><tr><td>
+
+  hooks.getCellProps.push(getCellPropsHook);
+};
+
+useTableStyles.pluginName = "useHvTableStyles";
+var _default = useTableStyles;
+exports.default = _default;
+//# sourceMappingURL=useTableStyles.js.map