@atlaskit/jql-editor 4.0.0

package/dist/cjs/plugins/rich-inline-nodes/util/react-node-view.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReactNodeView = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _Subject = require("rxjs/Subject");
+var _uuid = require("uuid");
+var _state = require("../../../state");
+var _constants = require("../constants");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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) { (0, _defineProperty2.default)(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; }
+var ReactNodeView = exports.ReactNodeView = /*#__PURE__*/function () {
+  function ReactNodeView(component, portalActions, _node) {
+    var _this = this;
+    (0, _classCallCheck2.default)(this, ReactNodeView);
+    (0, _defineProperty2.default)(this, "componentSubject", new _Subject.Subject());
+    (0, _defineProperty2.default)(this, "init", function (decorations) {
+      var Component = _this.component;
+      var PortallingComponent = function PortallingComponent() {
+        var _useState = (0, _react.useState)(_objectSpread(_objectSpread({}, _this.getProps(_this.node)), {}, {
+            selected: _this.isSelected(decorations),
+            error: _this.hasError(decorations)
+          })),
+          _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+          state = _useState2[0],
+          setState = _useState2[1];
+
+        // ProseMirror keeps decorations on blur (as those are derived from editor state and focus isn't part of it),
+        // but we don't want to show node views as selected when that happens. We could build a workaround for this in
+        // richInlineNodesPlugin, but this hook will make selection behave more consistently with other focus-related features.
+        var _useEditorViewHasFocu = (0, _state.useEditorViewHasFocus)(),
+          _useEditorViewHasFocu2 = (0, _slicedToArray2.default)(_useEditorViewHasFocu, 1),
+          hasFocus = _useEditorViewHasFocu2[0];
+        (0, _react.useEffect)(function () {
+          // Subscribe to the RxJS subject so concrete subclasses can emit events to re-render the node view component
+          var subscription = _this.componentSubject.subscribe(function (props) {
+            setState(props);
+          });
+          return function () {
+            return subscription.unsubscribe();
+          };
+        }, []);
+        (0, _react.useLayoutEffect)(function () {
+          if (state.error) {
+            _this.dom.dataset.tokenType = 'error';
+          } else {
+            delete _this.dom.dataset.tokenType;
+          }
+        }, [state]);
+        return /*#__PURE__*/_react.default.createElement(Component, (0, _extends2.default)({}, state, {
+          selected: state.selected && hasFocus
+        }));
+      };
+
+      // Ok, this is a tricky one. As everything that requires collaboration between ProseMirror and React.
+      //
+      // If we run `onCreatePortal` synchronously, ProseMirror won't insert the node view container (`this.dom`)
+      // immediately into the DOM (as init function hasn't returned yet). This can trigger race conditions in other
+      // code paths where ProseMirror may try to get DOM position for this node view before it has been inserted
+      // (e.g. calculating new autocomplete position after insertion, or setting selection after the node).
+      //
+      // With `queueMicrotask` we can schedule this operation to be run after ProseMirror is done with the element
+      // insertion, but before control of the execution context is returned to the browser's event loop. This should
+      // prevent all conflicts with other pieces of asynchronous code and still render the portal as soon as it is
+      // practically possible, so we can avoid flicker in situations where node views are reconstructed by ProseMirror.
+      // @see https://github.com/ProseMirror/prosemirror/issues/872
+      queueMicrotask(function () {
+        _this.portalActions.onCreatePortal(_this.portalKey, /*#__PURE__*/_react.default.createElement(PortallingComponent, null), _this.dom);
+      });
+      return _this;
+    });
+    (0, _defineProperty2.default)(this, "destroy", function () {
+      _this.portalActions.onDestroyPortal(_this.portalKey);
+    });
+    (0, _defineProperty2.default)(this, "update", function (node, decorations) {
+      // Update function may be called by ProseMirror with a node that has nothing to do with this node view ¯\_(ツ)_/¯
+      // @see https://prosemirror.net/docs/ref/#view.NodeView.update
+      if (node !== _this.node) {
+        return false;
+      }
+      _this.componentSubject.next(_objectSpread(_objectSpread({}, _this.getProps(node)), {}, {
+        selected: _this.isSelected(decorations),
+        error: _this.hasError(decorations)
+      }));
+      return true;
+    });
+    (0, _defineProperty2.default)(this, "getProps", function (node) {
+      return _objectSpread({}, node.attrs);
+    });
+    (0, _defineProperty2.default)(this, "isSelected", function (decorations) {
+      return decorations.some(function (decoration) {
+        return decoration.spec.type === _constants.SELECTED_NODE;
+      });
+    });
+    (0, _defineProperty2.default)(this, "hasError", function (decorations) {
+      return decorations.some(function (decoration) {
+        return decoration.spec.type === _constants.ERROR_NODE;
+      });
+    });
+    this.component = component;
+    this.portalActions = portalActions;
+    this.node = _node;
+    // Generate unique portal identifier
+    // If you read this comment in the future and TypeScript has added support for Symbols as object keys, please do
+    // JQL Editor a favor and replace this library with the native JS functionality that TS was supposed to support.
+    this.portalKey = (0, _uuid.v4)();
+    // Creating span under the assumption that all node views will be inline elements in JQL Editor
+    this.dom = document.createElement('span');
+    this.dom.setAttribute('data-testid', 'jql-editor-node-view');
+  }
+  (0, _createClass2.default)(ReactNodeView, null, [{
+    key: "for",
+    value: function _for(component, portalActions, node, decorations) {
+      return new ReactNodeView(component, portalActions, node).init(decorations);
+    }
+  }]);
+  return ReactNodeView;
+}();

package/dist/cjs/plugins/rich-inline-nodes/util/replace-nodes-transaction.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceRichInlineNodes = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _jqlAst = require("@atlaskit/jql-ast");
+var _schema = require("../../../schema");
+var _getDocumentPosition = _interopRequireDefault(require("../../common/get-document-position"));
+var _jqlAst2 = require("../../jql-ast");
+var _constants = require("../constants");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+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) { (0, _defineProperty2.default)(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; }
+var replaceRichInlineNodes = exports.replaceRichInlineNodes = function replaceRichInlineNodes(editorState, hydratedValues) {
+  var ast = (0, _jqlAst2.getJastFromState)(editorState);
+  var transaction = editorState.tr;
+  // Do not allow users to revert this transaction with undo command so they can't land in an unhydrated state
+  transaction.setMeta('addToHistory', false);
+  Object.entries(hydratedValues).forEach(function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      fieldName = _ref2[0],
+      values = _ref2[1];
+    values.forEach(function (value) {
+      if (value.type === 'user') {
+        var astNodes = getValueNodes(ast, fieldName, value.id);
+        astNodes.forEach(function (astNode) {
+          if (astNode.position) {
+            var _astNode$position = (0, _slicedToArray2.default)(astNode.position, 2),
+              from = _astNode$position[0],
+              to = _astNode$position[1];
+            var documentFrom = (0, _getDocumentPosition.default)(transaction.doc, from);
+            if (!isRichInlineNode(transaction.doc, documentFrom)) {
+              var documentTo = (0, _getDocumentPosition.default)(transaction.doc, to);
+              var node = getRichInlineNode(fieldName, value, astNode.text);
+              transaction.replaceWith(documentFrom, documentTo, node);
+            }
+          }
+        });
+      }
+    });
+  });
+  return transaction;
+};
+var getRichInlineNode = function getRichInlineNode(fieldName, value, text) {
+  switch (value.type) {
+    case 'user':
+      {
+        var textContent = _schema.JQLEditorSchema.text(text);
+        return _schema.JQLEditorSchema.nodes.user.create(_objectSpread(_objectSpread({}, value), {}, {
+          fieldName: fieldName
+        }), textContent);
+      }
+    default:
+      {
+        throw new Error("Unsupported hydrated value type ".concat(value.type));
+      }
+  }
+};
+var isRichInlineNode = function isRichInlineNode(doc, position) {
+  var _doc$resolve$nodeAfte;
+  return ((_doc$resolve$nodeAfte = doc.resolve(position).nodeAfter) === null || _doc$resolve$nodeAfte === void 0 ? void 0 : _doc$resolve$nodeAfte.type.spec.group) === _constants.RICH_INLINE_NODE;
+};
+var getValueNodes = function getValueNodes(ast, field, value) {
+  if (!ast.query) {
+    return [];
+  }
+  return ast.query.accept(new FindValuesVisitor(field, value));
+};
+var FindValuesVisitor = /*#__PURE__*/function (_AbstractJastVisitor) {
+  (0, _inherits2.default)(FindValuesVisitor, _AbstractJastVisitor);
+  var _super = _createSuper(FindValuesVisitor);
+  function FindValuesVisitor(field, value) {
+    var _this;
+    (0, _classCallCheck2.default)(this, FindValuesVisitor);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitQuery", function (query) {
+      if (query.where === undefined) {
+        return [];
+      }
+      return query.where.accept((0, _assertThisInitialized2.default)(_this));
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitCompoundClause", function (compoundClause) {
+      return compoundClause.clauses.reduce(function (operands, compoundClause) {
+        return [].concat((0, _toConsumableArray2.default)(operands), (0, _toConsumableArray2.default)(compoundClause.accept((0, _assertThisInitialized2.default)(_this))));
+      }, []);
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitTerminalClause", function (terminalClause) {
+      if (terminalClause.field.value !== _this.field) {
+        return [];
+      }
+      if (terminalClause.operand === undefined) {
+        return [];
+      }
+      return terminalClause.operand.accept((0, _assertThisInitialized2.default)(_this));
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitNotClause", function (notClause) {
+      return notClause.clause.accept((0, _assertThisInitialized2.default)(_this));
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitValueOperand", function (valueOperand) {
+      if (valueOperand.value !== _this.value) {
+        return [];
+      }
+      return [valueOperand];
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "visitListOperand", function (listOperand) {
+      return listOperand.values.reduce(function (values, operand) {
+        return [].concat((0, _toConsumableArray2.default)(values), (0, _toConsumableArray2.default)(operand.accept((0, _assertThisInitialized2.default)(_this))));
+      }, []);
+    });
+    _this.field = field;
+    _this.value = value;
+    return _this;
+  }
+  (0, _createClass2.default)(FindValuesVisitor, [{
+    key: "aggregateResult",
+    value: function aggregateResult(aggregate, nextResult) {
+      return [].concat((0, _toConsumableArray2.default)(aggregate), (0, _toConsumableArray2.default)(nextResult));
+    }
+  }, {
+    key: "defaultResult",
+    value: function defaultResult() {
+      return [];
+    }
+  }]);
+  return FindValuesVisitor;
+}(_jqlAst.AbstractJastVisitor);

