@jetbrains/ring-ui-built 6.0.1

package/components/caret/caret.d.ts

@@ -0,0 +1,66 @@
+export interface PositionParams {
+    avoidFocus?: boolean | null | undefined;
+}
+export interface Position {
+    startOffset: number;
+    endOffset: number;
+    position: number;
+}
+/**
+ * @name Caret
+ */
+export default class Caret {
+    /**
+     * Line endings RegExp
+     * @type {RegExp}
+     */
+    static returnRE: 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: string | undefined): string | undefined;
+    target: HTMLElement | HTMLInputElement;
+    constructor(target: HTMLElement);
+    isContentEditable(): boolean;
+    /**
+     * Set focus on target if possible
+     */
+    focus(): void;
+    /**
+     * Get absolute caret position index
+     * @return {number}
+     */
+    getAbsolutePosition(node: Node): number;
+    /**
+     * Get caret position index
+     * @param {Object} [params]
+     * @param {boolean} params.avoidFocus
+     * @return {number}
+     */
+    getPosition(params?: PositionParams): number | Position;
+    /**
+     * Get relative position of query
+     * @param  {Node} curNode
+     * @param {number} position
+     * @return {{_correctedPosition: number, _curNode: Node}}
+     */
+    getRelativePosition(curNode: Node, position: number): {
+        _curNode: Node;
+        _correctedPosition: number;
+    };
+    /**
+     * Set caret position index
+     * @param  {number} position
+     * @return {number}
+     */
+    setPosition(position?: Position | number): number | Range | undefined;
+    /**
+     * Get caret position in pixels
+     * @return {number}
+     */
+    getOffset(): number;
+}

package/components/caret/caret.js

