@depup/react-virtualized 9.22.6-depup.0

package/dist/es/Collection/SectionManager.jest.js

@@ -0,0 +1,118 @@
+import SectionManager from './SectionManager';
+import { CELLS, SECTION_SIZE } from './TestData';
+function initSectionManager() {
+  var sectionManager = new SectionManager(SECTION_SIZE);
+  CELLS.forEach(function (cellMetadatum, index) {
+    sectionManager.registerCell({
+      cellMetadatum: cellMetadatum,
+      index: index
+    });
+  });
+  return sectionManager;
+}
+function verifySections(sectionManager, sizeAndPosition, expectedSizeAndPositionInfos) {
+  var sections = sectionManager.getSections(sizeAndPosition);
+  expect(sections.length).toEqual(expectedSizeAndPositionInfos.length);
+  expectedSizeAndPositionInfos.forEach(function (sizeAndPosition) {
+    var match = sections.find(function (section) {
+      return section.x === sizeAndPosition.x && section.y === sizeAndPosition.y;
+    });
+    expect(!!match).toEqual(true);
+  });
+}
+describe('SectionManager', function () {
+  it('creates the appropriate number of Sections', function () {
+    var sectionManager = initSectionManager();
+    expect(sectionManager.getTotalSectionCount()).toEqual(6);
+  });
+  it('returns the proper Sections based on the specified area', function () {
+    var sectionManager = initSectionManager();
+    verifySections(sectionManager, {
+      x: 0,
+      y: 0,
+      width: 1,
+      height: 1
+    }, [{
+      x: 0,
+      y: 0
+    }]);
+    verifySections(sectionManager, {
+      x: 1,
+      y: 1,
+      width: 1,
+      height: 1
+    }, [{
+      x: 0,
+      y: 0
+    }]);
+    verifySections(sectionManager, {
+      x: 0,
+      y: 0,
+      width: 4,
+      height: 4
+    }, [{
+      x: 0,
+      y: 0
+    }, {
+      x: 2,
+      y: 0
+    }, {
+      x: 0,
+      y: 2
+    }, {
+      x: 2,
+      y: 2
+    }]);
+    verifySections(sectionManager, {
+      x: 4,
+      y: 0,
+      width: 2,
+      height: 3
+    }, [{
+      x: 4,
+      y: 0
+    }, {
+      x: 4,
+      y: 2
+    }]);
+  });
+  it('assigns cells to the appropriate sections', function () {
+    var sectionManager = initSectionManager();
+    expect(sectionManager.getCellIndices({
+      x: 0,
+      y: 0,
+      width: 2,
+      height: 2
+    })).toEqual([0]);
+    expect(sectionManager.getCellIndices({
+      x: 2,
+      y: 0,
+      width: 2,
+      height: 2
+    })).toEqual([1, 2, 3]);
+    expect(sectionManager.getCellIndices({
+      x: 4,
+      y: 0,
+      width: 2,
+      height: 2
+    })).toEqual([6]);
+    expect(sectionManager.getCellIndices({
+      x: 0,
+      y: 2,
+      width: 2,
+      height: 2
+    })).toEqual([4]);
+    expect(sectionManager.getCellIndices({
+      x: 2,
+      y: 2,
+      width: 2,
+      height: 2
+    })).toEqual([3, 4, 5]);
+    expect(sectionManager.getCellIndices({
+      x: 4,
+      y: 2,
+      width: 2,
+      height: 2
+    })).toEqual([7, 8, 9]);
+  });
+});

package/dist/es/Collection/SectionManager.js

