@atlaskit/jql-editor 4.0.0

package/dist/esm/ui/jql-editor-portal-provider/index.js

@@ -0,0 +1,107 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+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; }
+import React, { useMemo, useReducer } from 'react';
+import { createPortal } from 'react-dom';
+import { PortalActionsContext } from './context';
+var initialState = {
+  components: {},
+  containers: {}
+};
+var reducer = function reducer(state, action) {
+  switch (action.type) {
+    case 'createPortal':
+      {
+        var _action$payload = action.payload,
+          key = _action$payload.key,
+          portalComponent = _action$payload.portalComponent,
+          container = _action$payload.container;
+        return _objectSpread(_objectSpread({}, state), {}, {
+          components: _objectSpread(_objectSpread({}, state.components), {}, _defineProperty({}, key, {
+            portalComponent: portalComponent,
+            container: container
+          }))
+        });
+      }
+    case 'destroyPortal':
+      {
+        var _state$components = state.components,
+          _action$payload2 = action.payload,
+          toDestroy = _state$components[_action$payload2],
+          components = _objectWithoutProperties(_state$components, [_action$payload2].map(_toPropertyKey));
+        return _objectSpread(_objectSpread({}, state), {}, {
+          components: components
+        });
+      }
+    case 'registerPluginContainer':
+      {
+        var _action$payload3 = action.payload,
+          element = _action$payload3.element,
+          containerKey = _action$payload3.containerKey;
+        if (!element) {
+          return state;
+        }
+        return _objectSpread(_objectSpread({}, state), {}, {
+          containers: _objectSpread(_objectSpread({}, state.containers), {}, _defineProperty({}, containerKey, element))
+        });
+      }
+    default:
+      {
+        return state;
+      }
+  }
+};
+
+/**
+ * Provides actions to manage portals via context and renders portalled components into the React tree.
+ */
+export var JQLEditorPortalRenderer = function JQLEditorPortalRenderer(_ref) {
+  var children = _ref.children;
+  var _useReducer = useReducer(reducer, initialState),
+    _useReducer2 = _slicedToArray(_useReducer, 2),
+    state = _useReducer2[0],
+    dispatch = _useReducer2[1];
+  var actionsContext = useMemo(function () {
+    return {
+      onCreatePortal: function onCreatePortal(key, portalComponent, container) {
+        return dispatch({
+          type: 'createPortal',
+          payload: {
+            key: key,
+            portalComponent: portalComponent,
+            container: container
+          }
+        });
+      },
+      onDestroyPortal: function onDestroyPortal(key) {
+        return dispatch({
+          type: 'destroyPortal',
+          payload: key
+        });
+      },
+      onRegisterPluginContainer: function onRegisterPluginContainer(containerKey, element) {
+        return dispatch({
+          type: 'registerPluginContainer',
+          payload: {
+            containerKey: containerKey,
+            element: element
+          }
+        });
+      }
+    };
+  }, [dispatch]);
+  return /*#__PURE__*/React.createElement(PortalActionsContext.Provider, {
+    value: actionsContext
+  }, children, Object.entries(state.components).map(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+      key = _ref3[0],
+      value = _ref3[1];
+    var container = value.container instanceof Element ? value.container : state.containers[value.container];
+    return container !== undefined ? /*#__PURE__*/createPortal(value.portalComponent, container, key) : null;
+  }));
+};

package/dist/esm/ui/jql-editor-portal-provider/types.js

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

package/dist/esm/ui/jql-editor-view/index.js