@@ -0,0 +1,259 @@
+import { _ as _defineProperty, d as _createClass, c as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import { getRect } from '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+/**
+ * @name Caret
+ */
+var Caret = /*#__PURE__*/function () {
+  function Caret(target) {
+    _classCallCheck(this, Caret);
+    _defineProperty(this, "target", void 0);
+    this.target = target;
+  }
+  _createClass(Caret, [{
+    key: "isContentEditable",
+    value: function isContentEditable() {
+      return this.target.contentEditable === 'true';
+    }
+    /**
+     * Set focus on target if possible
+     */
+  }, {
+    key: "focus",
+    value: function focus() {
+      if (!document.activeElement || document.activeElement !== this.target) {
+        this.target.focus();
+      }
+    }
+    /**
+     * Get absolute caret position index
+     * @return {number}
+     */
+  }, {
+    key: "getAbsolutePosition",
+    value: function getAbsolutePosition(node) {
+      var _curNode = node;
+      var curPos = 0;
+      while (_curNode != null && _curNode !== this.target) {
+        while (_curNode.previousSibling) {
+          var _curNode$previousSibl, _curNode$previousSibl2;
+          curPos += (_curNode$previousSibl = (_curNode$previousSibl2 = _curNode.previousSibling.textContent) === null || _curNode$previousSibl2 === void 0 ? void 0 : _curNode$previousSibl2.length) !== null && _curNode$previousSibl !== void 0 ? _curNode$previousSibl : 0;
+          _curNode = _curNode.previousSibling;
+        }
+        _curNode = _curNode.parentNode;
+      }
+      return curPos;
+    }
+    /**
+     * Get caret position index
+     * @param {Object} [params]
+     * @param {boolean} params.avoidFocus
+     * @return {number}
+     */
+  }, {
+    key: "getPosition",
+    value: function getPosition() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (this.isContentEditable()) {
+        if (!params.avoidFocus) {
+          this.focus();
+        }
+        var selection = window.getSelection();
+        if (!(selection !== null && selection !== void 0 && selection.rangeCount)) {
+          return 0;
+        }
+        var range1 = selection.getRangeAt(0);
+        var range2 = range1.cloneRange();
+        range2.selectNodeContents(this.target);
+        range2.setEnd(range1.endContainer, range1.endOffset);
+        var _curNode = range1.startContainer;
+        if (this.target === _curNode) {
+          return range1.startOffset === 0 || _curNode.textContent == null ? 0 : _curNode.textContent.length;
+        } else if (!this.target.contains(_curNode)) {
+          return -1;
+        } else if (!_curNode) {
+          return 'selectionStart' in this.target && this.target.selectionStart || -1;
+        }
+        var 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 {
+          var startOffset = curPos + range1.startOffset;
+          var endPos = this.getAbsolutePosition(range1.endContainer);
+          var endOffset = endPos + range1.endOffset;
+          return {
+            startOffset,
+            endOffset,
+            position: range2.toString().length
+          };
+        }
+      }
+      return 'selectionStart' in this.target && this.target.selectionStart || -1;
+    }
+    /**
+     * Get relative position of query
+     * @param  {Node} curNode
+     * @param {number} position
+     * @return {{_correctedPosition: number, _curNode: Node}}
+     */
+  }, {
+    key: "getRelativePosition",
+    value: function getRelativePosition(curNode, position) {
+      var curPos = 0;
+      var _curNode = curNode;
+      var nodeTypeText = 3;
+      if (!_curNode) {
+        return {
+          _curNode: this.target,
+          _correctedPosition: position
+        };
+      }
+      if (position === 0) {
+        while (_curNode.nodeType !== nodeTypeText) {
+          _curNode = _curNode.childNodes[0];
+        }
+        var _correctedPosition2 = position;
+        return {
+          _curNode,
+          _correctedPosition: _correctedPosition2
+        };
+      }
+      var i = -1;
+      if (_curNode && _curNode.nodeType !== undefined) {
+        while (curPos < position && _curNode.nodeType !== nodeTypeText) {
+          i++;
+          if (_curNode.childNodes[i] != null) {
+            var _curNode$childNodes$i, _curNode$childNodes$i2;
+            curPos += (_curNode$childNodes$i = (_curNode$childNodes$i2 = _curNode.childNodes[i].textContent) === null || _curNode$childNodes$i2 === void 0 ? void 0 : _curNode$childNodes$i2.length) !== null && _curNode$childNodes$i !== void 0 ? _curNode$childNodes$i : 0;
+            if (curPos >= position) {
+              var _curNode$textContent$, _curNode$textContent;
+              _curNode = _curNode.childNodes[i];
+              curPos -= (_curNode$textContent$ = (_curNode$textContent = _curNode.textContent) === null || _curNode$textContent === void 0 ? void 0 : _curNode$textContent.length) !== null && _curNode$textContent$ !== void 0 ? _curNode$textContent$ : 0;
+              i = -1;
+            }
+          } else {
+            break;
+          }
+        }
+      }
+      var _correctedPosition = position - curPos;
+      return {
+        _curNode,
+        _correctedPosition
+      };
+    }
+    /**
+     * Set caret position index
+     * @param  {number} position
+     * @return {number}
+     */
+  }, {
+    key: "setPosition",
+    value: function setPosition(position) {
+      var isContentEditable = this.isContentEditable();
+      var correctedPosition;
+      var curNode = this.target && this.target.childNodes[0];
+      if (position !== undefined) {
+        if (typeof position === 'object') {
+          var range = new Range();
+          var start = this.getRelativePosition(curNode, position.startOffset);
+          range.setStart(start._curNode, start._correctedPosition);
+          var end = this.getRelativePosition(curNode, position.endOffset);
+          range.setEnd(end._curNode, end._correctedPosition);
+          correctedPosition = range;
+        } else if (position === -1) {
+          var _value$length;
+          var value = isContentEditable ? this.target.textContent : Caret.normalizeNewlines('value' in this.target ? this.target.value : undefined);
+          correctedPosition = (_value$length = value === null || value === void 0 ? void 0 : value.length) !== null && _value$length !== void 0 ? _value$length : 0;
+        } else {
+          var _this$getRelativePosi = this.getRelativePosition(curNode, position),
+            _curNode = _this$getRelativePosi._curNode,
+            _correctedPosition = _this$getRelativePosi._correctedPosition;
+          curNode = _curNode;
+          correctedPosition = _correctedPosition;
+        }
+      }
+      if (isContentEditable) {
+        this.focus();
+        try {
+          if (correctedPosition instanceof Range) {
+            var _window$getSelection, _window$getSelection2;
+            (_window$getSelection = window.getSelection()) === null || _window$getSelection === void 0 || _window$getSelection.removeAllRanges();
+            (_window$getSelection2 = window.getSelection()) === null || _window$getSelection2 === void 0 || _window$getSelection2.addRange(correctedPosition);
+          } else {
+            var _window$getSelection3;
+            (_window$getSelection3 = window.getSelection()) === null || _window$getSelection3 === void 0 || _window$getSelection3.collapse(curNode || this.target, correctedPosition);
+          }
+        } catch (e) {
+          // Do nothing
+        }
+      } else if ('setSelectionRange' in this.target && typeof correctedPosition === 'number') {
+        this.target.setSelectionRange(correctedPosition, correctedPosition);
+      }
+      return correctedPosition;
+    }
+    /**
+     * Get caret position in pixels
+     * @return {number}
+     */
+  }, {
+    key: "getOffset",
+    value: function getOffset() {
+      var offset = 0;
+      var range;
+      try {
+        var _window$getSelection4, _range;
+        // Both statements may throw
+        range = (_window$getSelection4 = window.getSelection()) === null || _window$getSelection4 === void 0 ? void 0 : _window$getSelection4.getRangeAt(0).cloneRange();
+        (_range = range) === null || _range === void 0 || _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 instanceof HTMLElement && range.startContainer.offsetLeft || 0);
+      }
+      return offset;
+    }
+  }], [{
+    key: "normalizeNewlines",
+    value:
+    /**
+     * Line endings normalizer
+     * Borrowed from jQuery
+     * @see https://github.com/jquery/jquery/blob/master/src/attributes/val.js
+     * @param value {*}
+     * @return {*}
+     */
+    function normalizeNewlines(value) {
+      return typeof value === 'string' ? value.replace(this.returnRE, '') : value;
+    }
+  }]);
+  return Caret;
+}();
+/**
+ * Line endings RegExp
+ * @type {RegExp}
+ */
+_defineProperty(Caret, "returnRE", /\r/g);
+
+export { Caret as default };