@@ -0,0 +1,128 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+/**
+ * Window Sections are used to group nearby cells.
+ * This enables us to more quickly determine which cells to display in a given region of the Window.
+ * 
+ */
+import Section from './Section';
+/*:: import type {Index, SizeAndPositionInfo} from './types';*/
+var SECTION_SIZE = 100;
+/*:: type RegisterCellParams = {
+  cellMetadatum: SizeAndPositionInfo,
+  index: number,
+};*/
+/**
+ * Contains 0 to many Sections.
+ * Grows (and adds Sections) dynamically as cells are registered.
+ * Automatically adds cells to the appropriate Section(s).
+ */
+var SectionManager = /*#__PURE__*/function () {
+  function SectionManager() {
+    var sectionSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SECTION_SIZE;
+    _classCallCheck(this, SectionManager);
+    this._sectionSize = sectionSize;
+    this._cellMetadata = [];
+    this._sections = {};
+  }
+
+  /**
+   * Gets all cell indices contained in the specified region.
+   * A region may encompass 1 or more Sections.
+   */
+  return _createClass(SectionManager, [{
+    key: "getCellIndices",
+    value: function getCellIndices(_ref /*:: */) /*: Array<number>*/{
+      var height = _ref /*:: */.height,
+        width = _ref /*:: */.width,
+        x = _ref /*:: */.x,
+        y = _ref /*:: */.y;
+      var indices = {};
+      this.getSections({
+        height: height,
+        width: width,
+        x: x,
+        y: y
+      }).forEach(function (section) {
+        return section.getCellIndices().forEach(function (index) {
+          indices[index] = index;
+        });
+      });
+
+      // Object keys are strings; this function returns numbers
+      return Object.keys(indices).map(function (index) {
+        return indices[index];
+      });
+    }
+
+    /** Get size and position information for the cell specified. */
+  }, {
+    key: "getCellMetadata",
+    value: function getCellMetadata(_ref2 /*:: */) /*: SizeAndPositionInfo*/{
+      var index = _ref2 /*:: */.index;
+      return this._cellMetadata[index];
+    }
+
+    /** Get all Sections overlapping the specified region. */
+  }, {
+    key: "getSections",
+    value: function getSections(_ref3 /*:: */) /*: Array<Section>*/{
+      var height = _ref3 /*:: */.height,
+        width = _ref3 /*:: */.width,
+        x = _ref3 /*:: */.x,
+        y = _ref3 /*:: */.y;
+      var sectionXStart = Math.floor(x / this._sectionSize);
+      var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);
+      var sectionYStart = Math.floor(y / this._sectionSize);
+      var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);
+      var sections = [];
+      for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {
+        for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {
+          var key = "".concat(sectionX, ".").concat(sectionY);
+          if (!this._sections[key]) {
+            this._sections[key] = new Section({
+              height: this._sectionSize,
+              width: this._sectionSize,
+              x: sectionX * this._sectionSize,
+              y: sectionY * this._sectionSize
+            });
+          }
+          sections.push(this._sections[key]);
+        }
+      }
+      return sections;
+    }
+
+    /** Total number of Sections based on the currently registered cells. */
+  }, {
+    key: "getTotalSectionCount",
+    value: function getTotalSectionCount() {
+      return Object.keys(this._sections).length;
+    }
+
+    /** Intended for debugger/test purposes only */
+  }, {
+    key: "toString",
+    value: function toString() {
+      var _this = this;
+      return Object.keys(this._sections).map(function (index) {
+        return _this._sections[index].toString();
+      });
+    }
+
+    /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */
+  }, {
+    key: "registerCell",
+    value: function registerCell(_ref4 /*:: */) {
+      var cellMetadatum = _ref4 /*:: */.cellMetadatum,
+        index = _ref4 /*:: */.index;
+      this._cellMetadata[index] = cellMetadatum;
+      this.getSections(cellMetadatum).forEach(function (section) {
+        return section.addCellIndex({
+          index: index
+        });
+      });
+    }
+  }]);
+}();
+export { SectionManager as default };

package/dist/es/Collection/TestData.js

