@depup/react-virtualized 9.22.6-depup.0

package/dist/es/ArrowKeyStepper/ArrowKeyStepper.js

@@ -0,0 +1,197 @@
+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";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 type {RenderedSection} from '../Grid';*/
+/*:: import type {ScrollIndices} from './types';*/
+import * as React from 'react';
+import { polyfill } from 'react-lifecycles-compat';
+
+/**
+ * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.
+ */
+/*:: type ChildrenParams = {
+  onSectionRendered: (params: RenderedSection) => void,
+  scrollToColumn: number,
+  scrollToRow: number,
+};*/
+/*:: type Props = {
+  children: (params: ChildrenParams) => React.Element<*>,
+  className?: string,
+  columnCount: number,
+  disabled: boolean,
+  isControlled: boolean,
+  mode: 'cells' | 'edges',
+  onScrollToChange?: (params: ScrollIndices) => void,
+  rowCount: number,
+  scrollToColumn: number,
+  scrollToRow: number,
+};*/
+/*:: type State = ScrollIndices & {
+  instanceProps: {
+    prevScrollToColumn: number,
+    prevScrollToRow: number,
+  },
+};*/
+var ArrowKeyStepper = /*#__PURE__*/function (_React$PureComponent) {
+  function ArrowKeyStepper() {
+    var _this;
+    _classCallCheck(this, ArrowKeyStepper);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, ArrowKeyStepper, [].concat(args));
+    _defineProperty(_this, "state", {
+      scrollToColumn: 0,
+      scrollToRow: 0,
+      instanceProps: {
+        prevScrollToColumn: 0,
+        prevScrollToRow: 0
+      }
+    });
+    _defineProperty(_this, "_columnStartIndex", 0);
+    _defineProperty(_this, "_columnStopIndex", 0);
+    _defineProperty(_this, "_rowStartIndex", 0);
+    _defineProperty(_this, "_rowStopIndex", 0);
+    _defineProperty(_this, "_onKeyDown", function (event /*: KeyboardEvent*/) {
+      var _this$props = _this.props,
+        columnCount = _this$props.columnCount,
+        disabled = _this$props.disabled,
+        mode = _this$props.mode,
+        rowCount = _this$props.rowCount;
+      if (disabled) {
+        return;
+      }
+      var _this$_getScrollState = _this._getScrollState(),
+        scrollToColumnPrevious = _this$_getScrollState.scrollToColumn,
+        scrollToRowPrevious = _this$_getScrollState.scrollToRow;
+      var _this$_getScrollState2 = _this._getScrollState(),
+        scrollToColumn = _this$_getScrollState2.scrollToColumn,
+        scrollToRow = _this$_getScrollState2.scrollToRow;
+
+      // The above cases all prevent default event event behavior.
+      // This is to keep the grid from scrolling after the snap-to update.
+      switch (event.key) {
+        case 'ArrowDown':
+          scrollToRow = mode === 'cells' ? Math.min(scrollToRow + 1, rowCount - 1) : Math.min(_this._rowStopIndex + 1, rowCount - 1);
+          break;
+        case 'ArrowLeft':
+          scrollToColumn = mode === 'cells' ? Math.max(scrollToColumn - 1, 0) : Math.max(_this._columnStartIndex - 1, 0);
+          break;
+        case 'ArrowRight':
+          scrollToColumn = mode === 'cells' ? Math.min(scrollToColumn + 1, columnCount - 1) : Math.min(_this._columnStopIndex + 1, columnCount - 1);
+          break;
+        case 'ArrowUp':
+          scrollToRow = mode === 'cells' ? Math.max(scrollToRow - 1, 0) : Math.max(_this._rowStartIndex - 1, 0);
+          break;
+      }
+      if (scrollToColumn !== scrollToColumnPrevious || scrollToRow !== scrollToRowPrevious) {
+        event.preventDefault();
+        _this._updateScrollState({
+          scrollToColumn: scrollToColumn,
+          scrollToRow: scrollToRow
+        });
+      }
+    });
+    _defineProperty(_this, "_onSectionRendered", function (_ref /*:: */) {
+      var columnStartIndex = _ref /*:: */.columnStartIndex,
+        columnStopIndex = _ref /*:: */.columnStopIndex,
+        rowStartIndex = _ref /*:: */.rowStartIndex,
+        rowStopIndex = _ref /*:: */.rowStopIndex;
+      _this._columnStartIndex = columnStartIndex;
+      _this._columnStopIndex = columnStopIndex;
+      _this._rowStartIndex = rowStartIndex;
+      _this._rowStopIndex = rowStopIndex;
+    });
+    return _this;
+  }
+  _inherits(ArrowKeyStepper, _React$PureComponent);
+  return _createClass(ArrowKeyStepper, [{
+    key: "setScrollIndexes",
+    value: function setScrollIndexes(_ref2 /*:: */) {
+      var scrollToColumn = _ref2 /*:: */.scrollToColumn,
+        scrollToRow = _ref2 /*:: */.scrollToRow;
+      this.setState({
+        scrollToRow: scrollToRow,
+        scrollToColumn: scrollToColumn
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        className = _this$props2.className,
+        children = _this$props2.children;
+      var _this$_getScrollState3 = this._getScrollState(),
+        scrollToColumn = _this$_getScrollState3.scrollToColumn,
+        scrollToRow = _this$_getScrollState3.scrollToRow;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        onKeyDown: this._onKeyDown
+      }, children({
+        onSectionRendered: this._onSectionRendered,
+        scrollToColumn: scrollToColumn,
+        scrollToRow: scrollToRow
+      }));
+    }
+  }, {
+    key: "_getScrollState",
+    value: function _getScrollState() {
+      return this.props.isControlled ? this.props : this.state;
+    }
+  }, {
+    key: "_updateScrollState",
+    value: function _updateScrollState(_ref3 /*:: */) {
+      var scrollToColumn = _ref3 /*:: */.scrollToColumn,
+        scrollToRow = _ref3 /*:: */.scrollToRow;
+      var _this$props3 = this.props,
+        isControlled = _this$props3.isControlled,
+        onScrollToChange = _this$props3.onScrollToChange;
+      if (typeof onScrollToChange === 'function') {
+        onScrollToChange({
+          scrollToColumn: scrollToColumn,
+          scrollToRow: scrollToRow
+        });
+      }
+      if (!isControlled) {
+        this.setState({
+          scrollToColumn: scrollToColumn,
+          scrollToRow: scrollToRow
+        });
+      }
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
+      if (nextProps.isControlled) {
+        return {};
+      }
+      if (nextProps.scrollToColumn !== prevState.instanceProps.prevScrollToColumn || nextProps.scrollToRow !== prevState.instanceProps.prevScrollToRow) {
+        return _objectSpread(_objectSpread({}, prevState), {}, {
+          scrollToColumn: nextProps.scrollToColumn,
+          scrollToRow: nextProps.scrollToRow,
+          instanceProps: {
+            prevScrollToColumn: nextProps.scrollToColumn,
+            prevScrollToRow: nextProps.scrollToRow
+          }
+        });
+      }
+      return {};
+    }
+  }]);
+}(React.PureComponent);
+_defineProperty(ArrowKeyStepper, "defaultProps", {
+  disabled: false,
+  isControlled: false,
+  mode: 'edges',
+  scrollToColumn: 0,
+  scrollToRow: 0
+});
+polyfill(ArrowKeyStepper);
+export default ArrowKeyStepper;

