@carbon/ibm-products 1.13.0 → 1.16.0

package/es/components/Datagrid/useDisableSelectRows.js

@@ -0,0 +1,84 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+var useDisableSelectRows = function useDisableSelectRows(hooks) {
+  updateSelectAll(hooks);
+  updatePageSelectAll(hooks);
+
+  var getRowProps = function getRowProps(props, _ref) {
+    var row = _ref.row,
+        instance = _ref.instance;
+    return [props, {
+      selectDisabled: instance.shouldDisableSelectRow && instance.shouldDisableSelectRow(row)
+    }];
+  };
+
+  hooks.getRowProps.push(getRowProps);
+};
+
+var updateSelectAll = function updateSelectAll(hooks) {
+  var getToggleAllRowsSelectedProps = function getToggleAllRowsSelectedProps(props, _ref2) {
+    var instance = _ref2.instance;
+    var selectableRows = instance.rows.filter(function (row) {
+      return !(instance.shouldDisableSelectRow && instance.shouldDisableSelectRow(row));
+    });
+    var isAllRowsSelected = selectableRows.length > 0 && selectableRows.every(function (_ref3) {
+      var id = _ref3.id;
+      return instance.state.selectedRowIds[id];
+    });
+    return [props, {
+      onChange: function onChange(e) {
+        selectableRows.forEach(function (row) {
+          return row.toggleRowSelected(e.target.checked);
+        });
+      },
+      style: {
+        cursor: 'pointer'
+      },
+      checked: isAllRowsSelected,
+      disabled: instance.disableSelectAll,
+      title: 'Toggle All Rows Selected',
+      indeterminate: Boolean(!isAllRowsSelected && Object.keys(instance.state.selectedRowIds).length)
+    }];
+  };
+
+  hooks.getToggleAllRowsSelectedProps.push(getToggleAllRowsSelectedProps);
+};
+
+var updatePageSelectAll = function updatePageSelectAll(hooks) {
+  var getToggleAllPageRowsSelectedProps = function getToggleAllPageRowsSelectedProps(props, _ref4) {
+    var instance = _ref4.instance;
+    var selectableRows = instance.page.filter(function (row) {
+      return !(instance.shouldDisableSelectRow && instance.shouldDisableSelectRow(row));
+    });
+    var isAllRowsSelected = selectableRows.length > 0 && selectableRows.every(function (_ref5) {
+      var id = _ref5.id;
+      return instance.state.selectedRowIds[id];
+    });
+    return [props, {
+      onChange: function onChange(e) {
+        selectableRows.forEach(function (row) {
+          return row.toggleRowSelected(e.target.checked);
+        });
+      },
+      style: {
+        cursor: 'pointer'
+      },
+      checked: isAllRowsSelected,
+      disabled: instance.disableSelectAll,
+      title: 'Toggle All Rows Selected',
+      indeterminate: Boolean(!isAllRowsSelected && instance.page.some(function (_ref6) {
+        var id = _ref6.id;
+        return instance.state.selectedRowIds[id];
+      }))
+    }];
+  };
+
+  hooks.getToggleAllPageRowsSelectedProps.push(getToggleAllPageRowsSelectedProps);
+};
+
+export default useDisableSelectRows;

package/es/components/Datagrid/useExpandedRow.js

