@atlaskit/jql-editor 4.0.0

package/dist/esm/state/hydration/index.js

@@ -0,0 +1,85 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 { getJastFromState } from '../../plugins/jql-ast';
+import { replaceRichInlineNodes } from '../../plugins/rich-inline-nodes/util/replace-nodes-transaction';
+import { actions } from '../index';
+import { ValidQueryVisitor } from './util';
+export var hydrateQuery = function hydrateQuery() {
+  return /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref, _ref2) {
+      var setState, getState, dispatch, onHydrate, _getState, query, oldHydratedValues, enableRichInlineNodes, editorState, queryToHydrate, jast, visitor, newHydratedValues, hydratedValuesMap;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setState = _ref.setState, getState = _ref.getState, dispatch = _ref.dispatch;
+            onHydrate = _ref2.onHydrate;
+            _getState = getState(), query = _getState.query, oldHydratedValues = _getState.hydratedValues, enableRichInlineNodes = _getState.enableRichInlineNodes, editorState = _getState.editorState;
+            if (!(!enableRichInlineNodes || !onHydrate || !query)) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return");
+          case 5:
+            queryToHydrate = query;
+            jast = getJastFromState(editorState); // Hydration API will fail for syntactically invalid queries, including partial queries. We do want to hydrate those
+            // as well to be able to handle queries like `assignee in (abc-123-def`, so we build an equivalent valid query.
+            if (jast.query && jast.errors.length) {
+              visitor = new ValidQueryVisitor();
+              queryToHydrate = jast.query.accept(visitor);
+            }
+            if (queryToHydrate) {
+              _context.next = 10;
+              break;
+            }
+            return _context.abrupt("return");
+          case 10:
+            _context.prev = 10;
+            _context.next = 13;
+            return onHydrate(queryToHydrate);
+          case 13:
+            newHydratedValues = _context.sent;
+            hydratedValuesMap = Object.entries(newHydratedValues).reduce(function (map, _ref4) {
+              var _ref5 = _slicedToArray(_ref4, 2),
+                fieldName = _ref5[0],
+                values = _ref5[1];
+              var valueMap = new Map(oldHydratedValues[fieldName]);
+              values.forEach(function (value) {
+                valueMap.set(value.id, value);
+              });
+              return _objectSpread(_objectSpread({}, map), {}, _defineProperty({}, fieldName, valueMap));
+            }, {});
+            setState({
+              hydratedValues: hydratedValuesMap
+            });
+            dispatch(replaceHydratedValuesWithRichInlineNodes());
+            _context.next = 21;
+            break;
+          case 19:
+            _context.prev = 19;
+            _context.t0 = _context["catch"](10);
+          case 21:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[10, 19]]);
+    }));
+    return function (_x, _x2) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+};
+var replaceHydratedValuesWithRichInlineNodes = function replaceHydratedValuesWithRichInlineNodes() {
+  return function (_ref6) {
+    var getState = _ref6.getState,
+      dispatch = _ref6.dispatch;
+    var _getState2 = getState(),
+      editorState = _getState2.editorState,
+      hydratedValues = _getState2.hydratedValues;
+    var transaction = replaceRichInlineNodes(editorState, hydratedValues);
+    dispatch(actions.onApplyEditorTransaction(transaction));
+  };
+};

package/dist/esm/state/hydration/util.js

@@ -0,0 +1,83 @@
+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; } }
+import { AbstractJastVisitor } from '@atlaskit/jql-ast';
+
+/**
+ * Given an AST with parse errors, this visitor returns a valid query that is equivalent for hydration purposes
+ * (i.e. just fields, operators and values). Resulting query is generated on a best-effort basis and depends on
+ * a successful parser error recovery.
+ *
+ * Example 1:
+ * - Original query: "assignee in (abc-123-def"
+ * - Equivalent query: "assignee in (abc-123-def)"
+ *
+ * Example 2:
+ * - Original query: "project = EM and status in (Done, currentUser(), EMPTY) and reporter in"
+ * - Equivalent query: "project = EM and status in (Done)"
+ */
+export var ValidQueryVisitor = /*#__PURE__*/function (_AbstractJastVisitor) {
+  _inherits(ValidQueryVisitor, _AbstractJastVisitor);
+  var _super = _createSuper(ValidQueryVisitor);
+  function ValidQueryVisitor() {
+    var _this;
+    _classCallCheck(this, ValidQueryVisitor);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "visitQuery", function (query) {
+      if (!query.where) {
+        return '';
+      }
+      return query.where.accept(_assertThisInitialized(_this));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitCompoundClause", function (compoundClause) {
+      return compoundClause.clauses.map(function (clause) {
+        return clause.accept(_assertThisInitialized(_this));
+      }).filter(function (value) {
+        return !!value;
+      }).join(' and ');
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitTerminalClause", function (terminalClause) {
+      var field = terminalClause.field,
+        operator = terminalClause.operator,
+        operand = terminalClause.operand;
+      if (!operator || !operand) {
+        return '';
+      }
+      var operandValue = operand.accept(_assertThisInitialized(_this));
+      if (!operandValue) {
+        return '';
+      }
+      return "".concat(field.text, " ").concat(operator.value, " ").concat(operandValue);
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitNotClause", function (notClause) {
+      return notClause.clause.accept(_assertThisInitialized(_this));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitValueOperand", function (valueOperand) {
+      return valueOperand.text;
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitListOperand", function (listOperand) {
+      return "(".concat(listOperand.values.map(function (value) {
+        return value.accept(_assertThisInitialized(_this));
+      }).filter(function (value) {
+        return !!value;
+      }).join(', '), ")");
+    });
+    return _this;
+  }
+  _createClass(ValidQueryVisitor, [{
+    key: "defaultResult",
+    value: function defaultResult() {
+      return '';
+    }
+  }]);
+  return ValidQueryVisitor;
+}(AbstractJastVisitor);