@atlaskit/jql-editor 4.0.0

package/dist/esm/plugins/autocomplete/types.js

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

package/dist/esm/plugins/autocomplete/view.js

@@ -0,0 +1,120 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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 _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; } }
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { isListOperator } from '@atlaskit/jql-ast';
+import getDocumentPosition from '../common/get-document-position';
+import ReactPluginView from '../common/react-plugin-view';
+import Autocomplete from './components/autocomplete';
+import { AUTOCOMPLETE_PLUGIN_NAME, JQLAutocompletePluginKey } from './constants';
+
+/**
+ * Returns whether an opening parenthesis should be automatically inserted for this option (e.g. after a list operator)
+ */
+var shouldInsertOpeningParenthesis = function shouldInsertOpeningParenthesis(_ref) {
+  var type = _ref.type,
+    context = _ref.context,
+    isListFunction = _ref.isListFunction;
+  if (type === 'value' || type === 'function' || type === 'keyword') {
+    var operator = context === null || context === void 0 ? void 0 : context.operator;
+    if (operator && isListOperator(operator) && !(context !== null && context !== void 0 && context.isList) && !isListFunction) {
+      return true;
+    }
+  }
+  return false;
+};
+var AutocompletePluginView = /*#__PURE__*/function (_ReactPluginView) {
+  _inherits(AutocompletePluginView, _ReactPluginView);
+  var _super = _createSuper(AutocompletePluginView);
+  function AutocompletePluginView(view, keymap, portalActions, enableRichInlineNodes) {
+    var _this;
+    _classCallCheck(this, AutocompletePluginView);
+    _this = _super.call(this, portalActions, AUTOCOMPLETE_PLUGIN_NAME, 'main');
+    _defineProperty(_assertThisInitialized(_this), "getComponent", function () {
+      return Autocomplete;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getInitialComponentProps", function () {
+      return {
+        keymap: _this.keymap,
+        onClick: _this.onReplaceSuggestion
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "onReplaceSuggestion", function (option) {
+      var _option$replacePositi = _slicedToArray(option.replacePosition, 2),
+        from = _option$replacePositi[0],
+        to = _option$replacePositi[1];
+      var transaction = _this.view.state.tr;
+      transaction.setMeta(JQLAutocompletePluginKey, true);
+
+      // Request query hydration if we are inserting a user node
+      if (_this.enableRichInlineNodes && option.type === 'value' && option.valueType === 'user') {
+        transaction.setMeta('hydrate', true);
+      }
+      var documentFrom = getDocumentPosition(transaction.doc, from);
+      var documentTo = getDocumentPosition(transaction.doc, to);
+
+      // Change current selection to the mapped replace position
+      transaction.setSelection(TextSelection.create(transaction.doc, documentTo, documentFrom));
+
+      // Replace selected range with the selected autocomplete option
+      transaction.replaceSelection(_this.getSliceForSuggestion(option));
+      _this.view.focus();
+      _this.view.dispatch(transaction);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getSliceForSuggestion", function (option) {
+      var value = option.value,
+        name = option.name,
+        nameOnRichInlineNode = option.nameOnRichInlineNode,
+        valueType = option.valueType,
+        context = option.context;
+      var nodes = [];
+      if (shouldInsertOpeningParenthesis(option)) {
+        nodes.push(_this.view.state.schema.text('('));
+      }
+      var textContent = _this.view.state.schema.text(value);
+      if (!_this.enableRichInlineNodes) {
+        nodes.push(textContent);
+      } else {
+        switch (valueType) {
+          case 'user':
+            {
+              var attributes = {
+                type: 'user',
+                id: value,
+                name: nameOnRichInlineNode !== null && nameOnRichInlineNode !== void 0 ? nameOnRichInlineNode : name,
+                fieldName: context === null || context === void 0 ? void 0 : context.field
+              };
+              nodes.push(_this.view.state.schema.nodes.user.create(attributes, textContent));
+              break;
+            }
+          default:
+            {
+              nodes.push(textContent);
+              break;
+            }
+        }
+      }
+      return new Slice(Fragment.from(nodes), 0, 0);
+    });
+    _this.view = view;
+    _this.keymap = keymap;
+    _this.enableRichInlineNodes = enableRichInlineNodes;
+    return _this;
+  }
+  _createClass(AutocompletePluginView, [{
+    key: "isSameState",
+    value: function isSameState(state, prevState) {
+      return prevState.doc.eq(state.doc) && prevState.selection.eq(state.selection);
+    }
+  }]);
+  return AutocompletePluginView;
+}(ReactPluginView);
+export { AutocompletePluginView as default };

package/dist/esm/plugins/common/get-document-position/index.js

@@ -0,0 +1,93 @@
+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 { JQLEditorSchema } from '../../../schema';
+
+/**
+ * Accumulator object to represent the current PM document position + text position within a PM node.
+ */
+
+/**
+ * Recursively find the PM node which includes our text position. This method tracks the offset of PM nodes in order
+ * to compute the correct document position according to the rules identified here: https://prosemirror.net/docs/guide/#doc.indexing.
+ *
+ * If for some reason the text position can not be found in the node then the position at which the current node ends
+ * will be returned.
+ *
+ * @param node Node to search
+ * @param parentNodePos Current document and text position within the parent when entering the current node.
+ * @param textPosition Text position to find in the Prosemirror document.
+ */
+var enterNode = function enterNode(node, parentNodePos, textPosition) {
+  var nodePos = _objectSpread({}, parentNodePos);
+  var isDocNode = node.type === JQLEditorSchema.nodes.doc;
+
+  // Enter non-leaf node
+  if (!node.isLeaf && !isDocNode) {
+    nodePos.doc += 1;
+    if (node.isBlock) {
+      if (nodePos.enteredInitialBlock) {
+        // Every time we enter a block node (after the initial block),
+        // we need to increment text position to account for newline char.
+        nodePos.text += 1;
+      }
+      nodePos.enteredInitialBlock = true;
+    }
+
+    // If we've entered a new block and now have a matching node then return the current node position.
+    if (nodePos.text === textPosition) {
+      return nodePos;
+    }
+
+    // If text position matches last position of a node view, return its outer document position
+    if (node.isAtom && textPosition === nodePos.text + node.content.size) {
+      nodePos.doc += node.content.size + 1;
+      nodePos.text += node.content.size;
+      return nodePos;
+    }
+  }
+  if (node.isText) {
+    // If our expected text position lies within the text nodes content, then return the associated document position.
+    if (textPosition >= nodePos.text && textPosition <= nodePos.text + node.nodeSize) {
+      var textOffset = textPosition - nodePos.text;
+      nodePos.doc += textOffset;
+      nodePos.text += textOffset;
+      return nodePos;
+    } else {
+      // Otherwise increment our accumulated document/text position
+      nodePos.doc += node.nodeSize;
+      nodePos.text += node.nodeSize;
+    }
+  }
+  for (var i = 0; i < node.childCount; i++) {
+    nodePos = enterNode(node.child(i), nodePos, textPosition);
+
+    // If we have a matching node after iterating this nodes children then return the current node position.
+    if (nodePos.text === textPosition) {
+      return nodePos;
+    }
+  }
+
+  // Exit non-leaf node
+  if (!node.isLeaf && !isDocNode) {
+    nodePos.doc += 1;
+  }
+  return nodePos;
+};
+
+/**
+ * Return the Prosemirror document position that maps to the provided plain text position.
+ *
+ * @param doc Prosemirror document
+ * @param textPosition Text position to find in the Prosemirror document.
+ */
+var getDocumentPosition = function getDocumentPosition(doc, textPosition) {
+  var currentPos = {
+    doc: 0,
+    text: 0,
+    enteredInitialBlock: false
+  };
+  var matchingNodePos = enterNode(doc, currentPos, textPosition);
+  return matchingNodePos.doc;
+};
+export default getDocumentPosition;

package/dist/esm/plugins/common/plugin-keymap.js

@@ -0,0 +1,43 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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; }
+export var PluginKeymap = /*#__PURE__*/function () {
+  function PluginKeymap() {
+    _classCallCheck(this, PluginKeymap);
+    _defineProperty(this, "keymap", {});
+  }
+  _createClass(PluginKeymap, [{
+    key: "bindKey",
+    value: function bindKey(key, handler) {
+      this.keymap = _objectSpread(_objectSpread({}, this.keymap), {}, _defineProperty({}, key, handler));
+    }
+  }, {
+    key: "bindMultipleKeys",
+    value: function bindMultipleKeys(keys, handler) {
+      var _this = this;
+      keys.forEach(function (key) {
+        _this.keymap = _objectSpread(_objectSpread({}, _this.keymap), {}, _defineProperty({}, key, handler));
+      });
+    }
+  }, {
+    key: "unbindKey",
+    value: function unbindKey(key) {
+      var _this$keymap = this.keymap,
+        keyToUnbind = _this$keymap[key],
+        rest = _objectWithoutProperties(_this$keymap, [key].map(_toPropertyKey));
+      this.keymap = rest;
+    }
+  }, {
+    key: "getKeyBinding",
+    value: function getKeyBinding(key) {
+      return this.keymap[key];
+    }
+  }]);
+  return PluginKeymap;
+}();

package/dist/esm/plugins/common/react-plugin-view.js

@@ -0,0 +1,84 @@
+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 React, { useEffect, useState } from 'react';
+import { Subject } from 'rxjs/Subject';
+/**
+ * Abstract class for Prosemirror plugin views which need to mount a React component. Concrete subclasses must implement
+ * {@link ReactPluginView#getComponent} which specifies the React component to render, along with
+ * {@link ReactPluginView#getInitialComponentProps} which returns any props to pass to the component on initial render.
+ *
+ * After the class is constructed, the caller must invoke {@link ReactPluginView#init} in order to mount the component.
+ *
+ * If there are external changes which the component needs to respond to, {@link ReactPluginView#componentSubject} can
+ * be used to trigger a re-render of the component with updated props. For example:
+ * ```
+ * update = (view: EditorView) => {
+ *   this.componentSubject.next(this.getComponentProps(view));
+ * };
+ *
+ * getComponentProps = (view: EditorView) => {
+ *   // Some logic to get props from the Prosemirror view
+ * }
+ * ```
+ */
+var ReactPluginView = /*#__PURE__*/function () {
+  /**
+   * Construct a Prosemirror plugin view which will render a React component in a portal.
+   *
+   * @param portalActions Provides callback functions which can be invoked to create and destroy a portal.
+   * @param portalKey Unique identifier for the plugin component.
+   * @param containerKey Key representing the HTML container the React component will be portalled into.
+   * @protected
+   */
+  function ReactPluginView(portalActions, portalKey, containerKey) {
+    var _this = this;
+    _classCallCheck(this, ReactPluginView);
+    _defineProperty(this, "componentSubject", new Subject());
+    _defineProperty(this, "init", function () {
+      var Component = _this.getComponent();
+      var PortallingComponent = function PortallingComponent() {
+        var _useState = useState(function () {
+            return _this.getInitialComponentProps();
+          }),
+          _useState2 = _slicedToArray(_useState, 2),
+          state = _useState2[0],
+          setState = _useState2[1];
+        useEffect(function () {
+          // Subscribe to the RxJS subject so concrete subclasses can emit events to re-render the plugin component.
+          var subscription = _this.componentSubject.subscribe(function (updatedProps) {
+            setState(updatedProps);
+          });
+          return function () {
+            return subscription.unsubscribe();
+          };
+        }, []);
+        return /*#__PURE__*/React.createElement(Component, state);
+      };
+
+      // Dispatch onCreatePortal which will allow the handler to create a new portalled React component
+      _this.portalActions.onCreatePortal(_this.portalKey, /*#__PURE__*/React.createElement(PortallingComponent, null), _this.containerKey);
+    });
+    this.portalActions = portalActions;
+    this.portalKey = portalKey;
+    this.containerKey = containerKey;
+  }
+  _createClass(ReactPluginView, [{
+    key: "destroy",
+    value: function destroy() {
+      // Dispatch onDestroyPortal which will allow the handler to remove the portalled React component.
+      this.portalActions.onDestroyPortal(this.portalKey);
+    }
+
+    /**
+     * Return a React component to render for the plugin.
+     */
+
+    /**
+     * Return props to set on the component for initial render.
+     */
+  }]);
+  return ReactPluginView;
+}();
+export { ReactPluginView as default };

package/dist/esm/plugins/index.js

@@ -0,0 +1,5 @@
+export { default as autocompletePlugin } from './autocomplete';
+export { default as jqlAstPlugin } from './jql-ast';
+export { default as jqlSyntaxHighlightingPlugin } from './jql-syntax-highlighting';
+export { default as richInlineNodesPlugin } from './rich-inline-nodes';
+export { default as validationTooltipPlugin } from './validation-tooltip';

package/dist/esm/plugins/jql-ast/JQLEditorErrorStrategy.js

@@ -0,0 +1,212 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _get from "@babel/runtime/helpers/get";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+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; } }
+import { DefaultErrorStrategy } from 'antlr4ts';
+import padStart from 'lodash/padStart';
+import { normaliseJqlString } from '@atlaskit/jql-ast';
+import { JQLAutocomplete } from '@atlaskit/jql-autocomplete';
+import { JQLLexer, JQLParser } from '@atlaskit/jql-parser';
+import { ignoredTokens, preferredRules } from './constants';
+import { handleCustomFieldRuleError } from './error-handlers/CustomFieldRuleErrorHandler';
+import { handleExpectedTokensError } from './error-handlers/ExpectedTokensErrorHandler';
+import { handleFieldPropertyIdRuleError } from './error-handlers/FieldPropertyIdErrorHandler';
+import { handleFieldRuleError } from './error-handlers/FieldRuleErrorHandler';
+import { handleFunctionArgumentRuleError } from './error-handlers/FunctionArgumentRuleErrorHandler';
+import { handleOperandRuleError } from './error-handlers/OperandRuleErrorHandler';
+import { handleOperatorRuleError } from './error-handlers/OperatorRuleErrorHandler';
+import { errorMessages } from './messages';
+import { getExpectedTokensFromParserOrException } from './utils';
+var isEscape = function isEscape(char) {
+  return char === '\\';
+};
+export var getPrintableChar = function getPrintableChar(char) {
+  var hex = char.charCodeAt(0).toString(16).toUpperCase();
+  return "U+".concat(padStart(hex, 4, '0'));
+};
+export var getJavaCodeFromChar = function getJavaCodeFromChar(char) {
+  var hex = char.charCodeAt(0).toString(16);
+  return "\\u".concat(padStart(hex, 4, '0'));
+};
+var JQLEditorErrorStrategy = /*#__PURE__*/function (_DefaultErrorStrategy) {
+  _inherits(JQLEditorErrorStrategy, _DefaultErrorStrategy);
+  var _super = _createSuper(JQLEditorErrorStrategy);
+  function JQLEditorErrorStrategy(intlRef) {
+    var _this;
+    _classCallCheck(this, JQLEditorErrorStrategy);
+    _this = _super.call(this);
+    _this.intlRef = intlRef;
+    return _this;
+  }
+  _createClass(JQLEditorErrorStrategy, [{
+    key: "reportInputMismatch",
+    value: function reportInputMismatch(recognizer, exception) {
+      this.handleSyntaxError(recognizer, recognizer.currentToken, exception);
+    }
+  }, {
+    key: "reportUnwantedToken",
+    value: function reportUnwantedToken(recognizer) {
+      if (this.inErrorRecoveryMode(recognizer)) {
+        return;
+      }
+      this.beginErrorCondition(recognizer);
+      this.handleSyntaxError(recognizer, recognizer.currentToken);
+    }
+  }, {
+    key: "reportMissingToken",
+    value: function reportMissingToken(recognizer) {
+      if (this.inErrorRecoveryMode(recognizer)) {
+        return;
+      }
+      this.beginErrorCondition(recognizer);
+
+      // This is called when single token insertion is a viable recovery strategy for the error. In this case we can
+      // use expected tokens from the parser to display an error to the user. If there are no viable tokens to show then
+      // we should fallback to syntax error handling.
+      if (getExpectedTokensFromParserOrException(recognizer).length > 0) {
+        var message = handleExpectedTokensError(recognizer, recognizer.currentToken,
+        // We want to derive expectedTokens from the parser state
+        [], this.intlRef.current);
+        recognizer.notifyErrorListeners(message, recognizer.currentToken, undefined);
+      } else {
+        this.handleSyntaxError(recognizer, recognizer.currentToken);
+      }
+    }
+  }, {
+    key: "reportNoViableAlternative",
+    value: function reportNoViableAlternative(recognizer, exception) {
+      var _exception$getOffendi;
+      // There are some cases, like "status was", where parser is unable to provide viable alternatives for current
+      // token, but autocomplete engine is still able to provide meaningful suggestions at offending token index
+      var currentToken = (_exception$getOffendi = exception === null || exception === void 0 ? void 0 : exception.getOffendingToken()) !== null && _exception$getOffendi !== void 0 ? _exception$getOffendi : recognizer.currentToken;
+      this.handleSyntaxError(recognizer, currentToken, exception);
+    }
+  }, {
+    key: "reportFailedPredicate",
+    value: function reportFailedPredicate(recognizer, e) {
+      // TODO: Don't know how to produce this error. Monitor if this happens and defer to default implementation
+      _get(_getPrototypeOf(JQLEditorErrorStrategy.prototype), "reportFailedPredicate", this).call(this, recognizer, e);
+    }
+  }, {
+    key: "handleSyntaxError",
+    value: function handleSyntaxError(recognizer, currentToken, exception) {
+      var message;
+      switch (currentToken.type) {
+        /*
+         * This is called when ANTLR finds a character that the grammar does not recognise. The grammar lexer uses
+         * a DFA to decide if a character is in error or not. This can mean that legal characters come as an error
+         * because they do not form a valid token. Because of this we have to do some extra checks here.
+         */
+        case JQLLexer.ERRORCHAR:
+        case JQLLexer.INVALID_QUOTE_STRING:
+        case JQLLexer.INVALID_SQUOTE_STRING:
+          {
+            var currentText = currentToken.text;
+
+            // These tokens are returned when an illegal character appears at the end of a quote string, but the token
+            // includes the entire quoted text. We take the last character from our text as that's the offending token.
+            if (currentToken.type === JQLLexer.INVALID_QUOTE_STRING || currentToken.type === JQLLexer.INVALID_SQUOTE_STRING) {
+              var _currentText;
+              currentText = (_currentText = currentText) === null || _currentText === void 0 ? void 0 : _currentText.slice(-1);
+            }
+
+            // This can happen (e.g. comment ~ \)
+            if (isEscape(currentText)) {
+              var nextToken = recognizer.inputStream.get(currentToken.tokenIndex + 1);
+              if (nextToken.type === JQLLexer.MATCHWS || nextToken.type === JQLLexer.EOF) {
+                message = this.intlRef.current.formatMessage(errorMessages.illegalEscapeBlank);
+              } else {
+                var _currentText2, _nextToken$text;
+                // Show the escaped character sequence in the message
+                var received = "".concat((_currentText2 = currentText) !== null && _currentText2 !== void 0 ? _currentText2 : '').concat((_nextToken$text = nextToken.text) !== null && _nextToken$text !== void 0 ? _nextToken$text : '');
+                message = this.intlRef.current.formatMessage(errorMessages.illegalEscape, {
+                  received: received
+                });
+              }
+            } else {
+              var _currentText3, _currentText4;
+              message = this.intlRef.current.formatMessage(errorMessages.illegalChar, {
+                char: getPrintableChar((_currentText3 = currentText) !== null && _currentText3 !== void 0 ? _currentText3 : ''),
+                escapedChar: getJavaCodeFromChar((_currentText4 = currentText) !== null && _currentText4 !== void 0 ? _currentText4 : '')
+              });
+            }
+            break;
+          }
+        // Special tokens that get created every time there is an unfinished string (i.e. without matching closing quote)
+        case JQLLexer.UNCLOSED_QUOTE_STRING:
+        case JQLLexer.UNCLOSED_SQUOTE_STRING:
+          {
+            var _currentToken$text;
+            var _received = normaliseJqlString((_currentToken$text = currentToken.text) !== null && _currentToken$text !== void 0 ? _currentToken$text : '');
+            if (_received === '') {
+              message = this.intlRef.current.formatMessage(errorMessages.unfinishedStringBlank);
+            } else {
+              message = this.intlRef.current.formatMessage(errorMessages.unfinishedString, {
+                received: _received
+              });
+            }
+            break;
+          }
+        case JQLLexer.RESERVED_WORD:
+          {
+            message = this.intlRef.current.formatMessage(errorMessages.reservedWord, {
+              word: currentToken.text
+            });
+            break;
+          }
+        case JQLLexer.ERROR_RESERVED:
+          {
+            var _currentToken$text2;
+            message = this.intlRef.current.formatMessage(errorMessages.reservedChar, {
+              char: currentToken.text,
+              escapedChar: getJavaCodeFromChar((_currentToken$text2 = currentToken.text) !== null && _currentToken$text2 !== void 0 ? _currentToken$text2 : '')
+            });
+            break;
+          }
+        default:
+          {
+            var autocomplete = JQLAutocomplete.fromParser(recognizer, ignoredTokens, preferredRules, new Set());
+            var _autocomplete$getJQLS = autocomplete.getJQLSuggestionsForTokenIndex(currentToken.tokenIndex),
+              tokens = _autocomplete$getJQLS.tokens,
+              rules = _autocomplete$getJQLS.rules;
+            if (rules.value || rules.list ||
+            // Restrict function rules to only be shown if we are currently INSIDE a function rule. Otherwise this error
+            // message would be shown for incomplete tokens following an operand, e.g. `status = open ord`.
+            rules.function && recognizer.context.ruleIndex === JQLParser.RULE_jqlFunction) {
+              message = handleOperandRuleError(recognizer, currentToken, tokens.values, rules, this.intlRef.current, exception);
+            } else if (tokens.values.includes('EMPTY')) {
+              message = handleExpectedTokensError(recognizer, currentToken, tokens.values, this.intlRef.current, exception);
+            } else if (rules.operator) {
+              message = handleOperatorRuleError(currentToken, this.intlRef.current);
+            } else if (rules.field) {
+              message = handleFieldRuleError(currentToken, this.intlRef.current);
+            } else if (rules.customField) {
+              message = handleCustomFieldRuleError(this.intlRef.current);
+            }
+            // Restrict field property rules to only be shown if we are currently INSIDE a field property. Otherwise this
+            // error message would be shown for incomplete tokens following a field, e.g. `ORDER BY issuetype as`.
+            else if (rules.fieldProperty && recognizer.context.ruleIndex === JQLParser.RULE_jqlFieldProperty) {
+              // Shows the correct message when a field property rule hasn't been completed, e.g. `issuetype[abc!`
+              message = handleExpectedTokensError(recognizer, currentToken,
+              // We want to derive expectedTokens from the exception/parser state
+              [], this.intlRef.current, exception);
+            } else if (rules.fieldPropertyId) {
+              message = handleFieldPropertyIdRuleError(currentToken, this.intlRef.current);
+            } else if (rules.functionArgument) {
+              message = handleFunctionArgumentRuleError(currentToken, this.intlRef.current);
+            } else {
+              message = handleExpectedTokensError(recognizer, currentToken, tokens.values, this.intlRef.current, exception);
+            }
+            break;
+          }
+      }
+      recognizer.notifyErrorListeners(message, currentToken, undefined);
+    }
+  }]);
+  return JQLEditorErrorStrategy;
+}(DefaultErrorStrategy);
+export { JQLEditorErrorStrategy as default };

