@atlaskit/jql-editor 4.0.0

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

@@ -0,0 +1,99 @@
+import React, { useMemo, useReducer } from 'react';
+import { createPortal } from 'react-dom';
+import { PortalActionsContext } from './context';
+const initialState = {
+  components: {},
+  containers: {}
+};
+const reducer = (state, action) => {
+  switch (action.type) {
+    case 'createPortal':
+      {
+        const {
+          key,
+          portalComponent,
+          container
+        } = action.payload;
+        return {
+          ...state,
+          components: {
+            ...state.components,
+            [key]: {
+              portalComponent,
+              container
+            }
+          }
+        };
+      }
+    case 'destroyPortal':
+      {
+        const {
+          [action.payload]: toDestroy,
+          ...components
+        } = state.components;
+        return {
+          ...state,
+          components
+        };
+      }
+    case 'registerPluginContainer':
+      {
+        const {
+          element,
+          containerKey
+        } = action.payload;
+        if (!element) {
+          return state;
+        }
+        return {
+          ...state,
+          containers: {
+            ...state.containers,
+            [containerKey]: element
+          }
+        };
+      }
+    default:
+      {
+        return state;
+      }
+  }
+};
+
+/**
+ * Provides actions to manage portals via context and renders portalled components into the React tree.
+ */
+export const JQLEditorPortalRenderer = ({
+  children
+}) => {
+  const [state, dispatch] = useReducer(reducer, initialState);
+  const actionsContext = useMemo(() => {
+    return {
+      onCreatePortal: (key, portalComponent, container) => dispatch({
+        type: 'createPortal',
+        payload: {
+          key,
+          portalComponent,
+          container
+        }
+      }),
+      onDestroyPortal: key => dispatch({
+        type: 'destroyPortal',
+        payload: key
+      }),
+      onRegisterPluginContainer: (containerKey, element) => dispatch({
+        type: 'registerPluginContainer',
+        payload: {
+          containerKey,
+          element
+        }
+      })
+    };
+  }, [dispatch]);
+  return /*#__PURE__*/React.createElement(PortalActionsContext.Provider, {
+    value: actionsContext
+  }, children, Object.entries(state.components).map(([key, value]) => {
+    const container = value.container instanceof Element ? value.container : state.containers[value.container];
+    return container !== undefined ? /*#__PURE__*/createPortal(value.portalComponent, container, key) : null;
+  }));
+};

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

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

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

