@jetbrains/ring-ui 5.0.156 → 5.0.158

package/dist/island/adaptive-island-hoc.js

@@ -1,38 +1,53 @@
-import React, { Component, createContext } from 'react';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, m as _assertThisInitialized, _ as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { createContext, Component } from 'react';
 import { interpolateLinear } from '../global/linear-function.js';
 
-const TITLE_RESIZE_END = 20;
-const TITLE_RESIZE_THRESHOLD = 36;
-const PhaseContext = /*#__PURE__*/createContext(null);
-const ScrollHandlerContext = /*#__PURE__*/createContext(null);
+var TITLE_RESIZE_END = 20;
+var TITLE_RESIZE_THRESHOLD = 36;
+var PhaseContext = /*#__PURE__*/createContext(null);
+var ScrollHandlerContext = /*#__PURE__*/createContext(null);
 function adaptiveIslandHOC(ComposedComponent) {
-  return class AdaptiveIsland extends Component {
-    static propTypes = ComposedComponent.propTypes;
-    state = {
-      phase: null
-    };
-    onContentScroll = _ref => {
-      var _this$state$phase;
-      let {
-        scrollTop,
-        scrollHeight,
-        clientHeight
-      } = _ref;
-      if (scrollHeight - clientHeight >= interpolateLinear(TITLE_RESIZE_THRESHOLD, TITLE_RESIZE_END, (_this$state$phase = this.state.phase) !== null && _this$state$phase !== void 0 ? _this$state$phase : 0)) {
-        const phase = Math.min(1, scrollTop / TITLE_RESIZE_END);
-        this.setState({
-          phase
-        });
+  var _class;
+  return _class = /*#__PURE__*/function (_Component) {
+    _inherits(AdaptiveIsland, _Component);
+    var _super = _createSuper(AdaptiveIsland);
+    function AdaptiveIsland() {
+      var _this;
+      _classCallCheck(this, AdaptiveIsland);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
-    };
-    render() {
-      return /*#__PURE__*/React.createElement(PhaseContext.Provider, {
-        value: this.state.phase
-      }, /*#__PURE__*/React.createElement(ScrollHandlerContext.Provider, {
-        value: this.onContentScroll
-      }, /*#__PURE__*/React.createElement(ComposedComponent, this.props)));
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        phase: null
+      });
+      _defineProperty(_assertThisInitialized(_this), "onContentScroll", function (_ref) {
+        var _this$state$phase;
+        var scrollTop = _ref.scrollTop,
+          scrollHeight = _ref.scrollHeight,
+          clientHeight = _ref.clientHeight;
+        if (scrollHeight - clientHeight >= interpolateLinear(TITLE_RESIZE_THRESHOLD, TITLE_RESIZE_END, (_this$state$phase = _this.state.phase) !== null && _this$state$phase !== void 0 ? _this$state$phase : 0)) {
+          var phase = Math.min(1, scrollTop / TITLE_RESIZE_END);
+          _this.setState({
+            phase: phase
+          });
+        }
+      });
+      return _this;
     }
-  };
+    _createClass(AdaptiveIsland, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/React.createElement(PhaseContext.Provider, {
+          value: this.state.phase
+        }, /*#__PURE__*/React.createElement(ScrollHandlerContext.Provider, {
+          value: this.onContentScroll
+        }, /*#__PURE__*/React.createElement(ComposedComponent, this.props)));
+      }
+    }]);
+    return AdaptiveIsland;
+  }(Component), _defineProperty(_class, "propTypes", ComposedComponent.propTypes), _class;
 }
 
 export { PhaseContext, ScrollHandlerContext, adaptiveIslandHOC as default };

package/dist/island/content.js

@@ -1,4 +1,5 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, m as _assertThisInitialized, _ as _createClass, h as _objectWithoutProperties, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
 import React, { Component, forwardRef } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -8,125 +9,139 @@ import { m as modules_e6a056e1 } from '../_helpers/island.js';
 import { ScrollHandlerContext } from './adaptive-island-hoc.js';
 import '../global/linear-function.js';
 