package/dist/esm/plugins/jql-ast/constants.js

@@ -0,0 +1,9 @@
+import { JQLLexer, JQLParser } from '@atlaskit/jql-parser';
+export var ignoredTokens = new Set([JQLLexer.EOF, JQLLexer.LPAREN, JQLLexer.LBRACKET, JQLLexer.STRING, JQLLexer.QUOTE_STRING, JQLLexer.SQUOTE_STRING, JQLLexer.POSNUMBER, JQLLexer.NEGNUMBER, JQLLexer.BANG, JQLLexer.CUSTOMFIELD]);
+export var preferredRules = new Set([JQLParser.RULE_jqlField, JQLParser.RULE_jqlFieldProperty, JQLParser.RULE_jqlEqualsOperator, JQLParser.RULE_jqlLikeOperator, JQLParser.RULE_jqlComparisonOperator, JQLParser.RULE_jqlInOperator, JQLParser.RULE_jqlIsOperator, JQLParser.RULE_jqlWasOperator, JQLParser.RULE_jqlWasInOperator, JQLParser.RULE_jqlChangedOperator, JQLParser.RULE_jqlValue, JQLParser.RULE_jqlListStart, JQLParser.RULE_jqlFunction, JQLParser.RULE_jqlCustomField,
+// Produces rules for fieldPropertyId, fieldPropertyArgument and functionArgument
+JQLParser.RULE_jqlArgument]);
+
+// The following tokens are returned by autocomplete but they are considered "lower" priority suggestions. We only want
+// to show these if there are no other viable tokens to suggest.
+export var lowPriorityTokens = [JQLLexer.RPAREN, JQLLexer.RBRACKET, JQLLexer.COMMA];