@@ -0,0 +1,52 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useState } from 'react';
+import DatagridExpandedRow from './Datagrid/DatagridExpandedRow';
+import useRowExpander from './useRowExpander';
+
+var useExpandedRow = function useExpandedRow(hooks) {
+  useRowExpander(hooks);
+
+  var useInstance = function useInstance(instance) {
+    var rows = instance.rows,
+        expandedContentHeight = instance.expandedContentHeight,
+        ExpandedRowContentComponent = instance.ExpandedRowContentComponent;
+
+    var _useState = useState({}),
+        _useState2 = _slicedToArray(_useState, 2),
+        expandedRowsHeight = _useState2[0],
+        setExpandedRowsHeight = _useState2[1];
+
+    var setExpandedRowHeight = function setExpandedRowHeight(rowIndex, height) {
+      return setExpandedRowsHeight(_objectSpread(_objectSpread({}, expandedRowsHeight), {}, _defineProperty({}, rowIndex, height)));
+    };
+
+    var rowsWithExpand = rows.map(function (row) {
+      return _objectSpread(_objectSpread({}, row), {}, {
+        canExpand: row.original && !row.original.notExpandable,
+        expandedContentHeight: expandedRowsHeight[row.index] || expandedContentHeight,
+        RowRenderer: DatagridExpandedRow(row.RowRenderer, ExpandedRowContentComponent)
+      });
+    });
+    Object.assign(instance, {
+      rows: rowsWithExpand,
+      setExpandedRowHeight: setExpandedRowHeight
+    });
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+export default useExpandedRow;

package/es/components/Datagrid/useFlexResize.js

@@ -0,0 +1,51 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+var useFlexResize = function useFlexResize(hooks) {
+  var spacerColumn = {
+    id: 'spacer',
+    width: 0,
+    disableSortBy: true,
+    disableResizing: true
+  };
+  hooks.visibleColumns.push(function (columns) {
+    return [].concat(_toConsumableArray(columns), [spacerColumn]);
+  });
+
+  var changeProps = function changeProps(props, data) {
+    var column = data.column;
+
+    if (!column && data.cell) {
+      column = data.cell.column;
+    }
+
+    if (column.id === spacerColumn.id) {
+      return [props, {
+        style: {
+          flex: '1 1 0'
+        }
+      }];
+    }
+
+    return [props, {
+      style: {
+        flex: '0 0 auto'
+      }
+    }];
+  };
+
+  hooks.getHeaderProps.push(function (props, data) {
+    return changeProps(props, data);
+  });
+  hooks.getCellProps.push(function (props, data) {
+    return changeProps(props, data);
+  });
+};
+
+export default useFlexResize;

package/es/components/Datagrid/useFloatingScroll.js

@@ -0,0 +1,88 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2021
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useEffect } from 'react';
+import cx from 'classnames';
+import { pkg } from '../../settings';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+
+var useFloatingScroll = function useFloatingScroll(hooks) {
+  var useInstance = function useInstance(instance) {
+    var tableId = instance.tableId,
+        withVirtualScroll = instance.withVirtualScroll,
+        ExpandedRowContentComponent = instance.ExpandedRowContentComponent;
+    useEffect(function () {
+      // Floating scroll doesn't work with expanded rows and virtual scroll
+      if (withVirtualScroll || ExpandedRowContentComponent) {
+        return;
+      }
+
+      var datagrid = document.getElementById(tableId); // eslint-disable-next-line no-unused-expressions
+
+      datagrid === null || datagrid === void 0 ? void 0 : datagrid.classList.add("".concat(blockClass, "__sticky"));
+    }, [ExpandedRowContentComponent, tableId, withVirtualScroll]);
+  };
+
+  var useAddStickyClass = function useAddStickyClass(instance) {
+    var withVirtualScroll = instance.withVirtualScroll,
+        ExpandedRowContentComponent = instance.ExpandedRowContentComponent; // Floating scroll doesn't work with expanded rows and virtual scroll
+
+    if (withVirtualScroll || ExpandedRowContentComponent) {
+      return;
+    }
+
+    var addStickyClass = function addStickyClass(props) {
+      return [props, {
+        className: cx(props.className, "".concat(blockClass, "__sticky"))
+      }];
+    };
+
+    hooks.getTableProps.push(addStickyClass);
+    hooks.getTableBodyProps.push(addStickyClass);
+    hooks.getHeaderGroupProps.push(addStickyClass);
+  };
+
+  var useAddScrollListener = function useAddScrollListener(instance) {
+    var withVirtualScroll = instance.withVirtualScroll,
+        ExpandedRowContentComponent = instance.ExpandedRowContentComponent,
+        tableId = instance.tableId; // Floating scroll doesn't work with expanded rows and virtual scroll
+
+    if (withVirtualScroll || ExpandedRowContentComponent) {
+      return;
+    }
+
+    var memoHead;
+
+    var addOnScroll = function addOnScroll(props) {
+      return [props, {
+        onScroll: function onScroll(e) {
+          var simpleThead;
+
+          if (memoHead) {
+            simpleThead = memoHead;
+          } else {
+            var datagrid = document.getElementById(tableId);
+            simpleThead = datagrid === null || datagrid === void 0 ? void 0 : datagrid.querySelector(".".concat(blockClass, "__table-simple thead > div"));
+            memoHead = simpleThead;
+          }
+
+          if (simpleThead) {
+            simpleThead.scrollLeft = e.target.scrollLeft;
+          }
+        }
+      }];
+    };
+
+    hooks.getTableBodyProps.push(addOnScroll);
+  };
+
+  hooks.useInstance.push(useAddStickyClass);
+  hooks.useInstance.push(useAddScrollListener);
+  hooks.useInstance.push(useInstance);
+};
+
+export default useFloatingScroll;

package/es/components/Datagrid/useInfiniteScroll.js

@@ -0,0 +1,54 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useCallback } from 'react';
+import debounce from 'lodash/debounce';
+import useParentDimensions from './useParentDimensions';
+import useResizeTable from './useResizeTable';
+
+var useInfiniteScroll = function useInfiniteScroll(hooks) {
+  useParentDimensions(hooks);
+  useResizeTable(hooks);
+
+  var useInstance = function useInstance(instance) {
+    var isFetching = instance.isFetching,
+        tableHeight = instance.tableHeight,
+        innerListRef = instance.innerListRef,
+        fetchMoreData = instance.fetchMoreData;
+    var loadMoreThreshold = 200;
+
+    var emptyFetchData = function emptyFetchData() {}; // eslint-disable-next-line react-hooks/exhaustive-deps
+
+
+    var fetchMore = useCallback(debounce(fetchMoreData || emptyFetchData, 3000, {
+      leading: true,
+      trailing: false
+    }), [fetchMoreData]);
+
+    var onScroll = function onScroll(_ref) {
+      var scrollDirection = _ref.scrollDirection,
+          scrollOffset = _ref.scrollOffset;
+
+      if (innerListRef && innerListRef.current) {
+        if (!isFetching && scrollDirection === 'forward' && scrollOffset + tableHeight >= innerListRef.current.clientHeight - loadMoreThreshold) {
+          if (fetchMoreData) {
+            fetchMore();
+          }
+        }
+      }
+    };
+
+    Object.assign(instance, {
+      onScroll: onScroll,
+      withVirtualScroll: true
+    });
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+export default useInfiniteScroll;

package/es/components/Datagrid/useNestedRows.js

@@ -0,0 +1,53 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import useRowExpander from './useRowExpander';
+import { pkg } from '../../settings';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+
+var useNestedRows = function useNestedRows(hooks) {
+  useRowExpander(hooks);
+  var marginLeft = 24;
+
+  var getRowProps = function getRowProps(props, _ref) {
+    var row = _ref.row;
+    return [props, {
+      className: row.depth > 0 ? "".concat(blockClass, "__carbon-nested-row") : ''
+    }];
+  };
+
+  var getRowStyles = function getRowStyles(props, _ref2) {
+    var row = _ref2.row;
+    return [props, {
+      style: {
+        marginLeft: "".concat(row.depth > 0 ? marginLeft : 0, "px"),
+        paddingLeft: "".concat(row.depth > 1 ? marginLeft * (row.depth - 1) + marginLeft : row.depth === 1 ? marginLeft : 0, "px"),
+        maxWidth: "calc(100% - ".concat(marginLeft * row.depth, "px)")
+      }
+    }];
+  };
+
+  var getCellProps = function getCellProps(props, _ref3) {
+    var cell = _ref3.cell,
+        instance = _ref3.instance;
+    // reduce the "first cell"s width to compensate added (left) margin
+    var isFirstCell = instance.columns.findIndex(function (c) {
+      return c.id === cell.column.id;
+    }) === 0;
+    return [props, {
+      style: {
+        marginRight: "".concat(isFirstCell && cell.row.depth > 0 ? "-".concat(marginLeft * (cell.row.depth + 1), "px") : '')
+      }
+    }];
+  };
+
+  hooks.getRowProps.push(getRowProps);
+  hooks.getRowProps.push(getRowStyles);
+  hooks.getCellProps.push(getCellProps);
+};
+
+export default useNestedRows;

package/es/components/Datagrid/useOnRowClick.js

@@ -0,0 +1,37 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+var useOnRowClick = function useOnRowClick(hooks) {
+  var useInstance = function useInstance(instance) {
+    var onRowClick = instance.onRowClick;
+
+    var getRowProps = function getRowProps(props, datagridState) {
+      var isFetching = datagridState.isFetching,
+          row = datagridState.row;
+
+      var onClick = function onClick() {
+        if (!isFetching && onRowClick) {
+          onRowClick(row);
+        }
+      };
+
+      return [props, {
+        onClick: onClick
+      }, {
+        style: {
+          cursor: 'pointer'
+        }
+      }];
+    };
+
+    hooks.getRowProps.push(getRowProps);
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+export default useOnRowClick;

package/es/components/Datagrid/useParentDimensions.js

@@ -0,0 +1,65 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useRef, useState } from 'react';
+
+var useParentDimensions = function useParentDimensions(hooks) {
+  var rootRef = useRef();
+  var headRef = useRef();
+  var innerListRef = useRef();
+  var listRef = useRef();
+
+  var _useState = useState(),
+      _useState2 = _slicedToArray(_useState, 2),
+      tableHeight = _useState2[0],
+      setTableHeight = _useState2[1];
+
+  var useInstance = function useInstance(instance) {
+    var DatagridActions = instance.DatagridActions,
+        DatagridBatchActions = instance.DatagridBatchActions,
+        totalColumnsWidth = instance.totalColumnsWidth,
+        DatagridPagination = instance.DatagridPagination;
+
+    var handleResize = function handleResize() {
+      var parent = rootRef && rootRef.current && rootRef.current.parentElement;
+
+      if (!parent) {
+        return;
+      }
+
+      var parentHeight = parent.clientHeight;
+      var parentWidth = parent.clientWidth;
+      var headHeight = headRef && headRef.current && headRef.current.clientHeight;
+      var parentStyles = window.getComputedStyle(parent);
+      var parentMarginBottom = parseFloat(parentStyles.getPropertyValue('margin-bottom'));
+      var parentPaddingBottom = parseFloat(parentStyles.getPropertyValue('padding-bottom'));
+      var parentMarginTop = parseFloat(parentStyles.getPropertyValue('margin-top'));
+      var parentPaddingTop = parseFloat(parentStyles.getPropertyValue('padding-top'));
+      var datagridActionsHeight = DatagridActions || DatagridBatchActions ? 48 : 0;
+      var datagridPaginationHeight = DatagridPagination ? 48 : 0;
+      var hasHorizontalScrollbar = parentWidth < totalColumnsWidth;
+      var horizontalScrollbarHolder = hasHorizontalScrollbar ? 16 : 0;
+      var newHeight = parentHeight - headHeight - parentMarginBottom - parentPaddingBottom - parentMarginTop - parentPaddingTop - datagridActionsHeight - datagridPaginationHeight - horizontalScrollbarHolder;
+      setTableHeight(newHeight);
+    };
+
+    Object.assign(instance, {
+      tableHeight: tableHeight,
+      rootRef: rootRef,
+      headRef: headRef,
+      innerListRef: innerListRef,
+      handleResize: handleResize,
+      listRef: listRef
+    });
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+export default useParentDimensions;

package/es/components/Datagrid/useResizeTable.js

@@ -0,0 +1,40 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useLayoutEffect } from 'react';
+
+var useResizeTable = function useResizeTable(hooks) {
+  var useInstanceBeforeDimensions = function useInstanceBeforeDimensions(instance) {
+    var rootRef = instance.rootRef,
+        handleResize = instance.handleResize;
+    var parent = rootRef && rootRef.current && rootRef.current.parentElement;
+    useLayoutEffect(function () {
+      if (!parent) {
+        return function () {};
+      }
+
+      handleResize();
+
+      if (typeof ResizeObserver === 'function') {
+        var resizeObserver = new ResizeObserver(function () {
+          handleResize();
+        });
+        resizeObserver.observe(parent);
+        return function () {
+          resizeObserver.disconnect(parent);
+          resizeObserver = null;
+        };
+      }
+
+      return console.error(' Could not resize table, no support for ResizeObserver');
+    }, [handleResize, parent]);
+  };
+
+  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
+};
+
+export default useResizeTable;

package/es/components/Datagrid/useRowExpander.js

@@ -0,0 +1,34 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+
+/* eslint-disable react/prop-types */
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import React from 'react';
+import { ChevronDown16, ChevronUp16 } from '@carbon/icons-react';
+
+var useRowExpander = function useRowExpander(hooks) {
+  var visibleColumns = function visibleColumns(columns) {
+    var expanderColumn = {
+      id: 'expander',
+      Cell: function Cell(_ref) {
+        var row = _ref.row;
+        return row.canExpand && /*#__PURE__*/React.createElement("span", row.getToggleRowExpandedProps(), row.isExpanded ? /*#__PURE__*/React.createElement(ChevronUp16, null) : /*#__PURE__*/React.createElement(ChevronDown16, null));
+      },
+      width: 48,
+      disableResizing: true,
+      disableSortBy: true,
+      Header: ''
+    };
+    return [expanderColumn].concat(_toConsumableArray(columns));
+  };
+
+  hooks.visibleColumns.push(visibleColumns);
+};
+
+export default useRowExpander;

package/es/components/Datagrid/useRowIsMouseOver.js

@@ -0,0 +1,61 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import { useState, useCallback } from 'react';
+import debounce from 'lodash/debounce';
+
+var useRowIsMouseOver = function useRowIsMouseOver(hooks) {
+  var useInstance = function useInstance(instance) {
+    var _useState = useState(),
+        _useState2 = _slicedToArray(_useState, 2),
+        mouseOverRowIndex = _useState2[0],
+        setMouseOverRowIndex = _useState2[1];
+
+    var onMouseChange = useDebounce(function (datagridState) {
+      var row = datagridState.row;
+      setMouseOverRowIndex(row.index);
+    }, 100);
+
+    var getRowProps = function getRowProps(props, datagridState) {
+      var onMouseOver = function onMouseOver() {
+        return onMouseChange(datagridState);
+      };
+
+      return [props, {
+        onMouseOver: onMouseOver
+      }];
+    };
+
+    var rows = instance.rows;
+    var rowsWithMouseOver = rows.map(function (row) {
+      return _objectSpread(_objectSpread({}, row), {}, {
+        isMouseOver: row.index === mouseOverRowIndex
+      });
+    });
+    Object.assign(instance, {
+      rows: rowsWithMouseOver
+    });
+    hooks.getRowProps.push(getRowProps);
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+var useDebounce = function useDebounce(fn, wait) {
+  return (// eslint-disable-next-line react-hooks/exhaustive-deps
+    useCallback(debounce(fn, wait), [])
+  );
+};
+
+export default useRowIsMouseOver;

package/es/components/Datagrid/useRowRenderer.js

@@ -0,0 +1,30 @@
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import DatagridRow from './Datagrid/DatagridRow';
+
+var useRowRenderer = function useRowRenderer(hooks) {
+  var useInstance = function useInstance(instance) {
+    var rows = instance.rows;
+
+    var addRowRenderer = function addRowRenderer(row) {
+      return Object.assign(row, {
+        RowRenderer: DatagridRow,
+        subRows: (row.subRows || []).map(addRowRenderer)
+      });
+    };
+
+    var rowsWithRenderer = rows.map(addRowRenderer);
+    Object.assign(instance, {
+      rows: rowsWithRenderer
+    });
+  };
+
+  hooks.useInstance.push(useInstance);
+};
+
+export default useRowRenderer;