@jetbrains/ring-ui 4.2.7 → 4.2.10

package/dist/global/focus-sensor-hoc.js

@@ -0,0 +1,146 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import composeRefs from './composeRefs.js';
+
+function focusSensorHOC(ComposedComponent) {
+  var _class;
+
+  return _class = class FocusSensor extends Component {
+    constructor() {
+      super(...arguments);
+
+      _defineProperty(this, "state", {
+        focused: this.props.focused
+      });
+
+      _defineProperty(this, "_skipNextCapture", false);
+
+      _defineProperty(this, "onRefUpdate", node => {
+        if (node) {
+          this.node = node;
+        }
+      });
+
+      _defineProperty(this, "onFocusCapture", _ref => {
+        let {
+          target
+        } = _ref;
+
+        if (this._skipNextCapture) {
+          this._skipNextCapture = false;
+          return;
+        }
+
+        const focused = this.node.contains(target);
+
+        if (focused && !this.state.focused) {
+          this.setState({
+            focused: true
+          });
+          this.props.onFocus();
+        }
+      });
+
+      _defineProperty(this, "onBlurCapture", _ref2 => {
+        let {
+          target
+        } = _ref2;
+        const {
+          state: {
+            focused
+          },
+          node
+        } = this;
+
+        if (focused) {
+          setTimeout(() => {
+            const blurred = node.contains(target) && !node.contains(document.activeElement);
+
+            if (blurred) {
+              this.setState({
+                focused: false
+              });
+              this.props.onBlur();
+            }
+          }, 1);
+        }
+      });
+
+      _defineProperty(this, "onFocusRestore", () => {
+        this._skipNextCapture = true;
+        this.node.focus();
+      });
+
+      _defineProperty(this, "onFocusReset", () => {
+        this.node.blur();
+      });
+    }
+
+    componentDidMount() {
+      const {
+        props: {
+          autofocus
+        },
+        node
+      } = this;
+      node.setAttribute('tabindex', '0');
+      node.style.outline = 'none';
+      document.addEventListener('focus', this.onFocusCapture, true);
+      document.addEventListener('blur', this.onBlurCapture, true);
+
+      if (autofocus) {
+        node.focus();
+      }
+    }
+
+    componentDidUpdate(prevProps) {
+      const {
+        focused
+      } = this.props;
+
+      if (focused && !prevProps.focused) {
+        this.onFocusRestore();
+      } else if (!focused && prevProps.focused) {
+        this.onFocusReset();
+      }
+    }
+
+    componentWillUnmount() {
+      document.removeEventListener('focus', this.onFocusCapture, true);
+      document.removeEventListener('blur', this.onBlurCapture, true);
+    }
+
+    render() {
+      const {
+        autofocus,
+        focused,
+        onFocus,
+        onBlur,
+        innerRef,
+        ...rest
+      } = this.props;
+      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, rest, {
+        innerRef: composeRefs(innerRef, this.onRefUpdate),
+        focused: this.state.focused,
+        onFocusReset: this.onFocusReset,
+        onFocusRestore: this.onFocusRestore
+      }));
+    }
+
+  }, _defineProperty(_class, "propTypes", { ...ComposedComponent.propTypes,
+    focused: PropTypes.bool,
+    autofocus: PropTypes.bool,
+    onFocus: PropTypes.func,
+    onBlur: PropTypes.func,
+    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }), _defineProperty(_class, "defaultProps", { ...ComposedComponent.defaultProps,
+    focused: false,
+    autofocus: false,
+    onFocus: () => {},
+    onBlur: () => {}
+  }), _class;
+}
+
+export { focusSensorHOC as default };

package/dist/global/fuzzy-highlight.js

