@atlaskit/editor-plugin-card 0.3.3 → 0.3.5

package/dist/esm/plugin.js

@@ -6,6 +6,7 @@ import { blockCard, embedCard, inlineCard } from '@atlaskit/adf-schema';
 import { IconDatasourceAssetsObjects, IconDatasourceJiraIssue } from '@atlaskit/editor-common/quick-insert';
 import { canRenderDatasource } from '@atlaskit/editor-common/utils';
 import { ASSETS_LIST_OF_LINKS_DATASOURCE_ID, JIRA_LIST_OF_LINKS_DATASOURCE_ID } from '@atlaskit/link-datasource';
+import { createEventsQueue } from './analytics/create-events-queue';
 import { messages } from './messages';
 import { hideLinkToolbar, showDatasourceModal } from './pm-plugins/actions';
 import { changeSelectedCardToLink, queueCardsFromChangedTr, setSelectedCardAppearance } from './pm-plugins/doc';
@@ -15,12 +16,13 @@ import { mountHyperlinkPlugin } from './pm-plugins/mountHyperlink';
 import { pluginKey } from './pm-plugins/plugin-key';
 import { floatingToolbar } from './toolbar';
 import DatasourceModalWithState from './ui/DatasourceModal/ModalWithState';
+import { EditorLinkingPlatformAnalytics } from './ui/EditorLinkingPlatformAnalytics';
 import { EditorSmartCardEvents } from './ui/EditorSmartCardEvents';
-import { EditorSmartCardEventsNext } from './ui/EditorSmartCardEventsNext';
 import LayoutButton from './ui/LayoutButton';
 export 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()) || {};
