@atlaskit/jql-editor 4.0.0

package/dist/es2019/plugins/autocomplete/components/autocomplete-option/index.js

@@ -0,0 +1,159 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React, { forwardRef, useCallback, useMemo, useState } from 'react';
+import deburr from 'lodash/deburr';
+import noop from 'lodash/noop';
+import Icon from '@atlaskit/icon';
+import InfoIcon from '@atlaskit/icon/glyph/editor/panel';
+import { normaliseJqlString } from '@atlaskit/jql-ast';
+import { N400 } from '@atlaskit/theme/colors';
+import Tooltip from '@atlaskit/tooltip';
+import { useIntl } from '../../../../state';
+import { checkboxGlyph, dateGlyph, dropdownGlyph, labelGlyph, numberGlyph, paragraphGlyph, peopleGlyph, shortTextGlyph, timeStampGlyph } from './glyphs';
+import { messages } from './messages';
+import { DeprecatedOptionContainer, FieldType, FieldTypeIcon, OptionHighlight, OptionListItem, OptionName, TooltipContent } from './styled';
+const ResizedIcon = ({
+  glyph
+}) => /*#__PURE__*/React.createElement(Icon, {
+  glyph: glyph,
+  size: "small",
+  label: "",
+  testId: "jql-editor-field-type-icon"
+});
+
+/**
+ * List of types with supported icons is derived from GIN
+ * Custom SVGs are provisional while we work on making field type icons consistent across Atlassian
+ */
+const getFieldTypeIcon = type => {
+  switch (type) {
+    case 'Checkboxes':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: checkboxGlyph
+      });
+    case 'Date':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: dateGlyph
+      });
+    case 'Dropdown':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: dropdownGlyph
+      });
+    case 'Labels':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: labelGlyph
+      });
+    case 'Number':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: numberGlyph
+      });
+    case 'Paragraph':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: paragraphGlyph
+      });
+    case 'People':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: peopleGlyph
+      });
+    case 'Short text':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: shortTextGlyph
+      });
+    case 'Time stamp':
+      return /*#__PURE__*/React.createElement(ResizedIcon, {
+        glyph: timeStampGlyph
+      });
+    default:
+      return null;
+  }
+};
+const getHighlightPosition = (name, matchedText) => {
+  const normalizedName = deburr(name).toLowerCase();
+  const normalizedMatchedText = deburr(normaliseJqlString(matchedText)).toLowerCase();
+  const index = normalizedName.indexOf(normalizedMatchedText);
+  if (index === -1) {
+    return null;
+  }
+  return [index, index + normalizedMatchedText.length];
+};
+const getDeprecatedTooltipMessage = deprecatedSearcherKey => {
+  switch (deprecatedSearcherKey) {
+    case 'com.pyxis.greenhopper.jira:gh-epic-link-searcher':
+    case 'com.atlassian.jpo:jpo-custom-field-parent-searcher':
+      return messages.deprecatedFieldTooltipParentReplacementMessage;
+    default:
+      return messages.deprecatedFieldTooltipDefaultMessage;
+  }
+};
+const AutocompleteOption = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    option: {
+      id,
+      name,
+      fieldType,
+      matchedText,
+      isDeprecated = false,
+      deprecatedSearcherKey
+    },
+    isSelected,
+    onClick,
+    onMouseMove
+  } = props;
+  const [overflows, setOverflows] = useState(false);
+  const [{
+    formatMessage
+  }] = useIntl();
+  const onNameRef = useCallback(node => {
+    // This ref will be re-invoked after a tooltip is rendered, so we avoid recomputing the overflow in that instance
+    // so we don't risk infinite re-renders (which we've observed through production logs).
+    if (node != null && !overflows) {
+      setOverflows(node.offsetWidth < node.scrollWidth);
+    }
+  }, [overflows]);
+
+  // TODO: verify type is i18n'd after integrating with GraphQL API
+
+  const fieldTypeIcon = fieldType ? getFieldTypeIcon(fieldType) : null;
+  const optionName = useMemo(() => {
+    const highlightPosition = getHighlightPosition(name, matchedText);
+    return highlightPosition ? /*#__PURE__*/React.createElement(OptionName, {
+      ref: onNameRef,
+      "aria-label": name
+    }, name.substring(0, highlightPosition[0]), /*#__PURE__*/React.createElement(OptionHighlight, null, name.substring(...highlightPosition)), name.substring(highlightPosition[1])) : /*#__PURE__*/React.createElement(OptionName, {
+      ref: onNameRef
+    }, name);
+  }, [onNameRef, name, matchedText]);
+  const deprecatedTooltipContent = /*#__PURE__*/React.createElement(TooltipContent, null, formatMessage(getDeprecatedTooltipMessage(deprecatedSearcherKey), {
+    b: text => /*#__PURE__*/React.createElement("b", null, text),
+    received: name,
+    parentReplacement: 'Parent'
+  }));
+  const ListItem = /*#__PURE__*/React.createElement(OptionListItem, _extends({
+    id: id,
+    "data-testid": "jql-editor-autocomplete-option",
+    role: "option",
+    isSelected: isSelected,
+    isDeprecated: isDeprecated,
+    onClick: isDeprecated ? noop : onClick,
+    onMouseMove: isDeprecated ? noop : onMouseMove
+  }, ref && {
+    ref: ref
+  }, {
+    "aria-selected": isSelected
+  }), isDeprecated ? /*#__PURE__*/React.createElement(DeprecatedOptionContainer, null, optionName, /*#__PURE__*/React.createElement(Tooltip, {
+    content: deprecatedTooltipContent,
+    position: 'right'
+  }, /*#__PURE__*/React.createElement(InfoIcon, {
+    testId: "jql-editor-deprecated-icon",
+    label: "",
+    primaryColor: `var(--ds-icon, ${N400})`
+  }))) : optionName, fieldType && /*#__PURE__*/React.createElement(FieldType, null, fieldTypeIcon && /*#__PURE__*/React.createElement(FieldTypeIcon, null, fieldTypeIcon), fieldType));
+  const tooltipContent = /*#__PURE__*/React.createElement(TooltipContent, null, name);
+  if (overflows) {
+    return /*#__PURE__*/React.createElement(Tooltip, {
+      content: tooltipContent,
+      position: 'right'
+    }, ListItem);
+  }
+  return ListItem;
+});
+export default AutocompleteOption;