@@ -0,0 +1,190 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+import throttle from 'lodash/throttle';
+import { JQL_EDITOR_AUTOCOMPLETE_ID, JQL_EDITOR_HELP_CONTENT_ID, JQL_EDITOR_INPUT_ID, JQL_EDITOR_MAIN_ID } from '../../common/constants';
+import { useEditorThemeContext } from '../../hooks/use-editor-theme';
+import { useEditorViewIsInvalid } from '../../hooks/use-editor-view-is-invalid';
+import { useAutocomplete, useAutocompleteIsOpen, useEditorView, useEditorViewHasFocus, useIntl, useLineNumbersVisible, useScopedId, useStoreActions } from '../../state';
+// eslint-disable-next-line @atlassian/tangerine/import/no-parent-imports
+import { JQLEditorControlsContent } from '../jql-editor-controls-content';
+// eslint-disable-next-line @atlassian/tangerine/import/no-parent-imports
+import { JQLEditorFooterContent } from '../jql-editor-footer-content';
+// eslint-disable-next-line @atlassian/tangerine/import/no-parent-imports
+import JQLEditorLayout from '../jql-editor-layout';
+// eslint-disable-next-line @atlassian/tangerine/import/no-parent-imports
+import { usePortalActionsContext } from '../jql-editor-portal-provider/context';
+// eslint-disable-next-line @atlassian/tangerine/import/no-parent-imports
+import { messages } from '../messages';
+
+/**
+ * This wraps ProseMirror's EditorView as a React component.
+ */
+var JQLEditorView = function JQLEditorView(_ref) {
+  var inputRef = _ref.inputRef;
+  var _useEditorView = useEditorView(),
+    _useEditorView2 = _slicedToArray(_useEditorView, 2),
+    editorView = _useEditorView2[0],
+    _useEditorView2$ = _useEditorView2[1],
+    initialiseEditorView = _useEditorView2$.initialiseEditorView,
+    updateEditorView = _useEditorView2$.updateEditorView;
+  var editorViewNodeRef = useRef(null);
+  var _useScopedId = useScopedId(JQL_EDITOR_MAIN_ID),
+    _useScopedId2 = _slicedToArray(_useScopedId, 1),
+    mainId = _useScopedId2[0];
+  var _useScopedId3 = useScopedId(JQL_EDITOR_AUTOCOMPLETE_ID),
+    _useScopedId4 = _slicedToArray(_useScopedId3, 1),
+    autocompleteId = _useScopedId4[0];
+  var _useScopedId5 = useScopedId(JQL_EDITOR_INPUT_ID),
+    _useScopedId6 = _slicedToArray(_useScopedId5, 1),
+    editorId = _useScopedId6[0];
+  var _useScopedId7 = useScopedId(JQL_EDITOR_HELP_CONTENT_ID),
+    _useScopedId8 = _slicedToArray(_useScopedId7, 1),
+    helpContentId = _useScopedId8[0];
+  var _useIntl = useIntl(),
+    _useIntl2 = _slicedToArray(_useIntl, 1),
+    intl = _useIntl2[0];
+  var portalActions = usePortalActionsContext();
+  var _useStoreActions = useStoreActions(),
+    _useStoreActions2 = _slicedToArray(_useStoreActions, 2),
+    _useStoreActions2$ = _useStoreActions2[1],
+    setEditorViewContainer = _useStoreActions2$.setEditorViewContainer,
+    setEditorViewContainerScroll = _useStoreActions2$.setEditorViewContainerScroll;
+  var _useEditorViewHasFocu = useEditorViewHasFocus(),
+    _useEditorViewHasFocu2 = _slicedToArray(_useEditorViewHasFocu, 2),
+    editorViewHasFocus = _useEditorViewHasFocu2[0],
+    _useEditorViewHasFocu3 = _useEditorViewHasFocu2[1],
+    onEditorViewBlur = _useEditorViewHasFocu3.onEditorViewBlur,
+    onEditorViewFocus = _useEditorViewHasFocu3.onEditorViewFocus;
+  var _useLineNumbersVisibl = useLineNumbersVisible(),
+    _useLineNumbersVisibl2 = _slicedToArray(_useLineNumbersVisibl, 1),
+    lineNumbersVisible = _useLineNumbersVisibl2[0];
+  var _useAutocomplete = useAutocomplete(),
+    _useAutocomplete2 = _slicedToArray(_useAutocomplete, 1),
+    selectedOptionId = _useAutocomplete2[0].selectedOptionId;
+  var _useAutocompleteIsOpe = useAutocompleteIsOpen(),
+    _useAutocompleteIsOpe2 = _slicedToArray(_useAutocompleteIsOpe, 1),
+    isAutocompleteOpen = _useAutocompleteIsOpe2[0];
+  var editorViewIsInvalid = useEditorViewIsInvalid();
+  var _useEditorThemeContex = useEditorThemeContext(),
+    expanded = _useEditorThemeContex.expanded;
+  var previousExpanded = useRef(expanded);
+  var onEditorViewTransitionEnd = useCallback(function () {
+    if (!expanded && editorViewNodeRef.current) {
+      // Clear any fixed heights when the editor is collapsed
+      editorViewNodeRef.current.style.height = '';
+    }
+  }, [expanded, editorViewNodeRef]);
+  var onMainRef = useCallback(function (element) {
+    return portalActions.onRegisterPluginContainer('main', element);
+  }, [portalActions]);
+  var onEditorViewContainerRef = useCallback(function (editorViewContainer) {
+    if (editorViewContainer) {
+      setEditorViewContainer(editorViewContainer);
+    }
+  }, [setEditorViewContainer]);
+  var throttledSetEditorViewContainerScroll = useMemo(function () {
+    return throttle(function (scrollTop) {
+      setEditorViewContainerScroll(scrollTop);
+    }, 1000 / 60);
+  },
+  // 60 fps
+  [setEditorViewContainerScroll]);
+  var onEditorViewContainerScroll = useCallback(function (event) {
+    var scrollTop = event.currentTarget.scrollTop;
+    throttledSetEditorViewContainerScroll(scrollTop);
+  }, [throttledSetEditorViewContainerScroll]);
+
+  // Compute HTML attributes to be applied to the Prosemirror editor view
+  var getAttributes = useCallback(function () {
+    return _objectSpread(_objectSpread({
+      id: editorId,
+      'data-testid': 'jql-editor-input',
+      // Disable grammarly
+      'data-gramm': 'false',
+      // Combobox might not be a semantically correct role for the editor,
+      // however some browsers like Safari will only announce suggestions when this role is present
+      role: 'combobox',
+      'aria-expanded': "".concat(isAutocompleteOpen),
+      'aria-autocomplete': 'list',
+      'aria-label': intl.formatMessage(messages.inputLabel),
+      'aria-controls': autocompleteId,
+      'aria-owns': autocompleteId,
+      'aria-describedby': helpContentId
+    }, selectedOptionId && {
+      'aria-activedescendant': selectedOptionId
+    }), editorViewIsInvalid && {
+      'aria-invalid': 'true'
+    });
+  }, [editorId, isAutocompleteOpen, intl, autocompleteId, helpContentId, selectedOptionId, editorViewIsInvalid]);
+
+  // Update attributes on our editor view whenever they have changed
+  useEffect(function () {
+    updateEditorView(getAttributes());
+  }, [getAttributes, updateEditorView]);
+  var onEditorViewRef = useCallback(function (editorViewNode) {
+    if (editorViewNode && !editorView) {
+      initialiseEditorView(editorViewNode, getAttributes(), portalActions);
+      editorViewNodeRef.current = editorViewNode;
+    }
+  }, [editorView, initialiseEditorView, getAttributes, portalActions]);
+  useEffect(function () {
+    if (editorViewNodeRef.current && expanded !== previousExpanded.current) {
+      if (expanded) {
+        // Set fixed height based on the current element height so we can transition to the expanded height
+        editorViewNodeRef.current.style.height = editorViewNodeRef.current.clientHeight + 'px';
+        requestAnimationFrame(function () {
+          if (editorViewNodeRef.current) {
+            editorViewNodeRef.current.style.height = '';
+            editorViewNodeRef.current.setAttribute('data-expanded', 'true');
+          }
+        });
+      } else {
+        if (editorView) {
+          requestAnimationFrame(function () {
+            if (editorViewNodeRef.current && editorView) {
+              // Transition to the default height based on the content of the editor
+              editorViewNodeRef.current.style.height = editorView.dom.clientHeight + 'px';
+              editorViewNodeRef.current.removeAttribute('data-expanded');
+            }
+          });
+        }
+      }
+    }
+    previousExpanded.current = expanded;
+  }, [expanded, previousExpanded, editorViewNodeRef, editorView]);
+  useImperativeHandle(inputRef, function () {
+    return {
+      focus: function focus() {
+        if (editorView) {
+          editorView.focus();
+        }
+      }
+    };
+  });
+  useEffect(function () {
+    return function () {
+      if (editorView) {
+        editorView.destroy();
+      }
+    };
+  }, [editorView]);
+  return /*#__PURE__*/React.createElement(JQLEditorLayout, {
+    EditorControlsContent: /*#__PURE__*/React.createElement(JQLEditorControlsContent, null),
+    EditorFooterContent: /*#__PURE__*/React.createElement(JQLEditorFooterContent, null),
+    editorViewHasFocus: editorViewHasFocus,
+    lineNumbersVisible: lineNumbersVisible,
+    editorViewIsInvalid: editorViewIsInvalid,
+    mainId: mainId,
+    onEditorMainRef: onMainRef,
+    onEditorViewContainerRef: onEditorViewContainerRef,
+    onEditorViewContainerScroll: onEditorViewContainerScroll,
+    onEditorViewRef: onEditorViewRef,
+    onEditorViewBlur: onEditorViewBlur,
+    onEditorViewFocus: onEditorViewFocus,
+    onEditorViewTransitionEnd: onEditorViewTransitionEnd
+  });
+};
+export default JQLEditorView;

