@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/button-group-ng/button-group-ng.js

@@ -0,0 +1,38 @@
+import angular from 'angular';
+import classNames from 'classnames';
+import { m as modules_1068e447 } from '../_helpers/button-group.js';
+
+var modules_c53cb36f = {"buttonGroup":"buttonGroup_rui_6db3"};
+
+/**
+ * @name Button Group Ng
+ */
+
+const angularModule = angular.module('Ring.button-group', []);
+const buttonGroupClasses = classNames(modules_1068e447.buttonGroup, modules_c53cb36f.buttonGroup);
+
+function rgButtonGroup() {
+  return {
+    restrict: 'A',
+    link: function link($scope, iElement) {
+      const element = iElement[0];
+      element.classList.add(...buttonGroupClasses.split(' '));
+    }
+  };
+}
+
+function rgButtonGroupCaption() {
+  return {
+    restrict: 'A',
+    link: function link($scope, iElement) {
+      const element = iElement[0];
+      element.classList.add(...modules_1068e447.caption.split(' '));
+    }
+  };
+}
+
+angularModule.directive('rgButtonGroup', rgButtonGroup);
+angularModule.directive('rgButtonGroupCaption', rgButtonGroupCaption);
+var buttonGroupNg = angularModule.name;
+
+export { buttonGroupNg as default };

package/dist/button-ng/button-ng.js