package/dist/es/ArrowKeyStepper/index.js

@@ -0,0 +1,3 @@
+/*:: export type {ScrollIndices} from './types';*/
+export { default } from './ArrowKeyStepper';
+export { default as ArrowKeyStepper } from './ArrowKeyStepper';

package/dist/es/ArrowKeyStepper/types.js

@@ -0,0 +1,4 @@
+/*:: export type ScrollIndices = {
+  scrollToColumn: number,
+  scrollToRow: number,
+};*/

package/dist/es/AutoSizer/AutoSizer.example.js

@@ -0,0 +1,96 @@
+import _extends from "@babel/runtime/helpers/extends";
+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";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 { List as ImmutableList } from 'immutable';
+import PropTypes from 'prop-types';
+import * as React from 'react';
+import { ContentBox, ContentBoxHeader, ContentBoxParagraph } from '../demo/ContentBox';
+import AutoSizer from './AutoSizer';
+import List from '../List';
+/*:: import { type RowRendererParams } from '../List';*/
+import styles from './AutoSizer.example.css';
+/*:: type State = {
+  hideDescription: boolean,
+};*/
+var AutoSizerExample = /*#__PURE__*/function (_React$PureComponent) {
+  function AutoSizerExample() {
+    var _this;
+    _classCallCheck(this, AutoSizerExample);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, AutoSizerExample, [].concat(args));
+    _defineProperty(_this, "state", {
+      hideDescription: false
+    });
+    _defineProperty(_this, "_rowRenderer", function (_ref /*:: */) {
+      var index = _ref /*:: */.index,
+        key = _ref /*:: */.key,
+        style = _ref /*:: */.style;
+      var list = _this.context.list;
+      var row = list.get(index);
+      return /*#__PURE__*/React.createElement("div", {
+        key: key,
+        className: styles.row,
+        style: style
+      }, row.name);
+    });
+    return _this;
+  }
+  _inherits(AutoSizerExample, _React$PureComponent);
+  return _createClass(AutoSizerExample, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var list = this.context.list;
+      var hideDescription = this.state.hideDescription;
+      return /*#__PURE__*/React.createElement(ContentBox, _extends({}, this.props, {
+        style: {
+          height: 400
+        }
+      }), /*#__PURE__*/React.createElement(ContentBoxHeader, {
+        text: "AutoSizer",
+        sourceLink: "https://github.com/bvaughn/react-virtualized/blob/master/source/AutoSizer/AutoSizer.example.js",
+        docsLink: "https://github.com/bvaughn/react-virtualized/blob/master/docs/AutoSizer.md"
+      }), /*#__PURE__*/React.createElement(ContentBoxParagraph, null, /*#__PURE__*/React.createElement("label", {
+        className: styles.checkboxLabel
+      }, /*#__PURE__*/React.createElement("input", {
+        "aria-label": "Hide description (to show resize)?",
+        className: styles.checkbox,
+        type: "checkbox",
+        checked: hideDescription,
+        onChange: function onChange(event) {
+          return _this2.setState({
+            hideDescription: event.target.checked
+          });
+        }
+      }), "Hide description (to show resize)?")), !hideDescription && /*#__PURE__*/React.createElement(ContentBoxParagraph, null, "This component decorates ", /*#__PURE__*/React.createElement("code", null, "List"), ", ", /*#__PURE__*/React.createElement("code", null, "Table"), ", or any other component and automatically manages its width and height. It uses Sebastian Decima's", ' ', /*#__PURE__*/React.createElement("a", {
+        href: "https://github.com/sdecima/javascript-detect-element-resize",
+        target: "_blank"
+      }, "element resize event"), ' ', "to determine the appropriate size. In this example", ' ', /*#__PURE__*/React.createElement("code", null, "AutoSizer"), " grows to fill the remaining width and height of this flex column."), /*#__PURE__*/React.createElement("div", {
+        className: styles.AutoSizerWrapper
+      }, /*#__PURE__*/React.createElement(AutoSizer, null, function (_ref2) {
+        var width = _ref2.width,
+          height = _ref2.height;
+        return /*#__PURE__*/React.createElement(List, {
+          className: styles.List,
+          height: height,
+          rowCount: list.size,
+          rowHeight: 30,
+          rowRenderer: _this2._rowRenderer,
+          width: width
+        });
+      })));
+    }
+  }]);
+}(React.PureComponent);
+_defineProperty(AutoSizerExample, "contextTypes", {
+  list: PropTypes.instanceOf(ImmutableList).isRequired
+});
+export { AutoSizerExample as default };

