@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/island/content.js

@@ -0,0 +1,151 @@
+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';
+import createResizeDetector from 'element-resize-detector';
+import scheduleRAF from '../global/schedule-raf.js';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import { ScrollHandlerContext } from './adaptive-island-hoc.js';
+import '../global/linear-function.js';
+
+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(_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 || _this$props$onScrollT.call(_this$props);
+        }
+        _this.setState({
+          scrolledToTop,
+          scrolledToBottom
+        });
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollableNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "setScrollableNodeAndCalculatePosition", function (node) {
+      if (!node) {
+        return;
+      }
+      _this.scrollableNode = node;
+      _this.calculateScrollPosition();
+    });
+    return _this;
+  }
+  _createClass(Content, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.scrollableNode = null;
+      if (!this.wrapperNode) {
+        return;
+      }
+      this.resizeDetector.removeAllListeners(this.wrapperNode);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      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, {
+        [modules_e6a056e1.contentWithTopFade]: fade && !scrolledToTop,
+        [modules_e6a056e1.contentWithBottomFade]: fade && !scrolledToBottom,
+        [modules_e6a056e1.withTransparentBottomBorder]: bottomBorder,
+        [modules_e6a056e1.withBottomBorder]: bottomBorder && !scrolledToBottom
+      });
+      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,
+  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,
+      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

@@ -0,0 +1,8 @@
+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) => React.JSX.Element;
+export default HeaderWrapper;

package/dist/island/header.js

@@ -0,0 +1,100 @@
+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';
+import { interpolateLinear } from '../global/linear-function.js';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import { PhaseContext } from './adaptive-island-hoc.js';
+
+var _excluded = ["children", "className", "wrapWithTitle", "border", "phase"];
+var Start = {
+  FONT_SIZE: 24,
+  LINE_HEIGHT: 28,
+  PADDING_TOP: 24,
+  PADDING_BOTTOM: 0,
+  X: 0,
+  Y: 0,
+  SPACING: 0
+};
+var End = {
+  FONT_SIZE: 13,
+  LINE_HEIGHT: 20,
+  PADDING_TOP: 16,
+  PADDING_BOTTOM: 8,
+  // Compensation
+  X: 0.4,
+  Y: 0.1,
+  SPACING: 1.09
+};
+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);
+  }
+  _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, {
+        [modules_e6a056e1.withBottomBorder]: border || phase != null && phase >= BORDER_APPEAR_PHASE
+      });
+      var headerStyle = phase != null ? {
+        lineHeight: "".concat(this.style('LINE_HEIGHT'), "px"),
+        // need to append px because number is a valid line-height value
+        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
+    } : {};
+    return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
+  });
+};
+
+export { HeaderWrapper as default };

package/dist/island/island.d.ts

@@ -0,0 +1,78 @@
+import React, { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface IslandProps extends HTMLAttributes<HTMLElement> {
+    narrow?: boolean | null | undefined;
+    withoutPaddings?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+/**
+ * @name Island
+ */
+export default class Island extends Component<IslandProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        narrow: PropTypes.Requireable<boolean>;
+        withoutPaddings: PropTypes.Requireable<boolean>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    render(): React.JSX.Element;
+}
+export declare const AdaptiveIsland: {
+    new (props: IslandProps | Readonly<IslandProps>): {
+        state: {
+            phase: null;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        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;
+        readonly props: Readonly<IslandProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: IslandProps, context: any): {
+        state: {
+            phase: null;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        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;
+        readonly props: Readonly<IslandProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: React.WeakValidationMap<IslandProps> | undefined;
+    contextType?: React.Context<any> | undefined;
+};
+export { default as Header } from './header';
+export { default as Content } from './content';

package/dist/island/island.js

@@ -0,0 +1,60 @@
+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';
+import joinDataTestAttributes from '../global/data-tests.js';
+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
+ */
+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 _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, {
+        [modules_e6a056e1.narrowIsland]: narrow,
+        [modules_e6a056e1.withoutPaddings]: withoutPaddings
+      });
+      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.d.ts

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

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

@@ -0,0 +1,34 @@
+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';
+
+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 };

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

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

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

@@ -0,0 +1,36 @@
+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';
+
+var _excluded = ["children", "className"];
+var Header = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Header, _PureComponent);
+  var _super = _createSuper(Header);
+  function Header() {
+    _classCallCheck(this, Header);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Header, [{
+    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__header', className);
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "ring-island__title"
+      }, children));
+    }
+  }]);
+  return Header;
+}(PureComponent);
+_defineProperty(Header, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Header as default };

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

@@ -0,0 +1,12 @@
+import React, { HTMLAttributes, PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import './island-legacy.css';
+export default class Island extends PureComponent<HTMLAttributes<HTMLElement>> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    render(): React.JSX.Element;
+}
+export { default as Header } from './header-legacy';
+export { default as Content } from './content-legacy';

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

