@atlaskit/editor-core 182.0.2 → 182.1.0

package/dist/esm/editor.js

@@ -23,6 +23,7 @@ import { defaultProps, propTypes } from './editor-next/utils/editorPropTypes';
 import _trackEditorActions from './editor-next/utils/trackEditorActions';
 import _onEditorCreated from './editor-next/utils/onEditorCreated';
 import deprecationWarnings from './editor-next/utils/deprecationWarnings';
+import { createFeatureFlagsFromProps } from './create-editor/feature-flags-from-props';
 import { fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
 import prepareQuickInsertProvider from './utils/prepare-quick-insert-provider';
 import prepareExtensionProvider from './utils/prepare-extension-provider';
@@ -62,6 +63,9 @@ var Editor = /*#__PURE__*/function (_React$Component) {
     _defineProperty(_assertThisInitialized(_this), "handleAnalyticsEvent", function (data) {
       return fireAnalyticsEvent(_this.createAnalyticsEvent)(data);
     });
+    _defineProperty(_assertThisInitialized(_this), "getFeatureFlags", function () {
+      return createFeatureFlagsFromProps(_this.props);
+    });
     _defineProperty(_assertThisInitialized(_this), "getExperienceStore", function () {
       return _this.experienceStore;
     });
@@ -258,18 +262,18 @@ var Editor = /*#__PURE__*/function (_React$Component) {
      * and need to find a workaround.
      */
     function registerEditorForActions(editorView, eventDispatcher, contentTransformer) {
-      this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer);
+      this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer, this.getFeatureFlags);
     }
-
+  }, {
+    key: "unregisterEditorFromActions",
+    value:
     /**
      * @private
      * @deprecated - Do not override this at all, this is an antipattern.
      * Please reach out to the Editor team if you were previously using this
      * and need to find a workaround.
      */
-  }, {
-    key: "unregisterEditorFromActions",
-    value: function unregisterEditorFromActions() {
+    function unregisterEditorFromActions() {
       this.editorActions._privateUnregisterEditor();
     }
   }, {

package/dist/esm/keymaps/index.js

@@ -1 +1 @@
-export { addAltText, toggleBold, toggleItalic, toggleUnderline, toggleStrikethrough, toggleSubscript, toggleSuperscript, toggleCode, pastePlainText, clearFormatting, setNormalText, toggleHeading1, toggleHeading2, toggleHeading3, toggleHeading4, toggleHeading5, toggleHeading6, toggleOrderedList, ctrlBackSpace, toggleBulletList, toggleBlockQuote, insertNewLine, shiftBackspace, splitCodeBlock, splitListItem, insertRule, undo, moveUp, moveDown, moveLeft, moveRight, indentList, outdentList, redo, openHelp, addLink, addInlineComment, submit, enter, shiftEnter, tab, indent, outdent, backspace, deleteKey, forwardDelete, space, escape, nextCell, previousCell, shiftTab, toggleTable, addRowBefore, addRowAfter, addColumnAfter, addColumnBefore, cut, copy, paste, altPaste, find, alignLeft, tooltip, ToolTipContent, findKeymapByDescription, findShortcutByDescription, findShortcutByKeymap, makeKeymap, makeKeyMapWithCommon, bindKeymapWithCommand, findKeyMapForBrowser, DOWN, HEADING_KEYS, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, LEFT, RIGHT, UP } from '@atlaskit/editor-common/keymaps';
+export { addAltText, navToEditorToolbar, navToFloatingToolbar, toggleBold, toggleItalic, toggleUnderline, toggleStrikethrough, toggleSubscript, toggleSuperscript, toggleCode, pastePlainText, clearFormatting, setNormalText, toggleHeading1, toggleHeading2, toggleHeading3, toggleHeading4, toggleHeading5, toggleHeading6, toggleOrderedList, ctrlBackSpace, toggleBulletList, toggleBlockQuote, insertNewLine, shiftBackspace, splitCodeBlock, splitListItem, insertRule, undo, moveUp, moveDown, moveLeft, moveRight, indentList, outdentList, redo, openHelp, addLink, addInlineComment, submit, enter, shiftEnter, tab, indent, outdent, backspace, deleteKey, forwardDelete, space, escape, nextCell, previousCell, shiftTab, toggleTable, addRowBefore, addRowAfter, addColumnAfter, addColumnBefore, cut, copy, paste, altPaste, find, alignLeft, tooltip, ToolTipContent, findKeymapByDescription, findShortcutByDescription, findShortcutByKeymap, makeKeymap, makeKeyMapWithCommon, bindKeymapWithCommand, findKeyMapForBrowser, DOWN, HEADING_KEYS, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, LEFT, RIGHT, UP } from '@atlaskit/editor-common/keymaps';

package/dist/esm/labs/next/internal/hooks/use-editor/index.js

@@ -7,8 +7,7 @@ import { measureRender, getResponseEndTime, startMeasure, stopMeasure } from '@a
 import measurements from '../../../../../utils/performance/measure-enum';
 import { getNodesCount } from '../../../../../utils';
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE, PLATFORMS } from '../../../../../plugins/analytics';
-import { getEnabledFeatureFlagKeys } from '../../../../../plugins/feature-flags-context/get-enabled-feature-flag-keys';
-import { getFeatureFlags } from '../../../../../plugins/feature-flags-context/';
+import { getEnabledFeatureFlagKeys } from '@atlaskit/editor-common/normalize-feature-flags';
 import { useAnalyticsHandler } from '../use-analytics';
 import { createDispatchTransaction } from './create-dispatch-transaction';
 import { createEditor } from './create-editor';
@@ -20,7 +19,7 @@ export function useEditor(config) {
     editorSharedConfig = _useCreateEditor2[0],
     mountEditor = _useCreateEditor2[1];
   useApplyEditorViewProps(editorSharedConfig, config.disabled);
-  useHandleEditorLifecycle(editorSharedConfig);
+  useHandleEditorLifecycle(editorSharedConfig, config.featureFlags);
   useAnalyticsHandler(editorSharedConfig);
   return [editorSharedConfig, mountEditor];
 }
@@ -119,7 +118,7 @@ function useApplyEditorViewProps(editorSharedConfig, disabled) {
 /**
  * Handles editor component unmount
  */
-export function useHandleEditorLifecycle(editorSharedConfig) {
+export function useHandleEditorLifecycle(editorSharedConfig, featureFlags) {
   React.useEffect(function () {
     //#region Did mount
     if (editorSharedConfig) {
@@ -132,7 +131,6 @@ export function useHandleEditorLifecycle(editorSharedConfig) {
       if (onMount) {
         onMount(editorActions);
       }
-      var featureFlags = getFeatureFlags(editorSharedConfig.editorView.state);
       var featureFlagsEnabled = featureFlags ? getEnabledFeatureFlagKeys(featureFlags) : [];
 
       // Fire editor started event
@@ -183,5 +181,5 @@ export function useHandleEditorLifecycle(editorSharedConfig) {
         editorView.destroy();
       }
     };
-  }, [editorSharedConfig]);
+  }, [editorSharedConfig, featureFlags]);
 }

package/dist/esm/labs/next/presets/default.js

@@ -12,7 +12,6 @@ import editorDisabledPlugin from '../../../plugins/editor-disabled';
 import typeAheadPlugin from '../../../plugins/type-ahead';
 import submitEditorPlugin from '../../../plugins/submit-editor';
 import fakeTextCursorPlugin from '../../../plugins/fake-text-cursor';
-import featureFlagsContextPlugin from '../../../plugins/feature-flags-context';
 import featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
 import floatingToolbarPlugin from '../../../plugins/floating-toolbar';
 import clipboardPlugin from '../../../plugins/clipboard';
@@ -44,7 +43,7 @@ export function createDefaultPreset(options) {
     return builder;
   }).add([hyperlinkPlugin, options.hyperlinkOptions]).add([textFormattingPlugin, options.textFormatting]).add(widthPlugin).add([quickInsertPlugin, options.quickInsert]).add([typeAheadPlugin, options.typeAhead || {
     createAnalyticsEvent: options.createAnalyticsEvent
-  }]).add(unsupportedContentPlugin).add(editorDisabledPlugin).add([submitEditorPlugin, options.submitEditor]).add(fakeTextCursorPlugin).add(floatingToolbarPlugin).add([featureFlagsContextPlugin, options.featureFlags || {}]).add([selectionPlugin, options.selection]).add([codeBlockPlugin, options.codeBlock || {
+  }]).add(unsupportedContentPlugin).add(editorDisabledPlugin).add([submitEditorPlugin, options.submitEditor]).add(fakeTextCursorPlugin).add(floatingToolbarPlugin).add([selectionPlugin, options.selection]).add([codeBlockPlugin, options.codeBlock || {
     appearance: 'full-page'
   }]);
   return preset;

package/dist/esm/plugins/card/index.js

@@ -1,12 +1,13 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 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 React from 'react';
+import React, { Fragment } from 'react';
 import { inlineCard, blockCard, embedCard } from '@atlaskit/adf-schema';
 import { createPlugin } from './pm-plugins/main';
 import { floatingToolbar } from './toolbar';
 import { EditorSmartCardEvents } from './ui/EditorSmartCardEvents';
 import { cardKeymap } from './pm-plugins/keymap';
+import { EditorSmartCardEventsNext } from './ui/EditorSmartCardEventsNext';
 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()) || {};
