@elliemae/ds-data-table 2.3.0-alpha.8 → 2.3.0-next.2

package/cjs/DataTable.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var reactRedux = require('react-redux');
+var toolkit = require('@reduxjs/toolkit');
+var dsPropsHelpers = require('@elliemae/ds-props-helpers');
+var TableContent = require('./parts/TableContent.js');
+var storeConfig = require('./redux/storeConfig.js');
+var DataTableContext = require('./DataTableContext.js');
+var constants = require('./configs/constants.js');
+var useDatatableConfig = require('./configs/useDatatableConfig.js');
+require('./configs/useRowFlattenization.js');
+var FiltersBar = require('./parts/FilterBar/FiltersBar.js');
+var DataTableSchema = require('./DataTableSchema.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+var _FiltersBar;
+
+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__default["default"](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; }
+const DataTable = props => {
+  const {
+    withFilterBar
+  } = props;
+  const reduxStore = React.useMemo(() => toolkit.configureStore(storeConfig.storeConfig), []);
+  const tableWrapperRef = React.useRef();
+  const tableContentWrapperRef = React.useRef();
+  const ctx = useDatatableConfig.useDatatableConfig(props);
+  return /*#__PURE__*/_jsx__default["default"](reactRedux.Provider, {
+    store: reduxStore
+  }, void 0, /*#__PURE__*/_jsx__default["default"](DataTableContext["default"].Provider, {
+    value: ctx
+  }, void 0, /*#__PURE__*/jsxRuntime.jsxs("div", {
+    ref: tableWrapperRef,
+    "data-testid": constants.DATA_TESTID.DATA_TABLE_WRAPPER,
+    children: [withFilterBar ? _FiltersBar || (_FiltersBar = /*#__PURE__*/_jsx__default["default"](FiltersBar.FiltersBar, {})) : null, /*#__PURE__*/jsxRuntime.jsx(TableContent, {
+      ref: tableContentWrapperRef
+    })]
+  })));
+};
+DataTable.defaultProps = _objectSpread({}, DataTableContext.defaultProps);
+const DataTableWithSchema = dsPropsHelpers.describe(DataTable).description('Data Table');
+DataTableWithSchema.propTypes = DataTableSchema.DataTableSchema;
+
+exports.DataTable = DataTable;
+exports.DataTableWithSchema = DataTableWithSchema;

package/cjs/DataTableContext.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var constants = require('./configs/constants.js');
+
+const defaultProps = {
+  height: '100%',
+  width: '100%',
+  renderRowActions: false,
+  getRowVariant: () => 'ds-primary-row',
+  isExpandable: false,
+  uniqueRowAccessor: undefined,
+  expandedRows: {},
+  disabledRows: {},
+  isResizeable: false,
+  isLoading: false,
+  isLoadingAppended: false,
+  pagination: false,
+  filters: [],
+  colsLayoutStyle: constants.ColsLayoutStyle.Fixed,
+  hiddenColumns: [],
+  noResultsMessage: 'No Results Found',
+  dragAndDropRows: false,
+  maxDragAndDropLevel: 1,
+  onRowsReorder: () => null,
+  dragAndDropColumns: false,
+  onColumnsReorder: () => null,
+  onColumnResize: () => null,
+  onRowClick: () => null,
+  onRowFocus: () => null,
+  noSelectionColumn: false,
+  selectSingle: false,
+  selection: undefined,
+  onSelectionChange: () => null,
+  // selectionHashMap -> { ...[id]: enum(true/'mixed'/false) }
+  textWrap: 'wrap',
+  isNoMoreDataAppended: false,
+  noMoreDataMessage: 'No more to show.',
+  onCellValueChange: () => null,
+  onFiltersChange: () => null,
+  onFilteredDataChange: () => null,
+  onPageChanged: () => null,
+  onRowExpand: () => null,
+  customSortLogic: false,
+  onColumnSortChange: () => null
+};
+const defaultRelativeRowMouseCoord = {
+  isBefore: false,
+  isAfter: false,
+  isValid: true,
+  hoveredRowIndex: null,
+  x: null,
+  y: null,
+  relativeElementDOMRect: null,
+  relativeElementIndex: null
+};
+/** Context for cross component communication */
+
+const DataTableContext = /*#__PURE__*/React.createContext({
+  tableProps: defaultProps,
+  layoutHelpers: {},
+  flattenedData: [],
+  allDataFlattened: [],
+  visibleColumns: [],
+  paginationHelpers: {},
+  virtualListRef: /*#__PURE__*/React.createRef(),
+  columnHeaderRef: /*#__PURE__*/React.createRef()
+});
+
+exports["default"] = DataTableContext;
+exports.defaultProps = defaultProps;
+exports.defaultRelativeRowMouseCoord = defaultRelativeRowMouseCoord;

package/cjs/DataTableSchema.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dsPropsHelpers = require('@elliemae/ds-props-helpers');
+
+/* eslint-disable max-lines */
+const outOfTheBoxFilterType = dsPropsHelpers.PropTypes.oneOf(['ds-filter-select', 'ds-filter-multi-select', 'ds-filter-single-date', 'ds-filter-date-range', 'ds-filter-number-range']);
+const textWrappingType = dsPropsHelpers.PropTypes.oneOf(['wrap', 'wrap-all', 'truncate']);
+const columnPropTypes = {
+  Header: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('Header name or component').isRequired,
+  accessor: dsPropsHelpers.PropTypes.string.description('The entry of the data that this column will display'),
+  id: dsPropsHelpers.PropTypes.string.description('The id of the column, will default to the Header or accessor if not present'),
+  filter: outOfTheBoxFilterType.description('out-of-the-box filters'),
+  Filter: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('The custom component to render as a filter'),
+  Cell: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('The custom cell renderer component'),
+  editable: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('The editable out-of-the-box or component to render'),
+  disableDnD: dsPropsHelpers.PropTypes.bool.description('Whereas this column should be draggable'),
+  canResize: dsPropsHelpers.PropTypes.bool.description('Whereas this column should be resizable'),
+  width: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.number]).description('Width of this column'),
+  minWidth: dsPropsHelpers.PropTypes.number.description('Minimum width of this column, useful when resizing'),
+  maxWidth: dsPropsHelpers.PropTypes.number.description('Maximum width of this column, useful when resizing'),
+  canSort: dsPropsHelpers.PropTypes.bool.description('Whereas this column is sortable'),
+  isSortedDesc: dsPropsHelpers.PropTypes.bool.description('Whereas this column is sorted descendingly'),
+  required: dsPropsHelpers.PropTypes.bool.description('Whereas this column is required'),
+  alwaysDisplayEditIcon: dsPropsHelpers.PropTypes.bool.description('Whereas to always show the edit icon on this column if it is editable'),
+  textWrap: textWrappingType.description('How to wrap the text in the column')
+};
+const columnsPropTypes = dsPropsHelpers.PropTypes.shape(columnPropTypes).description('Columns props');
+const rowPropTypes = {
+  tableRowDetails: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('Component for row details'),
+  dimsumHeaderValue: dsPropsHelpers.PropTypes.string.description('Header displayed on the header variant of the row')
+};
+const rowsPropTypes = dsPropsHelpers.PropTypes.shape(rowPropTypes).description('Rows props');
+const DataTableSchema = {
+  columns: dsPropsHelpers.PropTypes.arrayOf(columnsPropTypes).description('Array of columns').isRequired,
+  data: dsPropsHelpers.PropTypes.arrayOf(rowsPropTypes).description('Array of rows'),
+  height: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.number]).description('Height of the datatable component'),
+  width: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.number]).description('Width of the datatable component'),
+  renderRowActions: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.object, dsPropsHelpers.PropTypes.bool]).description('The renderer to use for the action toolbar'),
+  isExpandable: dsPropsHelpers.PropTypes.bool.description('Whether the datatable is expandable').defaultValue(false),
+  uniqueRowAccessor: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.string), dsPropsHelpers.PropTypes.func]).description('Column / Combination of columns / Function to call to produce a unique identifier for each row.' + ' This is necessary for the selectable and drag and drop features'),
+  disabledRows: dsPropsHelpers.PropTypes.object.description('Object with the identifiers of the rows as keys, and booleans as values. Specifies if a row is disabled or not'),
+  expandedRows: dsPropsHelpers.PropTypes.object.description('Object with the identifiers of the rows as keys, and booleans as values. Specifies if a row is expanded or not'),
+  onRowExpand: dsPropsHelpers.PropTypes.func.description('Function invoked when a row is (un)expanded'),
+  cellRendererProps: dsPropsHelpers.PropTypes.object.description('Object with all the props you want the cells to have available when rendering'),
+  selectSingle: dsPropsHelpers.PropTypes.bool.description('Whether the selectable feature is single').defaultValue(false),
+  selection: dsPropsHelpers.PropTypes.object.description('Object with the identifiers of the rows as keys, and booleans as values. Specifies if a row is selected or not'),
+  onSelectionChange: dsPropsHelpers.PropTypes.func.description('Function invoked when a row is selected'),
+  groupedRowsRenderHeader: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.string, dsPropsHelpers.PropTypes.func]).description('String | Function to call which will display in the row headers'),
+  isResizeable: dsPropsHelpers.PropTypes.bool.description("Whether the datatable's columns are resizeable"),
+  filters: dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.shape({
+    id: dsPropsHelpers.PropTypes.string,
+    type: dsPropsHelpers.PropTypes.string,
+    value: dsPropsHelpers.PropTypes.any
+  })).description('Array of filter keys and values'),
+  withFilterBar: dsPropsHelpers.PropTypes.bool.description('Whether to display the filter bar'),
+  filterBarProps: dsPropsHelpers.PropTypes.shape({
+    customPillRenderer: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('If you specify custom filters, you will need to render their pills here'),
+    extraOptions: dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.shape({
+      type: dsPropsHelpers.PropTypes.string,
+      id: dsPropsHelpers.PropTypes.string,
+      label: dsPropsHelpers.PropTypes.string,
+      onClick: dsPropsHelpers.PropTypes.func
+    })).description('Any extra option you want in the dropdownmenu of the filter bar')
+  }).description('Props for the filter bar'),
+  onFiltersChange: dsPropsHelpers.PropTypes.func.description('Function invoked when filters change'),
+  pagination: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.oneOf([false]), dsPropsHelpers.PropTypes.shape({
+    pageCount: dsPropsHelpers.PropTypes.number.description('How many pages are there'),
+    pageIndex: dsPropsHelpers.PropTypes.number.description('Index of the current page, starting from 1').defaultValue(1),
+    canPreviousPage: dsPropsHelpers.PropTypes.bool.description('Whether the previous button is disabled or not').defaultValue(true),
+    canNextPage: dsPropsHelpers.PropTypes.bool.description('Whether the next button is disabled or not').defaultValue(true),
+    pageSize: dsPropsHelpers.PropTypes.number.description('The current page size').defaultValue(10),
+    showPerPageSelector: dsPropsHelpers.PropTypes.bool.description('Whether to show the page selector').defaultValue(true),
+    perPageOptions: dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.number, dsPropsHelpers.PropTypes.shape({
+      dsId: dsPropsHelpers.PropTypes.string,
+      value: dsPropsHelpers.PropTypes.number,
+      label: dsPropsHelpers.PropTypes.string,
+      type: dsPropsHelpers.PropTypes.oneOf(['single'])
+    })])).description('The available options for page size').defaultValue([10]),
+    perPageStep: dsPropsHelpers.PropTypes.number.description('Step for the per page options').defaultValue(5),
+    minPerPage: dsPropsHelpers.PropTypes.number.description('Step for the per page options').defaultValue(0),
+    maxPerPage: dsPropsHelpers.PropTypes.number.description('Step for the per page options').defaultValue(100),
+    onPageSizeChange: dsPropsHelpers.PropTypes.func.description('Function invoked when the page size changes').defaultValue(() => null),
+    onPreviousPage: dsPropsHelpers.PropTypes.func.description('Function invoked when the previous button is pressed').defaultValue(() => null),
+    onPageChange: dsPropsHelpers.PropTypes.func.description('Function invoked when the page changes').defaultValue(() => null),
+    onNextPage: dsPropsHelpers.PropTypes.func.description('Function invoked when next button is pressed').defaultValue(() => null),
+    pageDetails: dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.string).description('Details to provide for each page').defaultValue([]),
+    pageDetailsTitle: dsPropsHelpers.PropTypes.string.description('The title of the details (usually a column of your dataset)').defaultValue('')
+  })]).description('Object containing the data for the pagination'),
+  colsLayoutStyle: dsPropsHelpers.PropTypes.oneOf(['auto', 'fixed']).description('Whether the datatable fills its container or not'),
+  hiddenColumns: dsPropsHelpers.PropTypes.arrayOf(dsPropsHelpers.PropTypes.string).description('IDs of columns not to render'),
+  dragAndDropRows: dsPropsHelpers.PropTypes.bool.description('Whether to turn on the d&d feature for the rows').defaultValue(false),
+  onRowsReorder: dsPropsHelpers.PropTypes.func.description('Function invoked when a row is reordered'),
+  maxDragAndDropLevel: dsPropsHelpers.PropTypes.number.description('Which level is the maximum allowed to drop into'),
+  dragAndDropColumns: dsPropsHelpers.PropTypes.bool.description('Whether to turn on the d&d feature for the columns'),
+  onColumnsReorder: dsPropsHelpers.PropTypes.func.description('Function invoked when a column is reordered'),
+  textWrap: textWrappingType.description('Global wrapping rule'),
+  noResultsMessage: dsPropsHelpers.PropTypes.string.description('Message to show when no more data is available'),
+  noResultsSecondaryMessage: dsPropsHelpers.PropTypes.string.description('Secondary message to show when no more data is available'),
+  noResultsButtonLabel: dsPropsHelpers.PropTypes.string.description('Label of the button when no more data is available'),
+  noResultsPlaceholder: dsPropsHelpers.PropTypes.oneOfType([dsPropsHelpers.PropTypes.func, dsPropsHelpers.PropTypes.element]).description('Custom content to show when dataset is empty'),
+  isLoading: dsPropsHelpers.PropTypes.bool.description('Whether to show a global loader in the datatable'),
+  isLoadingAppended: dsPropsHelpers.PropTypes.bool.description('Whether to show an appended loader in the datatable'),
+  onColumnResize: dsPropsHelpers.PropTypes.func.description('Function invoked when a column is resized'),
+  isNoMoreDataAppended: dsPropsHelpers.PropTypes.bool.description('Whether to show an appended message in the datatable for no more data'),
+  noMoreDataMessage: dsPropsHelpers.PropTypes.string.description('The message to show when no more data is available'),
+  onRowClick: dsPropsHelpers.PropTypes.func.description('Function invoked when clicking a row'),
+  onRowFocus: dsPropsHelpers.PropTypes.func.description('Function invoked when focusing a row'),
+  onCellValueChange: dsPropsHelpers.PropTypes.func.description("Function invoked when an editable cell's content is changed"),
+  onColumnSortChange: dsPropsHelpers.PropTypes.func.description('Function invoked when a column is sorted'),
+  actionRef: dsPropsHelpers.PropTypes.object.description('Reference where all the exposed action callbacks will be exposed')
+};
+
+exports.DataTableSchema = DataTableSchema;

