@atlaskit/editor-core 148.0.0 → 149.0.3

package/dist/esm/plugins/type-ahead/pm-plugins/reducer.js

@@ -0,0 +1,168 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { DecorationSet } from 'prosemirror-view';
+import { InsertTypeAheadStep, InsertTypeAheadStages } from '@atlaskit/adf-schema/steps';
+import { ACTIONS } from './actions';
+import { pluginKey } from './key';
+import { INPUT_METHOD } from '../../analytics/types/enums';
+import { isTypeAheadHandler } from '../utils';
+
+var shouldForceOpen = function shouldForceOpen(step) {
+  if (!(step instanceof InsertTypeAheadStep)) {
+    return false;
+  }
+
+  var isDeletionRawQueryOperation = step.isInsertionStep() && step.stage === InsertTypeAheadStages.DELETING_RAW_QUERY;
+  var isUndoingInsertionItem = step.isUndoingStep() && step.stage === InsertTypeAheadStages.INSERTING_ITEM;
+  return isDeletionRawQueryOperation || isUndoingInsertionItem;
+};
+
+var shouldForceClose = function shouldForceClose(step) {
+  if (!(step instanceof InsertTypeAheadStep)) {
+    return false;
+  }
+
+  var isInsertingItem = step.isInsertionStep() && step.stage === InsertTypeAheadStages.INSERTING_ITEM;
+  var isUndoingDeletionRawQuery = step.isUndoingStep() && step.stage === InsertTypeAheadStages.DELETING_RAW_QUERY;
+  return isInsertingItem || isUndoingDeletionRawQuery;
+};
+
+var createFindHandler = function createFindHandler(typeAheadHandlers) {
+  return function (step) {
+    if (!(step instanceof InsertTypeAheadStep)) {
+      return null;
+    }
+
+    var handler = typeAheadHandlers.find(function (h) {
+      return h.trigger === step.trigger;
+    });
+    return handler || null;
+  };
+};
+
+export var createReducer = function createReducer(_ref) {
+  var typeAheadHandlers = _ref.typeAheadHandlers,
+      removeDecorations = _ref.removeDecorations,
+      createDecorations = _ref.createDecorations;
+  var findHandler = createFindHandler(typeAheadHandlers);
+
+  var openMenu = function openMenu(currentPluginState, _ref2) {
+    var tr = _ref2.tr,
+        triggerHandler = _ref2.triggerHandler,
+        inputMethod = _ref2.inputMethod,
+        reopenQuery = _ref2.reopenQuery,
+        selectedIndex = _ref2.selectedIndex;
+    removeDecorations(currentPluginState.decorationSet);
+
+    var _createDecorations = createDecorations(tr, {
+      triggerHandler: triggerHandler,
+      inputMethod: inputMethod,
+      reopenQuery: reopenQuery
+    }),
+        decorationSet = _createDecorations.decorationSet,
+        decorationElement = _createDecorations.decorationElement,
+        stats = _createDecorations.stats;
+
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      stats: stats,
+      decorationSet: decorationSet,
+      triggerHandler: triggerHandler,
+      decorationElement: decorationElement,
+      inputMethod: inputMethod,
+      selectedIndex: typeof selectedIndex === 'number' ? selectedIndex : 0,
+      items: [],
+      query: reopenQuery || ''
+    });
+  };
+
+  var closeMenu = function closeMenu(currentPluginState) {
+    removeDecorations(currentPluginState.decorationSet);
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      inputMethod: null,
+      query: '',
+      decorationElement: null,
+      decorationSet: DecorationSet.empty,
+      stats: null,
+      triggerHandler: undefined,
+      items: []
+    });
+  };
+
+  return function (tr, currentPluginState, typeAheadStepOverride) {
+    var meta = tr.getMeta(pluginKey) || {}; // This code below controls when we should force
+    // the menu to open or close during undo/redo operations
+
+    var overrideHandler = findHandler(typeAheadStepOverride);
+
+    if (typeAheadStepOverride && overrideHandler && shouldForceOpen(typeAheadStepOverride)) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: overrideHandler,
+        inputMethod: INPUT_METHOD.KEYBOARD,
+        reopenQuery: typeAheadStepOverride.query,
+        selectedIndex: typeAheadStepOverride.selectedIndex
+      });
+    } else if (shouldForceClose(typeAheadStepOverride)) {
+      return closeMenu(currentPluginState);
+    }
+
+    var _ref3 = meta || {},
+        action = _ref3.action,
+        params = _ref3.params;
+
+    var shouldOpenMenu = action === ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR && isTypeAheadHandler(params === null || params === void 0 ? void 0 : params.triggerHandler);
+    var selectionChanged = tr.selectionSet && (tr.isGeneric || Boolean(tr.getMeta('pointer')));
+    var shouldCloseMenu = [ACTIONS.CLOSE_TYPE_AHEAD, ACTIONS.INSERT_ITEM].includes(action) || selectionChanged;
+    var shouldUpdateQuery = action === ACTIONS.CHANGE_QUERY;
+    var shouldUpdateListItems = action === ACTIONS.UPDATE_LIST_ITEMS;
+    var shouldUpdateSelectedIndex = action === ACTIONS.UPDATE_SELECTED_INDEX;
+
+    if (shouldOpenMenu) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: params.triggerHandler,
+        inputMethod: params.inputMethod
+      });
+    } else if (shouldCloseMenu) {
+      return closeMenu(currentPluginState);
+    } else if (shouldUpdateQuery) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        query: params.query
+      });
+    } else if (shouldUpdateListItems) {
+      var items = params.items;
+      var selectedIndex = currentPluginState.selectedIndex;
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        items: items,
+        selectedIndex: Math.max(selectedIndex >= items.length ? items.length - 1 : selectedIndex, 0)
+      });
+    } else if (shouldUpdateSelectedIndex) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        selectedIndex: params.selectedIndex
+      });
+    }
+
+    if (tr.docChanged) {
+      var decorationSet = currentPluginState.decorationSet;
+
+      var onRemove = function onRemove() {
+        // Make sure we are unmounting the component
+        // from the react tree when this decoration is removed
+        removeDecorations(currentPluginState.decorationSet);
+      };
+
+      var mappedDecorationSet = decorationSet.map(tr.mapping, tr.doc, {
+        onRemove: onRemove
+      });
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        decorationSet: mappedDecorationSet
+      });
+    }
+
+    return currentPluginState;
+  };
+};