@@ -0,0 +1,67 @@
+/** https://github.com/bevacqua/fuzzysearch + highlighting with Markdown */
+const marker = '**';
+function fuzzyHighlight(needle, haystack) {
+  let caseSensitive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const ndl = caseSensitive ? needle : needle.toLowerCase();
+  const hstck = caseSensitive ? haystack : haystack.toLowerCase();
+
+  const result = function (matched) {
+    let highlight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : haystack;
+    return {
+      matched,
+      highlight
+    };
+  };
+
+  const hlen = hstck.length;
+  const nlen = ndl.length;
+
+  if (nlen > hlen) {
+    return result(false);
+  }
+
+  if (nlen === hlen) {
+    const matched = ndl === hstck;
+    return result(matched, matched ? "".concat(marker).concat(haystack).concat(marker) : haystack);
+  }
+
+  let highlight = '';
+  let on = false;
+  let j = 0;
+  /* eslint-disable no-labels */
+
+  outer: for (let i = 0; i < nlen; i++) {
+    const nch = ndl[i];
+
+    while (j < hlen) {
+      const hch = hstck[j];
+      const match = hch === nch; // Don't turn highlight on for space characters
+
+      const nextOn = match && /\S/.test(hch);
+
+      if (nextOn !== on) {
+        highlight += marker;
+      }
+
+      highlight += haystack[j++];
+      on = nextOn;
+
+      if (match) {
+        continue outer;
+      }
+    }
+
+    return result(false);
+  }
+  /* eslint-enable */
+
+
+  if (on) {
+    highlight += marker;
+  }
+
+  highlight += haystack.slice(j);
+  return result(true, highlight);
+}
+
+export { fuzzyHighlight as default };

package/dist/global/get-event-key.js

@@ -0,0 +1,111 @@
+// react-dom getEventKey function extracted
+const normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+const translateToKey = {
+  8: 'Backspace',
+  9: 'Tab',
+  12: 'Clear',
+  13: 'Enter',
+  16: 'Shift',
+  17: 'Control',
+  18: 'Alt',
+  19: 'Pause',
+  20: 'CapsLock',
+  27: 'Escape',
+  32: ' ',
+  33: 'PageUp',
+  34: 'PageDown',
+  35: 'End',
+  36: 'Home',
+  37: 'ArrowLeft',
+  38: 'ArrowUp',
+  39: 'ArrowRight',
+  40: 'ArrowDown',
+  45: 'Insert',
+  46: 'Delete',
+  112: 'F1',
+  113: 'F2',
+  114: 'F3',
+  115: 'F4',
+  116: 'F5',
+  117: 'F6',
+  118: 'F7',
+  119: 'F8',
+  120: 'F9',
+  121: 'F10',
+  122: 'F11',
+  123: 'F12',
+  144: 'NumLock',
+  145: 'ScrollLock',
+  224: 'Meta'
+};
+const ENTER = 13;
+const SPACE = 32;
+
+function getEventCharCode(nativeEvent) {
+  let charCode;
+  const keyCode = nativeEvent.keyCode;
+
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+
+    if (charCode === 0 && keyCode === ENTER) {
+      charCode = ENTER;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+
+  if (charCode >= SPACE || charCode === ENTER) {
+    return charCode;
+  }
+
+  return 0;
+}
+
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    const key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
+
+
+  if (nativeEvent.type === 'keypress') {
+    const charCode = getEventCharCode(nativeEvent); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+
+    return charCode === SPACE ? 'Enter' : String.fromCharCode(charCode);
+  }
+
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+
+  return '';
+}
+
+export { getEventKey as default };

package/dist/global/get-uid.js

@@ -0,0 +1,15 @@
+const idCounters = {};
+function getUID(name) {
+  if (!name) {
+    throw Error('Argument "name" is required in getUID()');
+  }
+
+  if (!idCounters[name]) {
+    idCounters[name] = 0;
+  }
+
+  const id = String(idCounters[name]++);
+  return name + id;
+}
+
+export { getUID as default };

package/dist/global/inject-styles.js

@@ -0,0 +1,15 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+const injectStyleSheet = styles => {
+  const styleTag = document.createElement('style');
+  styleTag.setAttribute('type', 'text/css');
+  styleTag.textContent = styles;
+  document.head.appendChild(styleTag);
+  return styleTag;
+};
+const injectRuleSet = (selector, declarations) => injectStyleSheet("\n".concat(selector, " {\n  ").concat(Object.entries(declarations).map(_ref => {
+  let [property, value] = _ref;
+  return "".concat(property, ": ").concat(value, ";");
+}).join("\n  "), "\n}"));
+
+export { injectRuleSet, injectStyleSheet };

package/dist/global/linear-function.js

@@ -0,0 +1,17 @@
+function linearFunction(x0, y0, a) {
+  return {
+    y(x) {
+      return +y0 + (x - x0) * a;
+    },
+
+    x(y) {
+      return +x0 + (y - y0) / a;
+    }
+
+  };
+}
+function interpolateLinear(x0, x1, phase) {
+  return linearFunction(x0, x0, phase).y(x1);
+}
+
+export { linearFunction as default, interpolateLinear };