@@ -0,0 +1,71 @@
+/*
+  0 1 2 3 4 5
+ ┏━━━┯━━━┯━━━┓
+0┃0 0┊1 3┊6 6┃
+1┃0 0┊2 3┊6 6┃
+ ┠┈┈┈┼┈┈┈┼┈┈┈┨
+2┃4 4┊4 3┊7 8┃
+3┃4 4┊4 5┊9 9┃
+ ┗━━━┷━━━┷━━━┛
+
+Sections to Cells map:
+ 0.0 [0]
+ 1.0 [1, 2, 3]
+ 2.0 [6]
+ 0.1 [4]
+ 1.1 [3, 4, 5]
+ 2.1 [7, 8, 9]
+*/
+
+export var CELLS = [{
+  x: 0,
+  y: 0,
+  width: 2,
+  height: 2
+}, {
+  x: 2,
+  y: 0,
+  width: 1,
+  height: 1
+}, {
+  x: 2,
+  y: 1,
+  width: 1,
+  height: 1
+}, {
+  x: 3,
+  y: 0,
+  width: 1,
+  height: 3
+}, {
+  x: 0,
+  y: 2,
+  width: 3,
+  height: 2
+}, {
+  x: 3,
+  y: 3,
+  width: 1,
+  height: 1
+}, {
+  x: 4,
+  y: 0,
+  width: 2,
+  height: 2
+}, {
+  x: 4,
+  y: 2,
+  width: 1,
+  height: 1
+}, {
+  x: 5,
+  y: 2,
+  width: 1,
+  height: 1
+}, {
+  x: 4,
+  y: 3,
+  width: 2,
+  height: 1
+}];
+export var SECTION_SIZE = 2;

package/dist/es/Collection/index.js

@@ -0,0 +1,3 @@
+import Collection from './Collection';
+export default Collection;
+export { Collection };

package/dist/es/Collection/types.js

@@ -0,0 +1,21 @@
+/*:: export type Index = {
+  index: number,
+};*/
+/*:: export type PositionInfo = {
+  x: number,
+  y: number,
+};*/
+/*:: export type ScrollPosition = {
+  scrollLeft: number,
+  scrollTop: number,
+};*/
+/*:: export type SizeAndPositionInfo = {
+  height: number,
+  width: number,
+  x: number,
+  y: number,
+};*/
+/*:: export type SizeInfo = {
+  height: number,
+  width: number,
+};*/

package/dist/es/Collection/utils/calculateSizeAndPositionData.jest.js

@@ -0,0 +1,31 @@
+import calculateSizeAndPositionData from './calculateSizeAndPositionData';
+describe('calculateSizeAndPositionData', function () {
+  it('should query for size and position of each cell', function () {
+    var cellSizeAndPositionGetterCalls = [];
+    function cellSizeAndPositionGetter(_ref) {
+      var index = _ref.index;
+      cellSizeAndPositionGetterCalls.push(index);
+      return {
+        x: index * 50,
+        y: 0,
+        width: 50,
+        height: 50
+      };
+    }
+    var _calculateSizeAndPosi = calculateSizeAndPositionData({
+        cellCount: 3,
+        cellSizeAndPositionGetter: cellSizeAndPositionGetter
+      }),
+      sectionManager = _calculateSizeAndPosi.sectionManager;
+    expect(cellSizeAndPositionGetterCalls).toEqual([0, 1, 2]);
+    expect(sectionManager.getTotalSectionCount()).toEqual(2);
+  });
+  it('should throw an error if invalid metadata is returned for a cell', function () {
+    expect(function () {
+      return calculateSizeAndPositionData({
+        cellCount: 3,
+        cellSizeAndPositionGetter: function cellSizeAndPositionGetter() {}
+      });
+    }).toThrow();
+  });
+});

package/dist/es/Collection/utils/calculateSizeAndPositionData.js

