@atlaskit/editor-plugin-card 0.1.0

package/dist/cjs/pm-plugins/analytics/utils.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appearanceForLink = appearanceForLink;
+exports.findLinksAtPositions = exports.areSameLinks = void 0;
+exports.findLinksInNode = findLinksInNode;
+exports.getLinkNodeContext = void 0;
+exports.getLinkUrl = getLinkUrl;
+exports.isLink = void 0;
+exports.isLinkNode = isLinkNode;
+exports.linkObjectFromNode = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _utils2 = require("../../utils");
+/**
+ * Whether a node is a "link" node, ie inline card, block card, embed card
+ * (but not a text node with a link mark)
+ */
+function isLinkNode(node) {
+  return !!(0, _utils2.appearanceForNodeType)(node.type);
+}
+
+/**
+ * Analytics appearance for link object
+ */
+function appearanceForLink(link) {
+  if (link.type === 'node') {
+    var appearance = (0, _utils2.appearanceForNodeType)(link.node.type);
+    if (appearance) {
+      return appearance;
+    }
+  }
+  return 'url';
+}
+var nodeHasLinkMark = function nodeHasLinkMark(schema, node) {
+  if (node.marks) {
+    for (var i = 0; i < node.marks.length; i++) {
+      var mark = node.marks[i];
+      if ((0, _utils.isLinkMark)(mark, schema)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * Determine if a node is considered to be a link
+ */
+var isLink = function isLink(schema, node) {
+  if (isLinkNode(node)) {
+    return true;
+  }
+  return nodeHasLinkMark(schema, node);
+};
+
+/**
+ * Given a node, find all nodes and marks that are considered "links"
+ * @param state EditorState
+ * @param fragment Fragment to search
+ * @returns Array of nodes and marks found in the fragment that are "links"
+ */
+exports.isLink = isLink;
+function findLinksInNode(doc, schema, node, offset) {
+  var links = [];
+  node.descendants(function (node, pos) {
+    var nodeContext = getLinkNodeContext(doc, pos);
+
+    // Nodes
+    if (isLinkNode(node)) {
+      links.push({
+        type: 'node',
+        pos: pos + offset,
+        node: node,
+        nodeContext: nodeContext
+      });
+    }
+
+    // Marks
+    if (node.marks) {
+      for (var i = 0; i < node.marks.length; i++) {
+        var mark = node.marks[i];
+        if ((0, _utils.isLinkMark)(mark, schema)) {
+          links.push({
+            type: 'mark',
+            pos: pos + offset,
+            mark: mark,
+            nodeContext: nodeContext
+          });
+        }
+      }
+    }
+  });
+  return links;
+}
+function getLinkUrl(link) {
+  var _link$mark$attrs;
+  if (link.type === 'node') {
+    var _link$node$attrs;
+    return (_link$node$attrs = link.node.attrs) === null || _link$node$attrs === void 0 ? void 0 : _link$node$attrs.url;
+  }
+  return (_link$mark$attrs = link.mark.attrs) === null || _link$mark$attrs === void 0 ? void 0 : _link$mark$attrs.href;
+}
+var getLinkNodeContext = function getLinkNodeContext(doc, pos) {
+  var $pos = doc.resolve(pos);
+  var maxDepth = 3;
+  for (var i = 0; i <= maxDepth; i++) {
+    var node = $pos.node($pos.depth - i);
+    if (node && node.type.name !== 'paragraph') {
+      return node.type.name;
+    }
+  }
+  return 'unknown';
+};
+exports.getLinkNodeContext = getLinkNodeContext;
+var linkObjectFromNode = function linkObjectFromNode(doc, schema, node, pos) {
+  var nodeContext = getLinkNodeContext(doc, pos);
+  if (isLinkNode(node)) {
+    return {
+      type: 'node',
+      pos: pos,
+      node: node,
+      nodeContext: nodeContext
+    };
+  }
+  if (node.marks) {
+    for (var i = 0; i < node.marks.length; i++) {
+      var mark = node.marks[i];
+      if ((0, _utils.isLinkMark)(mark, schema)) {
+        return {
+          type: 'mark',
+          pos: pos,
+          mark: mark,
+          nodeContext: nodeContext
+        };
+      }
+    }
+  }
+};
+exports.linkObjectFromNode = linkObjectFromNode;
+var findLinksAtPositions = function findLinksAtPositions(tr, positions) {
+  var schema = tr.doc.type.schema;
+  var links = [];
+  for (var i = 0; i < positions.length; i++) {
+    var pos = positions[i];
+    var node = tr.doc.nodeAt(pos);
+    if (!node) {
+      continue;
+    }
+    var link = linkObjectFromNode(tr.doc, schema, node, pos);
+    if (!link) {
+      continue;
+    }
+    links.push(link);
+  }
+  return links;
+};
+
+/**
+ * Returns whether or not two sets of links appear to likely be the same set of links
+ * That they are in the same order and that both their hrefs and appearances match
+ */
+exports.findLinksAtPositions = findLinksAtPositions;
+var areSameLinks = function areSameLinks(linksA, linksB) {
+  if (linksA.length !== linksB.length) {
+    return false;
+  }
+  for (var i = 0; i < linksA.length; i++) {
+    var linkA = linksA[i];
+    var linkB = linksB[i];
+    if (getLinkUrl(linkA) !== getLinkUrl(linkB) || appearanceForLink(linkA) !== appearanceForLink(linkB)) {
+      return false;
+    }
+  }
+  return true;
+};
+exports.areSameLinks = areSameLinks;

package/dist/cjs/pm-plugins/doc.js

@@ -0,0 +1,479 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateExistingDatasource = exports.updateCard = exports.setSelectedCardAppearance = exports.replaceQueuedUrlWithCard = exports.queueCardsFromChangedTr = exports.queueCardFromChangedTr = exports.insertDatasource = exports.handleFallbackWithAnalytics = exports.convertHyperlinkToSmartCard = exports.changeSelectedCardToText = exports.changeSelectedCardToLinkFallback = exports.changeSelectedCardToLink = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+var _prosemirrorHistory = require("prosemirror-history");
+var _prosemirrorState = require("prosemirror-state");
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _card = require("@atlaskit/editor-common/card");
+var _utils = require("@atlaskit/editor-common/utils");
+var _utils2 = require("../utils");
+var _actions = require("./actions");
+var _pluginKey = require("./plugin-key");
+var _shouldReplaceLink = require("./shouldReplaceLink");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+/**
+ * Attempt to replace the link into the respective card.
+ */
+function replaceLinksToCards(tr, cardAdf, schema, request) {
+  var inlineCard = schema.nodes.inlineCard;
+  var url = request.url;
+  if (!(0, _adfSchema.isSafeUrl)(url)) {
+    return;
+  }
+
+  // replace all the outstanding links with their cards
+  var pos = tr.mapping.map(request.pos);
+  var $pos = tr.doc.resolve(pos);
+  var node = tr.doc.nodeAt(pos);
+  if (!node || !node.type.isText) {
+    return;
+  }
+  var replaceLink = request.shouldReplaceLink || (0, _shouldReplaceLink.shouldReplaceLink)(node, request.compareLinkText, url);
+  if (!replaceLink) {
+    return;
+  }
+
+  // ED-5638: add an extra space after inline cards to avoid re-rendering them
+  var nodes = [cardAdf];
+  if (cardAdf.type === inlineCard) {
+    nodes.push(schema.text(' '));
+  }
+  tr.replaceWith(pos, pos + (node.text || url).length, nodes);
+  return $pos.node($pos.depth - 1).type.name;
+}
+var replaceQueuedUrlWithCard = function replaceQueuedUrlWithCard(url, cardData, analyticsAction, editorAnalyticsApi, createAnalyticsEvent) {
+  return function (editorState, dispatch) {
+    var state = _pluginKey.pluginKey.getState(editorState);
+    if (!state) {
+      return false;
+    }
+
+    // find the requests for this URL
+    var requests = state.requests.filter(function (req) {
+      return req.url === url;
+    });
+
+    // try to transform response to ADF
+    var schema = editorState.schema;
+    var cardAdf = (0, _utils.processRawValue)(schema, cardData);
+    var tr = editorState.tr;
+    if (cardAdf) {
+      // Should prevent any other node than cards? [inlineCard, blockCard].includes(cardAdf.type)
+      var nodeContexts = requests.map(function (request) {
+        return replaceLinksToCards(tr, cardAdf, schema, request);
+      }).filter(function (context) {
+        return !!context;
+      }); // context exist
+
+      // Send analytics information
+      if (nodeContexts.length) {
+        var nodeContext = nodeContexts.every(function (context) {
+          return context === nodeContexts[0];
+        }) ? nodeContexts[0] : 'mixed';
+
+        /** For block links v1, default to inline links */
+        var nodeType = 'inlineCard';
+        var _url$split = url.split('/'),
+          _url$split2 = (0, _slicedToArray2.default)(_url$split, 3),
+          domainName = _url$split2[2];
+        if (state.smartLinkEvents) {
+          state.smartLinkEvents.insertSmartLink(domainName, 'inline', createAnalyticsEvent);
+        }
+
+        /**
+         * TODO:
+         * What if each request has a different source?
+         * Unlikely, but need to define behaviour.
+         * Ignore analytics event? take first? provide 'mixed' as well?
+         */
+        var inputMethod = requests[0].source;
+        var sourceEvent = requests[0].sourceEvent;
+        editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          action: analyticsAction || _analytics.ACTION.INSERTED,
+          actionSubject: _analytics.ACTION_SUBJECT.DOCUMENT,
+          actionSubjectId: _analytics.ACTION_SUBJECT_ID.SMART_LINK,
+          eventType: _analytics.EVENT_TYPE.TRACK,
+          attributes: {
+            inputMethod: inputMethod,
+            nodeType: nodeType,
+            nodeContext: nodeContext,
+            fromCurrentDomain: (0, _utils.isFromCurrentDomain)(url)
+          },
+          nonPrivacySafeAttributes: {
+            domainName: domainName
+          }
+        })(tr);
+        (0, _card.addLinkMetadata)(editorState.selection, tr, {
+          action: analyticsAction,
+          inputMethod: inputMethod,
+          cardAction: 'RESOLVE',
+          sourceEvent: sourceEvent
+        });
+      }
+    }
+    if (dispatch) {
+      dispatch((0, _actions.resolveCard)(url)((0, _prosemirrorHistory.closeHistory)(tr)));
+    }
+    return true;
+  };
+};
+exports.replaceQueuedUrlWithCard = replaceQueuedUrlWithCard;
+var handleFallbackWithAnalytics = function handleFallbackWithAnalytics(request, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var cardState = _pluginKey.pluginKey.getState(state);
+    if (!cardState) {
+      return false;
+    }
+    var tr = state.tr;
+    if (request.source !== _analytics.INPUT_METHOD.FLOATING_TB) {
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent((0, _utils.getLinkCreationAnalyticsEvent)(request.source, request.url))(tr);
+    }
+    (0, _card.addLinkMetadata)(state.selection, tr, {
+      action: request.analyticsAction,
+      inputMethod: request.source
+    });
+    if (dispatch) {
+      dispatch((0, _actions.resolveCard)(request.url)(tr));
+    }
+    return true;
+  };
+};
+exports.handleFallbackWithAnalytics = handleFallbackWithAnalytics;
+var queueCardsFromChangedTr = function queueCardsFromChangedTr(state, tr, source, analyticsAction) {
+  var normalizeLinkText = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var sourceEvent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+  var schema = state.schema;
+  var link = schema.marks.link;
+  var requests = [];
+  (0, _utils.nodesBetweenChanged)(tr, function (node, pos) {
+    if (!node.isText) {
+      return true;
+    }
+    var linkMark = node.marks.find(function (mark) {
+      return mark.type === link;
+    });
+    if (linkMark) {
+      if (!(0, _shouldReplaceLink.shouldReplaceLink)(node, normalizeLinkText)) {
+        return false;
+      }
+      requests.push({
+        url: linkMark.attrs.href,
+        pos: pos,
+        appearance: 'inline',
+        compareLinkText: normalizeLinkText,
+        source: source,
+        analyticsAction: analyticsAction,
+        sourceEvent: sourceEvent
+      });
+    }
+    return false;
+  });
+  if (analyticsAction) {
+    (0, _card.addLinkMetadata)(state.selection, tr, {
+      action: analyticsAction
+    });
+  }
+  return (0, _actions.queueCards)(requests)(tr);
+};
+exports.queueCardsFromChangedTr = queueCardsFromChangedTr;
+var queueCardFromChangedTr = function queueCardFromChangedTr(state, tr, source, analyticsAction) {
+  var normalizeLinkText = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var sourceEvent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+  var previousAppearance = arguments.length > 6 ? arguments[6] : undefined;
+  var schema = state.schema;
+  var link = schema.marks.link;
+  var requests = [];
+  (0, _utils.nodesBetweenChanged)(tr, function (node, pos) {
+    if (!node.isText) {
+      return true;
+    }
+    var linkMark = node.marks.find(function (mark) {
+      return mark.type === link;
+    });
+    if (linkMark) {
+      if (!(0, _shouldReplaceLink.shouldReplaceLink)(node, normalizeLinkText)) {
+        return false;
+      }
+      requests.push({
+        url: linkMark.attrs.href,
+        pos: pos,
+        appearance: 'inline',
+        previousAppearance: previousAppearance,
+        compareLinkText: normalizeLinkText,
+        source: source,
+        analyticsAction: analyticsAction,
+        sourceEvent: sourceEvent
+      });
+    }
+    return false;
+  });
+  (0, _card.addLinkMetadata)(state.selection, tr, {
+    action: analyticsAction
+  });
+  return (0, _actions.queueCards)(requests)(tr);
+};
+exports.queueCardFromChangedTr = queueCardFromChangedTr;
+var convertHyperlinkToSmartCard = function convertHyperlinkToSmartCard(state, source, appearance) {
+  var normalizeLinkText = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var schema = state.schema;
+  var link = schema.marks.link;
+  var requests = [];
+  state.tr.doc.nodesBetween(state.selection.from, state.selection.to, function (node, pos) {
+    var linkMark = node.marks.find(function (mark) {
+      return mark.type === link;
+    });
+    if (linkMark) {
+      requests.push({
+        url: linkMark.attrs.href,
+        pos: pos,
+        appearance: appearance,
+        previousAppearance: 'url',
+        compareLinkText: normalizeLinkText,
+        source: source,
+        analyticsAction: _analytics.ACTION.CHANGED_TYPE,
+        shouldReplaceLink: true
+      });
+    }
+  });
+  (0, _card.addLinkMetadata)(state.selection, state.tr, {
+    action: _analytics.ACTION.CHANGED_TYPE
+  });
+  return (0, _actions.queueCards)(requests)(state.tr);
+};
+exports.convertHyperlinkToSmartCard = convertHyperlinkToSmartCard;
+var changeSelectedCardToLink = function changeSelectedCardToLink(text, href, sendAnalytics, node, pos, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var tr;
+    if (node && pos) {
+      tr = cardNodeToLinkWithTransaction(state, text, href, node, pos);
+    } else {
+      tr = cardToLinkWithTransaction(state, text, href);
+    }
+    var selectedNode = state.selection instanceof _prosemirrorState.NodeSelection && state.selection.node;
+    if (sendAnalytics) {
+      if (selectedNode) {
+        editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+          action: _analytics.ACTION.CHANGED_TYPE,
+          actionSubject: _analytics.ACTION_SUBJECT.SMART_LINK,
+          eventType: _analytics.EVENT_TYPE.TRACK,
+          attributes: {
+            newType: _analytics.SMART_LINK_TYPE.URL,
+            previousType: (0, _utils2.appearanceForNodeType)(selectedNode.type)
+          }
+        })(tr);
+      }
+    }
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+};
+exports.changeSelectedCardToLink = changeSelectedCardToLink;
+var changeSelectedCardToLinkFallback = function changeSelectedCardToLinkFallback(text, href, sendAnalytics, node, pos, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var tr;
+    if (node && pos) {
+      tr = cardNodeToLinkWithTransaction(state, text, href, node, pos);
+    } else {
+      tr = cardToLinkWithTransaction(state, text, href);
+    }
+    if (sendAnalytics) {
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+        action: _analytics.ACTION.ERRORED,
+        actionSubject: _analytics.ACTION_SUBJECT.SMART_LINK,
+        eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+        attributes: {
+          error: 'Smart card falling back to link.'
+        }
+      })(tr);
+    }
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+};
+exports.changeSelectedCardToLinkFallback = changeSelectedCardToLinkFallback;
+var updateCard = function updateCard(href, sourceEvent) {
+  return function (state, dispatch) {
+    var selectedNode = state.selection instanceof _prosemirrorState.NodeSelection && state.selection.node;
+    if (!selectedNode) {
+      return false;
+    }
+    var cardAppearance = (0, _utils2.selectedCardAppearance)(state);
+    var tr = cardToLinkWithTransaction(state, href, href);
+    queueCardFromChangedTr(state, tr, _analytics.INPUT_METHOD.MANUAL, _analytics.ACTION.UPDATED, undefined, sourceEvent, cardAppearance);
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+};
+exports.updateCard = updateCard;
+function cardToLinkWithTransaction(state, text, href) {
+  var selectedNode = state.selection instanceof _prosemirrorState.NodeSelection && state.selection.node;
+  if (!selectedNode) {
+    return state.tr;
+  }
+  var link = state.schema.marks.link;
+  var url = selectedNode.attrs.url || selectedNode.attrs.data.url;
+  var tr = state.tr.replaceSelectionWith(state.schema.text(text || url, [link.create({
+    href: href || url
+  })]), false);
+  return tr;
+}
+function cardNodeToLinkWithTransaction(state, text, href, node, pos) {
+  var link = state.schema.marks.link;
+  var url = node.attrs.url || node.attrs.data.url;
+  return state.tr.replaceWith(pos, pos + node.nodeSize, state.schema.text(text || url, [link.create({
+    href: href || url
+  })]));
+}
+var changeSelectedCardToText = function changeSelectedCardToText(text, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var selectedNode = state.selection instanceof _prosemirrorState.NodeSelection && state.selection.node;
+    if (!selectedNode) {
+      return false;
+    }
+    var tr = state.tr.replaceSelectionWith(state.schema.text(text), false);
+    if (dispatch) {
+      (0, _card.addLinkMetadata)(state.selection, tr, {
+        action: _analytics.ACTION.UNLINK
+      });
+      tr.scrollIntoView();
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent((0, _analytics.unlinkPayload)(_analytics.ACTION_SUBJECT_ID.CARD_INLINE))(tr);
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+exports.changeSelectedCardToText = changeSelectedCardToText;
+var setSelectedCardAppearance = function setSelectedCardAppearance(appearance, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var _previousNode$type;
+    var selectedNode = state.selection instanceof _prosemirrorState.NodeSelection && state.selection.node;
+    if (!selectedNode) {
+      // When there is no selected node, we insert a new one
+      // and replace the existing blue link
+      var _tr = convertHyperlinkToSmartCard(state, _analytics.INPUT_METHOD.FLOATING_TB, appearance);
+      if (dispatch) {
+        (0, _card.addLinkMetadata)(state.selection, _tr, {
+          action: _analytics.ACTION.CHANGED_TYPE
+        });
+        dispatch(_tr.scrollIntoView());
+      }
+      return false;
+    }
+    if ((0, _utils2.appearanceForNodeType)(selectedNode.type) === appearance) {
+      return false;
+    }
+    var isEmbed = appearance === 'embed';
+    var attrs = isEmbed ? _objectSpread(_objectSpread({}, selectedNode.attrs), {}, {
+      layout: 'center'
+    }) : selectedNode.attrs;
+    var _state$selection = state.selection,
+      from = _state$selection.from,
+      to = _state$selection.to;
+    var nodeType = getLinkNodeType(appearance, state.schema.nodes);
+    var tr = state.tr.setNodeMarkup(from, nodeType, attrs, selectedNode.marks);
+
+    // When the selected card is the last element in the doc we add a new paragraph after it for consistent replacement
+    if (tr.doc.nodeSize - 2 === to) {
+      tr.insertText(' ', to);
+    }
+    tr.setSelection(_prosemirrorState.TextSelection.create(tr.doc, to + 1));
+    var previousNodePos = from - 1 > 0 ? from - 1 : 0;
+    var previousNode = tr.doc.nodeAt(previousNodePos);
+    if ((previousNode === null || previousNode === void 0 ? void 0 : (_previousNode$type = previousNode.type) === null || _previousNode$type === void 0 ? void 0 : _previousNode$type.name) === 'paragraph') {
+      tr.delete(previousNodePos, from);
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+      action: _analytics.ACTION.CHANGED_TYPE,
+      actionSubject: _analytics.ACTION_SUBJECT.SMART_LINK,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      attributes: {
+        newType: appearance,
+        previousType: (0, _utils2.appearanceForNodeType)(selectedNode.type)
+      }
+    })(tr);
+    (0, _card.addLinkMetadata)(state.selection, tr, {
+      action: _analytics.ACTION.CHANGED_TYPE
+    });
+    if (dispatch) {
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+};
+exports.setSelectedCardAppearance = setSelectedCardAppearance;
+var getLinkNodeType = function getLinkNodeType(appearance, linkNodes) {
+  switch (appearance) {
+    case 'inline':
+      return linkNodes.inlineCard;
+    case 'block':
+      return linkNodes.blockCard;
+    case 'embed':
+      return linkNodes.embedCard;
+  }
+};
+
+// Apply an update to a datasource (aka blockCard) node
+var updateExistingDatasource = function updateExistingDatasource(state, node, newAdf, view) {
+  var tr = state.tr,
+    from = state.selection.from,
+    schemaNodes = state.schema.nodes;
+
+  // datasource to datasource
+  if (newAdf.type === 'blockCard' && newAdf.attrs.datasource && node.attrs.datasource) {
+    var _ref3, _ref6, _newViews$properties, _oldViews$properties, _newAdf$attrs, _node$attrs;
+    var _ref = (_ref3 = newAdf.attrs.datasource.views) !== null && _ref3 !== void 0 ? _ref3 : [],
+      _ref2 = (0, _slicedToArray2.default)(_ref, 1),
+      newViews = _ref2[0];
+    var _ref4 = (_ref6 = node.attrs.datasource.views) !== null && _ref6 !== void 0 ? _ref6 : [],
+      _ref5 = (0, _slicedToArray2.default)(_ref4, 1),
+      oldViews = _ref5[0];
+    var newColumnKeys = newViews === null || newViews === void 0 ? void 0 : (_newViews$properties = newViews.properties) === null || _newViews$properties === void 0 ? void 0 : _newViews$properties.columns.map(function (column) {
+      return column.key;
+    });
+    var oldColumnKeys = oldViews === null || oldViews === void 0 ? void 0 : (_oldViews$properties = oldViews.properties) === null || _oldViews$properties === void 0 ? void 0 : _oldViews$properties.columns.map(function (column) {
+      return column.key;
+    });
+    var isColumnChange = !(0, _isEqual.default)(oldColumnKeys, newColumnKeys);
+    var isUrlChange = ((_newAdf$attrs = newAdf.attrs) === null || _newAdf$attrs === void 0 ? void 0 : _newAdf$attrs.url) !== ((_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.url);
+    if (isColumnChange || isUrlChange) {
+      tr.setNodeMarkup(from, schemaNodes.blockCard, _objectSpread(_objectSpread({}, node.attrs), newAdf.attrs));
+    }
+  } else if (newAdf.type === 'inlineCard') {
+    // datasource to inline
+    tr.setNodeMarkup(from, schemaNodes.inlineCard, newAdf.attrs);
+  }
+  (0, _actions.hideDatasourceModal)(tr);
+  view.dispatch(tr.scrollIntoView());
+};
+exports.updateExistingDatasource = updateExistingDatasource;
+var insertDatasource = function insertDatasource(state, adf, view) {
+  var tr = state.tr,
+    from = state.selection.from,
+    schemaNodes = state.schema.nodes;
+  var attrs = adf.attrs,
+    type = adf.type;
+  var schemaNode = type === 'inlineCard' ? schemaNodes.inlineCard : schemaNodes.blockCard;
+  var newNode = schemaNode.createChecked(attrs);
+  // in future, if we decide to do datasource insertion from the main toolbar, we should probably consider editor-plugin-content-insertion instead of tr.insert
+  // this will allow us to deal with insertions from multiple paths in a more consistent way
+  newNode && tr.insert(from, newNode);
+  (0, _actions.hideDatasourceModal)(tr);
+  view.dispatch(tr.scrollIntoView());
+};
+exports.insertDatasource = insertDatasource;