-const scheduleScrollAction = scheduleRAF();
-const noop = () => {};
-const END_DISTANCE = 16;
-class Content extends Component {
-  static propTypes = {
-    children: PropTypes.node,
-    className: PropTypes.string,
-    scrollableWrapperClassName: PropTypes.string,
-    fade: PropTypes.bool,
-    bottomBorder: PropTypes.bool,
-    onScroll: PropTypes.func,
-    onScrollToBottom: PropTypes.func
-  };
-  static defaultProps = {
-    fade: true,
-    bottomBorder: false,
-    onScroll: noop,
-    onScrollToBottom: noop
-  };
-  state = {
-    scrolledToTop: true,
-    scrolledToBottom: false
-  };
-  componentWillUnmount() {
-    this.scrollableNode = null;
-    if (!this.wrapperNode) {
-      return;
+var _excluded = ["children", "className", "bottomBorder", "scrollableWrapperClassName", "onScroll", "onScrollToBottom", "fade"];
+var scheduleScrollAction = scheduleRAF();
+var noop = function noop() {};
+var END_DISTANCE = 16;
+var Content = /*#__PURE__*/function (_Component) {
+  _inherits(Content, _Component);
+  var _super = _createSuper(Content);
+  function Content() {
+    var _this;
+    _classCallCheck(this, Content);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    this.resizeDetector.removeAllListeners(this.wrapperNode);
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      scrolledToTop: true,
+      scrolledToBottom: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "resizeDetector", createResizeDetector({
+      strategy: 'scroll'
+    }));
+    _defineProperty(_assertThisInitialized(_this), "wrapperNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "setWrapper", function (node) {
+      if (!node) {
+        return;
+      }
+      _this.wrapperNode = node;
+      _this.resizeDetector.listenTo(node, _this.calculateScrollPosition);
+    });
+    _defineProperty(_assertThisInitialized(_this), "calculateScrollPosition", function () {
+      return scheduleScrollAction(function () {
+        var _assertThisInitialize = _assertThisInitialized(_this),
+          scrollableNode = _assertThisInitialize.scrollableNode;
+        if (!scrollableNode) {
+          return;
+        }
+        _this.props.onScroll(scrollableNode);
+        var scrollTop = scrollableNode.scrollTop,
+          scrollHeight = scrollableNode.scrollHeight,
+          offsetHeight = scrollableNode.offsetHeight;
+        var scrolledToTop = scrollTop === 0;
+        var scrolledToBottom = offsetHeight + scrollTop >= scrollHeight - END_DISTANCE;
+        if (scrolledToBottom) {
+          var _this$props$onScrollT, _this$props;
+          (_this$props$onScrollT = (_this$props = _this.props).onScrollToBottom) === null || _this$props$onScrollT === void 0 ? void 0 : _this$props$onScrollT.call(_this$props);
+        }
+        _this.setState({
+          scrolledToTop: scrolledToTop,
+          scrolledToBottom: scrolledToBottom
+        });
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollableNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "setScrollableNodeAndCalculatePosition", function (node) {
+      if (!node) {
+        return;
+      }
+      _this.scrollableNode = node;
+      _this.calculateScrollPosition();
+    });
+    return _this;
   }
-  resizeDetector = createResizeDetector({
-    strategy: 'scroll'
-  });
-  wrapperNode;
-  setWrapper = node => {
-    if (!node) {
-      return;
+  _createClass(Content, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.scrollableNode = null;
+      if (!this.wrapperNode) {
+        return;
+      }
+      this.resizeDetector.removeAllListeners(this.wrapperNode);
     }
-    this.wrapperNode = node;
-    this.resizeDetector.listenTo(node, this.calculateScrollPosition);
-  };
-  calculateScrollPosition = () => scheduleScrollAction(() => {
-    const {
-      scrollableNode
-    } = this;
-    if (!scrollableNode) {
-      return;
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames;
+      var _this$props2 = this.props,
+        children = _this$props2.children,
+        className = _this$props2.className,
+        bottomBorder = _this$props2.bottomBorder,
+        scrollableWrapperClassName = _this$props2.scrollableWrapperClassName;
+        _this$props2.onScroll;
+        _this$props2.onScrollToBottom;
+        var fade = _this$props2.fade,
+        restProps = _objectWithoutProperties(_this$props2, _excluded);
+      var _this$state = this.state,
+        scrolledToTop = _this$state.scrolledToTop,
+        scrolledToBottom = _this$state.scrolledToBottom;
+      var classes = classNames(modules_e6a056e1.content, className, (_classNames = {}, _defineProperty(_classNames, modules_e6a056e1.contentWithTopFade, fade && !scrolledToTop), _defineProperty(_classNames, modules_e6a056e1.contentWithBottomFade, fade && !scrolledToBottom), _defineProperty(_classNames, modules_e6a056e1.withTransparentBottomBorder, bottomBorder), _defineProperty(_classNames, modules_e6a056e1.withBottomBorder, bottomBorder && !scrolledToBottom), _classNames));
+      var scrollableWrapperClasses = classNames(modules_e6a056e1.scrollableWrapper, scrollableWrapperClassName);
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        "data-test": "ring-island-content",
+        className: classes
+      }), /*#__PURE__*/React.createElement("div", {
+        // it has to be focusable because it can be scrollable
+        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+        tabIndex: 0,
+        "data-scrollable-container": true,
+        className: scrollableWrapperClasses,
+        ref: this.setScrollableNodeAndCalculatePosition,
+        onScroll: fade ? this.calculateScrollPosition : noop
+      }, fade && /*#__PURE__*/React.createElement("div", {
+        ref: this.setWrapper
+      }, children), !fade && children));
     }
-    this.props.onScroll(scrollableNode);
-    const {
-      scrollTop,
-      scrollHeight,
-      offsetHeight
-    } = scrollableNode;
-    const scrolledToTop = scrollTop === 0;
-    const scrolledToBottom = offsetHeight + scrollTop >= scrollHeight - END_DISTANCE;
-    if (scrolledToBottom) {
-      this.props.onScrollToBottom?.();
-    }
-    this.setState({
-      scrolledToTop,
-      scrolledToBottom
-    });
+  }]);
+  return Content;
+}(Component);
+_defineProperty(Content, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  scrollableWrapperClassName: PropTypes.string,
+  fade: PropTypes.bool,
+  bottomBorder: PropTypes.bool,
+  onScroll: PropTypes.func,
+  onScrollToBottom: PropTypes.func
+});
+_defineProperty(Content, "defaultProps", {
+  fade: true,
+  bottomBorder: false,
+  onScroll: noop,
+  onScrollToBottom: noop
+});
+var ContentWrapper = /*#__PURE__*/forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(ScrollHandlerContext.Consumer, null, function (onScroll) {
+    var addProps = onScroll != null ? {
+      onScroll: onScroll,
+      bottomBorder: true
+    } : {};
+    return /*#__PURE__*/React.createElement(Content, _extends({}, props, addProps, {
+      ref: ref
+    }));
   });
