@atlaskit/jql-editor 4.0.0

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

@@ -0,0 +1,183 @@
+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';
+const isEscape = char => char === '\\';
+export const getPrintableChar = char => {
+  const hex = char.charCodeAt(0).toString(16).toUpperCase();
+  return `U+${padStart(hex, 4, '0')}`;
+};
+export const getJavaCodeFromChar = char => {
+  const hex = char.charCodeAt(0).toString(16);
+  return `\\u${padStart(hex, 4, '0')}`;
+};
+export default class JQLEditorErrorStrategy extends DefaultErrorStrategy {
+  constructor(intlRef) {
+    super();
+    this.intlRef = intlRef;
+  }
+  reportInputMismatch(recognizer, exception) {
+    this.handleSyntaxError(recognizer, recognizer.currentToken, exception);
+  }
+  reportUnwantedToken(recognizer) {
+    if (this.inErrorRecoveryMode(recognizer)) {
+      return;
+    }
+    this.beginErrorCondition(recognizer);
+    this.handleSyntaxError(recognizer, recognizer.currentToken);
+  }
+  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) {
+      const 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);
+    }
+  }
+  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
+    const 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);
+  }
+  reportFailedPredicate(recognizer, e) {
+    // TODO: Don't know how to produce this error. Monitor if this happens and defer to default implementation
+    super.reportFailedPredicate(recognizer, e);
+  }
+  handleSyntaxError(recognizer, currentToken, exception) {
+    let 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:
+        {
+          let 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)) {
+            const 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
+              const received = `${(_currentText2 = currentText) !== null && _currentText2 !== void 0 ? _currentText2 : ''}${(_nextToken$text = nextToken.text) !== null && _nextToken$text !== void 0 ? _nextToken$text : ''}`;
+              message = this.intlRef.current.formatMessage(errorMessages.illegalEscape, {
+                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;
+          const 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
+            });
+          }
+          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:
+        {
+          const autocomplete = JQLAutocomplete.fromParser(recognizer, ignoredTokens, preferredRules, new Set());
+          const {
+            tokens,
+            rules
+          } = autocomplete.getJQLSuggestionsForTokenIndex(currentToken.tokenIndex);
+          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);
+  }
+}

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

@@ -0,0 +1,9 @@
+import { JQLLexer, JQLParser } from '@atlaskit/jql-parser';
+export const 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 const 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 const lowPriorityTokens = [JQLLexer.RPAREN, JQLLexer.RBRACKET, JQLLexer.COMMA];

package/dist/es2019/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 const handleCustomFieldRuleError = intl => {
+  return intl.formatMessage(errorMessages.expectingCustomFieldId);
+};

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