package/cjs/addons/Columns/ColumnAction/ColumnAction.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const actionColumn = renderRowActions => ({
+  Header: ' ',
+  id: 'rowActions',
+  width: renderRowActions.columnWidth,
+  style: {
+    overflow: 'visible'
+  },
+  // memo typing is broken?
+  Cell: /*#__PURE__*/React.memo(props => renderRowActions.renderer(props)),
+  canResize: false,
+  disableDnD: true,
+  isFocuseable: false
+});
+
+exports.actionColumn = actionColumn;

package/cjs/addons/Columns/ColumnDragHandle/ColumnDragHandle.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('react');
+var useRecoverFocusRow = require('../../../hooks/useRecoverFocusRow.js');
+require('../../../parts/TableContent.js');
+require('@elliemae/ds-grid');
+require('@elliemae/ds-circular-progress-indicator');
+require('styled-components');
+require('@elliemae/ds-icons');
+require('@elliemae/ds-system');
+require('@elliemae/ds-button');
+require('../../../DataTableContext.js');
+require('../../../parts/Row.js');
+require('../../../parts/Footer.js');
+var DnDHandle = require('../../../parts/DnDHandle.js');
+var styled = require('../../../styled.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+var _div;
+const dragHandleColumn = {
+  // Build our singleSelecter column
+  id: 'dragHandleColumn',
+  // Make sure it has an ID
+  // The header doesn't need anything for single selection
+  Header: () => _div || (_div = /*#__PURE__*/_jsx__default["default"]("div", {})),
+  Cell: _ref2 => {
+    let {
+      row,
+      isRowSelected,
+      cell,
+      isDragOverlay,
+      draggableProps
+    } = _ref2;
+    useRecoverFocusRow.useRecoverFocusRow(row, cell, isDragOverlay, draggableProps);
+    return /*#__PURE__*/_jsx__default["default"](styled.StyledFocusWithin, {
+      style: {
+        width: '100%',
+        height: '100%'
+      },
+      hideFocus: draggableProps && draggableProps.isDragging
+    }, void 0, /*#__PURE__*/_jsx__default["default"](DnDHandle, {
+      id: row.uid,
+      isReachable: isRowSelected,
+      innerRef: _ref => {
+        if (!isDragOverlay) cell.ref.current = _ref;
+      },
+      isDragOverlay: isDragOverlay
+    }, row.uid));
+  },
+  textWrap: 'wrap-all',
+  width: 24,
+  padding: 4,
+  canResize: false,
+  disableDnD: true,
+  isFocuseable: false
+};
+
+exports.dragHandleColumn = dragHandleColumn;

package/cjs/addons/Columns/ColumnExpand/ColumnExpand.js

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+var React = require('react');
+var dsIcons = require('@elliemae/ds-icons');
+var styled$1 = require('styled-components');
+var styled = require('../../../styled.js');
+var constants = require('../../../configs/constants.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('react-virtual');
+require('../../../configs/useRowFlattenization.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('@elliemae/ds-form');
+require('../../../parts/TableContent.js');
+require('@elliemae/ds-grid');
+require('@elliemae/ds-circular-progress-indicator');
+require('@elliemae/ds-system');
+require('@elliemae/ds-button');
+require('../../../DataTableContext.js');
+require('../../../parts/Row.js');
+require('../../../parts/Footer.js');
+require('../../../parts/HoC/SortableItemContext.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled$1);
+
+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__default["default"](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; }
+const StyledSpan = /*#__PURE__*/styled__default["default"].span.withConfig({
+  componentId: "sc-1xp824d-0"
+})(["cursor:pointer;box-sizing:border-box;outline:none;display:flex;justify-content:center;align-items:center;"]);
+const expandRowColumn = {
+  // Build our expander column
+  id: 'expander',
+  // Make sure it has an ID
+  accessor: 'expandRowColumn',
+  Header: _ref => {
+    let {
+      ctx
+    } = _ref;
+    const {
+      tableProps: {
+        expandedRows,
+        onRowExpand
+      },
+      allDataFlattened
+    } = ctx;
+    const allExpandable = React.useMemo(() => {
+      const expandable = {};
+      allDataFlattened.forEach(row => {
+        if (row.original.subRows || row.original.tableRowDetails || row.original.dimsumHeaderValue) expandable[row.uid] = true;
+      });
+      return expandable;
+    }, [allDataFlattened]);
+    const isAllRowsExpanded = React.useMemo(() => Object.keys(allExpandable).length === Object.keys(expandedRows).length, [allExpandable, expandedRows]);
+    const onExpandedAllHandler = React.useCallback(() => {
+      if (isAllRowsExpanded) onRowExpand({}, 'All');else onRowExpand(_objectSpread({}, allExpandable), 'All');
+    }, [allExpandable, isAllRowsExpanded, onRowExpand]);
+    const GlobalExpandIcon = React.useMemo(() => {
+      if (isAllRowsExpanded) return /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadDown, {
+        size: "s",
+        color: ['brand-primary', '600'],
+        "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_ARROW_DOWN
+      }); // Mixed
+
+      if (Object.keys(expandedRows).length) {
+        return /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadRight, {
+          size: "s",
+          color: ['brand-primary', '600'],
+          "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_ARROW_MIXED,
+          style: {
+            transform: 'rotate(45deg)'
+          }
+        });
+      }
+
+      return /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadRight, {
+        size: "s",
+        color: ['brand-primary', '600'],
+        "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_ARROW_RIGHT
+      });
+    }, [expandedRows, isAllRowsExpanded]);
+    return /*#__PURE__*/_jsx__default["default"](styled.StyledFocusWithin, {}, void 0, /*#__PURE__*/_jsx__default["default"](StyledSpan, {
+      role: "button",
+      tabIndex: 0,
+      title: "Toggle All Rows Expanded",
+      onClick: onExpandedAllHandler,
+      onKeyDown: e => {
+        if (['Enter', 'Space'].includes(e.code)) {
+          onExpandedAllHandler();
+          e.preventDefault();
+        }
+      },
+      "data-testid": constants.DATA_TESTID.DATA_TABLE_GLOBAL_EXPAND_CELL,
+      "aria-expanded": isAllRowsExpanded,
+      style: {
+        width: '24px',
+        height: '24px'
+      }
+    }, void 0, GlobalExpandIcon));
+  },
+  Cell: _ref2 => {
+    var _row$original$subRows;
+
+    let {
+      cell,
+      row,
+      isRowSelected,
+      ctx,
+      draggableProps
+    } = _ref2;
+    const {
+      tableProps: {
+        dragAndDropRows,
+        expandedRows,
+        onRowExpand
+      }
+    } = ctx;
+    const uniqueId = row.uid;
+    const isExpanded = expandedRows[uniqueId];
+    const shouldPrintCaret = ((_row$original$subRows = row.original.subRows) === null || _row$original$subRows === void 0 ? void 0 : _row$original$subRows.length) && row.depth === 0 || // only allows 1 level of expands
+    row.original.tableRowDetails || row.original.dimsumHeaderValue;
+    const onRowExpandHandler = React.useCallback(e => {
+      e.stopPropagation();
+
+      if (expandedRows[uniqueId]) {
+        delete expandedRows[uniqueId];
+      } else {
+        expandedRows[uniqueId] = true;
+      }
+
+      onRowExpand(_objectSpread({}, expandedRows), uniqueId);
+    }, [expandedRows, uniqueId, onRowExpand]);
+    const isDragging = draggableProps ? draggableProps.isDragging : false;
+    const isDragOverlay = dragAndDropRows && !draggableProps;
+    const indentStyle = React.useMemo(() => ({
+      marginLeft: "".concat(row.depth * 32, "px"),
+      marginRight: '18px',
+      paddingLeft: '2px',
+      paddingRight: '2px',
+      position: 'relative',
+      height: '100%',
+      display: 'flex',
+      alignItems: 'center'
+    }), [row.depth]);
+    const rowProps = React.useMemo(() => ({
+      role: 'button',
+      key: "".concat(row.uid, "-expand-button"),
+      title: 'Toggle Row Expanded',
+      onClick: onRowExpandHandler,
+      onKeyDown: e => {
+        if (['Enter', 'Space'].includes(e.code)) {
+          e.preventDefault();
+          onRowExpandHandler(e);
+        }
+      },
+      ref: cell.ref,
+      tabIndex: isRowSelected ? 0 : -1,
+      'data-testid': 'data-table-row-expand-cell',
+      'aria-expanded': isExpanded,
+      isRightArrow: !isExpanded || isDragging || isDragOverlay
+    }), [row.uid, onRowExpandHandler, cell.ref, isRowSelected, isExpanded, isDragging, isDragOverlay]);
+    const PureCaretIcon = React.useMemo(() => isExpanded && !isDragging && !isDragOverlay ? /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadDown, {
+      "data-is-col-expanded": isExpanded,
+      "data-role": "row-expander-col",
+      size: "s",
+      "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_ARROW_DOWN
+    }) : /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowheadRight, {
+      "data-is-col-expanded": isExpanded,
+      "data-role": "row-expander-col",
+      size: "s",
+      "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_ARROW_RIGHT
+    }), [isExpanded, isDragging, isDragOverlay]);
+    const ChildIcon = React.useMemo(() => /*#__PURE__*/_jsx__default["default"](dsIcons.ArrowShortReturn, {
+      size: "s",
+      "data-testid": constants.DATA_TESTID.DATA_TABLE_ICON_CHILD,
+      style: {
+        transform: 'rotate(90deg) scaleY(-1)'
+      },
+      color: ['brand-primary', '600']
+    }), []);
+    if (shouldPrintCaret) return /*#__PURE__*/_jsx__default["default"](styled.StyledFocusWithin, {
+      style: indentStyle
+    }, void 0, /*#__PURE__*/jsxRuntime.jsx(StyledSpan, _objectSpread(_objectSpread({}, rowProps), {}, {
+      children: PureCaretIcon
+    })));
+    if (row.depth !== 0) return /*#__PURE__*/_jsx__default["default"]("span", {
+      style: indentStyle
+    }, void 0, ChildIcon);
+    return /*#__PURE__*/_jsx__default["default"]("div", {
+      style: {
+        width: '36px'
+      }
+    });
+  },
+  textWrap: 'wrap',
+  canResize: false,
+  width: 25,
+  padding: 0,
+  isFocuseable: false,
+  disableDnD: true
+};
+
+exports.expandRowColumn = expandRowColumn;