package/dist/es2019/plugins/autocomplete/components/autocomplete-option/messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl-next';
+export const messages = defineMessages({
+  deprecatedFieldTooltipDefaultMessage: {
+    id: 'jql-editor.plugins.autocomplete.autocomplete-option.deprecated-tooltip.default',
+    defaultMessage: 'This field has been deprecated and may stop working in the future.',
+    description: 'Default tooltip message for a deprecated field.'
+  },
+  deprecatedFieldTooltipParentReplacementMessage: {
+    id: 'jql-editor.plugins.autocomplete.autocomplete-option.deprecated-tooltip.epic-link',
+    defaultMessage: "<b>''{received}''</b> will soon be replaced with <b>''{parentReplacement}''</b>. Use the <b>''{parentReplacement}''</b> field instead.",
+    description: 'Tooltip message served to user when there is a deprecated field'
+  }
+});

package/dist/es2019/plugins/autocomplete/components/autocomplete-option/styled.js

@@ -0,0 +1,51 @@
+import { css } from '@emotion/react';
+import styled from '@emotion/styled';
+import { N100, N20, N50, N800 } from '@atlaskit/theme/colors';
+import { codeFontFamily, fontFamily,
+// eslint-disable-next-line @atlaskit/design-system/no-deprecated-imports
+gridSize } from '@atlaskit/theme/constants';
+export const TooltipContent = styled.div`
+  font-family: ${fontFamily};
+`;
+
+// eslint-disable-next-line @atlaskit/design-system/ensure-design-token-usage
+export const OptionListItem = styled.li`
+  cursor: pointer;
+  padding: ${"var(--ds-space-075, 6px)"} ${5 / 4 * gridSize()}px;
+  font-family: ${codeFontFamily};
+  line-height: 24px;
+  ${props => props.isSelected ? css`
+          background: ${`var(--ds-background-neutral-subtle-hovered, ${N20})`};
+        ` : ''}
+  ${props => props.isDeprecated ? css`
+          cursor: default;
+          color: ${`var(--ds-text-disabled, ${N50})`};
+        ` : ''}
+`;
+export const OptionName = styled.div`
+  color: ${`var(--ds-text, ${N800})`};
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  // Added so that overflowed option names do not squish the deprecated info icon
+  flex: 1;
+`;
+export const DeprecatedOptionContainer = styled.div`
+  color: ${`var(--ds-text-disabled, ${N50})`};
+  display: flex;
+  justify-content: space-between;
+  opacity: 0.6;
+`;
+export const OptionHighlight = styled.span`
+  font-weight: bold;
+`;
+export const FieldType = styled.div`
+  display: flex;
+  align-items: center;
+  margin-top: ${"var(--ds-space-negative-025, -2px)"};
+  color: ${`var(--ds-text-subtlest, ${N100})`};
+`;
+export const FieldTypeIcon = styled.span`
+  display: flex;
+  margin-right: ${"var(--ds-space-050, 4px)"};
+`;