package/dist/esm/plugins/type-ahead/pm-plugins/utils.js

@@ -0,0 +1,16 @@
+import { pluginKey } from './key';
+export var isInsertionTransaction = function isInsertionTransaction(transactions, action) {
+  var _tr$getMeta2;
+
+  var tr = transactions.find(function (tr) {
+    var _tr$getMeta;
+
+    return ((_tr$getMeta = tr.getMeta(pluginKey)) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.action) === action;
+  });
+
+  if (!tr) {
+    return null;
+  }
+
+  return (_tr$getMeta2 = tr.getMeta(pluginKey)) === null || _tr$getMeta2 === void 0 ? void 0 : _tr$getMeta2.params;
+};

package/dist/esm/plugins/type-ahead/stats-modifier.js

@@ -0,0 +1,43 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export var StatsModifier = function StatsModifier() {
+  var _this = this;
+
+  _classCallCheck(this, StatsModifier);
+
+  _defineProperty(this, "startedAt", 0);
+
+  _defineProperty(this, "endedAt", 0);
+
+  _defineProperty(this, "keyCount", {
+    arrowUp: 0,
+    arrowDown: 0
+  });
+
+  _defineProperty(this, "increaseArrowUp", function () {
+    _this.keyCount.arrowUp += 1;
+  });
+
+  _defineProperty(this, "increaseArrowDown", function () {
+    _this.keyCount.arrowDown += 1;
+  });
+
+  _defineProperty(this, "serialize", function () {
+    var _this$keyCount, _this$keyCount2;
+
+    return {
+      startedAt: _this.startedAt,
+      endedAt: performance.now(),
+      keyCount: {
+        arrowUp: ((_this$keyCount = _this.keyCount) === null || _this$keyCount === void 0 ? void 0 : _this$keyCount.arrowUp) || 0,
+        arrowDown: ((_this$keyCount2 = _this.keyCount) === null || _this$keyCount2 === void 0 ? void 0 : _this$keyCount2.arrowDown) || 0
+      }
+    };
+  });
+
+  this.startedAt = performance.now();
+  this.keyCount = {
+    arrowUp: 0,
+    arrowDown: 0
+  };
+};