package/dist/es/AutoSizer/AutoSizer.jest.js

@@ -0,0 +1,335 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import * as React from 'react';
+import { findDOMNode } from 'react-dom';
+import { render } from '../TestUtils';
+import AutoSizer from './AutoSizer';
+function DefaultChildComponent(_ref) {
+  var height = _ref.height,
+    width = _ref.width,
+    foo = _ref.foo,
+    bar = _ref.bar;
+  return /*#__PURE__*/React.createElement("div", null, "width:".concat(width, ", height:").concat(height, ", foo:").concat(foo, ", bar:").concat(bar));
+}
+describe('AutoSizer', function () {
+  function getMarkup() {
+    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref2$bar = _ref2.bar,
+      bar = _ref2$bar === void 0 ? 123 : _ref2$bar,
+      _ref2$ChildComponent = _ref2.ChildComponent,
+      ChildComponent = _ref2$ChildComponent === void 0 ? DefaultChildComponent : _ref2$ChildComponent,
+      _ref2$className = _ref2.className,
+      className = _ref2$className === void 0 ? undefined : _ref2$className,
+      _ref2$defaultHeight = _ref2.defaultHeight,
+      defaultHeight = _ref2$defaultHeight === void 0 ? undefined : _ref2$defaultHeight,
+      _ref2$defaultWidth = _ref2.defaultWidth,
+      defaultWidth = _ref2$defaultWidth === void 0 ? undefined : _ref2$defaultWidth,
+      _ref2$disableHeight = _ref2.disableHeight,
+      disableHeight = _ref2$disableHeight === void 0 ? false : _ref2$disableHeight,
+      _ref2$disableWidth = _ref2.disableWidth,
+      disableWidth = _ref2$disableWidth === void 0 ? false : _ref2$disableWidth,
+      _ref2$foo = _ref2.foo,
+      foo = _ref2$foo === void 0 ? 456 : _ref2$foo,
+      _ref2$height = _ref2.height,
+      height = _ref2$height === void 0 ? 100 : _ref2$height,
+      onResize = _ref2.onResize,
+      _ref2$paddingBottom = _ref2.paddingBottom,
+      paddingBottom = _ref2$paddingBottom === void 0 ? 0 : _ref2$paddingBottom,
+      _ref2$paddingLeft = _ref2.paddingLeft,
+      paddingLeft = _ref2$paddingLeft === void 0 ? 0 : _ref2$paddingLeft,
+      _ref2$paddingRight = _ref2.paddingRight,
+      paddingRight = _ref2$paddingRight === void 0 ? 0 : _ref2$paddingRight,
+      _ref2$paddingTop = _ref2.paddingTop,
+      paddingTop = _ref2$paddingTop === void 0 ? 0 : _ref2$paddingTop,
+      _ref2$style = _ref2.style,
+      style = _ref2$style === void 0 ? undefined : _ref2$style,
+      _ref2$width = _ref2.width,
+      width = _ref2$width === void 0 ? 200 : _ref2$width;
+    var wrapperStyle = {
+      boxSizing: 'border-box',
+      height: height,
+      paddingBottom: paddingBottom,
+      paddingLeft: paddingLeft,
+      paddingRight: paddingRight,
+      paddingTop: paddingTop,
+      width: width
+    };
+    mockOffsetSize(width, height);
+    return /*#__PURE__*/React.createElement("div", {
+      style: wrapperStyle
+    }, /*#__PURE__*/React.createElement(AutoSizer, {
+      className: className,
+      defaultHeight: defaultHeight,
+      defaultWidth: defaultWidth,
+      disableHeight: disableHeight,
+      disableWidth: disableWidth,
+      onResize: onResize,
+      style: style
+    }, function (_ref3) {
+      var height = _ref3.height,
+        width = _ref3.width;
+      return /*#__PURE__*/React.createElement(ChildComponent, {
+        width: disableWidth ? undefined : width,
+        height: disableHeight ? undefined : height,
+        bar: bar,
+        foo: foo
+      });
+    }));
+  }
+
+  // AutoSizer uses offsetWidth and offsetHeight.
+  // Jest runs in JSDom which doesn't support measurements APIs.
+  function mockOffsetSize(width, height) {
+    Object.defineProperty(HTMLElement.prototype, 'offsetHeight', {
+      configurable: true,
+      value: height
+    });
+    Object.defineProperty(HTMLElement.prototype, 'offsetWidth', {
+      configurable: true,
+      value: width
+    });
+  }
+  it('should relay properties to ChildComponent or React child', function () {
+    var rendered = findDOMNode(render(getMarkup()));
+    expect(rendered.textContent).toContain('foo:456');
+    expect(rendered.textContent).toContain('bar:123');
+  });
+  it('should set the correct initial width and height of ChildComponent or React child', function () {
+    var rendered = findDOMNode(render(getMarkup()));
+    expect(rendered.textContent).toContain('height:100');
+    expect(rendered.textContent).toContain('width:200');
+  });
+  it('should account for padding when calculating the available width and height', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      paddingBottom: 10,
+      paddingLeft: 4,
+      paddingRight: 4,
+      paddingTop: 15
+    })));
+    expect(rendered.textContent).toContain('height:75');
+    expect(rendered.textContent).toContain('width:192');
+  });
+  it('should not update :width if :disableWidth is true', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      disableWidth: true
+    })));
+    expect(rendered.textContent).toContain('height:100');
+    expect(rendered.textContent).toContain('width:undefined');
+  });
+  it('should not update :height if :disableHeight is true', function () {
+    var rendered = findDOMNode(render(getMarkup({
+      disableHeight: true
+    })));
+    expect(rendered.textContent).toContain('height:undefined');
+    expect(rendered.textContent).toContain('width:200');
+  });
+  function simulateResize(_x) {
+    return _simulateResize.apply(this, arguments);
+  }
+  function _simulateResize() {
+    _simulateResize = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref4) {
+      var element, height, width, trigger;
+      return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            element = _ref4.element, height = _ref4.height, width = _ref4.width;
+            mockOffsetSize(width, height);
+
+            // Trigger detectElementResize library by faking a scroll event
+            // TestUtils Simulate doesn't work here in JSDom so we manually dispatch
+            trigger = element.querySelector('.contract-trigger');
+            trigger.dispatchEvent(new Event('scroll'));
+
+            // Allow requestAnimationFrame to be invoked before continuing
+            _context5.next = 6;
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, 100);
+            });
+          case 6:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }));
+    return _simulateResize.apply(this, arguments);
+  }
+  it('should update :height after a resize event', /*#__PURE__*/function () {
+    var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(done) {
+      var rendered;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            rendered = findDOMNode(render(getMarkup({
+              height: 100,
+              width: 200
+            })));
+            expect(rendered.textContent).toContain('height:100');
+            expect(rendered.textContent).toContain('width:200');
+            _context.next = 5;
+            return simulateResize({
+              element: rendered,
+              height: 400,
+              width: 300
+            });
+          case 5:
+            expect(rendered.textContent).toContain('height:400');
+            expect(rendered.textContent).toContain('width:300');
+            done();
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x2) {
+      return _ref5.apply(this, arguments);
+    };
+  }());
+  describe('onResize and (re)render', function () {
+    it('should trigger when size changes', /*#__PURE__*/function () {
+      var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(done) {
+        var onResize, ChildComponent, rendered;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              onResize = jest.fn();
+              ChildComponent = jest.fn().mockImplementation(DefaultChildComponent);
+              rendered = findDOMNode(render(getMarkup({
+                ChildComponent: ChildComponent,
+                height: 100,
+                onResize: onResize,
+                width: 200
+              })));
+              ChildComponent.mockClear(); // TODO Improve initial check in version 10; see AutoSizer render()
+              expect(onResize).toHaveBeenCalledTimes(1);
+              _context2.next = 7;
+              return simulateResize({
+                element: rendered,
+                height: 400,
+                width: 300
+              });
+            case 7:
+              expect(ChildComponent).toHaveBeenCalledTimes(1);
+              expect(onResize).toHaveBeenCalledTimes(2);
+              done();
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      return function (_x3) {
+        return _ref6.apply(this, arguments);
+      };
+    }());
+    it('should only trigger when height changes for disableWidth == true', /*#__PURE__*/function () {
+      var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(done) {
+        var onResize, ChildComponent, rendered;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              onResize = jest.fn();
+              ChildComponent = jest.fn().mockImplementation(DefaultChildComponent);
+              rendered = findDOMNode(render(getMarkup({
+                ChildComponent: ChildComponent,
+                disableWidth: true,
+                height: 100,
+                onResize: onResize,
+                width: 200
+              })));
+              ChildComponent.mockClear(); // TODO Improve initial check in version 10; see AutoSizer render()
+              expect(onResize).toHaveBeenCalledTimes(1);
+              _context3.next = 7;
+              return simulateResize({
+                element: rendered,
+                height: 100,
+                width: 300
+              });
+            case 7:
+              expect(ChildComponent).toHaveBeenCalledTimes(0);
+              expect(onResize).toHaveBeenCalledTimes(1);
+              _context3.next = 11;
+              return simulateResize({
+                element: rendered,
+                height: 200,
+                width: 300
+              });
+            case 11:
+              expect(ChildComponent).toHaveBeenCalledTimes(1);
+              expect(onResize).toHaveBeenCalledTimes(2);
+              done();
+            case 14:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x4) {
+        return _ref7.apply(this, arguments);
+      };
+    }());
+    it('should only trigger when width changes for disableHeight == true', /*#__PURE__*/function () {
+      var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(done) {
+        var onResize, ChildComponent, rendered;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              onResize = jest.fn();
+              ChildComponent = jest.fn().mockImplementation(DefaultChildComponent);
+              rendered = findDOMNode(render(getMarkup({
+                ChildComponent: ChildComponent,
+                disableHeight: true,
+                height: 100,
+                onResize: onResize,
+                width: 200
+              })));
+              ChildComponent.mockClear(); // TODO Improve initial check in version 10; see AutoSizer render()
+              expect(onResize).toHaveBeenCalledTimes(1);
+              _context4.next = 7;
+              return simulateResize({
+                element: rendered,
+                height: 200,
+                width: 200
+              });
+            case 7:
+              expect(ChildComponent).toHaveBeenCalledTimes(0);
+              expect(onResize).toHaveBeenCalledTimes(1);
+              _context4.next = 11;
+              return simulateResize({
+                element: rendered,
+                height: 200,
+                width: 300
+              });
+            case 11:
+              expect(ChildComponent).toHaveBeenCalledTimes(1);
+              expect(onResize).toHaveBeenCalledTimes(2);
+              done();
+            case 14:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      return function (_x5) {
+        return _ref8.apply(this, arguments);
+      };
+    }());
+  });
+  describe('className and style', function () {
+    it('should use a custom :className if specified', function () {
+      var rendered = findDOMNode(render(getMarkup({
+        className: 'foo'
+      })));
+      expect(rendered.firstChild.className).toContain('foo');
+    });
+    it('should use a custom :style if specified', function () {
+      var style = {
+        backgroundColor: 'red'
+      };
+      var rendered = findDOMNode(render(getMarkup({
+        style: style
+      })));
+      expect(rendered.firstChild.style.backgroundColor).toEqual('red');
+    });
+  });
+});