package/dist/esm/ui/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export var messages = defineMessages({
+  inputLabel: {
+    id: 'jql-editor.ui.input-label',
+    defaultMessage: 'JQL query',
+    description: 'Label for the input where users can type a JQL query. This text is not visible and is only read by screen readers.'
+  }
+});

package/dist/esm/ui/tooltip-tag/index.js

@@ -0,0 +1,10 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React, { forwardRef } from 'react';
+import { StyledTooltipTag } from './styled';
+
+// We need to use a custom tag element in our tooltip to prevent extra whitespace being rendered after the element
+export var TooltipTag = /*#__PURE__*/forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(StyledTooltipTag, _extends({
+    ref: ref
+  }, props));
+});

package/dist/esm/ui/tooltip-tag/styled.js

@@ -0,0 +1,4 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _templateObject;
+import styled from '@emotion/styled';
+export var StyledTooltipTag = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n"])));

package/dist/esm/ui/types.js

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

package/dist/esm/utils/document-text/index.js

@@ -0,0 +1,37 @@
+/**
+ * Get all text between positions `from` and `to` with a newline char between block nodes.
+ */
+export var getNodeText = function getNodeText(node, from, to) {
+  return getFragmentText(node.content, from, to);
+};
+
+/**
+ * Get all text between positions `from` and `to` with a newline char between block nodes.
+ */
+export var getFragmentText = function getFragmentText(fragment, from, to) {
+  return textBetween(fragment, from, to, '\n');
+};
+
+/**
+ * A modified version of {@link Fragment#textBetween}. The default implementation does not insert `blockSeparator` for
+ * consecutive empty block nodes (i.e. empty blocks are collapsed into one).
+ */
+var textBetween = function textBetween(fragment, from, to, blockSeparator, leafText) {
+  var text = '';
+  var enteredInitialBlock = false;
+  fragment.nodesBetween(from, to, function (innerNode, pos) {
+    if (innerNode.isText) {
+      var _innerNode$text;
+      text += (_innerNode$text = innerNode.text) === null || _innerNode$text === void 0 ? void 0 : _innerNode$text.slice(Math.max(from, pos) - pos, to - pos);
+    } else if (innerNode.isLeaf && leafText) {
+      text += leafText;
+    } else if (innerNode.isBlock) {
+      if (enteredInitialBlock) {
+        text += blockSeparator;
+      } else {
+        enteredInitialBlock = true;
+      }
+    }
+  }, 0);
+  return text;
+};

