@atlaskit/jql-editor 4.0.0

package/dist/esm/plugins/rich-inline-nodes/util/create-node-spec.js

@@ -0,0 +1,30 @@
+import mapKeys from 'lodash/mapKeys';
+import mapValues from 'lodash/mapValues';
+import { RICH_INLINE_NODE } from '../constants';
+export var createNodeSpec = function createNodeSpec(name, attrs) {
+  return {
+    group: RICH_INLINE_NODE,
+    content: 'text*',
+    inline: true,
+    atom: true,
+    // treat node as a leaf
+    attrs: attrs,
+    toDOM: function toDOM(node) {
+      var domAttrs = mapKeys(node.attrs, function (_, attr) {
+        return "data-".concat(attr);
+      });
+      return [name, domAttrs, 0];
+    },
+    parseDOM: [{
+      tag: name,
+      getAttrs: function getAttrs(node) {
+        if (node instanceof Element) {
+          return mapValues(attrs, function (_, attr) {
+            return node.getAttribute("data-".concat(attr));
+          });
+        }
+        return null; // should never™ happen
+      }
+    }]
+  };
+};

package/dist/esm/plugins/rich-inline-nodes/util/react-node-view.js

@@ -0,0 +1,119 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import React, { useEffect, useLayoutEffect, useState } from 'react';
+import { Subject } from 'rxjs/Subject';
+import { v4 as uuid } from 'uuid';
+import { useEditorViewHasFocus } from '../../../state';
+import { ERROR_NODE, SELECTED_NODE } from '../constants';
+export var ReactNodeView = /*#__PURE__*/function () {
+  function ReactNodeView(component, portalActions, _node) {
+    var _this = this;
+    _classCallCheck(this, ReactNodeView);
+    _defineProperty(this, "componentSubject", new Subject());
+    _defineProperty(this, "init", function (decorations) {
+      var Component = _this.component;
+      var PortallingComponent = function PortallingComponent() {
+        var _useState = useState(_objectSpread(_objectSpread({}, _this.getProps(_this.node)), {}, {
+            selected: _this.isSelected(decorations),
+            error: _this.hasError(decorations)
+          })),
+          _useState2 = _slicedToArray(_useState, 2),
+          state = _useState2[0],
+          setState = _useState2[1];
+
+        // ProseMirror keeps decorations on blur (as those are derived from editor state and focus isn't part of it),
+        // but we don't want to show node views as selected when that happens. We could build a workaround for this in
+        // richInlineNodesPlugin, but this hook will make selection behave more consistently with other focus-related features.
+        var _useEditorViewHasFocu = useEditorViewHasFocus(),
+          _useEditorViewHasFocu2 = _slicedToArray(_useEditorViewHasFocu, 1),
+          hasFocus = _useEditorViewHasFocu2[0];
+        useEffect(function () {
+          // Subscribe to the RxJS subject so concrete subclasses can emit events to re-render the node view component
+          var subscription = _this.componentSubject.subscribe(function (props) {
+            setState(props);
+          });
+          return function () {
+            return subscription.unsubscribe();
+          };
+        }, []);
+        useLayoutEffect(function () {
+          if (state.error) {
+            _this.dom.dataset.tokenType = 'error';
+          } else {
+            delete _this.dom.dataset.tokenType;
+          }
+        }, [state]);
+        return /*#__PURE__*/React.createElement(Component, _extends({}, state, {
+          selected: state.selected && hasFocus
+        }));
+      };
+
+      // Ok, this is a tricky one. As everything that requires collaboration between ProseMirror and React.
+      //
+      // If we run `onCreatePortal` synchronously, ProseMirror won't insert the node view container (`this.dom`)
+      // immediately into the DOM (as init function hasn't returned yet). This can trigger race conditions in other
+      // code paths where ProseMirror may try to get DOM position for this node view before it has been inserted
+      // (e.g. calculating new autocomplete position after insertion, or setting selection after the node).
+      //
+      // With `queueMicrotask` we can schedule this operation to be run after ProseMirror is done with the element
+      // insertion, but before control of the execution context is returned to the browser's event loop. This should
+      // prevent all conflicts with other pieces of asynchronous code and still render the portal as soon as it is
+      // practically possible, so we can avoid flicker in situations where node views are reconstructed by ProseMirror.
+      // @see https://github.com/ProseMirror/prosemirror/issues/872
+      queueMicrotask(function () {
+        _this.portalActions.onCreatePortal(_this.portalKey, /*#__PURE__*/React.createElement(PortallingComponent, null), _this.dom);
+      });
+      return _this;
+    });
+    _defineProperty(this, "destroy", function () {
+      _this.portalActions.onDestroyPortal(_this.portalKey);
+    });
+    _defineProperty(this, "update", function (node, decorations) {
+      // Update function may be called by ProseMirror with a node that has nothing to do with this node view ¯\_(ツ)_/¯
+      // @see https://prosemirror.net/docs/ref/#view.NodeView.update
+      if (node !== _this.node) {
+        return false;
+      }
+      _this.componentSubject.next(_objectSpread(_objectSpread({}, _this.getProps(node)), {}, {
+        selected: _this.isSelected(decorations),
+        error: _this.hasError(decorations)
+      }));
+      return true;
+    });
+    _defineProperty(this, "getProps", function (node) {
+      return _objectSpread({}, node.attrs);
+    });
+    _defineProperty(this, "isSelected", function (decorations) {
+      return decorations.some(function (decoration) {
+        return decoration.spec.type === SELECTED_NODE;
+      });
+    });
+    _defineProperty(this, "hasError", function (decorations) {
+      return decorations.some(function (decoration) {
+        return decoration.spec.type === ERROR_NODE;
+      });
+    });
+    this.component = component;
+    this.portalActions = portalActions;
+    this.node = _node;
+    // Generate unique portal identifier
+    // If you read this comment in the future and TypeScript has added support for Symbols as object keys, please do
+    // JQL Editor a favor and replace this library with the native JS functionality that TS was supposed to support.
+    this.portalKey = uuid();
+    // Creating span under the assumption that all node views will be inline elements in JQL Editor
+    this.dom = document.createElement('span');
+    this.dom.setAttribute('data-testid', 'jql-editor-node-view');
+  }
+  _createClass(ReactNodeView, null, [{
+    key: "for",
+    value: function _for(component, portalActions, node, decorations) {
+      return new ReactNodeView(component, portalActions, node).init(decorations);
+    }
+  }]);
+  return ReactNodeView;
+}();