package/components/checkbox/checkbox.d.ts

@@ -0,0 +1,45 @@
+import React, { PureComponent, InputHTMLAttributes, CSSProperties, Ref } from 'react';
+import PropTypes from 'prop-types';
+export interface CheckboxProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: string | null | undefined;
+    containerClassName?: string | null | undefined;
+    containerStyle?: CSSProperties | undefined;
+    cellClassName?: string | null | undefined;
+    labelClassName?: string | null | undefined;
+    indeterminate: boolean;
+    inputRef?: Ref<HTMLInputElement>;
+}
+/**
+ * @name Checkbox
+ */
+/**
+ * Displays a checkbox.
+ */
+export default class Checkbox extends PureComponent<CheckboxProps> {
+    static propTypes: {
+        name: PropTypes.Requireable<string>;
+        label: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        containerStyle: PropTypes.Requireable<object>;
+        cellClassName: PropTypes.Requireable<string>;
+        labelClassName: PropTypes.Requireable<string>;
+        defaultChecked: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        indeterminate: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        inputRef: PropTypes.Requireable<NonNullable<((...args: any[]) => any) | PropTypes.InferProps<{
+            current: PropTypes.Validator<HTMLInputElement | null | undefined>;
+        }> | null | undefined>>;
+    };
+    static defaultProps: {
+        indeterminate: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CheckboxProps): void;
+    input?: HTMLInputElement | null;
+    inputRef: (el: HTMLInputElement | null) => void;
+    render(): React.JSX.Element;
+}

package/components/checkbox/checkbox.js