package/dist/es2019/plugins/autocomplete/components/types.js

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

package/dist/es2019/plugins/autocomplete/constants.js

@@ -0,0 +1,21 @@
+import { empty } from 'rxjs/observable/empty';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export const AUTOCOMPLETE_PLUGIN_NAME = 'jql-autocomplete-plugin';
+export const ARROW_UP_KEY = 'ArrowUp';
+export const ARROW_DOWN_KEY = 'ArrowDown';
+export const CMD_ARROW_UP_KEY = 'Cmd-ArrowUp';
+export const CMD_ARROW_DOWN_KEY = 'Cmd-ArrowDown';
+export const HOME_KEY = 'Home'; // === Fn-Left in Mac
+export const END_KEY = 'End'; // === Fn-Right in Mac
+export const ENTER_KEY = 'Enter';
+export const ESCAPE_KEY = 'Escape';
+export const TAB_KEY = 'Tab';
+
+// No-op autocomplete provider used when creating the initial state
+export const defaultAutocompleteProvider = {
+  onFields: () => empty(),
+  onOperators: () => empty(),
+  onValues: () => empty(),
+  onFunctions: () => empty()
+};
+export const JQLAutocompletePluginKey = new PluginKey(AUTOCOMPLETE_PLUGIN_NAME);

package/dist/es2019/plugins/autocomplete/index.js

@@ -0,0 +1,36 @@
+import { keydownHandler } from '@atlaskit/editor-prosemirror/keymap';
+import { Plugin } from '@atlaskit/editor-prosemirror/state';
+import { PluginKeymap } from '../common/plugin-keymap';
+import { ARROW_DOWN_KEY, ARROW_UP_KEY, CMD_ARROW_DOWN_KEY, CMD_ARROW_UP_KEY, END_KEY, ENTER_KEY, ESCAPE_KEY, HOME_KEY, JQLAutocompletePluginKey, TAB_KEY } from './constants';
+import AutocompletePluginView from './view';
+const getKeyHandler = (keymap, key) => (state, dispatch, view) => {
+  const binding = keymap.getKeyBinding(key);
+  return binding ? binding(state, dispatch, view) : false;
+};
+const autocompletePlugin = (portalActions, enableRichInlineNodes) => {
+  // Empty keymap passed down to the React component so it can register key bindings
+  const keymap = new PluginKeymap();
+  return new Plugin({
+    key: JQLAutocompletePluginKey,
+    view: editorView => {
+      const view = new AutocompletePluginView(editorView, keymap, portalActions, enableRichInlineNodes);
+      // Initialise view to mount the react component
+      view.init();
+      return view;
+    },
+    props: {
+      handleKeyDown: keydownHandler({
+        [ARROW_UP_KEY]: getKeyHandler(keymap, ARROW_UP_KEY),
+        [ARROW_DOWN_KEY]: getKeyHandler(keymap, ARROW_DOWN_KEY),
+        [CMD_ARROW_UP_KEY]: getKeyHandler(keymap, CMD_ARROW_UP_KEY),
+        [CMD_ARROW_DOWN_KEY]: getKeyHandler(keymap, CMD_ARROW_DOWN_KEY),
+        [HOME_KEY]: getKeyHandler(keymap, HOME_KEY),
+        [END_KEY]: getKeyHandler(keymap, END_KEY),
+        [ESCAPE_KEY]: getKeyHandler(keymap, ESCAPE_KEY),
+        [ENTER_KEY]: getKeyHandler(keymap, ENTER_KEY),
+        [TAB_KEY]: getKeyHandler(keymap, TAB_KEY)
+      })
+    }
+  });
+};
+export default autocompletePlugin;