-  scrollableNode;
-  setScrollableNodeAndCalculatePosition = node => {
-    if (!node) {
-      return;
-    }
-    this.scrollableNode = node;
-    this.calculateScrollPosition();
-  };
-  render() {
-    const {
-      children,
-      className,
-      bottomBorder,
-      scrollableWrapperClassName,
-      onScroll,
-      onScrollToBottom,
-      fade,
-      ...restProps
-    } = this.props;
-    const {
-      scrolledToTop,
-      scrolledToBottom
-    } = this.state;
-    const classes = classNames(modules_e6a056e1.content, className, {
-      [modules_e6a056e1.contentWithTopFade]: fade && !scrolledToTop,
-      [modules_e6a056e1.contentWithBottomFade]: fade && !scrolledToBottom,
-      [modules_e6a056e1.withTransparentBottomBorder]: bottomBorder,
-      [modules_e6a056e1.withBottomBorder]: bottomBorder && !scrolledToBottom
-    });
-    const scrollableWrapperClasses = classNames(modules_e6a056e1.scrollableWrapper, scrollableWrapperClassName);
-    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-      "data-test": "ring-island-content",
-      className: classes
-    }), /*#__PURE__*/React.createElement("div", {
-      // it has to be focusable because it can be scrollable
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-      tabIndex: 0,
-      "data-scrollable-container": true,
-      className: scrollableWrapperClasses,
-      ref: this.setScrollableNodeAndCalculatePosition,
-      onScroll: fade ? this.calculateScrollPosition : noop
-    }, fade && /*#__PURE__*/React.createElement("div", {
-      ref: this.setWrapper
-    }, children), !fade && children));
-  }
-}
-const ContentWrapper = /*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/React.createElement(ScrollHandlerContext.Consumer, null, onScroll => {
-  const addProps = onScroll != null ? {
-    onScroll,
-    bottomBorder: true
-  } : {};
-  return /*#__PURE__*/React.createElement(Content, _extends({}, props, addProps, {
-    ref: ref
-  }));
-}));
+});
 ContentWrapper.displayName = 'ContentWrapper';
 
 export { ContentWrapper as default };

package/dist/island/header.js

@@ -1,4 +1,5 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, _ as _createClass, h as _objectWithoutProperties, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -6,7 +7,8 @@ import { interpolateLinear } from '../global/linear-function.js';
 import { m as modules_e6a056e1 } from '../_helpers/island.js';
 import { PhaseContext } from './adaptive-island-hoc.js';
 