package/dist/global/listeners.js

@@ -0,0 +1,44 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+class Listeners {
+  constructor() {
+    this.removeAll();
+  }
+
+  trigger(event, data) {
+    const handlers = this._all.get(event);
+
+    if (handlers) {
+      return Promise.all([...handlers].map(fn => fn(data)));
+    }
+
+    return Promise.resolve([]);
+  }
+
+  add(event, handler) {
+    let handlers = this._all.get(event);
+
+    if (!handlers) {
+      handlers = new Set();
+
+      this._all.set(event, handlers);
+    }
+
+    handlers.add(handler);
+  }
+
+  remove(event, handler) {
+    const handlers = this._all.get(event);
+
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+
+  removeAll() {
+    this._all = new Map();
+  }
+
+}
+
+export { Listeners as default };

package/dist/global/memoize.js

@@ -0,0 +1,20 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+function memoize(fn) {
+  const primitiveCache = new Map();
+  const objectCache = new WeakMap();
+  return function memoized() {
+    let arg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '__singleValue__';
+    const cache = arg instanceof Object ? objectCache : primitiveCache;
+
+    if (cache.has(arg)) {
+      return cache.get(arg);
+    }
+
+    const value = fn(arg);
+    cache.set(arg, value);
+    return value;
+  };
+}
+
+export { memoize as default };

package/dist/global/normalize-indent.js

@@ -0,0 +1,30 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+function normalizeIndent(string) {
+  const nonemptyRE = /\S/;
+  const indentRE = /^\s*/;
+  const lines = string.split(/\n/g);
+  const linesCopy = [...lines]; //remove empty lines at the beginning and the end
+
+  for (const line of linesCopy) {
+    if (nonemptyRE.test(line)) {
+      break;
+    } else {
+      lines.shift();
+    }
+  }
+
+  for (const line of linesCopy.reverse()) {
+    if (nonemptyRE.test(line)) {
+      break;
+    } else {
+      lines.pop();
+    }
+  }
+
+  const indents = lines.filter(line => nonemptyRE.test(line)).map(line => line.match(indentRE)[0].length);
+  const minIndent = Math.min(...indents);
+  return lines.map(line => line.slice(minIndent)).join('\n');
+}
+
+export { normalizeIndent as default };

package/dist/global/promise-with-timeout.js

@@ -0,0 +1,17 @@
+// Useful for using fetch with timeout
+// https://github.com/github/fetch/issues/175#issuecomment-284787564
+function promiseWithTimeout(promise, timeout, _ref) {
+  let {
+    error,
+    onTimeout = () => {}
+  } = _ref;
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      onTimeout();
+      reject(error || new Error('Timeout'));
+    }, timeout);
+    promise.then(resolve, reject);
+  });
+}
+
+export { promiseWithTimeout as default };

package/dist/global/radial-gradient-mask.js

@@ -0,0 +1,38 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+import getUID from './get-uid.js';
+import supportsCss from './supports-css.js';
+import 'core-js/modules/es.string.replace.js';
+import './memoize.js';
+
+const radialGradient = (length, stops) => "radial-gradient(".concat(length, ", ").concat(Object.entries(stops).map(entry => entry.join(' ')).join(', '), ")");
+
+var radialGradientMask = ((length, stops) => {
+  for (const prefix of ['', '-webkit-']) {
+    const property = "".concat(prefix, "mask-image");
+    const declaration = "".concat(property, ": radial-gradient(black, white)");
+
+    if (supportsCss(declaration)) {
+      return {
+        supports: true,
+        css: {
+          [property]: radialGradient(length, stops)
+        }
+      };
+    }
+  }
+
+  const gradientId = getUID('gradient');
+  const maskId = getUID('mask');
+  const svgDefs = "\n    <svg>\n      <defs>\n        <radialGradient id=\"".concat(gradientId, "\">\n          ").concat(Object.entries(stops).map(_ref => {
+    let [color, offset] = _ref;
+    return "\n            <stop offset=\"".concat(offset, "\" stop-color=\"").concat(color, "\"/>\n          ");
+  }).join(''), "\n        </radialGradient>\n        <mask id=\"").concat(maskId, "\">\n          <rect height=\"100%\" width=\"100%\" fill=\"url(#").concat(gradientId, ")\"/>\n        </mask>\n      </defs>\n    </svg>\n  ");
+  return {
+    supports: false,
+    css: {},
+    maskId,
+    svgDefs
+  };
+});
+
+export { radialGradientMask as default };