@@ -0,0 +1,223 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import angular from 'angular';
+import classNames from 'classnames';
+import RingAngularComponent from '../global/ring-angular-component.js';
+import { addClasses, removeClasses, applyMethodToClasses } from '../global/dom.js';
+import IconNG from '../icon-ng/icon-ng.js';
+import Theme, { applyTheme } from '../global/theme.js';
+import { m as modules_e81895c9, g as getButtonClasses } from '../_helpers/button__classes.js';
+import '../icon/icon__constants.js';
+import '../template-ng/template-ng.js';
+import '../_helpers/icon.js';
+import 'react';
+
+var modules_5f65bc62 = {"ringIconDefaultColor":"ringIconDefaultColor_rui_9b8c","iconMarginFix":"iconMarginFix_rui_9b8c","transcludeSpacer":"transcludeSpacer_rui_9b8c","buttonWithoutIcon":"buttonWithoutIcon_rui_9b8c","iconNg":"iconNg_rui_9b8c","narrowRight":"narrowRight_rui_9b8c"};
+
+const {
+  ringIconDefaultColor,
+  iconMarginFix,
+  transcludeSpacer
+} = modules_5f65bc62;
+/**
+ * @name Button Ng
+ */
+
+const angularModule = angular.module('Ring.button', [IconNG]);
+const ORDER_NOT_DEFINED = '-1';
+const buttonClassesMap = Object.values({ ...modules_e81895c9,
+  ...modules_5f65bc62
+}).reduce((acc, classes) => {
+  classes.split(' ').forEach(value => acc[value] = true);
+  return acc;
+}, {});
+const LOADER_BACKGROUND_SELECTOR = '.js-button-loader';
+
+class ButtonController extends RingAngularComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "updateClasses", () => {
+      const {
+        $attrs
+      } = this.$inject;
+      const theme = this.element.classList.contains(modules_e81895c9.light) ? Theme.LIGHT : Theme.DARK;
+      const foreignClasses = [...this.element.classList].filter(name => !buttonClassesMap[name]);
+      this.element.className = classNames(foreignClasses, getButtonClasses({
+        className: modules_e81895c9.button,
+        active: this.getAttrValue($attrs.active),
+        disabled: this.getAttrValue($attrs.disabled),
+        loader: this.getAttrValue($attrs.loader),
+        primary: $attrs.mode === 'primary' || $attrs.mode === 'blue',
+        short: this.getAttrValue($attrs.short),
+        text: this.getAttrValue($attrs.text),
+        inline: this.getAttrValue($attrs.inline),
+        danger: this.getAttrValue($attrs.danger),
+        delayed: this.getAttrValue($attrs.delayed),
+        icon: $attrs.icon,
+        theme
+      }), {
+        // Some overrides for angular buttons
+        [modules_5f65bc62.buttonWithoutIcon]: !$attrs.icon,
+        [modules_5f65bc62.narrowRight]: this.getAttrValue($attrs.narrowRight)
+      });
+
+      if (!$attrs.hasOwnProperty('mode')) {
+        addClasses(this.findTranscludeNode().classList, ringIconDefaultColor);
+      } else {
+        removeClasses(this.findTranscludeNode().classList, ringIconDefaultColor);
+      }
+    });
+
+    _defineProperty(this, "findTranscludeNode", () => this.element.querySelector('ng-transclude'));
+
+    _defineProperty(this, "updateIcon", () => {
+      const {
+        $attrs,
+        $compile,
+        $scope
+      } = this.$inject;
+      const icon = this.element.querySelector('rg-icon');
+      const transcludeNode = this.findTranscludeNode();
+      const glyph = $attrs.icon;
+      const size = $attrs.iconSize;
+      const isLoading = this.getAttrValue($attrs.loader);
+
+      if (glyph && isLoading) {
+        icon.setAttribute('loading', true);
+      } else {
+        icon.setAttribute('loading', false);
+      }
+
+      if (glyph) {
+        addClasses(transcludeNode.classList, transcludeSpacer);
+        icon.setAttribute('glyph', glyph);
+
+        if (size) {
+          icon.setAttribute('size', size);
+        }
+      } else {
+        removeClasses(transcludeNode.classList, transcludeSpacer);
+        icon.removeAttribute('glyph');
+        icon.removeAttribute('size');
+      }
+
+      $compile(icon)($scope);
+    });
+
+    const {
+      $element,
+      $attrs: _$attrs,
+      $scope: _$scope
+    } = this.$inject;
+    _$scope.styles = modules_e81895c9;
+    this.element = $element[0];
+    const modifiers = ['delayed', 'loader', 'danger', 'short', 'active', 'text', 'inline', 'narrowRight'];
+    modifiers.forEach(mod => {
+      _$scope.$watch(() => _$scope.$eval(_$attrs[mod]), val => {
+        this.updateClasses();
+        const attrName = `data-test-${mod}`;
+
+        if (val) {
+          this.element.setAttribute(attrName, true);
+        } else {
+          this.element.removeAttribute(attrName);
+        }
+
+        if (mod === 'loader') {
+          const isText = this.getAttrValue(_$attrs.text);
+          const withIcon = !!_$attrs.icon;
+          applyMethodToClasses(val && !isText && !withIcon ? 'add' : 'remove')(this.element.querySelector(LOADER_BACKGROUND_SELECTOR).classList, modules_e81895c9.loaderBackground);
+        }
+      });
+    });
+    const tabIndex = _$attrs.tabindex || ORDER_NOT_DEFINED;
+
+    if (tabIndex !== ORDER_NOT_DEFINED) {
+      this.element.setAttribute('tabindex', tabIndex);
+    }
+
+    _$scope.$watch(() => _$scope.$eval(_$attrs.loader), val => {
+      if (val) {
+        this.element.setAttribute('tabindex', ORDER_NOT_DEFINED);
+      } else if (tabIndex !== ORDER_NOT_DEFINED) {
+        this.element.setAttribute('tabindex', tabIndex);
+      } else {
+        this.element.removeAttribute('tabindex');
+      }
+    });
+  }
+
+  $postLink() {
+    this.updateClasses();
+    const {
+      $attrs
+    } = this.$inject;
+    $attrs.$observe('mode', this.updateClasses);
+    $attrs.$observe('icon', () => {
+      this.updateClasses();
+      this.updateIcon();
+    });
+    $attrs.$observe('iconSize', () => {
+      this.updateClasses();
+      this.updateIcon();
+    });
+    $attrs.$observe('theme', this.updateClasses);
+  }
+
+  getAttrValue(attribute) {
+    const {
+      $scope
+    } = this.$inject;
+    return $scope.$eval(attribute);
+  }
+
+}
+
+_defineProperty(ButtonController, "$inject", ['$element', '$attrs', '$scope', '$compile', '$log']);
+
+function changeTheme(element, data) {
+  return applyTheme({
+    element,
+    prevTheme: data.prevTheme && modules_e81895c9[data.prevTheme] || modules_e81895c9.light,
+    currentTheme: modules_e81895c9[data.currentTheme]
+  });
+}
+
+function createButtonDirective(tagName) {
+  return () => ({
+    restrict: 'E',
+    transclude: true,
+    replace: true,
+    require: {
+      rgThemeCtrl: '?^^rgTheme'
+    },
+    template: `
+  <${tagName} class="${modules_e81895c9.button} ${modules_e81895c9.light}">
+  <span class="${modules_e81895c9.content}"
+  ><rg-icon class="${classNames(modules_e81895c9.icon, modules_5f65bc62.iconNg, iconMarginFix)}"></rg-icon
+  ><ng-transclude></ng-transclude
+  ></span
+  ><div class="js-button-loader"></div>
+  </${tagName}>
+    `,
+    controller: ButtonController,
+    link: (scope, element, attrs, _ref) => {
+      let {
+        rgThemeCtrl
+      } = _ref;
+
+      if (rgThemeCtrl) {
+        changeTheme(element[0], {
+          currentTheme: rgThemeCtrl.theme
+        });
+        rgThemeCtrl.on('change', (event, data) => changeTheme(element[0], data));
+      }
+    }
+  });
+}
+
+angularModule.directive('rgButton', createButtonDirective('button'));
+angularModule.directive('rgButtonLink', createButtonDirective('a'));
+var ButtonNG = angularModule.name;
+
+export { LOADER_BACKGROUND_SELECTOR, ButtonNG as default };