@@ -0,0 +1,31 @@
+import SectionManager from '../SectionManager';
+export default function calculateSizeAndPositionData(_ref) {
+  var cellCount = _ref.cellCount,
+    cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter,
+    sectionSize = _ref.sectionSize;
+  var cellMetadata = [];
+  var sectionManager = new SectionManager(sectionSize);
+  var height = 0;
+  var width = 0;
+  for (var index = 0; index < cellCount; index++) {
+    var cellMetadatum = cellSizeAndPositionGetter({
+      index: index
+    });
+    if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) {
+      throw Error("Invalid metadata returned for cell ".concat(index, ":\n        x:").concat(cellMetadatum.x, ", y:").concat(cellMetadatum.y, ", width:").concat(cellMetadatum.width, ", height:").concat(cellMetadatum.height));
+    }
+    height = Math.max(height, cellMetadatum.y + cellMetadatum.height);
+    width = Math.max(width, cellMetadatum.x + cellMetadatum.width);
+    cellMetadata[index] = cellMetadatum;
+    sectionManager.registerCell({
+      cellMetadatum: cellMetadatum,
+      index: index
+    });
+  }
+  return {
+    cellMetadata: cellMetadata,
+    height: height,
+    sectionManager: sectionManager,
+    width: width
+  };
+}

package/dist/es/ColumnSizer/ColumnSizer.example.js

@@ -0,0 +1,150 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import * as React from 'react';
+import styles from './ColumnSizer.example.css';
+import AutoSizer from '../AutoSizer';
+import ColumnSizer from './ColumnSizer';
+import Grid from '../Grid';
+import { ContentBox, ContentBoxHeader, ContentBoxParagraph } from '../demo/ContentBox';
+import { LabeledInput, InputRow } from '../demo/LabeledInput';
+var ColumnSizerExample = /*#__PURE__*/function (_React$PureComponent) {
+  function ColumnSizerExample(props) {
+    var _this;
+    _classCallCheck(this, ColumnSizerExample);
+    _this = _callSuper(this, ColumnSizerExample, [props]);
+    _this.state = {
+      columnMaxWidth: 100,
+      columnMinWidth: 75,
+      columnCount: 10
+    };
+    _this._noColumnMaxWidthChange = _this._noColumnMaxWidthChange.bind(_this);
+    _this._noColumnMinWidthChange = _this._noColumnMinWidthChange.bind(_this);
+    _this._onColumnCountChange = _this._onColumnCountChange.bind(_this);
+    _this._noContentRenderer = _this._noContentRenderer.bind(_this);
+    _this._cellRenderer = _this._cellRenderer.bind(_this);
+    return _this;
+  }
+  _inherits(ColumnSizerExample, _React$PureComponent);
+  return _createClass(ColumnSizerExample, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$state = this.state,
+        columnMaxWidth = _this$state.columnMaxWidth,
+        columnMinWidth = _this$state.columnMinWidth,
+        columnCount = _this$state.columnCount;
+      return /*#__PURE__*/React.createElement(ContentBox, null, /*#__PURE__*/React.createElement(ContentBoxHeader, {
+        text: "ColumnSizer",
+        sourceLink: "https://github.com/bvaughn/react-virtualized/blob/master/source/ColumnSizer/ColumnSizer.example.js",
+        docsLink: "https://github.com/bvaughn/react-virtualized/blob/master/docs/ColumnSizer.md"
+      }), /*#__PURE__*/React.createElement(ContentBoxParagraph, null, "This component decorates a ", /*#__PURE__*/React.createElement("code", null, "Grid"), " and calculates the width of its columns based on the current (", /*#__PURE__*/React.createElement("code", null, "Grid"), ") width."), /*#__PURE__*/React.createElement(InputRow, null, /*#__PURE__*/React.createElement(LabeledInput, {
+        label: "Num Columns",
+        name: "columnCount",
+        onChange: this._onColumnCountChange,
+        value: columnCount
+      }), /*#__PURE__*/React.createElement(LabeledInput, {
+        label: "Column Min Width",
+        name: "columnMinWidth",
+        onChange: this._noColumnMinWidthChange,
+        value: columnMinWidth
+      }), /*#__PURE__*/React.createElement(LabeledInput, {
+        label: "Column Max Width",
+        name: "columnMaxWidth",
+        onChange: this._noColumnMaxWidthChange,
+        value: columnMaxWidth
+      })), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(AutoSizer, {
+        disableHeight: true
+      }, function (_ref) {
+        var width = _ref.width;
+        return /*#__PURE__*/React.createElement(ColumnSizer, {
+          columnMaxWidth: columnMaxWidth,
+          columnMinWidth: columnMinWidth,
+          columnCount: columnCount,
+          key: "GridColumnSizer",
+          width: width
+        }, function (_ref2) {
+          var adjustedWidth = _ref2.adjustedWidth,
+            columnWidth = _ref2.columnWidth,
+            registerChild = _ref2.registerChild;
+          return /*#__PURE__*/React.createElement("div", {
+            className: styles.GridContainer,
+            style: {
+              height: 50,
+              width: adjustedWidth
+            }
+          }, /*#__PURE__*/React.createElement(Grid, {
+            ref: registerChild,
+            columnWidth: columnWidth,
+            columnCount: columnCount,
+            height: 50,
+            noContentRenderer: _this2._noContentRenderer,
+            cellRenderer: _this2._cellRenderer,
+            rowHeight: 50,
+            rowCount: 1,
+            width: adjustedWidth
+          }));
+        });
+      })));
+    }
+  }, {
+    key: "_noColumnMaxWidthChange",
+    value: function _noColumnMaxWidthChange(event) {
+      var columnMaxWidth = parseInt(event.target.value, 10);
+      if (isNaN(columnMaxWidth)) {
+        columnMaxWidth = undefined;
+      } else {
+        columnMaxWidth = Math.min(1000, columnMaxWidth);
+      }
+      this.setState({
+        columnMaxWidth: columnMaxWidth
+      });
+    }
+  }, {
+    key: "_noColumnMinWidthChange",
+    value: function _noColumnMinWidthChange(event) {
+      var columnMinWidth = parseInt(event.target.value, 10);
+      if (isNaN(columnMinWidth)) {
+        columnMinWidth = undefined;
+      } else {
+        columnMinWidth = Math.max(1, columnMinWidth);
+      }
+      this.setState({
+        columnMinWidth: columnMinWidth
+      });
+    }
+  }, {
+    key: "_onColumnCountChange",
+    value: function _onColumnCountChange(event) {
+      this.setState({
+        columnCount: parseInt(event.target.value, 10) || 0
+      });
+    }
+  }, {
+    key: "_noContentRenderer",
+    value: function _noContentRenderer() {
+      return /*#__PURE__*/React.createElement("div", {
+        className: styles.noCells
+      }, "No cells");
+    }
+  }, {
+    key: "_cellRenderer",
+    value: function _cellRenderer(_ref3) {
+      var columnIndex = _ref3.columnIndex,
+        key = _ref3.key,
+        rowIndex = _ref3.rowIndex,
+        style = _ref3.style;
+      var className = columnIndex === 0 ? styles.firstCell : styles.cell;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        key: key,
+        style: style
+      }, "R:".concat(rowIndex, ", C:").concat(columnIndex));
+    }
+  }]);
+}(React.PureComponent);
+export { ColumnSizerExample as default };