package/dist/esm/plugins/rich-inline-nodes/util/replace-nodes-transaction.js

@@ -0,0 +1,131 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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; } }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { AbstractJastVisitor } from '@atlaskit/jql-ast';
+import { JQLEditorSchema } from '../../../schema';
+import getDocumentPosition from '../../common/get-document-position';
+import { getJastFromState } from '../../jql-ast';
+import { RICH_INLINE_NODE } from '../constants';
+export var replaceRichInlineNodes = function replaceRichInlineNodes(editorState, hydratedValues) {
+  var ast = getJastFromState(editorState);
+  var transaction = editorState.tr;
+  // Do not allow users to revert this transaction with undo command so they can't land in an unhydrated state
+  transaction.setMeta('addToHistory', false);
+  Object.entries(hydratedValues).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      fieldName = _ref2[0],
+      values = _ref2[1];
+    values.forEach(function (value) {
+      if (value.type === 'user') {
+        var astNodes = getValueNodes(ast, fieldName, value.id);
+        astNodes.forEach(function (astNode) {
+          if (astNode.position) {
+            var _astNode$position = _slicedToArray(astNode.position, 2),
+              from = _astNode$position[0],
+              to = _astNode$position[1];
+            var documentFrom = getDocumentPosition(transaction.doc, from);
+            if (!isRichInlineNode(transaction.doc, documentFrom)) {
+              var documentTo = getDocumentPosition(transaction.doc, to);
+              var node = getRichInlineNode(fieldName, value, astNode.text);
+              transaction.replaceWith(documentFrom, documentTo, node);
+            }
+          }
+        });
+      }
+    });
+  });
+  return transaction;
+};
+var getRichInlineNode = function getRichInlineNode(fieldName, value, text) {
+  switch (value.type) {
+    case 'user':
+      {
+        var textContent = JQLEditorSchema.text(text);
+        return JQLEditorSchema.nodes.user.create(_objectSpread(_objectSpread({}, value), {}, {
+          fieldName: fieldName
+        }), textContent);
+      }
+    default:
+      {
+        throw new Error("Unsupported hydrated value type ".concat(value.type));
+      }
+  }
+};
+var isRichInlineNode = function isRichInlineNode(doc, position) {
+  var _doc$resolve$nodeAfte;
+  return ((_doc$resolve$nodeAfte = doc.resolve(position).nodeAfter) === null || _doc$resolve$nodeAfte === void 0 ? void 0 : _doc$resolve$nodeAfte.type.spec.group) === RICH_INLINE_NODE;
+};
+var getValueNodes = function getValueNodes(ast, field, value) {
+  if (!ast.query) {
+    return [];
+  }
+  return ast.query.accept(new FindValuesVisitor(field, value));
+};
+var FindValuesVisitor = /*#__PURE__*/function (_AbstractJastVisitor) {
+  _inherits(FindValuesVisitor, _AbstractJastVisitor);
+  var _super = _createSuper(FindValuesVisitor);
+  function FindValuesVisitor(field, value) {
+    var _this;
+    _classCallCheck(this, FindValuesVisitor);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "visitQuery", function (query) {
+      if (query.where === undefined) {
+        return [];
+      }
+      return query.where.accept(_assertThisInitialized(_this));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitCompoundClause", function (compoundClause) {
+      return compoundClause.clauses.reduce(function (operands, compoundClause) {
+        return [].concat(_toConsumableArray(operands), _toConsumableArray(compoundClause.accept(_assertThisInitialized(_this))));
+      }, []);
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitTerminalClause", function (terminalClause) {
+      if (terminalClause.field.value !== _this.field) {
+        return [];
+      }
+      if (terminalClause.operand === undefined) {
+        return [];
+      }
+      return terminalClause.operand.accept(_assertThisInitialized(_this));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitNotClause", function (notClause) {
+      return notClause.clause.accept(_assertThisInitialized(_this));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitValueOperand", function (valueOperand) {
+      if (valueOperand.value !== _this.value) {
+        return [];
+      }
+      return [valueOperand];
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitListOperand", function (listOperand) {
+      return listOperand.values.reduce(function (values, operand) {
+        return [].concat(_toConsumableArray(values), _toConsumableArray(operand.accept(_assertThisInitialized(_this))));
+      }, []);
+    });
+    _this.field = field;
+    _this.value = value;
+    return _this;
+  }
+  _createClass(FindValuesVisitor, [{
+    key: "aggregateResult",
+    value: function aggregateResult(aggregate, nextResult) {
+      return [].concat(_toConsumableArray(aggregate), _toConsumableArray(nextResult));
+    }
+  }, {
+    key: "defaultResult",
+    value: function defaultResult() {
+      return [];
+    }
+  }]);
+  return FindValuesVisitor;
+}(AbstractJastVisitor);