package/dist/global/react-dom-renderer.js

@@ -0,0 +1,46 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+
+class Renderer extends Component {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "nodeRef", node => {
+      this.node = node;
+    });
+  }
+
+  componentDidMount() {
+    const {
+      nodes
+    } = this.props;
+
+    if (!this.node || !nodes || !nodes.length) {
+      return;
+    }
+
+    const fragment = document.createDocumentFragment();
+    nodes.forEach(nodeToRender => fragment.appendChild(nodeToRender));
+    this.node.appendChild(fragment);
+  }
+
+  render() {
+    const {
+      className
+    } = this.props;
+    return /*#__PURE__*/React.createElement("div", {
+      className: className,
+      ref: this.nodeRef
+    });
+  }
+
+}
+
+_defineProperty(Renderer, "propTypes", {
+  className: PropTypes.string,
+  nodes: PropTypes.array
+});
+
+export { Renderer as default };

package/dist/global/react-render-adapter.js

@@ -0,0 +1,41 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { render as render$1, unmountComponentAtNode as unmountComponentAtNode$1, hydrate as hydrate$1 } from 'react-dom';
+
+/* eslint-disable import/no-mutable-exports */
+
+let render = render$1;
+let unmountComponentAtNode = unmountComponentAtNode$1;
+let hydrate = hydrate$1;
+/* eslint-enable */
+
+function setClient(_ref) {
+  let {
+    createRoot,
+    hydrateRoot
+  } = _ref;
+  const roots = new WeakMap();
+
+  render = (element, container) => {
+    let root = roots.get(container);
+
+    if (root == null) {
+      root = createRoot(container);
+      roots.set(container, root);
+    }
+
+    root.render(element);
+  };
+
+  unmountComponentAtNode = container => {
+    var _roots$get;
+
+    return (_roots$get = roots.get(container)) === null || _roots$get === void 0 ? void 0 : _roots$get.unmount();
+  };
+
+  hydrate = (element, container) => {
+    const root = hydrateRoot(container, element);
+    roots.set(container, root);
+  };
+}
+
+export { hydrate, render, setClient, unmountComponentAtNode };

package/dist/global/rerender-hoc.js

@@ -0,0 +1,55 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { createElement } from 'react';
+import { render } from './react-render-adapter.js';
+import composeRefs from './composeRefs.js';
+import 'react-dom';
+
+/**
+ * Wraps a component to add a "rerender" method
+ * @param ComposedComponent
+ * @param captureNode, whether the wrapper should capture this.node itself. Set to false if the component already has "node" property captured
+ * @returns {Rerenderer}
+ */
+
+function rerenderHOC(ComposedComponent) {
+  let {
+    captureNode
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    captureNode: false
+  };
+
+  if (captureNode) {
+    // TODO remove in 5.0
+    throw new Error('rerenderHOC: captureNode={true} is deprecated. Wrapped component must have "node" property captured itself');
+  }
+
+  return class Rerenderer extends ComposedComponent {
+    constructor() {
+      super(...arguments);
+
+      _defineProperty(this, "_propsCache", {});
+    }
+
+    rerender() {
+      let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      let callback = arguments.length > 1 ? arguments[1] : undefined;
+      let container;
+
+      try {
+        container = this.node.parentNode;
+      } finally {
+        if (!container) {
+          throw new Error("".concat(this.constructor.name, " component isn't mounted"));
+        }
+      }
+
+      this._propsCache = Object.assign({}, this.props, this._propsCache, props);
+      this._propsCache.ref = composeRefs(this._propsCache.ref, callback);
+      render( /*#__PURE__*/createElement(this.constructor, this._propsCache), container);
+    }
+
+  };
+}
+
+export { rerenderHOC as default };

package/dist/global/ring-angular-component.js

@@ -0,0 +1,24 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
+class RingAngularComponent {
+  static get controller() {
+    return this;
+  }
+
+  constructor() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _defineProperty(this, "$inject", {});
+
+    this.constructor.$inject.forEach((injectName, i) => {
+      this.$inject[injectName] = args[i];
+    });
+  }
+
+}
+
+_defineProperty(RingAngularComponent, "$inject", []);
+
+export { RingAngularComponent as default };