@hitachivantara/uikit-react-core 5.109.1 → 6.0.0-next.10

package/dist/cjs/Table/hooks/useHvRowSelection.cjs

@@ -1,442 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const jsxRuntime = require("react/jsx-runtime");
-const React = require("react");
-const reactTable = require("react-table");
-const useLabels = require("../../hooks/useLabels.cjs");
-const CheckBox = require("../../CheckBox/CheckBox.cjs");
-reactTable.actions.resetSelectedRows = "resetSelectedRows";
-reactTable.actions.toggleAllRowsSelected = "toggleAllRowsSelected";
-reactTable.actions.toggleRowSelected = "toggleRowSelected";
-reactTable.actions.toggleAllPageRowsSelected = "toggleAllPageRowsSelected";
-reactTable.actions.resetLockedSelectionRows = "resetLockedSelectionRows";
-reactTable.actions.toggleRowLockedSelection = "toggleRowLockedSelection";
-const DEFAULT_LABELS = {
-  selectRowCheckBoxAriaLabel: "Select this row"
-};
-const hideHeaderVariants = ["checkbox", "actions"];
-const CellWithCheckBox = ({ row, labels: labelsProp }) => {
-  const labels = useLabels.useLabels(DEFAULT_LABELS, labelsProp);
-  const { onChange, checked, disabled, indeterminate } = row.getToggleRowSelectedProps();
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    CheckBox.HvCheckBox,
-    {
-      onChange,
-      checked,
-      disabled,
-      indeterminate,
-      "aria-label": labels.selectRowCheckBoxAriaLabel
-    }
-  );
-};
-const visibleColumnsHook = (columns) => {
-  const selectionColumn = {
-    id: "_hv_selection",
-    variant: "checkbox",
-    width: 32,
-    // this will only work when using useHvTableSticky
-    // but ensures it stays left of any sticky column
-    sticky: "left",
-    Cell: CellWithCheckBox
-  };
-  return [selectionColumn, ...columns];
-};
-const getHeaderPropsHook = (props, { column }) => {
-  const nextProps = {};
-  if (hideHeaderVariants.includes(column.variant)) {
-    nextProps["aria-hidden"] = true;
-  }
-  return [props, nextProps];
-};
-const getRowPropsHook = (props, { row }) => {
-  const nextProps = {
-    selected: row.isSelected
-  };
-  return [props, nextProps];
-};
-const defaultGetToggleRowSelectedProps = (props, meta) => {
-  const { instance, row } = meta;
-  const { manualRowSelectedKey = "isSelected" } = instance;
-  let checked = false;
-  if (row.original?.[manualRowSelectedKey]) {
-    checked = true;
-  } else {
-    checked = row.isSelected;
-  }
-  return [
-    props,
-    {
-      onChange: (e, check) => {
-        row.toggleRowSelected(check ?? e?.target?.checked);
-      },
-      disabled: row.isSelectionLocked,
-      checked,
-      indeterminate: row.isSomeSelected
-    }
-  ];
-};
-const defaultGetToggleAllRowsSelectedProps = (props, { instance }) => [
-  props,
-  {
-    onChange: (e) => {
-      instance.toggleAllRowsSelected(e.target.checked);
-    },
-    checked: instance.isAllRowsSelected,
-    indeterminate: Boolean(
-      !instance.isAllRowsSelected && Object.keys(instance.state.selectedRowIds).length
-    )
-  }
-];
-const defaultGetToggleAllPageRowsSelectedProps = (props, { instance }) => [
-  props,
-  {
-    onChange(e) {
-      instance.toggleAllPageRowsSelected(e.target.checked);
-    },
-    checked: instance.isAllPageRowsSelected,
-    indeterminate: Boolean(
-      !instance.isAllPageRowsSelected && instance.page.some(({ id }) => instance.state.selectedRowIds[id])
-    )
-  }
-];
-function reducer(state, action, previousState, instance) {
-  if (action.type === reactTable.actions.init) {
-    return {
-      selectedRowIds: {},
-      lockedSelectionRowIds: {},
-      ...state
-    };
-  }
-  if (action.type === reactTable.actions.resetSelectedRows) {
-    return {
-      ...state,
-      selectedRowIds: instance.initialState.selectedRowIds || {}
-    };
-  }
-  if (action.type === reactTable.actions.toggleAllRowsSelected) {
-    const { value: setSelected } = action;
-    const {
-      isAllRowsSelected,
-      rowsById,
-      initialRowsById,
-      nonGroupedRowsById = rowsById,
-      applyToggleAllRowsSelectedToPrefilteredRows
-    } = instance;
-    const rowsToSelect = applyToggleAllRowsSelectedToPrefilteredRows ? initialRowsById : nonGroupedRowsById;
-    const selectAll = setSelected ?? !isAllRowsSelected;
-    const selectedRowIds = { ...state.selectedRowIds };
-    if (selectAll) {
-      Object.keys(rowsToSelect).forEach((rowId) => {
-        const isSelectionLocked = state.lockedSelectionRowIds[rowId];
-        if (!isSelectionLocked) {
-          selectedRowIds[rowId] = true;
-        }
-      });
-    } else {
-      Object.keys(rowsToSelect).forEach((rowId) => {
-        const isSelectionLocked = state.lockedSelectionRowIds[rowId];
-        if (!isSelectionLocked) {
-          delete selectedRowIds[rowId];
-        }
-      });
-    }
-    return {
-      ...state,
-      selectedRowIds
-    };
-  }
-  if (action.type === reactTable.actions.toggleRowSelected) {
-    const { id, value: setSelected } = action;
-    const isSelectionLocked = state.lockedSelectionRowIds[id];
-    if (isSelectionLocked) {
-      return state;
-    }
-    const { rowsById, selectSubRows = true, getSubRows } = instance;
-    const isSelected = state.selectedRowIds[id];
-    const shouldExist = setSelected ?? !isSelected;
-    if (isSelected === shouldExist) {
-      return state;
-    }
-    const newSelectedRowIds = { ...state.selectedRowIds };
-    const handleRowById = (rowId) => {
-      const row = rowsById[rowId];
-      if (!row.isGrouped) {
-        if (shouldExist) {
-          newSelectedRowIds[rowId] = true;
-        } else {
-          delete newSelectedRowIds[rowId];
-        }
-      }
-      if (selectSubRows && getSubRows(row)) {
-        getSubRows(row).forEach((subrow) => {
-          handleRowById(subrow.id);
-        });
-      }
-    };
-    handleRowById(id);
-    return {
-      ...state,
-      selectedRowIds: newSelectedRowIds
-    };
-  }
-  if (action.type === reactTable.actions.toggleAllPageRowsSelected) {
-    const { value: setSelected } = action;
-    const {
-      page,
-      rowsById,
-      selectSubRows = true,
-      isAllPageRowsSelected,
-      getSubRows
-    } = instance;
-    const selectAll = setSelected ?? !isAllPageRowsSelected;
-    const newSelectedRowIds = { ...state.selectedRowIds };
-    const handleRowById = (rowId) => {
-      const row = rowsById[rowId];
-      const isSelectionLocked = state.lockedSelectionRowIds[rowId];
-      if (!isSelectionLocked && !row.isGrouped) {
-        if (selectAll) {
-          newSelectedRowIds[rowId] = true;
-        } else {
-          delete newSelectedRowIds[rowId];
-        }
-      }
-      if (selectSubRows && getSubRows(row)) {
-        getSubRows(row).forEach((subrow) => {
-          handleRowById(subrow.id);
-        });
-      }
-    };
-    page.forEach((row) => handleRowById(row.id));
-    return {
-      ...state,
-      selectedRowIds: newSelectedRowIds
-    };
-  }
-  if (action.type === reactTable.actions.resetLockedSelectionRows) {
-    return {
-      ...state,
-      lockedSelectionRowIds: instance.initialState.lockedSelectionRowIds || {}
-    };
-  }
-  if (action.type === reactTable.actions.toggleRowLockedSelection) {
-    const { id, value: setLockedSelection } = action;
-    const { rowsById, selectSubRows = true, getSubRows } = instance;
-    const isLockedSelection = state.lockedSelectionRowIds[id];
-    const shouldExist = setLockedSelection ?? !isLockedSelection;
-    if (isLockedSelection === shouldExist) {
-      return state;
-    }
-    const newLockedSelectionRowIds = { ...state.lockedSelectionRowIds };
-    const handleRowById = (rowId) => {
-      const row = rowsById[rowId];
-      if (!row.isGrouped) {
-        if (shouldExist) {
-          newLockedSelectionRowIds[rowId] = true;
-        } else {
-          delete newLockedSelectionRowIds[rowId];
-        }
-      }
-      if (selectSubRows && getSubRows(row)) {
-        getSubRows(row).forEach((subrow) => {
-          handleRowById(subrow.id);
-        });
-      }
-    };
-    handleRowById(id);
-    return {
-      ...state,
-      lockedSelectionRowIds: newLockedSelectionRowIds
-    };
-  }
-  return state;
-}
-function getRowIsSelected(row, selectedRowIds, getSubRows) {
-  if (selectedRowIds[row.id]) {
-    return true;
-  }
-  const subRows = getSubRows(row);
-  if (subRows?.length) {
-    let allChildrenSelected = true;
-    let someSelected = false;
-    subRows.forEach((subRow) => {
-      if (someSelected && !allChildrenSelected) {
-        return;
-      }
-      if (getRowIsSelected(subRow, selectedRowIds, getSubRows)) {
-        someSelected = true;
-      } else {
-        allChildrenSelected = false;
-      }
-    });
-    if (allChildrenSelected) {
-      return true;
-    }
-    if (someSelected) {
-      return null;
-    }
-  }
-  return false;
-}
-function useInstance(instance) {
-  const {
-    data,
-    rows,
-    getHooks,
-    plugins,
-    rowsById,
-    initialRowsById,
-    nonGroupedRowsById = rowsById,
-    autoResetSelectedRows = true,
-    autoResetLockedSelectionRows = true,
-    state: { selectedRowIds, lockedSelectionRowIds },
-    selectSubRows = true,
-    dispatch,
-    page,
-    getSubRows,
-    applyToggleAllRowsSelectedToPrefilteredRows
-  } = instance;
-  reactTable.ensurePluginOrder(
-    plugins,
-    ["useFilters", "useGroupBy", "useSortBy", "useExpanded", "usePagination"],
-    "useHvRowSelection"
-  );
-  const rowsToSelect = applyToggleAllRowsSelectedToPrefilteredRows ? initialRowsById : nonGroupedRowsById;
-  const selectedFlatRows = React.useMemo(() => {
-    const selectedRows = [];
-    rows.forEach((row) => {
-      const isSelected = selectSubRows ? getRowIsSelected(row, selectedRowIds, getSubRows) : !!selectedRowIds[row.id];
-      row.isSelected = !!isSelected;
-      row.isSomeSelected = isSelected === null;
-      if (isSelected) {
-        selectedRows.push(row);
-      }
-    });
-    return selectedRows;
-  }, [rows, selectSubRows, selectedRowIds, getSubRows]);
-  const existsLockedRows = !!Object.keys(lockedSelectionRowIds).length;
-  const isNoRowsSelected = !(Object.keys(rowsToSelect).length && selectedFlatRows.length);
-  let isNoPageRowsSelected;
-  let isAllRowsSelected;
-  let isAllPageRowsSelected;
-  let isAllSelectableRowsUnselected;
-  let isAllSelectablePageRowsUnselected;
-  let isAllSelectableRowsSelected;
-  let isAllSelectablePageRowsSelected;
-  if (isNoRowsSelected) {
-    isAllRowsSelected = false;
-    isAllPageRowsSelected = false;
-    isAllSelectableRowsSelected = existsLockedRows && !Object.keys(rowsToSelect).some((id) => !lockedSelectionRowIds[id]);
-    isAllSelectablePageRowsSelected = isAllSelectableRowsSelected;
-    isAllSelectableRowsUnselected = isAllSelectableRowsSelected;
-    isAllSelectablePageRowsUnselected = isAllSelectableRowsSelected;
-    isNoPageRowsSelected = true;
-  } else {
-    isAllRowsSelected = !Object.keys(rowsToSelect).some(
-      (id) => !selectedRowIds[id]
-    );
-    if (isAllRowsSelected) {
-      isAllSelectableRowsSelected = true;
-      isAllSelectablePageRowsSelected = true;
-      isAllSelectableRowsUnselected = existsLockedRows && Object.keys(rowsToSelect).filter((id) => !lockedSelectionRowIds[id]).length === 0;
-      isAllSelectablePageRowsUnselected = isAllSelectableRowsUnselected;
-      isNoPageRowsSelected = false;
-      isAllPageRowsSelected = true;
-    } else {
-      isAllSelectableRowsSelected = existsLockedRows && !Object.keys(rowsToSelect).filter((id) => !lockedSelectionRowIds[id]).some((id) => !selectedRowIds[id]);
-      isAllSelectableRowsUnselected = !existsLockedRows || !Object.keys(rowsToSelect).filter((id) => !lockedSelectionRowIds[id]).some((id) => selectedRowIds[id]);
-      isAllPageRowsSelected = !(page?.length && page.some(({ id }) => !selectedRowIds[id]));
-      if (isAllPageRowsSelected) {
-        isAllSelectablePageRowsSelected = true;
-        isAllSelectablePageRowsUnselected = existsLockedRows && page && page.length && page.filter(({ id }) => !lockedSelectionRowIds[id]).length === 0;
-        isNoPageRowsSelected = false;
-      } else {
-        isAllSelectablePageRowsSelected = existsLockedRows && !(page?.length && page.filter(({ id }) => !lockedSelectionRowIds[id]).some(({ id }) => !selectedRowIds[id]));
-        isAllSelectablePageRowsUnselected = !existsLockedRows || !(page?.length && page.filter(({ id }) => !lockedSelectionRowIds[id]).some(({ id }) => selectedRowIds[id]));
-        isNoPageRowsSelected = !(page?.length && page.some(({ id }) => selectedRowIds[id]));
-      }
-    }
-  }
-  const getAutoResetSelectedRows = reactTable.useGetLatest(autoResetSelectedRows);
-  const getAutoResetLockedSelectionRows = reactTable.useGetLatest(
-    autoResetLockedSelectionRows
-  );
-  reactTable.useMountedLayoutEffect(() => {
-    if (getAutoResetSelectedRows()) {
-      dispatch({ type: reactTable.actions.resetSelectedRows });
-    }
-    if (getAutoResetLockedSelectionRows()) {
-      dispatch({ type: reactTable.actions.resetLockedSelectionRows });
-    }
-  }, [dispatch, data]);
-  const toggleAllRowsSelected = React.useCallback(
-    (value) => dispatch({ type: reactTable.actions.toggleAllRowsSelected, value }),
-    [dispatch]
-  );
-  const toggleAllPageRowsSelected = React.useCallback(
-    (value) => dispatch({ type: reactTable.actions.toggleAllPageRowsSelected, value }),
-    [dispatch]
-  );
-  const toggleRowSelected = React.useCallback(
-    (id, value) => dispatch({ type: reactTable.actions.toggleRowSelected, id, value }),
-    [dispatch]
-  );
-  const getInstance = reactTable.useGetLatest(instance);
-  const getToggleAllRowsSelectedProps = reactTable.makePropGetter(
-    getHooks().getToggleAllRowsSelectedProps,
-    {
-      instance: getInstance()
-    }
-  );
-  const getToggleAllPageRowsSelectedProps = reactTable.makePropGetter(
-    getHooks().getToggleAllPageRowsSelectedProps,
-    { instance: getInstance() }
-  );
-  const toggleRowLockedSelection = React.useCallback(
-    (id, value) => dispatch({ type: reactTable.actions.toggleRowLockedSelection, id, value }),
-    [dispatch]
-  );
-  Object.assign(instance, {
-    selectedFlatRows,
-    isNoRowsSelected,
-    isNoPageRowsSelected,
-    isAllRowsSelected,
-    isAllPageRowsSelected,
-    isAllSelectableRowsSelected,
-    isAllSelectablePageRowsSelected,
-    isAllSelectableRowsUnselected,
-    isAllSelectablePageRowsUnselected,
-    toggleRowSelected,
-    toggleAllRowsSelected,
-    getToggleAllRowsSelectedProps,
-    getToggleAllPageRowsSelectedProps,
-    toggleAllPageRowsSelected,
-    toggleRowLockedSelection
-  });
-}
-function prepareRow(row, { instance }) {
-  row.toggleRowSelected = (set) => instance.toggleRowSelected(row.id, set);
-  row.getToggleRowSelectedProps = reactTable.makePropGetter(
-    instance.getHooks().getToggleRowSelectedProps,
-    {
-      instance,
-      row
-    }
-  );
-  row.toggleRowLockedSelection = (set) => instance.toggleRowLockedSelection(row.id, set);
-  row.isSelectionLocked = instance.state?.lockedSelectionRowIds?.[row.id] || false;
-}
-const useHvRowSelection = (hooks) => {
-  hooks.visibleColumns.push(visibleColumnsHook);
-  hooks.getRowProps.push(getRowPropsHook);
-  hooks.getHeaderProps.push(getHeaderPropsHook);
-  hooks.getToggleRowSelectedProps = [defaultGetToggleRowSelectedProps];
-  hooks.getToggleAllRowsSelectedProps = [defaultGetToggleAllRowsSelectedProps];
-  hooks.getToggleAllPageRowsSelectedProps = [
-    defaultGetToggleAllPageRowsSelectedProps
-  ];
-  hooks.stateReducers.push(reducer);
-  hooks.useInstance.push(useInstance);
-  hooks.prepareRow.push(prepareRow);
-};
-useHvRowSelection.pluginName = "useHvRowSelection";
-exports.useHvRowSelection = useHvRowSelection;