package/dist/esm/plugins/jql-ast/error-handlers/CustomFieldRuleErrorHandler.js

@@ -0,0 +1,8 @@
+import { errorMessages } from '../messages';
+
+/**
+ * Show the appropriate error message when parsing JQL fails and a custom field rule was expected.
+ */
+export var handleCustomFieldRuleError = function handleCustomFieldRuleError(intl) {
+  return intl.formatMessage(errorMessages.expectingCustomFieldId);
+};

package/dist/esm/plugins/jql-ast/error-handlers/ExpectedTokensErrorHandler.js

@@ -0,0 +1,57 @@
+import { JQLLexer } from '@atlaskit/jql-parser';
+import { commonMessages } from '../../../common/messages';
+import { lowPriorityTokens } from '../constants';
+import { errorMessages } from '../messages';
+import { getExpectedTokensFromParserOrException, getTokenDisplayNames } from '../utils';
+
+/**
+ * Show the appropriate error message when parsing JQL fails and 0 or more tokens were expected.
+ *
+ * If no `expectedTokens` were provided then we'll attempt to find viable tokens to suggest from the provided
+ * exception/parser state.
+ */
+export var handleExpectedTokensError = function handleExpectedTokensError(recognizer, currentToken, expectedTokens, intl, exception) {
+  // If there are no expected autocomplete tokens, then attempt to find viable tokens from the exception/parser.
+  if (expectedTokens.length === 0) {
+    expectedTokens = getTokenDisplayNames(recognizer, getExpectedTokensFromParserOrException(recognizer, exception));
+  }
+  var lowPriorityTokenNames = getTokenDisplayNames(recognizer, lowPriorityTokens);
+
+  // Only include tokens that are NOT low priority
+  var highPriorityTokens = expectedTokens.filter(function (tokenType) {
+    return !lowPriorityTokenNames.includes(tokenType);
+  });
+
+  // If we have any tokens that are high priority then we want to show them (without low priority suggestions).
+  if (highPriorityTokens.length > 0) {
+    expectedTokens = highPriorityTokens;
+  }
+  var isEOF = currentToken.type === JQLLexer.EOF;
+  if (expectedTokens.length > 1) {
+    var firstExpectedTokens = expectedTokens.slice(0, -1)
+    // Need to wrap tokens in single quotes ourselves as we cannot do it in the message descriptor
+    .map(function (token) {
+      return "'".concat(token, "'");
+    }).join(', ');
+    var lastExpectedToken = expectedTokens[expectedTokens.length - 1];
+    return isEOF ? intl.formatMessage(errorMessages.expectingMultipleTokensBeforeEOF, {
+      firstExpectedTokens: firstExpectedTokens,
+      lastExpectedToken: lastExpectedToken
+    }) : intl.formatMessage(errorMessages.expectingMultipleTokensButReceived, {
+      firstExpectedTokens: firstExpectedTokens,
+      lastExpectedToken: lastExpectedToken,
+      received: currentToken.text
+    });
+  } else if (expectedTokens.length === 1) {
+    return isEOF ? intl.formatMessage(errorMessages.expectingTokenBeforeEOF, {
+      expectedToken: expectedTokens[0]
+    }) : intl.formatMessage(errorMessages.expectingTokenButReceived, {
+      expectedToken: expectedTokens[0],
+      received: currentToken.text
+    });
+  } else {
+    return isEOF ? intl.formatMessage(commonMessages.unknownError) : intl.formatMessage(errorMessages.unknownErrorAtToken, {
+      received: currentToken.text
+    });
+  }
+};

package/dist/esm/plugins/jql-ast/error-handlers/FieldPropertyIdErrorHandler.js

@@ -0,0 +1,12 @@
+import { JQLLexer } from '@atlaskit/jql-parser';
+import { errorMessages } from '../messages';
+
+/**
+ * Show the appropriate error message when parsing JQL fails and a field property ID rule was expected.
+ */
+export var handleFieldPropertyIdRuleError = function handleFieldPropertyIdRuleError(currentToken, intl) {
+  var isEOF = currentToken.type === JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(errorMessages.expectingFieldPropertyIdBeforeEOF) : intl.formatMessage(errorMessages.expectingFieldPropertyIdButReceived, {
+    received: currentToken.text
+  });
+};