@jetbrains/ring-ui 4.2.9 → 4.2.10

package/dist/caret/caret.js

@@ -0,0 +1,266 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.string.replace.js';
+import { getRect } from '../global/dom.js';
+import 'core-js/modules/web.dom-collections.iterator.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 };

package/dist/checkbox/checkbox.js

@@ -0,0 +1,110 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import checkmarkIcon from '@jetbrains/icons/checkmark';
+import minusIcon from '@jetbrains/icons/remove-10px';
+import Icon from '../icon/icon.js';
+import { m as modules_3199090e } from '../_helpers/checkbox.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import '../global/memoize.js';
+
+/**
+ * @name Checkbox
+ */
+
+/**
+ * Displays a checkbox.
+ */
+
+class Checkbox extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "inputRef", el => {
+      if (el != null) {
+        el.indeterminate = this.props.indeterminate;
+      }
+
+      this.input = el;
+    });
+  }
+
+  componentDidMount() {
+    if (this.input != null) {
+      this.input.indeterminate = this.props.indeterminate;
+    }
+  }
+
+  componentDidUpdate(prevProps) {
+    const {
+      indeterminate
+    } = this.props;
+
+    if (this.input != null && indeterminate !== prevProps.indeterminate) {
+      this.input.indeterminate = this.props.indeterminate;
+    }
+  }
+
+  render() {
+    const {
+      children,
+      label,
+      className,
+      containerClassName,
+      containerStyle,
+      cellClassName,
+      labelClassName,
+      indeterminate,
+      ...restProps
+    } = this.props;
+    const classes = classNames(modules_3199090e.input, className);
+    const containerClasses = classNames(modules_3199090e.checkbox, containerClassName);
+    const cellClasses = classNames(modules_3199090e.cell, cellClassName);
+    const labelClasses = classNames(modules_3199090e.label, labelClassName);
+    return /*#__PURE__*/React.createElement("label", {
+      className: containerClasses,
+      style: containerStyle,
+      "data-test": "ring-checkbox"
+    }, /*#__PURE__*/React.createElement("input", _extends({}, restProps, {
+      "data-checked": restProps.checked,
+      ref: this.inputRef,
+      type: "checkbox",
+      className: classes
+    })), /*#__PURE__*/React.createElement("span", {
+      className: cellClasses
+    }, /*#__PURE__*/React.createElement(Icon, {
+      glyph: checkmarkIcon,
+      className: modules_3199090e.check
+    }), /*#__PURE__*/React.createElement(Icon, {
+      glyph: minusIcon,
+      className: modules_3199090e.minus
+    })), /*#__PURE__*/React.createElement("span", {
+      className: labelClasses
+    }, label || children));
+  }
+
+}
+
+_defineProperty(Checkbox, "propTypes", {
+  name: PropTypes.string,
+  label: PropTypes.string,
+  className: PropTypes.string,
+  containerClassName: PropTypes.string,
+  containerStyle: PropTypes.object,
+  cellClassName: PropTypes.string,
+  labelClassName: PropTypes.string,
+  defaultChecked: PropTypes.bool,
+  checked: PropTypes.bool,
+  indeterminate: PropTypes.bool,
+  disabled: PropTypes.bool,
+  onChange: PropTypes.func,
+  children: PropTypes.node
+});
+
+export { Checkbox as default };

package/dist/checkbox-ng/checkbox-ng.js

@@ -0,0 +1,38 @@
+import angular from 'angular';
+import checkmarkIcon from '@jetbrains/icons/checkmark';
+import IconNG from '../icon-ng/icon-ng.js';
+import proxyAttrs from '../proxy-attrs/proxy-attrs.js';
+import { m as modules_3199090e } from '../_helpers/checkbox.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../icon/icon__constants.js';
+import '../template-ng/template-ng.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import '../global/ring-angular-component.js';
+import '../_helpers/icon.js';
+
+/**
+ * @name Checkbox Ng
+ */
+
+const angularModule = angular.module('Ring.checkbox', [IconNG]);
+let idCounter = 0;
+const CHECKBOX_ID_PREFIX = 'rg-checkbox-';
+angularModule.directive('rgCheckbox', function rgCheckboxDirective() {
+  return {
+    restrict: 'E',
+    transclude: true,
+    replace: true,
+    template: proxyAttrs("\n<label class=\"".concat(modules_3199090e.checkbox, "\">\n  <input\n    data-proxy-ng-disabled\n    data-proxy-ng-model\n    data-proxy-ng-change\n    data-proxy-ng-true-value\n    data-proxy-ng-false-value\n    data-proxy-name\n    data-proxy-title\n    data-proxy-aria-label\n    data-test=\"ring-checkbox\"\n    type=\"checkbox\"\n    class=\"").concat(modules_3199090e.input, "\"\n  />\n  <span class=\"").concat(modules_3199090e.cell, "\">\n    <rg-icon class=\"").concat(modules_3199090e.check, "\" glyph=\"{{:: checkmarkIcon}}\" />\n  </span><span class=\"").concat(modules_3199090e.label, "\" ng-transclude></span>\n</label>\n    ")),
+    link: function link(scope, iElement) {
+      scope.checkmarkIcon = checkmarkIcon;
+      const input = iElement[0].querySelector('input[type="checkbox"]');
+      const id = CHECKBOX_ID_PREFIX + idCounter++;
+      iElement[0].setAttribute('for', id);
+      input.setAttribute('id', id);
+    }
+  };
+});
+var Checkbox = angularModule.name;
+
+export { Checkbox as default };