package/dist/cjs/plugins/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/plugins/validation-tooltip/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TOOLTIP_EXIT_CLASSNAME = exports.TOOLTIP_ENTER_CLASSNAME = exports.TOOLTIP_CLASSNAME = exports.JQLValidationTooltipPluginKey = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var JQLValidationTooltipPluginKey = exports.JQLValidationTooltipPluginKey = new _state.PluginKey('jql-validation-tooltip-plugin');
+var TOOLTIP_CLASSNAME = exports.TOOLTIP_CLASSNAME = 'jql-validation-tooltip';
+var TOOLTIP_ENTER_CLASSNAME = exports.TOOLTIP_ENTER_CLASSNAME = 'jql-validation-tooltip-enter';
+var TOOLTIP_EXIT_CLASSNAME = exports.TOOLTIP_EXIT_CLASSNAME = 'jql-validation-tooltip-exit';

package/dist/cjs/plugins/validation-tooltip/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _constants = require("./constants");
+var _view = require("./view");
+var validationTooltipPlugin = function validationTooltipPlugin(mainId) {
+  var plugin = new _state.Plugin({
+    key: _constants.JQLValidationTooltipPluginKey,
+    view: function view() {
+      return new _view.ValidationTooltipPluginView(mainId);
+    },
+    state: {
+      init: function init() {
+        return false;
+      },
+      // @ts-ignore
+      apply: function apply(tr, value) {
+        if (tr.getMeta(plugin) !== undefined) {
+          return tr.getMeta(plugin);
+        } else {
+          return value;
+        }
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        mouseover: function mouseover(_ref, event) {
+          var state = _ref.state,
+            dispatch = _ref.dispatch;
+          var isHovered = plugin.getState(state);
+          if (event.target instanceof Element && event.target.closest('[data-token-type="error"]')) {
+            if (!isHovered) {
+              dispatch(state.tr.setMeta(plugin, true));
+            }
+          } else if (isHovered) {
+            dispatch(state.tr.setMeta(plugin, false));
+          }
+          return false;
+        },
+        mouseleave: function mouseleave(_ref2) {
+          var state = _ref2.state,
+            dispatch = _ref2.dispatch;
+          var isHovered = plugin.getState(state);
+          if (isHovered) {
+            dispatch(state.tr.setMeta(plugin, false));
+          }
+          return false;
+        }
+      }
+    }
+  });
+  return plugin;
+};
+var _default = exports.default = validationTooltipPlugin;