@@ -0,0 +1,53 @@
+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 const 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));
+  }
+  const lowPriorityTokenNames = getTokenDisplayNames(recognizer, lowPriorityTokens);
+
+  // Only include tokens that are NOT low priority
+  const highPriorityTokens = expectedTokens.filter(tokenType => !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;
+  }
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  if (expectedTokens.length > 1) {
+    const firstExpectedTokens = expectedTokens.slice(0, -1)
+    // Need to wrap tokens in single quotes ourselves as we cannot do it in the message descriptor
+    .map(token => `'${token}'`).join(', ');
+    const lastExpectedToken = expectedTokens[expectedTokens.length - 1];
+    return isEOF ? intl.formatMessage(errorMessages.expectingMultipleTokensBeforeEOF, {
+      firstExpectedTokens,
+      lastExpectedToken
+    }) : intl.formatMessage(errorMessages.expectingMultipleTokensButReceived, {
+      firstExpectedTokens,
+      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/es2019/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 const handleFieldPropertyIdRuleError = (currentToken, intl) => {
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(errorMessages.expectingFieldPropertyIdBeforeEOF) : intl.formatMessage(errorMessages.expectingFieldPropertyIdButReceived, {
+    received: currentToken.text
+  });
+};

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

@@ -0,0 +1,15 @@
+import { JQLLexer } from '@atlaskit/jql-parser';
+import { errorMessages } from '../messages';
+
+/**
+ * Show the appropriate error message when parsing JQL fails and a field rule was expected.
+ */
+export const handleFieldRuleError = (currentToken, intl) => {
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  if (currentToken.type === JQLLexer.LBRACKET) {
+    return intl.formatMessage(errorMessages.expectingCFButReceived);
+  }
+  return isEOF ? intl.formatMessage(errorMessages.expectingFieldBeforeEOF) : intl.formatMessage(errorMessages.expectingFieldButReceived, {
+    received: currentToken.text
+  });
+};

package/dist/es2019/plugins/jql-ast/error-handlers/FunctionArgumentRuleErrorHandler.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 function argument rule was expected.
+ */
+export const handleFunctionArgumentRuleError = (currentToken, intl) => {
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(errorMessages.expectingFunctionArgBeforeEOF) : intl.formatMessage(errorMessages.expectingFunctionArgButReceived, {
+    received: currentToken.text
+  });
+};

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

@@ -0,0 +1,61 @@
+import { JQLLexer } from '@atlaskit/jql-parser';
+import { errorMessages } from '../messages';
+import { getExpectedTokensFromParserOrException, getTokenDisplayNames } from '../utils';
+import { handleExpectedTokensError } from './ExpectedTokensErrorHandler';
+
+/**
+ * Show the appropriate error message when parsing JQL fails and an operand rule was expected.
+ */
+export const 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 = getTokenDisplayNames(recognizer, getExpectedTokensFromParserOrException(recognizer, exception));
+  }
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  if (rules.value && rules.list && rules.function) {
+    return isEOF ? intl.formatMessage(errorMessages.expectingOperandBeforeEOF) : intl.formatMessage(errorMessages.expectingOperandButReceived, {
+      received: currentToken.text
+    });
+  }
+  if (rules.value && rules.function) {
+    return isEOF ? intl.formatMessage(errorMessages.expectingValueOrFunctionBeforeEOF) : intl.formatMessage(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 handleExpectedTokensError(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(errorMessages.expectingListOrFunctionBeforeEOF) : intl.formatMessage(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 handleExpectedTokensError(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(errorMessages.expectingFunctionBeforeEOF) : intl.formatMessage(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 handleExpectedTokensError(recognizer, currentToken, expectedTokens, intl, exception);
+    }
+    return isEOF ? intl.formatMessage(errorMessages.expectingListBeforeEOF) : intl.formatMessage(errorMessages.expectingListButReceived, {
+      received: currentToken.text
+    });
+  }
+  return isEOF ? intl.formatMessage(errorMessages.expectingValueBeforeEOF) : intl.formatMessage(errorMessages.expectingValueButReceived, {
+    received: currentToken.text
+  });
+};

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

@@ -0,0 +1,13 @@
+import { JQLLexer } from '@atlaskit/jql-parser';
+import { errorMessages } from '../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.
+ */
+export const handleOperatorRuleError = (currentToken, intl) => {
+  const isEOF = currentToken.type === JQLLexer.EOF;
+  return isEOF ? intl.formatMessage(errorMessages.expectingOperatorBeforeEOF) : intl.formatMessage(errorMessages.expectingOperatorButReceived, {
+    received: currentToken.text
+  });
+};

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

@@ -0,0 +1,40 @@
+import { Plugin, PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { JastBuilder } from '@atlaskit/jql-ast';
+import { getNodeText } from '../../utils/document-text';
+import JQLEditorErrorStrategy from './JQLEditorErrorStrategy';
+const JQLAstPluginKey = new PluginKey('jql-ast-plugin');
+export const getJastFromState = state => {
+  const 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;
+};
+const jqlAstPlugin = intlRef => {
+  const jastBuilder = new JastBuilder().setErrorHandler(new JQLEditorErrorStrategy(intlRef));
+  return new Plugin({
+    key: JQLAstPluginKey,
+    state: {
+      init: (_, {
+        doc
+      }) => {
+        return jastBuilder.build(getNodeText(doc, 0, doc.content.size));
+      },
+      // @ts-ignore
+      apply: (tr, value, oldState) => {
+        const text = getNodeText(tr.doc, 0, tr.doc.content.size);
+        const oldText = getNodeText(oldState.doc, 0, oldState.doc.content.size);
+        // Only update the AST if textContent has changed
+        return text !== oldText ? jastBuilder.build(text) : value;
+      }
+    }
+  });
+};
+export default jqlAstPlugin;

package/dist/es2019/plugins/jql-ast/messages.js

@@ -0,0 +1,173 @@
+import { defineMessages } from 'react-intl-next';
+export const errorMessages = defineMessages({
+  expectingOperatorButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingOperatorButReceived',
+    defaultMessage: "Expecting an operator but got ''{received}''. The valid operators are '=', '!=', '<', '>', '<=', '>=', '~', '!~', 'IN', 'NOT IN', 'IS' and 'IS NOT'.",
+    description: 'When an operator was expected but another token was received.'
+  },
+  expectingOperatorBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingOperatorBeforeEOF',
+    defaultMessage: "Expecting an operator before the end of the query. The valid operators are '=', '!=', '<', '>', '<=', '>=', '~', '!~', 'IN', 'NOT IN', 'IS' and 'IS NOT'.",
+    description: 'When an operator was expected before the end of the query.'
+  },
+  expectingFieldButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFieldButReceived',
+    defaultMessage: "Expecting a field name but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a field name.",
+    description: 'When a field was expected but another token was received.'
+  },
+  expectingFieldBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFieldBeforeEOF',
+    defaultMessage: 'Expecting a field name before the end of the query.',
+    description: 'When a field was expected before the end of the query.'
+  },
+  expectingCFButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingCFButReceived',
+    defaultMessage: "Expecting a field name but got '['. Did you mean 'cf['?",
+    description: `When a field was expected but a left bracket was received without a 'cf' prefix.`
+  },
+  expectingCustomFieldId: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingCustomFieldId',
+    defaultMessage: `Expecting a custom field id enclosed by '[ ]' after 'cf'. Example: 'cf[10021]'.`,
+    description: 'When a custom field id was expected before the end of the query. Text wrapped in single quotes in our message refer to specific tokens in the query so they should not be translated.'
+  },
+  expectingOperandButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingOperandButReceived',
+    defaultMessage: "Expecting either a value, list or function but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When an operand was expected but another token was received.'
+  },
+  expectingOperandBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingOperandBeforeEOF',
+    defaultMessage: 'Expecting either a value, list or function before the end of the query.',
+    description: 'When an operand was expected before the end of the query.'
+  },
+  expectingValueOrFunctionButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingValueOrFunctionButReceived',
+    defaultMessage: "Expecting a value or function but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a value or function was expected but another token was received.'
+  },
+  expectingValueOrFunctionBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingValueOrFunctionBeforeEOF',
+    defaultMessage: 'Expecting a value or function before the end of the query.',
+    description: 'When a value or function was expected before the end of the query.'
+  },
+  expectingListOrFunctionButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingListOrFunctionButReceived',
+    defaultMessage: "Expecting a list or function but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a list or function was expected but another token was received.'
+  },
+  expectingListOrFunctionBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingListOrFunctionBeforeEOF',
+    defaultMessage: 'Expecting a list or function before the end of the query.',
+    description: 'When a list or function was expected before the end of the query.'
+  },
+  expectingValueButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingValueButReceived',
+    defaultMessage: "Expecting a value but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a value was expected but another token was received.'
+  },
+  expectingValueBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingValueBeforeEOF',
+    defaultMessage: 'Expecting a value before the end of the query.',
+    description: 'When a value was expected before the end of the query.'
+  },
+  expectingListButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingListButReceived',
+    defaultMessage: "Expecting a list but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a list was expected but another token was received.'
+  },
+  expectingListBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingListBeforeEOF',
+    defaultMessage: 'Expecting a list before the end of the query.',
+    description: 'When a list was expected before the end of the query.'
+  },
+  expectingFunctionButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFunctionButReceived',
+    defaultMessage: "Expecting a function but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a function was expected but another token was received.'
+  },
+  expectingFunctionBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFunctionBeforeEOF',
+    defaultMessage: 'Expecting a function before the end of the query.',
+    description: 'When a function was expected before the end of the query.'
+  },
+  expectingFieldPropertyIdButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFieldPropertyIdButReceived',
+    defaultMessage: "Expecting a property id but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a field property ID was expected but another token was received.'
+  },
+  expectingFieldPropertyIdBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFieldPropertyIdBeforeEOF',
+    defaultMessage: 'Expecting a property id before the end of the query.',
+    description: 'When a field property ID was expected before the end of the query.'
+  },
+  expectingFunctionArgButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFunctionArgButReceived',
+    defaultMessage: "Expecting a function argument but got ''{received}''. You must surround ''{received}'' in quotation marks to use it as a value.",
+    description: 'When a function argument was expected but another token was received.'
+  },
+  expectingFunctionArgBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingFunctionArgBeforeEOF',
+    defaultMessage: 'Expecting a function argument before the end of the query.',
+    description: 'When a function argument was expected before the end of the query.'
+  },
+  expectingMultipleTokensButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingMultipleTokensButReceived',
+    defaultMessage: "Expecting {firstExpectedTokens} or ''{lastExpectedToken}'' but got ''{received}''.",
+    description: 'When the text the user entered does not match any of the expected tokens.'
+  },
+  expectingMultipleTokensBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingMultipleTokensBeforeEOF',
+    defaultMessage: "Expecting {firstExpectedTokens} or ''{lastExpectedToken}'' before the end of the query.",
+    description: 'When there are still tokens expected before the query can end.'
+  },
+  expectingTokenButReceived: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingTokenButReceived',
+    defaultMessage: "Expecting ''{expectedToken}'' but got ''{received}''.",
+    description: 'When the text the user entered does not match the expected tokens.'
+  },
+  expectingTokenBeforeEOF: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.expectingTokenBeforeEOF',
+    defaultMessage: "Expecting ''{expectedToken}'' before the end of the query.",
+    description: 'When an expected token needs to be inserted before the query can end.'
+  },
+  unknownErrorAtToken: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.unknownErrorAtToken',
+    defaultMessage: "Unable to parse the query at ''{received}''.",
+    description: 'When the query could not be parsed when a token was reached.'
+  },
+  reservedChar: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.reservedChar',
+    defaultMessage: "The character ''{char}'' is a reserved JQL character. You must enclose it in a string or use the escape ''{escapedChar}'' instead.",
+    description: 'When the user has a reserved character in the query.'
+  },
+  reservedWord: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.reservedWord',
+    defaultMessage: "''{word}'' is a reserved JQL word. You must surround it in quotation marks to use it in a query.",
+    description: 'When the user has a reserved word in the query.'
+  },
+  unfinishedString: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.unfinishedString',
+    defaultMessage: `The quoted string ''{received}'' has not been completed.`,
+    description: 'When a string is missing an opening or closing quote.'
+  },
+  unfinishedStringBlank: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.unfinishedStringBlank',
+    defaultMessage: 'The quoted string has not been completed.',
+    description: 'When a string is missing an opening or closing quote.'
+  },
+  illegalEscape: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.illegalEscape',
+    defaultMessage: `''{received}'' is an illegal JQL escape sequence. The valid escape sequences are \u005C', \u005C", \u005Ct, \u005Cn, \u005Cr, \u005C\u005C, '\u005C ' and \u005CuXXXX.`,
+    description: 'When there are no valid tokens following an escape character.'
+  },
+  illegalEscapeBlank: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.illegalEscapeBlank',
+    defaultMessage: `The escape sequence has not been completed. The valid escape sequences are \u005C', \u005C", \u005Ct, \u005Cn, \u005Cr, \u005C\u005C, '\u005C ' and \u005CuXXXX.`,
+    description: 'When there are no valid tokens following an escape character.'
+  },
+  illegalChar: {
+    id: 'jql-editor.plugins.jql-ast.error-messages.illegalChar',
+    defaultMessage: "The character ''{char}'' must be escaped. Use the escape ''{escapedChar}'' instead.",
+    description: 'When an illegal character is encountered in a query.'
+  }
+});

package/dist/es2019/plugins/jql-ast/utils.js

@@ -0,0 +1,13 @@
+import { ignoredTokens } from './constants';
+export const getTokenDisplayNames = (parser, tokens) => {
+  return tokens.map(tokenType => parser.vocabulary.getDisplayName(tokenType).replace(/^'|'$/g, ''));
+};
+export const getExpectedTokensFromParserOrException = (parser, exception) => {
+  var _exception$expectedTo;
+  // Read expected tokens from the exception if present, as it refers to the expected input symbols at the time the
+  // exception was thrown (whereas JQLParser will give us possible tokens from the current parser state).
+  const expectedTokenSet = (_exception$expectedTo = exception === null || exception === void 0 ? void 0 : exception.expectedTokens) !== null && _exception$expectedTo !== void 0 ? _exception$expectedTo : parser.getExpectedTokens();
+  return expectedTokenSet.toArray()
+  // Show the token if it's not ignored
+  .filter(tokenType => !ignoredTokens.has(tokenType));
+};