package/dist/esm/plugins/type-ahead/transforms/close-type-ahead.js

@@ -0,0 +1,7 @@
+import { pluginKey } from '../pm-plugins/key';
+import { ACTIONS } from '../pm-plugins/actions';
+export var closeTypeAhead = function closeTypeAhead(tr) {
+  return tr.setMeta(pluginKey, {
+    action: ACTIONS.CLOSE_TYPE_AHEAD
+  });
+};

package/dist/esm/plugins/type-ahead/transforms/open-typeahead-at-cursor.js

@@ -0,0 +1,39 @@
+import { TextSelection } from 'prosemirror-state';
+import { pluginKey } from '../pm-plugins/key';
+import { ACTIONS } from '../pm-plugins/actions';
+export var openTypeAheadAtCursor = function openTypeAheadAtCursor(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+      inputMethod = _ref.inputMethod,
+      query = _ref.query;
+  return function (tr) {
+    tr.setMeta(pluginKey, {
+      action: ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR,
+      params: {
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod,
+        query: query
+      }
+    });
+    var selection = tr.selection;
+
+    if (!(selection instanceof TextSelection)) {
+      return tr;
+    }
+
+    if (!selection.$cursor) {
+      tr.deleteSelection();
+      return tr;
+    } // Search & Destroy placeholder
+
+
+    var cursorPos = selection.$cursor.pos;
+    var nodeAtCursor = tr.doc.nodeAt(cursorPos);
+    var isPlaceholderAtCursorPosition = nodeAtCursor && nodeAtCursor.type.name === 'placeholder';
+
+    if (nodeAtCursor && isPlaceholderAtCursorPosition) {
+      tr.delete(cursorPos, cursorPos + nodeAtCursor.nodeSize);
+    }
+
+    return tr;
+  };
+};

package/dist/esm/plugins/type-ahead/transforms/set-selection-before-query.js

@@ -0,0 +1,13 @@
+import { TextSelection } from 'prosemirror-state';
+export var setSelectionBeforeQuery = function setSelectionBeforeQuery(rawText) {
+  return function (tr) {
+    var currentPosition = tr.selection.$from.pos;
+    var positionBeforeRawText = Math.max(currentPosition - rawText.length, 0);
+    var resolvedPositionBeforeText = tr.doc.resolve(positionBeforeRawText);
+    var nextSelection = TextSelection.findFrom(resolvedPositionBeforeText, -1, true);
+
+    if (nextSelection) {
+      tr.setSelection(nextSelection);
+    }
+  };
+};

package/dist/esm/plugins/type-ahead/ui/DynamicHeightListItem.js

