@jetbrains/ring-ui 5.1.1 → 5.1.4

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

@@ -1,42 +1,53 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d 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) {
   var _class;
-  return _class = class AdaptiveIsland extends Component {
-    constructor() {
-      super(...arguments);
-      _defineProperty(this, "state", {
+  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];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
         phase: null
       });
-      _defineProperty(this, "onContentScroll", _ref => {
+      _defineProperty(_assertThisInitialized(_this), "onContentScroll", function (_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 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;
     }
-    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)));
-    }
-  }, _defineProperty(_class, "propTypes", ComposedComponent.propTypes), _class;
+    _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.d.ts

@@ -37,7 +37,7 @@ declare class Content extends Component<IslandContentInnerProps> {
     calculateScrollPosition: () => void;
     scrollableNode?: HTMLElement | null;
     setScrollableNodeAndCalculatePosition: (node: HTMLElement | null) => void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 declare const ContentWrapper: React.ForwardRefExoticComponent<IslandContentProps & React.RefAttributes<Content>>;
 export default ContentWrapper;

package/dist/island/content.js

@@ -1,4 +1,5 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f 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,104 +9,113 @@ 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 {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "state", {
+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 = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
       scrolledToTop: true,
       scrolledToBottom: false
     });
-    _defineProperty(this, "resizeDetector", createResizeDetector({
+    _defineProperty(_assertThisInitialized(_this), "resizeDetector", createResizeDetector({
       strategy: 'scroll'
     }));
-    _defineProperty(this, "wrapperNode", void 0);
-    _defineProperty(this, "setWrapper", node => {
+    _defineProperty(_assertThisInitialized(_this), "wrapperNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "setWrapper", function (node) {
       if (!node) {
         return;
       }
-      this.wrapperNode = node;
-      this.resizeDetector.listenTo(node, this.calculateScrollPosition);
+      _this.wrapperNode = node;
+      _this.resizeDetector.listenTo(node, _this.calculateScrollPosition);
     });
-    _defineProperty(this, "calculateScrollPosition", () => scheduleScrollAction(() => {
-      const {
-        scrollableNode
-      } = this;
-      if (!scrollableNode) {
-        return;
-      }
-      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
+    _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(this, "scrollableNode", void 0);
-    _defineProperty(this, "setScrollableNodeAndCalculatePosition", node => {
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollableNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "setScrollableNodeAndCalculatePosition", function (node) {
       if (!node) {
         return;
       }
-      this.scrollableNode = node;
-      this.calculateScrollPosition();
+      _this.scrollableNode = node;
+      _this.calculateScrollPosition();
     });
+    return _this;
   }
-  componentWillUnmount() {
-    this.scrollableNode = null;
-    if (!this.wrapperNode) {
-      return;
+  _createClass(Content, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.scrollableNode = null;
+      if (!this.wrapperNode) {
+        return;
+      }
+      this.resizeDetector.removeAllListeners(this.wrapperNode);
     }
-    this.resizeDetector.removeAllListeners(this.wrapperNode);
-  }
-  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));
-  }
-}
+  }, {
+    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));
+    }
+  }]);
+  return Content;
+}(Component);
 _defineProperty(Content, "propTypes", {
   children: PropTypes.node,
   className: PropTypes.string,
@@ -121,15 +131,17 @@ _defineProperty(Content, "defaultProps", {
   onScroll: noop,
   onScrollToBottom: noop
 });
-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
-  }));
-}));
+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
+    }));
+  });
+});
 ContentWrapper.displayName = 'ContentWrapper';
 
 export { ContentWrapper as default };

package/dist/island/header.d.ts

@@ -1,8 +1,8 @@
-import { HTMLAttributes } from 'react';
+import React, { HTMLAttributes } from 'react';
 export interface IslandHeaderProps extends HTMLAttributes<HTMLElement> {
     wrapWithTitle?: boolean | undefined;
     border?: boolean | null | undefined;
     phase?: number | undefined;
 }
-declare const HeaderWrapper: (props: IslandHeaderProps) => JSX.Element;
+declare const HeaderWrapper: (props: IslandHeaderProps) => React.JSX.Element;
 export default HeaderWrapper;

package/dist/island/header.js

@@ -1,4 +1,5 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f 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,45 +27,54 @@ const End = {
   Y: 0.1,
   SPACING: 1.09
 };
-const BORDER_APPEAR_PHASE = 0.5;
-class Header extends Component {
-  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);
-  }
-}
+  _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,
@@ -74,11 +85,13 @@ _defineProperty(Header, "propTypes", {
 _defineProperty(Header, "defaultProps", {
   wrapWithTitle: true
 });
-const HeaderWrapper = props => /*#__PURE__*/React.createElement(PhaseContext.Consumer, null, phase => {
-  const addProps = phase != null ? {
-    phase
-  } : {};
-  return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
-});
+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.d.ts

@@ -16,7 +16,7 @@ export default class Island extends Component<IslandProps> {
         withoutPaddings: PropTypes.Requireable<boolean>;
         'data-test': PropTypes.Requireable<string>;
     };
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 export declare const AdaptiveIsland: {
     new (props: IslandProps | Readonly<IslandProps>): {
@@ -24,7 +24,7 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): JSX.Element;
+        render(): React.JSX.Element;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
@@ -50,7 +50,7 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): JSX.Element;
+        render(): React.JSX.Element;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;

package/dist/island/island.js

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -7,33 +7,45 @@ 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 {
-  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);
   }
-}
+  _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,
@@ -41,6 +53,6 @@ _defineProperty(Island, "propTypes", {
   withoutPaddings: PropTypes.bool,
   'data-test': PropTypes.string
 });
-const AdaptiveIsland = adaptiveIslandHOC(Island);
+var AdaptiveIsland = adaptiveIslandHOC(Island);
 
 export { AdaptiveIsland, Island as default };

package/dist/island-legacy/content-legacy.d.ts

@@ -1,4 +1,4 @@
-import { HTMLAttributes, PureComponent } from 'react';
+import React, { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Content extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,5 +6,5 @@ export default class Content extends PureComponent<HTMLAttributes<HTMLElement>>
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

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

@@ -1,21 +1,31 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 
-class Content extends PureComponent {
-  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