package/dist/esm/utils/split-text-by-new-line/index.js

@@ -0,0 +1,6 @@
+/**
+ * Splits the provided text by new line characters.
+ */
+export var splitTextByNewLine = function splitTextByNewLine(text) {
+  return text.split(/(?:\r\n?|\n)/);
+};

package/dist/types/accessibility/index.d.ts

@@ -0,0 +1 @@
+export { ScreenReaderText } from './styled';

package/dist/types/accessibility/styled.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const ScreenReaderText: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;

package/dist/types/analytics/constants.d.ts

@@ -0,0 +1,18 @@
+export declare enum Action {
+    CLICKED = "clicked",
+    RETRIEVE_FAILED = "retrieveFailed",
+    RETRIEVED = "retrieved",
+    SELECTED = "selected",
+    VIEWED = "viewed"
+}
+export declare enum ActionSubject {
+    BUTTON = "button",
+    AUTOCOMPLETE_OPTION = "autocompleteOption",
+    ERROR_MESSAGE = "errorMessage"
+}
+export declare enum ActionSubjectId {
+    EDITOR_EXPAND = "jqlEditorExpand",
+    EDITOR_SEARCH = "jqlEditorSearch",
+    EDITOR_HELP = "jqlEditorHelp",
+    JQL_RESULT = "jqlResult"
+}