package/dist/button-set/button-set.js

@@ -0,0 +1,26 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import { m as modules_fd849143 } from '../_helpers/button-set.js';
+
+/**
+ * @name Button Set
+ */
+
+class ButtonSet extends PureComponent {
+  render() {
+    const classes = classNames(modules_fd849143.buttonSet, this.props.className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, this.props, {
+      className: classes
+    }), this.props.children);
+  }
+
+}
+
+_defineProperty(ButtonSet, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string
+});
+
+export { ButtonSet as default };

package/dist/button-set-ng/button-set-ng.js

@@ -0,0 +1,19 @@
+import angular from 'angular';
+import { m as modules_fd849143 } from '../_helpers/button-set.js';
+
+const angularModule = angular.module('Ring.button-set', []);
+
+function rgButtonSet() {
+  return {
+    restrict: 'E',
+    replace: true,
+    scope: false,
+    transclude: true,
+    template: `<div class="${modules_fd849143.buttonSet}" ng-transclude></div>`
+  };
+}
+
+angularModule.directive('rgButtonSet', rgButtonSet);
+var ButtonSet = angularModule.name;
+
+export { ButtonSet as default };

package/dist/button-toolbar/button-toolbar.js

@@ -0,0 +1,29 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { m as modules_34154ec0 } from '../_helpers/button-toolbar.js';
+
+/**
+ * @name Button Toolbar
+*/
+
+class ButtonToolbar extends PureComponent {
+  render() {
+    const {
+      className
+    } = this.props;
+    const classes = classNames(modules_34154ec0.buttonToolbar, className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, this.props, {
+      className: classes
+    }));
+  }
+
+}
+
+_defineProperty(ButtonToolbar, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string
+});
+
+export { ButtonToolbar as default };

package/dist/button-toolbar-ng/button-toolbar-ng.js

@@ -0,0 +1,23 @@
+import angular from 'angular';
+import { m as modules_34154ec0 } from '../_helpers/button-toolbar.js';
+
+/**
+ * @name Button Toolbar Ng
+ */
+
+const angularModule = angular.module('Ring.button-toolbar', []);
+
+function rgButtonToolbar() {
+  return {
+    restrict: 'A',
+    link: function link($scope, iElement) {
+      const element = iElement[0];
+      element.classList.add(...modules_34154ec0.buttonToolbar.split(' '));
+    }
+  };
+}
+
+angularModule.directive('rgButtonToolbar', rgButtonToolbar);
+var buttonToolbarNg = angularModule.name;
+
+export { buttonToolbarNg as default };

package/dist/caret/caret.js