package/dist/es2019/plugins/autocomplete/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const messages = defineMessages({
+  optionsFound: {
+    id: 'jql-editor.plugins.autocomplete.options-found',
+    defaultMessage: 'Choose from the suggested list of options below.',
+    description: 'This message is read by screen readers when autocomplete suggestions are available in the JQL editor.'
+  }
+});

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

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

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

@@ -0,0 +1,102 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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)
+ */
+const shouldInsertOpeningParenthesis = ({
+  type,
+  context,
+  isListFunction
+}) => {
+  if (type === 'value' || type === 'function' || type === 'keyword') {
+    const 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;
+};
+export default class AutocompletePluginView extends ReactPluginView {
+  constructor(view, keymap, portalActions, enableRichInlineNodes) {
+    super(portalActions, AUTOCOMPLETE_PLUGIN_NAME, 'main');
+    _defineProperty(this, "getComponent", () => {
+      return Autocomplete;
+    });
+    _defineProperty(this, "getInitialComponentProps", () => {
+      return {
+        keymap: this.keymap,
+        onClick: this.onReplaceSuggestion
+      };
+    });
+    _defineProperty(this, "onReplaceSuggestion", option => {
+      const [from, to] = option.replacePosition;
+      const 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);
+      }
+      const documentFrom = getDocumentPosition(transaction.doc, from);
+      const 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(this, "getSliceForSuggestion", option => {
+      const {
+        value,
+        name,
+        nameOnRichInlineNode,
+        valueType,
+        context
+      } = option;
+      const nodes = [];
+      if (shouldInsertOpeningParenthesis(option)) {
+        nodes.push(this.view.state.schema.text('('));
+      }
+      const textContent = this.view.state.schema.text(value);
+      if (!this.enableRichInlineNodes) {
+        nodes.push(textContent);
+      } else {
+        switch (valueType) {
+          case 'user':
+            {
+              const 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;
+  }
+  isSameState(state, prevState) {
+    return prevState.doc.eq(state.doc) && prevState.selection.eq(state.selection);
+  }
+}

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

@@ -0,0 +1,92 @@
+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.
+ */
+const enterNode = (node, parentNodePos, textPosition) => {
+  let nodePos = {
+    ...parentNodePos
+  };
+  const 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) {
+      const 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 (let 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.
+ */
+const getDocumentPosition = (doc, textPosition) => {
+  const currentPos = {
+    doc: 0,
+    text: 0,
+    enteredInitialBlock: false
+  };
+  const matchingNodePos = enterNode(doc, currentPos, textPosition);
+  return matchingNodePos.doc;
+};
+export default getDocumentPosition;

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

@@ -0,0 +1,30 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export class PluginKeymap {
+  constructor() {
+    _defineProperty(this, "keymap", {});
+  }
+  bindKey(key, handler) {
+    this.keymap = {
+      ...this.keymap,
+      [key]: handler
+    };
+  }
+  bindMultipleKeys(keys, handler) {
+    keys.forEach(key => {
+      this.keymap = {
+        ...this.keymap,
+        [key]: handler
+      };
+    });
+  }
+  unbindKey(key) {
+    const {
+      [key]: keyToUnbind,
+      ...rest
+    } = this.keymap;
+    this.keymap = rest;
+  }
+  getKeyBinding(key) {
+    return this.keymap[key];
+  }
+}

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

@@ -0,0 +1,67 @@
+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
+ * }
+ * ```
+ */
+export default class ReactPluginView {
+  /**
+   * 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
+   */
+  constructor(portalActions, portalKey, containerKey) {
+    _defineProperty(this, "componentSubject", new Subject());
+    _defineProperty(this, "init", () => {
+      const Component = this.getComponent();
+      const PortallingComponent = () => {
+        const [state, setState] = useState(() => this.getInitialComponentProps());
+        useEffect(() => {
+          // Subscribe to the RxJS subject so concrete subclasses can emit events to re-render the plugin component.
+          const subscription = this.componentSubject.subscribe(updatedProps => {
+            setState(updatedProps);
+          });
+          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;
+  }
+  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.
+   */
+}

package/dist/es2019/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';