@atlaskit/link-picker 0.0.2 → 0.8.1

package/dist/esm/ui/link-picker.js

@@ -0,0 +1,560 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/** @jsx jsx */
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/core';
+import { injectIntl } from 'react-intl-next';
+import { messages } from '../messages';
+import PanelTextInput from './PanelTextInput';
+import LinkSearchList from './LinkSearchList';
+import { normalizeUrl, isSafeUrl } from '../url';
+import { recentListStyles, Container, SearchIconWrapper, ListTitleStyles } from '../styles';
+import { browser } from '../browser';
+import { transformTimeStamp } from '../transformTimeStamp';
+import Announcer from './announcer';
+import Button, { ButtonGroup } from '@atlaskit/button';
+import { FormFooter } from '@atlaskit/form';
+import EditorSearchIcon from '@atlaskit/icon/glyph/editor/search';
+import VisuallyHidden from '@atlaskit/visually-hidden';
+export var RECENT_SEARCH_LIST_SIZE = 5;
+
+var LinkPicker = /*#__PURE__*/function (_PureComponent) {
+  _inherits(LinkPicker, _PureComponent);
+
+  var _super = _createSuper(LinkPicker);
+
+  function LinkPicker(props) {
+    var _this;
+
+    _classCallCheck(this, LinkPicker);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "wrapperRef", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "queryVersion", 0);
+
+    _defineProperty(_assertThisInitialized(_this), "updateInput", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(input) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(input.length && isSafeUrl(input))) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return", _this.setState({
+                  url: input,
+                  selectedIndex: -1,
+                  items: [],
+                  isLoading: false,
+                  invalidUrl: null
+                }));
+
+              case 2:
+                return _context.abrupt("return", _this.setState({
+                  url: input,
+                  // Unset selection on any input change
+                  selectedIndex: -1,
+                  invalidUrl: null
+                }, function () {
+                  _this.updateResults();
+                }));
+
+              case 3:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+
+    _defineProperty(_assertThisInitialized(_this), "createClearHandler", function (field) {
+      return function () {
+        switch (field) {
+          case 'url':
+            {
+              _this.updateInput('');
+
+              break;
+            }
+
+          case 'displayText':
+            {
+              _this.setState(_defineProperty({}, field, ''));
+            }
+        }
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getScreenReaderText", function () {
+      var intl = _this.props.intl;
+      var _this$state = _this.state,
+          items = _this$state.items,
+          selectedIndex = _this$state.selectedIndex;
+
+      if (items.length && selectedIndex > -1) {
+        var _items$selectedIndex = items[selectedIndex],
+            name = _items$selectedIndex.name,
+            container = _items$selectedIndex.container,
+            lastUpdatedDate = _items$selectedIndex.lastUpdatedDate,
+            lastViewedDate = _items$selectedIndex.lastViewedDate;
+        var date = transformTimeStamp(intl, lastViewedDate, lastUpdatedDate);
+        return "".concat(name, ", ").concat(container, ", ").concat(date === null || date === void 0 ? void 0 : date.pageAction, " ").concat(date === null || date === void 0 ? void 0 : date.dateString, " ").concat((date === null || date === void 0 ? void 0 : date.timeSince) || '');
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "isUrlPopulatedWithSelectedItem", function () {
+      /**
+       * When we use ArrowKey to navigate through result items,
+       * the URL field will be populated with the content of
+       * selected item.
+       * This function will check if the URL field is populated
+       * with selected item.
+       * It can be useful to detect whether we want to insert a
+       * smartlink or a hyperlink with customized title
+       */
+      var _this$state2 = _this.state,
+          items = _this$state2.items,
+          selectedIndex = _this$state2.selectedIndex,
+          url = _this$state2.url;
+      var selectedItem = items[selectedIndex];
+
+      if (selectedItem && selectedItem.url === url) {
+        return true;
+      }
+
+      return false;
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleSelected", function (objectId) {
+      var items = _this.state.items;
+      var selectedItem = items.find(function (item) {
+        return item.objectId === objectId;
+      });
+
+      if (selectedItem) {
+        var url = selectedItem.url,
+            name = selectedItem.name;
+
+        _this.handleInsert(url, name, 'typeAhead');
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleInsert", function (url, title, inputType) {
+      var onSubmit = _this.props.onSubmit;
+      var _this$state3 = _this.state,
+          rawUrl = _this$state3.url,
+          displayText = _this$state3.displayText;
+
+      if (onSubmit) {
+        onSubmit(_objectSpread({
+          url: url,
+          displayText: displayText || null,
+          title: title || null,
+          meta: {
+            inputMethod: inputType
+          }
+        }, inputType === 'manual' ? {
+          rawUrl: rawUrl
+        } : {}));
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleMouseEnterResultItem", function (objectId) {
+      var items = _this.state.items;
+      var index = findIndex(items, function (item) {
+        return item.objectId === objectId;
+      });
+
+      _this.setState({
+        activeIndex: index
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleMouseLeaveResultItem", function (objectId) {
+      var _this$state4 = _this.state,
+          items = _this$state4.items,
+          activeIndex = _this$state4.activeIndex;
+      var index = findIndex(items, function (item) {
+        return item.objectId === objectId;
+      }); // This is to avoid updating index that was set by other mouseenter event
+
+      if (activeIndex === index) {
+        _this.setState({
+          activeIndex: -1
+        });
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleSubmit", function () {
+      var _this$state5 = _this.state,
+          url = _this$state5.url,
+          selectedIndex = _this$state5.selectedIndex,
+          items = _this$state5.items;
+      var selectedItem = items[selectedIndex];
+
+      if (_this.isUrlPopulatedWithSelectedItem()) {
+        _this.handleInsert(selectedItem.url, selectedItem.name, 'typeAhead');
+      } else if (url.length > 0) {
+        var normalized = normalizeUrl(url);
+
+        if (normalized) {
+          _this.handleInsert(normalized, null, 'manual');
+        } else {
+          var intl = _this.props.intl;
+          var linkInvalid = intl.formatMessage(messages.linkInvalid);
+
+          _this.setState({
+            invalidUrl: linkInvalid
+          });
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleKeyDown", function (event) {
+      var _this$state6 = _this.state,
+          items = _this$state6.items,
+          activeIndex = _this$state6.activeIndex;
+      var keyCode = event.keyCode;
+      var KEY_CODE_ARROW_DOWN = 40;
+      var KEY_CODE_ARROW_UP = 38;
+
+      if (!items || !items.length) {
+        return;
+      }
+
+      var updatedIndex = activeIndex;
+
+      switch (keyCode) {
+        case KEY_CODE_ARROW_DOWN:
+          // down
+          event.preventDefault();
+          updatedIndex = (activeIndex + 1) % items.length;
+          break;
+
+        case KEY_CODE_ARROW_UP:
+          // up
+          event.preventDefault();
+          updatedIndex = activeIndex > 0 ? activeIndex - 1 : items.length - 1;
+          break;
+      }
+
+      if ([KEY_CODE_ARROW_DOWN, KEY_CODE_ARROW_UP].includes(keyCode) && items[updatedIndex]) {
+        _this.setState({
+          activeIndex: updatedIndex,
+          selectedIndex: updatedIndex,
+          url: items[updatedIndex].url,
+          invalidUrl: null
+        });
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleCancel", function () {
+      var onCancel = _this.props.onCancel;
+
+      if (onCancel) {
+        onCancel();
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "updateTextInput", function (displayText) {
+      _this.setState({
+        displayText: displayText
+      });
+    });
+
+    _this.state = {
+      selectedIndex: -1,
+      activeIndex: -1,
+      isLoading: false,
+      url: normalizeUrl(props.url) || '',
+      displayText: props.displayText || '',
+      items: [],
+      invalidUrl: null
+    };
+    /* Cache functions */
+
+    _this.handleClearUrl = _this.createClearHandler('url');
+    _this.handleClearDisplayText = _this.createClearHandler('displayText');
+    return _this;
+  }
+
+  _createClass(LinkPicker, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.loadInitialLinkSearchResult();
+    }
+  }, {
+    key: "loadInitialLinkSearchResult",
+    value: function loadInitialLinkSearchResult() {
+      var url = this.state.url;
+
+      if (!url) {
+        this.updateResults();
+      }
+    }
+  }, {
+    key: "getActivePlugin",
+    value: function getActivePlugin() {
+      if (!this.props.plugins || this.props.plugins.length === 0) {
+        return null;
+      }
+
+      return this.props.plugins[0];
+    }
+    /**
+     * Interface between link picker and plugins to update results
+     */
+
+  }, {
+    key: "updateResults",
+    value: function () {
+      var _updateResults = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var queryVersion, activePlugin, updates, _yield$updates$next, done, value;
+
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                queryVersion = ++this.queryVersion;
+                activePlugin = this.getActivePlugin();
+
+                if (activePlugin) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 4:
+                updates = activePlugin.resolve({
+                  query: this.state.url
+                });
+                this.setState({
+                  isLoading: true,
+                  items: []
+                });
+                _context2.prev = 6;
+
+              case 7:
+                if (!(queryVersion === this.queryVersion)) {
+                  _context2.next = 20;
+                  break;
+                }
+
+                _context2.next = 10;
+                return updates.next();
+
+              case 10:
+                _yield$updates$next = _context2.sent;
+                done = _yield$updates$next.done;
+                value = _yield$updates$next.value;
+
+                if (!(queryVersion !== this.queryVersion)) {
+                  _context2.next = 15;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 15:
+                this.setState({
+                  items: limit(value),
+                  isLoading: !done
+                });
+
+                if (!done) {
+                  _context2.next = 18;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 18:
+                _context2.next = 7;
+                break;
+
+              case 20:
+                _context2.next = 25;
+                break;
+
+              case 22:
+                _context2.prev = 22;
+                _context2.t0 = _context2["catch"](6);
+                this.setState({
+                  isLoading: false
+                });
+
+              case 25:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[6, 22]]);
+      }));
+
+      function updateResults() {
+        return _updateResults.apply(this, arguments);
+      }
+
+      return updateResults;
+    }()
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state7 = this.state,
+          items = _this$state7.items,
+          isLoading = _this$state7.isLoading,
+          activeIndex = _this$state7.activeIndex,
+          selectedIndex = _this$state7.selectedIndex,
+          url = _this$state7.url,
+          displayText = _this$state7.displayText;
+      var formatMessage = this.props.intl.formatMessage;
+      var activePlugin = this.getActivePlugin();
+      var linkPlaceHolder = formatMessage(activePlugin ? messages.placeholder : messages.linkPlaceholder);
+      var linkLabel = formatMessage(messages.linkLabel);
+      var linkTextLabel = formatMessage(messages.linkTextLabel);
+      var linkTextPlaceHolder = formatMessage(messages.linkTextPlaceholder);
+      var screenReaderDescriptionId = 'search-recent-links-field-description';
+      var linkSearchListId = 'link-picker-search-list';
+      var ariaActiveDescendant = selectedIndex > -1 ? "link-search-list-item-".concat(selectedIndex) : ''; // Added workaround with a screen reader Announcer specifically for VoiceOver + Safari
+      // as the Aria design pattern for combobox does not work in this case
+      // for details: https://a11y-internal.atlassian.net/browse/AK-740
+
+      var screenReaderText = browser.safari && this.getScreenReaderText();
+      var searchIcon = activePlugin && jsx(SearchIconWrapper, {
+        "data-testid": "link-picker-search-icon"
+      }, jsx(EditorSearchIcon, {
+        size: "medium",
+        label: ''
+      }));
+      return jsx("div", {
+        "data-testid": "link-picker",
+        className: "recent-list",
+        css: recentListStyles
+      }, jsx(Container, {
+        innerRef: this.wrapperRef
+      }, screenReaderText && jsx(Announcer, {
+        ariaLive: "assertive",
+        text: screenReaderText,
+        ariaRelevant: "additions",
+        delay: 250
+      }), jsx(VisuallyHidden, null, jsx("span", {
+        "aria-hidden": "true",
+        id: screenReaderDescriptionId
+      }, formatMessage(messages.searchLinkAriaDescription))), jsx(PanelTextInput, {
+        name: "link",
+        testId: "link-url",
+        role: "combobox",
+        label: linkLabel,
+        placeholder: linkPlaceHolder,
+        value: url,
+        autoFocus: true,
+        autoComplete: "off",
+        elemBeforeInput: searchIcon,
+        onSubmit: this.handleSubmit,
+        onChange: this.updateInput,
+        onKeyDown: this.handleKeyDown,
+        onClear: this.handleClearUrl,
+        error: this.state.invalidUrl,
+        clearLabel: formatMessage(messages.clearLink),
+        "aria-controls": linkSearchListId,
+        "aria-autocomplete": "list",
+        "aria-activedescendant": ariaActiveDescendant,
+        "aria-describedby": screenReaderDescriptionId,
+        "aria-expanded": true
+      }), jsx(PanelTextInput, {
+        name: "link-text",
+        testId: "link-text",
+        autoComplete: "off",
+        label: linkTextLabel,
+        placeholder: linkTextPlaceHolder,
+        "aria-label": formatMessage(messages.linkAriaLabel),
+        value: displayText,
+        onSubmit: this.handleSubmit,
+        onKeyDown: this.handleKeyDown,
+        onChange: this.updateTextInput,
+        onClear: this.handleClearDisplayText,
+        clearLabel: formatMessage(messages.clearText)
+      }), !!items.length && jsx("div", {
+        css: ListTitleStyles,
+        id: "link-picker-list-title",
+        "data-testid": "link-picker-list-title"
+      }, formatMessage(this.state.url ? messages.titleResults : messages.titleRecentlyViewed)), jsx(VisuallyHidden, null, jsx("span", {
+        "aria-live": "polite",
+        "aria-atomic": "true",
+        id: "fabric.smartcard.linkpicker.suggested.results"
+      }, url && formatMessage(messages.searchLinkResults, {
+        count: items.length
+      }))), jsx(LinkSearchList, {
+        ariaLabelledBy: "link-picker-list-title",
+        ariaControls: "fabric.smartcard.linkpicker.suggested.results",
+        id: linkSearchListId,
+        role: "listbox",
+        items: items,
+        isLoading: isLoading,
+        selectedIndex: selectedIndex,
+        activeIndex: activeIndex,
+        onSelect: this.handleSelected,
+        onMouseEnter: this.handleMouseEnterResultItem,
+        onMouseLeave: this.handleMouseLeaveResultItem
+      }), jsx(FormFooter, {
+        align: "end"
+      }, jsx(ButtonGroup, null, jsx(Button, {
+        appearance: "default",
+        onClick: this.handleCancel,
+        testId: "link-picker-cancel-button"
+      }, formatMessage(messages.cancelButton)), jsx(Button, {
+        type: "submit",
+        appearance: "primary",
+        onClick: this.handleSubmit,
+        testId: "link-picker-insert-button"
+      }, formatMessage(messages.insertButton))))));
+    }
+  }]);
+
+  return LinkPicker;
+}(PureComponent);
+
+function findIndex(array, predicate) {
+  var index = -1;
+  array.some(function (item, i) {
+    if (predicate(item)) {
+      index = i;
+      return true;
+    }
+
+    return false;
+  });
+  return index;
+}
+
+function limit(items) {
+  return items.slice(0, RECENT_SEARCH_LIST_SIZE);
+}
+
+export var LinkPickerWithIntl = injectIntl(LinkPicker);

package/dist/esm/url.js

@@ -0,0 +1,90 @@
+import LinkifyIt from 'linkify-it';
+var linkify = LinkifyIt();
+linkify.add('sourcetree:', 'http:');
+var tlds = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');
+var tlds2Char = 'a[cdefgilmnoqrtuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrtuvwxyz]|n[acefgilopruz]|om|p[aefghkmnrtw]|qa|r[eosuw]|s[abcdegijklmnrtuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';
+tlds.push(tlds2Char);
+linkify.tlds(tlds, false);
+var whitelistedURLPatterns = [/^https?:\/\/[^\s]*$/im, /^ftps?:\/\//im, /^\//im, /^mailto:/im, /^skype:/im, /^callto:[^\s]*$/im, /^facetime:[^\s]*$/im, /^git:/im, /^irc6?:/im, /^news:/im, /^nntp:/im, /^feed:/im, /^cvs:/im, /^svn:/im, /^mvn:/im, /^ssh:/im, /^scp:\/\//im, /^sftp:\/\//im, /^itms:/im, /^notes:/im, /^hipchat:\/\//im, /^sourcetree:/im, /^urn:/im, /^tel:/im, /^xmpp:/im, /^telnet:/im, /^vnc:/im, /^rdp:/im, /^whatsapp:/im, /^slack:/im, /^sips?:/im, /^magnet:/im, /^foo:/im, /^#/im];
+
+var normaliseLinkHref = function normaliseLinkHref(url) {
+  var match = getLinkMatch(url);
+  return match && match.url || null;
+};
+
+var getLinkMatch = function getLinkMatch(str) {
+  if (!str) {
+    return null;
+  }
+
+  var match = linkifyMatch(str);
+
+  if (!match.length) {
+    match = linkify.match(str);
+  }
+
+  return match && match.length > 0 && match[0].index === 0 && match[0].lastIndex === str.trim().length ? match[0] : null;
+};
+
+var LINK_REGEXP = /(https?|ftp):\/\/[^\s]+/;
+
+var linkifyMatch = function linkifyMatch(text) {
+  var matches = [];
+
+  if (!LINK_REGEXP.test(text)) {
+    return matches;
+  }
+
+  var startpos = 0;
+  var substr;
+
+  while (substr = text.substr(startpos)) {
+    var link = (substr.match(LINK_REGEXP) || [''])[0];
+
+    if (link) {
+      var index = substr.search(LINK_REGEXP);
+      var start = index >= 0 ? index + startpos : index;
+      var end = start + link.length;
+      matches.push({
+        index: start,
+        lastIndex: end,
+        raw: link,
+        url: link,
+        text: link,
+        schema: ''
+      });
+      startpos += end;
+    } else {
+      break;
+    }
+  }
+
+  return matches;
+};
+
+export var isSafeUrl = function isSafeUrl(url) {
+  var urlTrimmed = url.trim();
+
+  if (urlTrimmed.length === 0) {
+    return true;
+  }
+
+  return whitelistedURLPatterns.some(function (p) {
+    return p.test(urlTrimmed);
+  });
+};
+/**
+ * Adds protocol to url if needed.
+ */
+
+export function normalizeUrl(url) {
+  if (!url) {
+    return '';
+  }
+
+  if (isSafeUrl(url)) {
+    return url.trim();
+  }
+
+  return normaliseLinkHref(url);
+}

package/dist/esm/utils.js

@@ -0,0 +1,24 @@
+import { browser } from './browser';
+export var relativeFontSizeToBase16 = function relativeFontSizeToBase16(px) {
+  if (typeof px === 'string') {
+    px = parseInt(px);
+  }
+
+  if (isNaN(px)) {
+    throw new Error("Invalid font size: '".concat(px, "'"));
+  }
+
+  return "".concat(px / 16, "rem");
+};
+var KeyZCode = 90;
+var KeyYCode = 89;
+export var isUndoEvent = function isUndoEvent(e) {
+  return e.keyCode === KeyZCode && ( // cmd + z for mac
+  browser.mac && e.metaKey && !e.shiftKey || // ctrl + z for non-mac
+  !browser.mac && e.ctrlKey);
+};
+export var isRedoEvent = function isRedoEvent(e) {
+  return (// ctrl + y for non-mac
+    !browser.mac && e.ctrlKey && e.keyCode === KeyYCode || browser.mac && e.metaKey && e.shiftKey && e.keyCode === KeyZCode || e.ctrlKey && e.shiftKey && e.keyCode === KeyZCode
+  );
+};

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/link-picker",
-	"version": "0.0.2",
+	"version": "0.8.1",
 	"sideEffects": false
 }

package/dist/types/browser.d.ts

@@ -0,0 +1,15 @@
+declare const result: {
+    mac: boolean;
+    ie: boolean;
+    ie_version: number;
+    gecko: boolean;
+    chrome: boolean;
+    chrome_version: number;
+    android: boolean;
+    ios: boolean;
+    webkit: boolean;
+    safari: boolean;
+    supportsIntersectionObserver: boolean;
+    supportsResizeObserver: boolean;
+};
+export { result as browser };