@@ -0,0 +1,167 @@
+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.
+ */
+const JQLEditorView = ({
+  inputRef
+}) => {
+  const [editorView, {
+    initialiseEditorView,
+    updateEditorView
+  }] = useEditorView();
+  const editorViewNodeRef = useRef(null);
+  const [mainId] = useScopedId(JQL_EDITOR_MAIN_ID);
+  const [autocompleteId] = useScopedId(JQL_EDITOR_AUTOCOMPLETE_ID);
+  const [editorId] = useScopedId(JQL_EDITOR_INPUT_ID);
+  const [helpContentId] = useScopedId(JQL_EDITOR_HELP_CONTENT_ID);
+  const [intl] = useIntl();
+  const portalActions = usePortalActionsContext();
+  const [, {
+    setEditorViewContainer,
+    setEditorViewContainerScroll
+  }] = useStoreActions();
+  const [editorViewHasFocus, {
+    onEditorViewBlur,
+    onEditorViewFocus
+  }] = useEditorViewHasFocus();
+  const [lineNumbersVisible] = useLineNumbersVisible();
+  const [{
+    selectedOptionId
+  }] = useAutocomplete();
+  const [isAutocompleteOpen] = useAutocompleteIsOpen();
+  const editorViewIsInvalid = useEditorViewIsInvalid();
+  const {
+    expanded
+  } = useEditorThemeContext();
+  const previousExpanded = useRef(expanded);
+  const onEditorViewTransitionEnd = useCallback(() => {
+    if (!expanded && editorViewNodeRef.current) {
+      // Clear any fixed heights when the editor is collapsed
+      editorViewNodeRef.current.style.height = '';
+    }
+  }, [expanded, editorViewNodeRef]);
+  const onMainRef = useCallback(element => portalActions.onRegisterPluginContainer('main', element), [portalActions]);
+  const onEditorViewContainerRef = useCallback(editorViewContainer => {
+    if (editorViewContainer) {
+      setEditorViewContainer(editorViewContainer);
+    }
+  }, [setEditorViewContainer]);
+  const throttledSetEditorViewContainerScroll = useMemo(() => throttle(scrollTop => {
+    setEditorViewContainerScroll(scrollTop);
+  }, 1000 / 60),
+  // 60 fps
+  [setEditorViewContainerScroll]);
+  const onEditorViewContainerScroll = useCallback(event => {
+    const {
+      scrollTop
+    } = event.currentTarget;
+    throttledSetEditorViewContainerScroll(scrollTop);
+  }, [throttledSetEditorViewContainerScroll]);
+
+  // Compute HTML attributes to be applied to the Prosemirror editor view
+  const getAttributes = useCallback(() => {
+    return {
+      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': `${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(() => {
+    updateEditorView(getAttributes());
+  }, [getAttributes, updateEditorView]);
+  const onEditorViewRef = useCallback(editorViewNode => {
+    if (editorViewNode && !editorView) {
+      initialiseEditorView(editorViewNode, getAttributes(), portalActions);
+      editorViewNodeRef.current = editorViewNode;
+    }
+  }, [editorView, initialiseEditorView, getAttributes, portalActions]);
+  useEffect(() => {
+    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(() => {
+          if (editorViewNodeRef.current) {
+            editorViewNodeRef.current.style.height = '';
+            editorViewNodeRef.current.setAttribute('data-expanded', 'true');
+          }
+        });
+      } else {
+        if (editorView) {
+          requestAnimationFrame(() => {
+            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, () => ({
+    focus: () => {
+      if (editorView) {
+        editorView.focus();
+      }
+    }
+  }));
+  useEffect(() => {
+    return () => {
+      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/es2019/ui/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const 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/es2019/ui/tooltip-tag/index.js

@@ -0,0 +1,8 @@
+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 const TooltipTag = /*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/React.createElement(StyledTooltipTag, _extends({
+  ref: ref
+}, props)));

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

@@ -0,0 +1,4 @@
+import styled from '@emotion/styled';
+export const StyledTooltipTag = styled.div`
+  display: flex;
+`;

package/dist/es2019/ui/types.js

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

package/dist/es2019/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 const 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 const 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).
+ */
+const textBetween = (fragment, from, to, blockSeparator, leafText) => {
+  let text = '';
+  let enteredInitialBlock = false;
+  fragment.nodesBetween(from, to, (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/es2019/utils/split-text-by-new-line/index.js

@@ -0,0 +1,4 @@
+/**
+ * Splits the provided text by new line characters.
+ */
+export const splitTextByNewLine = text => text.split(/(?:\r\n?|\n)/);

package/dist/esm/accessibility/index.js

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

package/dist/esm/accessibility/styled.js

@@ -0,0 +1,5 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+var _templateObject;
+import styled from '@emotion/styled';
+import { hiddenMixin } from '../common/styled';
+export var ScreenReaderText = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  ", "\n"])), hiddenMixin);

package/dist/esm/analytics/constants.js

@@ -0,0 +1,21 @@
+export var Action = /*#__PURE__*/function (Action) {
+  Action["CLICKED"] = "clicked";
+  Action["RETRIEVE_FAILED"] = "retrieveFailed";
+  Action["RETRIEVED"] = "retrieved";
+  Action["SELECTED"] = "selected";
+  Action["VIEWED"] = "viewed";
+  return Action;
+}({});
+export var ActionSubject = /*#__PURE__*/function (ActionSubject) {
+  ActionSubject["BUTTON"] = "button";
+  ActionSubject["AUTOCOMPLETE_OPTION"] = "autocompleteOption";
+  ActionSubject["ERROR_MESSAGE"] = "errorMessage";
+  return ActionSubject;
+}({});
+export var ActionSubjectId = /*#__PURE__*/function (ActionSubjectId) {
+  ActionSubjectId["EDITOR_EXPAND"] = "jqlEditorExpand";
+  ActionSubjectId["EDITOR_SEARCH"] = "jqlEditorSearch";
+  ActionSubjectId["EDITOR_HELP"] = "jqlEditorHelp";
+  ActionSubjectId["JQL_RESULT"] = "jqlResult";
+  return ActionSubjectId;
+}({});

package/dist/esm/analytics/index.js

@@ -0,0 +1,5 @@
+// Re-export common types for consumer convenience
+export { ANALYTICS_CHANNEL, EventType, useJqlPackageAnalytics } from '@atlaskit/jql-editor-common';
+export { ActionSubject, ActionSubjectId, Action } from './constants';
+export { JQLEditorAnalyticsListener } from './listener';
+export { useJqlEditorAnalytics } from './util';

package/dist/esm/analytics/listener/analytics-web-client-wrapper.js

@@ -0,0 +1,70 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * 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.
+ */
+
+var isPromise = function isPromise(c) {
+  return typeof c.then === 'function';
+};
+export var sendEvent = function sendEvent(logger, client) {
+  return function (event) {
+    if (client) {
+      var gasEvent = _objectSpread({}, event);
+      /*
+      Merging this ts-ignore is not going to affect the type definitions of the package
+      there's a whole lot more wrong going on here than just this delete.
+      All the send methods on the client take a GasPurePayload object which requires actionSubject
+      actionSubject is missing on GasPayload | GasScreenEventPayload
+      */
+      // @ts-ignore mergeable @fixme TypeScript 4.2.4 upgrade
+      delete gasEvent.eventType;
+      var withClient = function withClient(cb) {
+        if (isPromise(client)) {
+          client.then(cb).catch(function (e) {
+            return logger.warn('There was an error sending the event', e);
+          });
+        } else {
+          try {
+            cb(client);
+          } catch (e) {
+            logger.warn('There was an error sending the event', e);
+          }
+        }
+      };
+      switch (event.eventType) {
+        case 'ui':
+          logger.debug('Sending UI Event via analytics client', gasEvent);
+          withClient(function (client) {
+            return client.sendUIEvent(gasEvent);
+          });
+          break;
+        case 'operational':
+          logger.debug('Sending Operational Event via analytics client', gasEvent);
+          withClient(function (client) {
+            return client.sendOperationalEvent(gasEvent);
+          });
+          break;
+        case 'track':
+          logger.debug('Sending Track Event via analytics client', gasEvent);
+          withClient(function (client) {
+            return client.sendTrackEvent(gasEvent);
+          });
+          break;
+        case 'screen':
+          logger.debug('Sending Screen Event via analytics client', gasEvent);
+          withClient(function (client) {
+            return client.sendScreenEvent(gasEvent);
+          });
+          break;
+        default:
+          logger.error("cannot map eventType ".concat(event.eventType, " to an analytics-web-client function"));
+      }
+    } else {
+      logger.warn('AnalyticsWebClient instance is not provided');
+    }
+  };
+};

package/dist/esm/analytics/listener/handle-event.js

@@ -0,0 +1,15 @@
+/**
+ * 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 { sendEvent } from './analytics-web-client-wrapper';
+import { processEventPayload } from './process-event-payload';
+export var handleEvent = function handleEvent(event, logger, client) {
+  if (!event.payload) {
+    return;
+  }
+  var payload = processEventPayload(event);
+  sendEvent(logger, client)(payload);
+};

package/dist/esm/analytics/listener/helpers/logger.js

@@ -0,0 +1,83 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/**
+ * 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 var LOG_LEVEL = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  OFF: 4
+};
+var Logger = /*#__PURE__*/function () {
+  function Logger() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      logLevel = _ref.logLevel;
+    _classCallCheck(this, Logger);
+    _defineProperty(this, "logLevel", LOG_LEVEL.OFF);
+    if (typeof logLevel === 'number') {
+      this.setLogLevel(logLevel);
+    }
+  }
+  _createClass(Logger, [{
+    key: "setLogLevel",
+    value: function setLogLevel(logLevel) {
+      if (logLevel >= LOG_LEVEL.DEBUG && logLevel <= LOG_LEVEL.OFF) {
+        this.logLevel = +logLevel;
+      } else {
+        this.logLevel = LOG_LEVEL.OFF;
+      }
+    }
+  }, {
+    key: "logMessage",
+    value: function logMessage(level, type) {
+      if (level >= this.logLevel) {
+        var _console;
+        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          args[_key - 2] = arguments[_key];
+        }
+        // eslint-disable-next-line no-console
+        (_console = console)[type].apply(_console, args);
+      }
+    }
+  }, {
+    key: "debug",
+    value: function debug() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      this.logMessage.apply(this, [LOG_LEVEL.DEBUG, 'log'].concat(args));
+    }
+  }, {
+    key: "info",
+    value: function info() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      this.logMessage.apply(this, [LOG_LEVEL.INFO, 'info'].concat(args));
+    }
+  }, {
+    key: "warn",
+    value: function warn() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      this.logMessage.apply(this, [LOG_LEVEL.WARN, 'warn'].concat(args));
+    }
+  }, {
+    key: "error",
+    value: function error() {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+      this.logMessage.apply(this, [LOG_LEVEL.ERROR, 'error'].concat(args));
+    }
+  }]);
+  return Logger;
+}();
+export { Logger as default };

package/dist/esm/analytics/listener/index.js

@@ -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';

package/dist/esm/analytics/listener/jql-editor-analytics-listener.js

@@ -0,0 +1,48 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/**
+ * 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 from 'react';
+import { AnalyticsListener } from '@atlaskit/analytics-next';
+import { ANALYTICS_CHANNEL } from '@atlaskit/jql-editor-common';
+import { handleEvent } from './handle-event';
+import Logger from './helpers/logger';
+// eslint-disable-next-line @repo/internal/react/no-class-components
+var JQLEditorAnalyticsListener = /*#__PURE__*/function (_React$Component) {
+  _inherits(JQLEditorAnalyticsListener, _React$Component);
+  var _super = _createSuper(JQLEditorAnalyticsListener);
+  function JQLEditorAnalyticsListener(props) {
+    var _this;
+    _classCallCheck(this, JQLEditorAnalyticsListener);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "handleEventWrapper", function (event) {
+      handleEvent(event, _this.logger, _this.props.client);
+    });
+    _this.logger = new Logger({
+      logLevel: props.logLevel
+    });
+    return _this;
+  }
+  _createClass(JQLEditorAnalyticsListener, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(AnalyticsListener, {
+        onEvent: this.handleEventWrapper,
+        channel: ANALYTICS_CHANNEL
+      }, this.props.children);
+    }
+  }]);
+  return JQLEditorAnalyticsListener;
+}(React.Component);
+export { JQLEditorAnalyticsListener as default };

package/dist/esm/analytics/listener/process-event-payload.js

@@ -0,0 +1,39 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * 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 merge from 'lodash/merge';
+import { DEFAULT_SOURCE } from '@atlaskit/analytics-gas-types';
+var extractFieldsFromContext = function extractFieldsFromContext(fieldsToPick) {
+  return function (contexts) {
+    return contexts.map(function (ctx) {
+      return fieldsToPick.reduce(function (result, key) {
+        return ctx[key] ? merge(result, _defineProperty({}, key, ctx[key])) : result;
+      }, {});
+    }).reduce(function (result, item) {
+      return merge(result, item);
+    }, {});
+  };
+};
+var fieldExtractor = function fieldExtractor() {
+  return extractFieldsFromContext(['source', 'objectType', 'objectId', 'containerType', 'containerId']);
+};
+var updatePayloadWithContext = function updatePayloadWithContext(event) {
+  if (event.context.length === 0) {
+    return _objectSpread({
+      source: DEFAULT_SOURCE
+    }, event.payload);
+  }
+  var fields = fieldExtractor()(event.context);
+  return _objectSpread(_objectSpread({
+    source: DEFAULT_SOURCE
+  }, fields), event.payload);
+};
+export var processEventPayload = function processEventPayload(event) {
+  return updatePayloadWithContext(event);
+};

package/dist/esm/analytics/listener/types.js

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

package/dist/esm/analytics/types.js

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

package/dist/esm/analytics/util.js

@@ -0,0 +1,4 @@
+import { ANALYTICS_CHANNEL, useJqlPackageAnalytics } from '@atlaskit/jql-editor-common';
+export var useJqlEditorAnalytics = function useJqlEditorAnalytics(analyticsSource) {
+  return useJqlPackageAnalytics(analyticsSource, "@atlaskit/jql-editor", "4.0.0", ANALYTICS_CHANNEL);
+};