@atlaskit/editor-plugin-card 0.1.0

package/dist/esm/pm-plugins/analytics/events-from-tr.js

@@ -0,0 +1,350 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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) { _defineProperty(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; }
+import { AddMarkStep, RemoveMarkStep } from 'prosemirror-transform';
+import { LinkMetaStep } from '@atlaskit/adf-schema/steps';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import { getLinkMetadataFromTransaction } from '@atlaskit/editor-common/card';
+import { isLinkMark, pmHistoryPluginKey } from '@atlaskit/editor-common/utils';
+import { pluginKey } from '../plugin-key';
+import { getPluginState } from '../util/state';
+import { appearanceForLink, areSameLinks, findLinksAtPositions, getLinkNodeContext, getLinkUrl, isLink, linkObjectFromNode } from './utils';
+var findLinksInNodeRange = function findLinksInNodeRange(doc, schema, from, to) {
+  var links = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if (isLink(schema, node)) {
+      var entireLinkInRange = pos >= from && pos + node.nodeSize <= to;
+      if (entireLinkInRange) {
+        var link = linkObjectFromNode(doc, schema, node, pos);
+        if (link) {
+          links.push(link);
+        }
+      }
+    }
+  });
+  return links;
+};
+export var findChangedLinks = function findChangedLinks(tr, state) {
+  var schema = tr.doc.type.schema;
+  var removed = [];
+  var inserted = [];
+  var updated = [];
+  var queuedForUpgrade = isTransactionQueuedForUpgrade(tr);
+  var isResolveReplace = isTransactionResolveReplace(tr);
+
+  // History
+  var historyMeta = tr.getMeta(pmHistoryPluginKey);
+  var isUndo = isHistoryMeta(historyMeta) && historyMeta.redo === false;
+  var isRedo = isHistoryMeta(historyMeta) && historyMeta.redo === true;
+  var isUpdate = isUpdateTr(tr, isUndo || isRedo);
+  var _loop = function _loop(i) {
+    var _tr$docs$i, _tr$docs;
+    var step = tr.steps[i];
+    var stepMap = step.getMap();
+    var removedInStep = [];
+    var insertedInStep = [];
+    var before = (_tr$docs$i = tr.docs[i]) !== null && _tr$docs$i !== void 0 ? _tr$docs$i : tr.before;
+    var after = (_tr$docs = tr.docs[i + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : tr.doc;
+
+    /**
+     * AddMarkStep and RemoveMarkSteps don't produce stepMap ranges
+     * because there are no "changed tokens" only marks added/removed
+     * So have to check these manually
+     */
+    if (step instanceof AddMarkStep) {
+      var addMarkStep = step;
+      if (isLinkMark(addMarkStep.mark, schema)) {
+        /**
+         * For url text pasted on plain text
+         */
+        insertedInStep.push({
+          type: 'mark',
+          pos: addMarkStep.from,
+          mark: addMarkStep.mark,
+          nodeContext: getLinkNodeContext(after, addMarkStep.from)
+        });
+      }
+    }
+    if (step instanceof RemoveMarkStep) {
+      var removeMarkStep = step;
+      if (isLinkMark(removeMarkStep.mark, schema)) {
+        removedInStep.push({
+          type: 'mark',
+          pos: removeMarkStep.from,
+          mark: removeMarkStep.mark,
+          nodeContext: getLinkNodeContext(before, removeMarkStep.from)
+        });
+      }
+    }
+    stepMap.forEach(function (oldStart, oldEnd, newStart, newEnd) {
+      var _tr$docs2;
+      var before = tr.docs[i];
+      var after = (_tr$docs2 = tr.docs[i + 1]) !== null && _tr$docs2 !== void 0 ? _tr$docs2 : tr.doc;
+      var removedInRange = [];
+      var insertedInRange = [];
+
+      // Removed
+      removedInRange.push.apply(removedInRange, _toConsumableArray(findLinksInNodeRange(before, schema, oldStart, oldEnd)));
+      // Inserted
+      insertedInRange.push.apply(insertedInRange, _toConsumableArray(findLinksInNodeRange(after, schema, newStart, newEnd)));
+      removedInStep.push.apply(removedInStep, removedInRange);
+      insertedInStep.push.apply(insertedInStep, insertedInRange);
+    });
+    var omitQueuedLinks = function omitQueuedLinks(links) {
+      if (!queuedForUpgrade) {
+        return links;
+      }
+      /**
+       * Skip/filter out links that have been queued, they will be tracked later
+       */
+      var queuedPositions = getQueuedPositions(tr);
+      return links.filter(function (link) {
+        return !queuedPositions.includes(link.pos);
+      });
+    };
+
+    /**
+     * Skip "deletions" when the transaction is relating to
+     * replacing links queued for upgrade to cards,
+     * because the "deleted" link has not actually been
+     * tracked as "created" yet
+     */
+    if (!isResolveReplace) {
+      removed.push.apply(removed, removedInStep);
+    }
+    inserted.push.apply(inserted, _toConsumableArray(omitQueuedLinks(insertedInStep)));
+  };
+  for (var i = 0; i < tr.steps.length; i++) {
+    _loop(i);
+  }
+
+  /**
+   * If there are no links changed but the transaction is a "resolve" action
+   * Then this means we have resolved a link but it has failed to upgrade
+   * We should track all resolved links as now being created
+   */
+  if (inserted.length === 0 && isResolveReplace) {
+    var positions = getResolvePositions(tr, state);
+    inserted.push.apply(inserted, _toConsumableArray(findLinksAtPositions(tr, positions)));
+  }
+  if (!isUpdate) {
+    var _getLinkMetadataFromT = getLinkMetadataFromTransaction(tr),
+      inputMethod = _getLinkMetadataFromT.inputMethod;
+    /**
+     * If there is no identifiable input method, and the links inserted and removed appear to be the same,
+     * then this transaction likely is not intended to be consided to be the insertion and removal of links
+     */
+    if (!inputMethod && areSameLinks(removed, inserted)) {
+      return {
+        removed: [],
+        inserted: [],
+        updated: updated
+      };
+    }
+    return {
+      removed: removed,
+      inserted: inserted,
+      updated: updated
+    };
+  }
+  for (var _i = 0; _i < inserted.length; _i++) {
+    if (isResolveReplace) {
+      var newLink = inserted[_i];
+
+      // what is the 2nd argument 'assoc = -1' doing here exactly?
+      var mappedPos = tr.mapping.map(newLink.pos, -1);
+      var previousDisplay = getResolveLinkPrevDisplay(state, mappedPos);
+      updated.push({
+        inserted: inserted[_i],
+        previous: {
+          display: previousDisplay
+        }
+      });
+      continue;
+    }
+    if (inserted.length === removed.length) {
+      updated.push({
+        removed: removed[_i],
+        inserted: inserted[_i]
+      });
+    }
+  }
+  return {
+    inserted: [],
+    removed: [],
+    updated: updated
+  };
+};
+
+/**
+ * List of actions to be considered link "updates"
+ */
+var UPDATE_ACTIONS = [ACTION.CHANGED_TYPE, ACTION.UPDATED];
+
+/**
+ * Returns true if the transaction has LinkMetaSteps that indicate the transaction is
+ * intended to be perceived as an update to links, rather than insertion+deletion
+ */
+var isUpdateTr = function isUpdateTr(tr, isUndoOrRedo) {
+  return !!tr.steps.find(function (step) {
+    if (!(step instanceof LinkMetaStep)) {
+      return false;
+    }
+    var _step$getMetadata = step.getMetadata(),
+      action = _step$getMetadata.action,
+      cardAction = _step$getMetadata.cardAction;
+
+    /**
+     * Undo of a resolve step should be considered an update
+     * because the user is choosing to update the url back to the un-upgraded display
+     */
+    if (cardAction === 'RESOLVE' && isUndoOrRedo) {
+      return true;
+    }
+    if (!action) {
+      return false;
+    }
+    return UPDATE_ACTIONS.includes(action);
+  });
+};
+var hasType = function hasType(pluginMeta) {
+  return _typeof(pluginMeta) === 'object' && pluginMeta !== null && 'type' in pluginMeta;
+};
+var isTransactionQueuedForUpgrade = function isTransactionQueuedForUpgrade(tr) {
+  var pluginMeta = tr.getMeta(pluginKey);
+  return isMetadataQueue(pluginMeta);
+};
+var isMetadataQueue = function isMetadataQueue(metaData) {
+  return hasType(metaData) && metaData.type === 'QUEUE';
+};
+var isTransactionResolveReplace = function isTransactionResolveReplace(tr) {
+  var pluginMeta = tr.getMeta(pluginKey);
+  return isMetadataResolve(pluginMeta);
+};
+var isMetadataResolve = function isMetadataResolve(metaData) {
+  return hasType(metaData) && metaData.type === 'RESOLVE';
+};
+var isHistoryMeta = function isHistoryMeta(meta) {
+  return _typeof(meta) === 'object' && meta !== null && 'redo' in meta;
+};
+var getQueuedPositions = function getQueuedPositions(tr) {
+  var pluginMeta = tr.getMeta(pluginKey);
+  if (!isMetadataQueue(pluginMeta)) {
+    return [];
+  }
+  return pluginMeta.requests.map(function (_ref) {
+    var pos = _ref.pos;
+    return pos;
+  });
+};
+var getResolvePositions = function getResolvePositions(tr, state) {
+  var cardState = getPluginState(state);
+  if (!cardState) {
+    return [];
+  }
+  var pluginMeta = tr.getMeta(pluginKey);
+  if (!isMetadataResolve(pluginMeta)) {
+    return [];
+  }
+  return cardState.requests.filter(function (request) {
+    return request.url === pluginMeta.url;
+  }).map(function (request) {
+    return request.pos;
+  });
+};
+var getResolveLinkPrevDisplay = function getResolveLinkPrevDisplay(state, pos) {
+  var _cardState$requests$f;
+  var cardState = getPluginState(state);
+  if (!cardState) {
+    return undefined;
+  }
+  return (_cardState$requests$f = cardState.requests.find(function (request) {
+    return request.pos === pos;
+  })) === null || _cardState$requests$f === void 0 ? void 0 : _cardState$requests$f.previousAppearance;
+};
+export function eventsFromTransaction(tr, state) {
+  var events = [];
+  try {
+    /**
+     * Skip transactions sent by collab (identified by 'isRemote' key)
+     * Skip entire document replace steps
+     * We are only concerned with transactions performed on the document directly by the user
+     */
+    var isRemote = tr.getMeta('isRemote');
+    var isReplaceDocument = tr.getMeta('replaceDocument');
+    if (isRemote || isReplaceDocument) {
+      return events;
+    }
+    var historyMeta = tr.getMeta(pmHistoryPluginKey);
+    var isUndo = isHistoryMeta(historyMeta) && historyMeta.redo === false;
+    var isRedo = isHistoryMeta(historyMeta) && historyMeta.redo === true;
+
+    /**
+     * Retrieve metadata from the LinkMetaStep(s) in the transaction
+     */
+    var _getLinkMetadataFromT2 = getLinkMetadataFromTransaction(tr),
+      action = _getLinkMetadataFromT2.action,
+      inputMethod = _getLinkMetadataFromT2.inputMethod,
+      sourceEvent = _getLinkMetadataFromT2.sourceEvent;
+    var contextualData = {
+      action: action,
+      inputMethod: inputMethod,
+      sourceEvent: sourceEvent,
+      isUndo: isUndo,
+      isRedo: isRedo
+    };
+    var _findChangedLinks = findChangedLinks(tr, state),
+      removed = _findChangedLinks.removed,
+      inserted = _findChangedLinks.inserted,
+      updated = _findChangedLinks.updated;
+    var MAX_LINK_EVENTS = 50;
+    if ([removed, inserted, updated].some(function (arr) {
+      return arr.length > MAX_LINK_EVENTS;
+    })) {
+      return [];
+    }
+    for (var i = 0; i < updated.length; i++) {
+      var _update$previous$disp;
+      var update = updated[i];
+      var link = update.inserted;
+      var url = getLinkUrl(link);
+      var display = appearanceForLink(link);
+      var previousDisplay = 'removed' in update ? appearanceForLink(update.removed) : (_update$previous$disp = update.previous.display) !== null && _update$previous$disp !== void 0 ? _update$previous$disp : 'unknown';
+      if (url) {
+        events.push({
+          type: 'updated',
+          data: _objectSpread(_objectSpread({}, contextualData), {}, {
+            url: url,
+            display: display,
+            previousDisplay: previousDisplay,
+            nodeContext: link.nodeContext
+          })
+        });
+      }
+    }
+    var pushEvents = function pushEvents(links, type) {
+      for (var _i2 = 0; _i2 < links.length; _i2++) {
+        var _link = links[_i2];
+        var _url = getLinkUrl(_link);
+        var _display = appearanceForLink(_link);
+        if (_url) {
+          events.push({
+            type: type,
+            data: _objectSpread(_objectSpread({}, contextualData), {}, {
+              url: _url,
+              display: _display,
+              nodeContext: _link.nodeContext
+            })
+          });
+        }
+      }
+    };
+    pushEvents(removed, 'deleted');
+    pushEvents(inserted, 'created');
+    return events;
+  } catch (err) {
+    return events;
+  }
+}

package/dist/esm/pm-plugins/analytics/index.js

@@ -0,0 +1,2 @@
+export { createAnalyticsQueue } from './create-analytics-queue';
+export { eventsFromTransaction } from './events-from-tr';

package/dist/esm/pm-plugins/analytics/types.js

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

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

@@ -0,0 +1,160 @@
+import { isLinkMark } from '@atlaskit/editor-common/utils';
+import { appearanceForNodeType } from '../../utils';
+/**
+ * Whether a node is a "link" node, ie inline card, block card, embed card
+ * (but not a text node with a link mark)
+ */
+export function isLinkNode(node) {
+  return !!appearanceForNodeType(node.type);
+}
+
+/**
+ * Analytics appearance for link object
+ */
+export function appearanceForLink(link) {
+  if (link.type === 'node') {
+    var appearance = 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 (isLinkMark(mark, schema)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * Determine if a node is considered to be a link
+ */
+export 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"
+ */
+export 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 (isLinkMark(mark, schema)) {
+          links.push({
+            type: 'mark',
+            pos: pos + offset,
+            mark: mark,
+            nodeContext: nodeContext
+          });
+        }
+      }
+    }
+  });
+  return links;
+}
+export 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;
+}
+export 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';
+};
+export 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 (isLinkMark(mark, schema)) {
+        return {
+          type: 'mark',
+          pos: pos,
+          mark: mark,
+          nodeContext: nodeContext
+        };
+      }
+    }
+  }
+};
+export 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
+ */
+export 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;
+};