package/dist/types/analytics/index.d.ts

@@ -0,0 +1,7 @@
+export { ANALYTICS_CHANNEL, EventType, useJqlPackageAnalytics, } from '@atlaskit/jql-editor-common';
+export type { AnalyticsAttributes, JqlAnalyticsEvent, } from '@atlaskit/jql-editor-common';
+export { ActionSubject, ActionSubjectId, Action } from './constants';
+export { JQLEditorAnalyticsListener } from './listener';
+export type { ListenerProps } from './listener';
+export type { JqlEditorAnalyticsEvent } from './types';
+export { useJqlEditorAnalytics } from './util';

package/dist/types/analytics/listener/analytics-web-client-wrapper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copied from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src/analytics-web-client-wrapper.ts
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+import { GasPayload, GasScreenEventPayload } from '@atlaskit/analytics-gas-types';
+import Logger from './helpers/logger';
+import { AnalyticsWebClient } from './types';
+export declare const sendEvent: (logger: Logger, client?: AnalyticsWebClient | Promise<AnalyticsWebClient>) => (event: GasPayload | GasScreenEventPayload) => void;

package/dist/types/analytics/listener/handle-event.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Adapted from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src/fabric/handle-event.tsx
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import Logger from './helpers/logger';
+import { AnalyticsWebClient } from './types';
+export declare const handleEvent: (event: UIAnalyticsEvent, logger: Logger, client?: AnalyticsWebClient | Promise<AnalyticsWebClient>) => void;