-const Start = {
+var _excluded = ["children", "className", "wrapWithTitle", "border", "phase"];
+var Start = {
   FONT_SIZE: 24,
   LINE_HEIGHT: 28,
   PADDING_TOP: 24,
@@ -15,7 +17,7 @@ const Start = {
   Y: 0,
   SPACING: 0
 };
-const End = {
+var End = {
   FONT_SIZE: 13,
   LINE_HEIGHT: 20,
   PADDING_TOP: 16,
@@ -25,60 +27,71 @@ const End = {
   Y: 0.1,
   SPACING: 1.09
 };
-const BORDER_APPEAR_PHASE = 0.5;
-class Header extends Component {
-  static propTypes = {
-    children: PropTypes.node,
-    className: PropTypes.string,
-    border: PropTypes.bool,
-    wrapWithTitle: PropTypes.bool,
-    phase: PropTypes.number
-  };
-  static defaultProps = {
-    wrapWithTitle: true
-  };
-  style(name) {
-    var _this$props$phase;
-    return interpolateLinear(Start[name], End[name], (_this$props$phase = this.props.phase) !== null && _this$props$phase !== void 0 ? _this$props$phase : 0);
+var BORDER_APPEAR_PHASE = 0.5;
+var Header = /*#__PURE__*/function (_Component) {
+  _inherits(Header, _Component);
+  var _super = _createSuper(Header);
+  function Header() {
+    _classCallCheck(this, Header);
+    return _super.apply(this, arguments);
   }
-  render() {
-    const {
-      children,
-      className,
-      wrapWithTitle,
-      border,
-      phase,
-      ...restProps
-    } = this.props;
-    const classes = classNames(modules_e6a056e1.header, className, {
-      [modules_e6a056e1.withBottomBorder]: border || phase != null && phase >= BORDER_APPEAR_PHASE
-    });
-    const headerStyle = phase != null ? {
-      lineHeight: `${this.style('LINE_HEIGHT')}px`,
-      paddingTop: this.style('PADDING_TOP'),
-      paddingBottom: this.style('PADDING_BOTTOM')
-    } : undefined;
-    const scaleFont = phase != null && this.style('FONT_SIZE') / Start.FONT_SIZE;
-    const titleStyle = phase != null && phase < 1 ? {
-      fontSize: Start.FONT_SIZE,
-      transform: `translate(${this.style('X')}px, ${this.style('Y')}px) scale(${scaleFont})`,
-      letterSpacing: this.style('SPACING')
-    } : undefined;
-    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-      "data-test": "ring-island-header",
-      className: classes,
-      style: headerStyle
-    }), wrapWithTitle && /*#__PURE__*/React.createElement("h2", {
-      className: modules_e6a056e1.title,
-      style: titleStyle
-    }, children), !wrapWithTitle && children);
-  }
-}
-const HeaderWrapper = props => /*#__PURE__*/React.createElement(PhaseContext.Consumer, null, phase => {
-  const addProps = phase != null ? {
-    phase
-  } : {};
-  return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
+  _createClass(Header, [{
+    key: "style",
+    value: function style(name) {
+      var _this$props$phase;
+      return interpolateLinear(Start[name], End[name], (_this$props$phase = this.props.phase) !== null && _this$props$phase !== void 0 ? _this$props$phase : 0);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        wrapWithTitle = _this$props.wrapWithTitle,
+        border = _this$props.border,
+        phase = _this$props.phase,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_e6a056e1.header, className, _defineProperty({}, modules_e6a056e1.withBottomBorder, border || phase != null && phase >= BORDER_APPEAR_PHASE));
+      var headerStyle = phase != null ? {
+        lineHeight: "".concat(this.style('LINE_HEIGHT'), "px"),
+        paddingTop: this.style('PADDING_TOP'),
+        paddingBottom: this.style('PADDING_BOTTOM')
+      } : undefined;
+      var scaleFont = phase != null && this.style('FONT_SIZE') / Start.FONT_SIZE;
+      var titleStyle = phase != null && phase < 1 ? {
+        fontSize: Start.FONT_SIZE,
+        transform: "translate(".concat(this.style('X'), "px, ").concat(this.style('Y'), "px) scale(").concat(scaleFont, ")"),
+        letterSpacing: this.style('SPACING')
+      } : undefined;
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        "data-test": "ring-island-header",
+        className: classes,
+        style: headerStyle
+      }), wrapWithTitle && /*#__PURE__*/React.createElement("h2", {
+        className: modules_e6a056e1.title,
+        style: titleStyle
+      }, children), !wrapWithTitle && children);
+    }
+  }]);
+  return Header;
+}(Component);
+_defineProperty(Header, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  border: PropTypes.bool,
+  wrapWithTitle: PropTypes.bool,
+  phase: PropTypes.number
+});
+_defineProperty(Header, "defaultProps", {
+  wrapWithTitle: true
 });