package/dist/esm/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/plugins/validation-tooltip/constants.js

@@ -0,0 +1,5 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var JQLValidationTooltipPluginKey = new PluginKey('jql-validation-tooltip-plugin');
+export var TOOLTIP_CLASSNAME = 'jql-validation-tooltip';
+export var TOOLTIP_ENTER_CLASSNAME = 'jql-validation-tooltip-enter';
+export var TOOLTIP_EXIT_CLASSNAME = 'jql-validation-tooltip-exit';

package/dist/esm/plugins/validation-tooltip/index.js

@@ -0,0 +1,52 @@
+import { Plugin } from '@atlaskit/editor-prosemirror/state';
+import { JQLValidationTooltipPluginKey } from './constants';
+import { ValidationTooltipPluginView } from './view';
+var validationTooltipPlugin = function validationTooltipPlugin(mainId) {
+  var plugin = new Plugin({
+    key: JQLValidationTooltipPluginKey,
+    view: function view() {
+      return new ValidationTooltipPluginView(mainId);
+    },
+    state: {
+      init: function init() {
+        return false;
+      },
+      // @ts-ignore
+      apply: function apply(tr, value) {
+        if (tr.getMeta(plugin) !== undefined) {
+          return tr.getMeta(plugin);
+        } else {
+          return value;
+        }
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        mouseover: function mouseover(_ref, event) {
+          var state = _ref.state,
+            dispatch = _ref.dispatch;
+          var isHovered = plugin.getState(state);
+          if (event.target instanceof Element && event.target.closest('[data-token-type="error"]')) {
+            if (!isHovered) {
+              dispatch(state.tr.setMeta(plugin, true));
+            }
+          } else if (isHovered) {
+            dispatch(state.tr.setMeta(plugin, false));
+          }
+          return false;
+        },
+        mouseleave: function mouseleave(_ref2) {
+          var state = _ref2.state,
+            dispatch = _ref2.dispatch;
+          var isHovered = plugin.getState(state);
+          if (isHovered) {
+            dispatch(state.tr.setMeta(plugin, false));
+          }
+          return false;
+        }
+      }
+    }
+  });
+  return plugin;
+};
+export default validationTooltipPlugin;