@@ -29,16 +30,20 @@ var cardPlugin = function cardPlugin(options, api) {
       return nodes;
     },
     pmPlugins: function pmPlugins() {
-      var _options$allowBlockCa, _options$allowResizin, _options$useAlternati;
+      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: createPlugin(_objectSpread(_objectSpread({}, options), {}, {
           allowBlockCards: allowBlockCards,
           allowResizing: allowResizing,
-          useAlternativePreloader: useAlternativePreloader
+          useAlternativePreloader: useAlternativePreloader,
+          allowWrapping: allowWrapping,
+          allowAlignment: allowAlignment
         }))
       }];
       plugins.push({
@@ -52,9 +57,12 @@ var cardPlugin = function cardPlugin(options, api) {
     },
     contentComponent: function contentComponent(_ref2) {
       var editorView = _ref2.editorView;
-      return /*#__PURE__*/React.createElement(EditorSmartCardEvents, {
+      var lpAnalyticsEventsNext = featureFlags.lpAnalyticsEventsNext;
+      return /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(EditorSmartCardEvents, {
         editorView: editorView
-      });
+      }), lpAnalyticsEventsNext && /*#__PURE__*/React.createElement(EditorSmartCardEventsNext, {
+        editorView: editorView
+      }));
     },
     pluginsOptions: {
       floatingToolbar: floatingToolbar(options, featureFlags, options.platform, options.linkPicker)

package/dist/esm/plugins/card/pm-plugins/actions.js

@@ -34,6 +34,14 @@ export var registerSmartCardEvents = function registerSmartCardEvents(smartLinkE
     });
   };
 };