+var HeaderWrapper = function HeaderWrapper(props) {
+  return /*#__PURE__*/React.createElement(PhaseContext.Consumer, null, function (phase) {
+    var addProps = phase != null ? {
+      phase: phase
+    } : {};
+    return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
+  });
+};
 
 export { HeaderWrapper as default };

package/dist/island/island.js

@@ -1,4 +1,4 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, _ as _createClass, h as _objectWithoutProperties, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -7,40 +7,52 @@ import adaptiveIslandHOC from './adaptive-island-hoc.js';
 import { m as modules_e6a056e1 } from '../_helpers/island.js';
 export { default as Header } from './header.js';
 export { default as Content } from './content.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
 import '../global/linear-function.js';
 import 'element-resize-detector';
 import '../global/schedule-raf.js';
 
+var _excluded = ["children", "className", "narrow", "withoutPaddings", "data-test"];
 /**
  * @name Island
  */
-class Island extends Component {
-  static propTypes = {
-    children: PropTypes.node,
-    className: PropTypes.string,
-    narrow: PropTypes.bool,
-    withoutPaddings: PropTypes.bool,
-    'data-test': PropTypes.string
-  };
-  render() {
-    const {
-      children,
-      className,
-      narrow,
-      withoutPaddings,
-      'data-test': dataTest,
-      ...restProps
-    } = this.props;
-    const classes = classNames(modules_e6a056e1.island, className, {
-      [modules_e6a056e1.narrowIsland]: narrow,
-      [modules_e6a056e1.withoutPaddings]: withoutPaddings
-    });
-    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-      className: classes,
-      "data-test": joinDataTestAttributes('ring-island', dataTest)
-    }), children);
+var Island = /*#__PURE__*/function (_Component) {
+  _inherits(Island, _Component);
+  var _super = _createSuper(Island);
+  function Island() {
+    _classCallCheck(this, Island);
+    return _super.apply(this, arguments);
   }
-}
-const AdaptiveIsland = adaptiveIslandHOC(Island);
+  _createClass(Island, [{
+    key: "render",
+    value: function render() {
+      var _classNames;
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        narrow = _this$props.narrow,
+        withoutPaddings = _this$props.withoutPaddings,
+        dataTest = _this$props['data-test'],
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_e6a056e1.island, className, (_classNames = {}, _defineProperty(_classNames, modules_e6a056e1.narrowIsland, narrow), _defineProperty(_classNames, modules_e6a056e1.withoutPaddings, withoutPaddings), _classNames));
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes,
+        "data-test": joinDataTestAttributes('ring-island', dataTest)
+      }), children);
+    }
+  }]);
+  return Island;
+}(Component);
+_defineProperty(Island, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  narrow: PropTypes.bool,
+  withoutPaddings: PropTypes.bool,
+  'data-test': PropTypes.string
+});
+var AdaptiveIsland = adaptiveIslandHOC(Island);
 
 export { AdaptiveIsland, Island as default };

package/dist/island-legacy/content-legacy.js

@@ -1,24 +1,34 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { c as _defineProperty, j as _inherits, k as _createSuper, b as _classCallCheck, _ as _createClass, h as _objectWithoutProperties, i as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 
-class Content extends PureComponent {
-  static propTypes = {
-    className: PropTypes.string,
-    children: PropTypes.node
-  };
-  render() {
-    const {
-      children,
-      className,
-      ...restProps
-    } = this.props;
-    const classes = classNames('ring-island__content', className);
-    return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-      className: classes
-    }), children);
+var _excluded = ["children", "className"];
+var Content = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Content, _PureComponent);
+  var _super = _createSuper(Content);
+  function Content() {
+    _classCallCheck(this, Content);
+    return _super.apply(this, arguments);
   }
-}
+  _createClass(Content, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames('ring-island__content', className);
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes
+      }), children);
+    }
+  }]);
+  return Content;
+}(PureComponent);
+_defineProperty(Content, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
 
 export { Content as default };