package/dist/es/ColumnSizer/ColumnSizer.jest.js

@@ -0,0 +1,123 @@
+import * as React from 'react';
+import { findDOMNode } from 'react-dom';
+import { render } from '../TestUtils';
+import ColumnSizer from './ColumnSizer';
+import Grid from '../Grid';
+describe('ColumnSizer', function () {
+  function getMarkup() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$columnMinWidth = _ref.columnMinWidth,
+      columnMinWidth = _ref$columnMinWidth === void 0 ? undefined : _ref$columnMinWidth,
+      _ref$columnMaxWidth = _ref.columnMaxWidth,
+      columnMaxWidth = _ref$columnMaxWidth === void 0 ? undefined : _ref$columnMaxWidth,
+      _ref$columnCount = _ref.columnCount,
+      columnCount = _ref$columnCount === void 0 ? 10 : _ref$columnCount,
+      _ref$width = _ref.width,
+      width = _ref$width === void 0 ? 200 : _ref$width;
+    function cellRenderer(_ref2) {
+      var columnIndex = _ref2.columnIndex,
+        key = _ref2.key,
+        rowIndex = _ref2.rowIndex,
+        style = _ref2.style;
+      return /*#__PURE__*/React.createElement("div", {
+        className: "gridItem",
+        key: key,
+        style: style
+      }, "row:".concat(rowIndex, ", column:").concat(columnIndex));
+    }
+    return /*#__PURE__*/React.createElement(ColumnSizer, {
+      columnMinWidth: columnMinWidth,
+      columnMaxWidth: columnMaxWidth,
+      columnCount: columnCount,
+      width: width
+    }, function (_ref3) {
+      var adjustedWidth = _ref3.adjustedWidth,
+        columnWidth = _ref3.columnWidth,
+        registerChild = _ref3.registerChild;
+      return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Grid, {
+        columnCount: columnCount,
+        columnWidth: columnWidth,
+        height: 50,
+        ref: registerChild,
+        cellRenderer: cellRenderer,
+        rowHeight: 50,
+        rowCount: 1,
+        width: adjustedWidth
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "debug"
+      }, "adjustedWidth:".concat(adjustedWidth, " columnWidth:").concat(columnWidth)));
+    });
+  }
+  it('should distribute column widths evenly if no min/max boundaries have been set', function () {
+    var rendered = findDOMNode(render(getMarkup()));
+    expect(rendered.querySelector('.debug').textContent).toContain('columnWidth:20');
+  });
+  it('should respect :columnMaxWidth if specified', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      columnMaxWidth: 10
+    })));
+    expect(rendered.querySelector('.debug').textContent).toContain('columnWidth:10');
+  });
+  it('should respect :columnMinWidth if specified', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      columnMinWidth: 30
+    })));
+    expect(rendered.querySelector('.debug').textContent).toContain('columnWidth:30');
+  });
+  describe('recomputeGridSize', function () {
+    function helper(updatedProps, expectedTextContent) {
+      var renderedA = findDOMNode(render(getMarkup()));
+      expect(renderedA.querySelector('.debug').textContent).toContain('columnWidth:20');
+      var renderedB = findDOMNode(render(getMarkup(updatedProps)));
+      expect(renderedB.querySelector('.debug').textContent).toContain(expectedTextContent);
+    }
+    it('should recompute metadata sizes if :columnMinWidth changes', function () {
+      helper({
+        columnMinWidth: 30
+      }, 'columnWidth:30');
+    });
+    it('should recompute metadata sizes if :columnMaxWidth changes', function () {
+      helper({
+        columnMaxWidth: 15
+      }, 'columnWidth:15');
+    });
+    it('should recompute metadata sizes if :width changes', function () {
+      helper({
+        width: 300
+      }, 'columnWidth:30');
+    });
+    it('should recompute metadata sizes if :columnCount changes', function () {
+      helper({
+        columnCount: 2
+      }, 'columnWidth:100');
+    });
+  });
+  it('should pass the :width as :adjustedWidth if columns require more than the :width to be displayed', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      columnMinWidth: 30
+    })));
+    expect(rendered.querySelector('.debug').textContent).toContain('adjustedWidth:200');
+  });
+  it('should pass an :adjustedWidth if columns require less than the :width to be displayed', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      columnMaxWidth: 10
+    })));
+    expect(rendered.querySelector('.debug').textContent).toContain('adjustedWidth:100');
+  });
+  it('should error if the registered child is not a Grid or a MultiGrid', function () {
+    spyOn(console, 'error');
+    expect(function () {
+      render(/*#__PURE__*/React.createElement(ColumnSizer, {
+        columnMinWidth: 100,
+        columnMaxWidth: 100,
+        columnCount: 100,
+        width: 100
+      }, function (_ref4) {
+        var registerChild = _ref4.registerChild;
+        return /*#__PURE__*/React.createElement("div", {
+          ref: registerChild
+        });
+      }));
+    }).toThrow();
+  });
+});