package/dist/cjs/Table/hooks/useHvRowState.cjs

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactTable = require("react-table");
-const useHvRowState = reactTable.useRowState.bind({});
-useHvRowState.pluginName = "useHvRowState";
-exports.useHvRowState = useHvRowState;

package/dist/cjs/Table/hooks/useHvSortBy.cjs

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactTable = require("react-table");
-const getHeaderPropsHook = (props, { instance, column }) => {
-  const { isMultiSortEvent = (e) => e.shiftKey } = instance;
-  const sortDirection = column.isSortedDesc ? "descending" : "ascending";
-  const nextProps = {
-    sortable: column.canSort,
-    sorted: column.isSorted,
-    sortDirection: column.isSorted ? sortDirection : void 0,
-    onClick: column.canSort ? (e) => {
-      e.persist();
-      column.toggleSortBy(
-        void 0,
-        !instance.disableMultiSort && isMultiSortEvent(e)
-      );
-    } : void 0
-  };
-  return [props, nextProps];
-};
-const getCellPropsHook = (props, { cell }) => {
-  const nextProps = {
-    sorted: cell.column.isSorted
-  };
-  return [props, nextProps];
-};
-const useInstanceHook = (instance) => {
-  reactTable.ensurePluginOrder(instance.plugins, ["useSortBy"], "useHvSortBy");
-};
-const useHvSortBy = (hooks) => {
-  hooks.getHeaderProps.push(getHeaderPropsHook);
-  hooks.getCellProps.push(getCellPropsHook);
-  hooks.useInstance.push(useInstanceHook);
-};
-useHvSortBy.pluginName = "useHvSortBy";
-exports.useHvSortBy = useHvSortBy;

