@elliemae/ds-datagrids 1.61.0 → 2.0.0-alpha.12

package/esm/components/HeaderCell.js

@@ -1,62 +1,62 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import React from 'react';
-import PropTypes from 'prop-types';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'react';
 import { evaluateTransforms, evaluateFormatters } from '@elliemae/ds-shared/createDataInstance/utils';
 import DSTruncatedTooltipText from '@elliemae/ds-truncated-tooltip-text';
+import { jsx } from 'react/jsx-runtime';
+
+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) { _defineProperty(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; }
 
 function HeaderCell(_ref) {
-  var column = _ref.column,
-      columnIndex = _ref.columnIndex,
-      Component = _ref.component,
-      classProps = _ref.classProps,
-      grid = _ref.grid;
-  var property = column.property,
-      _column$header = column.header,
-      header = _column$header === void 0 ? {} : _column$header,
-      _column$props = column.props,
-      props = _column$props === void 0 ? {} : _column$props;
-  var evaluatedProperty = property || header && header.property;
-  var label = header.label,
-      _header$transforms = header.transforms,
-      transforms = _header$transforms === void 0 ? [] : _header$transforms,
-      _header$formatters = header.formatters,
-      formatters = _header$formatters === void 0 ? [] : _header$formatters; // subscribe hook effects into header cell
+  let {
+    column,
+    columnIndex,
+    component: Component,
+    classProps,
+    grid
+  } = _ref;
+  const {
+    property,
+    header = {},
+    props = {}
+  } = column;
+  const evaluatedProperty = property || header && header.property;
+  const {
+    label,
+    transforms = [],
+    formatters = []
+  } = header; // subscribe hook effects into header cell
 
-  if (column.headerHookEffects) column.headerHookEffects.forEach(function (hook) {
-    return hook();
-  });
-  var extraParameters = {
-    columnIndex: columnIndex,
+  if (column.headerHookEffects) column.headerHookEffects.forEach(hook => hook());
+  const extraParameters = {
+    columnIndex,
     property: evaluatedProperty,
-    column: column,
-    grid: grid
+    column,
+    grid
   };
 
-  var withTooltip = function withTooltip(v) {
-    return classProps && classProps.wrapText ? v : /*#__PURE__*/React.createElement(DSTruncatedTooltipText, {
-      value: v
-    });
-  };
+  const withTooltip = v => classProps && classProps.wrapText ? v : /*#__PURE__*/_jsx(DSTruncatedTooltipText, {
+    value: v
+  });
 
-  var value = withTooltip(label);
-  var transformedProps = evaluateTransforms(transforms, value, extraParameters);
-  var formattedValue = evaluateFormatters(formatters, value, extraParameters);
-  var testId = column.headerDataId || 'data-grid-header__cell';
-  return /*#__PURE__*/React.createElement(Component, _extends({
-    key: "".concat(evaluatedProperty, "-header"),
+  const value = withTooltip(label);
+  const transformedProps = evaluateTransforms(transforms, value, extraParameters);
+  const formattedValue = evaluateFormatters(formatters, value, extraParameters);
+  const testId = column.headerDataId || 'data-grid-header__cell';
+  return /*#__PURE__*/jsx(Component, _objectSpread(_objectSpread(_objectSpread(_objectSpread({
     "data-testid": testId,
     index: columnIndex,
     classProps: classProps
-  }, props, header && header.props, transformedProps), transformedProps.children || formattedValue);
+  }, props), header && header.props), transformedProps), {}, {
+    children: transformedProps.children || formattedValue
+  }), "".concat(evaluatedProperty, "-header"));
 }
 
-HeaderCell.propTypes = {
-  column: PropTypes.any,
-  columnIndex: PropTypes.number,
-  component: PropTypes.any,
-  classProps: PropTypes.any,
-  grid: PropTypes.any
-};
-
 export { HeaderCell as default };
-//# sourceMappingURL=HeaderCell.js.map

package/esm/components/List.js

@@ -1,16 +1,26 @@
-import React from 'react';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'react';
+import { jsx } from 'react/jsx-runtime';
+
+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) { _defineProperty(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; }
 
 function List(props, instance) {
   // todo: add should list update to memoize this
-  var _instance$getInstance = instance.getInstance(),
-      renderers = _instance$getInstance.renderers,
-      getListProps = _instance$getInstance.getListProps;
-
-  var ListComponent = renderers.list; // props from component props and plugins
+  const {
+    renderers,
+    getListProps
+  } = instance.getInstance();
+  const ListComponent = renderers.list; // props from component props and plugins
 
-  var mixedProps = getListProps(props);
-  return /*#__PURE__*/React.createElement(ListComponent, mixedProps);
+  const mixedProps = getListProps(props);
+  return /*#__PURE__*/jsx(ListComponent, _objectSpread({}, mixedProps));
 }
 
 export { List as default };
-//# sourceMappingURL=List.js.map

package/esm/components/ListItem.js

@@ -1,24 +1,38 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import React from 'react';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.reduce.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.reduce.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'react';
+import { jsx } from 'react/jsx-runtime';
 
-function ListItem(props, instance) {
-  var record = props.record;
+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; }
 
-  var _instance$getInstance = instance.getInstance(),
-      renderers = _instance$getInstance.renderers,
-      getItemProps = _instance$getInstance.getItemProps,
-      itemRenderer = _instance$getInstance.decorators.itemRenderer; // props from component props and plugins
+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) { _defineProperty(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; }
 
+function ListItem(props, instance) {
+  const {
+    record
+  } = props;
+  const {
+    renderers,
+    getItemProps,
+    decorators: {
+      itemRenderer
+    }
+  } = instance.getInstance(); // props from component props and plugins
 
-  var mixedProps = getItemProps(props);
-  var children = itemRenderer.reduce(function (result, formatter) {
-    return formatter(result, record, instance);
-  }, record.data.name);
-  var ItemComponent = renderers.list;
-  return /*#__PURE__*/React.createElement(ItemComponent, _extends({
+  const mixedProps = getItemProps(props);
+  const children = itemRenderer.reduce((result, formatter) => formatter(result, record, instance), record.data.name);
+  const ItemComponent = renderers.list;
+  return /*#__PURE__*/jsx(ItemComponent, _objectSpread(_objectSpread({
     record: record
-  }, mixedProps), children);
+  }, mixedProps), {}, {
+    children: children
+  }));
 }
 
 export { ListItem as default };
-//# sourceMappingURL=ListItem.js.map

package/esm/components/NoResults.js

@@ -1,31 +1,43 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
-import React from 'react';
+import 'react';
 import styled from 'styled-components';
 import { __UNSAFE_SPACE_TO_DIMSUM } from '@elliemae/ds-system';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 
-var _excluded = ["innerRef", "rowRenderer", "children"];
-var NoResultsContainer = /*#__PURE__*/styled.div.withConfig({
+const _excluded = ["innerRef", "rowRenderer", "children"];
+
+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) { _defineProperty(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; }
+const NoResultsContainer = /*#__PURE__*/styled.div.withConfig({
   componentId: "sc-uiln16-0"
-})(["display:flex;flex-direction:column;justify-content:center;align-items:center;padding:", ";padding-bottom:0;height:calc(100% - 36px);overflow:auto;"], function (props) {
-  return __UNSAFE_SPACE_TO_DIMSUM(props.theme.space.s);
-});
+})(["display:flex;flex-direction:column;justify-content:center;align-items:center;padding:", ";padding-bottom:0;height:calc(100% - 36px);overflow:auto;"], props => __UNSAFE_SPACE_TO_DIMSUM(props.theme.space.s));
 
 function NoResults(_ref) {
-  var innerRef = _ref.innerRef,
-      rowRenderer = _ref.rowRenderer,
-      children = _ref.children,
+  let {
+    innerRef,
+    rowRenderer,
+    children
+  } = _ref,
       rest = _objectWithoutProperties(_ref, _excluded);
 
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(NoResultsContainer, _extends({}, rest, {
-    innerRef: innerRef
-  }), children), rowRenderer({}, {
-    style: {
-      visibility: 'hidden',
-      marginBottom: 0
-    }
-  }, {}));
+  return /*#__PURE__*/jsxs(Fragment, {
+    children: [/*#__PURE__*/jsx(NoResultsContainer, _objectSpread(_objectSpread({}, rest), {}, {
+      innerRef: innerRef,
+      children: children
+    })), rowRenderer({}, {
+      style: {
+        visibility: 'hidden',
+        marginBottom: 0
+      }
+    }, {})]
+  });
 }
 
 export { NoResults as default };
-//# sourceMappingURL=NoResults.js.map

package/esm/components/RowsLoader.js

@@ -1,16 +1,15 @@
-import React from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
 import DSSpinner from '@elliemae/ds-spinner';
 import { SpinnerContainer } from './renderers/defaultClassedRenderers.js';
-import '@elliemae/ds-classnames';
-import '../blockNames.js';
 
 function RowsLoader(_ref) {
-  var _ref$size = _ref.size,
-      size = _ref$size === void 0 ? 'm' : _ref$size;
-  return /*#__PURE__*/React.createElement(SpinnerContainer, null, /*#__PURE__*/React.createElement(DSSpinner, {
+  let {
+    size = 'm'
+  } = _ref;
+  return /*#__PURE__*/_jsx(SpinnerContainer, {}, void 0, /*#__PURE__*/_jsx(DSSpinner, {
     size: size
   }));
 }
 
 export { RowsLoader as default };
-//# sourceMappingURL=RowsLoader.js.map

package/esm/components/Table.js

@@ -1,77 +1,80 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { useEffect, useCallback } from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useEffect, useCallback } from 'react';
 import TableHeader from './TableHeader.js';
 import TableBody from './TableBody.js';
 import HeaderCell from './HeaderCell.js';
 import BodyCell from './BodyCell.js';
 import { TableContext } from './tableContext.js';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import 'prop-types';
-import '@elliemae/ds-shared/createDataInstance/utils';
-import '@elliemae/ds-truncated-tooltip-text';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@elliemae/ds-shared/FocusGroup/FocusGrid';
+import { jsx } from 'react/jsx-runtime';
 
 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) { _defineProperty(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 Provider = TableContext.Provider;
+const {
+  Provider
+} = TableContext;
 
 function Table(props) {
-  var renderers = props.decoratedRenderers,
-      columns = props.decoratedColumns,
-      getRowProps = props.getRowProps,
-      getHeaderRowProps = props.getHeaderRowProps,
-      getTableProps = props.getTableProps,
-      children = props.children,
-      tableRef = props.tableRef,
-      wrapText = props.props.wrapText,
-      style = props.style,
-      _props$onDefaultFilte = props.onDefaultFiltersLoad,
-      onDefaultFiltersLoad = _props$onDefaultFilte === void 0 ? function () {
-    return null;
-  } : _props$onDefaultFilte;
-  useEffect(function () {
+  const {
+    decoratedRenderers: renderers,
+    decoratedColumns: columns,
+    getRowProps,
+    getHeaderRowProps,
+    getTableProps,
+    children,
+    tableRef,
+    props: {
+      wrapText
+    },
+    style,
+    onDefaultFiltersLoad = () => null
+  } = props;
+  useEffect(() => {
     onDefaultFiltersLoad(props.composedRows);
   }, [onDefaultFiltersLoad]);
 
-  var headerRowRenderer = function headerRowRenderer() {
-    var Row = renderers.header.row;
-    var Cell = renderers.header.cell;
-    var cells = []; // optimize the rendering using for loop
+  const headerRowRenderer = () => {
+    const Row = renderers.header.row;
+    const Cell = renderers.header.cell;
+    const cells = []; // optimize the rendering using for loop
 
-    for (var index = 0; index < columns.length; index++) {
-      cells.push( /*#__PURE__*/React.createElement(HeaderCell, {
-        key: index,
+    for (let index = 0; index < columns.length; index++) {
+      cells.push( /*#__PURE__*/_jsx(HeaderCell, {
         classProps: {
-          wrapText: wrapText
+          wrapText
         },
         column: columns[index],
         columnIndex: index,
         component: Cell,
         grid: props
-      }));
+      }, index));
     }
 
-    var rowProps = getHeaderRowProps({}, {});
-    return /*#__PURE__*/React.createElement(Row, rowProps, cells);
+    const rowProps = getHeaderRowProps({}, {});
+    return /*#__PURE__*/jsx(Row, _objectSpread(_objectSpread({}, rowProps), {}, {
+      children: cells
+    }));
   };
 
-  var bodyRowRenderer = useCallback(function (rowData, rowProps, extraParams) {
-    var Row = renderers.body.row;
-    var Cell = renderers.body.cell;
-    var nextRowProps = getRowProps(rowProps, _objectSpread(_objectSpread({}, extraParams), {}, {
-      rowData: rowData
+  const bodyRowRenderer = useCallback((rowData, rowProps, extraParams) => {
+    const Row = renderers.body.row;
+    const Cell = renderers.body.cell;
+    const nextRowProps = getRowProps(rowProps, _objectSpread(_objectSpread({}, extraParams), {}, {
+      rowData
     })); // get cells from columns api
 
-    var cells = []; // optimize the rendering using for loop
+    const cells = []; // optimize the rendering using for loop
 
-    for (var index = 0; index < columns.length; index++) {
-      cells.push( /*#__PURE__*/React.createElement(BodyCell, {
-        key: index,
+    for (let index = 0; index < columns.length; index++) {
+      cells.push( /*#__PURE__*/_jsx(BodyCell, {
         classProps: {
-          wrapText: wrapText
+          wrapText
         },
         column: columns[index],
         columnIndex: index,
@@ -79,32 +82,34 @@ function Table(props) {
         grid: props,
         rowIndex: extraParams.rowIndex,
         rowProps: _objectSpread({
-          rowData: rowData
+          rowData
         }, nextRowProps)
-      }));
+      }, index));
     }
 
-    return /*#__PURE__*/React.createElement(Row, _extends({}, nextRowProps, {
-      rowData: rowData
-    }), cells);
+    return /*#__PURE__*/jsx(Row, _objectSpread(_objectSpread({}, nextRowProps), {}, {
+      rowData: rowData,
+      children: cells
+    }));
   }, [columns, renderers]);
-  var TableComponent = renderers.table;
+  const TableComponent = renderers.table;
 
-  var value = _objectSpread(_objectSpread({}, props), {}, {
-    bodyRowRenderer: bodyRowRenderer,
-    headerRowRenderer: headerRowRenderer
+  const value = _objectSpread(_objectSpread({}, props), {}, {
+    bodyRowRenderer,
+    headerRowRenderer
   });
 
-  return /*#__PURE__*/React.createElement(Provider, {
+  return /*#__PURE__*/_jsx(Provider, {
     value: value
-  }, /*#__PURE__*/React.createElement(TableComponent, getTableProps({
+  }, void 0, /*#__PURE__*/jsx(TableComponent, _objectSpread(_objectSpread({}, getTableProps({
     innerRef: tableRef,
-    style: style
-  }), children));
+    style
+  })), {}, {
+    children: children
+  })));
 }
 
 Table.Header = TableHeader;
 Table.Body = TableBody;
 
 export { Table as default };
-//# sourceMappingURL=Table.js.map

package/esm/components/TableBody.js

@@ -1,37 +1,43 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
 import React, { useContext } from 'react';
 import { TableContext } from './tableContext.js';
+import { jsx } from 'react/jsx-runtime';
 
-var _excluded = ["rows", "noResultsPlaceholder", "isPlaceholderActive"];
+const _excluded = ["rows", "noResultsPlaceholder", "isPlaceholderActive"];
 
 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) { _defineProperty(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; }
 
 function TableBody(_ref) {
-  var rows = _ref.rows,
-      _ref$noResultsPlaceho = _ref.noResultsPlaceholder,
-      noResultsPlaceholder = _ref$noResultsPlaceho === void 0 ? 'No data' : _ref$noResultsPlaceho,
-      _ref$isPlaceholderAct = _ref.isPlaceholderActive,
-      isPlaceholderActive = _ref$isPlaceholderAct === void 0 ? false : _ref$isPlaceholderAct,
+  let {
+    rows,
+    noResultsPlaceholder = 'No data',
+    isPlaceholderActive = false
+  } = _ref,
       props = _objectWithoutProperties(_ref, _excluded);
 
-  var _useContext = useContext(TableContext),
-      refs = _useContext.refs,
-      decoratedColumns = _useContext.decoratedColumns,
-      renderers = _useContext.decoratedRenderers,
-      composedRows = _useContext.composedRows,
-      getBodyProps = _useContext.getBodyProps,
-      rowRenderer = _useContext.bodyRowRenderer,
-      _useContext$props = _useContext.props,
-      rowKey = _useContext$props.rowKey,
-      numRowsVisible = _useContext$props.numRowsVisible,
-      groupedRows = _useContext$props.groupedRows;
-
-  var BodyWrapperComponent = renderers.body.wrapper;
-  return /*#__PURE__*/React.createElement(BodyWrapperComponent, _extends({
+  const {
+    refs,
+    decoratedColumns,
+    decoratedRenderers: renderers,
+    composedRows,
+    getBodyProps,
+    bodyRowRenderer: rowRenderer,
+    props: {
+      rowKey,
+      numRowsVisible,
+      groupedRows
+    }
+  } = useContext(TableContext);
+  const BodyWrapperComponent = renderers.body.wrapper;
+  return /*#__PURE__*/jsx(BodyWrapperComponent, _objectSpread(_objectSpread({
     classProps: {
       grouped: groupedRows
     }
@@ -39,16 +45,17 @@ function TableBody(_ref) {
     innerRef: refs.body,
     innerBodyRef: refs.innerBody,
     rows: rows || composedRows.rows || composedRows,
-    noResultsPlaceholder: noResultsPlaceholder,
-    rowRenderer: rowRenderer,
+    noResultsPlaceholder,
+    rowRenderer,
     columns: decoratedColumns,
-    rowKey: rowKey,
-    numRowsVisible: numRowsVisible,
-    isPlaceholderActive: isPlaceholderActive
-  }))), "kajsd;klfajsd;fj");
+    rowKey,
+    numRowsVisible,
+    isPlaceholderActive
+  }))), {}, {
+    children: "kajsd;klfajsd;fj"
+  }));
 }
 
 var TableBody$1 = /*#__PURE__*/React.memo(TableBody);
 
 export { TableBody$1 as default };
-//# sourceMappingURL=TableBody.js.map

package/esm/components/TableHeader.js

@@ -1,24 +1,31 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import React, { useContext } from 'react';
+import { useContext } from 'react';
 import { TableContext } from './tableContext.js';
+import { jsx } from 'react/jsx-runtime';
 
 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) { _defineProperty(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; }
 
 function TableHeader(props) {
-  var _useContext = useContext(TableContext),
-      renderers = _useContext.decoratedRenderers,
-      columns = _useContext.decoratedColumns,
-      headerRowRenderer = _useContext.headerRowRenderer,
-      getHeaderProps = _useContext.getHeaderProps,
-      refs = _useContext.refs;
-
-  var HeaderWrapper = renderers.header.wrapper;
-  return /*#__PURE__*/React.createElement(HeaderWrapper, getHeaderProps(_objectSpread(_objectSpread({}, props), {}, {
+  const {
+    decoratedRenderers: renderers,
+    decoratedColumns: columns,
+    headerRowRenderer,
+    getHeaderProps,
+    refs
+  } = useContext(TableContext);
+  const HeaderWrapper = renderers.header.wrapper;
+  return /*#__PURE__*/jsx(HeaderWrapper, _objectSpread(_objectSpread({}, getHeaderProps(_objectSpread(_objectSpread({}, props), {}, {
     innerRef: refs.header
-  })), headerRowRenderer(columns, {}));
+  }))), {}, {
+    children: headerRowRenderer(columns, {})
+  }));
 }
 
 export { TableHeader as default };
-//# sourceMappingURL=TableHeader.js.map