package/dist/code/code.js

@@ -0,0 +1,137 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import highlight from 'highlight.js/lib/core';
+export { default as highlight } from 'highlight.js/lib/core';
+import normalizeIndent from '../global/normalize-indent.js';
+import trivialTemplateTag from '../global/trivial-template-tag.js';
+import memoize from '../global/memoize.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+var modules_66c414ea = {"unit":"8px","code":"code_rui_7185","inline":"inline_rui_7185","softWrap":"softWrap_rui_7185"};
+
+var modules_39cf09e8 = {"highlightContainer":"highlightContainer_rui_6e02"};
+
+function noop() {}
+
+const registerLanguage = memoize(async language => {
+  const languageExports = await import(
+  /* webpackChunkName: "highlight-[request]" */
+  "highlight.js/lib/languages/".concat(language));
+  highlight.registerLanguage(language, languageExports.default);
+});
+/**
+ * @name Code
+ */
+
+class Code extends PureComponent {
+  componentDidMount() {
+    this.highlight();
+  }
+
+  componentDidUpdate() {
+    this.highlight();
+  }
+
+  async highlight() {
+    const codeRef = this.codeRef;
+
+    if (codeRef == null) {
+      return;
+    }
+
+    const {
+      language,
+      inline,
+      replacer
+    } = this.props;
+
+    if (!inline) {
+      if (language != null && highlight.getLanguage(language) == null) {
+        await registerLanguage(language);
+      }
+
+      highlight.highlightElement(codeRef);
+    }
+
+    replacer(codeRef);
+  }
+
+  get codeRef() {
+    const {
+      codeRef
+    } = this.props;
+    return !codeRef || this.isFunctionCodeRef ? this.code : codeRef.current;
+  }
+
+  get isFunctionCodeRef() {
+    return typeof this.props.codeRef === 'function';
+  }
+
+  get initCodeRef() {
+    const {
+      codeRef
+    } = this.props;
+
+    if (codeRef && !this.isFunctionCodeRef) {
+      return codeRef;
+    }
+
+    return ref => {
+      this.code = ref;
+
+      if (this.isFunctionCodeRef) {
+        codeRef(this.code);
+      }
+    };
+  }
+
+  render() {
+    const {
+      code,
+      className,
+      inline,
+      softWrap,
+      language
+    } = this.props;
+    const Tag = inline ? 'span' : 'pre';
+    const classes = classNames(modules_66c414ea.code, className, language, {
+      [modules_66c414ea.inline]: inline,
+      [modules_66c414ea.softWrap]: softWrap
+    });
+    return /*#__PURE__*/React.createElement(Tag, {
+      className: classes
+    }, /*#__PURE__*/React.createElement("code", {
+      // should be focusable because it can be scrollable
+      tabIndex: inline ? -1 : 0,
+      ref: this.initCodeRef,
+      className: modules_39cf09e8.highlightContainer
+    }, normalizeIndent(code)));
+  }
+
+}
+
+_defineProperty(Code, "propTypes", {
+  className: PropTypes.string,
+  code: PropTypes.string.isRequired,
+  inline: PropTypes.bool,
+  softWrap: PropTypes.bool,
+  language: PropTypes.string,
+  replacer: PropTypes.func,
+  codeRef: PropTypes.oneOfType([PropTypes.shape({
+    current: PropTypes.instanceOf(Element)
+  }), PropTypes.func])
+});
+
+_defineProperty(Code, "defaultProps", {
+  inline: false,
+  softWrap: false,
+  replacer: noop
+});
+
+const code = trivialTemplateTag(source => /*#__PURE__*/React.createElement(Code, {
+  code: source
+}));
+
+export { code, Code as default };

package/dist/compiler-ng/compiler-ng.js

@@ -0,0 +1,53 @@
+import angular from 'angular';
+
+const angularModule = angular.module('Ring.compiler', []).factory('rgCompiler', ["$q", "$controller", "$injector", "$compile", function rgCompilerFactory($q, $controller, $injector, $compile) {
+  return options => {
+    const template = options.template;
+    const controller = options.controller;
+    const controllerAs = options.controllerAs;
+    const resolve = angular.extend({}, options.resolve);
+    const bindToController = options.bindToController;
+    angular.forEach(resolve, (value, key) => {
+      if (angular.isString(value)) {
+        resolve[key] = $injector.get(value);
+      } else {
+        // Use comma expression to disable babel-plugin-angular-annotate
+        // Otherwise is fails with "Maximum call stack size exceeded" error
+        resolve[key] = $injector.invoke((value));
+      }
+    });
+    angular.extend(resolve, options.locals);
+    return $q.all(resolve).then(locals => {
+      const element = options.element || angular.element('<div>').html(template.trim()).contents();
+      const linkFn = $compile(element, locals.$transclude);
+      locals.$element = element;
+      return {
+        locals,
+        element,
+        link: function link(scope) {
+          locals.$scope = scope;
+
+          if (controller) {
+            const invokeCtrl = $controller(controller, locals, true);
+
+            if (bindToController) {
+              angular.extend(invokeCtrl.instance, locals);
+            }
+
+            const ctrl = invokeCtrl();
+            element.data('$ngControllerController', ctrl);
+
+            if (controllerAs) {
+              scope[controllerAs] = ctrl;
+            }
+          }
+
+          return linkFn(scope);
+        }
+      };
+    });
+  };
+}]);
+var rgCompilerModuleName = angularModule.name;
+
+export { rgCompilerModuleName as default };