@@ -0,0 +1,130 @@
+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, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import checkmarkIcon from '@jetbrains/icons/checkmark-14px';
+import minusIcon from '@jetbrains/icons/remove-14px';
+import Icon from '../icon/icon.js';
+import { refObject } from '../global/prop-types.js';
+import composeRefs from '../global/composeRefs.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+var modules_3199090e = {"checkboxSize":"14px","light":"light_rui_2ac4","checkbox":"checkbox_rui_d990","cell":"cell_rui_d990","icon":"icon_rui_d990","check":"check_rui_d990 icon_rui_d990","minus":"minus_rui_d990 icon_rui_d990","input":"input_rui_d990","focus":"focus_rui_d990","label":"label_rui_d990"};
+
+var _excluded = ["children", "label", "className", "containerClassName", "containerStyle", "cellClassName", "labelClassName", "indeterminate", "inputRef"];
+/**
+ * @name Checkbox
+ */
+/**
+ * Displays a checkbox.
+ */
+var Checkbox = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Checkbox, _PureComponent);
+  var _super = _createSuper(Checkbox);
+  function Checkbox() {
+    var _this;
+    _classCallCheck(this, Checkbox);
+    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), "input", void 0);
+    _defineProperty(_assertThisInitialized(_this), "inputRef", function (el) {
+      if (el != null) {
+        el.indeterminate = _this.props.indeterminate;
+      }
+      _this.input = el;
+    });
+    return _this;
+  }
+  _createClass(Checkbox, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.input != null) {
+        this.input.indeterminate = this.props.indeterminate;
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var indeterminate = this.props.indeterminate;
+      if (this.input != null && indeterminate !== prevProps.indeterminate) {
+        this.input.indeterminate = this.props.indeterminate;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        label = _this$props.label,
+        className = _this$props.className,
+        containerClassName = _this$props.containerClassName,
+        containerStyle = _this$props.containerStyle,
+        cellClassName = _this$props.cellClassName,
+        labelClassName = _this$props.labelClassName;
+        _this$props.indeterminate;
+        var inputRef = _this$props.inputRef,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_3199090e.input, className);
+      var containerClasses = classNames(modules_3199090e.checkbox, containerClassName);
+      var cellClasses = classNames(modules_3199090e.cell, cellClassName);
+      var 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: composeRefs(this.inputRef, 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));
+    }
+  }]);
+  return Checkbox;
+}(PureComponent);
+_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,
+  inputRef: PropTypes.oneOfType([PropTypes.func, refObject(PropTypes.instanceOf(HTMLInputElement))])
+});
+_defineProperty(Checkbox, "defaultProps", {
+  indeterminate: false
+});
+
+export { Checkbox as default };

package/components/clipboard/clipboard-fallback.d.ts

@@ -0,0 +1,2 @@
+export declare function copyTextToClipboard(str: string): void;
+export declare function copyHTMLToClipboard(str: string): void;

package/components/clipboard/clipboard-fallback.js

@@ -0,0 +1,42 @@
+function copyTextToClipboard(str) {
+  var el = document.createElement('textarea');
+  el.value = str;
+  el.setAttribute('readonly', '');
+  el.style.position = 'absolute';
+  el.style.left = '-9999px';
+  document.body.appendChild(el);
+  var selection = document.getSelection();
+  // Should restore previous selection
+  var selected = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : false;
+  el.select();
+  document.execCommand('copy');
+  document.body.removeChild(el);
+  if (selected && selection) {
+    selection.removeAllRanges();
+    selection.addRange(selected);
+  }
+}
+function copyHTMLToClipboard(str) {
+  var el = document.createElement('div');
+  el.innerHTML = str;
+  el.setAttribute('readonly', '');
+  el.style.position = 'absolute';
+  el.style.left = '-9999px';
+  document.body.appendChild(el);
+  var selection = document.getSelection();
+  // Should restore previous selection
+  var selected = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : false;
+  selection === null || selection === void 0 || selection.removeAllRanges();
+  var range = document.createRange();
+  range.selectNode(el);
+  selection === null || selection === void 0 || selection.addRange(range);
+  document.execCommand('copy');
+  selection === null || selection === void 0 || selection.removeAllRanges();
+  document.execCommand('copy');
+  document.body.removeChild(el);
+  if (selected && selection) {
+    selection.addRange(selected);
+  }
+}
+
+export { copyHTMLToClipboard, copyTextToClipboard };

package/components/clipboard/clipboard.d.ts

@@ -0,0 +1,5 @@
+declare const clipboard: {
+    copyText: (text: string, successMessage?: string | undefined, errorMessage?: string | undefined, delay?: number) => Promise<void>;
+    copyHTML: (html: string, successMessage?: string | undefined, errorMessage?: string | undefined, delay?: number) => Promise<void>;
+};
+export default clipboard;