+  var cardPluginEvents = featureFlags !== null && featureFlags !== void 0 && featureFlags.lpAnalyticsEventsNext ? createEventsQueue() : undefined;
   return {
     name: 'card',
     getSharedState: function getSharedState(editorState) {
@@ -61,7 +63,8 @@ export var cardPlugin = function cardPlugin(options, api) {
           useAlternativePreloader: useAlternativePreloader,
           allowWrapping: allowWrapping,
           allowAlignment: allowAlignment,
-          allowDatasource: allowDatasource
+          allowDatasource: allowDatasource,
+          cardPluginEvents: cardPluginEvents
         }), api)
       }, {
         name: 'cardHyperlink',
@@ -83,10 +86,10 @@ export var cardPlugin = function cardPlugin(options, api) {
         popupsMountPoint = _ref2.popupsMountPoint,
         popupsScrollableElement = _ref2.popupsScrollableElement,
         popupsBoundariesElement = _ref2.popupsBoundariesElement;
-      var lpAnalyticsEventsNext = featureFlags.lpAnalyticsEventsNext;
       return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(EditorSmartCardEvents, {
         editorView: editorView
-      }), lpAnalyticsEventsNext && /*#__PURE__*/React.createElement(EditorSmartCardEventsNext, {
+      }), cardPluginEvents && /*#__PURE__*/React.createElement(EditorLinkingPlatformAnalytics, {
+        cardPluginEvents: cardPluginEvents,
         editorView: editorView
       }), /*#__PURE__*/React.createElement(LayoutButton, {
         api: api,

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

@@ -34,14 +34,6 @@ 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/pm-plugins/doc.js

@@ -436,6 +436,9 @@ export var updateExistingDatasource = function updateExistingDatasource(state, n
     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));
+      addLinkMetadata(state.selection, tr, {
+        action: ACTION.UPDATED
+      });
     }
   } else if (newAdf.type === 'inlineCard') {
     // datasource to inline

package/dist/esm/pm-plugins/main.js

@@ -6,12 +6,12 @@ import { DATASOURCE_INNER_CONTAINER_CLASSNAME } from '@atlaskit/editor-common/st
 import { canRenderDatasource } from '@atlaskit/editor-common/utils';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { findDomRefAtPos } from '@atlaskit/editor-prosemirror/utils';
+import { eventsFromTransaction } from '../analytics/events-from-tr';
 import { BlockCard } from '../nodeviews/blockCard';
 import { Datasource } from '../nodeviews/datasource';
 import { EmbedCard } from '../nodeviews/embedCard';
 import { InlineCardNodeView } from '../nodeviews/inlineCard';
 import { setCardLayoutAndDatasourceTableRef, setDatasourceTableRef } from './actions';
-import { createAnalyticsQueue, eventsFromTransaction } from './analytics';
 import { pluginKey } from './plugin-key';
 import reducer from './reducers';
 import { handleProvider, resolveWithProvider } from './util/resolve';
@@ -19,14 +19,13 @@ import { getNewRequests, getPluginState, getPluginStateWithUpdatedPos } from './
 export { pluginKey } from './plugin-key';
 export var createPlugin = function createPlugin(options, pluginInjectionApi) {
   return function (pmPluginFactoryParams) {
-    var lpAnalyticsEventsNext = pmPluginFactoryParams.featureFlags.lpAnalyticsEventsNext;
-    var analyticsQueue = createAnalyticsQueue(!!lpAnalyticsEventsNext);
     var editorAppearance = options.editorAppearance,
       platform = options.platform,
       allowResizing = options.allowResizing,
       useAlternativePreloader = options.useAlternativePreloader,
       fullWidthMode = options.fullWidthMode,
-      showServerActions = options.showServerActions;
+      showServerActions = options.showServerActions,
+      cardPluginEvents = options.cardPluginEvents;
     var inlineCardViewProducer = getInlineNodeViewProducer({
       pmPluginFactoryParams: pmPluginFactoryParams,
       Component: InlineCardNodeView,
@@ -44,7 +43,6 @@ export var createPlugin = function createPlugin(options, pluginInjectionApi) {
             cards: [],
             showLinkingToolbar: false,
             smartLinkEvents: undefined,
-            smartLinkEventsNext: undefined,
             editorAppearance: editorAppearance,
             showDatasourceModal: false,
             datasourceModalType: undefined,
@@ -59,14 +57,12 @@ export var createPlugin = function createPlugin(options, pluginInjectionApi) {
 
           // apply any actions
           var meta = tr.getMeta(pluginKey);
-          var events = eventsFromTransaction(tr, prevEditorState);
-          analyticsQueue.push.apply(analyticsQueue, _toConsumableArray(events));
+          if (cardPluginEvents) {
+            var events = eventsFromTransaction(tr, prevEditorState);
+            cardPluginEvents.push.apply(cardPluginEvents, _toConsumableArray(events));
+          }
           if (meta) {
-            var nextState = reducer(pluginStateWithUpdatedPos, meta);
-            if (!pluginState.smartLinkEventsNext && nextState.smartLinkEventsNext) {
-              analyticsQueue.setCallbacks(nextState.smartLinkEventsNext);
-            }
-            return nextState;
+            return reducer(pluginStateWithUpdatedPos, meta);
           }
           return pluginStateWithUpdatedPos;
         }
@@ -134,7 +130,13 @@ export var createPlugin = function createPlugin(options, pluginInjectionApi) {
                 invoke();
               });
             }
-            analyticsQueue.flush();
+
+            /**
+             * If there have been any events queued, flush them
+             * so subscribers can now be notified and dispatch
+             * analytics events
+             */
+            cardPluginEvents === null || cardPluginEvents === void 0 ? void 0 : cardPluginEvents.flush();
           },
           destroy: function destroy() {
             // Cancel any outstanding raf callbacks.

package/dist/esm/pm-plugins/reducers.js

@@ -50,11 +50,6 @@ var registerEvents = function registerEvents(state, action) {
     smartLinkEvents: action.smartLinkEvents
   });
 };
-var registerEventsNext = function registerEventsNext(state, action) {
-  return _objectSpread(_objectSpread({}, state), {}, {
-    smartLinkEventsNext: action.smartLinkEvents
-  });
-};
 var setLinkToolbar = function setLinkToolbar(state, action) {
   return _objectSpread(_objectSpread({}, state), {}, {
     showLinkingToolbar: action.type === 'SHOW_LINK_TOOLBAR'
@@ -84,8 +79,6 @@ export default (function (state, action) {
       return register(state, action);
     case 'REGISTER_EVENTS':
       return registerEvents(state, action);
-    case 'REGISTER_EVENTS_NEXT':
-      return registerEventsNext(state, action);
     case 'SET_DATASOURCE_TABLE_REF':
       return setDatasourceTableRef(state, action);
     case 'SET_CARD_LAYOUT':

package/dist/esm/ui/EditorLinkingPlatformAnalytics/DatasourceEvents.js

@@ -0,0 +1,44 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { useEffect, useMemo } from 'react';
+import { EVENT, EVENT_SUBJECT } from '../../analytics/types';
+/**
+ * Subscribes to the events occuring in the card
+ * plugin and fires analytics events accordingly
+ */
+export var DatasourceEventsBinding = function DatasourceEventsBinding(_ref) {
+  var cardPluginEvents = _ref.cardPluginEvents;
+  var eventHandlers = useMemo(function () {
+    var _ref2;
+    return _ref2 = {}, _defineProperty(_ref2, EVENT.CREATED, function (metadata) {
+      // TODO Impl as part of https://product-fabric.atlassian.net/browse/EDM-7072
+      // eslint-disable-next-line no-console
+      console.log('CREATED', metadata.node, metadata.nodeContext);
+    }), _defineProperty(_ref2, EVENT.UPDATED, function (metadata) {
+      // TODO Impl as part of https://product-fabric.atlassian.net/browse/EDM-7072
+      // eslint-disable-next-line no-console
+      console.log('UPDATED', metadata.node, metadata.nodeContext);
+    }), _defineProperty(_ref2, EVENT.DELETED, function (metadata) {
+      // TODO Impl as part of https://product-fabric.atlassian.net/browse/EDM-7072
+      // eslint-disable-next-line no-console
+      console.log('DELETED', metadata.node, metadata.nodeContext);
+    }), _ref2;
+  }, []);
+
+  /**
+   * Subscribe to datasource events
+   */
+  useEffect(function () {
+    var unsubscribe = cardPluginEvents.subscribe(function (_ref3) {
+      var event = _ref3.event,
+        subject = _ref3.subject,
+        data = _ref3.data;
+      if (subject === EVENT_SUBJECT.DATASOURCE) {
+        eventHandlers[event](data);
+      }
+    });
+    return function () {
+      return unsubscribe();
+    };
+  }, [eventHandlers, cardPluginEvents]);
+  return null;
+};

package/dist/esm/ui/EditorLinkingPlatformAnalytics/LinkEvents.js

@@ -0,0 +1,125 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["node", "nodeContext"],
+  _excluded2 = ["node", "nodeContext", "previousDisplay"],
+  _excluded3 = ["node", "nodeContext"];
+import { useEffect, useMemo } from 'react';
+import { useSmartLinkLifecycleAnalytics } from '@atlaskit/link-analytics';
+import { EVENT, EVENT_SUBJECT } from '../../analytics/types';
+import { appearanceForLink, getUrl } from '../../analytics/utils';
+import { getDeleteType, getMethod, getSourceEventFromMetadata, getUpdateType } from './common';
+
+/**
+ * Set display category as `link` if not displaying the link as a smart card
+ */
+var displayCategoryFromDisplay = function displayCategoryFromDisplay(display) {
+  if (display === 'url') {
+    return 'link';
+  }
+};
+/**
+ * Subscribes to the events occuring in the card
+ * plugin and fires analytics events accordingly
+ */
+export var LinkEventsBinding = function LinkEventsBinding(_ref) {
+  var cardPluginEvents = _ref.cardPluginEvents;
+  /**
+   * These callbacks internally use window.requestIdleCallback/requestAnimationFrame
+   * to defer any heavy operations involving network
+   *
+   * The callbacks themselves should not be deferred, they should be called syncronously the moment
+   * the events take place.
+   */
+  var _useSmartLinkLifecycl = useSmartLinkLifecycleAnalytics(),
+    linkCreated = _useSmartLinkLifecycl.linkCreated,
+    linkUpdated = _useSmartLinkLifecycl.linkUpdated,
+    linkDeleted = _useSmartLinkLifecycl.linkDeleted;
+  var linkEvents = useMemo(function () {
+    var _ref5;
+    return _ref5 = {}, _defineProperty(_ref5, EVENT.CREATED, function (_ref2) {
+      var node = _ref2.node,
+        nodeContext = _ref2.nodeContext,
+        metadata = _objectWithoutProperties(_ref2, _excluded);
+      var url = getUrl(node);
+      if (!url) {
+        return;
+      }
+      var display = appearanceForLink(node);
+      var displayCategory = displayCategoryFromDisplay(display);
+      var sourceEvent = getSourceEventFromMetadata(metadata);
+      var creationMethod = getMethod(metadata);
+      linkCreated({
+        url: url,
+        displayCategory: displayCategory
+      }, sourceEvent, {
+        display: display,
+        nodeContext: nodeContext,
+        creationMethod: creationMethod
+      });
+    }), _defineProperty(_ref5, EVENT.UPDATED, function (_ref3) {
+      var node = _ref3.node,
+        nodeContext = _ref3.nodeContext,
+        previousDisplay = _ref3.previousDisplay,
+        metadata = _objectWithoutProperties(_ref3, _excluded2);
+      var url = getUrl(node);
+      if (!url) {
+        return;
+      }
+      var display = appearanceForLink(node);
+      var displayCategory = displayCategoryFromDisplay(display);
+      var sourceEvent = getSourceEventFromMetadata(metadata);
+      var updateMethod = getMethod(metadata);
+      var updateType = getUpdateType(metadata);
+      linkUpdated({
+        url: url,
+        displayCategory: displayCategory
+      }, sourceEvent, {
+        display: display,
+        previousDisplay: previousDisplay,
+        nodeContext: nodeContext,
+        updateMethod: updateMethod,
+        updateType: updateType
+      });
+    }), _defineProperty(_ref5, EVENT.DELETED, function (_ref4) {
+      var node = _ref4.node,
+        nodeContext = _ref4.nodeContext,
+        metadata = _objectWithoutProperties(_ref4, _excluded3);
+      var url = getUrl(node);
+      if (!url) {
+        return;
+      }
+      var display = appearanceForLink(node);
+      var displayCategory = displayCategoryFromDisplay(display);
+      var sourceEvent = getSourceEventFromMetadata(metadata);
+      var deleteMethod = getMethod(metadata);
+      var deleteType = getDeleteType(metadata);
+      linkDeleted({
+        url: url,
+        displayCategory: displayCategory
+      }, sourceEvent, {
+        display: display,
+        nodeContext: nodeContext,
+        deleteMethod: deleteMethod,
+        deleteType: deleteType
+      });
+    }), _ref5;
+  }, [linkCreated, linkUpdated, linkDeleted]);
+
+  /**
+   * Subscribe to link events
+   */
+  useEffect(function () {
+    var unsubscribe = cardPluginEvents.subscribe(function (_ref6) {
+      var event = _ref6.event,
+        subject = _ref6.subject,
+        data = _ref6.data;
+      if (subject === EVENT_SUBJECT.LINK) {
+        linkEvents[event](data);
+      }
+    });
+    return function () {
+      return unsubscribe();
+    };
+  }, [linkEvents, cardPluginEvents]);
+  return null;
+};

package/dist/esm/ui/EditorLinkingPlatformAnalytics/common.js

@@ -0,0 +1,55 @@
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { ACTION, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+/**
+ * If the metadata is for a history event,
+ * returns undo/redo instead of instead of what fn(metadata) would have otherwise
+ * returned
+ */
+var withHistoryMethod = function withHistoryMethod(fn) {
+  return function (metadata) {
+    var isUndo = metadata.isUndo,
+      isRedo = metadata.isRedo;
+    if (isUndo) {
+      return 'undo';
+    }
+    if (isRedo) {
+      return 'redo';
+    }
+    return fn(metadata);
+  };
+};
+export var getMethod = withHistoryMethod(function (_ref) {
+  var inputMethod = _ref.inputMethod;
+  switch (inputMethod) {
+    case INPUT_METHOD.CLIPBOARD:
+      return 'editor_paste';
+    case INPUT_METHOD.FLOATING_TB:
+      return 'editor_floatingToolbar';
+    case INPUT_METHOD.AUTO_DETECT:
+    case INPUT_METHOD.FORMATTING:
+      return 'editor_type';
+    default:
+      return 'unknown';
+  }
+});
+export var getUpdateType = withHistoryMethod(function (_ref2) {
+  var action = _ref2.action;
+  switch (action) {
+    case ACTION.CHANGED_TYPE:
+      return 'display_update';
+    case ACTION.UPDATED:
+      return 'link_update';
+    default:
+      return 'unknown';
+  }
+});
+export var getDeleteType = withHistoryMethod(function (_ref3) {
+  var action = _ref3.action;
+  if (action === ACTION.UNLINK) {
+    return 'unlink';
+  }
+  return 'delete';
+});
+export var getSourceEventFromMetadata = function getSourceEventFromMetadata(metadata) {
+  return metadata.sourceEvent instanceof UIAnalyticsEvent ? metadata.sourceEvent : null;
+};

package/dist/esm/ui/EditorLinkingPlatformAnalytics/index.js

@@ -0,0 +1,47 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import React from 'react';
+import PropTypes from 'prop-types';
+import { EditorAnalyticsContext } from '../EditorAnalyticsContext';
+import { DatasourceEventsBinding } from './DatasourceEvents';
+import { LinkEventsBinding } from './LinkEvents';
+
+// eslint-disable-next-line @repo/internal/react/no-class-components
+export var EditorLinkingPlatformAnalytics = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(EditorLinkingPlatformAnalytics, _React$PureComponent);
+  var _super = _createSuper(EditorLinkingPlatformAnalytics);
+  function EditorLinkingPlatformAnalytics() {
+    _classCallCheck(this, EditorLinkingPlatformAnalytics);
+    return _super.apply(this, arguments);
+  }
+  _createClass(EditorLinkingPlatformAnalytics, [{
+    key: "render",
+    value: function render() {
+      var cardContext = this.context.contextAdapter.card;
+
+      /**
+       * The analytics hook needs to be able to communicate with the card context
+       * If we can't access it, don't mount the event bindings
+       * This effectively entirely disables all tracking behaviour
+       */
+      if (!cardContext) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement(cardContext.Provider, {
+        value: cardContext.value
+      }, /*#__PURE__*/React.createElement(EditorAnalyticsContext, {
+        editorView: this.props.editorView
+      }, /*#__PURE__*/React.createElement(LinkEventsBinding, this.props), /*#__PURE__*/React.createElement(DatasourceEventsBinding, this.props)));
+    }
+  }]);
+  return EditorLinkingPlatformAnalytics;
+}(React.PureComponent);
+_defineProperty(EditorLinkingPlatformAnalytics, "contextTypes", {
+  contextAdapter: PropTypes.object
+});

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-plugin-card",
-	"version": "0.3.3",
+	"version": "0.3.5",
 	"sideEffects": false
 }

package/dist/types/analytics/create-events-queue.d.ts

@@ -0,0 +1,21 @@
+export type Subscriber<T> = (event: T) => void;
+export type EditorCardPluginEvents<T> = {
+    push: (...events: T[]) => void;
+    subscribe: (listener: Subscriber<T>) => () => void;
+    flush: () => void;
+    getSize: () => number;
+};
+/**
+ * Simple mechanism to defer event related callbacks
+ *
+ * Probably think twice whether your event should use this instead of
+ * editor's built-in `editor-plugin-analytics`
+ *
+ * Editor-Plugin-Analytics provides methods methods to dispatch events, and attach events into prosemiror transactions
+ * However we do not have access to the smart card context in prosemirror
+ *
+ * We are using this queue to relay events occurring in prosemirror (which does not have access to the react context)
+ * to be subscribed to elsewhere where the react context is available (contentComponent or otherwise) (smart card context)
+ * in order to be able to annotate events with additional attributes to events
+ */
+export declare const createEventsQueue: <T extends unknown>() => EditorCardPluginEvents<T>;

package/dist/types/analytics/events-from-tr.d.ts

@@ -0,0 +1,19 @@
+import { EditorState, ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { CardPluginEvent, Entity } from './types';
+/**
+ * Find the links, smartLinks, datasources that were changed in a transaction
+ */
+export declare const findChanged: (tr: Transaction | ReadonlyTransaction, state: EditorState) => {
+    removed: Entity[];
+    inserted: Entity[];
+    updated: ({
+        removed: Entity;
+        inserted: Entity;
+    } | {
+        inserted: Entity;
+        previous: {
+            display?: string;
+        };
+    })[];
+};
+export declare function eventsFromTransaction(tr: ReadonlyTransaction, state: EditorState): CardPluginEvent[];

package/dist/types/analytics/index.d.ts

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

package/dist/types/analytics/types.d.ts

@@ -0,0 +1,66 @@
+import { Node } from '@atlaskit/editor-prosemirror/model';
+export type Entity = {
+    pos: number;
+    node: Node;
+    nodeContext: string;
+};
+type Metadata<T = {}> = {
+    node: Node;
+    isUndo?: boolean;
+    isRedo?: boolean;
+    action?: string;
+    inputMethod?: string;
+    sourceEvent?: unknown;
+    nodeContext?: string;
+} & T;
+type UpdateMetadata = {
+    previousDisplay?: string;
+};
+export declare enum EVENT {
+    CREATED = "created",
+    UPDATED = "updated",
+    DELETED = "deleted"
+}
+export declare enum EVENT_SUBJECT {
+    LINK = "link",
+    DATASOURCE = "datasource"
+}
+/**
+ * These are not GASv3 events
+ * But they share a similar in shape so that GASv3
+ * events can be derived from them / think of them in the same way
+ */
+export type LinkCreatedEvent = {
+    event: EVENT.CREATED;
+    subject: EVENT_SUBJECT.LINK;
+    data: Metadata;
+};
+export type LinkUpdatedEvent = {
+    event: EVENT.UPDATED;
+    subject: EVENT_SUBJECT.LINK;
+    data: Metadata<UpdateMetadata>;
+};
+export type LinkDeletedEvent = {
+    event: EVENT.DELETED;
+    subject: EVENT_SUBJECT.LINK;
+    data: Metadata;
+};
+export type DatasourceCreatedEvent = {
+    event: EVENT.CREATED;
+    subject: EVENT_SUBJECT.DATASOURCE;
+    data: Metadata;
+};
+export type DatasourceUpdatedEvent = {
+    event: EVENT.UPDATED;
+    subject: EVENT_SUBJECT.DATASOURCE;
+    data: Metadata<UpdateMetadata>;
+};
+export type DatasourceDeletedEvent = {
+    event: EVENT.DELETED;
+    subject: EVENT_SUBJECT.DATASOURCE;
+    data: Metadata;
+};
+export type LinkEvent = LinkCreatedEvent | LinkUpdatedEvent | LinkDeletedEvent;
+export type DatasourceEvent = DatasourceCreatedEvent | DatasourceUpdatedEvent | DatasourceDeletedEvent;
+export type CardPluginEvent = LinkEvent | DatasourceEvent;
+export {};

package/dist/types/analytics/utils.d.ts

@@ -0,0 +1,22 @@
+import { Node } from '@atlaskit/editor-prosemirror/model';
+import { ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Entity, EVENT_SUBJECT } from './types';
+export declare function isDatasourceNode(node: Node): boolean;
+/**
+ * Determine if a node is considered to be a link
+ */
+export declare const isLinkNode: (node: Node) => boolean;
+export declare function getNodeSubject(node: Node): EVENT_SUBJECT | null;
+/**
+ * Analytics appearance for link object
+ */
+export declare function appearanceForLink(node: Node): "url" | import("@atlaskit/editor-common/provider-factory").CardAppearance;
+export declare function getUrl(node: Node): string | undefined;
+export declare const getNodeContext: (doc: Node, pos: number) => string;
+export declare const findAtPositions: (tr: Transaction | ReadonlyTransaction, positions: number[]) => Entity[];
+export declare const findInNodeRange: (doc: Node, from: number, to: number, predicate: (node: Node) => boolean) => Entity[];
+/**
+ * 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 declare const areSameNodes: (setA: Entity[], setB: Entity[]) => boolean;

package/dist/types/pm-plugins/actions.d.ts

@@ -2,14 +2,13 @@ import { CardProvider } from '@atlaskit/editor-common/provider-factory';
 import type { DatasourceModalType } from '@atlaskit/editor-common/types';
 import { Transaction } from '@atlaskit/editor-prosemirror/state';
 import { SmartLinkEvents } from '@atlaskit/smart-card';
-import { CardInfo, CardPluginAction, Request, SmartLinkEventsNext } from '../types';
+import { CardInfo, CardPluginAction, Request } from '../types';
 import { DatasourceTableLayout } from '../ui/LayoutButton/types';
 export declare const cardAction: (tr: Transaction, action: CardPluginAction) => Transaction;
 export declare const resolveCard: (url: string) => (tr: Transaction) => Transaction;
 export declare const queueCards: (requests: Request[]) => (tr: Transaction) => Transaction;
 export declare const registerCard: (info: CardInfo) => (tr: Transaction) => Transaction;
 export declare const registerSmartCardEvents: (smartLinkEvents: SmartLinkEvents) => (tr: Transaction) => Transaction;
-export declare const registerSmartCardEventsNext: (smartLinkEvents: SmartLinkEventsNext) => (tr: Transaction) => Transaction;
 export declare const setProvider: (cardProvider: CardProvider | null) => (tr: Transaction) => Transaction;
 export declare const setDatasourceTableRef: (datasourceTableRef?: HTMLElement) => (tr: Transaction) => Transaction;
 export declare const setCardLayout: (layout: DatasourceTableLayout) => (tr: Transaction) => Transaction;

package/dist/types/pm-plugins/util/state.d.ts

@@ -21,7 +21,6 @@ export declare const getPluginStateWithUpdatedPos: (pluginState: CardPluginState
     provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
     showLinkingToolbar: boolean;
     smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents | undefined;
-    smartLinkEventsNext?: import("../../types").SmartLinkEventsNext | undefined;
     editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance | undefined;
     showDatasourceModal: boolean;
     datasourceModalType?: import("@atlaskit/editor-common/types").DatasourceModalType | undefined;