package/dist/esm/plugins/validation-tooltip/view.js

@@ -0,0 +1,67 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { JQLSyntaxError } from '@atlaskit/jql-ast';
+import getDocumentPosition from '../common/get-document-position';
+import { getJastFromState } from '../jql-ast';
+import { JQLValidationTooltipPluginKey, TOOLTIP_CLASSNAME, TOOLTIP_ENTER_CLASSNAME, TOOLTIP_EXIT_CLASSNAME } from './constants';
+export var ValidationTooltipPluginView = /*#__PURE__*/function () {
+  function ValidationTooltipPluginView(mainId) {
+    var _this = this,
+      _document$getElementB;
+    _classCallCheck(this, ValidationTooltipPluginView);
+    _defineProperty(this, "showTooltip", function (error, start, end) {
+      var _this$tooltip$offsetP, _box$left, _box$top;
+      // Find a center position from the selection endpoints
+      var left = (start.left + end.left) / 2;
+
+      // The box in which the container is positioned, to use as base
+      var box = (_this$tooltip$offsetP = _this.tooltip.offsetParent) === null || _this$tooltip$offsetP === void 0 ? void 0 : _this$tooltip$offsetP.getBoundingClientRect();
+      _this.tooltip.style.left = "".concat(left - ((_box$left = box === null || box === void 0 ? void 0 : box.left) !== null && _box$left !== void 0 ? _box$left : 0), "px");
+      _this.tooltip.style.top = "".concat(start.top - ((_box$top = box === null || box === void 0 ? void 0 : box.top) !== null && _box$top !== void 0 ? _box$top : 0), "px");
+      _this.tooltip.textContent = error.message;
+      _this.tooltip.classList.remove(TOOLTIP_EXIT_CLASSNAME);
+      _this.tooltip.classList.add(TOOLTIP_ENTER_CLASSNAME);
+    });
+    _defineProperty(this, "hideTooltip", function () {
+      _this.tooltip.classList.remove(TOOLTIP_ENTER_CLASSNAME);
+      _this.tooltip.classList.add(TOOLTIP_EXIT_CLASSNAME);
+    });
+    this.tooltip = document.createElement('div');
+    this.tooltip.setAttribute('data-testid', 'jql-validation-tooltip');
+    this.tooltip.classList.add(TOOLTIP_CLASSNAME);
+    (_document$getElementB = document.getElementById(mainId)) === null || _document$getElementB === void 0 || _document$getElementB.appendChild(this.tooltip);
+  }
+  _createClass(ValidationTooltipPluginView, [{
+    key: "update",
+    value: function update(view, lastState) {
+      var state = view.state;
+      var isHovered = JQLValidationTooltipPluginKey.getState(state);
+      var lastIsHovered = JQLValidationTooltipPluginKey.getState(lastState);
+      var jast = getJastFromState(state);
+      var _jast$errors = _slicedToArray(jast.errors, 1),
+        error = _jast$errors[0];
+      if (isHovered === lastIsHovered) {
+        return;
+      }
+      if (isHovered) {
+        if (error instanceof JQLSyntaxError) {
+          var start = getDocumentPosition(state.doc, error.start);
+          var stop = getDocumentPosition(state.doc, error.stop);
+          var startCoords = view.coordsAtPos(start);
+          var stopCoords = view.coordsAtPos(stop);
+          this.showTooltip(error, startCoords, stopCoords);
+        }
+      } else {
+        this.hideTooltip();
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.tooltip.remove();
+    }
+  }]);
+  return ValidationTooltipPluginView;
+}();

package/dist/esm/schema/index.js

@@ -0,0 +1,129 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import mapValues from 'lodash/mapValues';
+import { baseKeymap } from '@atlaskit/editor-prosemirror/commands';
+import { history, redo, undo } from '@atlaskit/editor-prosemirror/history';
+import { keydownHandler, keymap } from '@atlaskit/editor-prosemirror/keymap';
+import { DOMParser, Schema } from '@atlaskit/editor-prosemirror/model';
+import { EditorState, Plugin } from '@atlaskit/editor-prosemirror/state';
+import { autocompletePlugin, jqlAstPlugin, jqlSyntaxHighlightingPlugin, richInlineNodesPlugin, validationTooltipPlugin } from '../plugins';
+import { RICH_INLINE_NODE } from '../plugins/rich-inline-nodes/constants';
+import { richInlineNodes } from '../plugins/rich-inline-nodes/nodes';
+import { createNodeSpec } from '../plugins/rich-inline-nodes/util/create-node-spec';
+import { getFragmentText } from '../utils/document-text';
+import { splitTextByNewLine } from '../utils/split-text-by-new-line';
+var createMarkWithStyle = function createMarkWithStyle(tokenType) {
+  var mark = document.createElement('span');
+  mark.className = "mark-token-".concat(tokenType);
+  mark.setAttribute('data-token-type', tokenType);
+  mark.setAttribute('spellcheck', 'false');
+  return mark;
+};
+export var JQLEditorSchema = new Schema({
+  nodes: _objectSpread({
+    doc: {
+      content: 'paragraph+'
+    },
+    paragraph: {
+      content: "(text|".concat(RICH_INLINE_NODE, ")*"),
+      toDOM: function toDOM() {
+        return ['p', {
+          spellcheck: 'false'
+        }, 0];
+      },
+      parseDOM: [{
+        tag: 'p'
+      }]
+    },
+    text: {}
+  }, mapValues(richInlineNodes, function (spec, name) {
+    return createNodeSpec(name, spec.attrs);
+  })),
+  marks: {
+    token: {
+      toDOM: function toDOM(_ref) {
+        var attrs = _ref.attrs;
+        return createMarkWithStyle(attrs.tokenType);
+      },
+      attrs: {
+        tokenType: {}
+      }
+    },
+    cursor: {
+      toDOM: function toDOM() {
+        return document.createElement('span');
+      }
+    }
+  }
+});
+var domParser = DOMParser.fromSchema(JQLEditorSchema);
+
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer but
+ * preserves consecutive empty block nodes.
+ */
+export var clipboardTextSerializer = function clipboardTextSerializer(slice) {
+  return getFragmentText(slice.content, 0, slice.content.size);
+};
+
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextParser but
+ * preserves consecutive empty lines.
+ */
+export var clipboardTextParser = function clipboardTextParser(text, $context) {
+  var dom = document.createElement('div');
+  // Split each line of text and wrap each in a p tag.
+  splitTextByNewLine(text).forEach(function (block) {
+    dom.appendChild(document.createElement('p')).textContent = block;
+  });
+  return domParser.parseSlice(dom, {
+    context: $context,
+    preserveWhitespace: true
+  });
+};
+export var defaultEditorState = EditorState.create({
+  schema: JQLEditorSchema
+});
+
+// @types/prosemirror-commands@1.0.1 does not export Command and Keymap types
+// TODO: update to Command<JQLEditorSchemaType> and Keymap<JQLEditorSchemaType> if types are bumped to a newer version
+export var configurePlugins = function configurePlugins(editorState, onSearchCommand, intlRef, mainId, portalActions, enableRichInlineNodes) {
+  return editorState.reconfigure({
+    plugins: [history(),
+    // Other plugins rely on having AST as part of the state during a transaction, this plugin should be kept first
+    jqlAstPlugin(intlRef), jqlSyntaxHighlightingPlugin()].concat(_toConsumableArray(portalActions !== undefined ? [autocompletePlugin(portalActions, enableRichInlineNodes)].concat(_toConsumableArray(enableRichInlineNodes ? [richInlineNodesPlugin(portalActions)] : [])) : []), [validationTooltipPlugin(mainId),
+    // Keeping these at the bottom allows plugins to define custom key bindings to override default behavior
+    keymap({
+      'Mod-z': undo,
+      'Mod-Shift-z': redo,
+      'Mod-y': redo,
+      // Mimic default Enter behavior in PM's base keymap, allowing to insert new lines even when autocomplete is open
+      'Shift-Enter': baseKeymap.Enter
+    })], _toConsumableArray(!onSearchCommand ? [] : [keymapNoRepeat({
+      'Mod-Enter': onSearchCommand,
+      Enter: onSearchCommand
+    })]), [keymap(baseKeymap)])
+  });
+};
+var noopCommand = function noopCommand() {
+  return true;
+};
+function keymapNoRepeat(bindings) {
+  var handler = keydownHandler(bindings);
+  var proxyBindings = mapValues(bindings, function () {
+    return noopCommand;
+  });
+  var proxyHandler = keydownHandler(proxyBindings);
+  return new Plugin({
+    props: {
+      handleKeyDown: function handleKeyDown(view, event) {
+        if (event.repeat) {
+          return proxyHandler(view, event);
+        }
+        return handler(view, event);
+      }
+    }
+  });
+}

package/dist/esm/state/analytics/index.js

@@ -0,0 +1,50 @@
+import { Subscription } from 'rxjs/Subscription';
+import { ActionSubject, Action as AnalyticsAction, EventType } from '../../analytics';
+export var ANALYTICS_DEBOUNCE_MS = 2000;
+var AUTOCOMPLETE_ANALYTICS_MEASURE = 'jql-editor-autocomplete';
+export var onStartAutocompleteEvent = function onStartAutocompleteEvent() {
+  return function (_, _ref) {
+    var createAndFireAnalyticsEvent = _ref.createAndFireAnalyticsEvent;
+    performance.clearMeasures(AUTOCOMPLETE_ANALYTICS_MEASURE);
+    performance.clearMarks("".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+    performance.mark("".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+    var timeoutId = null;
+    var promise = new Promise(function (resolve) {
+      // Resolve the promise after a fixed debounce period
+      timeoutId = window.setTimeout(function () {
+        resolve();
+      }, ANALYTICS_DEBOUNCE_MS);
+    });
+
+    // Create a new subscription which will cancel the analytics promise when unsubscribed
+    var analyticsSubscription = new Subscription(function () {
+      timeoutId !== null && window.clearTimeout(timeoutId);
+    });
+    var onStopAutocompleteEvent = function onStopAutocompleteEvent(isSuccess, optionTypes, hasOptions) {
+      performance.measure(AUTOCOMPLETE_ANALYTICS_MEASURE, "".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+      var entry = performance.getEntriesByName(AUTOCOMPLETE_ANALYTICS_MEASURE).pop();
+      var duration = entry === null || entry === void 0 ? void 0 : entry.duration;
+
+      // Fire our analytics event once our autocomplete data is fetched AND our debounced promise is resolved
+      return promise.then(function () {
+        var attributes = {
+          optionTypes: optionTypes.sort(),
+          hasOptions: hasOptions
+        };
+        if (duration !== undefined) {
+          attributes.duration = duration;
+        }
+        createAndFireAnalyticsEvent({
+          action: isSuccess ? AnalyticsAction.RETRIEVED : AnalyticsAction.RETRIEVE_FAILED,
+          actionSubject: ActionSubject.AUTOCOMPLETE_OPTION,
+          eventType: EventType.OPERATIONAL,
+          attributes: attributes
+        });
+      });
+    };
+    return {
+      analyticsSubscription: analyticsSubscription,
+      onStopAutocompleteEvent: onStopAutocompleteEvent
+    };
+  };
+};

package/dist/esm/state/autocomplete/index.js

@@ -0,0 +1,17 @@
+import { map } from 'rxjs/operators/map';
+import { OPERATOR_CHANGED, OPERATOR_EQUALS, OPERATOR_GT, OPERATOR_GT_EQUALS, OPERATOR_IN, OPERATOR_IS, OPERATOR_IS_NOT, OPERATOR_LIKE, OPERATOR_LT, OPERATOR_LT_EQUALS, OPERATOR_NOT_EQUALS, OPERATOR_NOT_IN, OPERATOR_NOT_LIKE, OPERATOR_WAS, OPERATOR_WAS_IN, OPERATOR_WAS_NOT, OPERATOR_WAS_NOT_IN } from '@atlaskit/jql-ast';
+// Opinionated order in which we want to render operators
+export var ORDERED_OPERATORS = [OPERATOR_EQUALS, OPERATOR_NOT_EQUALS, OPERATOR_LIKE, OPERATOR_NOT_LIKE, OPERATOR_LT_EQUALS, OPERATOR_GT_EQUALS, OPERATOR_GT, OPERATOR_LT, OPERATOR_IS, OPERATOR_IS_NOT, OPERATOR_IN, OPERATOR_NOT_IN, OPERATOR_WAS, OPERATOR_WAS_NOT, OPERATOR_WAS_IN, OPERATOR_WAS_NOT_IN, OPERATOR_CHANGED];
+export var sortOperators = function sortOperators(operators$) {
+  return operators$.pipe(map(function (options) {
+    return ORDERED_OPERATORS.reduce(function (result, orderedOperator) {
+      var matchingOption = options.find(function (option) {
+        return orderedOperator.toLowerCase() === option.value.toLowerCase();
+      });
+      if (matchingOption !== undefined) {
+        result.push(matchingOption);
+      }
+      return result;
+    }, []);
+  }));
+};