@atlaskit/editor-plugin-card 0.1.0

package/dist/cjs/plugin.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cardPlugin = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _quickInsert = require("@atlaskit/editor-common/quick-insert");
+var _utils = require("@atlaskit/editor-common/utils");
+var _linkDatasource = require("@atlaskit/link-datasource");
+var _messages = require("./messages");
+var _actions = require("./pm-plugins/actions");
+var _doc = require("./pm-plugins/doc");
+var _keymap = require("./pm-plugins/keymap");
+var _main = require("./pm-plugins/main");
+var _mountHyperlink = require("./pm-plugins/mountHyperlink");
+var _pluginKey = require("./pm-plugins/plugin-key");
+var _toolbar = require("./toolbar");
+var _ModalWithState = _interopRequireDefault(require("./ui/DatasourceModal/ModalWithState"));
+var _EditorSmartCardEvents = require("./ui/EditorSmartCardEvents");
+var _EditorSmartCardEventsNext = require("./ui/EditorSmartCardEventsNext");
+var _LayoutButton = _interopRequireDefault(require("./ui/LayoutButton"));
+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; }
+var cardPlugin = function cardPlugin(options, api) {
+  var _api$dependencies, _api$dependencies$fea;
+  var featureFlags = (api === null || api === void 0 ? void 0 : (_api$dependencies = api.dependencies) === null || _api$dependencies === void 0 ? void 0 : (_api$dependencies$fea = _api$dependencies.featureFlags) === null || _api$dependencies$fea === void 0 ? void 0 : _api$dependencies$fea.sharedState.currentState()) || {};
+  return {
+    name: 'card',
+    getSharedState: function getSharedState(editorState) {
+      if (!editorState) {
+        return null;
+      }
+      return _pluginKey.pluginKey.getState(editorState) || null;
+    },
+    nodes: function nodes() {
+      var nodes = [{
+        name: 'inlineCard',
+        node: _adfSchema.inlineCard
+      }, {
+        name: 'blockCard',
+        node: _adfSchema.blockCard
+      }];
+      if (options.allowEmbeds) {
+        nodes.push({
+          name: 'embedCard',
+          node: _adfSchema.embedCard
+        });
+      }
+      return nodes;
+    },
+    pmPlugins: function pmPlugins() {
+      var _options$allowBlockCa, _options$allowResizin, _options$useAlternati, _options$allowWrappin, _options$allowAlignme;
+      var allowBlockCards = (_options$allowBlockCa = options.allowBlockCards) !== null && _options$allowBlockCa !== void 0 ? _options$allowBlockCa : true;
+      var allowResizing = (_options$allowResizin = options.allowResizing) !== null && _options$allowResizin !== void 0 ? _options$allowResizin : true;
+      var useAlternativePreloader = (_options$useAlternati = options.useAlternativePreloader) !== null && _options$useAlternati !== void 0 ? _options$useAlternati : true;
+      var allowWrapping = (_options$allowWrappin = options.allowWrapping) !== null && _options$allowWrappin !== void 0 ? _options$allowWrappin : true;
+      var allowAlignment = (_options$allowAlignme = options.allowAlignment) !== null && _options$allowAlignme !== void 0 ? _options$allowAlignme : true;
+      var plugins = [{
+        name: 'card',
+        plugin: (0, _main.createPlugin)(_objectSpread(_objectSpread({}, options), {}, {
+          allowBlockCards: allowBlockCards,
+          allowResizing: allowResizing,
+          useAlternativePreloader: useAlternativePreloader,
+          allowWrapping: allowWrapping,
+          allowAlignment: allowAlignment
+        }), api)
+      }, {
+        name: 'cardHyperlink',
+        plugin: function plugin() {
+          return (0, _mountHyperlink.mountHyperlinkPlugin)(api, options);
+        }
+      }];
+      plugins.push({
+        name: 'cardKeymap',
+        plugin: function plugin(_ref) {
+          var featureFlags = _ref.featureFlags;
+          return (0, _keymap.cardKeymap)(featureFlags);
+        }
+      });
+      return plugins;
+    },
+    contentComponent: function contentComponent(_ref2) {
+      var editorView = _ref2.editorView,
+        popupsMountPoint = _ref2.popupsMountPoint,
+        popupsScrollableElement = _ref2.popupsScrollableElement,
+        popupsBoundariesElement = _ref2.popupsBoundariesElement;
+      var lpAnalyticsEventsNext = featureFlags.lpAnalyticsEventsNext;
+      return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_EditorSmartCardEvents.EditorSmartCardEvents, {
+        editorView: editorView
+      }), lpAnalyticsEventsNext && /*#__PURE__*/_react.default.createElement(_EditorSmartCardEventsNext.EditorSmartCardEventsNext, {
+        editorView: editorView
+      }), /*#__PURE__*/_react.default.createElement(_LayoutButton.default, {
+        api: api,
+        editorView: editorView,
+        mountPoint: popupsMountPoint,
+        scrollableElement: popupsScrollableElement,
+        boundariesElement: popupsBoundariesElement
+      }), /*#__PURE__*/_react.default.createElement(_ModalWithState.default, {
+        api: api,
+        editorView: editorView
+      }));
+    },
+    actions: {
+      hideLinkToolbar: _actions.hideLinkToolbar,
+      queueCardsFromChangedTr: _doc.queueCardsFromChangedTr,
+      changeSelectedCardToLink: _doc.changeSelectedCardToLink,
+      setSelectedCardAppearance: _doc.setSelectedCardAppearance
+    },
+    pluginsOptions: {
+      floatingToolbar: (0, _toolbar.floatingToolbar)(options, featureFlags, options.platform, options.linkPicker, api),
+      quickInsert: function quickInsert(_ref3) {
+        var formatMessage = _ref3.formatMessage;
+        if ((0, _utils.canRenderDatasource)(_linkDatasource.JIRA_LIST_OF_LINKS_DATASOURCE_ID)) {
+          return [{
+            id: 'datasource',
+            title: formatMessage(_messages.messages.datasourceJiraIssue),
+            description: formatMessage(_messages.messages.datasourceJiraIssueDescription),
+            keywords: ['jira'],
+            icon: function icon() {
+              return /*#__PURE__*/_react.default.createElement(_quickInsert.IconDatasourceJiraIssue, null);
+            },
+            action: function action(insert) {
+              var tr = insert(undefined);
+              (0, _actions.showDatasourceModal)('jira')(tr);
+              return tr;
+            }
+          }];
+        }
+        return [];
+      }
+    }
+  };
+};
+exports.cardPlugin = cardPlugin;

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

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.showLinkToolbar = exports.showDatasourceModal = exports.setProvider = exports.setDatasourceTableRef = exports.setCardLayoutAndDatasourceTableRef = exports.setCardLayout = exports.resolveCard = exports.registerSmartCardEventsNext = exports.registerSmartCardEvents = exports.registerCard = exports.queueCards = exports.hideLinkToolbar = exports.hideDatasourceModal = exports.cardAction = void 0;
+var _pluginKey = require("./plugin-key");
+var cardAction = function cardAction(tr, action) {
+  return tr.setMeta(_pluginKey.pluginKey, action);
+};
+exports.cardAction = cardAction;
+var resolveCard = function resolveCard(url) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'RESOLVE',
+      url: url
+    });
+  };
+};
+exports.resolveCard = resolveCard;
+var queueCards = function queueCards(requests) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'QUEUE',
+      requests: requests
+    });
+  };
+};
+exports.queueCards = queueCards;
+var registerCard = function registerCard(info) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'REGISTER',
+      info: info
+    });
+  };
+};
+exports.registerCard = registerCard;
+var registerSmartCardEvents = function registerSmartCardEvents(smartLinkEvents) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'REGISTER_EVENTS',
+      smartLinkEvents: smartLinkEvents
+    });
+  };
+};
+exports.registerSmartCardEvents = registerSmartCardEvents;
+var registerSmartCardEventsNext = function registerSmartCardEventsNext(smartLinkEvents) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'REGISTER_EVENTS_NEXT',
+      smartLinkEvents: smartLinkEvents
+    });
+  };
+};
+exports.registerSmartCardEventsNext = registerSmartCardEventsNext;
+var setProvider = function setProvider(cardProvider) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'SET_PROVIDER',
+      provider: cardProvider
+    });
+  };
+};
+exports.setProvider = setProvider;
+var setDatasourceTableRef = function setDatasourceTableRef(datasourceTableRef) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'SET_DATASOURCE_TABLE_REF',
+      datasourceTableRef: datasourceTableRef
+    });
+  };
+};
+exports.setDatasourceTableRef = setDatasourceTableRef;
+var setCardLayout = function setCardLayout(layout) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'SET_CARD_LAYOUT',
+      layout: layout
+    });
+  };
+};
+exports.setCardLayout = setCardLayout;
+var setCardLayoutAndDatasourceTableRef = function setCardLayoutAndDatasourceTableRef(_ref) {
+  var layout = _ref.layout,
+    datasourceTableRef = _ref.datasourceTableRef;
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF',
+      layout: layout,
+      datasourceTableRef: datasourceTableRef
+    });
+  };
+};
+exports.setCardLayoutAndDatasourceTableRef = setCardLayoutAndDatasourceTableRef;
+var showLinkToolbar = function showLinkToolbar(tr) {
+  return cardAction(tr, {
+    type: 'SHOW_LINK_TOOLBAR'
+  });
+};
+exports.showLinkToolbar = showLinkToolbar;
+var hideLinkToolbar = function hideLinkToolbar(tr) {
+  return cardAction(tr, {
+    type: 'HIDE_LINK_TOOLBAR'
+  });
+};
+exports.hideLinkToolbar = hideLinkToolbar;
+var showDatasourceModal = function showDatasourceModal(modalType) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'SHOW_DATASOURCE_MODAL',
+      modalType: modalType
+    });
+  };
+};
+exports.showDatasourceModal = showDatasourceModal;
+var hideDatasourceModal = function hideDatasourceModal(tr) {
+  return cardAction(tr, {
+    type: 'HIDE_DATASOURCE_MODAL'
+  });
+};
+exports.hideDatasourceModal = hideDatasourceModal;

