@depup/react-virtualized 9.22.6-depup.0

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

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _SectionManager = _interopRequireDefault(require("./SectionManager"));
+var _TestData = require("./TestData");
+function initSectionManager() {
+  var sectionManager = new _SectionManager["default"](_TestData.SECTION_SIZE);
+  _TestData.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/commonjs/Collection/SectionManager.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _Section = _interopRequireDefault(require("./Section"));
+/**
+ * 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 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 = exports["default"] = /*#__PURE__*/function () {
+  function SectionManager() {
+    var sectionSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SECTION_SIZE;
+    (0, _classCallCheck2["default"])(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 (0, _createClass2["default"])(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["default"]({
+              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
+        });
+      });
+    }
+  }]);
+}();

package/dist/commonjs/Collection/TestData.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SECTION_SIZE = exports.CELLS = void 0;
+/*
+  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]
+*/
+
+var CELLS = exports.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
+}];
+var SECTION_SIZE = exports.SECTION_SIZE = 2;

package/dist/commonjs/Collection/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Collection", {
+  enumerable: true,
+  get: function get() {
+    return _Collection["default"];
+  }
+});
+exports["default"] = void 0;
+var _Collection = _interopRequireDefault(require("./Collection"));
+var _default = exports["default"] = _Collection["default"];

package/dist/commonjs/Collection/types.js

@@ -0,0 +1,22 @@
+/*:: 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,
+};*/
+"use strict";

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _calculateSizeAndPositionData = _interopRequireDefault(require("./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 = (0, _calculateSizeAndPositionData["default"])({
+        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 (0, _calculateSizeAndPositionData["default"])({
+        cellCount: 3,
+        cellSizeAndPositionGetter: function cellSizeAndPositionGetter() {}
+      });
+    }).toThrow();
+  });
+});

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

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = calculateSizeAndPositionData;
+var _SectionManager = _interopRequireDefault(require("../SectionManager"));
+function calculateSizeAndPositionData(_ref) {
+  var cellCount = _ref.cellCount,
+    cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter,
+    sectionSize = _ref.sectionSize;
+  var cellMetadata = [];
+  var sectionManager = new _SectionManager["default"](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/commonjs/ColumnSizer/ColumnSizer.example.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var React = _interopRequireWildcard(require("react"));
+var _ColumnSizerExample = _interopRequireDefault(require("./ColumnSizer.example.css"));
+var _AutoSizer = _interopRequireDefault(require("../AutoSizer"));
+var _ColumnSizer = _interopRequireDefault(require("./ColumnSizer"));
+var _Grid = _interopRequireDefault(require("../Grid"));
+var _ContentBox = require("../demo/ContentBox");
+var _LabeledInput = require("../demo/LabeledInput");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); }
+var ColumnSizerExample = exports["default"] = /*#__PURE__*/function (_React$PureComponent) {
+  function ColumnSizerExample(props) {
+    var _this;
+    (0, _classCallCheck2["default"])(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;
+  }
+  (0, _inherits2["default"])(ColumnSizerExample, _React$PureComponent);
+  return (0, _createClass2["default"])(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.ContentBox, null, /*#__PURE__*/React.createElement(_ContentBox.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(_ContentBox.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(_LabeledInput.InputRow, null, /*#__PURE__*/React.createElement(_LabeledInput.LabeledInput, {
+        label: "Num Columns",
+        name: "columnCount",
+        onChange: this._onColumnCountChange,
+        value: columnCount
+      }), /*#__PURE__*/React.createElement(_LabeledInput.LabeledInput, {
+        label: "Column Min Width",
+        name: "columnMinWidth",
+        onChange: this._noColumnMinWidthChange,
+        value: columnMinWidth
+      }), /*#__PURE__*/React.createElement(_LabeledInput.LabeledInput, {
+        label: "Column Max Width",
+        name: "columnMaxWidth",
+        onChange: this._noColumnMaxWidthChange,
+        value: columnMaxWidth
+      })), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(_AutoSizer["default"], {
+        disableHeight: true
+      }, function (_ref) {
+        var width = _ref.width;
+        return /*#__PURE__*/React.createElement(_ColumnSizer["default"], {
+          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: _ColumnSizerExample["default"].GridContainer,
+            style: {
+              height: 50,
+              width: adjustedWidth
+            }
+          }, /*#__PURE__*/React.createElement(_Grid["default"], {
+            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: _ColumnSizerExample["default"].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 ? _ColumnSizerExample["default"].firstCell : _ColumnSizerExample["default"].cell;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        key: key,
+        style: style
+      }, "R:".concat(rowIndex, ", C:").concat(columnIndex));
+    }
+  }]);
+}(React.PureComponent);