package/dist/cjs/Table/hooks/useHvSticky.cjs

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const reactTable = require("react-table");
-const uikitStyles = require("@hitachivantara/uikit-styles");
-const isSticky = (value) => /left|right/i.test(value);
-const getStickyValue = ({ sticky, parent }) => {
-  if (isSticky(sticky)) {
-    return sticky;
-  }
-  if (parent != null) {
-    sticky = getStickyValue(parent);
-    if (isSticky(sticky)) {
-      return sticky;
-    }
-    const { columns } = parent;
-    if (columns?.length > 0) {
-      sticky = columns?.find((col) => col.sticky != null)?.sticky;
-      if (isSticky(sticky)) {
-        return sticky;
-      }
-    }
-  }
-  return void 0;
-};
-const updateColumnAndParent = (column, props) => {
-  Object.assign(column, props);
-  if (column.parent != null) {
-    updateColumnAndParent(column.parent, props);
-  }
-};
-const visibleColumnsHook = (columns, { instance }) => {
-  const toTheLeft = [];
-  const toTheRight = [];
-  const others = [];
-  columns.forEach((column) => {
-    const sticky = getStickyValue(column)?.toLowerCase();
-    updateColumnAndParent(column, { sticky });
-    if (sticky === "left") {
-      toTheLeft.push(column);
-    } else if (sticky === "right") {
-      toTheRight.push(column);
-    } else {
-      others.push(column);
-    }
-  });
-  if (others.length > 0) {
-    const [firstNotSticky] = others;
-    updateColumnAndParent(firstNotSticky, { isFirstNotSticky: true });
-    const lastNotSticky = others[others.length - 1];
-    updateColumnAndParent(lastNotSticky, { isLastNotSticky: true });
-  }
-  const hasLeftSticky = toTheLeft.length > 0;
-  if (hasLeftSticky) {
-    const lastLeftSticky = toTheLeft[toTheLeft.length - 1];
-    updateColumnAndParent(lastLeftSticky, { isLastLeftSticky: true });
-  }
-  const hasRightSticky = toTheRight.length > 0;
-  if (hasRightSticky) {
-    const [firstRightSticky] = toTheRight;
-    updateColumnAndParent(firstRightSticky, { isFirstRightSticky: true });
-  }
-  instance.hasStickyColumns = hasLeftSticky || hasRightSticky;
-  return [...toTheLeft, ...others, ...toTheRight];
-};
-const calculateHeaderWidthsToTheRight = (headers, right = 0) => {
-  if (!headers?.length) {
-    return;
-  }
-  for (let i = headers.length - 1; i !== -1; i -= 1) {
-    const header = headers[i];
-    header.totalRight = right;
-    const { headers: subHeaders } = header;
-    if (subHeaders?.length > 0) {
-      calculateHeaderWidthsToTheRight(subHeaders, right);
-    }
-    if (header.isVisible) {
-      right += header.totalWidth;
-    }
-  }
-};
-const useInstanceHook = (instance) => {
-  calculateHeaderWidthsToTheRight(instance.headers);
-  const getInstance = reactTable.useGetLatest(instance);
-  instance.getTableHeadProps = reactTable.makePropGetter(
-    instance.getHooks().getTableHeadProps,
-    {
-      instance: getInstance()
-    }
-  );
-};
-const getRowProps = () => ({
-  style: {
-    display: "flex",
-    flex: "1 0 auto"
-  }
-});
-const getCellProps = (header, isHeaderCell) => {
-  const props = {
-    style: {
-      display: "inline-flex",
-      flex: `${header.totalWidth} ${header.totalMinWidth} auto`,
-      alignItems: isHeaderCell ? "start" : "center",
-      justifyContent: header.align,
-      width: `${header.totalWidth}px`,
-      minWidth: `${header.totalMinWidth}px`,
-      ...isHeaderCell && { backgroundColor: uikitStyles.theme.colors.bgPage }
-    }
-  };
-  if (header.sticky != null) {
-    props.stickyColumn = true;
-    const margin = header.sticky === "left" ? header.totalLeft : header.totalRight;
-    props.style[header.sticky] = `${margin}px`;
-    if (header.isLastLeftSticky) {
-      props.stickyColumnMostLeft = true;
-    }
-    if (header.isFirstRightSticky) {
-      props.stickyColumnLeastRight = true;
-    }
-  } else {
-    if (header.isFirstNotSticky) {
-      props.style.borderLeft = 0;
-    }
-    if (header.isLastNotSticky) {
-      props.style.borderRight = 0;
-    }
-  }
-  return props;
-};
-const getTablePropsHook = (props, { instance }) => {
-  const nextProps = {
-    stickyHeader: instance.stickyHeader,
-    stickyColumns: instance.hasStickyColumns
-  };
-  return [props, nextProps];
-};
-const getTableHeadPropsHook = (props, { instance }) => {
-  const nextProps = {
-    stickyHeader: instance.stickyHeader
-  };
-  return [props, nextProps];
-};
-const getHeaderGroupPropsHook = (props, { instance }) => {
-  const nextProps = instance.hasStickyColumns ? getRowProps() : {};
-  return [props, nextProps];
-};
-const getHeaderPropsHook = (props, { instance, column }) => {
-  const nextProps = instance.hasStickyColumns ? getCellProps(column, true) : {};
-  return [props, nextProps];
-};
-const getRowPropsHook = (props, { instance }) => {
-  const nextProps = instance.hasStickyColumns ? getRowProps() : {};
-  return [props, nextProps];
-};
-const getCellPropsHook = (props, { instance, cell }) => {
-  const nextProps = instance.hasStickyColumns ? getCellProps(cell.column, false) : {};
-  return [props, nextProps];
-};
-const useHvTableSticky = (hooks) => {
-  hooks.visibleColumns.push(visibleColumnsHook);
-  hooks.useInstance.push(useInstanceHook);
-  hooks.getTableProps.push(getTablePropsHook);
-  hooks.getTableHeadProps = [getTableHeadPropsHook];
-  hooks.getHeaderGroupProps.push(getHeaderGroupPropsHook);
-  hooks.getHeaderProps.push(getHeaderPropsHook);
-  hooks.getRowProps.push(getRowPropsHook);
-  hooks.getCellProps.push(getCellPropsHook);
-};
-useHvTableSticky.pluginName = "useHvTableSticky";
-exports.useHvTableSticky = useHvTableSticky;