package/dist/cjs/pm-plugins/analytics/create-analytics-queue.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAnalyticsQueue = void 0;
+/**
+ * Simple mechanism to defer analytics related callbacks
+ */
+var createAnalyticsQueue = function createAnalyticsQueue() {
+  var enabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var queue = [];
+  var callbacksRef = {
+    current: null
+  };
+  var setCallbacks = function setCallbacks(callbacks) {
+    callbacksRef.current = callbacks;
+  };
+  var push = function push() {
+    var callbacks = callbacksRef.current;
+    if (!enabled || !callbacks) {
+      return;
+    }
+    queue.push.apply(queue, arguments);
+  };
+  var flush = function flush() {
+    var callbacks = callbacksRef.current;
+    if (!enabled || !callbacks) {
+      return;
+    }
+    while (queue.length) {
+      var event = queue.pop();
+      if (event) {
+        callbacks[event.type](event.data);
+      }
+    }
+  };
+  var getSize = function getSize() {
+    return queue.length;
+  };
+  return {
+    push: push,
+    flush: flush,
+    setCallbacks: setCallbacks,
+    getSize: getSize
+  };
+};
+exports.createAnalyticsQueue = createAnalyticsQueue;

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

@@ -0,0 +1,359 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.eventsFromTransaction = eventsFromTransaction;
+exports.findChangedLinks = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _prosemirrorTransform = require("prosemirror-transform");
+var _steps = require("@atlaskit/adf-schema/steps");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _card = require("@atlaskit/editor-common/card");
+var _utils = require("@atlaskit/editor-common/utils");
+var _pluginKey = require("../plugin-key");
+var _state = require("../util/state");
+var _utils2 = require("./utils");
+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; }
+var findLinksInNodeRange = function findLinksInNodeRange(doc, schema, from, to) {
+  var links = [];
+  doc.nodesBetween(from, to, function (node, pos) {
+    if ((0, _utils2.isLink)(schema, node)) {
+      var entireLinkInRange = pos >= from && pos + node.nodeSize <= to;
+      if (entireLinkInRange) {
+        var link = (0, _utils2.linkObjectFromNode)(doc, schema, node, pos);
+        if (link) {
+          links.push(link);
+        }
+      }
+    }
+  });
+  return links;
+};
+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(_utils.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 _prosemirrorTransform.AddMarkStep) {
+      var addMarkStep = step;
+      if ((0, _utils.isLinkMark)(addMarkStep.mark, schema)) {
+        /**
+         * For url text pasted on plain text
+         */
+        insertedInStep.push({
+          type: 'mark',
+          pos: addMarkStep.from,
+          mark: addMarkStep.mark,
+          nodeContext: (0, _utils2.getLinkNodeContext)(after, addMarkStep.from)
+        });
+      }
+    }
+    if (step instanceof _prosemirrorTransform.RemoveMarkStep) {
+      var removeMarkStep = step;
+      if ((0, _utils.isLinkMark)(removeMarkStep.mark, schema)) {
+        removedInStep.push({
+          type: 'mark',
+          pos: removeMarkStep.from,
+          mark: removeMarkStep.mark,
+          nodeContext: (0, _utils2.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, (0, _toConsumableArray2.default)(findLinksInNodeRange(before, schema, oldStart, oldEnd)));
+      // Inserted
+      insertedInRange.push.apply(insertedInRange, (0, _toConsumableArray2.default)(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, (0, _toConsumableArray2.default)(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, (0, _toConsumableArray2.default)((0, _utils2.findLinksAtPositions)(tr, positions)));
+  }
+  if (!isUpdate) {
+    var _getLinkMetadataFromT = (0, _card.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 && (0, _utils2.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"
+ */
+exports.findChangedLinks = findChangedLinks;
+var UPDATE_ACTIONS = [_analytics.ACTION.CHANGED_TYPE, _analytics.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 _steps.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 (0, _typeof2.default)(pluginMeta) === 'object' && pluginMeta !== null && 'type' in pluginMeta;
+};
+var isTransactionQueuedForUpgrade = function isTransactionQueuedForUpgrade(tr) {
+  var pluginMeta = tr.getMeta(_pluginKey.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.pluginKey);
+  return isMetadataResolve(pluginMeta);
+};
+var isMetadataResolve = function isMetadataResolve(metaData) {
+  return hasType(metaData) && metaData.type === 'RESOLVE';
+};
+var isHistoryMeta = function isHistoryMeta(meta) {
+  return (0, _typeof2.default)(meta) === 'object' && meta !== null && 'redo' in meta;
+};
+var getQueuedPositions = function getQueuedPositions(tr) {
+  var pluginMeta = tr.getMeta(_pluginKey.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 = (0, _state.getPluginState)(state);
+  if (!cardState) {
+    return [];
+  }
+  var pluginMeta = tr.getMeta(_pluginKey.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 = (0, _state.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;
+};
+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(_utils.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 = (0, _card.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 = (0, _utils2.getLinkUrl)(link);
+      var display = (0, _utils2.appearanceForLink)(link);
+      var previousDisplay = 'removed' in update ? (0, _utils2.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 = (0, _utils2.getLinkUrl)(_link);
+        var _display = (0, _utils2.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/cjs/pm-plugins/analytics/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createAnalyticsQueue", {
+  enumerable: true,
+  get: function get() {
+    return _createAnalyticsQueue.createAnalyticsQueue;
+  }
+});
+Object.defineProperty(exports, "eventsFromTransaction", {
+  enumerable: true,
+  get: function get() {
+    return _eventsFromTr.eventsFromTransaction;
+  }
+});
+var _createAnalyticsQueue = require("./create-analytics-queue");
+var _eventsFromTr = require("./events-from-tr");

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

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