@@ -0,0 +1,36 @@
+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';
+export { default as Header } from './header-legacy.js';
+export { default as Content } from './content-legacy.js';
+
+var _excluded = ["children", "className"];
+var Island = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Island, _PureComponent);
+  var _super = _createSuper(Island);
+  function Island() {
+    _classCallCheck(this, Island);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Island, [{
+    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', className);
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes
+      }), children);
+    }
+  }]);
+  return Island;
+}(PureComponent);
+_defineProperty(Island, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Island as default };

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

@@ -0,0 +1,44 @@
+import 'core-js/modules/es.array.concat.js';
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import scheduleRAF from '../global/schedule-raf.js';
+import compile from './island-ng-class-fixer.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+
+var scheduleScroll = scheduleRAF();
+var angularModule = angular.module('Ring.island-ng.header', []);
+angularModule.directive('rgIslandContent', function islandContentDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      fade: '=?',
+      onScroll: '&?'
+    },
+    compile,
+    template: "\n<div\n  data-test=\"ring-island-content\"\n  class=".concat(modules_e6a056e1.content, "\n  ng-class=\"{\n    '").concat(modules_e6a056e1.contentWithTopFade, "': contentCtrl.fade,\n    '").concat(modules_e6a056e1.contentWithBottomFade, "': contentCtrl.fade\n  }\"\n>\n  <div\n    tabindex=\"0\"\n    class=\"").concat(modules_e6a056e1.scrollableWrapper, " js-scrollable-wrapper\"\n    ng-transclude\n  ></div>\n</div>\n"),
+    controllerAs: 'contentCtrl',
+    controller: ["$scope", "$element", function controller($scope, $element) {
+      var _this = this;
+      var el = $element[0];
+      if (this.onScroll) {
+        var scrollable = el.querySelector('.js-scrollable-wrapper');
+        var scrollCallback = function scrollCallback(evt) {
+          var $scrollTop = scrollable.scrollTop;
+          _this.onScroll({
+            $event: evt,
+            $scrollTop
+          });
+          $scope.$apply();
+        };
+        scrollable.addEventListener('scroll', function () {
+          return scheduleScroll(scrollCallback);
+        });
+      }
+    }]
+  };
+});
+var IslandContent = angularModule.name;
+
+export { IslandContent as default };

package/dist/island-ng/island-header-ng.js

@@ -0,0 +1,29 @@
+import 'core-js/modules/es.array.concat.js';
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import compile from './island-ng-class-fixer.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+
+var angularModule = angular.module('Ring.island-ng.content', []);
+angularModule.directive('rgIslandHeader', function islandHeaderDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      border: '=?'
+    },
+    compile,
+    template: "\n<div\n  data-test=\"ring-island-header\"\n  class=\"".concat(modules_e6a056e1.header, "\"\n  ng-class=\"{'").concat(modules_e6a056e1.withBottomBorder, "': headerCtrl.border}\" \n  ng-transclude\n></div>\n"),
+    controllerAs: 'headerCtrl',
+    controller: function controller() {
+      var _this = this;
+      this.$onInit = function () {
+        _this.wrapWithTitle = _this.wrapWithTitle !== undefined ? _this.wrapWithTitle : true;
+      };
+    }
+  };
+});
+var IslandHeader = angularModule.name;
+
+export { IslandHeader as default };

package/dist/island-ng/island-ng-class-fixer.js

@@ -0,0 +1,12 @@
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+
+// Workaround fo Angular bug with ng-class & replace: true support
+// See https://github.com/angular/angular.js/issues/5695#issuecomment-31898355
+function compile(tElement, tAttrs) {
+  if (tAttrs.ngClass) {
+    tAttrs.ngClass = tAttrs.ngClass.replace(/}\s*{/g, ', ');
+  }
+}
+
+export { compile as default };

package/dist/island-ng/island-ng.js

@@ -0,0 +1,27 @@
+import 'core-js/modules/es.array.concat.js';
+import angular from 'angular';
+import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import IslandHeader from './island-header-ng.js';
+import IslandContent from './island-content-ng.js';
+import compile from './island-ng-class-fixer.js';
+import '../global/schedule-raf.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+
+var angularModule = angular.module('Ring.island-ng', [IslandHeader, IslandContent]);
+angularModule.directive('rgIsland', function islandDirective() {
+  return {
+    transclude: true,
+    replace: true,
+    bindToController: {
+      narrow: '='
+    },
+    compile,
+    template: "\n<div\n  data-test=\"ring-island\"\n  class=\"".concat(modules_e6a056e1.island, "\"\n  ng-class=\"{'").concat(modules_e6a056e1.narrowIsland, "': islandCtrl.narrow}\"\n  ng-transclude\n></div>\n"),
+    controllerAs: 'islandCtrl',
+    controller: angular.noop
+  };
+});
+var islandNg = angularModule.name;
+
+export { islandNg as default };