package/dist/types/analytics/listener/helpers/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copied from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src/helpers/logger.ts
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+export declare const LOG_LEVEL: {
+    DEBUG: number;
+    INFO: number;
+    WARN: number;
+    ERROR: number;
+    OFF: number;
+};
+export default class Logger {
+    logLevel: number;
+    constructor({ logLevel }?: {
+        logLevel?: number;
+    });
+    setLogLevel(logLevel: number): void;
+    logMessage(level: number, type: keyof Pick<Console, 'log' | 'info' | 'warn' | 'error'>, ...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}

package/dist/types/analytics/listener/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Files in this directory are adapted from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+export { default as JQLEditorAnalyticsListener } from './jql-editor-analytics-listener';
+export type { ListenerProps } from './jql-editor-analytics-listener';

package/dist/types/analytics/listener/jql-editor-analytics-listener.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapted from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src/fabric/FabricEditorListener.tsx
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+import React, { ReactNode } from 'react';
+import { UIAnalyticsEventHandler } from '@atlaskit/analytics-next';
+import Logger from './helpers/logger';
+import { AnalyticsWebClient } from './types';
+export type ListenerProps = {
+    children?: ReactNode;
+    client?: AnalyticsWebClient | Promise<AnalyticsWebClient>;
+    logLevel?: number;
+};
+export default class JQLEditorAnalyticsListener extends React.Component<ListenerProps> {
+    logger: Logger;
+    constructor(props: ListenerProps);
+    handleEventWrapper: UIAnalyticsEventHandler;
+    render(): JSX.Element;
+}

package/dist/types/analytics/listener/process-event-payload.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapted from https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/analytics/analytics-listeners/src/fabric/process-event-payload.tsx
+ * In future if this package is migrated into the Atlassian Frontend repo, then this code and related logic should be
+ * moved into @atlaskit/analytics-listeners.
+ */
+import { GasPayload, GasScreenEventPayload } from '@atlaskit/analytics-gas-types';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+export declare const processEventPayload: (event: UIAnalyticsEvent) => GasPayload | GasScreenEventPayload;

package/dist/types/analytics/listener/types.d.ts

@@ -0,0 +1,7 @@
+import { GasPurePayload, GasPureScreenEventPayload } from '@atlaskit/analytics-gas-types';
+export type AnalyticsWebClient = {
+    sendUIEvent: (event: GasPurePayload) => void;
+    sendOperationalEvent: (event: GasPurePayload) => void;
+    sendTrackEvent: (event: GasPurePayload) => void;
+    sendScreenEvent: (event: GasPureScreenEventPayload) => void;
+};

package/dist/types/analytics/types.d.ts

@@ -0,0 +1,3 @@
+import { JqlAnalyticsEvent } from '@atlaskit/jql-editor-common';
+import { Action, ActionSubject, ActionSubjectId } from './constants';
+export type JqlEditorAnalyticsEvent = JqlAnalyticsEvent<Action, ActionSubject, ActionSubjectId>;

package/dist/types/analytics/util.d.ts

@@ -0,0 +1,4 @@
+import { Action, ActionSubject, ActionSubjectId } from './constants';
+export declare const useJqlEditorAnalytics: (analyticsSource: string) => {
+    createAndFireAnalyticsEvent: (payload: import("@atlaskit/jql-editor-common").JqlAnalyticsEvent<Action, ActionSubject, ActionSubjectId>) => void;
+};

package/dist/types/async.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { JQLEditorProps } from './ui/types';
+export declare const JQLEditorAsync: (props: JQLEditorProps) => JSX.Element;

package/dist/types/commands/select-error-command/index.d.ts

@@ -0,0 +1,5 @@
+import { JQLEditorCommand } from '../../schema';
+/**
+ * A Prosemirror Command that will select the first JQL error in the query if present.
+ */
+export declare const selectErrorCommand: JQLEditorCommand;

package/dist/types/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const JQL_EDITOR_MAIN_ID = "jql-editor-main";
+export declare const JQL_EDITOR_AUTOCOMPLETE_ID = "jql-editor-autocomplete";
+export declare const JQL_EDITOR_INPUT_ID = "jql-editor-input";
+export declare const JQL_EDITOR_HELP_CONTENT_ID = "jql-editor-help-content";
+export declare const SYNTAX_HELP_DESCRIPTION_ID = "syntax-help-description";

package/dist/types/common/messages.d.ts

@@ -0,0 +1,7 @@
+export declare const commonMessages: {
+    unknownError: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types/common/styled.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const hiddenMixin: import("@emotion/react").SerializedStyles;
+export declare const TooltipContent: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;

package/dist/types/hooks/use-editor-theme/index.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+export type EditorTheme = {
+    /**
+     * The maximum number of rows that are visible in the default editor view.
+     */
+    defaultMaxRows: number;
+    /**
+     * `true` if the editor view is in the expanded state.
+     */
+    expanded: boolean;
+    /**
+     * The number of rows that are visible when the editor view is expanded.
+     */
+    expandedRows: number;
+    /**
+     * Toggle the editor view expanded state.
+     */
+    toggleExpanded: () => void;
+    /**
+     * `true` shows search button, other search related elements
+     * `false` to act as a text field
+     */
+    isSearch: boolean;
+    /**
+     * `false` matches AK's default field styling
+     * `true` matches AK's compact field styling, generally used for search purposes.
+     */
+    isCompact: boolean;
+};
+export declare const EditorThemeContext: import("react").Context<EditorTheme>;
+/**
+ * Hook to manage the theming state of the editor.
+ */
+export declare const useEditorTheme: ({ isSearch, isCompact, }: {
+    isSearch?: boolean | undefined;
+    isCompact?: boolean | undefined;
+}) => EditorTheme;
+export declare const useEditorThemeContext: () => EditorTheme;

package/dist/types/hooks/use-editor-view-has-infos/index.d.ts

@@ -0,0 +1 @@
+export declare const useEditorViewHasInfos: () => boolean;

package/dist/types/hooks/use-editor-view-has-warnings/index.d.ts

@@ -0,0 +1 @@
+export declare const useEditorViewHasWarnings: () => boolean;

package/dist/types/hooks/use-editor-view-is-invalid/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Determine if the editor view should be displayed in an invalid state. To determine if the editor is invalid we adopt
+ * the following rules:
+ * 1. Client errors are dynamic
+ *    a. If the user searches with invalid JQL then the invalid state is shown
+ *    b. If the user fixes the error the invalid state is cleared until their next search
+ * 2. External JQL errors are static
+ *    a. If an external error is provided (and the previous search contains no client errors) then the invalid state is
+ *    shown until their next search
+ */
+export declare const useEditorViewIsInvalid: () => boolean;