@@ -0,0 +1,51 @@
+import React, { useContext, useRef, useCallback } from 'react';
+import { TypeAheadListItem } from './TypeAheadListItem';
+import { useResizeObserver } from './hooks/use-resize-observer';
+
+var noop = function noop() {};
+
+export var SelectedIndexContext = /*#__PURE__*/React.createContext(0);
+export var ListItemActionsContext = /*#__PURE__*/React.createContext({
+  onItemClick: noop,
+  onItemHover: noop
+});
+export var UpdateListItemHeightContext = /*#__PURE__*/React.createContext(noop);
+export var DynamicHeightListItem = function DynamicHeightListItem(_ref) {
+  var index = _ref.index,
+      data = _ref.data,
+      style = _ref.style;
+  var item = data[index];
+  var selectedIndex = useContext(SelectedIndexContext);
+
+  var _useContext = useContext(ListItemActionsContext),
+      onItemClick = _useContext.onItemClick,
+      onItemHover = _useContext.onItemHover;
+
+  var updateItemHeight = useContext(UpdateListItemHeightContext);
+  var innerDivRef = useRef(document.createElement('div'));
+  var onResize = useCallback(function (entry) {
+    if (typeof updateItemHeight !== 'function') {
+      return;
+    }
+
+    updateItemHeight({
+      index: index,
+      height: entry.contentRect.height
+    });
+  }, [updateItemHeight, index]);
+  useResizeObserver(innerDivRef, onResize);
+  return /*#__PURE__*/React.createElement("div", {
+    style: style,
+    "data-index": index
+  }, /*#__PURE__*/React.createElement("div", {
+    ref: innerDivRef,
+    "data-testid": "list-item-height-observed-".concat(index)
+  }, /*#__PURE__*/React.createElement(TypeAheadListItem, {
+    key: item.title,
+    item: item,
+    itemIndex: index,
+    selectedIndex: selectedIndex,
+    onItemClick: onItemClick,
+    onItemHover: onItemHover
+  })));
+};

package/dist/esm/plugins/type-ahead/ui/InputQuery.js