+export var registerSmartCardEventsNext = function registerSmartCardEventsNext(smartLinkEvents) {
+  return function (tr) {
+    return cardAction(tr, {
+      type: 'REGISTER_EVENTS_NEXT',
+      smartLinkEvents: smartLinkEvents
+    });
+  };
+};
 export var setProvider = function setProvider(cardProvider) {
   return function (tr) {
     return cardAction(tr, {

package/dist/esm/plugins/card/pm-plugins/analytics/create-analytics-queue.js

@@ -0,0 +1,41 @@
+/**
+ * Simple mechanism to defer analytics related callbacks
+ */
+export 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
+  };
+};

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

@@ -0,0 +1,328 @@
+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 { ACTION } from '@atlaskit/editor-common/analytics';
+import { isLinkMark } from '@atlaskit/editor-common/utils';
+import { getLinkMetadataFromTransaction } from '@atlaskit/editor-common/card';
+import { LinkMetaStep } from '@atlaskit/adf-schema/steps';
+import { pmHistoryPluginKey } from '../../../history/pm-history-types';
+import { getPluginState } from '../util/state';
+import { pluginKey } from '../plugin-key';
+import { isLink, linkObjectFromNode, getLinkUrl, appearanceForLink, findLinksAtPositions } from './utils';
+var findLinksInNodeRange = function findLinksInNodeRange(node, schema, from, to) {
+  var links = [];
+  node.nodesBetween(from, to, function (node, pos) {
+    if (isLink(schema, node)) {
+      var entireLinkInRange = pos >= from && pos + node.nodeSize <= to;
+      if (entireLinkInRange) {
+        var link = linkObjectFromNode(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 step = tr.steps[i];
+    var stepMap = step.getMap();
+    var removedInStep = [];
+    var insertedInStep = [];
+
+    /**
+     * 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
+        });
+      }
+    }
+    if (step instanceof RemoveMarkStep) {
+      var removeMarkStep = step;
+      if (isLinkMark(removeMarkStep.mark, schema)) {
+        /**
+         * For url text pasted on plain text
+         */
+        removedInStep.push({
+          type: 'mark',
+          pos: removeMarkStep.from,
+          mark: removeMarkStep.mark
+        });
+      }
+    }
+    stepMap.forEach(function (oldStart, oldEnd, newStart, newEnd) {
+      var _tr$docs;
+      var before = tr.docs[i];
+      var after = (_tr$docs = tr.docs[i + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : 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) {
+    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 hasType(pluginMeta) && pluginMeta.type === 'QUEUE';
+};
+var isTransactionResolveReplace = function isTransactionResolveReplace(tr) {
+  var pluginMeta = tr.getMeta(pluginKey);
+  return hasType(pluginMeta) && pluginMeta.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 (!isTransactionQueuedForUpgrade(tr)) {
+    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 (!isTransactionResolveReplace(tr)) {
+    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 _getLinkMetadataFromT = getLinkMetadataFromTransaction(tr),
+      action = _getLinkMetadataFromT.action,
+      inputMethod = _getLinkMetadataFromT.inputMethod,
+      sourceEvent = _getLinkMetadataFromT.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 = 10;
+    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
+          })
+        });
+      }
+    }
+    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
+            })
+          });
+        }
+      }
+    };
+    pushEvents(removed, 'deleted');
+    pushEvents(inserted, 'created');
+    return events;
+  } catch (err) {
+    return events;
+  }
+}

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

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

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

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

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

@@ -0,0 +1,124 @@
+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(schema, node, offset) {
+  var links = [];
+  node.descendants(function (node, pos) {
+    // Nodes
+    if (isLinkNode(node)) {
+      links.push({
+        type: 'node',
+        pos: pos + offset,
+        node: node
+      });
+    }
+
+    // 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
+          });
+        }
+      }
+    }
+  });
+  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 linkObjectFromNode = function linkObjectFromNode(schema, node, pos) {
+  if (isLinkNode(node)) {
+    return {
+      type: 'node',
+      pos: pos,
+      node: node
+    };
+  }
+  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
+        };
+      }
+    }
+  }
+};
+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(schema, node, pos);
+    if (!link) {
+      continue;
+    }
+    links.push(link);
+  }
+  return links;
+};