@atlaskit/jql-editor 4.0.0

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

@@ -0,0 +1,218 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPrintableChar = exports.getJavaCodeFromChar = exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _antlr4ts = require("antlr4ts");
+var _padStart = _interopRequireDefault(require("lodash/padStart"));
+var _jqlAst = require("@atlaskit/jql-ast");
+var _jqlAutocomplete = require("@atlaskit/jql-autocomplete");
+var _jqlParser = require("@atlaskit/jql-parser");
+var _constants = require("./constants");
+var _CustomFieldRuleErrorHandler = require("./error-handlers/CustomFieldRuleErrorHandler");
+var _ExpectedTokensErrorHandler = require("./error-handlers/ExpectedTokensErrorHandler");
+var _FieldPropertyIdErrorHandler = require("./error-handlers/FieldPropertyIdErrorHandler");
+var _FieldRuleErrorHandler = require("./error-handlers/FieldRuleErrorHandler");
+var _FunctionArgumentRuleErrorHandler = require("./error-handlers/FunctionArgumentRuleErrorHandler");
+var _OperandRuleErrorHandler = require("./error-handlers/OperandRuleErrorHandler");
+var _OperatorRuleErrorHandler = require("./error-handlers/OperatorRuleErrorHandler");
+var _messages = require("./messages");
+var _utils = require("./utils");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+var isEscape = function isEscape(char) {
+  return char === '\\';
+};
+var getPrintableChar = exports.getPrintableChar = function getPrintableChar(char) {
+  var hex = char.charCodeAt(0).toString(16).toUpperCase();
+  return "U+".concat((0, _padStart.default)(hex, 4, '0'));
+};
+var getJavaCodeFromChar = exports.getJavaCodeFromChar = function getJavaCodeFromChar(char) {
+  var hex = char.charCodeAt(0).toString(16);
+  return "\\u".concat((0, _padStart.default)(hex, 4, '0'));
+};
+var JQLEditorErrorStrategy = exports.default = /*#__PURE__*/function (_DefaultErrorStrategy) {
+  (0, _inherits2.default)(JQLEditorErrorStrategy, _DefaultErrorStrategy);
+  var _super = _createSuper(JQLEditorErrorStrategy);
+  function JQLEditorErrorStrategy(intlRef) {
+    var _this;
+    (0, _classCallCheck2.default)(this, JQLEditorErrorStrategy);
+    _this = _super.call(this);
+    _this.intlRef = intlRef;
+    return _this;
+  }
+  (0, _createClass2.default)(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 ((0, _utils.getExpectedTokensFromParserOrException)(recognizer).length > 0) {
+        var message = (0, _ExpectedTokensErrorHandler.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
+      (0, _get2.default)((0, _getPrototypeOf2.default)(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 _jqlParser.JQLLexer.ERRORCHAR:
+        case _jqlParser.JQLLexer.INVALID_QUOTE_STRING:
+        case _jqlParser.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 === _jqlParser.JQLLexer.INVALID_QUOTE_STRING || currentToken.type === _jqlParser.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 === _jqlParser.JQLLexer.MATCHWS || nextToken.type === _jqlParser.JQLLexer.EOF) {
+                message = this.intlRef.current.formatMessage(_messages.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(_messages.errorMessages.illegalEscape, {
+                  received: received
+                });
+              }
+            } else {
+              var _currentText3, _currentText4;
+              message = this.intlRef.current.formatMessage(_messages.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 _jqlParser.JQLLexer.UNCLOSED_QUOTE_STRING:
+        case _jqlParser.JQLLexer.UNCLOSED_SQUOTE_STRING:
+          {
+            var _currentToken$text;
+            var _received = (0, _jqlAst.normaliseJqlString)((_currentToken$text = currentToken.text) !== null && _currentToken$text !== void 0 ? _currentToken$text : '');
+            if (_received === '') {
+              message = this.intlRef.current.formatMessage(_messages.errorMessages.unfinishedStringBlank);
+            } else {
+              message = this.intlRef.current.formatMessage(_messages.errorMessages.unfinishedString, {
+                received: _received
+              });
+            }
+            break;
+          }
+        case _jqlParser.JQLLexer.RESERVED_WORD:
+          {
+            message = this.intlRef.current.formatMessage(_messages.errorMessages.reservedWord, {
+              word: currentToken.text
+            });
+            break;
+          }
+        case _jqlParser.JQLLexer.ERROR_RESERVED:
+          {
+            var _currentToken$text2;
+            message = this.intlRef.current.formatMessage(_messages.errorMessages.reservedChar, {
+              char: currentToken.text,
+              escapedChar: getJavaCodeFromChar((_currentToken$text2 = currentToken.text) !== null && _currentToken$text2 !== void 0 ? _currentToken$text2 : '')
+            });
+            break;
+          }
+        default:
+          {
+            var autocomplete = _jqlAutocomplete.JQLAutocomplete.fromParser(recognizer, _constants.ignoredTokens, _constants.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.JQLParser.RULE_jqlFunction) {
+              message = (0, _OperandRuleErrorHandler.handleOperandRuleError)(recognizer, currentToken, tokens.values, rules, this.intlRef.current, exception);
+            } else if (tokens.values.includes('EMPTY')) {
+              message = (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken, tokens.values, this.intlRef.current, exception);
+            } else if (rules.operator) {
+              message = (0, _OperatorRuleErrorHandler.handleOperatorRuleError)(currentToken, this.intlRef.current);
+            } else if (rules.field) {
+              message = (0, _FieldRuleErrorHandler.handleFieldRuleError)(currentToken, this.intlRef.current);
+            } else if (rules.customField) {
+              message = (0, _CustomFieldRuleErrorHandler.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.JQLParser.RULE_jqlFieldProperty) {
+              // Shows the correct message when a field property rule hasn't been completed, e.g. `issuetype[abc!`
+              message = (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken,
+              // We want to derive expectedTokens from the exception/parser state
+              [], this.intlRef.current, exception);
+            } else if (rules.fieldPropertyId) {
+              message = (0, _FieldPropertyIdErrorHandler.handleFieldPropertyIdRuleError)(currentToken, this.intlRef.current);
+            } else if (rules.functionArgument) {
+              message = (0, _FunctionArgumentRuleErrorHandler.handleFunctionArgumentRuleError)(currentToken, this.intlRef.current);
+            } else {
+              message = (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken, tokens.values, this.intlRef.current, exception);
+            }
+            break;
+          }
+      }
+      recognizer.notifyErrorListeners(message, currentToken, undefined);
+    }
+  }]);
+  return JQLEditorErrorStrategy;
+}(_antlr4ts.DefaultErrorStrategy);

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.preferredRules = exports.lowPriorityTokens = exports.ignoredTokens = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var ignoredTokens = exports.ignoredTokens = new Set([_jqlParser.JQLLexer.EOF, _jqlParser.JQLLexer.LPAREN, _jqlParser.JQLLexer.LBRACKET, _jqlParser.JQLLexer.STRING, _jqlParser.JQLLexer.QUOTE_STRING, _jqlParser.JQLLexer.SQUOTE_STRING, _jqlParser.JQLLexer.POSNUMBER, _jqlParser.JQLLexer.NEGNUMBER, _jqlParser.JQLLexer.BANG, _jqlParser.JQLLexer.CUSTOMFIELD]);
+var preferredRules = exports.preferredRules = new Set([_jqlParser.JQLParser.RULE_jqlField, _jqlParser.JQLParser.RULE_jqlFieldProperty, _jqlParser.JQLParser.RULE_jqlEqualsOperator, _jqlParser.JQLParser.RULE_jqlLikeOperator, _jqlParser.JQLParser.RULE_jqlComparisonOperator, _jqlParser.JQLParser.RULE_jqlInOperator, _jqlParser.JQLParser.RULE_jqlIsOperator, _jqlParser.JQLParser.RULE_jqlWasOperator, _jqlParser.JQLParser.RULE_jqlWasInOperator, _jqlParser.JQLParser.RULE_jqlChangedOperator, _jqlParser.JQLParser.RULE_jqlValue, _jqlParser.JQLParser.RULE_jqlListStart, _jqlParser.JQLParser.RULE_jqlFunction, _jqlParser.JQLParser.RULE_jqlCustomField,
+// Produces rules for fieldPropertyId, fieldPropertyArgument and functionArgument
+_jqlParser.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.
+var lowPriorityTokens = exports.lowPriorityTokens = [_jqlParser.JQLLexer.RPAREN, _jqlParser.JQLLexer.RBRACKET, _jqlParser.JQLLexer.COMMA];

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleCustomFieldRuleError = void 0;
+var _messages = require("../messages");
+/**
+ * Show the appropriate error message when parsing JQL fails and a custom field rule was expected.
+ */
+var handleCustomFieldRuleError = exports.handleCustomFieldRuleError = function handleCustomFieldRuleError(intl) {
+  return intl.formatMessage(_messages.errorMessages.expectingCustomFieldId);
+};

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

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleExpectedTokensError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../../../common/messages");
+var _constants = require("../constants");
+var _messages2 = require("../messages");
+var _utils = require("../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.
+ */
+var handleExpectedTokensError = exports.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 = (0, _utils.getTokenDisplayNames)(recognizer, (0, _utils.getExpectedTokensFromParserOrException)(recognizer, exception));
+  }
+  var lowPriorityTokenNames = (0, _utils.getTokenDisplayNames)(recognizer, _constants.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 === _jqlParser.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(_messages2.errorMessages.expectingMultipleTokensBeforeEOF, {
+      firstExpectedTokens: firstExpectedTokens,
+      lastExpectedToken: lastExpectedToken
+    }) : intl.formatMessage(_messages2.errorMessages.expectingMultipleTokensButReceived, {
+      firstExpectedTokens: firstExpectedTokens,
+      lastExpectedToken: lastExpectedToken,
+      received: currentToken.text
+    });
+  } else if (expectedTokens.length === 1) {
+    return isEOF ? intl.formatMessage(_messages2.errorMessages.expectingTokenBeforeEOF, {
+      expectedToken: expectedTokens[0]
+    }) : intl.formatMessage(_messages2.errorMessages.expectingTokenButReceived, {
+      expectedToken: expectedTokens[0],
+      received: currentToken.text
+    });
+  } else {
+    return isEOF ? intl.formatMessage(_messages.commonMessages.unknownError) : intl.formatMessage(_messages2.errorMessages.unknownErrorAtToken, {
+      received: currentToken.text
+    });
+  }
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleFieldPropertyIdRuleError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../messages");
+/**
+ * Show the appropriate error message when parsing JQL fails and a field property ID rule was expected.
+ */
+var handleFieldPropertyIdRuleError = exports.handleFieldPropertyIdRuleError = function handleFieldPropertyIdRuleError(currentToken, intl) {
+  var isEOF = currentToken.type === _jqlParser.JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(_messages.errorMessages.expectingFieldPropertyIdBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingFieldPropertyIdButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/cjs/plugins/jql-ast/error-handlers/FieldRuleErrorHandler.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleFieldRuleError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../messages");
+/**
+ * Show the appropriate error message when parsing JQL fails and a field rule was expected.
+ */
+var handleFieldRuleError = exports.handleFieldRuleError = function handleFieldRuleError(currentToken, intl) {
+  var isEOF = currentToken.type === _jqlParser.JQLLexer.EOF;
+  if (currentToken.type === _jqlParser.JQLLexer.LBRACKET) {
+    return intl.formatMessage(_messages.errorMessages.expectingCFButReceived);
+  }
+  return isEOF ? intl.formatMessage(_messages.errorMessages.expectingFieldBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingFieldButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/cjs/plugins/jql-ast/error-handlers/FunctionArgumentRuleErrorHandler.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleFunctionArgumentRuleError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../messages");
+/**
+ * Show the appropriate error message when parsing JQL fails and a function argument rule was expected.
+ */
+var handleFunctionArgumentRuleError = exports.handleFunctionArgumentRuleError = function handleFunctionArgumentRuleError(currentToken, intl) {
+  var isEOF = currentToken.type === _jqlParser.JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(_messages.errorMessages.expectingFunctionArgBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingFunctionArgButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/cjs/plugins/jql-ast/error-handlers/OperandRuleErrorHandler.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleOperandRuleError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../messages");
+var _utils = require("../utils");
+var _ExpectedTokensErrorHandler = require("./ExpectedTokensErrorHandler");
+/**
+ * Show the appropriate error message when parsing JQL fails and an operand rule was expected.
+ */
+var handleOperandRuleError = exports.handleOperandRuleError = function handleOperandRuleError(recognizer, currentToken, expectedTokens, rules, intl, exception) {
+  // If there are no expected autocomplete tokens, then attempt to find viable tokens from the exception/parser.
+  if (expectedTokens.length === 0) {
+    expectedTokens = (0, _utils.getTokenDisplayNames)(recognizer, (0, _utils.getExpectedTokensFromParserOrException)(recognizer, exception));
+  }
+  var isEOF = currentToken.type === _jqlParser.JQLLexer.EOF;
+  if (rules.value && rules.list && rules.function) {
+    return isEOF ? intl.formatMessage(_messages.errorMessages.expectingOperandBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingOperandButReceived, {
+      received: currentToken.text
+    });
+  }
+  if (rules.value && rules.function) {
+    return isEOF ? intl.formatMessage(_messages.errorMessages.expectingValueOrFunctionBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingValueOrFunctionButReceived, {
+      received: currentToken.text
+    });
+  }
+  if (rules.list && rules.function) {
+    // Lists and functions are the only operands that contain structural tokens (i.e. LPAREN, RPAREN and COMMA).
+    // So, if there are specific expected tokens, we prioritize those over generic rule messages.
+    if (expectedTokens.length) {
+      return (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(_messages.errorMessages.expectingListOrFunctionBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingListOrFunctionButReceived, {
+      received: currentToken.text
+    });
+  }
+
+  // Value or list combination is not possible with current grammar definition
+
+  if (rules.function) {
+    // Lists and functions are the only operands that contain structural tokens (i.e. LPAREN, RPAREN and COMMA).
+    // So, if there are specific expected tokens, we prioritize those over generic rule messages.
+    if (expectedTokens.length) {
+      return (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(_messages.errorMessages.expectingFunctionBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingFunctionButReceived, {
+      received: currentToken.text
+    });
+  }
+  if (rules.list) {
+    // Lists and functions are the only operands that contain structural tokens (i.e. LPAREN, RPAREN and COMMA).
+    // So, if there are specific expected tokens, we prioritize those over generic rule messages.
+    if (expectedTokens.length) {
+      return (0, _ExpectedTokensErrorHandler.handleExpectedTokensError)(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(_messages.errorMessages.expectingListBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingListButReceived, {
+      received: currentToken.text
+    });
+  }
+  return isEOF ? intl.formatMessage(_messages.errorMessages.expectingValueBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingValueButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/cjs/plugins/jql-ast/error-handlers/OperatorRuleErrorHandler.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleOperatorRuleError = void 0;
+var _jqlParser = require("@atlaskit/jql-parser");
+var _messages = require("../messages");
+// TODO: Figure out if we can show a message without hardcoded operators
+/**
+ * Show the appropriate error message when parsing JQL fails and an operator rule was expected.
+ */
+var handleOperatorRuleError = exports.handleOperatorRuleError = function handleOperatorRuleError(currentToken, intl) {
+  var isEOF = currentToken.type === _jqlParser.JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(_messages.errorMessages.expectingOperatorBeforeEOF) : intl.formatMessage(_messages.errorMessages.expectingOperatorButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/cjs/plugins/jql-ast/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getJastFromState = exports.default = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _jqlAst = require("@atlaskit/jql-ast");
+var _documentText = require("../../utils/document-text");
+var _JQLEditorErrorStrategy = _interopRequireDefault(require("./JQLEditorErrorStrategy"));
+var JQLAstPluginKey = new _state.PluginKey('jql-ast-plugin');
+var getJastFromState = exports.getJastFromState = function getJastFromState(state) {
+  var jast = JQLAstPluginKey.getState(state);
+  // This should never happen as the JQLAstPlugin will always be configured but we'll handle this case anyway to keep TS happy.
+  if (jast == null) {
+    // eslint-disable-next-line no-console
+    console.error('Unable to get state from the JQLAstPlugin as it has not been configured.');
+    return {
+      query: undefined,
+      represents: '',
+      errors: []
+    };
+  }
+  return jast;
+};
+var jqlAstPlugin = function jqlAstPlugin(intlRef) {
+  var jastBuilder = new _jqlAst.JastBuilder().setErrorHandler(new _JQLEditorErrorStrategy.default(intlRef));
+  return new _state.Plugin({
+    key: JQLAstPluginKey,
+    state: {
+      init: function init(_, _ref) {
+        var doc = _ref.doc;
+        return jastBuilder.build((0, _documentText.getNodeText)(doc, 0, doc.content.size));
+      },
+      // @ts-ignore
+      apply: function apply(tr, value, oldState) {
+        var text = (0, _documentText.getNodeText)(tr.doc, 0, tr.doc.content.size);
+        var oldText = (0, _documentText.getNodeText)(oldState.doc, 0, oldState.doc.content.size);
+        // Only update the AST if textContent has changed
+        return text !== oldText ? jastBuilder.build(text) : value;
+      }
+    }
+  });
+};
+var _default = exports.default = jqlAstPlugin;