@@ -0,0 +1,302 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+
+var _templateObject;
+
+import React, { useRef, useEffect, useCallback } from 'react';
+import styled from 'styled-components';
+import { keyName as keyNameNormalized } from 'w3c-keyname';
+import { browser, ZERO_WIDTH_SPACE } from '@atlaskit/editor-common';
+import { CloseSelectionOptions } from '../constants';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+var QuerySpan = styled.span(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  outline: none;\n"])));
+
+var isNavigationKey = function isNavigationKey(event) {
+  return ['Enter', 'Tab', 'ArrowDown', 'ArrowUp'].includes(event.key);
+};
+
+var isUndoRedoShortcut = function isUndoRedoShortcut(event) {
+  var key = keyNameNormalized(event);
+
+  if (event.ctrlKey && key === 'y') {
+    return 'historyRedo';
+  }
+
+  if ((event.ctrlKey || event.metaKey) && event.shiftKey && key === 'Z') {
+    return 'historyRedo';
+  }
+
+  if ((event.ctrlKey || event.metaKey) && key === 'z') {
+    return 'historyUndo';
+  }
+
+  return false;
+};
+
+export var InputQuery = /*#__PURE__*/React.memo(function (_ref) {
+  var triggerQueryPrefix = _ref.triggerQueryPrefix,
+      cancel = _ref.cancel,
+      onQueryChange = _ref.onQueryChange,
+      onItemSelect = _ref.onItemSelect,
+      selectNextItem = _ref.selectNextItem,
+      selectPreviousItem = _ref.selectPreviousItem,
+      forceFocus = _ref.forceFocus,
+      reopenQuery = _ref.reopenQuery,
+      onQueryFocus = _ref.onQueryFocus,
+      onUndoRedo = _ref.onUndoRedo;
+  var ref = useRef(document.createElement('span'));
+  var cleanedInputContent = useCallback(function () {
+    var raw = ref.current.textContent || '';
+    return raw.replace(ZERO_WIDTH_SPACE, '');
+  }, []);
+  var onKeyUp = useCallback(function (event) {
+    var text = cleanedInputContent();
+    onQueryChange(text);
+  }, [onQueryChange, cleanedInputContent]);
+  var checkKeyEvent = useCallback(function (event) {
+    var key = keyNameNormalized(event);
+    var sel = document.getSelection();
+    var raw = ref.current.textContent || '';
+    var text = cleanedInputContent();
+    var stopDefault = false;
+
+    switch (key) {
+      case ' ':
+        // space key
+        if (text.length === 0) {
+          cancel({
+            forceFocusOnEditor: true,
+            text: ' ',
+            addPrefixTrigger: true,
+            setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED
+          });
+          stopDefault = true;
+        }
+
+        break;
+
+      case 'Escape':
+        cancel({
+          text: text,
+          forceFocusOnEditor: true,
+          addPrefixTrigger: true,
+          setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED
+        });
+        break;
+
+      case 'Backspace':
+        if (raw === ZERO_WIDTH_SPACE || raw.length === 0 || (sel === null || sel === void 0 ? void 0 : sel.anchorOffset) === 0) {
+          event.stopPropagation();
+          event.preventDefault();
+          cancel({
+            forceFocusOnEditor: true,
+            text: text,
+            addPrefixTrigger: false,
+            setSelectionAt: CloseSelectionOptions.BEFORE_TEXT_INSERTED
+          });
+        }
+
+        break;
+
+      case 'Enter':
+        onItemSelect(event.shiftKey ? SelectItemMode.SHIFT_ENTER : SelectItemMode.ENTER);
+        break;
+
+      case 'Tab':
+        onItemSelect(SelectItemMode.TAB);
+        break;
+
+      case 'ArrowDown':
+        selectNextItem();
+        break;
+
+      case 'ArrowUp':
+        selectPreviousItem();
+        break;
+    }
+
+    var undoRedoType = isUndoRedoShortcut(event);
+
+    if (onUndoRedo && undoRedoType && onUndoRedo(undoRedoType)) {
+      stopDefault = true;
+    }
+
+    if (isNavigationKey(event) || stopDefault) {
+      event.stopPropagation();
+      event.preventDefault();
+      return false;
+    }
+  }, [onUndoRedo, onItemSelect, selectNextItem, cancel, selectPreviousItem, cleanedInputContent]);
+  var onClick = useCallback(function (event) {
+    event.stopPropagation();
+    event.preventDefault();
+    onQueryFocus();
+    ref.current.focus();
+    return false;
+  }, [onQueryFocus]);
+  useEffect(function () {
+    if (!ref.current) {
+      return;
+    }
+
+    var element = ref.current;
+
+    var onFocusIn = function onFocusIn(event) {
+      onQueryFocus();
+    };
+
+    var keyDown = function keyDown(event) {
+      var key = keyNameNormalized(event);
+
+      if (['ArrowLeft', 'ArrowRight'].includes(key) && document.getSelection && document.getSelection()) {
+        var q = ref.current.textContent || '';
+        var sel = document.getSelection();
+        var isMovingRight = sel && 'ArrowRight' === key && sel.anchorOffset === q.length;
+        var isMovingLeft = sel && 'ArrowLeft' === key && sel.anchorOffset === 0;
+
+        if (!isMovingRight && !isMovingLeft) {
+          return;
+        }
+
+        cancel({
+          forceFocusOnEditor: true,
+          addPrefixTrigger: true,
+          text: cleanedInputContent(),
+          setSelectionAt: isMovingRight ? CloseSelectionOptions.AFTER_TEXT_INSERTED : CloseSelectionOptions.BEFORE_TEXT_INSERTED
+        });
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+
+      checkKeyEvent(event);
+    };
+
+    var onFocusOut = function onFocusOut(event) {
+      cancel({
+        addPrefixTrigger: true,
+        text: cleanedInputContent(),
+        setSelectionAt: CloseSelectionOptions.BEFORE_TEXT_INSERTED,
+        forceFocusOnEditor: false
+      });
+    };
+
+    var close = function close() {
+      cancel({
+        addPrefixTrigger: false,
+        text: '',
+        forceFocusOnEditor: true,
+        setSelectionAt: CloseSelectionOptions.BEFORE_TEXT_INSERTED
+      });
+    };
+
+    var beforeinput = function beforeinput(e) {
+      var _target$textContent;
+
+      var target = e.target;
+
+      if (e.isComposing || !(target instanceof HTMLElement)) {
+        return;
+      }
+
+      if (e.inputType === 'historyUndo' && (((_target$textContent = target.textContent) === null || _target$textContent === void 0 ? void 0 : _target$textContent.length) === 0 || target.textContent === ZERO_WIDTH_SPACE)) {
+        e.preventDefault();
+        e.stopPropagation();
+        close();
+        return;
+      }
+
+      if (e.data != null && target.textContent === ZERO_WIDTH_SPACE) {
+        element.textContent = ''; // We need to change the content on Safari
+        // and set the cursor at the right place
+
+        if (browser.safari) {
+          e.preventDefault();
+          var dataElement = document.createTextNode(e.data);
+          element.appendChild(dataElement);
+          var sel = window.getSelection();
+          var range = document.createRange();
+          range.setStart(dataElement, dataElement.length);
+          range.collapse(true);
+          sel === null || sel === void 0 ? void 0 : sel.removeAllRanges();
+          sel === null || sel === void 0 ? void 0 : sel.addRange(range);
+        }
+      }
+    };
+
+    var onInput = null;
+
+    if (browser.safari) {
+      // On Safari, for reasons beyond my understanding,
+      // The undo behavior is totally different from other browsers
+      // That why we need to have an specific branch only for Safari.
+      var _onInput = function _onInput(e) {
+        var _target$textContent2;
+
+        var target = e.target;
+
+        if (e.isComposing || !(target instanceof HTMLElement)) {
+          return;
+        }
+
+        if (e.inputType === 'historyUndo' && ((_target$textContent2 = target.textContent) === null || _target$textContent2 === void 0 ? void 0 : _target$textContent2.length) === 1) {
+          e.preventDefault();
+          e.stopPropagation();
+          close();
+          return;
+        }
+      };
+
+      element.addEventListener('input', _onInput);
+    }
+
+    element.addEventListener('focusout', onFocusOut);
+    element.addEventListener('focusin', onFocusIn);
+    element.addEventListener('keydown', keyDown);
+    element.addEventListener('beforeinput', beforeinput);
+    return function () {
+      element.removeEventListener('focusout', onFocusOut);
+      element.removeEventListener('focusin', onFocusIn);
+      element.removeEventListener('keydown', keyDown);
+      element.removeEventListener('beforeinput', beforeinput);
+
+      if (browser.safari) {
+        element.removeEventListener('input', onInput);
+      }
+    };
+  }, [triggerQueryPrefix, cleanedInputContent, onQueryFocus, cancel, checkKeyEvent]);
+  useEffect(function () {
+    var hasReopenQuery = typeof reopenQuery === 'string' && reopenQuery.trim().length > 0;
+
+    if (ref.current && forceFocus) {
+      ref.current.textContent = hasReopenQuery ? reopenQuery : ZERO_WIDTH_SPACE;
+      requestAnimationFrame(function () {
+        if (!(ref !== null && ref !== void 0 && ref.current)) {
+          return;
+        }
+
+        var sel = window.getSelection();
+
+        if (sel && hasReopenQuery && ref.current.lastChild instanceof Text) {
+          var lastChild = ref.current.lastChild;
+          var range = document.createRange();
+          range.setStart(ref.current.lastChild, lastChild.length);
+          range.collapse(true);
+          sel.removeAllRanges();
+          sel.addRange(range);
+        }
+
+        ref.current.focus();
+      });
+    }
+  }, [forceFocus, reopenQuery]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, triggerQueryPrefix, /*#__PURE__*/React.createElement(QuerySpan, {
+    contentEditable: true,
+    innerRef: ref,
+    onKeyUp: onKeyUp,
+    onClick: onClick,
+    role: "textbox",
+    suppressContentEditableWarning: true,
+    "data-query-prefix": triggerQueryPrefix
+  }));
+});
+InputQuery.displayName = 'InputQuery';