@@ -0,0 +1,264 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { getRect } from '../global/dom.js';
+
+/**
+ * @name Caret
+ */
+
+class Caret {
+  /**
+   * Line endings RegExp
+   * @type {RegExp}
+   */
+
+  /**
+   * Line endings normalizer
+   * Borrowed from jQuery
+   * @see https://github.com/jquery/jquery/blob/master/src/attributes/val.js
+   * @param value {*}
+   * @return {*}
+   */
+  static normalizeNewlines(value) {
+    return typeof value === 'string' ? value.replace(this.returnRE, '') : value;
+  }
+
+  constructor(target) {
+    this.target = target;
+  }
+
+  isContentEditable() {
+    return this.target.contentEditable === 'true';
+  }
+  /**
+   * Set focus on target if possible
+   */
+
+
+  focus() {
+    if (!document.activeElement || document.activeElement !== this.target) {
+      this.target.focus();
+    }
+  }
+  /**
+   * Get absolute caret position index
+   * @return {number}
+   */
+
+
+  getAbsolutePosition(node) {
+    let _curNode = node;
+    let curPos = 0;
+
+    while (_curNode !== this.target) {
+      while (_curNode.previousSibling) {
+        curPos += _curNode.previousSibling.textContent.length;
+        _curNode = _curNode.previousSibling;
+      }
+
+      _curNode = _curNode.parentNode;
+    }
+
+    return curPos;
+  }
+  /**
+   * Get caret position index
+   * @param {Object} [params]
+   * @param {boolean} params.avoidFocus
+   * @return {number}
+   */
+
+
+  getPosition() {
+    let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    if (this.isContentEditable()) {
+      if (!params.avoidFocus) {
+        this.focus();
+      }
+
+      const selection = window.getSelection();
+
+      if (!selection.rangeCount) {
+        return 0;
+      }
+
+      const range1 = selection.getRangeAt(0);
+      const range2 = range1.cloneRange();
+      range2.selectNodeContents(this.target);
+      range2.setEnd(range1.endContainer, range1.endOffset);
+      const _curNode = range1.startContainer;
+
+      if (this.target === _curNode) {
+        return range1.startOffset === 0 ? 0 : _curNode.textContent.length;
+      } else if (!this.target.contains(_curNode)) {
+        return -1;
+      } else if (!_curNode) {
+        return this.target.selectionStart;
+      }
+
+      const curPos = this.getAbsolutePosition(_curNode);
+
+      if (range1.startContainer === range1.endContainer) {
+        if (range1.startOffset === range1.endOffset) {
+          return curPos + range1.startOffset;
+        } else {
+          return {
+            startOffset: curPos + range1.startOffset,
+            endOffset: curPos + range1.endOffset,
+            position: range2.toString().length
+          };
+        }
+      } else {
+        const startOffset = curPos + range1.startOffset;
+        const endPos = this.getAbsolutePosition(range1.endContainer);
+        const endOffset = endPos + range1.endOffset;
+        return {
+          startOffset,
+          endOffset,
+          position: range2.toString().length
+        };
+      }
+    }
+
+    return this.target.selectionStart;
+  }
+  /**
+   * Get relative position of query
+   * @param  {Node} curNode
+   * @param {number} position
+   * @return {{_correctedPosition: number, _curNode: Node}}
+   */
+
+
+  getRelativePosition(curNode, position) {
+    let curPos = 0;
+    let _curNode = curNode;
+    const nodeTypeText = 3;
+
+    if (!_curNode) {
+      return {
+        _curNode: this.target,
+        _correctedPosition: position
+      };
+    }
+
+    if (position === 0) {
+      while (_curNode.nodeType !== nodeTypeText) {
+        _curNode = _curNode.childNodes[0];
+      }
+
+      const _correctedPosition = position;
+      return {
+        _curNode,
+        _correctedPosition
+      };
+    }
+
+    let i = -1;
+
+    if (_curNode && _curNode.nodeType !== undefined) {
+      while (curPos < position && _curNode.nodeType !== nodeTypeText) {
+        i++;
+
+        if (_curNode.childNodes[i] !== null && _curNode.childNodes[i]) {
+          curPos += _curNode.childNodes[i].textContent.length;
+
+          if (curPos >= position) {
+            _curNode = _curNode.childNodes[i];
+            curPos -= _curNode.textContent.length;
+            i = -1;
+          }
+        } else {
+          break;
+        }
+      }
+    }
+
+    const _correctedPosition = position - curPos;
+
+    return {
+      _curNode,
+      _correctedPosition
+    };
+  }
+  /**
+   * Set caret position index
+   * @param  {number} position
+   * @return {number}
+   */
+
+
+  setPosition(position) {
+    const isContentEditable = this.isContentEditable();
+    let correctedPosition;
+    let curNode = this.target && this.target.childNodes[0];
+
+    if (position !== undefined) {
+      if (position.startOffset !== undefined) {
+        const range = new Range();
+        const start = this.getRelativePosition(curNode, position.startOffset);
+        range.setStart(start._curNode, start._correctedPosition);
+        const end = this.getRelativePosition(curNode, position.endOffset);
+        range.setEnd(end._curNode, end._correctedPosition);
+        correctedPosition = range;
+      } else if (position === -1) {
+        const value = isContentEditable ? this.target.textContent : this.constructor.normalizeNewlines(this.target.value);
+        correctedPosition = value.length;
+      } else {
+        const {
+          _curNode,
+          _correctedPosition
+        } = this.getRelativePosition(curNode, position);
+        curNode = _curNode;
+        correctedPosition = _correctedPosition;
+      }
+    }
+
+    if (isContentEditable) {
+      this.focus();
+
+      try {
+        if (correctedPosition instanceof Range) {
+          window.getSelection().removeAllRanges();
+          window.getSelection().addRange(correctedPosition);
+        } else {
+          window.getSelection().collapse(curNode || this.target, correctedPosition);
+        }
+      } catch (e) {// Do nothing
+      }
+    } else {
+      this.target.setSelectionRange(correctedPosition, correctedPosition);
+    }
+
+    return correctedPosition;
+  }
+  /**
+   * Get caret position in pixels
+   * @return {number}
+   */
+
+
+  getOffset() {
+    let offset = 0;
+    let range;
+
+    try {
+      // Both statements may throw
+      range = window.getSelection().getRangeAt(0).cloneRange();
+      range.setStart(range.startContainer, range.startOffset - 1);
+    } catch (e) {
+      return offset;
+    }
+
+    if (range && range.endOffset !== 0 && range.toString() !== '') {
+      offset = getRect(range).right - getRect(this.target).left - (range.startContainer.offsetLeft || 0);
+    }
+
+    return offset;
+  }
+
+}
+
+_defineProperty(Caret, "returnRE", /\r/g);
+
+export { Caret as default };