package/dist/cjs/plugins/validation-tooltip/view.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationTooltipPluginView = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _jqlAst = require("@atlaskit/jql-ast");
+var _getDocumentPosition = _interopRequireDefault(require("../common/get-document-position"));
+var _jqlAst2 = require("../jql-ast");
+var _constants = require("./constants");
+var ValidationTooltipPluginView = exports.ValidationTooltipPluginView = /*#__PURE__*/function () {
+  function ValidationTooltipPluginView(mainId) {
+    var _this = this,
+      _document$getElementB;
+    (0, _classCallCheck2.default)(this, ValidationTooltipPluginView);
+    (0, _defineProperty2.default)(this, "showTooltip", function (error, start, end) {
+      var _this$tooltip$offsetP, _box$left, _box$top;
+      // Find a center position from the selection endpoints
+      var left = (start.left + end.left) / 2;
+
+      // The box in which the container is positioned, to use as base
+      var box = (_this$tooltip$offsetP = _this.tooltip.offsetParent) === null || _this$tooltip$offsetP === void 0 ? void 0 : _this$tooltip$offsetP.getBoundingClientRect();
+      _this.tooltip.style.left = "".concat(left - ((_box$left = box === null || box === void 0 ? void 0 : box.left) !== null && _box$left !== void 0 ? _box$left : 0), "px");
+      _this.tooltip.style.top = "".concat(start.top - ((_box$top = box === null || box === void 0 ? void 0 : box.top) !== null && _box$top !== void 0 ? _box$top : 0), "px");
+      _this.tooltip.textContent = error.message;
+      _this.tooltip.classList.remove(_constants.TOOLTIP_EXIT_CLASSNAME);
+      _this.tooltip.classList.add(_constants.TOOLTIP_ENTER_CLASSNAME);
+    });
+    (0, _defineProperty2.default)(this, "hideTooltip", function () {
+      _this.tooltip.classList.remove(_constants.TOOLTIP_ENTER_CLASSNAME);
+      _this.tooltip.classList.add(_constants.TOOLTIP_EXIT_CLASSNAME);
+    });
+    this.tooltip = document.createElement('div');
+    this.tooltip.setAttribute('data-testid', 'jql-validation-tooltip');
+    this.tooltip.classList.add(_constants.TOOLTIP_CLASSNAME);
+    (_document$getElementB = document.getElementById(mainId)) === null || _document$getElementB === void 0 || _document$getElementB.appendChild(this.tooltip);
+  }
+  (0, _createClass2.default)(ValidationTooltipPluginView, [{
+    key: "update",
+    value: function update(view, lastState) {
+      var state = view.state;
+      var isHovered = _constants.JQLValidationTooltipPluginKey.getState(state);
+      var lastIsHovered = _constants.JQLValidationTooltipPluginKey.getState(lastState);
+      var jast = (0, _jqlAst2.getJastFromState)(state);
+      var _jast$errors = (0, _slicedToArray2.default)(jast.errors, 1),
+        error = _jast$errors[0];
+      if (isHovered === lastIsHovered) {
+        return;
+      }
+      if (isHovered) {
+        if (error instanceof _jqlAst.JQLSyntaxError) {
+          var start = (0, _getDocumentPosition.default)(state.doc, error.start);
+          var stop = (0, _getDocumentPosition.default)(state.doc, error.stop);
+          var startCoords = view.coordsAtPos(start);
+          var stopCoords = view.coordsAtPos(stop);
+          this.showTooltip(error, startCoords, stopCoords);
+        }
+      } else {
+        this.hideTooltip();
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.tooltip.remove();
+    }
+  }]);
+  return ValidationTooltipPluginView;
+}();

package/dist/cjs/schema/index.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultEditorState = exports.configurePlugins = exports.clipboardTextSerializer = exports.clipboardTextParser = exports.JQLEditorSchema = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _mapValues = _interopRequireDefault(require("lodash/mapValues"));
+var _commands = require("@atlaskit/editor-prosemirror/commands");
+var _history = require("@atlaskit/editor-prosemirror/history");
+var _keymap = require("@atlaskit/editor-prosemirror/keymap");
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _plugins = require("../plugins");
+var _constants = require("../plugins/rich-inline-nodes/constants");
+var _nodes = require("../plugins/rich-inline-nodes/nodes");
+var _createNodeSpec = require("../plugins/rich-inline-nodes/util/create-node-spec");
+var _documentText = require("../utils/document-text");
+var _splitTextByNewLine = require("../utils/split-text-by-new-line");
+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) { (0, _defineProperty2.default)(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; }
+var createMarkWithStyle = function createMarkWithStyle(tokenType) {
+  var mark = document.createElement('span');
+  mark.className = "mark-token-".concat(tokenType);
+  mark.setAttribute('data-token-type', tokenType);
+  mark.setAttribute('spellcheck', 'false');
+  return mark;
+};
+var JQLEditorSchema = exports.JQLEditorSchema = new _model.Schema({
+  nodes: _objectSpread({
+    doc: {
+      content: 'paragraph+'
+    },
+    paragraph: {
+      content: "(text|".concat(_constants.RICH_INLINE_NODE, ")*"),
+      toDOM: function toDOM() {
+        return ['p', {
+          spellcheck: 'false'
+        }, 0];
+      },
+      parseDOM: [{
+        tag: 'p'
+      }]
+    },
+    text: {}
+  }, (0, _mapValues.default)(_nodes.richInlineNodes, function (spec, name) {
+    return (0, _createNodeSpec.createNodeSpec)(name, spec.attrs);
+  })),
+  marks: {
+    token: {
+      toDOM: function toDOM(_ref) {
+        var attrs = _ref.attrs;
+        return createMarkWithStyle(attrs.tokenType);
+      },
+      attrs: {
+        tokenType: {}
+      }
+    },
+    cursor: {
+      toDOM: function toDOM() {
+        return document.createElement('span');
+      }
+    }
+  }
+});
+var domParser = _model.DOMParser.fromSchema(JQLEditorSchema);
+
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer but
+ * preserves consecutive empty block nodes.
+ */
+var clipboardTextSerializer = exports.clipboardTextSerializer = function clipboardTextSerializer(slice) {
+  return (0, _documentText.getFragmentText)(slice.content, 0, slice.content.size);
+};
+
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextParser but
+ * preserves consecutive empty lines.
+ */
+var clipboardTextParser = exports.clipboardTextParser = function clipboardTextParser(text, $context) {
+  var dom = document.createElement('div');
+  // Split each line of text and wrap each in a p tag.
+  (0, _splitTextByNewLine.splitTextByNewLine)(text).forEach(function (block) {
+    dom.appendChild(document.createElement('p')).textContent = block;
+  });
+  return domParser.parseSlice(dom, {
+    context: $context,
+    preserveWhitespace: true
+  });
+};
+var defaultEditorState = exports.defaultEditorState = _state.EditorState.create({
+  schema: JQLEditorSchema
+});
+
+// @types/prosemirror-commands@1.0.1 does not export Command and Keymap types
+// TODO: update to Command<JQLEditorSchemaType> and Keymap<JQLEditorSchemaType> if types are bumped to a newer version
+
+var configurePlugins = exports.configurePlugins = function configurePlugins(editorState, onSearchCommand, intlRef, mainId, portalActions, enableRichInlineNodes) {
+  return editorState.reconfigure({
+    plugins: [(0, _history.history)(),
+    // Other plugins rely on having AST as part of the state during a transaction, this plugin should be kept first
+    (0, _plugins.jqlAstPlugin)(intlRef), (0, _plugins.jqlSyntaxHighlightingPlugin)()].concat((0, _toConsumableArray2.default)(portalActions !== undefined ? [(0, _plugins.autocompletePlugin)(portalActions, enableRichInlineNodes)].concat((0, _toConsumableArray2.default)(enableRichInlineNodes ? [(0, _plugins.richInlineNodesPlugin)(portalActions)] : [])) : []), [(0, _plugins.validationTooltipPlugin)(mainId),
+    // Keeping these at the bottom allows plugins to define custom key bindings to override default behavior
+    (0, _keymap.keymap)({
+      'Mod-z': _history.undo,
+      'Mod-Shift-z': _history.redo,
+      'Mod-y': _history.redo,
+      // Mimic default Enter behavior in PM's base keymap, allowing to insert new lines even when autocomplete is open
+      'Shift-Enter': _commands.baseKeymap.Enter
+    })], (0, _toConsumableArray2.default)(!onSearchCommand ? [] : [keymapNoRepeat({
+      'Mod-Enter': onSearchCommand,
+      Enter: onSearchCommand
+    })]), [(0, _keymap.keymap)(_commands.baseKeymap)])
+  });
+};
+var noopCommand = function noopCommand() {
+  return true;
+};
+function keymapNoRepeat(bindings) {
+  var handler = (0, _keymap.keydownHandler)(bindings);
+  var proxyBindings = (0, _mapValues.default)(bindings, function () {
+    return noopCommand;
+  });
+  var proxyHandler = (0, _keymap.keydownHandler)(proxyBindings);
+  return new _state.Plugin({
+    props: {
+      handleKeyDown: function handleKeyDown(view, event) {
+        if (event.repeat) {
+          return proxyHandler(view, event);
+        }
+        return handler(view, event);
+      }
+    }
+  });
+}

package/dist/cjs/state/analytics/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onStartAutocompleteEvent = exports.ANALYTICS_DEBOUNCE_MS = void 0;
+var _Subscription = require("rxjs/Subscription");
+var _analytics = require("../../analytics");
+var ANALYTICS_DEBOUNCE_MS = exports.ANALYTICS_DEBOUNCE_MS = 2000;
+var AUTOCOMPLETE_ANALYTICS_MEASURE = 'jql-editor-autocomplete';
+var onStartAutocompleteEvent = exports.onStartAutocompleteEvent = function onStartAutocompleteEvent() {
+  return function (_, _ref) {
+    var createAndFireAnalyticsEvent = _ref.createAndFireAnalyticsEvent;
+    performance.clearMeasures(AUTOCOMPLETE_ANALYTICS_MEASURE);
+    performance.clearMarks("".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+    performance.mark("".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+    var timeoutId = null;
+    var promise = new Promise(function (resolve) {
+      // Resolve the promise after a fixed debounce period
+      timeoutId = window.setTimeout(function () {
+        resolve();
+      }, ANALYTICS_DEBOUNCE_MS);
+    });
+
+    // Create a new subscription which will cancel the analytics promise when unsubscribed
+    var analyticsSubscription = new _Subscription.Subscription(function () {
+      timeoutId !== null && window.clearTimeout(timeoutId);
+    });
+    var onStopAutocompleteEvent = function onStopAutocompleteEvent(isSuccess, optionTypes, hasOptions) {
+      performance.measure(AUTOCOMPLETE_ANALYTICS_MEASURE, "".concat(AUTOCOMPLETE_ANALYTICS_MEASURE, "::start"));
+      var entry = performance.getEntriesByName(AUTOCOMPLETE_ANALYTICS_MEASURE).pop();
+      var duration = entry === null || entry === void 0 ? void 0 : entry.duration;
+
+      // Fire our analytics event once our autocomplete data is fetched AND our debounced promise is resolved
+      return promise.then(function () {
+        var attributes = {
+          optionTypes: optionTypes.sort(),
+          hasOptions: hasOptions
+        };
+        if (duration !== undefined) {
+          attributes.duration = duration;
+        }
+        createAndFireAnalyticsEvent({
+          action: isSuccess ? _analytics.Action.RETRIEVED : _analytics.Action.RETRIEVE_FAILED,
+          actionSubject: _analytics.ActionSubject.AUTOCOMPLETE_OPTION,
+          eventType: _analytics.EventType.OPERATIONAL,
+          attributes: attributes
+        });
+      });
+    };
+    return {
+      analyticsSubscription: analyticsSubscription,
+      onStopAutocompleteEvent: onStopAutocompleteEvent
+    };
+  };
+};

package/dist/cjs/state/autocomplete/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortOperators = exports.ORDERED_OPERATORS = void 0;
+var _map = require("rxjs/operators/map");
+var _jqlAst = require("@atlaskit/jql-ast");
+// Opinionated order in which we want to render operators
+var ORDERED_OPERATORS = exports.ORDERED_OPERATORS = [_jqlAst.OPERATOR_EQUALS, _jqlAst.OPERATOR_NOT_EQUALS, _jqlAst.OPERATOR_LIKE, _jqlAst.OPERATOR_NOT_LIKE, _jqlAst.OPERATOR_LT_EQUALS, _jqlAst.OPERATOR_GT_EQUALS, _jqlAst.OPERATOR_GT, _jqlAst.OPERATOR_LT, _jqlAst.OPERATOR_IS, _jqlAst.OPERATOR_IS_NOT, _jqlAst.OPERATOR_IN, _jqlAst.OPERATOR_NOT_IN, _jqlAst.OPERATOR_WAS, _jqlAst.OPERATOR_WAS_NOT, _jqlAst.OPERATOR_WAS_IN, _jqlAst.OPERATOR_WAS_NOT_IN, _jqlAst.OPERATOR_CHANGED];
+var sortOperators = exports.sortOperators = function sortOperators(operators$) {
+  return operators$.pipe((0, _map.map)(function (options) {
+    return ORDERED_OPERATORS.reduce(function (result, orderedOperator) {
+      var matchingOption = options.find(function (option) {
+        return orderedOperator.toLowerCase() === option.value.toLowerCase();
+      });
+      if (matchingOption !== undefined) {
+        result.push(matchingOption);
+      }
+      return result;
+    }, []);
+  }));
+};